d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Upgrade to regex from grep 2.4.2

Browse Source
This commit is contained in:
Andrey A. Chernov 2004-02-25 02:41:15 +00:00
parent f88175ccbf
commit a3625ac84d
41 changed files with 11 additions and 12865 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gnu/lib/libregex/AUTHORS
View File

@ -1,10 +0,0 @@
Richard Stallman -- original version and continuing revisions of
regex.c and regex.h, and original version of the documentation.
Karl Berry and Kathryn Hargreaves -- extensive modifications to above,
and all test files.
Jim Blandy -- original version of re_set_registers, revisions to regex.c.
Joe Arceneaux, David MacKenzie, Mike Haertel, Charles Hannum, and
probably others -- revisions to regex.c.

339
gnu/lib/libregex/COPYING
View File

@ -1,339 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

3030
gnu/lib/libregex/ChangeLog
View File

File diff suppressed because it is too large Load Diff

117
gnu/lib/libregex/INSTALL
View File

@ -1,117 +0,0 @@
This is a generic INSTALL file for utilities distributions.
If this package does not come with, e.g., installable documentation or
data files, please ignore the references to them below.
To compile this package:
1. Configure the package for your system. In the directory that this
file is in, type `./configure'. If you're using `csh' on an old
version of System V, you might need to type `sh configure' instead to
prevent `csh' from trying to execute `configure' itself.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation, and
creates the Makefile(s) (one in each subdirectory of the source
directory). In some packages it creates a C header file containing
system-dependent definitions. It also creates a file `config.status'
that you can run in the future to recreate the current configuration.
Running `configure' takes a minute or two. While it is running, it
prints some messages that tell what it is doing. If you don't want to
see the messages, run `configure' with its standard output redirected
to `/dev/null'; for example, `./configure >/dev/null'.
To compile the package in a different directory from the one
containing the source code, you must use a version of `make' that
supports the VPATH variable, such as GNU `make'. `cd' to the directory
where you want the object files and executables to go and run
`configure'. `configure' automatically checks for the source code in
the directory that `configure' is in and in `..'. If for some reason
`configure' is not in the source code directory that you are
configuring, then it will report that it can't find the source code.
In that case, run `configure' with the option `--srcdir=DIR', where
DIR is the directory that contains the source code.
By default, `make install' will install the package's files in
/usr/local/bin, /usr/local/lib, /usr/local/man, etc. You can specify
an installation prefix other than /usr/local by giving `configure' the
option `--prefix=PATH'. Alternately, you can do so by giving a value
for the `prefix' variable when you run `make', e.g.,
make prefix=/usr/gnu
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If
you give `configure' the option `--exec-prefix=PATH' or set the
`make' variable `exec_prefix' to PATH, the package will use PATH as
the prefix for installing programs and libraries. Data files and
documentation will still use the regular prefix. Normally, all files
are installed using the regular prefix.
Another `configure' option is useful mainly in `Makefile' rules for
updating `config.status' and `Makefile'. The `--no-create' option
figures out the configuration for your system and records it in
`config.status', without actually configuring the package (creating
`Makefile's and perhaps a configuration header file). Later, you can
run `./config.status' to actually configure the package. You can also
give `config.status' the `--recheck' option, which makes it re-run
`configure' with the same arguments you used before. This option is
useful if you change `configure'.
Some packages pay attention to `--with-PACKAGE' options to `configure',
where PACKAGE is something like `gnu-libc' or `x' (for the X Window System).
The README should mention any --with- options that the package recognizes.
`configure' ignores any other arguments that you give it.
If your system requires unusual options for compilation or linking
that `configure' doesn't know about, you can give `configure' initial
values for some variables by setting them in the environment. In
Bourne-compatible shells, you can do that on the command line like
this:
CC='gcc -traditional' DEFS=-D_POSIX_SOURCE ./configure
The `make' variables that you might want to override with environment
variables when running `configure' are:
(For these variables, any value given in the environment overrides the
value that `configure' would choose:)
CC C compiler program.
Default is `cc', or `gcc' if `gcc' is in your PATH.
INSTALL Program to use to install files.
Default is `install' if you have it, `cp' otherwise.
(For these variables, any value given in the environment is added to
the value that `configure' chooses:)
DEFS Configuration options, in the form `-Dfoo -Dbar ...'
Do not use this variable in packages that create a
configuration header file.
LIBS Libraries to link with, in the form `-lfoo -lbar ...'
If you need to do unusual things to compile the package, we encourage
you to figure out how `configure' could check whether to do them, and
mail diffs or instructions to the address given in the README so we
can include them in the next release.
2. Type `make' to compile the package. If you want, you can override
the `make' variables CFLAGS and LDFLAGS like this:
make CFLAGS=-O2 LDFLAGS=-s
3. If the package comes with self-tests and you want to run them,
type `make check'. If you're not sure whether there are any, try it;
if `make' responds with something like
make: *** No way to make target `check'. Stop.
then the package does not come with self-tests.
4. Type `make install' to install programs, data files, and
documentation.
5. You can remove the program binaries and object files from the
source directory by typing `make clean'. To also remove the
Makefile(s), the header file containing system-dependent definitions
(if the package uses one), and `config.status' (all the files that
`configure' created), type `make distclean'.
The file `configure.in' is used as a template to create `configure' by
a program called `autoconf'. You will only need it if you want to
regenerate `configure' using a newer version of `autoconf'.

14
gnu/lib/libregex/Makefile
View File

@ -6,12 +6,20 @@ LIB= gnuregex
SHLIB_MAJOR= 2
SRCS= regex.c
INCSGROUPS= INCS WRINCS
INCS= regex.h
INCSGROUPS= INCS WRINCS PXINCS
INCS= regex.h.patched
CLEANFILES+= regex.h.patched
INCSNAME= regex.h
INCSDIR= ${INCLUDEDIR}/gnu
WRINCS= gnuregex.h
PXINCS= posix/regex.h
PXINCSDIR= ${INCLUDEDIR}/gnu/posix
NOMAN= noman
CFLAGS+=-I${.CURDIR} -DHAVE_STRING_H=1 -DSTDC_HEADERS=1 -DNO_POSIX_COMPAT=1
CFLAGS+=-D_REGEX_RE_COMP -DSTDC_HEADERS -I${DESTDIR}/usr/include/gnu
regex.h.patched: regex.h
sed 's=<posix/regex\.h>=<gnu/posix/regex.h>=g' \
< ${.ALLSRC} > ${.TARGET}
.include <bsd.lib.mk>

99
gnu/lib/libregex/Makefile.gnu
View File

@ -1,99 +0,0 @@
# Generated automatically from Makefile.in by configure.
# Makefile for regex.
#
# Copyright (C) 1992, 1993 Free Software Foundation, Inc.
#
# This program 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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
version = 0.12
# You can define CPPFLAGS on the command line. Aside from system-specific
# flags, you can define:
# -DREGEX_MALLOC to use malloc/realloc/free instead of alloca.
# -DDEBUG to enable the compiled pattern disassembler and execution
# tracing; code runs substantially slower.
# -DEXTRACT_MACROS to use the macros EXTRACT_* (as opposed to
# the corresponding C procedures). If not -DDEBUG, the macros
# are used.
CPPFLAGS =
# Likewise, you can override CFLAGS to optimize, use -Wall, etc.
CFLAGS = -g
# Ditto for LDFLAGS and LOADLIBES.
LDFLAGS =
LOADLIBES =
srcdir = .
VPATH = .
CC = gcc
DEFS = -DHAVE_STRING_H=1
SHELL = /bin/sh
subdirs = doc test
default all:: regex.o
.PHONY: default all
regex.o: regex.c regex.h
$(CC) $(CFLAGS) $(CPPFLAGS) $(DEFS) -I. -I$(srcdir) -c $<
clean mostlyclean::
rm -f *.o
distclean:: clean
rm -f Makefile config.status
extraclean:: distclean
rm -f patch* *~* *\#* *.orig *.rej *.bak core a.out
configure: configure.in
autoconf
config.status: configure
sh configure --no-create
Makefile: Makefile.in config.status
sh config.status
makeargs = $(MFLAGS) CPPFLAGS='$(CPPFLAGS)' CFLAGS='$(CFLAGS)' CC='$(CC)' \
DEFS='$(DEFS)' LDFLAGS='$(LDFLAGS)' LOADLIBES='$(LOADLIBES)'
default all install \
mostlyclean clean distclean extraclean realclean \
TAGS check::
for d in $(subdirs); do (cd $$d; $(MAKE) $(makeargs) $@); done
.PHONY: install mostlyclean clean distclean extraclean realclean TAGS check
# Prevent GNU make 3 from overflowing arg limit on system V.
.NOEXPORT:
distfiles = AUTHORS ChangeLog COPYING INSTALL NEWS README \
*.in configure regex.c regex.h
distdir = regex-$(version)
distargs = version=$(version) distdir=../$(distdir)/$$d
dist: TAGS configure
@echo "Version numbers in: Makefile.in, ChangeLog, NEWS,"
@echo " regex.c, regex.h,"
@echo " and doc/xregex.texi (if modified)."
rm -rf $(distdir)
mkdir $(distdir)
ln $(distfiles) $(distdir)
for d in $(subdirs); do (cd $$d; $(MAKE) $(distargs) dist); done
tar czhf $(distdir).tar.Z $(distdir)
rm -rf $(distdir)
.PHONY: dist

98
gnu/lib/libregex/Makefile.in
View File

@ -1,98 +0,0 @@
# Makefile for regex.
#
# Copyright (C) 1992, 1993 Free Software Foundation, Inc.
#
# This program 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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
version = 0.12
# You can define CPPFLAGS on the command line. Aside from system-specific
# flags, you can define:
# -DREGEX_MALLOC to use malloc/realloc/free instead of alloca.
# -DDEBUG to enable the compiled pattern disassembler and execution
# tracing; code runs substantially slower.
# -DEXTRACT_MACROS to use the macros EXTRACT_* (as opposed to
# the corresponding C procedures). If not -DDEBUG, the macros
# are used.
CPPFLAGS =
# Likewise, you can override CFLAGS to optimize, use -Wall, etc.
CFLAGS = -g
# Ditto for LDFLAGS and LOADLIBES.
LDFLAGS =
LOADLIBES =
srcdir = @srcdir@
VPATH = @srcdir@
CC = @CC@
DEFS = @DEFS@
SHELL = /bin/sh
subdirs = doc test
default all:: regex.o
.PHONY: default all
regex.o: regex.c regex.h
$(CC) $(CFLAGS) $(CPPFLAGS) $(DEFS) -I. -I$(srcdir) -c $<
clean mostlyclean::
rm -f *.o
distclean:: clean
rm -f Makefile config.status
extraclean:: distclean
rm -f patch* *~* *\#* *.orig *.rej *.bak core a.out
configure: configure.in
autoconf
config.status: configure
sh configure --no-create
Makefile: Makefile.in config.status
sh config.status
makeargs = $(MFLAGS) CPPFLAGS='$(CPPFLAGS)' CFLAGS='$(CFLAGS)' CC='$(CC)' \
DEFS='$(DEFS)' LDFLAGS='$(LDFLAGS)' LOADLIBES='$(LOADLIBES)'
default all install \
mostlyclean clean distclean extraclean realclean \
TAGS check::
for d in $(subdirs); do (cd $$d; $(MAKE) $(makeargs) $@); done
.PHONY: install mostlyclean clean distclean extraclean realclean TAGS check
# Prevent GNU make 3 from overflowing arg limit on system V.
.NOEXPORT:
distfiles = AUTHORS ChangeLog COPYING INSTALL NEWS README \
*.in configure regex.c regex.h
distdir = regex-$(version)
distargs = version=$(version) distdir=../$(distdir)/$$d
dist: TAGS configure
@echo "Version numbers in: Makefile.in, ChangeLog, NEWS,"
@echo " regex.c, regex.h,"
@echo " and doc/xregex.texi (if modified)."
rm -rf $(distdir)
mkdir $(distdir)
ln $(distfiles) $(distdir)
for d in $(subdirs); do (cd $$d; $(MAKE) $(distargs) dist); done
tar czhf $(distdir).tar.Z $(distdir)
rm -rf $(distdir)
.PHONY: dist

62
gnu/lib/libregex/NEWS
View File

@ -1,62 +0,0 @@
Version 0.12
* regex.c does not #define bcmp/bcopy/bzero if they already are.
* regex.h does not redefine `const' if it is already defined, even if
__STDC__ is not defined.
* RE_SYNTAX_ED added (same as POSIX BRE's).
* The following bugs have been fixed, among others:
* The pattern \w+ doesn't infinite loop.
* The pattern ".+\n" is compiled correctly.
* Expressions with more than MAX_REGNUM groups are compiled correctly.
* Patterns that end in a repetition operator (e.g., `*') match
slightly faster if no looping is actually necessary.
Version 0.11 (17 Sep 92)
* Back-references to nonexistent subexpressions, as in the r.e. `abc\1',
are always invalid. Previously, they could match the literal digit,
e.g., the stated r.e. might have matched `abc1'.
* Empty subexpressions are always valid (POSIX leaves this undefined).
* Simplified rules for ^ and $ being anchors.
* One minor speedup (rewriting the C procedure `pop_failure_point' as a
macro again).
* Bug fixes involving:
- Declarations in regex.h and non-ANSI compilers.
- Bracket expressions with characters between 0x80-0xff.
- Memory leak in re_match_2 on systems requiring `alloca (0)' to
free alloca'd storage.
* Test and documentation files moved into subdirectories.
Version 0.10 (9 Sep 92)
* `obscure_syntax' is now called `re_default_syntax'.
* `re_comp's return type is no longer `const', for compatibility with BSD.
* POSIX syntaxes now include as much functionality as possible
(consistent with the standard).
* Compilation conditionals normalized to what the rest of GNU is
migrating towards these days.
* Bug fixes involving:
- Ranges with characters between 0x80 and 0xff, e.g., [\001-\377].
- `re_compile_fastmap' and the sequence `.*\n'.
- Intervals with exact counts, e.g., a{5}.
* Changed distribution to use a standard Makefile, install the info
files, use a configure script, etc.
Version 0.9
* The longest match was not always chosen: `a*|ab' didn't match `aab'.

60
gnu/lib/libregex/README
View File

@ -1,60 +0,0 @@
This directory contains the GNU regex library. It is compliant with
POSIX.2, except for internationalization features.
See the file NEWS for a list of major changes in the current release.
See the file INSTALL for compilation instructions. (The only thing
installed is the documentation; regex.c is compiled into regex.o, but
not installed anywhere.)
The subdirectory `doc' contains a (programmers') manual for the library.
It's probably out-of-date. Improvements are welcome.
The subdirectory `test' contains the various tests we've written.
We know this code is not as fast as it might be. If you have specific
suggestions, profiling results, or other such useful information to
report, please do.
Emacs 18 is not going use this revised regex (but Emacs 19 will). If
you want to try it with Emacs 18, apply the patch at the end of this
file first.
Mail bug reports to bug-gnu-utils@prep.ai.mit.edu.
Please include an actual regular expression that fails (and the syntax
used to compile it); without that, there's no way to reproduce the bug,
so there's no way we can fix it. Even if you include a patch, also
include the regular expression in error; otherwise, we can't know for
sure what you're trying to fix.
Here is the patch to make this version of regex work with Emacs 18.
*** ORIG/search.c Tue Jan 8 13:04:55 1991
--- search.c Sun Jan 5 10:57:00 1992
***************
*** 25,26 ****
--- 25,28 ----
#include "commands.h"
+
+ #include <sys/types.h>
#include "regex.h"
***************
*** 477,479 ****
/* really needed. */
! && *(searchbuf.buffer) == (char) exactn /* first item is "exact match" */
&& searchbuf.buffer[1] + 2 == searchbuf.used) /*first is ONLY item */
--- 479,482 ----
/* really needed. */
! /* first item is "exact match" */
! && *(searchbuf.buffer) == (char) RE_EXACTN_VALUE
&& searchbuf.buffer[1] + 2 == searchbuf.used) /*first is ONLY item */
***************
*** 1273,1275 ****
searchbuf.allocated = 100;
! searchbuf.buffer = (char *) malloc (searchbuf.allocated);
searchbuf.fastmap = search_fastmap;
--- 1276,1278 ----
searchbuf.allocated = 100;
! searchbuf.buffer = (unsigned char *) malloc (searchbuf.allocated);
searchbuf.fastmap = search_fastmap;

3
gnu/lib/libregex/VERSION
View File

@ -1,3 +0,0 @@
GNU regex version 0.12
complete, unmodified regex sources are available from prep.ai.mit.edu.

59
gnu/lib/libregex/config.status
View File

@ -1,59 +0,0 @@
#!/bin/sh
# Generated automatically by configure.
# Run this file to recreate the current configuration.
# This directory was configured as follows,
# on host sun-lamp.cs.berkeley.edu:
#
# configure
for arg
do
case "$arg" in
-recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
exec /bin/sh configure ;;
*) echo "Usage: config.status --recheck" 2>&1; exit 1 ;;
esac
done
trap 'rm -f Makefile doc/Makefile test/Makefile; exit 1' 1 3 15
CC='gcc'
INSTALL='/usr/bin/install -c'
INSTALL_PROGRAM='$(INSTALL)'
INSTALL_DATA='$(INSTALL) -m 644'
CPP='${CC-cc} -E'
ALLOCA=''
LIBS=''
srcdir='.'
DEFS=' -DHAVE_STRING_H=1'
prefix='/usr'
exec_prefix='${prefix}'
prsub='s%^prefix\([ ]*\)=\([ ]*\).*$%prefix\1=\2/usr%
s%^exec_prefix\([ ]*\)=\([ ]*\).*$%exec_prefix\1=\2${prefix}%'
top_srcdir=$srcdir
for file in .. Makefile doc/Makefile test/Makefile; do if [ "x$file" != "x.." ]; then
srcdir=$top_srcdir
# Remove last slash and all that follows it. Not all systems have dirname.
dir=`echo $file|sed 's%/[^/][^/]*$%%'`
if test "$dir" != "$file"; then
test "$top_srcdir" != . && srcdir=$top_srcdir/$dir
test ! -d $dir && mkdir $dir
fi
echo creating $file
rm -f $file
echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file
sed -e "
$prsub
s%@CC@%$CC%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@CPP@%$CPP%g
s%@ALLOCA@%$ALLOCA%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%$DEFS%
" $top_srcdir/${file}.in >> $file
fi; done
exit 0

462
gnu/lib/libregex/configure vendored
View File

@ -1,462 +0,0 @@
#!/bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf.
# Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
# This program 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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
# Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp] [--no-create]
# [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE] [TARGET]
# Ignores all args except --srcdir, --prefix, --exec-prefix, --no-create, and
# --with-PACKAGE unless this script has special code to handle it.
for arg
do
# Handle --exec-prefix with a space before the argument.
if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix=
# Handle --host with a space before the argument.
elif test x$next_host = xyes; then next_host=
# Handle --prefix with a space before the argument.
elif test x$next_prefix = xyes; then prefix=$arg; next_prefix=
# Handle --srcdir with a space before the argument.
elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir=
else
case $arg in
# For backward compatibility, also recognize exact --exec_prefix.
-exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*)
exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
-exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e)
next_exec_prefix=yes ;;
-gas | --gas | --ga | --g) ;;
-host=* | --host=* | --hos=* | --ho=* | --h=*) ;;
-host | --host | --hos | --ho | --h)
next_host=yes ;;
-nfp | --nfp | --nf) ;;
-no-create | --no-create | --no-creat | --no-crea | --no-cre | --no-cr | --no-c | --no- | --no)
no_create=1 ;;
-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
next_prefix=yes ;;
-srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*)
srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;;
-srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s)
next_srcdir=yes ;;
-with-* | --with-*)
package=`echo $arg|sed 's/-*with-//'`
# Delete all the valid chars; see if any are left.
if test -n "`echo $package|sed 's/[-a-zA-Z0-9_]*//g'`"; then
echo "configure: $package: invalid package name" >&2; exit 1
fi
eval "with_`echo $package|sed s/-/_/g`=1" ;;
*) ;;
esac
fi
done
trap 'rm -f conftest* core; exit 1' 1 3 15
rm -f conftest*
compile='${CC-cc} $CFLAGS $DEFS conftest.c -o conftest $LIBS >/dev/null 2>&1'
# 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.
unique_file=regex.c
# Find the source files, if location was not specified.
if test -z "$srcdir"; then
srcdirdefaulted=yes
# Try the directory containing this script, then `..'.
prog=$0
confdir=`echo $prog|sed 's%/[^/][^/]*$%%'`
test "X$confdir" = "X$prog" && confdir=.
srcdir=$confdir
if test ! -r $srcdir/$unique_file; then
srcdir=..
fi
fi
if test ! -r $srcdir/$unique_file; then
if test x$srcdirdefaulted = xyes; then
echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2
else
echo "configure: Can not find sources in \`${srcdir}'." 1>&2
fi
exit 1
fi
# Preserve a srcdir of `.' to avoid automounter screwups with pwd.
# But we can't avoid them for `..', to make subdirectories work.
case $srcdir in
.|/*|~*) ;;
*) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute.
esac
if test -z "$CC"; then
echo checking for gcc
saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/gcc; then
CC="gcc"
break
fi
done
IFS="$saveifs"
fi
test -z "$CC" && CC="cc"
# Find out if we are using GNU C, under whatever name.
cat > conftest.c <<EOF
#ifdef __GNUC__
yes
#endif
EOF
${CC-cc} -E conftest.c > conftest.out 2>&1
if egrep yes conftest.out >/dev/null 2>&1; then
GCC=1 # For later tests.
fi
rm -f conftest*
# Make sure to not get the incompatible SysV /etc/install and
# /usr/sbin/install, which might be in PATH before a BSD-like install,
# or the SunOS /usr/etc/install directory, or the AIX /bin/install,
# or the AFS install, which mishandles nonexistent args. (Sigh.)
if test -z "$INSTALL"; then
echo checking for install
saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
case $dir in
/etc|/usr/sbin|/usr/etc|/usr/afsws/bin) ;;
*)
if test -f $dir/install; then
if grep dspmsg $dir/install >/dev/null 2>&1; then
: # AIX
else
INSTALL="$dir/install -c"
INSTALL_PROGRAM='$(INSTALL)'
INSTALL_DATA='$(INSTALL) -m 644'
break
fi
fi
;;
esac
done
IFS="$saveifs"
fi
INSTALL=${INSTALL-cp}
INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'}
INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'}
echo checking for AIX
echo checking how to run the C preprocessor
if test -z "$CPP"; then
CPP='${CC-cc} -E'
cat > conftest.c <<EOF
#include <stdio.h>
EOF
err=`eval "$CPP $DEFS conftest.c 2>&1 >/dev/null"`
if test -z "$err"; then
:
else
CPP=/lib/cpp
fi
rm -f conftest*
fi
cat > conftest.c <<EOF
#ifdef _AIX
yes
#endif
EOF
eval "$CPP $DEFS conftest.c > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
DEFS="$DEFS -D_ALL_SOURCE=1"
fi
rm -f conftest*
echo checking for DYNIX/ptx libseq
cat > conftest.c <<EOF
#if defined(_SEQUENT_)
yes
#endif
EOF
eval "$CPP $DEFS conftest.c > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
SEQUENT=1
fi
rm -f conftest*
test -n "$SEQUENT" && test -f /usr/lib/libseq.a &&
LIBS="$LIBS -lseq"
echo checking for POSIXized ISC
if test -d /etc/conf/kconfig.d &&
grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1
then
ISC=1 # If later tests want to check for ISC.
DEFS="$DEFS -D_POSIX_SOURCE=1"
if test -n "$GCC"; then
CC="$CC -posix"
else
CC="$CC -Xp"
fi
fi
echo checking for minix/config.h
cat > conftest.c <<EOF
#include <minix/config.h>
EOF
err=`eval "$CPP $DEFS conftest.c 2>&1 >/dev/null"`
if test -z "$err"; then
MINIX=1
fi
rm -f conftest*
# The Minix shell can't assign to the same variable on the same line!
if test -n "$MINIX"; then
DEFS="$DEFS -D_POSIX_SOURCE=1"
DEFS="$DEFS -D_POSIX_1_SOURCE=2"
DEFS="$DEFS -D_MINIX=1"
fi
echo checking for ANSI C header files
cat > conftest.c <<EOF
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <float.h>
EOF
err=`eval "$CPP $DEFS conftest.c 2>&1 >/dev/null"`
if test -z "$err"; then
# SunOS string.h does not declare mem*, contrary to ANSI.
echo '#include <string.h>' > conftest.c
eval "$CPP $DEFS conftest.c > conftest.out 2>&1"
if egrep "memchr" conftest.out >/dev/null 2>&1; then
# SGI's /bin/cc from Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
cat > conftest.c <<EOF
#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
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
DEFS="$DEFS -DSTDC_HEADERS=1"
fi
rm -f conftest*
fi
rm -f conftest*
fi
rm -f conftest*
for hdr in string.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include <${hdr}>
EOF
err=`eval "$CPP $DEFS conftest.c 2>&1 >/dev/null"`
if test -z "$err"; then
DEFS="$DEFS -D${trhdr}=1"
fi
rm -f conftest*
done
# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
# for constant arguments. Useless!
echo checking for working alloca.h
cat > conftest.c <<EOF
#include <alloca.h>
main() { exit(0); }
t() { char *p = alloca(2 * sizeof(int)); }
EOF
if eval $compile; then
DEFS="$DEFS -DHAVE_ALLOCA_H=1"
fi
rm -f conftest*
decl="#ifdef __GNUC__
#define alloca __builtin_alloca
#else
#if HAVE_ALLOCA_H
#include <alloca.h>
#else
#ifdef _AIX
#pragma alloca
#else
char *alloca ();
#endif
#endif
#endif
"
echo checking for alloca
cat > conftest.c <<EOF
$decl
main() { exit(0); }
t() { char *p = (char *) alloca(1); }
EOF
if eval $compile; then
:
else
alloca_missing=1
fi
rm -f conftest*
if test -n "$alloca_missing"; then
# The SVR3 libPW and SVR4 libucb both contain incompatible functions
# that cause trouble. Some versions do not even contain alloca or
# contain a buggy version. If you still want to use their alloca,
# use ar to extract alloca.o from them instead of compiling alloca.c.
ALLOCA=alloca.o
fi
prog='/* Ultrix mips cc rejects this. */
typedef int charset[2]; const charset x;
/* SunOS 4.1.1 cc rejects this. */
char const *const *p;
char **p2;
/* HPUX 7.0 cc rejects these. */
++p;
p2 = (char const* const*) p;'
echo checking for working const
cat > conftest.c <<EOF
main() { exit(0); }
t() { $prog }
EOF
if eval $compile; then
:
else
DEFS="$DEFS -Dconst="
fi
rm -f conftest*
if test -z "$prefix"
then
echo checking for gcc to derive installation directory prefix
saveifs="$IFS"; IFS="$IFS:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test $dir != . && test -f $dir/gcc; then
# Not all systems have dirname.
prefix=`echo $dir|sed 's%/[^/][^/]*$%%'`
break
fi
done
IFS="$saveifs"
fi
if test -n "$prefix"; then
test -z "$exec_prefix" && exec_prefix='${prefix}'
prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%"
fi
if test -n "$exec_prefix"; then
prsub="$prsub
s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%\
exec_prefix\\1=\\2$exec_prefix%"
fi
trap 'rm -f config.status; exit 1' 1 3 15
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`:
#
# $0 $*
for arg
do
case "\$arg" in
-recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
exec /bin/sh $0 $* ;;
*) echo "Usage: config.status --recheck" 2>&1; exit 1 ;;
esac
done
trap 'rm -f Makefile doc/Makefile test/Makefile; exit 1' 1 3 15
CC='$CC'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
CPP='$CPP'
ALLOCA='$ALLOCA'
LIBS='$LIBS'
srcdir='$srcdir'
DEFS='$DEFS'
prefix='$prefix'
exec_prefix='$exec_prefix'
prsub='$prsub'
EOF
cat >> config.status <<\EOF
top_srcdir=$srcdir
for file in .. Makefile doc/Makefile test/Makefile; do if [ "x$file" != "x.." ]; then
srcdir=$top_srcdir
# Remove last slash and all that follows it. Not all systems have dirname.
dir=`echo $file|sed 's%/[^/][^/]*$%%'`
if test "$dir" != "$file"; then
test "$top_srcdir" != . && srcdir=$top_srcdir/$dir
test ! -d $dir && mkdir $dir
fi
echo creating $file
rm -f $file
echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file
sed -e "
$prsub
s%@CC@%$CC%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@CPP@%$CPP%g
s%@ALLOCA@%$ALLOCA%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%$DEFS%
" $top_srcdir/${file}.in >> $file
fi; done
exit 0
EOF
chmod +x config.status
test -n "$no_create" || ./config.status

23
gnu/lib/libregex/configure.in
View File

@ -1,23 +0,0 @@
dnl Process this file with autoconf to produce a configure script.
AC_INIT(regex.c)
AC_PROG_CC
AC_PROG_INSTALL
dnl I'm not sure if AC_AIX and AC_DYNIX_SEQ are really necessary. The
dnl Autoconf documentation isn't specific about which BSD functions they
dnl provide.
AC_AIX
AC_DYNIX_SEQ
AC_ISC_POSIX
AC_MINIX
AC_STDC_HEADERS
AC_HAVE_HEADERS(string.h)
AC_ALLOCA
AC_CONST
AC_PREFIX(gcc)
AC_OUTPUT(Makefile doc/Makefile test/Makefile)

77
gnu/lib/libregex/test/ChangeLog
View File

@ -1,77 +0,0 @@
Thu Mar 25 21:23:43 1993 Jim Blandy (jimb@totoro.cs.oberlin.edu)
* debugmalloc.c: #include <string.h>, and remove declaration of
memcpy.
Sun Dec 13 20:59:32 1992 Jim Blandy (jimb@totoro.cs.oberlin.edu)
* tregress.c (test_regress): Add regression test for matching
"[a-a]" against "a" with the upcase translation map.
* iregex.c (print_regs): Don't print a newline after the register
contents.
(main): Instead, write out newlines here after printing match and
search results; this way, we get a newline whether or not the
pattern matched.
Fri Dec 11 03:30:50 1992 Jim Blandy (jimb@totoro.cs.oberlin.edu)
* tregress.c (test_regress): Add new test to catch bug fixed by
change to regex.c today.
* Makefile.in (dregex.o): Depend on `../regex.[ch]', not `regex.[ch]'.
Sun Nov 15 07:51:40 1992 Karl Berry (karl@cs.umb.edu)
* debugmalloc.c (memcpy): Declare; also, include <assert.h>.
* psx-interf.c (fill_pmatch): Declare offsets as `regoff_t'
instead of `off_t'.
Thu Nov 12 11:29:58 1992 Karl Berry (karl@cs.umb.edu)
* iregex.c (main): Remove unused variable `c'; initialize
the char array in C code; only call print_regs if the match and
search succeeded.
(strlen): Declare.
* tregress.c (test_regress): Bug from enami.
Tue Nov 10 10:36:53 1992 Karl Berry (karl@cs.umb.edu)
* tregress.c (test_regress): Remove Emacs 19 diff bug from rms, as
it was never the right thing to test anyway, and the test itself
had bugs in it.
Mon Nov 9 10:09:40 1992 Karl Berry (karl@cs.umb.edu)
* tregress.c (test_regress): Bug from meyering.
Thu Sep 24 10:48:34 1992 Karl Berry (karl@cs.umb.edu)
* Makefile.in: avoid $< (except in implicit rule).
Sat Sep 19 15:38:29 1992 Karl Berry (karl@hayley)
* Makefile.in (TAGS): include regex.c and regex.h.
Wed Sep 16 09:29:27 1992 Karl Berry (karl@hayley)
* xmalloc.c (xmalloc): use char *, not void *, as some compilers
bomb out on the latter.
* Makefile.in (LOADLIBES): use LIBS instead, as that what's
Autoconf wants to define.
* other.c: remove tests for ^/$ around newlines.
Tue Sep 15 11:01:15 1992 Karl Berry (karl@hayley)
* fileregex.c (main): call re_search_2 instead of re_search.
* Makefile.in (regex.o): make target dregex.o, so VPATH doesn't
find ../regex.o.
Sun Sep 13 06:50:03 1992 Karl Berry (karl@hayley)
* Created.

171
gnu/lib/libregex/test/Makefile
View File

@ -1,171 +0,0 @@
# $FreeBSD$
# Generated automatically from Makefile.in by configure.
# Makefile for regex testing.
#
# Copyright (C) 1992 Free Software Foundation, Inc.
#
# This program 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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
CPPFLAGS =
CFLAGS = -g
LDFLAGS =
srcdir = .
VPATH = .:../.
CC = gcc
DEFS = -DHAVE_STRING_H=1
LIBS = $(LOADLIBES)
ETAGS = etags
SHELL = /bin/sh
debug = -DDEBUG
ALL_CPPFLAGS = -I. -I$(srcdir) -I../$(srcdir) $(DEFS) $(CPPFLAGS) $(debug)
.c.o:
$(CC) $(ALL_CPPFLAGS) $(CFLAGS) -c $<
# Define this as `../regex.o' to get the optimized version.
regex_o = dregex.o
test_h = test.h
test_o = test.o bsd-interf.o other.o tregress.o psx-basic.o psx-extend.o \
psx-generic.o psx-group.o psx-interf.o psx-interv.o
common_o = printchar.o upcase.o xmalloc.o $(malloc)
# We have a lot of mallocs we can try when we run afoul of strange bugs.
malloc =
#malloc = # the libc malloc
#malloc = g++malloc.o
#malloc = debugmalloc.o
#malloc = emacsmalloc.o
emacsmallocflags = -Drcheck -Dbotch=abort -DUSG
# default is to do nothing.
default:
all: regex syntax
regex: $(regex_o) $(common_o) $(test_o) main.o
$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
# As long as we're doing tests, we enable debugging.
dregex.o: ../regex.c ../regex.h
rm -f $@
$(CC) $(ALL_CPPFLAGS) $(CFLAGS) -c ../$(srcdir)/regex.c
mv -f regex.o $@
# iregex is the interactive regex.
iregex: $(common_o) $(regex_o) iregex.o
$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
# fileregex searches for an r.e. in every line of a given file.
fileregex_o = fileregex.o printchar.o $(regex_o)
fileregex: $(fileregex_o)
$(CC) -o $@ $(LDFLAGS) $(fileregex_o) $(LIBS)
# cppregex is regex with a preprocessed regex.c. Useful when the
# problem is inside some macro.
cppregex: regexcpp.o $(common_o) $(test_o) main.o
$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
regexcpp.o: regexcpp.c
regexcpp.c: regex.c regexcpp.sed
rm -f regexcpp.c
$(CC) -E $(ALL_CPPFLAGS) ../$(srcdir)/regex.c \
| egrep -v '^#|^ *$$' \
| sed -f regexcpp.sed \
> regexcpp.c
chmod a-w regexcpp.c
# Have to give this malloc special flags.
emacsmalloc.o: emacsmalloc.c
$(CC) -c $(CFLAGS) $(ALL_CPPFLAGS) $(emacsmallocflags) \
../$(srcdir)/test/emacsmalloc.c
syntax: syntax.o
$(CC) $(CFLAGS) -o $@ syntax.o
syntax.c: syntax.skel bits
sed '/\[\[\[replace.*\]\]\]/r bits' syntax.skel > $@
bits: regex.h
sed -n 1,/RE_SYNTAX_EMACS/p ../$(srcdir)/regex.h \
| grep "#define RE_.*1" \
| sed 's/^#define \(RE_[A-Z_]*\) .*/ TEST_BIT (\1);/' > $@
check: regex
./regex
TAGS: regex.c regex.h *.h *.c
$(ETAGS) -t $^
depend:
gcc -MM $(ALL_CPPFLAGS) *.c > /tmp/depend
.PHONY: depend
install:
.PHONY: install
clean mostlyclean:
rm -f *.o regex cppregex iregex fileregex regexcpp.c syntax
distclean: clean
rm -f bits syntax.c Makefile
extraclean: distclean
rm -f *~* *\#* patch* *.orig *.rej *.bak core a.out
realclean: distclean
rm -f TAGS
Makefile: Makefile.in ../config.status
(cd ..; sh config.status)
# Prevent GNU make 3 from overflowing arg limit on system V.
.NOEXPORT:
# Assumes $(distdir) is the place to put our files.
distfiles = ChangeLog TAGS *.in *.c *.h regexcpp.sed syntax.skel
dist: Makefile TAGS
mkdir $(distdir)
ln $(distfiles) $(distdir)
# Automatically-generated dependencies below here.
alloca.o : alloca.c
bsd-interf.o : bsd-interf.c
debugmalloc.o : debugmalloc.c
emacsmalloc.o : emacsmalloc.c getpagesize.h
fileregex.o : fileregex.c .././regex.h
g++malloc.o : g++malloc.c //usr/include/stdio.h getpagesize.h
iregex.o : iregex.c .././regex.h
main.o : main.c test.h .././regex.h
malloc-test.o : malloc-test.c
other.o : other.c test.h .././regex.h
printchar.o : printchar.c
psx-basic.o : psx-basic.c test.h .././regex.h
psx-extend.o : psx-extend.c test.h .././regex.h
psx-generic.o : psx-generic.c test.h .././regex.h
psx-group.o : psx-group.c test.h .././regex.h
psx-interf.o : psx-interf.c test.h .././regex.h
psx-interv.o : psx-interv.c test.h .././regex.h
syntax.o : syntax.c .././regex.h
test.o : test.c test.h .././regex.h
tregress.o : tregress.c test.h .././regex.h
upcase.o : upcase.c
xmalloc.o : xmalloc.c

170
gnu/lib/libregex/test/Makefile.in
View File

@ -1,170 +0,0 @@
# $FreeBSD$
# Makefile for regex testing.
#
# Copyright (C) 1992 Free Software Foundation, Inc.
#
# This program 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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
CPPFLAGS =
CFLAGS = -g
LDFLAGS =
srcdir = @srcdir@
VPATH = @srcdir@:../@srcdir@
CC = @CC@
DEFS = @DEFS@
LIBS = @LIBS@ $(LOADLIBES)
ETAGS = etags
SHELL = /bin/sh
debug = -DDEBUG
ALL_CPPFLAGS = -I. -I$(srcdir) -I../$(srcdir) $(DEFS) $(CPPFLAGS) $(debug)
.c.o:
$(CC) $(ALL_CPPFLAGS) $(CFLAGS) -c $<
# Define this as `../regex.o' to get the optimized version.
regex_o = dregex.o
test_h = test.h
test_o = test.o bsd-interf.o other.o tregress.o psx-basic.o psx-extend.o \
psx-generic.o psx-group.o psx-interf.o psx-interv.o
common_o = printchar.o upcase.o xmalloc.o $(malloc)
# We have a lot of mallocs we can try when we run afoul of strange bugs.
malloc = @ALLOCA@
#malloc = # the libc malloc
#malloc = g++malloc.o
#malloc = debugmalloc.o
#malloc = emacsmalloc.o
emacsmallocflags = -Drcheck -Dbotch=abort -DUSG
# default is to do nothing.
default:
all: regex syntax
regex: $(regex_o) $(common_o) $(test_o) main.o
$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
# As long as we're doing tests, we enable debugging.
dregex.o: ../regex.c ../regex.h
rm -f $@
$(CC) $(ALL_CPPFLAGS) $(CFLAGS) -c ../$(srcdir)/regex.c
mv -f regex.o $@
# iregex is the interactive regex.
iregex: $(common_o) $(regex_o) iregex.o
$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
# fileregex searches for an r.e. in every line of a given file.
fileregex_o = fileregex.o printchar.o $(regex_o)
fileregex: $(fileregex_o)
$(CC) -o $@ $(LDFLAGS) $(fileregex_o) $(LIBS)
# cppregex is regex with a preprocessed regex.c. Useful when the
# problem is inside some macro.
cppregex: regexcpp.o $(common_o) $(test_o) main.o
$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
regexcpp.o: regexcpp.c
regexcpp.c: regex.c regexcpp.sed
rm -f regexcpp.c
$(CC) -E $(ALL_CPPFLAGS) ../$(srcdir)/regex.c \
| egrep -v '^#|^ *$$' \
| sed -f regexcpp.sed \
> regexcpp.c
chmod a-w regexcpp.c
# Have to give this malloc special flags.
emacsmalloc.o: emacsmalloc.c
$(CC) -c $(CFLAGS) $(ALL_CPPFLAGS) $(emacsmallocflags) \
../$(srcdir)/test/emacsmalloc.c
syntax: syntax.o
$(CC) $(CFLAGS) -o $@ syntax.o
syntax.c: syntax.skel bits
sed '/\[\[\[replace.*\]\]\]/r bits' syntax.skel > $@
bits: regex.h
sed -n 1,/RE_SYNTAX_EMACS/p ../$(srcdir)/regex.h \
| grep "#define RE_.*1" \
| sed 's/^#define \(RE_[A-Z_]*\) .*/ TEST_BIT (\1);/' > $@
check: regex
./regex
TAGS: regex.c regex.h *.h *.c
$(ETAGS) -t $^
depend:
gcc -MM $(ALL_CPPFLAGS) *.c > /tmp/depend
.PHONY: depend
install:
.PHONY: install
clean mostlyclean:
rm -f *.o regex cppregex iregex fileregex regexcpp.c syntax
distclean: clean
rm -f bits syntax.c Makefile
extraclean: distclean
rm -f *~* *\#* patch* *.orig *.rej *.bak core a.out
realclean: distclean
rm -f TAGS
Makefile: Makefile.in ../config.status
(cd ..; sh config.status)
# Prevent GNU make 3 from overflowing arg limit on system V.
.NOEXPORT:
# Assumes $(distdir) is the place to put our files.
distfiles = ChangeLog TAGS *.in *.c *.h regexcpp.sed syntax.skel
dist: Makefile TAGS
mkdir $(distdir)
ln $(distfiles) $(distdir)
# Automatically-generated dependencies below here.
alloca.o : alloca.c
bsd-interf.o : bsd-interf.c
debugmalloc.o : debugmalloc.c
emacsmalloc.o : emacsmalloc.c getpagesize.h
fileregex.o : fileregex.c .././regex.h
g++malloc.o : g++malloc.c //usr/include/stdio.h getpagesize.h
iregex.o : iregex.c .././regex.h
main.o : main.c test.h .././regex.h
malloc-test.o : malloc-test.c
other.o : other.c test.h .././regex.h
printchar.o : printchar.c
psx-basic.o : psx-basic.c test.h .././regex.h
psx-extend.o : psx-extend.c test.h .././regex.h
psx-generic.o : psx-generic.c test.h .././regex.h
psx-group.o : psx-group.c test.h .././regex.h
psx-interf.o : psx-interf.c test.h .././regex.h
psx-interv.o : psx-interv.c test.h .././regex.h
syntax.o : syntax.c .././regex.h
test.o : test.c test.h .././regex.h
tregress.o : tregress.c test.h .././regex.h
upcase.o : upcase.c
xmalloc.o : xmalloc.c

194
gnu/lib/libregex/test/alloca.c
View File

@ -1,194 +0,0 @@
/*
alloca -- (mostly) portable public-domain implementation -- D A Gwyn
last edit: 86/05/30 rms
include config.h, since on VMS it renames some symbols.
Use xmalloc instead of malloc.
This implementation of the PWB library alloca() function,
which is used to allocate space off the run-time stack so
that it is automatically reclaimed upon procedure exit,
was inspired by discussions with J. Q. Johnson of Cornell.
It should work under any C implementation that uses an
actual procedure stack (as opposed to a linked list of
frames). There are some preprocessor constants that can
be defined when compiling for your specific system, for
improved efficiency; however, the defaults should be okay.
The general concept of this implementation is to keep
track of all alloca()-allocated blocks, and reclaim any
that are found to be deeper in the stack than the current
invocation. This heuristic does not reclaim storage as
soon as it becomes invalid, but it will do so eventually.
As a special case, alloca(0) reclaims storage without
allocating any. It is a good idea to use alloca(0) in
your main control loop, etc. to force garbage collection.
*/
#ifndef lint
static char SCCSid[] = "@(#)alloca.c 1.1"; /* for the "what" utility */
#endif
#ifdef emacs
#include "config.h"
#ifdef static
/* actually, only want this if static is defined as ""
-- this is for usg, in which emacs must undefine static
in order to make unexec workable
*/
#ifndef STACK_DIRECTION
you
lose
-- must know STACK_DIRECTION at compile-time
#endif /* STACK_DIRECTION undefined */
#endif /* static */
#endif /* emacs */
#ifndef alloca /* If compiling with GCC, this file's not needed. */
#ifdef __STDC__
typedef void *pointer; /* generic pointer type */
#else
typedef char *pointer; /* generic pointer type */
#endif
#define NULL 0 /* null pointer constant */
extern void free();
extern pointer xmalloc();
/*
Define STACK_DIRECTION if you know the direction of stack
growth for your system; otherwise it will be automatically
deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown
*/
#ifndef STACK_DIRECTION
#define STACK_DIRECTION 0 /* direction unknown */
#endif
#if STACK_DIRECTION != 0
#define STACK_DIR STACK_DIRECTION /* known at compile-time */
#else /* STACK_DIRECTION == 0; need run-time code */
static int stack_dir; /* 1 or -1 once known */
#define STACK_DIR stack_dir
static void
find_stack_direction (/* void */)
{
static char *addr = NULL; /* address of first
`dummy', once known */
auto char dummy; /* to get stack address */
if (addr == NULL)
{ /* initial entry */
addr = &dummy;
find_stack_direction (); /* recurse once */
}
else /* second entry */
if (&dummy > addr)
stack_dir = 1; /* stack grew upward */
else
stack_dir = -1; /* stack grew downward */
}
#endif /* STACK_DIRECTION == 0 */
/*
An "alloca header" is used to:
(a) chain together all alloca()ed blocks;
(b) keep track of stack depth.
It is very important that sizeof(header) agree with malloc()
alignment chunk size. The following default should work okay.
*/
#ifndef ALIGN_SIZE
#define ALIGN_SIZE sizeof(double)
#endif
typedef union hdr
{
char align[ALIGN_SIZE]; /* to force sizeof(header) */
struct
{
union hdr *next; /* for chaining headers */
char *deep; /* for stack depth measure */
} h;
} header;
/*
alloca( size ) returns a pointer to at least `size' bytes of
storage which will be automatically reclaimed upon exit from
the procedure that called alloca(). Originally, this space
was supposed to be taken from the current stack frame of the
caller, but that method cannot be made to work for some
implementations of C, for example under Gould's UTX/32.
*/
static header *last_alloca_header = NULL; /* -> last alloca header */
pointer
alloca (size) /* returns pointer to storage */
unsigned size; /* # bytes to allocate */
{
auto char probe; /* probes stack depth: */
register char *depth = &probe;
#if STACK_DIRECTION == 0
if (STACK_DIR == 0) /* unknown growth direction */
find_stack_direction ();
#endif
/* Reclaim garbage, defined as all alloca()ed storage that
was allocated from deeper in the stack than currently. */
{
register header *hp; /* traverses linked list */
for (hp = last_alloca_header; hp != NULL;)
if ((STACK_DIR > 0 && hp->h.deep > depth)
|| (STACK_DIR < 0 && hp->h.deep < depth))
{
register header *np = hp->h.next;
free ((pointer) hp); /* collect garbage */
hp = np; /* -> next header */
}
else
break; /* rest are not deeper */
last_alloca_header = hp; /* -> last valid storage */
}
if (size == 0)
return NULL; /* no allocation required */
/* Allocate combined header + user data storage. */
{
register pointer new = xmalloc (sizeof (header) + size);
/* address of header */
((header *)new)->h.next = last_alloca_header;
((header *)new)->h.deep = depth;
last_alloca_header = (header *)new;
/* User storage begins just after header. */
return (pointer)((char *)new + sizeof(header));
}
}
#endif /* no alloca */

38
gnu/lib/libregex/test/bsd-interf.c
View File

@ -1,38 +0,0 @@
/* bsd-interf.c: test BSD interface. */
#ifndef _POSIX_SOURCE /* whole file */
#include "test.h"
void
test_berk_search (pattern, string)
const char *pattern;
char *string;
{
const char *return_value = re_comp (pattern);
if (return_value != 0)
{
printf ("This didn't compile: `%s'.\n", pattern);
printf (" The error message was: `%s'.\n", return_value);
}
else
if (test_should_match && re_exec (string) != strlen (string))
{
printf ("Should have matched but didn't:\n");
printf (" The pattern was: %s.\n", pattern);
if (string)
printf (" The string was: `%s'.'n", string);
else
printf (" The string was empty.\n");
}
}
void
test_bsd_interface ()
{
test_berk_search ("a", "ab");
}
#endif /* _POSIX_SOURCE */

273
gnu/lib/libregex/test/debugmalloc.c
View File

@ -1,273 +0,0 @@
/* debugmalloc.c: a malloc for debugging purposes. */
#include <stdio.h>
#include <assert.h>
#include <string.h>
static unsigned trace = 0;
#define TRACE(s) if (trace) fprintf (stderr, "%s", s)
#define TRACE1(s, e1) if (trace) fprintf (stderr, s, e1)
#define TRACE2(s, e1, e2) if (trace) fprintf (stderr, s, e1, e2)
#define TRACE3(s, e1, e2, e3) if (trace) fprintf (stderr, s, e1, e2, e3)
#define TRACE4(s, e1, e2, e3, e4) \
if (trace) fprintf (stderr, s, e1, e2, e3, e4)
typedef char *address;
/* Wrap our calls to sbrk. */
address
xsbrk (incr)
int incr;
{
extern char *sbrk ();
address ret = sbrk (incr);
if (ret == (address) -1)
{
perror ("sbrk"); /* Actually, we should return NULL, not quit. */
abort ();
}
return ret;
}
typedef struct chunk_struct
{
/* This is the size (in bytes) that has actually been actually
allocated, not the size that the user requested. */
unsigned alloc_size;
/* This is the size the user requested. */
unsigned user_size;
/* Points to the next block in one of the lists. */
struct chunk_struct *next;
/* Now comes the user's memory. */
address user_mem;
/* After the user's memory is a constant. */
} *chunk;
#define MALLOC_OVERHEAD 16
/* We might play around with the `user_size' field, but the amount of
memory that is actually available in the chunk is always the size
allocated minus the overhead. */
#define USER_ALLOC(c) ((c)->alloc_size - MALLOC_OVERHEAD)
/* Given a pointer to a malloc-allocated block, the beginning of the
chunk should always be MALLOC_OVERHEAD - 4 bytes back, since the only
overhead after the user memory is the constant. */
chunk
mem_to_chunk (mem)
address mem;
{
return (chunk) (mem - (MALLOC_OVERHEAD - 4));
}
/* The other direction is even easier, since the user's memory starts at
the `user_mem' member in the chunk. */
address
chunk_to_mem (c)
chunk c;
{
return (address) &(c->user_mem);
}
/* We keep both all the allocated chunks and all the free chunks on
lists. Since we put the next pointers in the chunk structure, we
don't need a separate chunk_list structure. */
chunk alloc_list = NULL, free_list = NULL;
/* We always append the new chunk at the beginning of the list. */
void
chunk_insert (chunk_list, new_c)
chunk *chunk_list;
chunk new_c;
{
chunk c = *chunk_list; /* old beginning of list */
TRACE3 (" Inserting 0x%x at the beginning of 0x%x, before 0x%x.\n",
new_c, chunk_list, c);
*chunk_list = new_c;
new_c->next = c;
}
/* Thus, removing an element means we have to search until we find it.
Have to delete before we insert, since insertion changes the next
pointer, which we need to put it on the other list. */
void
chunk_delete (chunk_list, dead_c)
chunk *chunk_list;
chunk dead_c;
{
chunk c = *chunk_list;
chunk prev_c = NULL;
TRACE2 (" Deleting 0x%x from 0x%x:", dead_c, chunk_list);
while (c != dead_c && c != NULL)
{
TRACE1 (" 0x%x", c);
prev_c = c;
c = c->next;
}
if (c == NULL)
{
fprintf (stderr, "Chunk at 0x%x not found on list.\n", dead_c);
abort ();
}
if (prev_c == NULL)
{
TRACE1 (".\n Setting head to 0x%x.\n", c->next);
*chunk_list = c->next;
}
else
{
TRACE2 (".\n Linking next(0x%x) to 0x%x.\n", prev_c, c->next);
prev_c->next = c->next;
}
}
/* See if a list is hunky-dory. */
void
validate_list (chunk_list)
chunk *chunk_list;
{
chunk c;
TRACE1 (" Validating list at 0x%x:", chunk_list);
for (c = *chunk_list; c != NULL; c = c->next)
{
assert (c->user_size < c->alloc_size);
assert (memcmp (chunk_to_mem (c) + c->user_size, "Karl", 4));
TRACE2 (" 0x%x/%d", c, c->user_size);
}
TRACE (".\n");
}
/* See if we have a free chunk of a given size. We'll take the first
one that is big enough. */
chunk
free_list_available (needed)
unsigned needed;
{
chunk c;
TRACE1 (" Checking free list for %d bytes:", needed);
if (free_list == NULL)
{
return NULL;
}
c = free_list;
while (c != NULL && USER_ALLOC (c) < needed)
{
TRACE2 (" 0x%x/%d", c, USER_ALLOC (c));
c = c->next;
}
TRACE1 ("\n Returning 0x%x.\n", c);
return c;
}
address
malloc (n)
unsigned n;
{
address new_mem;
chunk c;
TRACE1 ("Mallocing %d bytes.\n", n);
validate_list (&free_list);
validate_list (&alloc_list);
c = free_list_available (n);
if (c == NULL)
{ /* Nothing suitable on free list. Allocate a new chunk. */
TRACE (" not on free list.\n");
c = (chunk) xsbrk (n + MALLOC_OVERHEAD);
c->alloc_size = n + MALLOC_OVERHEAD;
}
else
{ /* Found something on free list. Don't split it, just use as is. */
TRACE (" found on free list.\n");
chunk_delete (&free_list, c);
}
/* If we took this from the free list, then the user size might be
different now, and consequently the constant at the end might be in
the wrong place. */
c->user_size = n;
new_mem = chunk_to_mem (c);
memcpy (new_mem + n, "Karl", 4);
chunk_insert (&alloc_list, c);
TRACE2 ("Malloc returning 0x%x (chunk 0x%x).\n", new_mem, c);
return new_mem;
}
address
realloc (mem, n)
address mem;
unsigned n;
{
void free ();
chunk c = mem_to_chunk (mem);
address new_mem;
TRACE3 ("Reallocing %d bytes at 0x%x (chunk 0x%x).\n", n, mem, c);
new_mem = malloc (n);
memcpy (new_mem, mem, c->user_size);
free (mem);
return new_mem;
}
void
free (mem)
address mem;
{
chunk c = mem_to_chunk (mem);
TRACE2 ("Freeing memory at 0x%x (chunk at 0x%x).\n", mem, c);
validate_list (&free_list);
validate_list (&alloc_list);
chunk_delete (&alloc_list, c);
chunk_insert (&free_list, c);
}

844
gnu/lib/libregex/test/emacsmalloc.c
View File

@ -1,844 +0,0 @@
/* dynamic memory allocation for GNU.
Copyright (C) 1985, 1987 Free Software Foundation, Inc.
This program 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 1, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding! */
/*
* @(#)nmalloc.c 1 (Caltech) 2/21/82
*
* U of M Modified: 20 Jun 1983 ACT: strange hacks for Emacs
*
* Nov 1983, Mike@BRL, Added support for 4.1C/4.2 BSD.
*
* This is a very fast storage allocator. It allocates blocks of a small
* number of different sizes, and keeps free lists of each size. Blocks
* that don't exactly fit are passed up to the next larger size. In this
* implementation, the available sizes are (2^n)-4 (or -16) bytes long.
* This is designed for use in a program that uses vast quantities of
* memory, but bombs when it runs out. To make it a little better, it
* warns the user when he starts to get near the end.
*
* June 84, ACT: modified rcheck code to check the range given to malloc,
* rather than the range determined by the 2-power used.
*
* Jan 85, RMS: calls malloc_warning to issue warning on nearly full.
* No longer Emacs-specific; can serve as all-purpose malloc for GNU.
* You should call malloc_init to reinitialize after loading dumped Emacs.
* Call malloc_stats to get info on memory stats if MSTATS turned on.
* realloc knows how to return same block given, just changing its size,
* if the power of 2 is correct.
*/
/*
* nextf[i] is the pointer to the next free block of size 2^(i+3). The
* smallest allocatable block is 8 bytes. The overhead information will
* go in the first int of the block, and the returned pointer will point
* to the second.
*
#ifdef MSTATS
* nmalloc[i] is the difference between the number of mallocs and frees
* for a given block size.
#endif MSTATS
*/
#ifdef emacs
/* config.h specifies which kind of system this is. */
#include "config.h"
#include <signal.h>
#else
/* Determine which kind of system this is. */
#include <sys/types.h>
#include <signal.h>
#include <string.h>
#define bcopy(s,d,n) memcpy ((d), (s), (n))
#define bcmp(s1,s2,n) memcmp ((s1), (s2), (n))
#define bzero(s,n) memset ((s), 0, (n))
#ifndef SIGTSTP
#ifndef VMS
#ifndef USG
#define USG
#endif
#endif /* not VMS */
#else /* SIGTSTP */
#ifdef SIGIO
#define BSD4_2
#endif /* SIGIO */
#endif /* SIGTSTP */
#endif /* not emacs */
/* Define getpagesize () if the system does not. */
#include "getpagesize.h"
#ifdef BSD
#ifdef BSD4_1
#include <sys/vlimit.h> /* warn the user when near the end */
#else /* if 4.2 or newer */
#include <sys/time.h>
#include <sys/resource.h>
#endif /* if 4.2 or newer */
#endif
#ifdef VMS
#include "vlimit.h"
#endif
extern char *start_of_data ();
#ifdef BSD
#ifndef DATA_SEG_BITS
#define start_of_data() &etext
#endif
#endif
#ifndef emacs
#define start_of_data() &etext
#endif
#define ISALLOC ((char) 0xf7) /* magic byte that implies allocation */
#define ISFREE ((char) 0x54) /* magic byte that implies free block */
/* this is for error checking only */
#define ISMEMALIGN ((char) 0xd6) /* Stored before the value returned by
memalign, with the rest of the word
being the distance to the true
beginning of the block. */
extern char etext;
/* These two are for user programs to look at, when they are interested. */
unsigned int malloc_sbrk_used; /* amount of data space used now */
unsigned int malloc_sbrk_unused; /* amount more we can have */
/* start of data space; can be changed by calling init_malloc */
static char *data_space_start;
#ifdef MSTATS
static int nmalloc[30];
static int nmal, nfre;
#endif /* MSTATS */
/* If range checking is not turned on, all we have is a flag indicating
whether memory is allocated, an index in nextf[], and a size field; to
realloc() memory we copy either size bytes or 1<<(index+3) bytes depending
on whether the former can hold the exact size (given the value of
'index'). If range checking is on, we always need to know how much space
is allocated, so the 'size' field is never used. */
struct mhead {
char mh_alloc; /* ISALLOC or ISFREE */
char mh_index; /* index in nextf[] */
/* Remainder are valid only when block is allocated */
unsigned short mh_size; /* size, if < 0x10000 */
#ifdef rcheck
unsigned mh_nbytes; /* number of bytes allocated */
int mh_magic4; /* should be == MAGIC4 */
#endif /* rcheck */
};
/* Access free-list pointer of a block.
It is stored at block + 4.
This is not a field in the mhead structure
because we want sizeof (struct mhead)
to describe the overhead for when the block is in use,
and we do not want the free-list pointer to count in that. */
#define CHAIN(a) \
(*(struct mhead **) (sizeof (char *) + (char *) (a)))
#ifdef rcheck
/* To implement range checking, we write magic values in at the beginning and
end of each allocated block, and make sure they are undisturbed whenever a
free or a realloc occurs. */
/* Written in each of the 4 bytes following the block's real space */
#define MAGIC1 0x55
/* Written in the 4 bytes before the block's real space */
#define MAGIC4 0x55555555
#define ASSERT(p) if (!(p)) botch("p"); else
#define EXTRA 4 /* 4 bytes extra for MAGIC1s */
#else
#define ASSERT(p) if (!(p)) abort (); else
#define EXTRA 0
#endif /* rcheck */
/* nextf[i] is free list of blocks of size 2**(i + 3) */
static struct mhead *nextf[30];
/* busy[i] is nonzero while allocation of block size i is in progress. */
static char busy[30];
/* Number of bytes of writable memory we can expect to be able to get */
static unsigned int lim_data;
/* Level number of warnings already issued.
0 -- no warnings issued.
1 -- 75% warning already issued.
2 -- 85% warning already issued.
*/
static int warnlevel;
/* Function to call to issue a warning;
0 means don't issue them. */
static void (*warnfunction) ();
/* nonzero once initial bunch of free blocks made */
static int gotpool;
char *_malloc_base;
static void getpool ();
/* Cause reinitialization based on job parameters;
also declare where the end of pure storage is. */
void
malloc_init (start, warnfun)
char *start;
void (*warnfun) ();
{
if (start)
data_space_start = start;
lim_data = 0;
warnlevel = 0;
warnfunction = warnfun;
}
/* Return the maximum size to which MEM can be realloc'd
without actually requiring copying. */
int
malloc_usable_size (mem)
char *mem;
{
struct mhead *p
= (struct mhead *) (mem - ((sizeof (struct mhead) + 7) & ~7));
int blocksize = 8 << p->mh_index;
return blocksize - sizeof (struct mhead) - EXTRA;
}
static void
morecore (nu) /* ask system for more memory */
register int nu; /* size index to get more of */
{
char *sbrk ();
register char *cp;
register int nblks;
register unsigned int siz;
int oldmask;
#ifdef BSD
#ifndef BSD4_1
int newmask = -1;
/* Blocking these signals interferes with debugging, at least on BSD on
the HP 9000/300. */
#ifdef SIGTRAP
newmask &= ~(1 << SIGTRAP);
#endif
#ifdef SIGILL
newmask &= ~(1 << SIGILL);
#endif
#ifdef SIGTSTP
newmask &= ~(1 << SIGTSTP);
#endif
#ifdef SIGSTOP
newmask &= ~(1 << SIGSTOP);
#endif
oldmask = sigsetmask (newmask);
#endif
#endif
if (!data_space_start)
{
data_space_start = start_of_data ();
}
if (lim_data == 0)
get_lim_data ();
/* On initial startup, get two blocks of each size up to 1k bytes */
if (!gotpool)
{ getpool (); getpool (); gotpool = 1; }
/* Find current end of memory and issue warning if getting near max */
#ifndef VMS
/* Maximum virtual memory on VMS is difficult to calculate since it
* depends on several dynmacially changing things. Also, alignment
* isn't that important. That is why much of the code here is ifdef'ed
* out for VMS systems.
*/
cp = sbrk (0);
siz = cp - data_space_start;
if (warnfunction)
switch (warnlevel)
{
case 0:
if (siz > (lim_data / 4) * 3)
{
warnlevel++;
(*warnfunction) ("Warning: past 75% of memory limit");
}
break;
case 1:
if (siz > (lim_data / 20) * 17)
{
warnlevel++;
(*warnfunction) ("Warning: past 85% of memory limit");
}
break;
case 2:
if (siz > (lim_data / 20) * 19)
{
warnlevel++;
(*warnfunction) ("Warning: past 95% of memory limit");
}
break;
}
if ((int) cp & 0x3ff) /* land on 1K boundaries */
sbrk (1024 - ((int) cp & 0x3ff));
#endif /* not VMS */
/* Take at least 2k, and figure out how many blocks of the desired size
we're about to get */
nblks = 1;
if ((siz = nu) < 8)
nblks = 1 << ((siz = 8) - nu);
if ((cp = sbrk (1 << (siz + 3))) == (char *) -1)
{
#ifdef BSD
#ifndef BSD4_1
sigsetmask (oldmask);
#endif
#endif
return; /* no more room! */
}
malloc_sbrk_used = siz;
malloc_sbrk_unused = lim_data - siz;
#ifndef VMS
if ((int) cp & 7)
{ /* shouldn't happen, but just in case */
cp = (char *) (((int) cp + 8) & ~7);
nblks--;
}
#endif /* not VMS */
/* save new header and link the nblks blocks together */
nextf[nu] = (struct mhead *) cp;
siz = 1 << (nu + 3);
while (1)
{
((struct mhead *) cp) -> mh_alloc = ISFREE;
((struct mhead *) cp) -> mh_index = nu;
if (--nblks <= 0) break;
CHAIN ((struct mhead *) cp) = (struct mhead *) (cp + siz);
cp += siz;
}
CHAIN ((struct mhead *) cp) = 0;
#ifdef BSD
#ifndef BSD4_1
sigsetmask (oldmask);
#endif
#endif
}
static void
getpool ()
{
register int nu;
char * sbrk ();
register char *cp = sbrk (0);
if ((int) cp & 0x3ff) /* land on 1K boundaries */
sbrk (1024 - ((int) cp & 0x3ff));
/* Record address of start of space allocated by malloc. */
if (_malloc_base == 0)
_malloc_base = cp;
/* Get 2k of storage */
cp = sbrk (04000);
if (cp == (char *) -1)
return;
/* Divide it into an initial 8-word block
plus one block of size 2**nu for nu = 3 ... 10. */
CHAIN (cp) = nextf[0];
nextf[0] = (struct mhead *) cp;
((struct mhead *) cp) -> mh_alloc = ISFREE;
((struct mhead *) cp) -> mh_index = 0;
cp += 8;
for (nu = 0; nu < 7; nu++)
{
CHAIN (cp) = nextf[nu];
nextf[nu] = (struct mhead *) cp;
((struct mhead *) cp) -> mh_alloc = ISFREE;
((struct mhead *) cp) -> mh_index = nu;
cp += 8 << nu;
}
}
char *
malloc (n) /* get a block */
unsigned n;
{
register struct mhead *p;
register unsigned int nbytes;
register int nunits = 0;
/* Figure out how many bytes are required, rounding up to the nearest
multiple of 8, then figure out which nestf[] area to use.
Both the beginning of the header and the beginning of the
block should be on an eight byte boundary. */
nbytes = (n + ((sizeof *p + 7) & ~7) + EXTRA + 7) & ~7;
{
register unsigned int shiftr = (nbytes - 1) >> 2;
while (shiftr >>= 1)
nunits++;
}
/* In case this is reentrant use of malloc from signal handler,
pick a block size that no other malloc level is currently
trying to allocate. That's the easiest harmless way not to
interfere with the other level of execution. */
while (busy[nunits]) nunits++;
busy[nunits] = 1;
/* If there are no blocks of the appropriate size, go get some */
/* COULD SPLIT UP A LARGER BLOCK HERE ... ACT */
if (nextf[nunits] == 0)
morecore (nunits);
/* Get one block off the list, and set the new list head */
if ((p = nextf[nunits]) == 0)
{
busy[nunits] = 0;
return 0;
}
nextf[nunits] = CHAIN (p);
busy[nunits] = 0;
/* Check for free block clobbered */
/* If not for this check, we would gobble a clobbered free chain ptr */
/* and bomb out on the NEXT allocate of this size block */
if (p -> mh_alloc != ISFREE || p -> mh_index != nunits)
#ifdef rcheck
botch ("block on free list clobbered");
#else /* not rcheck */
abort ();
#endif /* not rcheck */
/* Fill in the info, and if range checking, set up the magic numbers */
p -> mh_alloc = ISALLOC;
#ifdef rcheck
p -> mh_nbytes = n;
p -> mh_magic4 = MAGIC4;
{
/* Get the location n after the beginning of the user's space. */
register char *m = (char *) p + ((sizeof *p + 7) & ~7) + n;
*m++ = MAGIC1, *m++ = MAGIC1, *m++ = MAGIC1, *m = MAGIC1;
}
#else /* not rcheck */
p -> mh_size = n;
#endif /* not rcheck */
#ifdef MSTATS
nmalloc[nunits]++;
nmal++;
#endif /* MSTATS */
return (char *) p + ((sizeof *p + 7) & ~7);
}
free (mem)
char *mem;
{
register struct mhead *p;
{
register char *ap = mem;
if (ap == 0)
return;
p = (struct mhead *) (ap - ((sizeof *p + 7) & ~7));
if (p -> mh_alloc == ISMEMALIGN)
{
ap -= p->mh_size;
p = (struct mhead *) (ap - ((sizeof *p + 7) & ~7));
}
#ifndef rcheck
if (p -> mh_alloc != ISALLOC)
abort ();
#else rcheck
if (p -> mh_alloc != ISALLOC)
{
if (p -> mh_alloc == ISFREE)
botch ("free: Called with already freed block argument\n");
else
botch ("free: Called with bad argument\n");
}
ASSERT (p -> mh_magic4 == MAGIC4);
ap += p -> mh_nbytes;
ASSERT (*ap++ == MAGIC1); ASSERT (*ap++ == MAGIC1);
ASSERT (*ap++ == MAGIC1); ASSERT (*ap == MAGIC1);
#endif /* rcheck */
}
{
register int nunits = p -> mh_index;
ASSERT (nunits <= 29);
p -> mh_alloc = ISFREE;
/* Protect against signal handlers calling malloc. */
busy[nunits] = 1;
/* Put this block on the free list. */
CHAIN (p) = nextf[nunits];
nextf[nunits] = p;
busy[nunits] = 0;
#ifdef MSTATS
nmalloc[nunits]--;
nfre++;
#endif /* MSTATS */
}
}
char *
realloc (mem, n)
char *mem;
register unsigned n;
{
register struct mhead *p;
register unsigned int tocopy;
register unsigned int nbytes;
register int nunits;
if (mem == 0)
return malloc (n);
p = (struct mhead *) (mem - ((sizeof *p + 7) & ~7));
nunits = p -> mh_index;
ASSERT (p -> mh_alloc == ISALLOC);
#ifdef rcheck
ASSERT (p -> mh_magic4 == MAGIC4);
{
register char *m = mem + (tocopy = p -> mh_nbytes);
ASSERT (*m++ == MAGIC1); ASSERT (*m++ == MAGIC1);
ASSERT (*m++ == MAGIC1); ASSERT (*m == MAGIC1);
}
#else /* not rcheck */
if (p -> mh_index >= 13)
tocopy = (1 << (p -> mh_index + 3)) - ((sizeof *p + 7) & ~7);
else
tocopy = p -> mh_size;
#endif /* not rcheck */
/* See if desired size rounds to same power of 2 as actual size. */
nbytes = (n + ((sizeof *p + 7) & ~7) + EXTRA + 7) & ~7;
/* If ok, use the same block, just marking its size as changed. */
if (nbytes > (4 << nunits) && nbytes <= (8 << nunits))
{
#ifdef rcheck
register char *m = mem + tocopy;
*m++ = 0; *m++ = 0; *m++ = 0; *m++ = 0;
p-> mh_nbytes = n;
m = mem + n;
*m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1;
#else /* not rcheck */
p -> mh_size = n;
#endif /* not rcheck */
return mem;
}
if (n < tocopy)
tocopy = n;
{
register char *new;
if ((new = malloc (n)) == 0)
return 0;
bcopy (mem, new, tocopy);
free (mem);
return new;
}
}
/* This is in case something linked with Emacs calls calloc. */
char *
calloc (num, size)
unsigned num, size;
{
register char *mem;
num *= size;
mem = malloc (num);
if (mem != 0)
bzero (mem, num);
return mem;
}
#ifndef VMS
char *
memalign (alignment, size)
unsigned alignment, size;
{
register char *ptr = malloc (size + alignment);
register char *aligned;
register struct mhead *p;
if (ptr == 0)
return 0;
/* If entire block has the desired alignment, just accept it. */
if (((int) ptr & (alignment - 1)) == 0)
return ptr;
/* Otherwise, get address of byte in the block that has that alignment. */
aligned = (char *) (((int) ptr + alignment - 1) & -alignment);
/* Store a suitable indication of how to free the block,
so that free can find the true beginning of it. */
p = (struct mhead *) (aligned - ((7 + sizeof (struct mhead)) & ~7));
p -> mh_size = aligned - ptr;
p -> mh_alloc = ISMEMALIGN;
return aligned;
}
#ifndef HPUX
/* This runs into trouble with getpagesize on HPUX.
Patching out seems cleaner than the ugly fix needed. */
char *
valloc (size)
{
return memalign (getpagesize (), size);
}
#endif /* not HPUX */
#endif /* not VMS */
#ifdef MSTATS
/* Return statistics describing allocation of blocks of size 2**n. */
struct mstats_value
{
int blocksize;
int nfree;
int nused;
};
struct mstats_value
malloc_stats (size)
int size;
{
struct mstats_value v;
register int i;
register struct mhead *p;
v.nfree = 0;
if (size < 0 || size >= 30)
{
v.blocksize = 0;
v.nused = 0;
return v;
}
v.blocksize = 1 << (size + 3);
v.nused = nmalloc[size];
for (p = nextf[size]; p; p = CHAIN (p))
v.nfree++;
return v;
}
int
malloc_mem_used ()
{
int i;
int size_used;
size_used = 0;
for (i = 0; i < 30; i++)
{
int allocation_size = 1 << (i + 3);
struct mhead *p;
size_used += nmalloc[i] * allocation_size;
}
return size_used;
}
int
malloc_mem_free ()
{
int i;
int size_unused;
size_unused = 0;
for (i = 0; i < 30; i++)
{
int allocation_size = 1 << (i + 3);
struct mhead *p;
for (p = nextf[i]; p ; p = CHAIN (p))
size_unused += allocation_size;
}
return size_unused;
}
#endif /* MSTATS */
/*
* This function returns the total number of bytes that the process
* will be allowed to allocate via the sbrk(2) system call. On
* BSD systems this is the total space allocatable to stack and
* data. On USG systems this is the data space only.
*/
#ifdef USG
get_lim_data ()
{
extern long ulimit ();
#ifdef ULIMIT_BREAK_VALUE
lim_data = ULIMIT_BREAK_VALUE;
#else
lim_data = ulimit (3, 0);
#endif
lim_data -= (long) data_space_start;
}
#else /* not USG */
#if defined (BSD4_1) || defined (VMS)
get_lim_data ()
{
lim_data = vlimit (LIM_DATA, -1);
}
#else /* not BSD4_1 and not VMS */
get_lim_data ()
{
struct rlimit XXrlimit;
getrlimit (RLIMIT_DATA, &XXrlimit);
#ifdef RLIM_INFINITY
lim_data = XXrlimit.rlim_cur & RLIM_INFINITY; /* soft limit */
#else
lim_data = XXrlimit.rlim_cur; /* soft limit */
#endif
}
#endif /* not BSD4_1 and not VMS */
#endif /* not USG */
#ifdef VMS
/* There is a problem when dumping and restoring things on VMS. Calls
* to SBRK don't necessarily result in contiguous allocation. Dumping
* doesn't work when it isn't. Therefore, we make the initial
* allocation contiguous by allocating a big chunk, and do SBRKs from
* there. Once Emacs has dumped there is no reason to continue
* contiguous allocation, malloc doesn't depend on it.
*
* There is a further problem of using brk and sbrk while using VMS C
* run time library routines malloc, calloc, etc. The documentation
* says that this is a no-no, although I'm not sure why this would be
* a problem. In any case, we remove the necessity to call brk and
* sbrk, by calling calloc (to assure zero filled data) rather than
* sbrk.
*
* VMS_ALLOCATION_SIZE is the size of the allocation array. This
* should be larger than the malloc size before dumping. Making this
* too large will result in the startup procedure slowing down since
* it will require more space and time to map it in.
*
* The value for VMS_ALLOCATION_SIZE in the following define was determined
* by running emacs linked (and a large allocation) with the debugger and
* looking to see how much storage was used. The allocation was 201 pages,
* so I rounded it up to a power of two.
*/
#ifndef VMS_ALLOCATION_SIZE
#define VMS_ALLOCATION_SIZE (512*256)
#endif
/* Use VMS RTL definitions */
#undef sbrk
#undef brk
#undef malloc
int vms_out_initial = 0;
char vms_initial_buffer[VMS_ALLOCATION_SIZE];
static char *vms_current_brk = &vms_initial_buffer;
static char *vms_end_brk = &vms_initial_buffer[VMS_ALLOCATION_SIZE-1];
#include <stdio.h>
char *
sys_sbrk (incr)
int incr;
{
char *sbrk(), *temp, *ptr;
if (vms_out_initial)
{
/* out of initial allocation... */
if (!(temp = malloc (incr)))
temp = (char *) -1;
}
else
{
/* otherwise, go out of our area */
ptr = vms_current_brk + incr; /* new current_brk */
if (ptr <= vms_end_brk)
{
temp = vms_current_brk;
vms_current_brk = ptr;
}
else
{
vms_out_initial = 1; /* mark as out of initial allocation */
if (!(temp = malloc (incr)))
temp = (char *) -1;
}
}
return temp;
}
#endif /* VMS */

77
gnu/lib/libregex/test/fileregex.c
View File

@ -1,77 +0,0 @@
#include <sys/types.h>
#include <stdio.h>
#include "regex.h"
#define BYTEWIDTH 8
/* Sorry, but this is just a test program. */
#define LINE_MAX 500
int
main (argc, argv)
int argc;
char *argv[];
{
FILE *f;
char *filename;
char pat[500]; /* Sorry for that maximum size, too. */
char line[LINE_MAX];
struct re_pattern_buffer buf;
char fastmap[(1 << BYTEWIDTH)];
const char *compile_ret;
unsigned lineno = 1;
unsigned nfound = 0;
/* Actually, it might be useful to allow the data file to be standard
input, and to specify the pattern on the command line. */
if (argc != 2)
{
fprintf (stderr, "Usage: %s <filename>.\n", argv[0]);
exit (1);
}
filename = argv[1];
f = fopen (filename, "r");
if (f == NULL)
perror (filename);
buf.allocated = 0;
buf.buffer = NULL;
buf.fastmap = fastmap;
printf ("Pattern = ", pat);
gets (pat);
if (feof (stdin))
{
putchar ('\n');
exit (0);
}
compile_ret = re_compile_pattern (pat, strlen (pat), &buf);
if (compile_ret != NULL)
{
fprintf (stderr, "%s: %s\n", pat, compile_ret);
exit (1);
}
while (fgets (line, LINE_MAX, f) != NULL)
{
size_t len = strlen (line);
struct re_registers regs;
int search_ret
= re_search_2 (&buf, NULL, 0, line, len, 0, len, &regs, len);
if (search_ret == -2)
{
fprintf (stderr, "%s:%d: re_search failed.\n", filename, lineno);
exit (1);
}
nfound += search_ret != -1;
lineno++;
}
printf ("Matches found: %u (out of %u lines).\n", nfound, lineno - 1);
return 0;
}

1288
gnu/lib/libregex/test/g++malloc.c
View File

File diff suppressed because it is too large Load Diff

25
gnu/lib/libregex/test/getpagesize.h
View File

@ -1,25 +0,0 @@
#ifdef BSD
#ifndef BSD4_1
#define HAVE_GETPAGESIZE
#endif
#endif
#ifndef HAVE_GETPAGESIZE
#include <sys/param.h>
#ifdef EXEC_PAGESIZE
#define getpagesize() EXEC_PAGESIZE
#else
#ifdef NBPG
#define getpagesize() NBPG * CLSIZE
#ifndef CLSIZE
#define CLSIZE 1
#endif /* no CLSIZE */
#else /* no NBPG */
#define getpagesize() NBPC
#endif /* no NBPG */
#endif /* no EXEC_PAGESIZE */
#endif /* not HAVE_GETPAGESIZE */

164
gnu/lib/libregex/test/iregex.c
View File

@ -1,164 +0,0 @@
/* Main program for interactive testing. For maximum output, compile
this and regex.c with -DDEBUG. */
#include <stdio.h>
#include <sys/types.h>
#include "regex.h"
/* Don't bother to guess about <string.h> vs <strings.h>, etc. */
extern int strlen ();
#define BYTEWIDTH 8
extern void printchar ();
extern char upcase[];
static void scanstring ();
static void print_regs ();
int
main (argc, argv)
int argc;
char **argv;
{
int i;
struct re_pattern_buffer buf;
char fastmap[(1 << BYTEWIDTH)];
/* Allow a command argument to specify the style of syntax. You can
use the `syntax' program to decode integer syntax values. */
if (argc > 1)
re_set_syntax (atoi (argv[1]));
buf.allocated = 0;
buf.buffer = NULL;
buf.fastmap = fastmap;
buf.translate = upcase;
for (;;)
{
char pat[500], str[500];
struct re_registers regs;
/* Some C compilers don't like `char pat[500] = ""'. */
pat[0] = 0;
printf ("Pattern (%s) = ", pat);
gets (pat);
scanstring (pat);
if (feof (stdin))
{
putchar ('\n');
exit (0);
}
if (*pat)
{
re_compile_pattern (pat, strlen (pat), &buf);
re_compile_fastmap (&buf);
#ifdef DEBUG
print_compiled_pattern (&buf);
#endif
}
printf ("String = ");
gets (str); /* Now read the string to match against */
scanstring (str);
i = re_match (&buf, str, strlen (str), 0, &regs);
printf ("Match value %d.\t", i);
if (i >= 0)
print_regs (regs);
putchar ('\n');
i = re_search (&buf, str, strlen (str), 0, strlen (str), &regs);
printf ("Search value %d.\t", i);
if (i >= 0)
print_regs (regs);
putchar ('\n');
}
/* We never get here, but what the heck. */
return 0;
}
void
scanstring (s)
char *s;
{
char *write = s;
while (*s != '\0')
{
if (*s == '\\')
{
s++;
switch (*s)
{
case '\0':
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
*write = *s++ - '0';
if ('0' <= *s && *s <= '9')
{
*write = (*write << 3) + (*s++ - '0');
if ('0' <= *s && *s <= '9')
*write = (*write << 3) + (*s++ - '0');
}
write++;
break;
case 'n':
*write++ = '\n';
s++;
break;
case 't':
*write++ = '\t';
s++;
break;
default:
*write++ = *s++;
break;
}
}
else
*write++ = *s++;
}
*write++ = '\0';
}
/* Print REGS in human-readable form. */
void
print_regs (regs)
struct re_registers regs;
{
int i, end;
printf ("Registers: ");
if (regs.num_regs == 0 || regs.start[0] == -1)
{
printf ("(none)");
}
else
{
/* Find the last register pair that matched. */
for (end = regs.num_regs - 1; end >= 0; end--)
if (regs.start[end] != -1)
break;
printf ("[%d ", regs.start[0]);
for (i = 1; i <= end; i++)
printf ("(%d %d) ", regs.start[i], regs.end[i]);
printf ("%d]", regs.end[0]);
}
}

49
gnu/lib/libregex/test/main.c
View File

@ -1,49 +0,0 @@
/* Main routine for running various tests. Meant only to be linked with
all the auxiliary test source files, with `test' undefined. */
#include "test.h"
test_type t = all_test;
/* Use this to run the tests we've thought of. */
int
main ()
{
switch (t)
{
case all_test:
test_regress ();
test_others ();
test_posix_basic ();
test_posix_extended ();
test_posix_interface ();
break;
case other_test:
test_others ();
break;
case posix_basic_test:
test_posix_basic ();
break;
case posix_extended_test:
test_posix_extended ();
break;
case posix_interface_test:
test_posix_interface ();
break;
case regress_test:
test_regress ();
break;
default:
fprintf (stderr, "Unknown test %d.\n", t);
}
return 0;
}

47
gnu/lib/libregex/test/malloc-test.c
View File

@ -1,47 +0,0 @@
typedef struct {
unsigned *bits;
unsigned size;
} bits_list_type;
#define BYTEWIDTH 8
#define NULL 0
#define BITS_BLOCK_SIZE (sizeof (unsigned) * BYTEWIDTH)
#define BITS_BLOCK(position) ((position) / BITS_BLOCK_SIZE)
#define BITS_MASK(position) (1 << ((position) % BITS_BLOCK_SIZE))
static unsigned
init_bits_list (bits_list_ptr)
bits_list_type *bits_list_ptr;
{
bits_list_ptr->bits = NULL;
bits_list_ptr->bits = (unsigned *) malloc (sizeof (unsigned));
if (bits_list_ptr->bits == NULL)
return 0;
bits_list_ptr->bits[0] = (unsigned)0;
bits_list_ptr->size = BITS_BLOCK_SIZE;
return 1;
}
main()
{
bits_list_type dummy;
bits_list_type dummy_1;
bits_list_type dummy_2;
bits_list_type dummy_3;
init_bits_list (&dummy);
printf("init 1\n");
init_bits_list (&dummy_1);
printf("init 2\n");
init_bits_list (&dummy_2);
printf("init 3\n");
init_bits_list (&dummy_3);
printf("init 4\n");
}

503
gnu/lib/libregex/test/other.c
View File

@ -1,503 +0,0 @@
/* other.c: test (not exhaustively) non-POSIX regular expressions. */
#include "test.h"
void
test_others ()
{
struct re_registers regs;
printf ("\nStarting non-POSIX tests.\n");
t = other_test;
test_should_match = true;
/* The big question: does the group participate in the match, or match
the empty string? */
re_set_syntax (RE_NO_BK_PARENS);
test_match ("(a*)*ab", "ab");
TEST_REGISTERS ("(a*)*ab", "ab", 0, 2, 0, 0, -1, -1);
test_match ("(a*)*", "");
TEST_REGISTERS ("(a*)*ab", "ab", 0, 0, 0, 0, -1, -1);
/* This tests finding the highest and lowest active registers. */
test_match ("(a(b)c(d(e)f)g)h(i(j)k(l(m)n)o)\\1\\2\\3\\4\\5\\6\\7\\8",
"abcdefghijklmnoabcdefgbdefeijklmnojlmnm");
/* Test that \< and \> match at the beginning and end of the string. */
test_match ("\\<abc\\>", "abc");
/* May as well test \` and \' while we're at it. */
test_match ("\\`abc\\'", "abc");
#if 0
/* Test backreferencing and the fastmap -- which doesn't work. */
test_fastmap ("(a)*\\1", "a", 0, 0);
#endif
/* But at least we shouldn't search improperly. */
test_search_return (-1, "(a)\\1", "");
re_set_syntax (RE_SYNTAX_EMACS);
MATCH_SELF("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
MATCH_SELF ("a^");
MATCH_SELF ("a^b");
MATCH_SELF ("$a");
MATCH_SELF ("a$b");
re_set_syntax (RE_BACKSLASH_ESCAPE_IN_LISTS);
test_match ("[\\^a]", "a");
test_match ("[\\^a]", "^");
/* These op characters should be ordinary if RE_CONTEXT_INVALID_OPS
isn't set. */
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_BRACES | RE_INTERVALS
| RE_NO_BK_PARENS);
MATCH_SELF ("*");
test_match ("a|*", "*");
test_match ("(*)", "*");
MATCH_SELF ("+");
test_match ("a|+", "+");
test_match ("(+)", "+");
MATCH_SELF ("?");
test_match ("a|?", "?");
test_match ("(?)", "?");
MATCH_SELF ("{1}");
test_match ("a|{1}", "a");
test_match ("a|{1}", "{1}");
test_match ("({1})", "{1}");
test_match ("\\{", "{");
re_set_syntax (RE_LIMITED_OPS);
MATCH_SELF ("|");
MATCH_SELF ("a|");
MATCH_SELF ("a|");
MATCH_SELF ("a||");
MATCH_SELF ("a||");
MATCH_SELF ("(|)");
re_set_syntax (RE_SYNTAX_EMACS);
TEST_SEARCH ("^a", "b\na", 0, 3);
TEST_SEARCH ("b$", "b\na", 0, 3);
#if 0
/* Newline is no longer special for anchors (16 Sep 92). --karl */
test_match_2 ("a\n^b", "a", "\nb");
test_match_2 ("a$\nb", "a\n", "b");
#endif
/* Test grouping. */
re_set_syntax (RE_NO_BK_PARENS);
test_match ("()", "");
test_fastmap ("()", "", 0, 0);
TEST_REGISTERS ("()", "", 0, 0, 0, 0, -1, -1);
test_match ("((((((((()))))))))", "");
test_fastmap ("((((((((()))))))))", "", 0, 0);
test_match ("a()b", "ab");
TEST_REGISTERS ("a()b", "ab", 0, 2, 1, 1, -1, -1);
test_match ("(((((((((())))))))))", "");
test_fastmap ("(((((((((())))))))))", "", 0, 0);
test_match ("()*", "");
TEST_REGISTERS ("()*", "", 0, 0, 0, 0, -1, -1); /* empty string */
test_match ("(())*", "");
re_set_syntax (RE_CONTEXT_INDEP_OPS);
test_match ("*", "");
re_set_syntax (RE_INTERVALS | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES);
test_match ("{1}", ""); /* Should remain an interval. */
MATCH_SELF ("{1"); /* Not a valid interval. */
re_set_syntax (RE_NEWLINE_ALT);
test_match ("a\nb", "a");
test_match ("a\nb", "b");
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
test_match ("^a", "a");
test_match ("(^a)", "a");
test_match ("(a|^b)", "b");
test_match ("a$", "a");
test_match ("(a$)", "a");
test_match ("a$|b", "a");
/* You should be able to have empty alternatives if RE_NO_EMPTY_ALTS
isn't set. */
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
test_match ("|", "");
test_match ("^|a", "");
test_match ("^|a", "a");
test_match ("a|", "");
test_match ("a|", "a");
test_match ("a|$", "");
test_match ("a|$", "a");
test_match ("a||b", "a");
test_match ("a||b", "");
test_match ("a||b", "b");
test_match ("(|a)", "");
test_match ("(|a)", "a");
test_match ("(a|)", "");
test_match ("(a|)", "a");
TEST_SEARCH ("a|$", "xa", 0, 2);
TEST_SEARCH ("a|$", "x", 0, 1);
TEST_SEARCH ("$|b", "x", 0, 1);
TEST_SEARCH ("$|b", "xb", 0, 2);
TEST_SEARCH ("c(a|$)", "xca", 0, 3);
TEST_SEARCH ("c(a|$)", "xc", 0, 2);
TEST_SEARCH ("c($|b)", "xcb", 0, 3);
TEST_SEARCH ("c($|b)", "xc", 0, 2);
TEST_SEARCH ("c($|b$)", "xcb", 0, 3);
TEST_SEARCH ("c($|b$)", "xc", 0, 2);
TEST_SEARCH ("c(a$|$)", "xca", 0, 3);
TEST_SEARCH ("c(a$|$)", "xc", 0, 2);
TEST_SEARCH ("(a$|b$)|$", "x", 0, 1);
TEST_SEARCH ("(a$|b$)|$", "xa", 0, 2);
TEST_SEARCH ("(a$|b$)|$", "xb", 0, 2);
TEST_SEARCH ("(a$|$)|c$", "x", 0, 1);
TEST_SEARCH ("(a$|$)|c$", "xa", 0, 2);
TEST_SEARCH ("(a$|$)|c$", "xc", 0, 2);
TEST_SEARCH ("($|b$)|c$", "x", 0, 1);
TEST_SEARCH ("($|b$)|c$", "xb", 0, 2);
TEST_SEARCH ("($|b$)|c$", "xc", 0, 2);
TEST_SEARCH ("c$|(a$|$)", "x", 0, 1);
TEST_SEARCH ("c$|(a$|$)", "xa", 0, 2);
TEST_SEARCH ("c$|(a$|$)", "xc", 0, 2);
TEST_SEARCH ("c$|($|b$)", "x", 0, 1);
TEST_SEARCH ("c$|($|b$)", "xb", 0, 2);
TEST_SEARCH ("c$|($|b$)", "xc", 0, 2);
TEST_SEARCH ("$|(a$|b$)", "x", 0, 1);
TEST_SEARCH ("$|(a$|b$)", "xa", 0, 2);
TEST_SEARCH ("$|(a$|b$)", "xb", 0, 2);
TEST_SEARCH ("c(a$|b$)|$", "x", 0, 1);
TEST_SEARCH ("c(a$|b$)|$", "xca", 0, 3);
TEST_SEARCH ("c(a$|b$)|$", "xcb", 0, 3);
TEST_SEARCH ("c(a$|$)|d$", "xc", 0, 2);
TEST_SEARCH ("c(a$|$)|d$", "xca", 0, 3);
TEST_SEARCH ("c(a$|$)|d$", "xd", 0, 2);
TEST_SEARCH ("c($|b$)|d$", "xc", 0, 2);
TEST_SEARCH ("c($|b$)|d$", "xcb", 0, 3);
TEST_SEARCH ("c($|b$)|d$", "xd", 0, 2);
TEST_SEARCH ("d(c$|e((a$|$)))", "xdc", 0, 3);
TEST_SEARCH ("d(c$|e((a$|$)))", "xde", 0, 3);
TEST_SEARCH ("d(c$|e((a$|$)))", "xdea", 0, 4);
TEST_SEARCH ("d(c$|e(($|b$)))", "xdc", 0, 3);
TEST_SEARCH ("d(c$|e(($|b$)))", "xde", 0, 3);
TEST_SEARCH ("d(c$|e(($|b$)))", "xdeb", 0, 4);
TEST_SEARCH ("d($|e((a$|b$)))", "xd", 0, 2);
TEST_SEARCH ("d($|e((a$|b$)))", "xdea", 0, 4);
TEST_SEARCH ("d($|e((a$|b$)))", "xdeb", 0, 4);
TEST_SEARCH ("a(b$|c$)|$", "x", 0, 1);
TEST_SEARCH ("a(b$|c$)|$", "xab", 0, 3);
TEST_SEARCH ("a(b$|c$)|$", "xac", 0, 3);
TEST_SEARCH ("a(b$|$)|d$", "xa", 0, 2);
TEST_SEARCH ("a(b$|$)|d$", "xab", 0, 3);
TEST_SEARCH ("a(b$|$)|d$", "xd", 0, 2);
TEST_SEARCH ("a($|c$)|d$", "xa", 0, 2);
TEST_SEARCH ("a($|c$)|d$", "xac", 0, 3);
TEST_SEARCH ("a($|c$)|d$", "xd", 0, 2);
TEST_SEARCH ("d$|a(b$|$)", "xd", 0, 2);
TEST_SEARCH ("d$|a(b$|$)", "xa", 0, 2);
TEST_SEARCH ("d$|a(b$|$)", "xab", 0, 3);
TEST_SEARCH ("d$|a($|c$)", "xd", 0, 2);
TEST_SEARCH ("d$|a($|c$)", "xa", 0, 2);
TEST_SEARCH ("d$|a($|c$)", "xac", 0, 3);
TEST_SEARCH ("$|a(b$|c$)", "x", 0, 1);
TEST_SEARCH ("$|a(b$|c$)", "xab", 0, 3);
TEST_SEARCH ("$|a(b$|c$)", "xac", 0, 3);
TEST_SEARCH ("(a)(b$|c$)|d$", "xab", 0, 3);
TEST_SEARCH ("(a)(b$|c$)|d$", "xac", 0, 3);
TEST_SEARCH ("(a)(b$|c$)|d$", "xd", 0, 2);
TEST_SEARCH ("(a)(b$|$)|d$", "xa", 0, 2);
TEST_SEARCH ("(a)(b$|$)|d$", "xab", 0, 3);
TEST_SEARCH ("(a)(b$|$)|d$", "xd", 0, 2);
TEST_SEARCH ("(a)($|c$)|d$", "xa", 0, 2);
TEST_SEARCH ("(a)($|c$)|d$", "xac", 0, 3);
TEST_SEARCH ("(a)($|c$)|d$", "xd", 0, 2);
TEST_SEARCH ("d$|(a)(b$|$)", "xd", 0, 2);
TEST_SEARCH ("d$|(a)(b$|$)", "xa", 0, 2);
TEST_SEARCH ("d$|(a)(b$|$)", "xab", 0, 3);
TEST_SEARCH ("d$|(a)($|c$)", "xd", 0, 2);
TEST_SEARCH ("d$|(a)($|c$)", "xa", 0, 2);
TEST_SEARCH ("d$|(a)($|c$)", "xac", 0, 3);
TEST_SEARCH ("$|(a)(b$|c$)", "x", 0, 1);
TEST_SEARCH ("$|(a)(b$|c$)", "xab", 0, 3);
TEST_SEARCH ("$|(a)(b$|c$)", "xac", 0, 3);
TEST_SEARCH ("d$|(c$|(a$|$))", "x", 0, 1);
TEST_SEARCH ("d$|(c$|(a$|$))", "xd", 0, 2);
TEST_SEARCH ("d$|(c$|(a$|$))", "xc", 0, 2);
TEST_SEARCH ("d$|(c$|(a$|$))", "xa", 0, 2);
TEST_SEARCH ("d$|(c$|($|b$))", "x", 0, 1);
TEST_SEARCH ("d$|(c$|($|b$))", "xd", 0, 2);
TEST_SEARCH ("d$|(c$|($|b$))", "xc", 0, 2);
TEST_SEARCH ("d$|(c$|($|b$))", "xb", 0, 2);
TEST_SEARCH ("d$|($|(a$|b$))", "x", 0, 1);
TEST_SEARCH ("d$|($|(a$|b$))", "xd", 0, 2);
TEST_SEARCH ("d$|($|(a$|b$))", "xa", 0, 2);
TEST_SEARCH ("d$|($|(a$|b$))", "xb", 0, 2);
TEST_SEARCH ("$|(c$|(a$|b$))", "x", 0, 1);
TEST_SEARCH ("$|(c$|(a$|b$))", "xc", 0, 2);
TEST_SEARCH ("$|(c$|(a$|b$))", "xa", 0, 2);
TEST_SEARCH ("$|(c$|(a$|b$))", "xb", 0, 2);
TEST_SEARCH ("d$|c(a$|$)", "xd", 0, 2);
TEST_SEARCH ("d$|c(a$|$)", "xc", 0, 2);
TEST_SEARCH ("d$|c(a$|$)", "xca", 0, 3);
TEST_SEARCH ("d$|c($|b$)", "xd", 0, 2);
TEST_SEARCH ("d$|c($|b$)", "xc", 0, 2);
TEST_SEARCH ("d$|c($|b$)", "xcb", 0, 3);
TEST_SEARCH ("$|c(a$|b$)", "x", 0, 1);
TEST_SEARCH ("$|c(a$|b$)", "xca", 0, 3);
TEST_SEARCH ("$|c(a$|b$)", "xcb", 0, 3);
TEST_SEARCH ("e(d$|c((a$|$)))", "xed", 0, 3);
TEST_SEARCH ("e(d$|c((a$|$)))", "xec", 0, 3);
TEST_SEARCH ("e(d$|c((a$|$)))", "xeca", 0, 3);
TEST_SEARCH ("e(d$|c(($|b$)))", "xed", 0, 3);
TEST_SEARCH ("e(d$|c(($|b$)))", "xec", 0, 3);
TEST_SEARCH ("e(d$|c(($|b$)))", "xecb", 0, 4);
TEST_SEARCH ("e($|c((a$|b$)))", "xe", 0, 2);
TEST_SEARCH ("e($|c((a$|b$)))", "xeca", 0, 4);
TEST_SEARCH ("e($|c((a$|b$)))", "xecb", 0, 4);
TEST_SEARCH ("ed$|(c((a$|$)))", "xed", 0, 3);
TEST_SEARCH ("ed$|(c((a$|$)))", "xc", 0, 2);
TEST_SEARCH ("ed$|(c((a$|$)))", "xca", 0, 3);
TEST_SEARCH ("ed$|(c(($|b$)))", "xed", 0, 3);
TEST_SEARCH ("ed$|(c(($|b$)))", "xc", 0, 2);
TEST_SEARCH ("ed$|(c(($|b$)))", "xcb", 0, 3);
TEST_SEARCH ("$|(c((a$|b$)))", "x", 0, 1);
TEST_SEARCH ("$|(c((a$|b$)))", "xca", 0, 3);
TEST_SEARCH ("$|(c((a$|b$)))", "xcb", 0, 3);
TEST_SEARCH ("d$|($|(a|b)$)", "x", 0, 1);
TEST_SEARCH ("d$|($|(a|b)$)", "xa", 0, 2);
TEST_SEARCH ("d$|($|(a|b)$)", "xb", 0, 2);
TEST_SEARCH ("$|(c$|(a|b)$)", "x", 0, 1);
TEST_SEARCH ("$|(c$|(a|b)$)", "xc", 0, 2);
TEST_SEARCH ("$|(c$|(a|b)$)", "xa", 0, 2);
TEST_SEARCH ("$|(c$|(a|b)$)", "xb", 0, 2);
re_set_syntax (0);
test_match ("[^\n]", "a");
test_match ("[^a]", "\n");
TEST_SEARCH ("^a", "b\na", 0, 3);
TEST_SEARCH ("b$", "b\na", 0, 3);
test_case_fold ("[!-`]", "A");
test_case_fold ("[!-`]", "a");
re_set_syntax (RE_CONTEXT_INDEP_OPS | RE_NO_BK_VBAR | RE_NO_BK_PARENS
| RE_NO_BK_BRACES | RE_INTERVALS);
valid_nonposix_pattern ("()^a");
valid_nonposix_pattern ("()\\1^a");
/* Per Cederqvist (cedar@lysator.liu.se) bug. */
re_set_syntax (RE_SYNTAX_EMACS);
/* One `a' before the \n and 638 a's after it. */
test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "a\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
/* No a's before the \n and 639 a's after it. */
test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
/* One `a' before the \n and 639 a's after it. */
test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "a\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
/* No a's before the \n and 640 a's after it. */
test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
TEST_SEARCH ("^(^a)", "ab", 0, 2);
TEST_SEARCH ("(a$)$", "ba", 0, 2);
test_match ("a|$b", "$b");
/* Mike's curiosity item. */
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
test_all_registers ("(foo|foobar)(foo|bar)*\\1(foo|bar)*",
"foobarfoobar", "",
0, 12, 0, 3, 3, 6, 9, 12, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1);
/* Another one from Mike. */
test_match ("(foo|foobarfoo)(bar)*", "foobarfoo");
/* And another. */
test_match("(foo|foobar)(bar|barfoo)?\\1", "foobarfoobar");
re_set_syntax (RE_NO_BK_PARENS | RE_INTERVALS | RE_NO_BK_VBAR
| RE_NO_BK_BRACES); /* xx get new ones from ext.*/
test_match ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)*", "bb");
test_all_registers ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)*", "", "bb",
0, 2, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1);
test_match ("((a+?*{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)", "b");
test_all_registers ("((a+?*{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)", "", "b",
0, 1, 0, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1);
/* Valid anchoring. */
/* See generic_test.c and extended_test.c for more search
tests. xx Not sure all these tests are represented in the
search tests. */
re_set_syntax (RE_NO_BK_PARENS | RE_NO_BK_VBAR);
valid_nonposix_pattern
("(((((((((((((((((((((((((((((((((^a)))))))))))))))))))))))))))))))))");
valid_nonposix_pattern
("(((((((((((((((((((((((((((((((((a$)))))))))))))))))))))))))))))))))");
valid_nonposix_pattern ("\\b\\B\\<\\>\\`\\'^a");
valid_nonposix_pattern ("a$\\b\\B\\<\\>\\`\\'");
valid_nonposix_pattern ("(^a)");
valid_nonposix_pattern ("(a$)");
valid_nonposix_pattern ("(^a)b");
valid_nonposix_pattern ("b(a$)");
valid_nonposix_pattern ("(^a|^b)c");
valid_nonposix_pattern ("c(a$|b$)");
valid_nonposix_pattern ("(^a|^b)|^c");
valid_nonposix_pattern ("(a$|b$)|c$");
valid_nonposix_pattern ("^c|(^a|^b)");
valid_nonposix_pattern ("c$|(a$|b$)");
valid_nonposix_pattern ("(^a|^b)c|^d");
valid_nonposix_pattern ("c(a$|b$)|d$");
valid_nonposix_pattern ("(((^a|^b))c|^d)e");
valid_nonposix_pattern ("(c((a|b))|d)e$");
valid_nonposix_pattern ("^d(c|e((a|b)))");
valid_nonposix_pattern ("d(c$|e((a$|b$)))");
valid_nonposix_pattern ("(((^a|^b))c)|^de");
valid_nonposix_pattern ("(((a|b))c$)|de$");
valid_nonposix_pattern ("((a$)$)$");
valid_nonposix_pattern ("^(^(^a))");
valid_nonposix_pattern ("^de|^(c((a|b)))");
valid_nonposix_pattern ("^de|(^c((a|b)))");
valid_nonposix_pattern ("de$|(c((a|b)$))");
valid_nonposix_pattern ("de$|(c((a|b))$)");
valid_nonposix_pattern ("de$|(c((a|b)))$");
valid_nonposix_pattern ("^a(b|c)|^d");
valid_nonposix_pattern ("a(b$|c$)|d$");
valid_nonposix_pattern ("^d|^a(b|c)");
valid_nonposix_pattern ("d$|a(b$|c$)");
valid_nonposix_pattern ("^d|^(b|c)a");
valid_nonposix_pattern ("d$|(b|c)a$");
valid_nonposix_pattern ("^(a)(b|c)|^d");
valid_nonposix_pattern ("(a)(b|c)$|d$");
valid_nonposix_pattern ("(^a)(b|c)|^d");
valid_nonposix_pattern ("(a)(b$|c$)|d$");
valid_nonposix_pattern ("^d|^(b|c)(a)");
valid_nonposix_pattern ("d$|(b|c)(a)$");
valid_nonposix_pattern ("^d|(^b|^c)(a)");
valid_nonposix_pattern ("d$|(b|c)(a$)");
valid_nonposix_pattern ("^d|^(a)(b|c)");
valid_nonposix_pattern ("^d|(^a)(b|c)");
valid_nonposix_pattern ("d$|(a)(b$|c$)");
valid_nonposix_pattern ("((^a|^b)|^c)|^d");
valid_nonposix_pattern ("d$|(c$|(a$|b$))");
/* Tests shouldn't match. */
test_should_match = false;
/* Test that RE_CONTEXT_INVALID_OPS has precedence over
RE_CONTEXT_INDEP_OPS. */
re_set_syntax (RE_CONTEXT_INDEP_OPS | RE_CONTEXT_INVALID_OPS
| RE_NO_BK_VBAR | RE_NO_BK_PARENS
| RE_NO_BK_BRACES | RE_INTERVALS);
INVALID_PATTERN ("*");
INVALID_PATTERN ("^*");
INVALID_PATTERN ("a|*");
INVALID_PATTERN ("(*)");
INVALID_PATTERN ("^+");
INVALID_PATTERN ("+");
INVALID_PATTERN ("a|+");
INVALID_PATTERN ("(+)");
INVALID_PATTERN ("^?");
INVALID_PATTERN ("?");
INVALID_PATTERN ("a|?");
INVALID_PATTERN ("(?)");
INVALID_PATTERN ("^{1}");
INVALID_PATTERN ("{1}");
INVALID_PATTERN ("a|{1}");
INVALID_PATTERN ("({1})");
#if 0
/* No longer have this syntax option -- POSIX says empty alternatives
are undefined as of draft 11.2. */
/* You can't have empty alternatives if RE_NO_EMPTY_ALTS is set. */
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_ALTS);
INVALID_PATTERN ("|");
INVALID_PATTERN ("^|a");
INVALID_PATTERN ("a|");
INVALID_PATTERN ("a||");
INVALID_PATTERN ("a||b");
INVALID_PATTERN ("(|a)");
INVALID_PATTERN ("(a|)");
INVALID_PATTERN ("(a|)");
/* Test above with `\(' and `\)'. */
re_set_syntax (RE_NO_BK_VBAR | RE_NO_EMPTY_ALTS);
INVALID_PATTERN ("\\(|a\\)");
INVALID_PATTERN ("\\(a|\\)");
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_ALTS);
INVALID_PATTERN ("(|)()$|d$");
#endif
/* Test grouping. */
test_match ("()", "a");
/* Test backslashed intervals that are CONTEXTly invalid if have
nothing on which to operate. */
re_set_syntax (RE_INTERVALS | RE_CONTEXT_INVALID_OPS);
INVALID_PATTERN ("\\{1\\}");
re_set_syntax (0);
test_match ("z-a", "a");
re_set_syntax (RE_BK_PLUS_QM);
INVALID_PATTERN ("a*\\");
re_set_syntax (0);
INVALID_PATTERN ("a*\\");
re_set_syntax (RE_BACKSLASH_ESCAPE_IN_LISTS);
INVALID_PATTERN ("[\\");
#if 0
/* Empty groups are always ok now. (13 Sep 92) */
re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_GROUPS);
INVALID_PATTERN ("(|)()$|d$");
#endif
printf ("\nFinished non-POSIX tests.\n");
}
/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/

14
gnu/lib/libregex/test/printchar.c
View File

@ -1,14 +0,0 @@
void
printchar (c)
char c;
{
if (c < 040 || c >= 0177)
{
putchar ('\\');
putchar (((c >> 6) & 3) + '0');
putchar (((c >> 3) & 7) + '0');
putchar ((c & 7) + '0');
}
else
putchar (c);
}

253
gnu/lib/libregex/test/psx-basic.c
View File

@ -1,253 +0,0 @@
/* psx-basic.c: Test POSIX basic regular expressions. */
#include "test.h"
void
test_posix_basic ()
{
/* Intervals can only match up to RE_DUP_MAX occurences of anything. */
char dup_max_plus_one[6];
sprintf (dup_max_plus_one, "%d", RE_DUP_MAX + 1);
printf ("\nStarting POSIX basic tests.\n");
t = posix_basic_test;
re_set_syntax (RE_SYNTAX_POSIX_MINIMAL_BASIC);
test_posix_generic ();
printf ("\nContinuing POSIX basic tests.\n");
/* Grouping tests that are not the same. */
test_should_match = false;
invalid_pattern (REG_EPAREN, PARENS_TO_OPS ("a)"));
test_should_match = true;
/* Special characters. */
MATCH_SELF ("*");
test_match ("\\(*\\)", "*");
test_match ("\\(^*\\)", "*");
test_match ("**", "***");
test_match ("***", "****");
MATCH_SELF ("{"); /* of extended... */
MATCH_SELF ("()"); /* also non-Posix. */
MATCH_SELF ("a+");
MATCH_SELF ("a?");
MATCH_SELF ("a|b");
MATCH_SELF ("a|"); /* No alternations, */
MATCH_SELF ("|a"); /* so OK if empty. */
MATCH_SELF ("a||");
test_match ("\\(|a\\)", "|a");
test_match ("\\(a|\\)", "a|");
test_match ("a\\+", "a+");
test_match ("a\\?", "a?");
test_match ("a\\|b", "a|b");
test_match ("^*", "*");
test_match ("^+", "+");
test_match ("^?", "?");
test_match ("^{", "{");
/* Valid subexpressions
(empty) in basic only. */
test_match ("\\(\\)", "");
test_match ("a\\(\\)", "a");
test_match ("\\(\\)b", "b");
test_match ("a\\(\\)b", "ab");
TEST_REGISTERS ("a\\(\\)b", "ab", 0, 2, 1, 1, -1, -1);
test_match ("\\(\\)*", "");
test_match ("\\(\\(\\)\\)*", "");
/* Valid back references. */
/* N.B.: back references to subexpressions that include a * are
undefined in the spec. The tests are in here to see if we handle
the situation consistently, but if it fails any of them, it doesn't
matter. */
test_match ("\\(\\)\\1", "");
TEST_REGISTERS ("\\(\\)\\1", "", 0, 0, 0, 0, -1, -1);
test_match ("\\(\\(\\)\\)\\(\\)\\2", "");
test_match ("\\(a\\)\\1", "aa");
TEST_REGISTERS ("\\(a\\)\\1", "aa", 0, 2, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a\\)\\1", "xaax", 1, 3, 1, 2, -1, -1);
test_match ("\\(\\(a\\)\\)\\1", "aa");
test_match ("\\(a\\)\\(b\\)\\2\\1", "abba");
test_match ("\\(a\\)*\\1", "aa");
TEST_REGISTERS ("\\(a\\)*\\1", "aa", 0, 2, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a\\)*\\1", "xaax", 0, 0, -1, -1, -1, -1);
test_match ("\\(\\(a\\)\\2b\\)*", "aab");
TEST_REGISTERS ("\\(\\(a\\)\\2b\\)*", "aab", 0, 3, 0, 3, 0, 1);
TEST_REGISTERS ("\\(\\(a\\)\\2b\\)*", "xaabx", 0, 0, -1, -1, -1, -1);
test_match ("\\(a*\\)*\\1", "");
test_match ("\\(a*\\)*\\1", "aa");
TEST_REGISTERS ("\\(a*\\)*\\1", "aa", 0, 2, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a*\\)*\\1", "xaax", 0, 0, 0, 0, -1, -1);
test_match ("\\(a*\\)*\\1", "");
test_match ("\\(a*\\)*\\1", "aa");
test_match ("\\(\\(a*\\)*\\)*\\1", "aa");
test_match ("\\(ab*\\)*\\1", "abab");
TEST_REGISTERS ("\\(ab*\\)*\\1", "abab", 0, 4, 0, 2, -1, -1);
TEST_REGISTERS ("\\(ab*\\)*\\1", "xababx", 0, 0, -1, -1, -1, -1);
test_match ("\\(a*\\)ab\\1", "aaba");
TEST_REGISTERS ("\\(a*\\)ab\\1", "aaba", 0, 4, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a*\\)ab\\1", "xaabax", 1, 5, 1, 2, -1, -1);
test_match ("\\(a*\\)*ab\\1", "aaba");
TEST_REGISTERS ("\\(a*\\)*ab\\1", "aaba", 0, 4, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a*\\)*ab\\1", "xaabax", 1, 5, 1, 2, -1, -1);
test_match ("\\(\\(a*\\)b\\)*\\2", "abb");
TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "abb", 0, 3, 2, 3, 2, 2);
TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "xabbx", 0, 0, -1, -1, -1, -1);
/* Different from above. */
test_match ("\\(\\(a*\\)b*\\)*\\2", "aa");
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aa", 0, 2, 0, 1, 0, 1);
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaax", 0, 0, 0, 0, 0, 0);
test_match ("\\(\\(a*\\)b*\\)*\\2", "aba");
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aba", 0, 3, 0, 2, 0, 1);
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xabax", 0, 0, 0, 0, 0, 0);
test_match ("\\(\\(a*\\)b\\)*\\2", "aababa");
TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "aababa", 0, 6, 3, 5, 3, 4);
TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "xaababax", 0, 0, -1, -1, -1, -1);
test_match ("\\(\\(a*\\)b*\\)*\\2", "aabaa");
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aabaa", 0, 5, 0, 3, 0, 2);
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaabaax", 0, 0, 0, 0, 0, 0);
test_match ("\\(\\(a*\\)b*\\)*\\2", "aabbaa");
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aabbaa", 0, 6, 0, 4, 0, 2);
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaabbaax", 0, 0, 0, 0, 0, 0);
test_match ("\\(\\(a*\\)b*\\)*\\2", "abaabaa");
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "abaabaa", 0, 7, 2, 5, 2, 4);
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaababaax", 0, 0, 0, 0, 0, 0);
test_match ("\\(\\(a*\\)b*\\)*a\\2", "aabaaa");
TEST_REGISTERS ("\\(\\(a*\\)b*a\\)*\\2", "aabaaa", 0, 6, 0, 3, 0, 2);
TEST_REGISTERS ("\\(\\(a*\\)b*a\\)*\\2", "xaabaax", 0, 0, -1, -1, -1, -1);
test_match ("\\(\\(a*\\)b*\\)*\\2a", "aabaaa");
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2a", "aabaaa", 0, 6, 0, 3, 0, 2);
TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2a", "xaabaaax", 1, 7, 1, 4, 1, 3);
test_match ("\\(\\(a*\\)b\\)*\\2\\1", "abaabaaaab");
TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2\\1", "abaabaaaab", 0, 10, 2, 5, 2, 4);
/* We are matching the empty string here. */
TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2\\1", "xabaabaaaabx", 0, 0, -1, -1, -1, -1);
test_match ("\\(a*b\\)\\1", "abab");
test_match ("\\(a\\)\\1\\1", "aaa");
test_match ("\\(a\\(c\\)d\\)\\1\\2", "acdacdc");
test_match ("\\(a\\)\\1*", "aaa");
TEST_REGISTERS ("\\(a\\)\\1*", "aaa", 0, 3, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a\\)\\1*", "xaaax", 1, 4, 1, 2, -1, -1);
test_match ("\\(a\\)\\{1,3\\}b\\1", "aba");
TEST_REGISTERS ("\\(a\\)\\{1,3\\}b\\1", "aba", 0, 3, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a\\)\\{1,3\\}b\\1", "xabax", 1, 4, 1, 2, -1, -1);
test_match ("\\(\\(a\\)\\2\\)*", "aaaa"); /* rms? */
TEST_REGISTERS ("\\(\\(a*b\\)\\2\\)*", "bbabab", 0, 6, 2, 6, 2, 4); /* rms? */
test_match ("\\(\\(a\\)\\1\\)*", "a1a1");
test_match ("\\(\\(a\\)\\2\\)\\1", "aaaa");
test_match ("\\(\\(a*\\)\\2\\)\\1", "aaaa");
TEST_REGISTERS ("\\(\\(a*\\)\\2\\)\\1", "aaaa", 0, 4, 0, 2, 0, 1);
TEST_REGISTERS ("\\(\\(a*\\)\\2\\)\\1", "xaaaax", 0, 0, 0, 0, 0, 0);
test_match ("\\{1\\}", "{1}");
test_match ("^\\{1\\}", "{1}");
test_match ("\\(a\\)\\1\\{1,2\\}", "aaa");
TEST_REGISTERS ("\\(a\\)\\1\\{1,2\\}", "aaa", 0, 3, 0, 1, -1, -1);
TEST_REGISTERS ("\\(a\\)\\1\\{1,2\\}", "xaaax", 1, 4, 1, 2, -1, -1);
/* Per POSIX D11.1 p. 109, leftmost longest match. */
test_match (PARENS_TO_OPS ("(.*).*\\1"), "abcabc");
/* Per POSIX D11.1, p. 125, leftmost longest match. */
test_match (PARENS_TO_OPS ("(ac*)c*d[ac]*\\1"), "acdacaaa");
TEST_REGISTERS (PARENS_TO_OPS ("(ac*)c*d[ac]*\\1"), "acdacaaa",
0, 8, 0, 1, -1, -1);
/* Anchors become ordinary, sometimes. */
MATCH_SELF ("a^");
MATCH_SELF ("$a");
MATCH_SELF ("$^");
test_fastmap ("$a^", "$", 0, 0);
test_match ("$^*", "$^^");
test_match ("\\($^\\)", "$^");
test_match ("$*", "$$");
/* xx -- known bug, solution pending test_match ("^^$", "^"); */
test_match ("$\\{0,\\}", "$$");
TEST_SEARCH ("^$*", "$$", 0, 2);
TEST_SEARCH ("^$\\{0,\\}", "$$", 0, 2);
MATCH_SELF ("2^10");
MATCH_SELF ("$HOME");
MATCH_SELF ("$1.35");
/* Basic regular expressions, continued; these don't match their strings. */
test_should_match = false;
invalid_pattern (REG_EESCAPE, "\\(a\\");
/* Invalid back references. */
test_match ("\\(a\\)\\1", "ab");
test_match ("\\(a\\)\\1\\1", "aab");
test_match ("\\(a\\)\\(b\\)\\2\\1", "abab");
test_match ("\\(a\\(c\\)d\\)\\1\\2", "acdc");
test_match ("\\(a*b\\)\\1", "abaab");
test_match ("\\(a\\)\\1*", "aaaaaaaaaab");
test_match ("\\(\\(a\\)\\1\\)*", "aaa");
invalid_pattern (REG_ESUBREG, "\\1");
invalid_pattern (REG_ESUBREG, "\\(a\\)\\2");
test_match ("\\(\\(a\\)\\2\\)*", "abaa");
test_match ("\\(\\(a\\)\\1\\)*", "a");
test_match ("\\(\\(a\\)\\2\\)\\1", "abaa");
test_match ("\\(\\(a*\\)\\2\\)\\1", "abaa");
/* Invalid intervals. */
invalid_pattern (REG_EBRACE, "a\\{");
invalid_pattern (REG_BADBR, "a\\{-1");
invalid_pattern (REG_BADBR, concat ("a\\{", (char *)dup_max_plus_one));
invalid_pattern (REG_BADBR, concat (concat ("a\\{", (char *)dup_max_plus_one), ","));
invalid_pattern (REG_BADBR, "a\\{1,0");
invalid_pattern (REG_EBRACE, "a\\{1");
invalid_pattern (REG_EBRACE, "a\\{0,");
invalid_pattern (REG_EBRACE, "a\\{0,1");
invalid_pattern (REG_EBRACE, "a\\{0,1}");
printf ("\nFinished POSIX basic tests.\n");
}
/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/

1244
gnu/lib/libregex/test/psx-extend.c
View File

File diff suppressed because it is too large Load Diff

336
gnu/lib/libregex/test/psx-generic.c
View File

@ -1,336 +0,0 @@
/* psx-generic.c: test POSIX re's independent of us using basic or
extended syntax. */
#include "test.h"
void
test_posix_generic ()
{
int omit_generic_tests = 0; /* reset in debugger to skip */
if (omit_generic_tests)
return;
/* Tests somewhat in the order of P1003.2. */
/* Both posix basic and extended; should match. */
printf ("\nStarting generic POSIX tests.\n");
test_grouping ();
test_intervals ();
test_should_match = true;
/* Ordinary characters. */
printf ("\nContinuing generic POSIX tests.\n");
MATCH_SELF ("");
test_fastmap ("", "", 0, 0);
test_fastmap_search ("", "", "", 0, 0, 2, 0, 0);
TEST_REGISTERS ("", "", 0, 0, -1, -1, -1, -1);
TEST_SEARCH ("", "", 0, 0);
TEST_SEARCH_2 ("", "", "", 0, 1, 0);
MATCH_SELF ("abc");
test_fastmap ("abc", "a", 0, 0);
TEST_REGISTERS ("abc", "abc", 0, 3, -1, -1, -1, -1);
TEST_REGISTERS ("abc", "xabcx", 1, 4, -1, -1, -1, -1);
test_match ("\\a","a");
test_match ("\\0", "0");
TEST_SEARCH ("a", "ab", 0, 2);
TEST_SEARCH ("b", "ab", 0, 2);
TEST_SEARCH ("a", "ab", 1, -2);
TEST_SEARCH_2 ("a", "a", "b", 0, 2, 2);
TEST_SEARCH_2 ("b", "a", "b", 0, 2, 2);
TEST_SEARCH_2 ("a", "a", "b", 1, -2, 2);
test_match ("\n", "\n");
test_match ("a\n", "a\n");
test_match ("\nb", "\nb");
test_match ("a\nb", "a\nb");
TEST_SEARCH ("b", "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 236, -237);
/* Valid use of special characters. */
test_match ("a*", "aa");
test_fastmap ("a*", "a", 0, 0);
TEST_REGISTERS ("a*", "aa", 0, 2, -1, -1, -1, -1);
test_match ("a*b", "aab");
test_fastmap ("a*b", "ab", 0, 0);
test_match ("a*ab", "aab");
TEST_REGISTERS ("a*a", "aa", 0, 2, -1, -1, -1, -1);
TEST_REGISTERS ("a*a", "xaax", 1, 3, -1, -1, -1, -1);
test_match ("\\{", "{");
test_match ("\\^", "^");
test_match ("\\.", ".");
test_match ("\\*", "*");
test_match ("\\[", "[");
test_match ("\\$", "$");
test_match ("\\\\", "\\");
test_match ("ab*", "a");
test_match ("ab*", "abb");
/* Valid consecutive repetitions. */
test_match ("a**", "a");
/* Valid period. */
test_match (".", "a");
TEST_REGISTERS (".", "a", 0, 1, -1, -1, -1, -1);
test_match (".", "\004");
test_match (".", "\n");
/* Valid bracket expressions. */
test_match ("[ab]", "a");
test_match ("[ab]", "b");
test_fastmap ("[ab]", "ab", 0, 0);
TEST_REGISTERS ("[ab]", "a", 0, 1, -1, -1, -1, -1);
TEST_REGISTERS ("[ab]", "xax", 1, 2, -1, -1, -1, -1);
test_fastmap ("[^ab]", "ab", 1, 1);
test_match ("[^ab]", "c");
test_match ("[^a]", "\n");
test_match ("[a]*a", "aa");
test_match ("[[]", "[");
test_match ("[]]", "]");
test_match ("[.]", ".");
test_match ("[*]", "*");
test_match ("[\\]", "\\");
test_match ("[\\(]", "(");
test_match ("[\\)]", ")");
test_match ("[^]]", "a");
test_match ("[a^]", "^");
test_match ("[a$]", "$");
test_match ("[]a]", "]");
test_match ("[a][]]", "a]");
test_match ("[\n]", "\n");
test_match ("[^a]", "\n");
test_match ("[a-]", "a");
TEST_REGISTERS ("\\`[ \t\n]*", " karl (Karl Berry)", 0, 1, -1, -1, -1, -1);
TEST_REGISTERS ("[ \t\n]*\\'", " karl (Karl Berry)", 18, 18, -1, -1, -1, -1);
/* Collating, noncollating,
equivalence classes aren't
implemented yet. */
/* Character classes. */
test_match ("[:alpha:]", "p");
test_match ("[[:alpha:]]", "a");
test_match ("[[:alpha:]]", "z");
test_match ("[[:alpha:]]", "A");
test_match ("[[:alpha:]]", "Z");
test_match ("[[:upper:]]", "A");
test_match ("[[:upper:]]", "Z");
test_match ("[[:lower:]]", "a");
test_match ("[[:lower:]]", "z");
test_match ("[[:digit:]]", "0");
test_match ("[[:digit:]]", "9");
test_fastmap ("[[:digit:]]", "0123456789", 0, 0);
test_match ("[[:alnum:]]", "0");
test_match ("[[:alnum:]]", "9");
test_match ("[[:alnum:]]", "a");
test_match ("[[:alnum:]]", "z");
test_match ("[[:alnum:]]", "A");
test_match ("[[:alnum:]]", "Z");
test_match ("[[:xdigit:]]", "0");
test_match ("[[:xdigit:]]", "9");
test_match ("[[:xdigit:]]", "A");
test_match ("[[:xdigit:]]", "F");
test_match ("[[:xdigit:]]", "a");
test_match ("[[:xdigit:]]", "f");
test_match ("[[:space:]]", " ");
test_match ("[[:print:]]", " ");
test_match ("[[:print:]]", "~");
test_match ("[[:punct:]]", ",");
test_match ("[[:graph:]]", "!");
test_match ("[[:graph:]]", "~");
test_match ("[[:cntrl:]]", "\177");
test_match ("[[:digit:]a]", "a");
test_match ("[[:digit:]a]", "2");
test_match ("[a[:digit:]]", "a");
test_match ("[a[:digit:]]", "2");
test_match ("[[:]", "[");
test_match ("[:]", ":");
test_match ("[[:a]", "[");
test_match ("[[:alpha:a]", "[");
/* Valid ranges. */
test_match ("[a-a]", "a");
test_fastmap ("[a-a]", "a", 0, 0);
TEST_REGISTERS ("[a-a]", "xax", 1, 2, -1, -1, -1, -1);
test_match ("[a-z]", "z");
test_fastmap ("[a-z]", "abcdefghijklmnopqrstuvwxyz", 0, 0);
test_match ("[-a]", "-"); /* First */
test_match ("[-a]", "a");
test_match ("[a-]", "-"); /* Last */
test_match ("[a-]", "a");
test_match ("[--@]", "@"); /* First and starting point. */
test_match ("[%--a]", "%"); /* Ending point. */
test_match ("[%--a]", "-"); /* Ditto. */
test_match ("[a%--]", "%"); /* Both ending point and last. */
test_match ("[a%--]", "-");
test_match ("[%--a]", "a"); /* Ending point only. */
test_match ("[a-c-f]", "e"); /* Piggyback. */
test_match ("[)-+--/]", "*");
test_match ("[)-+--/]", ",");
test_match ("[)-+--/]", "/");
test_match ("[[:digit:]-]", "-");
/* Concatenation ????*/
test_match ("[ab][cd]", "ac");
test_fastmap ("[ab][cd]", "ab", 0, 0);
TEST_REGISTERS ("[ab][cd]", "ad", 0, 2, -1, -1, -1, -1);
TEST_REGISTERS ("[ab][cd]", "xadx", 1, 3, -1, -1, -1, -1);
/* Valid expression anchoring. */
test_match ("^a", "a");
test_fastmap ("^a", "a", 0, 0);
TEST_REGISTERS ("^a", "ax", 0, 1, -1, -1, -1, -1);
test_match ("^", "");
TEST_REGISTERS ("^", "", 0, 0, -1, -1, -1, -1);
test_match ("$", "");
TEST_REGISTERS ("$", "", 0, 0, -1, -1, -1, -1);
test_match ("a$", "a");
test_fastmap ("a$", "a", 0, 0);
TEST_REGISTERS ("a$", "xa", 1, 2, -1, -1, -1, -1);
test_match ("^ab$", "ab");
test_fastmap ("^ab$", "a", 0, 0);
TEST_REGISTERS ("^a$", "a", 0, 1, -1, -1, -1, -1);
test_fastmap ("^$", "", 0, 0);
test_match ("^$", "");
TEST_REGISTERS ("^$", "", 0, 0, -1, -1, -1, -1);
TEST_SEARCH (PARENS_TO_OPS ("(^a)"), "ab", 0, 2);
TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ba", 0, 2);
TEST_SEARCH (PARENS_TO_OPS ("^(^a)"), "ab", 0, 2);
TEST_SEARCH (PARENS_TO_OPS ("(a$)$"), "ba", 0, 2);
/* Two strings. */
test_match_2 ("ab", "a", "b");
TEST_REGISTERS_2 ("ab", "a", "b", 0, 2, -1, -1, -1, -1);
test_match_2 ("a", "", "a");
test_match_2 ("a", "a", "");
test_match_2 ("ab", "a", "b");
/* (start)pos. */
TEST_POSITIONED_MATCH ("b", "ab", 1);
/* mstop. */
TEST_TRUNCATED_MATCH ("a", "ab", 1);
/* Both basic and extended, continued; should not match. */
test_should_match = false;
/* Ordinary characters. */
test_match ("abc", "ab");
TEST_SEARCH ("c", "ab", 0, 2);
TEST_SEARCH ("c", "ab", 0, 2);
TEST_SEARCH ("c", "ab", 1, -2);
TEST_SEARCH ("c", "ab", 0, 10);
TEST_SEARCH ("c", "ab", 1, -10);
TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
TEST_SEARCH_2 ("c", "a", "b", 1, -2, 2);
TEST_SEARCH_2 ("c", "a", "b", 1, -2, 2);
TEST_SEARCH ("c", "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 236, -237);
/* Invalid use of special characters. */
invalid_pattern (REG_EESCAPE, "\\");
invalid_pattern (REG_EESCAPE, "a\\");
invalid_pattern (REG_EESCAPE, "a*\\");
/* Invalid period. */
test_match (".", "");
/* Invalid bracket expressions. */
test_match ("[ab]", "c");
test_match ("[^b]", "b");
test_match ("[^]]", "]");
invalid_pattern (REG_EBRACK, "[");
invalid_pattern (REG_EBRACK, "[^");
invalid_pattern (REG_EBRACK, "[a");
invalid_pattern (REG_EBRACK, "[]");
invalid_pattern (REG_EBRACK, "[]a");
invalid_pattern (REG_EBRACK, "a[]a");
test_match ("[:alpha:]", "q"); /* Character classes. */
test_match ("[[:alpha:]]", "2");
test_match ("[[:upper:]]", "a");
test_match ("[[:lower:]]", "A");
test_match ("[[:digit:]]", "a");
test_match ("[[:alnum:]]", ":");
test_match ("[[:xdigit:]]", "g");
test_match ("[[:space:]]", "a");
test_match ("[[:print:]]", "\177");
test_match ("[[:punct:]]", "a");
test_match ("[[:graph:]]", " ");
test_match ("[[:cntrl:]]", "a");
invalid_pattern (REG_EBRACK, "[[:");
invalid_pattern (REG_EBRACK, "[[:alpha:");
invalid_pattern (REG_EBRACK, "[[:alpha:]");
invalid_pattern (REG_ECTYPE, "[[::]]");
invalid_pattern (REG_ECTYPE, "[[:a:]]");
invalid_pattern (REG_ECTYPE, "[[:alpo:]]");
invalid_pattern (REG_ECTYPE, "[[:a:]");
test_match ("[a-z]", "2"); /* Invalid ranges. */
test_match ("[^-a]", "-");
test_match ("[^a-]", "-");
test_match ("[)-+--/]", ".");
invalid_pattern (REG_ERANGE, "[z-a]"); /* Empty */
invalid_pattern (REG_ERANGE, "[a--]"); /* Empty */
invalid_pattern (REG_ERANGE, "[[:digit:]-9]");
invalid_pattern (REG_ERANGE, "[a-[:alpha:]]");
invalid_pattern (REG_ERANGE, "[a-");
invalid_pattern (REG_EBRACK, "[a-z");
test_match ("[ab][cd]", "ae"); /* Concatenation. */
test_match ("b*c", "b"); /* Star. */
/* Invalid anchoring. */
test_match ("^", "a");
test_match ("^a", "ba");
test_match ("$", "b");
test_match ("a$", "ab");
test_match ("^$", "a");
test_match ("^ab$", "a");
TEST_SEARCH ("^a", "b\na", 0, 3);
TEST_SEARCH ("b$", "b\na", 0, 3);
test_match_2 ("^a", "\n", "a");
test_match_2 ("a$", "a", "\n");
TEST_SEARCH (PARENS_TO_OPS ("(^a)"), "ba", 0, 2);
TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ab", 0, 2);
TEST_SEARCH (PARENS_TO_OPS ("^(^a)"), "ba", 0, 2);
TEST_SEARCH (PARENS_TO_OPS ("(a$)$"), "ab", 0, 2);
printf ("\nFinished generic POSIX tests.\n");
}
/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/

440
gnu/lib/libregex/test/psx-group.c
View File

@ -1,440 +0,0 @@
/* psx-group.c: test POSIX grouping, both basic and extended. */
#include "test.h"
void
test_grouping ()
{
printf ("\nStarting POSIX grouping tests.\n");
test_should_match = true;
test_fastmap (PARENS_TO_OPS ("(a)"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a)"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("(a)"), "a", 0, 1, 0, 1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a)"), "xax", 1, 2, 1, 2, -1, -1);
test_match (PARENS_TO_OPS ("((a))"), "a");
test_fastmap (PARENS_TO_OPS ("((a))"), "a", 0, 0);
TEST_REGISTERS (PARENS_TO_OPS ("((a))"), "a", 0, 1, 0, 1, 0, 1);
TEST_REGISTERS (PARENS_TO_OPS ("((a))"), "xax", 1, 2, 1, 2, 1, 2);
test_fastmap (PARENS_TO_OPS ("(a)(b)"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a)(b)"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a)(b)"), "ab", 0, 2, 0, 1, 1, 2);
TEST_REGISTERS (PARENS_TO_OPS ("(a)(b)"), "xabx", 1, 3, 1, 2, 2, 3);
test_all_registers (PARENS_TO_OPS ("((a)(b))"), "ab", "", 0, 2, 0, 2, 0, 1,
1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
/* Test that we simply ignore groups past the 255th. */
test_match (PARENS_TO_OPS ("((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((a))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))"), "a");
/* Per POSIX D11.1, p. 125. */
test_fastmap (PARENS_TO_OPS ("(a)*"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(a)*"), "", 0, 0, -1, -1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a)*"), "aa", 0, 2, 1, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*)"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a*)"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)"), "", 0, 0, 0, 0, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*)"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a*)"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)"), "a", 0, 1, 0, 1, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*)b"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(a*)b"), "b");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)b"), "b", 0, 1, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("(a*)b"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)b"), "ab", 0, 2, 0, 1, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a*)b)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("((a*)b)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "", 0, 0, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("((a*)b)*"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "ab", 0, 2, 0, 2, 0, 1);
test_match (PARENS_TO_OPS ("((a*)b)*"), "abb");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abb", 0, 3, 2, 3, 2, 2);
test_match (PARENS_TO_OPS ("((a*)b)*"), "aabab");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "aabab", 0, 5, 3, 5, 3, 4);
test_match (PARENS_TO_OPS ("((a*)b)*"), "abbab");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abbab", 0, 5, 3, 5, 3, 4);
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "xabbabx", 0, 0, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("((a*)b)*"), "abaabaaaab");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b)*"), "abaabaaab", 0, 9, 5, 9, 5, 8);
test_fastmap (PARENS_TO_OPS ("(ab)*"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(ab)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "", 0, 0, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(ab)*"), "abab");
TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "abab", 0, 4, 2, 4, -1, -1);
/* We match the empty string here. */
TEST_REGISTERS (PARENS_TO_OPS ("(ab)*"), "xababx", 0, 0, -1, -1, -1, -1);
/* Per David A. Willcox. */
TEST_REGISTERS (PARENS_TO_OPS ("a(b*)c"), "ac", 0, 2, 1, 1, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a)*b"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(a)*b"), "b");
TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "b", 0, 1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(a)*b"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "ab", 0, 2, 0, 1, -1, -1);
test_match_2 (PARENS_TO_OPS ("(a)*b"), "a", "ab");
TEST_REGISTERS_2 (PARENS_TO_OPS ("(a)*b"), "a", "ab", 0, 3, 1, 2, -1, -1);
test_match (PARENS_TO_OPS ("(a)*b"), "aab");
TEST_REGISTERS (PARENS_TO_OPS ("(a)*b"), "aab", 0, 3, 1, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a)*a"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a)*a"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("(a)*a"), "a", 0, 1, -1, -1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "", 0, 0, 0, 0, 0, 0);
test_match (PARENS_TO_OPS ("((a*))*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("((a*))*"), "", 0, 0, 0, 0, 0, 0);
test_match (PARENS_TO_OPS ("((a*))*"), "aa");
test_fastmap (PARENS_TO_OPS ("(a*)*b"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(a*)*b"), "b");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "b", 0, 1, 0, 0, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "xbx", 1, 2, 1, 1, -1, -1);
test_match (PARENS_TO_OPS ("(a*)*b"), "ab"); /* Per rms. */
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "ab", 0, 2, 0, 1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "xabx", 1, 3, 1, 2, -1, -1);
/* Test register restores. */
test_match (PARENS_TO_OPS ("(a*)*b"), "aab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b"), "aab", 0, 3, 0, 2, -1, -1);
TEST_REGISTERS_2 (PARENS_TO_OPS ("(a*)*b"), "a", "ab", 0, 3, 0, 2, -1, -1);
/* We are matching the empty string, with backtracking. */
test_fastmap (PARENS_TO_OPS ("(a*)a"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a*)a"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)a"), "a", 0, 1, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("(a*)a"), "aa");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)a"), "aa", 0, 2, 0, 1, -1, -1);
/* We are matching the empty string, with backtracking. */
/*fails test_match (PARENS_TO_OPS ("(a*)*a"), "a"); */
test_match (PARENS_TO_OPS ("(a*)*a"), "aa");
/* Match the empty string. */
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "a", 0, 1, 0, 0, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "xax", 1, 2, 1, 1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "aa", 0, 2, 0, 1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*a"), "xaax", 1, 3, 1, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a)*ab"), "a", 0 , 0);
test_match (PARENS_TO_OPS ("(a)*ab"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a)*ab"), "ab", 0, 2, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(a)*ab"), "aab");
TEST_REGISTERS (PARENS_TO_OPS ("(a)*ab"), "aab", 0, 3, 0, 1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS("(a)*ab"), "xaabx", 1, 4, 1, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*)ab"), "a", 0 , 0);
test_match (PARENS_TO_OPS ("(a*)ab"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "ab", 0, 2, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("(a*)ab"), "aab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "aab", 0, 3, 0, 1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS ("(a*)ab"), "xaabx", 1, 4, 1, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*)*ab"), "a", 0 , 0);
test_match (PARENS_TO_OPS ("(a*)*ab"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*ab"), "ab", 0, 2, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("(a*)*ab"), "aab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*ab"), "aab", 0, 3, 0, 1, -1, -1);
TEST_REGISTERS (PARENS_TO_OPS("(a*)*ab"), "xaabx", 1, 4, 1, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*)*b*c"), "abc", 0, 0);
test_match (PARENS_TO_OPS ("(a*)*b*c"), "c");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*b*c"), "c", 0, 1, 0, 0, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a)*(ab)*"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a)*(ab)*"), "ab");
/* Register 1 doesn't match at all (vs. matching the empty string)
because of backtracking, hence -1's. */
TEST_REGISTERS (PARENS_TO_OPS ("(a)*(ab)*"), "ab", 0, 2, -1, -1, 0, 2);
test_match (PARENS_TO_OPS ("(a*)*(ab)*"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*(ab)*"), "ab", 0, 2, 0, 0, 0, 2);
test_fastmap (PARENS_TO_OPS ("(a*b)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(a*b)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "", 0, 0, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(a*b)*"), "b");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "b", 0, 1, 0, 1, -1, -1);
test_match (PARENS_TO_OPS ("(a*b)*"), "baab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*"), "baab", 0, 4, 1, 4, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*b*)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(a*b*)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "", 0, 0, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("(a*b*)*"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "a", 0, 1, 0, 1, -1, -1);
test_match (PARENS_TO_OPS ("(a*b*)*"), "ba");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "ba", 0, 2, 1, 2, -1, -1);
test_match (PARENS_TO_OPS ("(a*b*)*"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "ab", 0, 2, 0, 2, -1, -1);
test_match (PARENS_TO_OPS ("(a*b*)*"), "aa");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "aa", 0, 2, 0, 2, -1, -1);
test_match (PARENS_TO_OPS ("(a*b*)*"), "bb");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "bb", 0, 2, 0, 2, -1, -1);
test_match (PARENS_TO_OPS ("(a*b*)*"), "aba");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "aba", 0, 3, 2, 3, -1, -1);
test_match (PARENS_TO_OPS ("(a*b*)b"), "b");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)b"), "b", 0, 1, 0, 0, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a*)*(b*)*)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("((a*)*(b*)*)*"), "");
test_all_registers (PARENS_TO_OPS ("((a*)*(b*)*)*"), "", "", 0, 0, 0, 0,
0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("((a*)*(b*)*)*"), "aba");
/* Perhaps register 3 should be 3/3 here? Not sure if standard
specifies this. xx*/
test_all_registers (PARENS_TO_OPS ("((a*)*(b*)*)*"), "aba", "", 0, 3, 2, 3,
2, 3, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a*)(b*))*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("((a*)(b*))*"), "");
test_all_registers (PARENS_TO_OPS ("((a*)(b*))*"), "", "", 0, 0, 0, 0,
0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "");
test_match (PARENS_TO_OPS ("((a*)(b*))*"), "aba");
test_all_registers (PARENS_TO_OPS ("((a*)(b*))*"), "aba", "", 0, 3, 2, 3,
2, 3, 3, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a)*(b)*)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("((a)*(b)*)*"), "");
test_all_registers (PARENS_TO_OPS ("((a)*(b)*)*"), "", "", 0, 0, 0, 0,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("((a)*(b)*)*"), "aba");
test_all_registers (PARENS_TO_OPS ("((a)*(b)*)*"), "aba", "", 0, 3, 2, 3,
2, 3, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("(c(a)*(b)*)*"), "c", 0, 0);
test_match (PARENS_TO_OPS ("(c(a)*(b)*)*"), "");
test_all_registers (PARENS_TO_OPS ("(c(a)*(b)*)*"), "", "", 0, 0, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(c(a)*(b)*)*"), "c");
test_all_registers (PARENS_TO_OPS ("(c(a)*(b)*)*"), "c", "", 0, 1, 0, 1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("c((a)*(b)*)*"), "c", 0, 0);
test_match (PARENS_TO_OPS ("c((a)*(b)*)*"), "c");
test_all_registers (PARENS_TO_OPS ("c((a)*(b)*)*"), "c", "", 0, 1, 1, 1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("(((a)*(b)*)*)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(((a)*(b)*)*)*"), "");
test_all_registers (PARENS_TO_OPS ("(((a)*(b)*)*)*"), "", "", 0, 0, 0, 0,
0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "");
test_fastmap (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "c", 0, 0);
test_all_registers (PARENS_TO_OPS ("(c(c(a)*(b)*)*)*"), "", "", 0, 0, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a)*b)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("((a)*b)*"), "");
test_match (PARENS_TO_OPS ("((a)*b)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "", 0, 0, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("((a)*b)*"), "abb");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "abb", 0, 3, 2, 3, 0, 1); /*zz*/
test_match (PARENS_TO_OPS ("((a)*b)*"), "abbab");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "abbab", 0, 5, 3, 5, 3, 4);
/* We match the empty string here. */
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*"), "xabbabx", 0, 0, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*)*"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(a*)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "", 0, 0, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("(a*)*"), "aa");
TEST_REGISTERS (PARENS_TO_OPS ("(a*)*"), "aa", 0, 2, 0, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a*)*)*"), "a", 0, 0);
test_match (PARENS_TO_OPS ("((a*)*)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)*)*"), "", 0, 0, 0, 0, 0, 0);
test_match (PARENS_TO_OPS ("((a*)*)*"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)*)*"), "a", 0, 1, 0, 1, 0, 1);
test_fastmap (PARENS_TO_OPS ("(ab*)*"), "a", 0, 0);
test_match (PARENS_TO_OPS ("(ab*)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*"), "", 0, 0, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(ab*)*"), "aa");
TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*"), "aa", 0, 2, 1, 2, -1, -1);
test_fastmap (PARENS_TO_OPS ("(ab*)*c"), "ac", 0, 0);
test_match (PARENS_TO_OPS ("(ab*)*c"), "c");
TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "c", 0, 1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(ab*)*c"), "abbac");
TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "abbac", 0, 5, 3, 4, -1, -1);
test_match (PARENS_TO_OPS ("(ab*)*c"), "abac");
TEST_REGISTERS (PARENS_TO_OPS ("(ab*)*c"), "abac", 0, 4, 2, 3, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*b)*c"), "abc", 0, 0);
test_match (PARENS_TO_OPS ("(a*b)*c"), "c");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "c", 0, 1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(a*b)*c"), "bbc");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "bbc", 0, 3, 1, 2, -1, -1);
test_match (PARENS_TO_OPS ("(a*b)*c"), "aababc");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "aababc", 0, 6, 3, 5, -1, -1);
test_match (PARENS_TO_OPS ("(a*b)*c"), "aabaabc");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b)*c"), "aabaabc", 0, 7, 3, 6, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a*)b*)"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("((a*)b*)"), "");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "", 0, 0, 0, 0, 0, 0);
test_match (PARENS_TO_OPS ("((a*)b*)"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "a", 0, 1, 0, 1, 0, 1);
test_match (PARENS_TO_OPS ("((a*)b*)"), "b");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)"), "b", 0, 1, 0, 1, 0, 0);
test_fastmap (PARENS_TO_OPS ("((a)*b*)"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("((a)*b*)"), "");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "", 0, 0, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("((a)*b*)"), "a");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "a", 0, 1, 0, 1, 0, 1);
test_match (PARENS_TO_OPS ("((a)*b*)"), "b");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "b", 0, 1, 0, 1, -1, -1);
test_match (PARENS_TO_OPS ("((a)*b*)"), "ab");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)"), "ab", 0, 2, 0, 2, 0, 1);
test_fastmap (PARENS_TO_OPS ("((a*)b*)c"), "abc", 0, 0);
test_match (PARENS_TO_OPS ("((a*)b*)c"), "c");
TEST_REGISTERS (PARENS_TO_OPS ("((a*)b*)c"), "c", 0, 1, 0, 0, 0, 0);
test_fastmap (PARENS_TO_OPS ("((a)*b*)c"), "abc", 0, 0);
test_match (PARENS_TO_OPS ("((a)*b*)c"), "c");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b*)c"), "c", 0, 1, 0, 0, -1, -1);
test_fastmap (PARENS_TO_OPS ("(a*b*)*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(a*b*)*"), "");
TEST_REGISTERS (PARENS_TO_OPS ("(a*b*)*"), "", 0, 0, 0, 0, -1, -1);
test_fastmap (PARENS_TO_OPS ("(((a*))((b*)))*"), "ab", 0, 0);
test_match (PARENS_TO_OPS ("(((a*))((b*)))*"), "");
test_all_registers (PARENS_TO_OPS ("(((a*))((b*)))*"), "", "", 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("(c*((a*))d*((b*))e*)*"), "abcde", 0, 0);
test_match (PARENS_TO_OPS ("(c*((a*))d*((b*))e*)*"), "");
test_all_registers (PARENS_TO_OPS ("(c*((a*))d*((b*))e*)*"), "", "", 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1);
test_fastmap (PARENS_TO_OPS ("((a)*b)*c"), "abc", 0, 0);
test_match (PARENS_TO_OPS ("((a)*b)*c"), "c");
TEST_REGISTERS (PARENS_TO_OPS ("((a)*b)*c"), "c", 0, 1, -1, -1, -1, -1);
test_match (PARENS_TO_OPS ("(ab)*"), "");
test_match (PARENS_TO_OPS ("((ab)*)"), "");
test_match (PARENS_TO_OPS ("(((ab)*))"), "");
test_match (PARENS_TO_OPS ("((((ab)*)))"), "");
test_match (PARENS_TO_OPS ("(((((ab)*))))"), "");
test_match (PARENS_TO_OPS ("((((((ab)*)))))"), "");
test_match (PARENS_TO_OPS ("(((((((ab)*))))))"), "");
test_match (PARENS_TO_OPS ("((((((((ab)*)))))))"), "");
test_match (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "");
test_fastmap (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "a", 0, 0);
test_match (PARENS_TO_OPS ("((((((((((ab)*)))))))))"), "");
test_match (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "");
test_all_registers (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "", NULL,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1);
test_match (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "abab");
test_all_registers (PARENS_TO_OPS ("(((((((((ab)*))))))))"), "abab", NULL,
0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 2, 4);
test_should_match = false;
invalid_pattern (REG_EPAREN, PARENS_TO_OPS ("(a"));
test_match (PARENS_TO_OPS ("(a)"), "");
test_match (PARENS_TO_OPS ("((a))"), "b");
test_match (PARENS_TO_OPS ("(a)(b)"), "ac");
test_match (PARENS_TO_OPS ("(ab)*"), "acab");
test_match (PARENS_TO_OPS ("(a*)*b"), "c");
test_match (PARENS_TO_OPS ("(a*b)*"), "baa");
test_match (PARENS_TO_OPS ("(a*b)*"), "baabc");
test_match (PARENS_TO_OPS ("(a*b*)*"), "c");
test_match (PARENS_TO_OPS ("((a*)*(b*)*)*"), "c");
test_match (PARENS_TO_OPS ("(a*)*"), "ab");
test_match (PARENS_TO_OPS ("((a*)*)*"), "ab");
test_match (PARENS_TO_OPS ("((a*)*)*"), "b");
test_match (PARENS_TO_OPS ("(ab*)*"), "abc");
test_match (PARENS_TO_OPS ("(ab*)*c"), "abbad");
test_match (PARENS_TO_OPS ("(a*c)*b"), "aacaacd");
test_match (PARENS_TO_OPS ("(a*)"), "b");
test_match (PARENS_TO_OPS ("((a*)b*)"), "c");
/* Expression anchoring. */
TEST_SEARCH (PARENS_TO_OPS ("(^b)"), "ab", 0, 2);
TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ab", 0, 2);
printf ("\nFinished POSIX grouping tests.\n");
}

624
gnu/lib/libregex/test/psx-interf.c
View File

@ -1,624 +0,0 @@
/* psx-interf.c: test POSIX interface. */
#include <string.h>
#include <assert.h>
#include "test.h"
#define ERROR_CODE_LENGTH 20
#define TEST_ERRBUF_SIZE 15
void test_compile ();
/* ANSWER should be at least ERROR_CODE_LENGTH long. */
static char *
get_error_string (error_code, answer)
int error_code;
char answer[];
{
switch (error_code)
{
case 0: strcpy (answer, "No error"); break;
case REG_NOMATCH: strcpy (answer, "REG_NOMATCH"); break;
case REG_BADPAT: strcpy (answer, "REG_BADPAT"); break;
case REG_EPAREN: strcpy (answer, "REG_EPAREN"); break;
case REG_ESPACE: strcpy (answer, "REG_ESPACE"); break;
case REG_ECOLLATE: strcpy (answer, "REG_ECOLLATE"); break;
case REG_ECTYPE: strcpy (answer, "REG_ECTYPE"); break;
case REG_EESCAPE: strcpy (answer, "REG_EESCAPE"); break;
case REG_ESUBREG: strcpy (answer, "REG_ESUBREG"); break;
case REG_EBRACK: strcpy (answer, "REG_EBRACK"); break;
case REG_EBRACE: strcpy (answer, "REG_EBRACE"); break;
case REG_BADBR: strcpy (answer, "REG_BADBR"); break;
case REG_ERANGE: strcpy (answer, "REG_ERANGE"); break;
case REG_BADRPT: strcpy (answer, "REG_BADRPT"); break;
case REG_EEND: strcpy (answer, "REG_EEND"); break;
default: strcpy (answer, "Bad error code");
}
return answer;
}
/* I don't think we actually need to initialize all these things.
--karl */
void
init_pattern_buffer (pattern_buffer_ptr)
regex_t *pattern_buffer_ptr;
{
pattern_buffer_ptr->buffer = NULL;
pattern_buffer_ptr->allocated = 0;
pattern_buffer_ptr->used = 0;
pattern_buffer_ptr->fastmap = NULL;
pattern_buffer_ptr->fastmap_accurate = 0;
pattern_buffer_ptr->translate = NULL;
pattern_buffer_ptr->can_be_null = 0;
pattern_buffer_ptr->re_nsub = 0;
pattern_buffer_ptr->no_sub = 0;
pattern_buffer_ptr->not_bol = 0;
pattern_buffer_ptr->not_eol = 0;
}
void
test_compile (valid_pattern, error_code_expected, pattern,
pattern_buffer_ptr, cflags)
unsigned valid_pattern;
int error_code_expected;
const char *pattern;
regex_t *pattern_buffer_ptr;
int cflags;
{
int error_code_returned;
boolean error = false;
char errbuf[TEST_ERRBUF_SIZE];
init_pattern_buffer (pattern_buffer_ptr);
error_code_returned = regcomp (pattern_buffer_ptr, pattern, cflags);
if (valid_pattern && error_code_returned)
{
printf ("\nShould have been a valid pattern but wasn't.\n");
regerror (error_code_returned, pattern_buffer_ptr, errbuf,
TEST_ERRBUF_SIZE);
printf ("%s", errbuf);
error = true;
}
if (!valid_pattern && !error_code_returned)
{
printf ("\n\nInvalid pattern compiled as valid:\n");
error = true;
}
if (error_code_returned != error_code_expected)
{
char expected_error_string[ERROR_CODE_LENGTH];
char returned_error_string[ERROR_CODE_LENGTH];
get_error_string (error_code_expected, expected_error_string),
get_error_string (error_code_returned, returned_error_string);
printf (" Expected error code %s but got `%s'.\n",
expected_error_string, returned_error_string);
error = true;
}
if (error)
print_pattern_info (pattern, pattern_buffer_ptr);
}
static void
test_nsub (sub_count, pattern, cflags)
unsigned sub_count;
char *pattern;
int cflags;
{
regex_t pattern_buffer;
test_compile (1, 0, pattern, &pattern_buffer, cflags);
if (pattern_buffer.re_nsub != sub_count)
{
printf ("\nShould have counted %d subexpressions but counted %d \
instead.\n", sub_count, pattern_buffer.re_nsub);
}
regfree (&pattern_buffer);
}
static void
test_regcomp ()
{
regex_t pattern_buffer;
int cflags = 0;
printf ("\nStarting regcomp tests.\n");
cflags = 0;
test_compile (0, REG_ESUBREG, "\\(a\\)\\2", &pattern_buffer, cflags);
test_compile (0, REG_EBRACE, "a\\{", &pattern_buffer, cflags);
test_compile (0, REG_BADBR, "a\\{-1\\}", &pattern_buffer, cflags);
test_compile (0, REG_EBRACE, "a\\{", &pattern_buffer, cflags);
test_compile (0, REG_EBRACE, "a\\{1", &pattern_buffer, cflags);
cflags = REG_EXTENDED;
test_compile (0, REG_ECTYPE, "[[:alpo:]]", &pattern_buffer, cflags);
test_compile (0, REG_EESCAPE, "\\", &pattern_buffer, cflags);
test_compile (0, REG_EBRACK, "[a", &pattern_buffer, cflags);
test_compile (0, REG_EPAREN, "(", &pattern_buffer, cflags);
test_compile (0, REG_ERANGE, "[z-a]", &pattern_buffer, cflags);
test_nsub (1, "(a)", cflags);
test_nsub (2, "((a))", cflags);
test_nsub (2, "(a)(b)", cflags);
cflags = REG_EXTENDED | REG_NOSUB;
test_nsub (1, "(a)", cflags);
regfree (&pattern_buffer);
printf ("\nFinished regcomp tests.\n");
}
static void
fill_pmatch (pmatch, start0, end0, start1, end1, start2, end2)
regmatch_t pmatch[];
regoff_t start0, end0, start1, end1, start2, end2;
{
pmatch[0].rm_so = start0;
pmatch[0].rm_eo = end0;
pmatch[1].rm_so = start1;
pmatch[1].rm_eo = end1;
pmatch[2].rm_so = start2;
pmatch[2].rm_eo = end2;
}
static void
test_pmatch (pattern, string, nmatch, pmatch, correct_pmatch, cflags)
char *pattern;
char *string;
unsigned nmatch;
regmatch_t pmatch[];
regmatch_t correct_pmatch[];
int cflags;
{
regex_t pattern_buffer;
unsigned this_match;
int error_code_returned;
boolean found_nonmatch = false;
test_compile (1, 0, pattern, &pattern_buffer, cflags);
error_code_returned = regexec (&pattern_buffer, string, nmatch, pmatch, 0);
if (error_code_returned == REG_NOMATCH)
printf ("Matching failed in test_pmatch.\n");
else
{
for (this_match = 0; this_match < nmatch; this_match++)
{
if (pmatch[this_match].rm_so != correct_pmatch[this_match].rm_so)
{
if (found_nonmatch == false)
printf ("\n");
printf ("Pmatch start %d wrong: was %d when should have \
been %d.\n", this_match, pmatch[this_match].rm_so,
correct_pmatch[this_match].rm_so);
found_nonmatch = true;
}
if (pmatch[this_match].rm_eo != correct_pmatch[this_match].rm_eo)
{
if (found_nonmatch == false)
printf ("\n");
printf ("Pmatch end %d wrong: was %d when should have been \
%d.\n", this_match, pmatch[this_match].rm_eo,
correct_pmatch[this_match].rm_eo);
found_nonmatch = true;
}
}
if (found_nonmatch)
{
printf (" The number of pmatches requested was: %d.\n", nmatch);
printf (" The string to match was: `%s'.\n", string);
print_pattern_info (pattern, &pattern_buffer);
}
} /* error_code_returned == REG_NOMATCH */
regfree (&pattern_buffer);
}
static void
test_eflags (must_match_bol, must_match_eol, pattern, string, cflags, eflags)
boolean must_match_bol;
boolean must_match_eol;
char *pattern;
char *string;
int cflags;
int eflags;
{
regex_t pattern_buffer;
int error_code_returned;
boolean was_error = false;
test_compile (1, 0, pattern, &pattern_buffer, cflags);
error_code_returned = regexec (&pattern_buffer, string, 0, 0, eflags);
if (error_code_returned == REG_NOMATCH)
{
/* If wasn't true that both 1) the anchored part of the pattern
had to match this string and 2) this string was a proper
substring... */
if (!( (must_match_bol && (eflags & REG_NOTBOL))
|| (must_match_eol && (eflags & REG_NOTEOL)) ))
{
printf ("\nEflags test failed: didn't match when should have.\n");
was_error = true;
}
}
else /* We got a match. */
{
/* If wasn't true that either 1) the anchored part of the pattern
didn't have to match this string or 2) this string wasn't a
proper substring... */
if ((must_match_bol == (eflags & REG_NOTBOL))
|| (must_match_eol == (eflags & REG_NOTEOL)))
{
printf ("\nEflags test failed: matched when shouldn't have.\n");
was_error = true;
}
}
if (was_error)
{
printf (" The string to match was: `%s'.\n", string);
print_pattern_info (pattern, &pattern_buffer);
if (eflags & REG_NOTBOL)
printf (" The eflag REG_BOL was set.\n");
if (eflags & REG_NOTEOL)
printf (" The eflag REG_EOL was set.\n");
}
regfree (&pattern_buffer);
}
static void
test_ignore_case (should_match, pattern, string, cflags)
boolean should_match;
char *pattern;
char *string;
int cflags;
{
regex_t pattern_buffer;
int error_code_returned;
test_compile (1, 0, pattern, &pattern_buffer, cflags);
error_code_returned = regexec (&pattern_buffer, string, 0, 0, 0);
if (should_match && error_code_returned == REG_NOMATCH)
{
printf ("\nIgnore-case test failed:\n");
printf (" The string to match was: `%s'.\n", string);
print_pattern_info (pattern, &pattern_buffer);
if (cflags & REG_ICASE)
printf (" The cflag REG_ICASE was set.\n");
}
regfree (&pattern_buffer);
}
static void
test_newline (should_match, pattern, string, cflags)
boolean should_match;
char *pattern;
char *string;
int cflags;
{
regex_t pattern_buffer;
int error_code_returned;
test_compile (1, 0, pattern, &pattern_buffer, cflags);
error_code_returned = regexec (&pattern_buffer, string, 0, 0, 0);
if (should_match && error_code_returned == REG_NOMATCH)
{
printf ("\nNewline test failed:\n");
printf (" The string to match was: `%s'.\n", string);
print_pattern_info (pattern, &pattern_buffer);
if (cflags & REG_NEWLINE)
printf (" The cflag REG_NEWLINE was set.\n");
else
printf (" The cflag REG_NEWLINE wasn't set.\n");
}
regfree (&pattern_buffer);
}
static void
test_posix_match (should_match, pattern, string, cflags)
boolean should_match;
char *pattern;
char *string;
int cflags;
{
regex_t pattern_buffer;
int error_code_returned;
boolean was_error = false;
test_compile (1, 0, pattern, &pattern_buffer, cflags);
error_code_returned = regexec (&pattern_buffer, string, 0, 0, 0);
if (should_match && error_code_returned == REG_NOMATCH)
{
printf ("\nShould have matched but didn't:\n");
was_error = true;
}
else if (!should_match && error_code_returned != REG_NOMATCH)
{
printf ("\nShould not have matched but did:\n");
was_error = true;
}
if (was_error)
{
printf (" The string to match was: `%s'.\n", string);
print_pattern_info (pattern, &pattern_buffer);
}
regfree (&pattern_buffer);
}
static void
test_regexec ()
{
regmatch_t pmatch[3];
regmatch_t correct_pmatch[3];
int cflags = 0;
int eflags = 0;
printf ("\nStarting regexec tests.\n");
cflags = REG_NOSUB; /* shouldn't look at any of pmatch. */
test_pmatch ("a", "a", 0, pmatch, correct_pmatch, cflags);
/* Ask for less `pmatch'es than there are pattern subexpressions.
(Shouldn't look at pmatch[2]. */
cflags = REG_EXTENDED;
fill_pmatch (correct_pmatch, 0, 1, 0, 1, 100, 101);
test_pmatch ("((a))", "a", 2, pmatch, correct_pmatch, cflags);
/* Ask for same number of `pmatch'es as there are pattern subexpressions. */
cflags = REG_EXTENDED;
fill_pmatch(correct_pmatch, 0, 1, 0, 1, -1, -1);
test_pmatch ("(a)", "a", 2, pmatch, correct_pmatch, cflags);
/* Ask for more `pmatch'es than there are pattern subexpressions. */
cflags = REG_EXTENDED;
fill_pmatch (correct_pmatch, 0, 1, -1, -1, -1, -1);
test_pmatch ("a", "a", 2, pmatch, correct_pmatch, cflags);
eflags = REG_NOTBOL;
test_eflags (true, false, "^a", "a", cflags, eflags);
test_eflags (true, false, "(^a)", "a", cflags, eflags);
test_eflags (true, false, "a|^b", "b", cflags, eflags);
test_eflags (true, false, "^b|a", "b", cflags, eflags);
eflags = REG_NOTEOL;
test_eflags (false, true, "a$", "a", cflags, eflags);
test_eflags (false, true, "(a$)", "a", cflags, eflags);
test_eflags (false, true, "a|b$", "b", cflags, eflags);
test_eflags (false, true, "b$|a", "b", cflags, eflags);
eflags = REG_NOTBOL | REG_NOTEOL;
test_eflags (true, true, "^a$", "a", cflags, eflags);
test_eflags (true, true, "(^a$)", "a", cflags, eflags);
test_eflags (true, true, "a|(^b$)", "b", cflags, eflags);
test_eflags (true, true, "(^b$)|a", "b", cflags, eflags);
cflags = REG_ICASE;
test_ignore_case (true, "a", "a", cflags);
test_ignore_case (true, "A", "A", cflags);
test_ignore_case (true, "A", "a", cflags);
test_ignore_case (true, "a", "A", cflags);
test_ignore_case (true, "@", "@", cflags);
test_ignore_case (true, "\\[", "[", cflags);
test_ignore_case (true, "`", "`", cflags);
test_ignore_case (true, "{", "{", cflags);
test_ignore_case (true, "[!-`]", "A", cflags);
test_ignore_case (true, "[!-`]", "a", cflags);
cflags = 0;
test_ignore_case (false, "a", "a", cflags);
test_ignore_case (false, "A", "A", cflags);
test_ignore_case (false, "A", "a", cflags);
test_ignore_case (false, "a", "A", cflags);
test_ignore_case (true, "@", "@", cflags);
test_ignore_case (true, "\\[", "[", cflags);
test_ignore_case (true, "`", "`", cflags);
test_ignore_case (true, "{", "{", cflags);
test_ignore_case (true, "[!-`]", "A", cflags);
test_ignore_case (false, "[!-`]", "a", cflags);
/* Test newline stuff. */
cflags = REG_EXTENDED | REG_NEWLINE;
test_newline (true, "\n", "\n", cflags);
test_newline (true, "a\n", "a\n", cflags);
test_newline (true, "\nb", "\nb", cflags);
test_newline (true, "a\nb", "a\nb", cflags);
test_newline (false, ".", "\n", cflags);
test_newline (false, "[^a]", "\n", cflags);
test_newline (true, "\n^a", "\na", cflags);
test_newline (true, "\n(^a|b)", "\na", cflags);
test_newline (true, "a$\n", "a\n", cflags);
test_newline (true, "(a$|b)\n", "a\n", cflags);
test_newline (true, "(a$|b|c)\n", "a\n", cflags);
test_newline (true, "((a$|b|c)$)\n", "a\n", cflags);
test_newline (true, "((a$|b|c)$)\n", "b\n", cflags);
test_newline (true, "(a$|b)\n|a\n", "a\n", cflags);
test_newline (true, "^a", "\na", cflags);
test_newline (true, "a$", "a\n", cflags);
/* Now test normal behavior. */
cflags = REG_EXTENDED;
test_newline (true, "\n", "\n", cflags);
test_newline (true, "a\n", "a\n", cflags);
test_newline (true, "\nb", "\nb", cflags);
test_newline (true, "a\nb", "a\nb", cflags);
test_newline (true, ".", "\n", cflags);
test_newline (true, "[^a]", "\n", cflags);
test_newline (false, "\n^a", "\na", cflags);
test_newline (false, "a$\n", "a\n", cflags);
test_newline (false, "^a", "\na", cflags);
test_newline (false, "a$", "a\n", cflags);
/* Test that matches whole string only. */
cflags = 0;
test_posix_match (true, "a", "a", cflags);
/* Tests that match substrings. */
test_posix_match (true, "a", "ab", cflags);
test_posix_match (true, "b", "ab", cflags);
/* Test that doesn't match. */
test_posix_match (false, "a", "b", cflags);
printf ("\nFinished regexec tests.\n");
}
static void
test_error_code_message (error_code, expected_error_message)
int error_code;
char *expected_error_message;
{
char returned_error_message[TEST_ERRBUF_SIZE];
char error_code_string[ERROR_CODE_LENGTH];
size_t expected_error_message_length = strlen (expected_error_message) + 1;
size_t returned_error_message_length = regerror (error_code, 0,
returned_error_message,
TEST_ERRBUF_SIZE);
if (returned_error_message_length != expected_error_message_length)
{
printf ("\n\n Testing returned error codes, with expected error \
message `%s':\n", expected_error_message);
printf ("\n\n and returned error message `%s':\n",
returned_error_message);
printf (" should have returned a length of %d but returned %d.\n",
expected_error_message_length, returned_error_message_length);
}
if (strncmp (expected_error_message, returned_error_message,
TEST_ERRBUF_SIZE - 1) != 0)
{
get_error_string (error_code, error_code_string),
printf ("\n\n With error code %s (%d), expected error message:\n",
error_code_string, error_code);
printf (" `%s'\n", expected_error_message);
printf (" but got:\n");
printf (" `%s'\n", returned_error_message);
}
}
static void
test_error_code_allocation (error_code, expected_error_message)
int error_code;
char *expected_error_message;
{
char *returned_error_message = NULL;
char error_code_string[ERROR_CODE_LENGTH];
size_t returned_error_message_length = regerror (error_code, 0,
returned_error_message,
(size_t)0);
returned_error_message = xmalloc (returned_error_message_length + 1);
regerror (error_code, 0, returned_error_message,
returned_error_message_length);
if (strcmp (expected_error_message, returned_error_message) != 0)
{
get_error_string (error_code, error_code_string),
printf ("\n\n Testing error code allocation,\n");
printf ("with error code %s (%d), expected error message:\n",
error_code_string, error_code);
printf (" `%s'\n", expected_error_message);
printf (" but got:\n");
printf (" `%s'\n", returned_error_message);
}
}
static void
test_regerror ()
{
test_error_code_message (REG_NOMATCH, "No match");
test_error_code_message (REG_BADPAT, "Invalid regular expression");
test_error_code_message (REG_ECOLLATE, "Invalid collation character");
test_error_code_message (REG_ECTYPE, "Invalid character class name");
test_error_code_message (REG_EESCAPE, "Trailing backslash");
test_error_code_message (REG_ESUBREG, "Invalid back reference");
test_error_code_message (REG_EBRACK, "Unmatched [ or [^");
test_error_code_message (REG_EPAREN, "Unmatched ( or \\(");
test_error_code_message (REG_EBRACE, "Unmatched \\{");
test_error_code_message (REG_BADBR, "Invalid content of \\{\\}");
test_error_code_message (REG_ERANGE, "Invalid range end");
test_error_code_message (REG_ESPACE, "Memory exhausted");
test_error_code_message (REG_BADRPT, "Invalid preceding regular expression");
test_error_code_message (REG_EEND, "Premature end of regular expression");
test_error_code_message (REG_ESIZE, "Regular expression too big");
test_error_code_allocation (REG_ERPAREN, "Unmatched ) or \\)");
}
void
test_posix_interface ()
{
printf ("\nStarting POSIX interface tests.\n");
t = posix_interface_test;
test_regcomp ();
test_regexec ();
test_regerror ();
printf ("\nFinished POSIX interface tests.\n");
}

140
gnu/lib/libregex/test/psx-interv.c
View File

@ -1,140 +0,0 @@
/* psx-interv.c: test POSIX intervals, both basic and extended. */
#include "test.h"
void
test_intervals ()
{
printf ("\nStarting POSIX interval tests.\n");
test_should_match = true;
/* Valid intervals. */
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a{1,2}b)*")), "abaab");
test_fastmap (BRACES_TO_OPS (PARENS_TO_OPS ("(a{1,2}b)*")), "a", 0, 0);
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a{1,2}b)*")),
"abaab", 0, 5, 2, 5, -1, -1);
test_match (BRACES_TO_OPS ("a{0}"), "");
test_fastmap (BRACES_TO_OPS ("a{0}"), "", 0, 0);
TEST_REGISTERS (BRACES_TO_OPS ("a{0}"), "", 0, 0, -1, -1, -1, -1);
TEST_REGISTERS (BRACES_TO_OPS ("a{0}"), "x", 0, 0, -1, -1, -1, -1);
test_match (BRACES_TO_OPS ("a{0,}"), "");
test_match (BRACES_TO_OPS ("a{0,}"), "a");
test_fastmap (BRACES_TO_OPS ("a{0,}"), "a", 0, 0);
TEST_REGISTERS (BRACES_TO_OPS ("a{0,}"), "a", 0, 1, -1, -1, -1, -1);
TEST_REGISTERS (BRACES_TO_OPS ("a{0,}"), "xax", 0, 0, -1, -1, -1, -1);
test_match (BRACES_TO_OPS ("a{1}"), "a");
test_match (BRACES_TO_OPS ("a{1,}"), "a");
test_match (BRACES_TO_OPS ("a{1,}"), "aa");
test_match (BRACES_TO_OPS ("a{0,0}"), "");
test_match (BRACES_TO_OPS ("a{0,1}"), "");
test_match (BRACES_TO_OPS ("a{0,1}"), "a");
test_match (BRACES_TO_OPS ("a{1,3}"), "a");
test_match (BRACES_TO_OPS ("a{1,3}"), "aa");
test_match (BRACES_TO_OPS ("a{1,3}"), "aaa");
TEST_REGISTERS (BRACES_TO_OPS ("a{1,3}"), "aaa", 0, 3, -1, -1, -1, -1);
TEST_REGISTERS (BRACES_TO_OPS ("a{1,3}"), "xaaax", 1, 4, -1, -1, -1, -1);
test_match (BRACES_TO_OPS ("a{0,3}b"), "b");
test_match (BRACES_TO_OPS ("a{0,3}b"), "aaab");
test_fastmap (BRACES_TO_OPS ("a{0,3}b"), "ab", 0, 0);
TEST_REGISTERS (BRACES_TO_OPS ("a{0,3}b"), "b", 0, 1, -1, -1, -1, -1);
TEST_REGISTERS (BRACES_TO_OPS ("a{0,3}b"), "xbx", 1, 2, -1, -1, -1, -1);
test_match (BRACES_TO_OPS ("a{1,3}b"), "ab");
test_match (BRACES_TO_OPS ("a{1,3}b"), "aaab");
test_match (BRACES_TO_OPS ("ab{1,3}c"), "abbbc");
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a){0,3}b")), "b");
test_fastmap (BRACES_TO_OPS (PARENS_TO_OPS ("(a){0,3}b")), "ab", 0, 0);
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a){0,3}b")), "b", 0, 1, -1, -1, -1, -1);
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a){0,3}b")), "ab", 0, 2, 0, 1, -1, -1);
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a){0,3}b")), "xabx", 1, 3, 1, 2, -1, -1);
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a){1,3}b")), "ab");
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a){1,3}b")), "aaab");
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a){1,3}b")), "aaab", 0, 4, 2, 3, -1, -1);
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a){1,3}b")), "xaaabx", 1, 5, 3, 4, -1, -1);
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){0,3}b")), "aaaab");
test_fastmap (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){0,3}b")), "ab", 0, 0);
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){0,3}b")), "aaaab", 0, 5, 4, 4, -1, -1);
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,3}b")), "b");
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,3}b")), "aaab");
test_fastmap (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,3}b")), "ab", 0, 0);
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,1}ab")), "aaaab");
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,1}ab")), "aaaab", 0, 5, 0, 3, -1, -1);
test_match (BRACES_TO_OPS (".{0,3}b"), "b");
test_match (BRACES_TO_OPS (".{0,3}b"), "ab");
test_match (BRACES_TO_OPS ("[a]{0,3}b"), "b");
test_match (BRACES_TO_OPS ("[a]{0,3}b"), "aaab");
test_fastmap (BRACES_TO_OPS ("[a]{0,3}b"), "ab", 0, 0);
test_match (BRACES_TO_OPS ("[^a]{0,3}b"), "bcdb");
test_match (BRACES_TO_OPS ("ab{0,3}c"), "abbbc");
test_match (BRACES_TO_OPS ("[[:digit:]]{0,3}d"), "123d");
test_fastmap (BRACES_TO_OPS ("[[:digit:]]{0,3}d"), "0123456789d", 0, 0);
test_match (BRACES_TO_OPS ("\\*{0,3}a"), "***a");
test_match (BRACES_TO_OPS (".{0,3}b"), "aaab");
test_match (BRACES_TO_OPS ("a{0,3}a"), "aaa");
/* Backtracking. */
test_fastmap (BRACES_TO_OPS (PARENS_TO_OPS ("(a{1,})*a")), "a", 0, 0);
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a{1,})*a")), "a");
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a{1,})*a")), "a", 0, 1, -1, -1, -1, -1);
test_fastmap (BRACES_TO_OPS (PARENS_TO_OPS ("(a{2,})*aa")), "aa", 0, 0);
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a{2,})*aa")), "aa");
TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a{2,})*aa")), "aa", 0, 2, -1, -1, -1, -1);
test_match (BRACES_TO_OPS ("a{2}*"), "");
test_match (BRACES_TO_OPS ("a{2}*"), "aa");
test_match (BRACES_TO_OPS ("a{1}*"), "");
test_match (BRACES_TO_OPS ("a{1}*"), "a");
test_match (BRACES_TO_OPS ("a{1}*"), "aa");
test_match (BRACES_TO_OPS ("a{1}{1}"), "a");
test_match (BRACES_TO_OPS ("a{1}{1}{1}"), "a");
test_match (BRACES_TO_OPS ("a{1}{1}{2}"), "aa");
test_match (BRACES_TO_OPS ("a{1}{1}*"), "");
test_match (BRACES_TO_OPS ("a{1}{1}*"), "a");
test_match (BRACES_TO_OPS ("a{1}{1}*"), "aa");
test_match (BRACES_TO_OPS ("a{1}{1}*"), "aaa");
test_match (BRACES_TO_OPS ("a{1}{2}"), "aa");
test_match (BRACES_TO_OPS ("a{2}{1}"), "aa");
test_should_match = false;
test_match (BRACES_TO_OPS ("a{0}"), "a");
test_match (BRACES_TO_OPS ("a{0,}"), "b");
test_match (BRACES_TO_OPS ("a{1}"), "");
test_match (BRACES_TO_OPS ("a{1}"), "aa");
test_match (BRACES_TO_OPS ("a{1,}"), "");
test_match (BRACES_TO_OPS ("a{1,}"), "b");
test_match (BRACES_TO_OPS ("a{0,0}"), "a");
test_match (BRACES_TO_OPS ("a{0,1}"), "aa");
test_match (BRACES_TO_OPS ("a{0,1}"), "b");
test_match (BRACES_TO_OPS ("a{1,3}"), "");
test_match (BRACES_TO_OPS ("a{1,3}"), "aaaa");
test_match (BRACES_TO_OPS ("a{1,3}"), "b");
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a){1,3}b")), "aaaab");
test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,3}b")), "bb");
test_match (BRACES_TO_OPS ("[a]{0,3}"), "aaaa");
test_match (BRACES_TO_OPS ("[^a]{0,3}b"), "ab");
test_match (BRACES_TO_OPS ("ab{0,3}c"), "abababc");
test_match (BRACES_TO_OPS ("[:alpha:]{0,3}d"), "123d");
test_match (BRACES_TO_OPS ("\\^{1,3}a"), "a");
test_match (BRACES_TO_OPS (".{0,3}b"), "aaaab");
printf ("\nFinished POSIX interval tests.\n");
}

8
gnu/lib/libregex/test/regexcpp.sed
View File

@ -1,8 +0,0 @@
/;..*$/s/;/;\
/g
/{ .*$/s/{/{\
/g
/ \?[^'] /s/?/?\
/g
/ : /s/:/:\
/g

74
gnu/lib/libregex/test/syntax.skel
View File

@ -1,74 +0,0 @@
/* Print which syntax bits are set. */
#include <sys/types.h>
#include <stdio.h>
#include "regex.h"
/* It's coincidental that these two are currently the same. */
#define LONGEST_BIT_NAME "RE_UNMATCHED_RIGHT_PAREN_ORD"
#define LAST_BIT RE_UNMATCHED_RIGHT_PAREN_ORD
/* Sum of above, when printed. Assigned in main. */
static unsigned longest;
static void
test_bit (syntax, bit, name)
reg_syntax_t syntax;
unsigned bit;
char *name;
{
char padding[100], test_str[100];
int padding_count;
sprintf (test_str, "%s (%d=0x%x)", name, bit, bit);
padding_count = longest - strlen (test_str);
padding[padding_count] = 0;
while (padding_count--)
{
padding[padding_count] = ' ';
}
printf ("%s%s (%d=0x%x): %c\n",
name, padding, bit, bit, syntax & bit ? 'y' : 'n');
}
/* Macro to abbreviate the constant arguments. */
#define TEST_BIT(bit) test_bit (syntax, bit, #bit)
int
main (argc, argv)
int argc;
char *argv[];
{
reg_syntax_t syntax;
char syntax_str[1000], test_str[100];
switch (argc)
{
case 1:
printf ("Syntax? ");
scanf ("%s", syntax_str);
break;
case 2:
strcpy (syntax_str, argv[1]);
break;
default:
fprintf (stderr, "Usage: syntax [syntax].\n");
exit (1);
}
sscanf (syntax_str, "%i", &syntax);
/* Figure out the longest name, so we can align the output nicely. */
sprintf (test_str, "%s (%d=0x%x)", LONGEST_BIT_NAME, LAST_BIT, LAST_BIT);
longest = strlen (test_str);
/* [[[replace with bit tests]]] */
return 0;
}

782
gnu/lib/libregex/test/test.c
View File

@ -1,782 +0,0 @@
/* test.c: testing routines for regex.c. */
#include <assert.h>
#ifdef STDC_HEADERS
#include <stdlib.h>
#else
char *malloc ();
char *realloc ();
#endif
/* Just to be complete, we make both the system V/ANSI and the BSD
versions of the string functions available. */
#if USG || STDC_HEADERS
#include <string.h>
#define index strchr
#define rindex strrchr
#define bcmp(s1, s2, len) memcmp ((s1), (s2), (len))
#define bcopy(from, to, len) memcpy ((to), (from), (len))
#define bzero(s, len) memset ((s), 0, (len))
#else
#include <strings.h>
#define strchr index
#define strrchr rindex
#ifndef NEED_MEMORY_H
#define memcmp(s1, s2, n) bcmp ((s1), (s2), (n))
#define memcpy(to, from, len) bcopy ((from), (to), (len))
#endif
extern char *strtok ();
extern char *strstr ();
#endif /* not USG or STDC_HEADERS */
/* SunOS 4.1 declares memchr in <memory.h>, not <string.h>. I don't
understand why. */
#if NEED_MEMORY_H
#include <memory.h>
#endif
#include "test.h"
#define BYTEWIDTH 8
extern void print_partial_compiled_pattern ();
extern void print_compiled_pattern ();
extern void print_double_string ();
/* If nonzero, the results of every test are displayed. */
boolean verbose = false;
/* If nonzero, don't do register testing. */
boolean omit_register_tests = true;
/* Says whether the current test should match or fail to match. */
boolean test_should_match;
static void
set_all_registers (start0, end0, start1, end1,
start2, end2, start3, end3,
start4, end4, start5, end5,
start6, end6, start7, end7,
start8, end8, start9, end9, regs)
int start0; int end0; int start1; int end1;
int start2; int end2; int start3; int end3;
int start4; int end4; int start5; int end5;
int start6; int end6; int start7; int end7;
int start8; int end8; int start9; int end9;
struct re_registers *regs;
{
unsigned r;
regs->start[0] = start0; regs->end[0] = end0;
regs->start[1] = start1; regs->end[1] = end1;
regs->start[2] = start2; regs->end[2] = end2;
regs->start[3] = start3; regs->end[3] = end3;
regs->start[4] = start4; regs->end[4] = end4;
regs->start[5] = start5; regs->end[5] = end5;
regs->start[6] = start6; regs->end[6] = end6;
regs->start[7] = start7; regs->end[7] = end7;
regs->start[8] = start8; regs->end[8] = end8;
regs->start[9] = start9; regs->end[9] = end9;
for (r = 10; r < regs->num_regs; r++)
{
regs->start[r] = -1;
regs->end[r] = -1;
}
}
/* Return the concatenation of S1 and S2. This would be a prime place
to use varargs. */
char *
concat (s1, s2)
char *s1;
char *s2;
{
char *answer = xmalloc (strlen (s1) + strlen (s2) + 1);
strcpy (answer, s1);
strcat (answer, s2);
return answer;
}
#define OK_TO_SEARCH (nonconst_buf.fastmap_accurate && (str1 || str2))
/* We ignore the `can_be_null' argument. Should just be removed. */
void
general_test (pattern_should_be_valid, match_whole_string,
pat, str1, str2, start, range, end, correct_fastmap,
correct_regs, can_be_null)
unsigned pattern_should_be_valid;
unsigned match_whole_string;
const char *pat;
char *str1, *str2;
int start, range, end;
char *correct_fastmap;
struct re_registers *correct_regs;
int can_be_null;
{
struct re_pattern_buffer nonconst_buf;
struct re_pattern_buffer old_buf;
struct re_registers regs;
const char *r;
char fastmap[1 << BYTEWIDTH];
unsigned *regs_correct = NULL;
unsigned all_regs_correct = 1;
boolean fastmap_internal_error = false;
unsigned match = 0;
unsigned match_1 = 0;
unsigned match_2 = 0;
unsigned invalid_pattern = 0;
boolean internal_error_1 = false;
boolean internal_error_2 = false;
nonconst_buf.allocated = 8;
nonconst_buf.buffer = xmalloc (nonconst_buf.allocated);
nonconst_buf.fastmap = fastmap;
nonconst_buf.translate = 0;
assert (pat != NULL);
r = re_compile_pattern (pat, strlen (pat), &nonconst_buf);
/* Kludge: if we are doing POSIX testing, we really should have
called regcomp, not re_compile_pattern. As it happens, the only
way in which it matters is that re_compile_pattern sets the
newline/anchor field for matching (part of what happens when
REG_NEWLINE is given to regcomp). We have to undo that for POSIX
matching. */
if (t == posix_basic_test || t == posix_extended_test)
nonconst_buf.newline_anchor = 0;
invalid_pattern = r != NULL;
if (!r)
{
int r;
if (!pattern_should_be_valid)
printf ("\nShould have been an invalid pattern but wasn't:\n");
else
{
fastmap_internal_error = (re_compile_fastmap (&nonconst_buf) == -2);
if (correct_fastmap)
nonconst_buf.fastmap_accurate =
memcmp (nonconst_buf.fastmap, correct_fastmap, 1 << BYTEWIDTH)
== 0;
if (OK_TO_SEARCH)
{
old_buf = nonconst_buf;
old_buf.buffer = (unsigned char *) xmalloc (nonconst_buf.used);
memcpy (old_buf.buffer, nonconst_buf.buffer, nonconst_buf.used);
/* If only one string is null, call re_match or re_search,
which is what the user would probably do. */
if (str1 == NULL && str2 != NULL
|| str2 == NULL && str1 != NULL)
{
char *the_str = str1 == NULL ? str2 : str1;
match_1
= match_whole_string
? (r = re_match (&nonconst_buf, the_str,
strlen (the_str), start, &regs))
== strlen (the_str)
: (r = re_search (&nonconst_buf,
the_str, strlen (the_str),
start, range, &regs))
>= 0;
if (r == -2)
internal_error_1 = true;
}
else
match_1 = 1;
/* Also call with re_match_2 or re_search_2, as they might
do this. (Also can check calling with either string1
or string2 or both null.) */
if (match_whole_string)
{
r = re_match_2 (&nonconst_buf,
str1, SAFE_STRLEN (str1),
str2, SAFE_STRLEN (str2),
start, &regs, end);
match_2 = r == SAFE_STRLEN (str1) + SAFE_STRLEN (str2);
}
else
{
r = re_search_2 (&nonconst_buf,
str1, SAFE_STRLEN (str1),
str2, SAFE_STRLEN (str2),
start, range, &regs, end);
match_2 = r >= 0;
}
if (r == -2)
internal_error_2 = true;
match = match_1 & match_2;
if (correct_regs)
{
unsigned reg;
if (regs_correct != NULL)
free (regs_correct);
regs_correct
= (unsigned *) xmalloc (regs.num_regs * sizeof (unsigned));
for (reg = 0;
reg < regs.num_regs && reg < correct_regs->num_regs;
reg++)
{
regs_correct[reg]
= (regs.start[reg] == correct_regs->start[reg]
&& regs.end[reg] == correct_regs->end[reg])
#ifdef EMPTY_REGS_CONFUSED
/* There is confusion in the standard about
the registers in some patterns which can
match either the empty string or not match.
For example, in `((a*))*' against the empty
string, the two registers can either match
the empty string (be 0/0), or not match
(because of the outer *) (be -1/-1). (Or
one can do one and one can do the other.) */
|| (regs.start[reg] == -1 && regs.end[reg] == -1
&& correct_regs->start[reg]
== correct_regs->end[reg])
#endif
;
all_regs_correct &= regs_correct[reg];
}
}
} /* OK_TO_SEARCH */
}
}
if (fastmap_internal_error)
printf ("\n\nInternal error in re_compile_fastmap:");
if (internal_error_1)
{
if (!fastmap_internal_error)
printf ("\n");
printf ("\nInternal error in re_match or re_search:");
}
if (internal_error_2)
{
if (!internal_error_1)
printf ("\n");
printf ("\nInternal error in re_match_2 or re_search_2:");
}
if ((OK_TO_SEARCH && ((match && !test_should_match)
|| (!match && test_should_match))
|| (correct_regs && !all_regs_correct))
|| !nonconst_buf.fastmap_accurate
|| invalid_pattern
|| !pattern_should_be_valid
|| internal_error_1 || internal_error_2
|| verbose)
{
if (OK_TO_SEARCH && match && !test_should_match)
{
printf ("\n\nMatched but shouldn't have:\n");
if (match_1)
printf ("The single match/search succeeded.\n");
if (match_2)
printf ("The double match/search succeeded.\n");
}
else if (OK_TO_SEARCH && !match && test_should_match)
{
printf ("\n\nDidn't match but should have:\n");
if (!match_1)
printf ("The single match/search failed.\n");
if (!match_2)
printf ("The double match/search failed.\n");
}
else if (invalid_pattern && pattern_should_be_valid)
printf ("\n\nInvalid pattern (%s):\n", r);
else if (!nonconst_buf.fastmap_accurate && pattern_should_be_valid)
printf ("\n\nIncorrect fastmap:\n");
else if (OK_TO_SEARCH && correct_regs && !all_regs_correct)
printf ("\n\nNot all registers were correct:\n");
else if (verbose)
printf ("\n\nTest was OK:\n");
if ((!(invalid_pattern && !pattern_should_be_valid)) || verbose)
printf (" Pattern: `%s'.\n", pat);
if (pattern_should_be_valid || verbose
|| internal_error_1 || internal_error_2)
{
printf(" Strings: ");
printf ("`%s' and ", str1 == NULL ? "NULL" : str1);
printf ("`%s'.\n", str2 == NULL ? "NULL" : str2);
if ((OK_TO_SEARCH || verbose || internal_error_1 || internal_error_2)
&& !invalid_pattern)
{
if (memcmp (old_buf.buffer, nonconst_buf.buffer,
nonconst_buf.used) != 0
&& !invalid_pattern)
{
printf(" (%s)\n", r ? r : "Valid regular expression");
printf ("\n Compiled pattern before matching: ");
print_compiled_pattern (&old_buf);
printf ("\n Compiled pattern after matching: ");
}
else
printf ("\n Compiled pattern: ");
print_compiled_pattern (&nonconst_buf);
}
if (correct_fastmap && (!nonconst_buf.fastmap_accurate || verbose))
{
printf ("\n The fastmap should have been: ");
print_fastmap (correct_fastmap);
printf ("\n Fastmap: ");
print_fastmap (fastmap);
printf ("\n Compiled pattern before matching: ");
print_compiled_pattern (&nonconst_buf);
}
if ((!all_regs_correct || verbose) && correct_regs)
{
unsigned this_reg;
printf ("\n Incorrect registers:");
for (this_reg = 0; this_reg < regs.num_regs; this_reg++)
{
if (!regs_correct[this_reg])
{
printf ("\n Register %d's start was %2d. ", this_reg,
regs.start[this_reg]);
printf ("\tIt should have been %d.\n",
correct_regs->start[this_reg]);
printf (" Register %d's end was %2d. ", this_reg,
regs.end[this_reg]);
printf ("\tIt should have been %d.\n",
correct_regs->end[this_reg]);
}
}
}
}
}
if (nonconst_buf.buffer != NULL)
free (nonconst_buf.buffer);
if (OK_TO_SEARCH)
{
free (old_buf.buffer);
if (correct_regs)
free (regs_correct);
}
nonconst_buf.buffer = old_buf.buffer = NULL;
regs_correct = NULL;
regs.start = regs.end = NULL;
} /* general_test */
void
test_search_return (match_start_wanted, pattern, string)
int match_start_wanted;
const char *pattern;
char *string;
{
struct re_pattern_buffer buf;
char fastmap[1 << BYTEWIDTH];
const char *compile_return;
int match_start;
static num_times_called = 0;
num_times_called++;
buf.allocated = 1;
buf.buffer = xmalloc (buf.allocated);
assert (pattern != NULL);
buf.translate = 0;
compile_return = re_compile_pattern (pattern, strlen (pattern), &buf);
if (compile_return)
{
printf ("\n\nInvalid pattern in test_match_start:\n");
printf ("%s\n", compile_return);
}
else
{
buf.fastmap = fastmap;
match_start = re_search (&buf, string, strlen (string),
0, strlen (string), 0);
if (match_start != match_start_wanted)
printf ("\nWanted search to start at %d but started at %d.\n",
match_start, match_start_wanted);
}
free (buf.buffer);
buf.buffer = NULL;
}
#define SET_FASTMAP() \
{ \
unsigned this_char; \
\
memset (correct_fastmap, invert, (1 << BYTEWIDTH)); \
\
for (this_char = 0; this_char < strlen (fastmap_string); this_char++)\
correct_fastmap[fastmap_string[this_char]] = !invert; \
correct_fastmap['\n'] = match_newline; \
}
void
test_fastmap (pat, fastmap_string, invert, match_newline)
const char *pat;
char *fastmap_string;
unsigned invert;
unsigned match_newline;
{
char correct_fastmap[(1 << BYTEWIDTH)];
SET_FASTMAP ();
general_test (1, 0, pat, NULL, NULL, -1, 0, -1, correct_fastmap, 0, -1);
}
void
test_fastmap_search (pat, str, fastmap_string, invert, match_newline,
can_be_null, start0, end0)
const char *pat;
char *str;
char *fastmap_string;
unsigned invert;
unsigned match_newline;
int can_be_null;
int start0;
int end0;
{
char correct_fastmap[(1 << BYTEWIDTH)];
struct re_registers correct_regs;
correct_regs.num_regs = RE_NREGS;
correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
set_all_registers (start0, end0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, &correct_regs);
SET_FASTMAP ();
general_test (1, 0, pat, str, NULL, 0, SAFE_STRLEN (str), SAFE_STRLEN (str),
correct_fastmap, &correct_regs, can_be_null);
free (correct_regs.start);
free (correct_regs.end);
}
void
test_all_registers (pat, str1, str2,
start0, end0, start1, end1,
start2, end2, start3, end3,
start4, end4, start5, end5,
start6, end6, start7, end7,
start8, end8, start9, end9)
char *pat; char *str1; char *str2;
int start0; int end0; int start1; int end1;
int start2; int end2; int start3; int end3;
int start4; int end4; int start5; int end5;
int start6; int end6; int start7; int end7;
int start8; int end8; int start9; int end9;
{
struct re_registers correct_regs;
if (omit_register_tests) return;
correct_regs.num_regs = RE_NREGS;
correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
set_all_registers (start0, end0, start1, end1, start2, end2, start3, end3,
start4, end4, start5, end5, start6, end6, start7, end7,
start8, end8, start9, end9, &correct_regs);
general_test (1, 0, pat, str1, str2, 0,
SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
NULL, &correct_regs, -1);
free (correct_regs.start);
free (correct_regs.end);
}
void
invalid_pattern (error_code_expected, pattern)
int error_code_expected;
char *pattern;
{
regex_t pattern_buffer;
int cflags
= re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
|| re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
? REG_EXTENDED : 0;
test_compile (0, error_code_expected, pattern, &pattern_buffer, cflags);
}
void
valid_pattern (pattern)
char *pattern;
{
regex_t pattern_buffer;
int cflags
= re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
|| re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
? REG_EXTENDED : 0;
test_compile (1, 0, pattern, &pattern_buffer, cflags);
}
char *
delimiters_to_ops (source, left_delimiter, right_delimiter)
char *source;
char left_delimiter;
char right_delimiter;
{
static char *answer = NULL;
char *tmp = NULL;
boolean double_size = false;
unsigned source_char;
unsigned answer_char = 0;
assert (source != NULL);
switch (left_delimiter)
{
case '(': if (!(re_syntax_options & RE_NO_BK_PARENS))
double_size = true;
break;
case '{': if (!(re_syntax_options & RE_NO_BK_BRACES))
double_size = true;
break;
default: printf ("Found strange delimiter %c in delimiter_to_ops.\n",
left_delimiter);
printf ("The source was `%s'\n", source);
exit (0);
}
if (answer == source)
{
tmp = (char *) xmalloc (strlen (source) + 1);
strcpy (tmp, source);
source = tmp;
}
if (answer)
{
free (answer);
answer = NULL;
}
answer = (char *) xmalloc ((double_size
? strlen (source) << 1
: strlen (source))
+ 1);
if (!double_size)
strcpy (answer, source);
else
{
for (source_char = 0; source_char < strlen (source); source_char++)
{
if (source[source_char] == left_delimiter
|| source[source_char] == right_delimiter)
answer[answer_char++] = '\\';
answer[answer_char++] = source[source_char];
}
answer[answer_char] = 0;
}
return answer;
}
void
print_pattern_info (pattern, pattern_buffer_ptr)
const char *pattern;
regex_t *pattern_buffer_ptr;
{
printf (" Pattern: `%s'.\n", pattern);
printf (" Compiled pattern: ");
print_compiled_pattern (pattern_buffer_ptr);
}
void
valid_nonposix_pattern (pattern)
char *pattern;
{
struct re_pattern_buffer nonconst_buf;
nonconst_buf.allocated = 0;
nonconst_buf.buffer = NULL;
nonconst_buf.translate = NULL;
assert (pattern != NULL);
if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
{
printf ("Couldn't compile the pattern.\n");
print_pattern_info (pattern, &nonconst_buf);
}
}
void
compile_and_print_pattern (pattern)
char *pattern;
{
struct re_pattern_buffer nonconst_buf;
nonconst_buf.allocated = 0;
nonconst_buf.buffer = NULL;
if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
printf ("Couldn't compile the pattern.\n");
print_pattern_info (pattern, &nonconst_buf);
}
void
test_case_fold (pattern, string)
const char *pattern;
char* string;
{
struct re_pattern_buffer nonconst_buf;
const char *ret;
init_pattern_buffer (&nonconst_buf);
nonconst_buf.translate = upcase;
assert (pattern != NULL);
ret = re_compile_pattern (pattern, strlen (pattern), &nonconst_buf);
if (ret)
{
printf ("\nShould have been a valid pattern but wasn't.\n");
print_pattern_info (pattern, &nonconst_buf);
}
else
{
if (test_should_match
&& re_match (&nonconst_buf, string, strlen (string), 0, 0)
!= strlen (string))
{
printf ("Match failed for case fold.\n");
printf (" Pattern: `%s'.\n", pattern);
printf (" String: `%s'.\n", string == NULL ? "NULL" : string);
}
}
}
void
test_match_n_times (n, pattern, string)
unsigned n;
char* pattern;
char* string;
{
struct re_pattern_buffer buf;
const char *r;
unsigned match = 0;
unsigned this_match;
buf.allocated = 0;
buf.buffer = NULL;
buf.translate = 0;
assert (pattern != NULL);
r = re_compile_pattern (pattern, strlen (pattern), &buf);
if (r)
{
printf ("Didn't compile.\n");
printf (" Pattern: %s.\n", pattern);
}
else
{
for (this_match = 1; this_match <= n; this_match++)
match = (re_match (&buf, string, strlen (string),
0, 0)
== strlen (string));
if (match && !test_should_match)
printf ("\n\nMatched but shouldn't have:\n");
else if (!match && test_should_match)
printf ("\n\nDidn't match but should have:\n");
if ((match && !test_should_match) || (!match && test_should_match))
{
printf(" The string to match was: ");
if (string)
printf ("`%s' and ", string);
else
printf ("`'");
printf (" Pattern: %s.\n", pattern);
printf (" Compiled pattern: %s.\n", pattern);
print_compiled_pattern (&buf);
}
}
}
void
test_match_2 (pat, str1, str2)
const char *pat;
char *str1;
char *str2;
{
general_test (1, 1, pat, str1, str2, 0, 1,
SAFE_STRLEN (str1) + SAFE_STRLEN (str2), NULL, 0, -1);
}
void
test_match (pat, str)
const char *pat;
char *str;
{
test_match_2 (pat, str, NULL);
test_match_2 (pat, NULL, str);
}

141
gnu/lib/libregex/test/test.h
View File

@ -1,141 +0,0 @@
/* test.h: for Regex testing. */
#ifndef TEST_H
#define TEST_H
#include <stdio.h>
#include <assert.h>
#include <sys/types.h>
#include "regex.h"
/* A strlen that works even on a null pointer. */
#define SAFE_STRLEN(s) (s == NULL ? 0 : strlen (s))
typedef enum { false = 0, true = 1 } boolean;
extern boolean test_should_match;
extern boolean omit_register_tests;
extern void *xmalloc ();
/* Defined in upcase.c. */
extern char upcase[];
typedef enum
{
all_test,
other_test,
posix_basic_test,
posix_extended_test,
posix_interface_test,
regress_test
} test_type;
extern test_type t;
#if __STDC__
extern char *concat (char *, char *);
extern void general_test (unsigned pattern_should_be_valid,
unsigned match_whole_string,
const char *pat, char *str1, char *str2,
int start, int range, int end,
char *correct_fastmap,
struct re_registers *correct_regs, int can_be_null);
extern void init_pattern_buffer (regex_t *pattern_buffer_ptr);
extern void test_compile (unsigned valid_pattern, int error_code_expected,
const char *pattern, regex_t *pattern_buffer_ptr,
int cflags);
extern char *delimiter_to_ops (char *source, char left_delimiter,
char right_delimiter);
extern void test_search_return (int, const char *, char *);
extern void test_berk_search (const char *pattern, char *string);
extern void test_fastmap (const char *pat, char *fastmap_string, unsigned invert,
unsigned match_newline);
extern void test_fastmap_search (const char *pat, char *str, char *fastmap_string,
unsigned invert, unsigned match_newline,
int can_be_null, int start0, int end0);
extern void test_all_registers (char *pat, char *str1, char *str2,
int start0, int end0, int start1, int end1,
int start2, int end2, int start3, int end3,
int start4, int end4, int start5, int end5,
int start6, int end6, int start7, int end7,
int start8, int end8, int start9, int end9);
extern void print_pattern_info (const char *pattern, regex_t *pattern_buffer_ptr);
extern void compile_and_print_pattern (char *pattern);
extern void test_case_fold (const char *pattern, char* string);
extern void test_posix_generic ();
extern void test_grouping ();
extern void invalid_pattern (int error_code_expected, char *pattern);
extern void valid_nonposix_pattern (char *pattern);
extern void valid_pattern (char *pattern);
extern void test_match_2 (const char *pat, char *str1, char *str2);
extern void test_match (const char *pat, char *str);
#endif /* __STDC__ */
#define TEST_REGISTERS_2(pat, str1, str2, start0, end0, start1, end1, start2, end2)\
if (!omit_register_tests) \
test_all_registers (pat, str1, str2, start0, end0, start1, end1, \
start2, end2, -1, -1, -1, -1, -1, -1, -1, -1,\
-1, -1, -1, -1, -1, -1) \
#define TEST_REGISTERS(pat, str, start0, end0, start1, end1, start2, end2) \
TEST_REGISTERS_2 (pat, str, NULL, start0, end0, start1, end1, start2, end2)\
#define BRACES_TO_OPS(string) ((char *) delimiters_to_ops (string, '{', '}'))
#define PARENS_TO_OPS(string) ((char *) delimiters_to_ops (string, '(', ')'))
#define INVALID_PATTERN(pat) \
general_test (0, 0, pat, NULL, NULL, -1, 0, -1, NULL, 0, -1)
#define MATCH_SELF(p) test_match (p, p)
#define TEST_POSITIONED_MATCH(pat, str, start) \
general_test (1, 0, pat, str, NULL, start, 1, SAFE_STRLEN (str), \
NULL, 0, -1)
#define TEST_TRUNCATED_MATCH(pat, str, end) \
general_test (1, 0, pat, str, NULL, 0, 1, end, NULL, 0, -1)
#define TEST_SEARCH_2(pat, str1, str2, start, range, one_past_end) \
general_test (1, 0, pat, str1, str2, start, range, one_past_end, \
NULL, 0, -1)
#define TEST_SEARCH(pat, str, start, range) \
{ \
TEST_SEARCH_2 (pat, str, NULL, start, range, SAFE_STRLEN (str)); \
TEST_SEARCH_2 (pat, NULL, str, start, range, SAFE_STRLEN (str)); \
}
#endif /* TEST_H */
/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/

464
gnu/lib/libregex/test/tregress.c
View File

@ -1,464 +0,0 @@
/* tregress.c: reported bugs. The `t' just makes the filename not have
a common prefix with `regex.c', so completion works better. */
#include "test.h"
boolean pause_at_error = true;
char *
itoa (i)
int i;
{
char *a = xmalloc (21); /* sign + 19 digits (enough for 64 bits) + null */
sprintf (a, "%d", i);
return a;
}
static void
simple_fail (routine, pat, buf, str, ret)
const char *routine;
const char *pat;
struct re_pattern_buffer *buf;
const char *str;
char *ret;
{
fprintf (stderr, "Failed %s (return = %s).\n", routine, ret);
if (str && *str) fprintf (stderr, " String = %s\n", str);
fprintf (stderr, " Pattern = %s\n", pat);
print_compiled_pattern (buf);
if (pause_at_error)
{
fprintf (stderr, "RET to continue: ");
(void) getchar ();
}
}
/* Abbreviate the most common calls. */
static void
simple_compile (pat, buf)
const char *pat;
struct re_pattern_buffer *buf;
{
const char *ret = re_compile_pattern (pat, strlen (pat), buf);
if (ret != NULL) simple_fail ("compile", pat, buf, NULL, ret);
}
static void
simple_fastmap (pat)
const char *pat;
{
struct re_pattern_buffer buf;
char fastmap[256];
int ret;
buf.allocated = 0;
buf.buffer = buf.translate = NULL;
buf.fastmap = fastmap;
simple_compile (pat, &buf);
ret = re_compile_fastmap (&buf);
if (ret != 0) simple_fail ("fastmap compile", pat, &buf, NULL, itoa (ret));
}
#define SIMPLE_MATCH(pat, str) do_match (pat, str, strlen (str))
#define SIMPLE_NONMATCH(pat, str) do_match (pat, str, -1)
static void
do_match (pat, str, expected)
const char *pat, *str;
int expected;
{
int ret;
unsigned len;
struct re_pattern_buffer buf;
buf.allocated = 0;
buf.buffer = buf.translate = buf.fastmap = NULL;
simple_compile (pat, &buf);
len = strlen (str);
ret = re_match_2 (&buf, NULL, 0, str, len, 0, NULL, len);
if (ret != expected) simple_fail ("match", pat, &buf, str, itoa (ret));
}
static void
simple_search (pat, str, correct_startpos)
const char *pat, *str;
int correct_startpos;
{
int ret;
unsigned len;
struct re_pattern_buffer buf;
buf.allocated = 0;
buf.buffer = buf.translate = buf.fastmap = NULL;
simple_compile (pat, &buf);
len = strlen (str);
ret = re_search_2 (&buf, NULL, 0, str, len, 0, len, NULL, len);
if (ret != correct_startpos)
simple_fail ("match", pat, &buf, str, itoa (ret));
}
/* Past bugs people have reported. */
void
test_regress ()
{
extern char upcase[];
struct re_pattern_buffer buf;
unsigned len;
struct re_registers regs;
int ret;
char *fastmap = xmalloc (256);
buf.translate = NULL;
buf.fastmap = NULL;
buf.allocated = 0;
buf.buffer = NULL;
printf ("\nStarting regression tests.\n");
t = regress_test;
test_should_match = true;
re_set_syntax (RE_SYNTAX_EMACS);
/* enami@sys.ptg.sony.co.jp 10 Nov 92 15:19:02 JST */
buf.translate = upcase;
SIMPLE_MATCH ("[A-[]", "A");
buf.translate = NULL;
/* meyering@cs.utexas.edu Nov 6 22:34:41 1992 */
simple_search ("\\w+", "a", 0);
/* jimb@occs.cs.oberlin.edu 10 Sep 92 00:42:33 */
buf.translate = upcase;
SIMPLE_MATCH ("[\001-\377]", "\001");
SIMPLE_MATCH ("[\001-\377]", "a");
SIMPLE_MATCH ("[\001-\377]", "\377");
buf.translate = NULL;
/* mike@skinner.cs.uoregon.edu 1 Sep 92 01:45:22 */
SIMPLE_MATCH ("^^$", "^");
/* pclink@qld.tne.oz.au Sep 7 22:42:36 1992 */
re_set_syntax (RE_INTERVALS);
SIMPLE_MATCH ("^a\\{3\\}$", "aaa");
SIMPLE_NONMATCH ("^a\\{3\\}$", "aa");
re_set_syntax (RE_SYNTAX_EMACS);
/* pclink@qld.tne.oz.au, 31 Aug 92. (conjecture) */
re_set_syntax (RE_INTERVALS);
simple_search ("a\\{1,3\\}b", "aaab", 0);
simple_search ("a\\{1,3\\}b", "aaaab", 1);
re_set_syntax (RE_SYNTAX_EMACS);
/* trq@dionysos.thphys.ox.ac.uk, 31 Aug 92. (simplified) */
simple_fastmap ("^.*\n[ ]*");
/* wind!greg@plains.NoDak.edu, 25 Aug 92. (simplified) */
re_set_syntax (RE_INTERVALS);
SIMPLE_MATCH ("[a-zA-Z]*.\\{5\\}", "xN0000");
SIMPLE_MATCH ("[a-zA-Z]*.\\{5\\}$", "systemxN0000");
SIMPLE_MATCH ("\\([a-zA-Z]*\\).\\{5\\}$", "systemxN0000");
re_set_syntax (RE_SYNTAX_EMACS);
/* jimb, 18 Aug 92. Don't use \000, so `strlen' (in our testing
routines) will work. (This still tickles the bug jimb reported.) */
SIMPLE_MATCH ("[\001-\377]", "\001");
SIMPLE_MATCH ("[\001-\377]", "a");
SIMPLE_MATCH ("[\001-\377]", "\377");
/* jimb, 13 Aug 92. */
SIMPLE_MATCH ("[\001-\177]", "\177");
/* Tests based on bwoelfel's below. */
SIMPLE_MATCH ("\\(a\\|ab\\)*", "aab");
SIMPLE_MATCH ("\\(a\\|ab\\)+", "aab");
SIMPLE_MATCH ("\\(a*\\|ab\\)+", "aab");
SIMPLE_MATCH ("\\(a+\\|ab\\)+", "aab");
SIMPLE_MATCH ("\\(a?\\|ab\\)+", "aab");
/* bwoelfel@widget.seas.upenn.edu, 25 Jul 92. */
SIMPLE_MATCH ("^\\([ab]+\\|bc\\)+", "abc");
/* jla, 3 Jul 92. Core dump in re_search_2. */
buf.fastmap = fastmap;
buf.translate = upcase;
#define DATEDUMP_PATTERN " *[0-9]*:"
if (re_compile_pattern (DATEDUMP_PATTERN, strlen (DATEDUMP_PATTERN), &buf)
!= NULL)
printf ("date dump compile failed.\n");
regs.num_regs = 0;
regs.start = regs.end = NULL;
if (re_search_2 (&buf, NULL, 0, "Thu Jul 2 18:34:18 1992",
24, 3, 21, &regs, 24) != 10)
printf ("date dump search failed.\n");
buf.fastmap = 0;
buf.translate = 0;
/* rms, 4 Jul 1992. Pattern is much slower in Emacs 19. Fastmap
should be only a backslash. */
#define BEGINEND_PATTERN "\\(\\\\begin\\s *{\\)\\|\\(\\\\end\\s *{\\)"
test_fastmap (BEGINEND_PATTERN, "\\", false, 0);
/* kaoru@is.s.u-tokyo.ac.jp, 27 Jun 1992. Code for [a-z] (in regex.c)
should translate the whole set. */
buf.translate = upcase;
#define CASE_SET_PATTERN "[ -`]"
if (re_compile_pattern (CASE_SET_PATTERN, strlen (CASE_SET_PATTERN), &buf)
!= NULL)
printf ("case set compile failed.\n");
if (re_match_2 (&buf, "K", 1, "", 0, 0, NULL, 1) != 1)
printf ("case set match failed.\n");
#define CASE_SET_PATTERN2 "[`-|]"
if (re_compile_pattern (CASE_SET_PATTERN2, strlen (CASE_SET_PATTERN2), &buf)
!= NULL)
printf ("case set2 compile failed.\n");
if (re_match_2 (&buf, "K", 1, "", 0, 0, NULL, 1) != 1)
printf ("case set2 match failed.\n");
buf.translate = NULL;
/* jimb, 27 Jun 92. Problems with gaps in the string. */
#define GAP_PATTERN "x.*y.*z"
if (re_compile_pattern (GAP_PATTERN, strlen (GAP_PATTERN), &buf) != NULL)
printf ("gap didn't compile.\n");
if (re_match_2 (&buf, "x-", 2, "y-z-", 4, 0, NULL, 6) != 5)
printf ("gap match failed.\n");
/* jimb, 19 Jun 92. Since `beginning of word' matches at the
beginning of the string, then searching ought to find it there.
If `re_compile_fastmap' is not called, then it works ok. */
buf.fastmap = fastmap;
#define BOW_BEG_PATTERN "\\<"
if (re_compile_pattern (BOW_BEG_PATTERN, strlen (BOW_BEG_PATTERN), &buf)
!= NULL)
printf ("begword-begstring didn't compile.\n");
if (re_search (&buf, "foo", 3, 0, 3, NULL) != 0)
printf ("begword-begstring search failed.\n");
/* Same bug report, different null-matching pattern. */
#define EMPTY_ANCHOR_PATTERN "^$"
if (re_compile_pattern (EMPTY_ANCHOR_PATTERN, strlen (EMPTY_ANCHOR_PATTERN),
&buf) != NULL)
printf ("empty anchor didn't compile.\n");
if (re_search (&buf, "foo\n\nbar", 8, 0, 8, NULL) != 4)
printf ("empty anchor search failed.\n");
/* jimb@occs.cs.oberlin.edu, 21 Apr 92. After we first allocate
registers for a particular re_pattern_buffer, we might have to
reallocate more registers on subsequent calls -- and we should be
reusing the same memory. */
#define ALLOC_REG_PATTERN "\\(abc\\)"
free (buf.fastmap);
buf.fastmap = 0;
if (re_compile_pattern (ALLOC_REG_PATTERN, strlen (ALLOC_REG_PATTERN), &buf)
!= NULL)
printf ("register allocation didn't compile.\n");
if (re_match (&buf, "abc", 3, 0, &regs) != 3)
printf ("register allocation didn't match.\n");
if (regs.start[1] != 0 || regs.end[1] != 3)
printf ("register allocation reg #1 wrong.\n");
{
int *old_regstart = regs.start;
int *old_regend = regs.end;
if (re_match (&buf, "abc", 3, 0, &regs) != 3)
printf ("register reallocation didn't match.\n");
if (regs.start[1] != 0 || regs.end[1] != 3
|| old_regstart[1] != 0 || old_regend[1] != 3
|| regs.start != old_regstart || regs.end != old_regend)
printf ("register reallocation registers wrong.\n");
}
/* jskudlarek@std.MENTORG.COM, 21 Apr 92 (string-match). */
#define JSKUD_PATTERN "[^/]+\\(/[^/.]+\\)?/[0-9]+$"
if (re_compile_pattern (JSKUD_PATTERN, strlen (JSKUD_PATTERN), &buf) != NULL)
printf ("jskud test didn't compile.\n");
if (re_search (&buf, "a/1", 3, 0, 3, &regs) != 0)
printf ("jskud test didn't match.\n");
if (regs.start[1] != -1 || regs.end[1] != -1)
printf ("jskud test, reg #1 wrong.\n");
/* jla's bug (with string-match), 5 Feb 92. */
TEST_SEARCH ("\\`[ \t\n]*", "jla@challenger (Joseph Arceneaux)", 0, 100);
/* jwz@lucid.com, 8 March 1992 (re-search-forward). (His is the
second.) These are not supposed to match. */
#if 0
/* This one fails quickly, because we can change the maybe_pop_jump
from the + to a pop_failure_pop, because of the c's. */
TEST_SEARCH ("^\\(To\\|CC\\):\\([^c]*\\)+co",
"To: hbs%titanic@lucid.com (Harlan Sexton)\n\
Cc: eb@thalidomide, jlm@thalidomide\n\
Subject: Re: so is this really as horrible an idea as it seems to me?\n\
In-Reply-To: Harlan Sexton's message of Sun 8-Mar-92 11:00:06 PST <9203081900.AA24794@titanic.lucid>\n\
References: <9203080736.AA05869@thalidomide.lucid>\n\
<9203081900.AA24794@titanic.lucid>", 0, 5000);
/* This one takes a long, long time to complete, because we have to
keep the failure points around because we might backtrack. */
TEST_SEARCH ("^\\(To\\|CC\\):\\(.*\n.*\\)+co",
/* "X-Windows: The joke that kills.\n\
FCC: /u/jwz/VM/inbox\n\
From: Jamie Zawinski <jwz@lucid.com>\n\ */
"To: hbs%titanic@lucid.com (Harlan Sexton)\n\
Cc: eb@thalidomide, jlm@thalidomide\n\
Subject: Re: so is this really as horrible an idea as it seems to me?\n\
In-Reply-To: Harlan Sexton's message of Sun 8-Mar-92 11:00:06 PST <9203081900.AA24794@titanic.lucid>\n\
References: <9203080736.AA05869@thalidomide.lucid>\n\
<9203081900.AA24794@titanic.lucid>", 0, 5000);
#endif /* 0 [failed searches] */
/* macrakis' bugs. */
buf.translate = upcase; /* message of 24 Jan 91 */
if (re_compile_pattern ("[!-`]", 5, &buf) != NULL)
printf ("Range test didn't compile.\n");
if (re_match (&buf, "A", 1, 0, NULL) != 1)
printf ("Range test #1 didn't match.\n");
if (re_match (&buf, "a", 1, 0, NULL) != 1)
printf ("Range test #2 didn't match.\n");
buf.translate = 0;
#define FAO_PATTERN "\\(f\\(.\\)o\\)+"
if (re_compile_pattern (FAO_PATTERN, strlen (FAO_PATTERN), &buf) != NULL)
printf ("faofdx test didn't compile.\n");
if (re_search (&buf, "faofdx", 6, 0, 6, &regs) != 0)
printf ("faofdx test didn't match.\n");
if (regs.start[1] != 0 || regs.end[1] != 3)
printf ("faofdx test, reg #1 wrong.\n");
if (regs.start[2] != 1 || regs.end[2] != 2)
printf ("faofdx test, reg #2 wrong.\n");
TEST_REGISTERS ("\\(a\\)*a", "aaa", 0, 3, 1, 2, -1, -1);
test_fastmap ("^\\([^ \n]+:\n\\)+\\([^ \n]+:\\)", " \n", 1, 0);
/* 40 lines, 48 a's in each line. */
test_match ("^\\([^ \n]+:\n\\)+\\([^ \n]+:\\)",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n\
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:");
/* 640 a's followed by one b, twice. */
test_match ("\\(.*\\)\\1", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab");
/* 640 a's followed by two b's, twice. */
test_match ("\\(.*\\)\\1", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabb");
/* Dave G. bug: Reference to a subexpression which didn't match.
Should fail. */
re_set_syntax (RE_NO_BK_PARENS | RE_NO_BK_VBAR);
test_match ("(ooooooooooone())-annnnnnnnnnnd-(twooooooooooo\\2)",
"ooooooooooone-annnnnnnnnnnd-twooooooooooo");
test_match ("(o|t)", "o");
test_match ("(o()|t)", "o");
test_match ("(o|t)", "o");
test_match ("(ooooooooooooooo|tttttttttttttttt())", "ooooooooooooooo");
test_match ("(o|t())", "o");
test_match ("(o()|t())", "o");
test_match ("(ooooooooooooooooooooooooone()|twooooooooooooooooooooooooo())", "ooooooooooooooooooooooooone");
test_match ("(o()|t())-a-(t\\2|f\\3)", "o-a-t");
test_match ("(o()|t())-a-(t\\2|f\\3)", "t-a-f");
test_should_match = 0;
test_match ("(foo(bar)|second)\\2", "second");
test_match ("(o()|t())-a-(t\\2|f\\3)", "t-a-t");
test_match ("(o()|t())-a-(t\\2|f\\3)", "o-a-f");
re_set_syntax (RE_SYNTAX_EMACS);
test_match ("\\(foo\\(bar\\)\\|second\\)\\2", "secondbar");
test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
"one-and-four");
test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
"two-and-three");
test_should_match = 1;
re_set_syntax (RE_SYNTAX_EMACS);
test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
"one-and-three");
test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
"two-and-four");
TEST_REGISTERS (":\\(.*\\)", ":/", 0, 2, 1, 2, -1, -1);
/* Bug with `upcase' translation table, from Nico Josuttis
<nico@bredex.de> */
test_should_match = 1;
test_case_fold ("[a-a]", "a");
printf ("\nFinished regression tests.\n");
}
/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/

39
gnu/lib/libregex/test/upcase.c
View File

@ -1,39 +0,0 @@
/* Indexed by a character, gives the upper case equivalent of the
character. */
char upcase[0400] =
{ 000, 001, 002, 003, 004, 005, 006, 007,
010, 011, 012, 013, 014, 015, 016, 017,
020, 021, 022, 023, 024, 025, 026, 027,
030, 031, 032, 033, 034, 035, 036, 037,
040, 041, 042, 043, 044, 045, 046, 047,
050, 051, 052, 053, 054, 055, 056, 057,
060, 061, 062, 063, 064, 065, 066, 067,
070, 071, 072, 073, 074, 075, 076, 077,
0100, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117,
0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
0130, 0131, 0132, 0133, 0134, 0135, 0136, 0137,
0140, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117,
0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
0130, 0131, 0132, 0173, 0174, 0175, 0176, 0177,
0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217,
0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227,
0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237,
0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247,
0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317,
0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327,
0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357,
0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377
};

21
gnu/lib/libregex/test/xmalloc.c
View File

@ -1,21 +0,0 @@
#include <stdio.h>
extern char *malloc ();
#ifndef NULL
#define NULL 0
#endif
void *
xmalloc (size)
unsigned size;
{
char *new_mem = malloc (size);
if (new_mem == NULL)
{
fprintf (stderr, "xmalloc: request for %u bytes failed.\n", size);
abort ();
}
return new_mem;
}