This commit was manufactured by cvs2svn to create tag

'wxPy_2_3_3_pre'. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/wxPy_2_3_3_pre@16847 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2002-08-28 20:02:20 +00:00
82 changed files with 5621 additions and 8070 deletions
--- a/docs/html/icons/no.gif
+++ b/docs/html/icons/no.gif
--- a/docs/html/icons/somewhat.gif
+++ b/docs/html/icons/somewhat.gif
--- a/docs/html/icons/yes.gif
+++ b/docs/html/icons/yes.gif
--- a/docs/html/roadmap.htm
+++ b/docs/html/roadmap.htm
@@ -0,0 +1,165 @@
 <HTML>
 <HEAD>
  <TITLE>wxWindows Roadmap</TITLE>
 </HEAD>
 <BODY>
 <a name="top"></a>
 <font face="Arial, Lucida Sans, Helvetica">
 <table width=100% border=0 cellpadding=3 cellspacing=0>
 <tr>
 <td bgcolor="#004080" align=left height=24 background="images/bluetitlegradient.gif">
 <font size=+1 face="Arial, Lucida Sans, Helvetica" color="#FFFFFF">
 <b>wxWindows Roadmap</b>
 </font>
 </td>
 </tr>
 </table>
 <P>
 <CENTER>
 <a href="#schedule">Schedule</a> | <a href="#todo">To-Do List</a>
 </CENTER>
 <P>
 This page represents current thinking about where wxWindows is going in the near, 
 medium and long-term. It also serves as a schedule for new releases so
 that both developers and users can know what to expect when, at least approximately.<P>
 We are adopting the Linux kernel style of numbering system where odd minor version numbers are development
 versions, and even numbers are stable versions. For example, 2.1.x are development releases,
 and the next 'stable' or final release of it would be 2.2.<P>
 Bug-fix patches to the stable release (if made) then become point
 releases of 2.2 (2.2.x) while development continues with wild abandon
 on 2.3.x until the end of the next development cycle when it is
 released as 2.4.<P>
 Development versions that end up on the FTP site or CD-ROM, as opposed to remaining
 in the CVS archive, are semi-stable -- i.e. they are checked for compilation and
 run-time problems, but not as thoroughly as the stable versions.<P>
 Note that since the wxWindows effort is voluntary, these are not hard-and-fast deadlines:
 but we will endeavour to follow them as closely as possible.<P>
 Note also that the releases described are for wxGTK, wxMSW and wxMotif ports. wxMac currently follows
 its own development path but is due to merge with the main code base in November/December.
 Also, minor snapshot releases for specific platforms may be
 available at dates convenient to the developers.
 Finally, this page only shows the things which are still left to do, please
 look elsewhere to see the complete list of changes between the releases,
 including the things which are already done.
 <P>
 <CENTER>
 <HR> <FONT SIZE=+2><I><B><a name="schedule">Schedule</a></B></I></FONT> <HR>
 </CENTER>
 <P>
 <H4>Release 2.4.0 (stable)</H4>
 Release date: Summer 2002?
 <p>
 Stable version of 2.3.
 <ol>
    <li>Very important
        <ul>
            <li>wxMac: make the release together with the other ports
            <li>Fix wxStream::Eof() problems
            <li>wxGTK: GTK+ 2.0 support
        </ul>
    <li>Important
        <ul>
            <li>(Unix) implement <tt>wx-config</tt> as a version and build
            parameters independent script which would just read the
            configuration files
            <li>Finish wxFileName
            <li>Make it possible to process the key strokes portably
            <li>Add wxSemaphor, fix wxCondition
        </ul>
    <li>Nice to have
        <ul>
            <li>support for text in the wxToolBar buttons
            <li>radio buttons in wxToolBar
            <li>possibility to use individual wxUniv controls from the native
            ports
        </ul>
 </ol>
 <P>
 <H4>Release 3.0.0 (stable)</H4>
 This release should finally mark the end of support for the antiquated
 compilers without decent support of the modern C++ features such as templates,
 exceptions and namespaces. wxWindows containers should be replaced with the
 corresponding standard library classes and <tt>std::basic_string&lt;&gt;</tt>
 should be used instead of <tt>wxString</tt>.
 <p>
 <CENTER>
 <HR> <FONT SIZE=+2><I><B><a name="todo">To-Do List</a></B></I></FONT> <HR>
 </CENTER>
 <P>
 This is just a collection of the various things which it would be nice to
 include in wxWindows but which are not actively worked on right now and for
 which no schedule is fixed yet. If you're interested in helping with wxWindows
 development, one of the small projects below could be a great way to join the
 team!
 <p>
 Developers: please feel free to add to these, and delete them when they are done.
 <P>
 <B><I>General</I></B><P>
 <ul>
 <li>A rich text editor similar to GTK+ 2.0 GtkTextView but cross-platform
 <li>Extend and unify drag and drop handling (e.g. we need to specify multiple drop targets
 that can handle multiple formats).
 <li>Support for 'skins', perhaps using a set of alternative control and window classes
 written generically in wxWindows.
 <li>Serial and parallel port support.
 <li>Modem and telephony support.
 <li>Book, tutorial.
 <li>More examples.
 </ul>
 <P>
 <B><I>wxMSW</I></B><P>
 <ul>
 <li>Windows CE port.
 </ul>
 <P>
 <B><I>wxGTK</I></B><P>
 <ul>
 <li>Full Unicode support using GTK+ 2.0
 <li>Wrap the new GTK+ 2.0 GtkTextView powerful widget
 <li>GNOME/KDE integration libraries.
 </ul>
 <P>
 </BODY>
 </HTML>
--- a/docs/mac/changes.txt
+++ b/docs/mac/changes.txt
@@ -0,0 +1,4 @@
 These are the changes for wxMac 2.3.2
 - support for configuration and build under Mac OS X using the Apple Developer
  Tools
--- a/docs/symbols.txt
+++ b/docs/symbols.txt
@@ -0,0 +1,64 @@
 This is a list of preprocessor symbols used in the wxWindows source.
 GUIs:
 -----
 __X__           any X, but not GTK
 __WXMOTIF__     Motif
 __WXXT__        Xt; mutually exclusive with WX_MOTIF (?)
 __WXGTK__       GTK
 __WXGTK12__     GTK 1.2 or higher
 __WXMSW__       Any Windows
 __WXWINE__      WINE (i.e. Win32 on Unix)
 __WXMAC__       MacOS
 __WXPM__        OS/2 native Presentation Manager
 __UNIX__        any Unix
 __WINDOWS__     any Windows
 __WIN95__       GUI for Windows 95 and above; NT 4.0 and above.
 __WIN32__       WIN32 API
 __NT__          Windows NT
 __WXCURSES__    CURSES
 __WXSTUBS__     Stubbed version ('template' wxWin implementation)
 In fact, they should better all start with __WX instead of __ only.
 The only GUIs implemented for 2.0 are __WXGTK__, __WXMSW__ and __WXMOTIF__
 yet. Any new ones, please start the define with __WX.
 OSes/machines:
 __HPUX__
 __SVR4__
 __SYSV__
 __LINUX__
 __SGI__
 __ULTRIX__
 __BSD__
 __VMS__
 __SUN__         Any Sun
 __SUNOS__
 __SOLARIS__
 __ALPHA__
 __AIX__
 __DATA_GENERAL__
 __OSF__
 __FREEBSD__
 Compilers:
 ----------
 __GNUWIN32__    Gnu-Win32 compiler
 __DJGPP__       DJGPP
 __GNUG__        Gnu C++ on any platform
 __BORLANDC__    Borland C++
 __WATCOMC__     Watcom C++
 __SYMANTECC__   Symantec C++
 __VISUALC__     VC++
 __SUNCC__       Sun CC
 __XLC__         ?? compiler
 wxWindows modes:
 ----------------
 __WXDEBUG__     usage: #ifdef __WXDEBUG__ (=> debug mode, else => release)
 WXDEBUG         usage: #if DEBUG (0: release, 1: minimal debug code, ...)
--- a/samples/mdi/bitmaps/bitmap1.bmp
+++ b/samples/mdi/bitmaps/bitmap1.bmp
--- a/samples/mdi/bitmaps/bitmap2.bmp
+++ b/samples/mdi/bitmaps/bitmap2.bmp
--- a/samples/mdi/bitmaps/calc.bmp
+++ b/samples/mdi/bitmaps/calc.bmp
--- a/samples/mdi/bitmaps/copy.bmp
+++ b/samples/mdi/bitmaps/copy.bmp
--- a/samples/mdi/bitmaps/cut.bmp
+++ b/samples/mdi/bitmaps/cut.bmp
--- a/samples/mdi/bitmaps/dirplain.xbm
+++ b/samples/mdi/bitmaps/dirplain.xbm
@@ -0,0 +1,14 @@
 #define dirplain_width 32
 #define dirplain_height 32
 static char dirplain_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xfc, 0x01, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x04,
   0xfc, 0xff, 0xff, 0x1f, 0x02, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x60,
   0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60,
   0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60,
   0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60,
   0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60,
   0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60,
   0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60,
   0xfe, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0x7f};
--- a/samples/mdi/bitmaps/draft.xbm
+++ b/samples/mdi/bitmaps/draft.xbm
@@ -0,0 +1,14 @@
 #define draft_width 32
 #define draft_height 32
 static char draft_bits[] = {
   0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x20, 0x02, 0x00,
   0x00, 0x10, 0x04, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x04, 0x10, 0x00,
   0x00, 0x02, 0x20, 0x00, 0x00, 0x01, 0x40, 0x00, 0x80, 0x00, 0x80, 0x18,
   0x40, 0x00, 0x00, 0x3d, 0x20, 0x00, 0x00, 0x76, 0x10, 0x00, 0x00, 0xeb,
   0xe8, 0xff, 0xff, 0xd5, 0x44, 0x00, 0xc0, 0x6a, 0x82, 0x00, 0x60, 0x35,
   0x01, 0xf1, 0xb1, 0x5a, 0x02, 0x22, 0xfc, 0x8d, 0x04, 0x44, 0x02, 0x47,
   0x08, 0x08, 0x01, 0x22, 0x10, 0x90, 0x0c, 0x14, 0x20, 0x80, 0x13, 0x08,
   0x40, 0x70, 0xfe, 0xf1, 0x80, 0x40, 0x0c, 0xe0, 0x00, 0xb1, 0x00, 0xe0,
   0x00, 0x5b, 0x01, 0xe0, 0x00, 0xaf, 0x06, 0xe0, 0x00, 0x57, 0xfb, 0xe7,
   0x00, 0xaf, 0x11, 0xf8, 0x00, 0xde, 0x08, 0xe0, 0x00, 0x7c, 0x04, 0x00,
   0x00, 0xf8, 0x02, 0x00, 0x00, 0xf0, 0x01, 0x00};
--- a/samples/mdi/bitmaps/drawing.xbm
+++ b/samples/mdi/bitmaps/drawing.xbm
@@ -0,0 +1,14 @@
 #define drawing_width 32
 #define drawing_height 32
 static char drawing_bits[] = {
   0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x20, 0x02, 0x00,
   0x00, 0x10, 0x04, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x04, 0x10, 0x00,
   0x00, 0x82, 0x20, 0x00, 0x00, 0xc1, 0x41, 0x00, 0x80, 0xa0, 0x82, 0x00,
   0x40, 0x90, 0x04, 0x01, 0x20, 0x88, 0x08, 0x02, 0x10, 0x84, 0x10, 0x04,
   0x08, 0x42, 0x21, 0x08, 0x04, 0x21, 0x22, 0x10, 0x02, 0x11, 0xfc, 0x20,
   0x11, 0x09, 0x02, 0x41, 0x0a, 0x05, 0x01, 0x82, 0x04, 0x83, 0x0c, 0x44,
   0x08, 0x81, 0x13, 0x28, 0x10, 0x72, 0xfe, 0xf1, 0x20, 0x44, 0x0c, 0xe0,
   0x40, 0x88, 0x00, 0xe0, 0x80, 0x10, 0x01, 0xe0, 0x00, 0xa1, 0x06, 0xe0,
   0x00, 0x42, 0xf8, 0xe7, 0x00, 0x04, 0x40, 0xf8, 0x00, 0x08, 0x20, 0xe0,
   0x00, 0x10, 0x10, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x40, 0x04, 0x00,
   0x00, 0x80, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00};
--- a/samples/mdi/bitmaps/flowchar.xbm
+++ b/samples/mdi/bitmaps/flowchar.xbm
@@ -0,0 +1,14 @@
 #define flowchart_width 32
 #define flowchart_height 32
 static char flowchart_bits[] = {
   0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x20, 0x02, 0x00,
   0x00, 0x10, 0x04, 0x00, 0x00, 0x88, 0x08, 0x00, 0x00, 0x44, 0x11, 0x00,
   0x00, 0x22, 0x22, 0x00, 0x00, 0x11, 0x44, 0x00, 0x80, 0x08, 0x82, 0x00,
   0x40, 0x10, 0x01, 0x01, 0x20, 0xaa, 0x00, 0x02, 0x10, 0x45, 0x00, 0x04,
   0x88, 0x08, 0x00, 0x08, 0x44, 0x10, 0x00, 0x10, 0x22, 0x08, 0xfc, 0x20,
   0x41, 0x04, 0x02, 0x41, 0x82, 0x02, 0x01, 0x82, 0x04, 0x81, 0x0c, 0x44,
   0x08, 0x81, 0x13, 0x28, 0x10, 0x71, 0xfe, 0xf1, 0xa0, 0x4a, 0x0c, 0xe0,
   0x40, 0x9c, 0x00, 0xe0, 0x80, 0x20, 0x01, 0xe0, 0x00, 0x41, 0x06, 0xe0,
   0x00, 0x82, 0xf8, 0xe7, 0x00, 0x04, 0x41, 0xf8, 0x00, 0x08, 0x22, 0xe0,
   0x00, 0x10, 0x14, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x40, 0x04, 0x00,
   0x00, 0x80, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00};
--- a/samples/mdi/bitmaps/help.bmp
+++ b/samples/mdi/bitmaps/help.bmp
--- a/samples/mdi/bitmaps/helpcs.bmp
+++ b/samples/mdi/bitmaps/helpcs.bmp
--- a/samples/mdi/bitmaps/new.bmp
+++ b/samples/mdi/bitmaps/new.bmp
--- a/samples/mdi/bitmaps/open.bmp
+++ b/samples/mdi/bitmaps/open.bmp
--- a/samples/mdi/bitmaps/paste.bmp
+++ b/samples/mdi/bitmaps/paste.bmp
--- a/samples/mdi/bitmaps/preview.bmp
+++ b/samples/mdi/bitmaps/preview.bmp
--- a/samples/mdi/bitmaps/print.bmp
+++ b/samples/mdi/bitmaps/print.bmp
--- a/samples/mdi/bitmaps/save.bmp
+++ b/samples/mdi/bitmaps/save.bmp
--- a/samples/mdi/bitmaps/tick.bmp
+++ b/samples/mdi/bitmaps/tick.bmp
--- a/samples/mdi/bitmaps/write.xbm
+++ b/samples/mdi/bitmaps/write.xbm
@@ -0,0 +1,14 @@
 #define write_width 32
 #define write_height 32
 static char write_bits[] = {
   0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x20, 0x02, 0x00,
   0x00, 0x10, 0x04, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x04, 0x10, 0x00,
   0x00, 0x92, 0x20, 0x00, 0x00, 0x49, 0x40, 0x00, 0x80, 0x04, 0x81, 0x00,
   0x40, 0x90, 0x04, 0x01, 0x20, 0x09, 0x02, 0x02, 0x90, 0x20, 0x01, 0x04,
   0x08, 0x92, 0x00, 0x08, 0x24, 0x49, 0x00, 0x10, 0x92, 0x00, 0xfc, 0x20,
   0x49, 0x12, 0x02, 0x41, 0x22, 0x09, 0x01, 0x82, 0x84, 0x84, 0x0c, 0x44,
   0x48, 0x82, 0x13, 0x28, 0x10, 0x79, 0xfe, 0xf1, 0x20, 0x44, 0x0c, 0xe0,
   0x40, 0x82, 0x00, 0xe0, 0x80, 0x00, 0x01, 0xe0, 0x00, 0x01, 0x06, 0xe0,
   0x00, 0x02, 0xf8, 0xe7, 0x00, 0x04, 0x40, 0xf8, 0x00, 0x08, 0x20, 0xe0,
   0x00, 0x10, 0x10, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x40, 0x04, 0x00,
   0x00, 0x80, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00};
--- a/samples/minifram/bitmaps/copy.bmp
+++ b/samples/minifram/bitmaps/copy.bmp
--- a/samples/minifram/bitmaps/cut.bmp
+++ b/samples/minifram/bitmaps/cut.bmp
--- a/samples/minifram/bitmaps/help.bmp
+++ b/samples/minifram/bitmaps/help.bmp
--- a/samples/minifram/bitmaps/new.bmp
+++ b/samples/minifram/bitmaps/new.bmp
--- a/samples/minifram/bitmaps/open.bmp
+++ b/samples/minifram/bitmaps/open.bmp
--- a/samples/minifram/bitmaps/page.bmp
+++ b/samples/minifram/bitmaps/page.bmp
--- a/samples/minifram/bitmaps/paste.bmp
+++ b/samples/minifram/bitmaps/paste.bmp
--- a/samples/minifram/bitmaps/preview.bmp
+++ b/samples/minifram/bitmaps/preview.bmp
--- a/samples/minifram/bitmaps/print.bmp
+++ b/samples/minifram/bitmaps/print.bmp
--- a/samples/minifram/bitmaps/save.bmp
+++ b/samples/minifram/bitmaps/save.bmp
--- a/samples/minimal/MinimalM6.mcp
+++ b/samples/minimal/MinimalM6.mcp
--- a/samples/minimal/makemac6.mcp
+++ b/samples/minimal/makemac6.mcp
--- a/samples/treectrl/bitmaps/file1.bmp
+++ b/samples/treectrl/bitmaps/file1.bmp
--- a/samples/treectrl/bitmaps/file1.ico
+++ b/samples/treectrl/bitmaps/file1.ico
--- a/samples/treectrl/bitmaps/file2.bmp
+++ b/samples/treectrl/bitmaps/file2.bmp
--- a/samples/treectrl/bitmaps/file2.ico
+++ b/samples/treectrl/bitmaps/file2.ico
--- a/samples/treectrl/bitmaps/folder1.bmp
+++ b/samples/treectrl/bitmaps/folder1.bmp
--- a/samples/treectrl/bitmaps/folder1.ico
+++ b/samples/treectrl/bitmaps/folder1.ico
--- a/samples/treectrl/bitmaps/folder2.bmp
+++ b/samples/treectrl/bitmaps/folder2.bmp
--- a/samples/treectrl/bitmaps/folder2.ico
+++ b/samples/treectrl/bitmaps/folder2.ico
--- a/samples/treectrl/bitmaps/folder3.bmp
+++ b/samples/treectrl/bitmaps/folder3.bmp
--- a/samples/treectrl/bitmaps/folder3.ico
+++ b/samples/treectrl/bitmaps/folder3.ico
--- a/samples/wizard/Wiztest.bmp
+++ b/samples/wizard/Wiztest.bmp
--- a/src/makeg95.env
+++ b/src/makeg95.env
@@ -46,6 +46,9 @@ RM=rm -f
 # You can get a suitable cp.exe from ports/mingw32/extra.zip on the ftp site.
 COPY=cp
 # Cross compiling? Provide the target prefix (eg., i386-mingw32-)
 # CROSS=i386-mingw32-
 ########################## Compiler ##################################
 # C++ compiler
@@ -63,19 +66,19 @@ endif
 ifeq ($(MINGW32),1)
  ifneq "$(_GCC295)$(_GCC3)" ""
-    CC = gcc --pipe $(if $(_GCC3), , -fvtable-thunks)
+    CC = $(CROSS)gcc --pipe $(if $(_GCC3), , -fvtable-thunks)
  else
-    CC = gcc
+    CC = $(CROSS)gcc
  endif
 else
-  CC = gcc
+  CC = $(CROSS)gcc
 endif
 # C compiler for pure C programs
 CCC = $(CC)
 # Compiler used for LEX generated C
-CCLEX=gcc
+CCLEX=$(CROSS)gcc
 # This shouldn't be needed as make is supposed to define this
 # variable itself. Uncomment it if your make complains.
@@ -91,7 +94,7 @@ YACC=byacc
 # Settings for Cyginw/Mingw32
 # Some versions of windres cannot cope with the --preprocessor
 # option. Uncomment the RCPREPROCESSOR line below if yours can.
-RESCOMP=windres
+RESCOMP=$(CROSS)windres
 RCINPUTSWITCH=-i
 RCOUTPUTSWITCH=-o
 RCINCSWITCH=--include-dir
@@ -106,8 +109,8 @@ RCDEFSWITCH=--define
 RESFLAGS=$(RCPREPROCESSOR) $(RCINCSWITCH) $(WXDIR)/include $(RCEXTRAINC) $(RCDEFSWITCH) __WIN32__ $(RCDEFSWITCH) __WIN95__ $(RCDEFSWITCH) __GNUWIN32__
 # Needed to build a DLL if your linker does not support --shared option.
-AS = as
+AS = $(CROSS)as
-DLLTOOL = dlltool
+DLLTOOL = $(CROSS)dlltool
 ########################## Compiler flags #############################
@@ -172,9 +175,9 @@ endif
 # Options for ar archiver
 # AROPTIONS = crs # For IRIX and Solaris (both SYSVR4).
-AR = ar
+AR = $(CROSS)ar
 AROPTIONS = ruv
-RANLIB = ranlib
+RANLIB = $(CROSS)ranlib
 # Extra compiler libraries
 COMPLIBS=
--- a/src/makemac6.mcp
+++ b/src/makemac6.mcp
--- a/src/makemac7.mcp
+++ b/src/makemac7.mcp
--- a/src/regex/COPYRIGHT
+++ b/src/regex/COPYRIGHT
@@ -1,166 +1,20 @@
-This regular expression package was originally developed by Henry Spencer.
+Copyright 1992, 1993, 1994, 1997 Henry Spencer.  All rights reserved.
-It bears the following copyright notice:
+This software is not subject to any license of the American Telephone
 and Telegraph Company or of the Regents of the University of California.
-**********************************************************************
+Permission is granted to anyone to use this software for any purpose on
 any computer system, and to alter it and redistribute it, subject
 to the following restrictions:
-Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+1. The author is not responsible for the consequences of use of this
   software, no matter how awful, even if they arise from flaws in it.
-Development of this software was funded, in part, by Cray Research Inc.,
+2. The origin of this software must not be misrepresented, either by
-UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+   explicit claim or by omission.  Since few users ever read sources,
-Corporation, none of whom are responsible for the results.  The author
+   credits must appear in the documentation.
 thanks all of them. 
-Redistribution and use in source and binary forms -- with or without
+3. Altered versions must be plainly marked as such, and must not be
-modification -- are permitted for any purpose, provided that
+   misrepresented as being the original software.  Since few users
-redistributions in source form retain this entire copyright notice and
+   ever read sources, credits must appear in the documentation.
 indicate the origin and nature of any modifications.
 I'd appreciate being given credit for this package in the documentation
 of software which uses it, but that is not a requirement.
 THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 **********************************************************************
 PostgreSQL adopted the code out of Tcl 8.4.1.  Portions of regc_locale.c
 and re_syntax.n were developed by Tcl developers other than Henry; these
 files bear the Tcl copyright and license notice:
 **********************************************************************
 This software is copyrighted by the Regents of the University of
 California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
 Corporation and other parties.  The following terms apply to all files
 associated with the software unless explicitly disclaimed in
 individual files.
 The authors hereby grant permission to use, copy, modify, distribute,
 and license this software and its documentation for any purpose, provided
 that existing copyright notices are retained in all copies and that this
 notice is included verbatim in any distributions. No written agreement,
 license, or royalty fee is required for any of the authorized uses.
 Modifications to this software may be copyrighted by their authors
 and need not follow the licensing terms described here, provided that
 the new terms are clearly indicated on the first page of each file where
 they apply.
 IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
 FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
 DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
 IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
 NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
 MODIFICATIONS.
 GOVERNMENT USE: If you are acquiring this software on behalf of the
 U.S. government, the Government shall have only "Restricted Rights"
 in the software and related documentation as defined in the Federal 
 Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
 are acquiring the software on behalf of the Department of Defense, the
 software shall be classified as "Commercial Computer Software" and the
 Government shall have only "Restricted Rights" as defined in Clause
 252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the
 authors grant the U.S. Government and others acting in its behalf
 permission to use and distribute the software in accordance with the
 terms specified in this license. 
 **********************************************************************
 Subsequent modifications to the code by the PostgreSQL project follow
 the same license terms as the rest of PostgreSQL.
 (License follows)
 ****************************************************************************
 PostgreSQL Database Management System
 (formerly known as Postgres, then as Postgres95)
 Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
 Portions Copyright (c) 1994, The Regents of the University of California
 Permission to use, copy, modify, and distribute this software and its
 documentation for any purpose, without fee, and without a written agreement
 is hereby granted, provided that the above copyright notice and this
 paragraph and the following two paragraphs appear in all copies.
 IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
 LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
 DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO
 PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 ****************************************************************************
 And if that's not enough, changes made from wxWindows are put under the 
 wxWindows license:
 ****************************************************************************
                wxWindows Library Licence, Version 3
                ====================================
  Copyright (C) 1998 Julian Smart, Robert Roebling [, ...]
  Everyone is permitted to copy and distribute verbatim copies
  of this licence document, but changing it is not allowed.
                       WXWINDOWS LIBRARY LICENCE
     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  This library is free software; you can redistribute it and/or modify it
  under the terms of the GNU Library General Public Licence as published by
  the Free Software Foundation; either version 2 of the Licence, or (at
  your option) any later version.
  This library 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 Library
  General Public Licence for more details.
  You should have received a copy of the GNU Library General Public Licence
  along with this software, usually in a file named COPYING.LIB.  If not,
  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA 02111-1307 USA.
  EXCEPTION NOTICE
  1. As a special exception, the copyright holders of this library give
  permission for additional uses of the text contained in this release of
  the library as licenced under the wxWindows Library Licence, applying
  either version 3 of the Licence, or (at your option) any later version of
  the Licence as published by the copyright holders of version 3 of the
  Licence document.
  2. The exception is that you may use, copy, link, modify and distribute
  under the user's own terms, binary object code versions of works based
  on the Library.
  3. If you copy code from files distributed under the terms of the GNU
  General Public Licence or the GNU Library General Public Licence into a
  copy of this library, as this licence permits, the exception does not
  apply to the code that you add in this way.  To avoid misleading anyone as
  to the status of such modified files, you must delete this exception
  notice from such code and/or adjust the licensing conditions notice
  accordingly.
  4. If you write modifications of your own for this library, it is your
  choice whether to permit this exception to apply to your modifications. 
  If you do not wish that, you must delete the exception notice from such
  code and/or adjust the licensing conditions notice accordingly.
 ****************************************************************************
 4. This notice may not be removed or altered.
--- a/src/regex/Makefile
+++ b/src/regex/Makefile
@@ -1,28 +1,130 @@
-#-------------------------------------------------------------------------
+# You probably want to take -DREDEBUG out of CFLAGS, and put something like
-#
+# -O in, *after* testing (-DREDEBUG strengthens testing by enabling a lot of
-# Makefile--
+# internal assertion checking and some debugging facilities).
-#    Makefile for backend/regex
+# Put -Dconst= in for a pre-ANSI compiler.
-#
+# Do not take -DPOSIX_MISTAKE out.
-# IDENTIFICATION
+# REGCFLAGS isn't important to you (it's for my use in some special contexts).
-#    $Header: /projects/cvsroot/pgsql-server/src/backend/regex/Makefile,v 1.20 2003/02/05 17:41:32 tgl Exp $
+CFLAGS=-I. -DPOSIX_MISTAKE -DREDEBUG $(REGCFLAGS)
 #
 #-------------------------------------------------------------------------
-subdir = src/backend/regex
+# If you have a pre-ANSI compiler, put -o into MKHFLAGS.  If you want
-top_builddir = ../../..
+# the Berkeley __P macro, put -b in.
-include $(top_builddir)/src/Makefile.global
+MKHFLAGS=
-OBJS = regcomp.o regerror.o regexec.o regfree.o
+# Flags for linking but not compiling, if any.
 LDFLAGS=
-all: SUBSYS.o
+# Extra libraries for linking, if any.
 LIBS=
-SUBSYS.o: $(OBJS)
+# Internal stuff, should not need changing.
-	$(LD) $(LDREL) $(LDOUT) SUBSYS.o $(OBJS)
+OBJPRODN=regcomp.o regexec.o regerror.o regfree.o
 OBJS=$(OBJPRODN) split.o debug.o re_main.o
 H=cclass.h cname.h regex2.h utils.h
 REGSRC=regcomp.c regerror.c regexec.c regfree.c
 ALLSRC=$(REGSRC) engine.c debug.c re_main.c split.c
-# mark inclusion dependencies between .c files explicitly
+# Stuff that matters only if you're trying to lint the package.
-regcomp.o: regcomp.c regc_lex.c regc_color.c regc_nfa.c regc_cvec.c regc_locale.c
+LINTFLAGS=-I. -Dstatic= -Dconst= -DREDEBUG
 LINTC=regcomp.c regexec.c regerror.c regfree.c debug.c re_main.c
 JUNKLINT=possible pointer alignment|null effect
-regexec.o: regexec.c rege_dfa.c
+# arrangements to build forward-reference header files
 .SUFFIXES:	.ih .h
 .c.ih:
 	sh ./mkh $(MKHFLAGS) -p $< >$@
-clean: 
+default:	r
-	rm -f SUBSYS.o $(OBJS)
+
 lib:	purge $(OBJPRODN)
 	rm -f libregex.a
 	ar crv libregex.a $(OBJPRODN)
 purge:
 	rm -f *.o
 # stuff to build regex.h
 REGEXH=regex.h
 REGEXHSRC=regex2.h $(REGSRC)
 $(REGEXH):	$(REGEXHSRC) mkh
 	sh ./mkh $(MKHFLAGS) -i _REGEX_H_ $(REGEXHSRC) >regex.tmp
 	cmp -s regex.tmp regex.h 2>/dev/null || cp regex.tmp regex.h
 	rm -f regex.tmp
 # dependencies
 $(OBJPRODN) debug.o:	utils.h regex.h regex2.h
 regcomp.o:	cclass.h cname.h regcomp.ih
 regexec.o:	engine.c engine.ih
 regerror.o:	regerror.ih
 debug.o:	debug.ih
 re_main.o:	re_main.ih
 # tester
 re:	$(OBJS)
 	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
 # regression test
 r:	re tests
 	./re <tests
 	./re -el <tests
 	./re -er <tests
 # 57 variants, and other stuff, for development use -- not useful to you
 ra:	./re tests
 	-./re <tests
 	-./re -el <tests
 	-./re -er <tests
 rx:	./re tests
 	./re -x <tests
 	./re -x -el <tests
 	./re -x -er <tests
 t:	./re tests
 	-time ./re <tests
 	-time ./re -cs <tests
 	-time ./re -el <tests
 	-time ./re -cs -el <tests
 l:	$(LINTC)
 	lint $(LINTFLAGS) -h $(LINTC) 2>&1 | egrep -v '$(JUNKLINT)' | tee lint
 fullprint:
 	ti README WHATSNEW notes todo | list
 	ti *.h | list
 	list *.c
 	list regex.3 regex.7
 print:
 	ti README WHATSNEW notes todo | list
 	ti *.h | list
 	list reg*.c engine.c
 mf.tmp:	Makefile
 	sed '/^REGEXH=/s/=.*/=regex.h/' Makefile | sed '/#DEL$$/d' >$@
 DTRH=cclass.h cname.h regex2.h utils.h
 PRE=COPYRIGHT README WHATSNEW
 POST=mkh regex.3 regex.7 tests $(DTRH) $(ALLSRC) fake/*.[ch]
 FILES=$(PRE) Makefile $(POST)
 DTR=$(PRE) Makefile=mf.tmp $(POST)
 dtr:	$(FILES) mf.tmp
 	makedtr $(DTR) >$@
 	rm mf.tmp
 cio:	$(FILES)
 	cio $(FILES)
 rdf:	$(FILES)
 	rcsdiff -c $(FILES) 2>&1 | p
 # various forms of cleanup
 tidy:
 	rm -f junk* core core.* *.core dtr *.tmp lint
 clean:	tidy
 	rm -f *.o *.s *.ih re libregex.a
 # don't do this one unless you know what you're doing
 spotless:	clean
 	rm -f mkh regex.h
--- a/src/regex/cclass.h
+++ b/src/regex/cclass.h
@@ -0,0 +1,20 @@
 /* character-class table */
 static struct cclass {
 	char *name;
 	char *chars;
 	char *multis;
 } cclasses[] = {
 	{ "alnum",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",				"" },
 	{ "alpha",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", "" },
 	{ "blank",	" \t",		"" },
 	{ "cntrl",	"\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177",	"" },
 	{ "digit",	"0123456789",	"" },
 	{ "graph",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", "" },
 	{ "lower",	"abcdefghijklmnopqrstuvwxyz", "" },
 	{ "print",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ", "" },
 	{ "punct",	"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", "" },
 	{ "space",	"\t\n\v\f\r ",	"" },
 	{ "upper",	"ABCDEFGHIJKLMNOPQRSTUVWXYZ", "" },
 	{ "xdigit",	"0123456789ABCDEFabcdef", "" },
    { NULL,		0,		"" }
 };
--- a/src/regex/cname.h
+++ b/src/regex/cname.h
@@ -0,0 +1,102 @@
 /* character-name table */
 static struct cname {
 	char *name;
 	char code;
 } cnames[] = {
 	{ "NUL",	'\0' },
 	{ "SOH",	'\001' },
 	{ "STX",	'\002' },
 	{ "ETX",	'\003' },
 	{ "EOT",	'\004' },
 	{ "ENQ",	'\005' },
 	{ "ACK",	'\006' },
 	{ "BEL",	'\007' },
 	{ "alert",	'\007' },
 	{ "BS",		'\010' },
 	{ "backspace",	'\b' },
 	{ "HT",		'\011' },
 	{ "tab",		'\t' },
 	{ "LF",		'\012' },
 	{ "newline",	'\n' },
 	{ "VT",		'\013' },
 	{ "vertical-tab",	'\v' },
 	{ "FF",		'\014' },
 	{ "form-feed",	'\f' },
 	{ "CR",		'\015' },
 	{ "carriage-return",	'\r' },
 	{ "SO",	'\016' },
 	{ "SI",	'\017' },
 	{ "DLE",	'\020' },
 	{ "DC1",	'\021' },
 	{ "DC2",	'\022' },
 	{ "DC3",	'\023' },
 	{ "DC4",	'\024' },
 	{ "NAK",	'\025' },
 	{ "SYN",	'\026' },
 	{ "ETB",	'\027' },
 	{ "CAN",	'\030' },
 	{ "EM",	'\031' },
 	{ "SUB",	'\032' },
 	{ "ESC",	'\033' },
 	{ "IS4",	'\034' },
 	{ "FS",	'\034' },
 	{ "IS3",	'\035' },
 	{ "GS",	'\035' },
 	{ "IS2",	'\036' },
 	{ "RS",	'\036' },
 	{ "IS1",	'\037' },
 	{ "US",	'\037' },
 	{ "space",		' ' },
 	{ "exclamation-mark",	'!' },
 	{ "quotation-mark",	'"' },
 	{ "number-sign",		'#' },
 	{ "dollar-sign",		'$' },
 	{ "percent-sign",		'%' },
 	{ "ampersand",		'&' },
 	{ "apostrophe",		'\'' },
 	{ "left-parenthesis",	'(' },
 	{ "right-parenthesis",	')' },
 	{ "asterisk",	'*' },
 	{ "plus-sign",	'+' },
 	{ "comma",	',' },
 	{ "hyphen",	'-' },
 	{ "hyphen-minus",	'-' },
 	{ "period",	'.' },
 	{ "full-stop",	'.' },
 	{ "slash",	'/' },
 	{ "solidus",	'/' },
 	{ "zero",		'0' },
 	{ "one",		'1' },
 	{ "two",		'2' },
 	{ "three",	'3' },
 	{ "four",		'4' },
 	{ "five",		'5' },
 	{ "six",		'6' },
 	{ "seven",	'7' },
 	{ "eight",	'8' },
 	{ "nine",		'9' },
 	{ "colon",	':' },
 	{ "semicolon",	';' },
 	{ "less-than-sign",	'<' },
 	{ "equals-sign",		'=' },
 	{ "greater-than-sign",	'>' },
 	{ "question-mark",	'?' },
 	{ "commercial-at",	'@' },
 	{ "left-square-bracket",	'[' },
 	{ "backslash",		'\\' },
 	{ "reverse-solidus",	'\\' },
 	{ "right-square-bracket",	']' },
 	{ "circumflex",		'^' },
 	{ "circumflex-accent",	'^' },
 	{ "underscore",		'_' },
 	{ "low-line",		'_' },
 	{ "grave-accent",		'`' },
 	{ "left-brace",		'{' },
 	{ "left-curly-bracket",	'{' },
 	{ "vertical-line",	'|' },
 	{ "right-brace",		'}' },
 	{ "right-curly-bracket",	'}' },
 	{ "tilde",		'~' },
 	{ "DEL",	'\177' },
 	{ NULL,	0 },
 };
--- a/src/regex/debug.c
+++ b/src/regex/debug.c
@@ -0,0 +1,242 @@
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include "regex.h"
 #include "utils.h"
 #include "regex2.h"
 #include "debug.ih"
 /*
 - regprint - print a regexp for debugging
 == void regprint(regex_t *r, FILE *d);
 */
 void
 regprint(r, d)
 regex_t *r;
 FILE *d;
 {
 	register struct re_guts *g = r->re_g;
 	register int i;
 	register int c;
 	register int last;
 	int nincat[NC];
 	fprintf(d, "%ld states, %d categories", (long)g->nstates,
 							g->ncategories);
 	fprintf(d, ", first %ld last %ld", (long)g->firststate,
 						(long)g->laststate);
 	if (g->iflags&USEBOL)
 		fprintf(d, ", USEBOL");
 	if (g->iflags&USEEOL)
 		fprintf(d, ", USEEOL");
 	if (g->iflags&BAD)
 		fprintf(d, ", BAD");
 	if (g->nsub > 0)
 		fprintf(d, ", nsub=%ld", (long)g->nsub);
 	if (g->must != NULL)
 		fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
 								g->must);
 	if (g->backrefs)
 		fprintf(d, ", backrefs");
 	if (g->nplus > 0)
 		fprintf(d, ", nplus %ld", (long)g->nplus);
 	fprintf(d, "\n");
 	s_print(g, d);
 	for (i = 0; i < g->ncategories; i++) {
 		nincat[i] = 0;
 		for (c = CHAR_MIN; c <= CHAR_MAX; c++)
 			if (g->categories[c] == i)
 				nincat[i]++;
 	}
 	fprintf(d, "cc0#%d", nincat[0]);
 	for (i = 1; i < g->ncategories; i++)
 		if (nincat[i] == 1) {
 			for (c = CHAR_MIN; c <= CHAR_MAX; c++)
 				if (g->categories[c] == i)
 					break;
 			fprintf(d, ", %d=%s", i, regchar(c));
 		}
 	fprintf(d, "\n");
 	for (i = 1; i < g->ncategories; i++)
 		if (nincat[i] != 1) {
 			fprintf(d, "cc%d\t", i);
 			last = -1;
 			for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)	/* +1 does flush */
 				if (c <= CHAR_MAX && g->categories[c] == i) {
 					if (last < 0) {
 						fprintf(d, "%s", regchar(c));
 						last = c;
 					}
 				} else {
 					if (last >= 0) {
 						if (last != c-1)
 							fprintf(d, "-%s",
 								regchar(c-1));
 						last = -1;
 					}
 				}
 			fprintf(d, "\n");
 		}
 }
 /*
 - s_print - print the strip for debugging
 == static void s_print(register struct re_guts *g, FILE *d);
 */
 static void
 s_print(g, d)
 register struct re_guts *g;
 FILE *d;
 {
 	register sop *s;
 	register cset *cs;
 	register int i;
 	register int done = 0;
 	register sop opnd;
 	register int col = 0;
 	register int last;
 	register sopno offset = 2;
 #	define	GAP()	{	if (offset % 5 == 0) { \
 					if (col > 40) { \
 						fprintf(d, "\n\t"); \
 						col = 0; \
 					} else { \
 						fprintf(d, " "); \
 						col++; \
 					} \
 				} else \
 					col++; \
 				offset++; \
 			}
 	if (OP(g->strip[0]) != OEND)
 		fprintf(d, "missing initial OEND!\n");
 	for (s = &g->strip[1]; !done; s++) {
 		opnd = OPND(*s);
 		switch (OP(*s)) {
 		case OEND:
 			fprintf(d, "\n");
 			done = 1;
 			break;
 		case OCHAR:
 			if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
 				fprintf(d, "\\%c", (char)opnd);
 			else
 				fprintf(d, "%s", regchar((char)opnd));
 			break;
 		case OBOL:
 			fprintf(d, "^");
 			break;
 		case OEOL:
 			fprintf(d, "$");
 			break;
 		case OBOW:
 			fprintf(d, "\\{");
 			break;
 		case OEOW:
 			fprintf(d, "\\}");
 			break;
 		case OANY:
 			fprintf(d, ".");
 			break;
 		case OANYOF:
 			fprintf(d, "[(%ld)", (long)opnd);
 			cs = &g->sets[opnd];
 			last = -1;
 			for (i = 0; i < g->csetsize+1; i++)	/* +1 flushes */
 				if (CHIN(cs, i) && i < g->csetsize) {
 					if (last < 0) {
 						fprintf(d, "%s", regchar(i));
 						last = i;
 					}
 				} else {
 					if (last >= 0) {
 						if (last != i-1)
 							fprintf(d, "-%s",
 								regchar(i-1));
 						last = -1;
 					}
 				}
 			fprintf(d, "]");
 			break;
 		case OBACK_:
 			fprintf(d, "(\\<%ld>", (long)opnd);
 			break;
 		case O_BACK:
 			fprintf(d, "<%ld>\\)", (long)opnd);
 			break;
 		case OPLUS_:
 			fprintf(d, "(+");
 			if (OP(*(s+opnd)) != O_PLUS)
 				fprintf(d, "<%ld>", (long)opnd);
 			break;
 		case O_PLUS:
 			if (OP(*(s-opnd)) != OPLUS_)
 				fprintf(d, "<%ld>", (long)opnd);
 			fprintf(d, "+)");
 			break;
 		case OQUEST_:
 			fprintf(d, "(?");
 			if (OP(*(s+opnd)) != O_QUEST)
 				fprintf(d, "<%ld>", (long)opnd);
 			break;
 		case O_QUEST:
 			if (OP(*(s-opnd)) != OQUEST_)
 				fprintf(d, "<%ld>", (long)opnd);
 			fprintf(d, "?)");
 			break;
 		case OLPAREN:
 			fprintf(d, "((<%ld>", (long)opnd);
 			break;
 		case ORPAREN:
 			fprintf(d, "<%ld>))", (long)opnd);
 			break;
 		case OCH_:
 			fprintf(d, "<");
 			if (OP(*(s+opnd)) != OOR2)
 				fprintf(d, "<%ld>", (long)opnd);
 			break;
 		case OOR1:
 			if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
 				fprintf(d, "<%ld>", (long)opnd);
 			fprintf(d, "|");
 			break;
 		case OOR2:
 			fprintf(d, "|");
 			if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
 				fprintf(d, "<%ld>", (long)opnd);
 			break;
 		case O_CH:
 			if (OP(*(s-opnd)) != OOR1)
 				fprintf(d, "<%ld>", (long)opnd);
 			fprintf(d, ">");
 			break;
 		default:
 			fprintf(d, "!%d(%d)!", OP(*s), opnd);
 			break;
 		}
 		if (!done)
 			GAP();
 	}
 }
 /*
 - regchar - make a character printable
 == static char *regchar(int ch);
 */
 static char *			/* -> representation */
 regchar(ch)
 int ch;
 {
 	static char buf[10];
 	if (isprint(ch) || ch == ' ')
 		sprintf(buf, "%c", ch);
 	else
 		sprintf(buf, "\\%o", ch);
 	return(buf);
 }
--- a/src/regex/engine.c
+++ b/src/regex/engine.c
--- a/src/regex/re_main.c
+++ b/src/regex/re_main.c
@@ -0,0 +1,510 @@
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <regex.h>
 #include <assert.h>
 #include "main.ih"
 char *progname;
 int debug = 0;
 int line = 0;
 int status = 0;
 int copts = REG_EXTENDED;
 int eopts = 0;
 regoff_t startoff = 0;
 regoff_t endoff = 0;
 extern int split();
 extern void regprint();
 /*
 - main - do the simple case, hand off to regress() for regression
 */
 main(argc, argv)
 int argc;
 char *argv[];
 {
 	regex_t re;
 #	define	NS	10
 	regmatch_t subs[NS];
 	char erbuf[100];
 	int err;
 	size_t len;
 	int c;
 	int errflg = 0;
 	register int i;
 	extern int optind;
 	extern char *optarg;
 	progname = argv[0];
 	while ((c = getopt(argc, argv, "c:e:S:E:x")) != EOF)
 		switch (c) {
 		case 'c':	/* compile options */
 			copts = options('c', optarg);
 			break;
 		case 'e':	/* execute options */
 			eopts = options('e', optarg);
 			break;
 		case 'S':	/* start offset */
 			startoff = (regoff_t)atoi(optarg);
 			break;
 		case 'E':	/* end offset */
 			endoff = (regoff_t)atoi(optarg);
 			break;
 		case 'x':	/* Debugging. */
 			debug++;
 			break;
 		case '?':
 		default:
 			errflg++;
 			break;
 		}
 	if (errflg) {
 		fprintf(stderr, "usage: %s ", progname);
 		fprintf(stderr, "[-c copt][-C][-d] [re]\n");
 		exit(2);
 	}
 	if (optind >= argc) {
 		regress(stdin);
 		exit(status);
 	}
 	err = regcomp(&re, argv[optind++], copts);
 	if (err) {
 		len = regerror(err, &re, erbuf, sizeof(erbuf));
 		fprintf(stderr, "error %s, %d/%d `%s'\n",
 			eprint(err), len, sizeof(erbuf), erbuf);
 		exit(status);
 	}
 	regprint(&re, stdout);	
 	if (optind >= argc) {
 		regfree(&re);
 		exit(status);
 	}
 	if (eopts&REG_STARTEND) {
 		subs[0].rm_so = startoff;
 		subs[0].rm_eo = strlen(argv[optind]) - endoff;
 	}
 	err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
 	if (err) {
 		len = regerror(err, &re, erbuf, sizeof(erbuf));
 		fprintf(stderr, "error %s, %d/%d `%s'\n",
 			eprint(err), len, sizeof(erbuf), erbuf);
 		exit(status);
 	}
 	if (!(copts&REG_NOSUB)) {
 		len = (int)(subs[0].rm_eo - subs[0].rm_so);
 		if (subs[0].rm_so != -1) {
 			if (len != 0)
 				printf("match `%.*s'\n", len,
 					argv[optind] + subs[0].rm_so);
 			else
 				printf("match `'@%.1s\n",
 					argv[optind] + subs[0].rm_so);
 		}
 		for (i = 1; i < NS; i++)
 			if (subs[i].rm_so != -1)
 				printf("(%d) `%.*s'\n", i,
 					(int)(subs[i].rm_eo - subs[i].rm_so),
 					argv[optind] + subs[i].rm_so);
 	}
 	exit(status);
 }
 /*
 - regress - main loop of regression test
 == void regress(FILE *in);
 */
 void
 regress(in)
 FILE *in;
 {
 	char inbuf[1000];
 #	define	MAXF	10
 	char *f[MAXF];
 	int nf;
 	int i;
 	char erbuf[100];
 	size_t ne;
 	char *badpat = "invalid regular expression";
 #	define	SHORT	10
 	char *bpname = "REG_BADPAT";
 	regex_t re;
 	while (fgets(inbuf, sizeof(inbuf), in) != NULL) {
 		line++;
 		if (inbuf[0] == '#' || inbuf[0] == '\n')
 			continue;			/* NOTE CONTINUE */
 		inbuf[strlen(inbuf)-1] = '\0';	/* get rid of stupid \n */
 		if (debug)
 			fprintf(stdout, "%d:\n", line);
 		nf = split(inbuf, f, MAXF, "\t\t");
 		if (nf < 3) {
 			fprintf(stderr, "bad input, line %d\n", line);
 			exit(1);
 		}
 		for (i = 0; i < nf; i++)
 			if (strcmp(f[i], "\"\"") == 0)
 				f[i] = "";
 		if (nf <= 3)
 			f[3] = NULL;
 		if (nf <= 4)
 			f[4] = NULL;
 		try(f[0], f[1], f[2], f[3], f[4], options('c', f[1]));
 		if (opt('&', f[1]))	/* try with either type of RE */
 			try(f[0], f[1], f[2], f[3], f[4],
 					options('c', f[1]) &~ REG_EXTENDED);
 	}
 	ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
 	if (strcmp(erbuf, badpat) != 0 || ne != strlen(badpat)+1) {
 		fprintf(stderr, "end: regerror() test gave `%s' not `%s'\n",
 							erbuf, badpat);
 		status = 1;
 	}
 	ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, (size_t)SHORT);
 	if (strncmp(erbuf, badpat, SHORT-1) != 0 || erbuf[SHORT-1] != '\0' ||
 						ne != strlen(badpat)+1) {
 		fprintf(stderr, "end: regerror() short test gave `%s' not `%.*s'\n",
 						erbuf, SHORT-1, badpat);
 		status = 1;
 	}
 	ne = regerror(REG_ITOA|REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
 	if (strcmp(erbuf, bpname) != 0 || ne != strlen(bpname)+1) {
 		fprintf(stderr, "end: regerror() ITOA test gave `%s' not `%s'\n",
 						erbuf, bpname);
 		status = 1;
 	}
 	re.re_endp = bpname;
 	ne = regerror(REG_ATOI, &re, erbuf, sizeof(erbuf));
 	if (atoi(erbuf) != (int)REG_BADPAT) {
 		fprintf(stderr, "end: regerror() ATOI test gave `%s' not `%ld'\n",
 						erbuf, (long)REG_BADPAT);
 		status = 1;
 	} else if (ne != strlen(erbuf)+1) {
 		fprintf(stderr, "end: regerror() ATOI test len(`%s') = %ld\n",
 						erbuf, (long)REG_BADPAT);
 		status = 1;
 	}
 }
 /*
 - try - try it, and report on problems
 == void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
 */
 void
 try(f0, f1, f2, f3, f4, opts)
 char *f0;
 char *f1;
 char *f2;
 char *f3;
 char *f4;
 int opts;			/* may not match f1 */
 {
 	regex_t re;
 #	define	NSUBS	10
 	regmatch_t subs[NSUBS];
 #	define	NSHOULD	15
 	char *should[NSHOULD];
 	int nshould;
 	char erbuf[100];
 	int err;
 	int len;
 	char *type = (opts & REG_EXTENDED) ? "ERE" : "BRE";
 	register int i;
 	char *grump;
 	char f0copy[1000];
 	char f2copy[1000];
 	strcpy(f0copy, f0);
 	re.re_endp = (opts&REG_PEND) ? f0copy + strlen(f0copy) : NULL;
 	fixstr(f0copy);
 	err = regcomp(&re, f0copy, opts);
 	if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
 		/* unexpected error or wrong error */
 		len = regerror(err, &re, erbuf, sizeof(erbuf));
 		fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
 					line, type, eprint(err), len,
 					sizeof(erbuf), erbuf);
 		status = 1;
 	} else if (err == 0 && opt('C', f1)) {
 		/* unexpected success */
 		fprintf(stderr, "%d: %s should have given REG_%s\n",
 						line, type, f2);
 		status = 1;
 		err = 1;	/* so we won't try regexec */
 	}
 	if (err != 0) {
 		regfree(&re);
 		return;
 	}
 	strcpy(f2copy, f2);
 	fixstr(f2copy);
 	if (options('e', f1)&REG_STARTEND) {
 		if (strchr(f2, '(') == NULL || strchr(f2, ')') == NULL)
 			fprintf(stderr, "%d: bad STARTEND syntax\n", line);
 		subs[0].rm_so = strchr(f2, '(') - f2 + 1;
 		subs[0].rm_eo = strchr(f2, ')') - f2;
 	}
 	err = regexec(&re, f2copy, NSUBS, subs, options('e', f1));
 	if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
 		/* unexpected error or wrong error */
 		len = regerror(err, &re, erbuf, sizeof(erbuf));
 		fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
 					line, type, eprint(err), len,
 					sizeof(erbuf), erbuf);
 		status = 1;
 	} else if (err != 0) {
 		/* nothing more to check */
 	} else if (f3 == NULL) {
 		/* unexpected success */
 		fprintf(stderr, "%d: %s exec should have failed\n",
 						line, type);
 		status = 1;
 		err = 1;		/* just on principle */
 	} else if (opts&REG_NOSUB) {
 		/* nothing more to check */
 	} else if ((grump = check(f2, subs[0], f3)) != NULL) {
 		fprintf(stderr, "%d: %s %s\n", line, type, grump);
 		status = 1;
 		err = 1;
 	}
 	if (err != 0 || f4 == NULL) {
 		regfree(&re);
 		return;
 	}
 	for (i = 1; i < NSHOULD; i++)
 		should[i] = NULL;
 	nshould = split(f4, should+1, NSHOULD-1, ",");
 	if (nshould == 0) {
 		nshould = 1;
 		should[1] = "";
 	}
 	for (i = 1; i < NSUBS; i++) {
 		grump = check(f2, subs[i], should[i]);
 		if (grump != NULL) {
 			fprintf(stderr, "%d: %s $%d %s\n", line,
 							type, i, grump);
 			status = 1;
 			err = 1;
 		}
 	}
 	regfree(&re);
 }
 /*
 - options - pick options out of a regression-test string
 == int options(int type, char *s);
 */
 int
 options(type, s)
 int type;			/* 'c' compile, 'e' exec */
 char *s;
 {
 	register char *p;
 	register int o = (type == 'c') ? copts : eopts;
 	register char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
 	for (p = s; *p != '\0'; p++)
 		if (strchr(legal, *p) != NULL)
 			switch (*p) {
 			case 'b':
 				o &= ~REG_EXTENDED;
 				break;
 			case 'i':
 				o |= REG_ICASE;
 				break;
 			case 's':
 				o |= REG_NOSUB;
 				break;
 			case 'n':
 				o |= REG_NEWLINE;
 				break;
 			case 'm':
 				o &= ~REG_EXTENDED;
 				o |= REG_NOSPEC;
 				break;
 			case 'p':
 				o |= REG_PEND;
 				break;
 			case '^':
 				o |= REG_NOTBOL;
 				break;
 			case '$':
 				o |= REG_NOTEOL;
 				break;
 			case '#':
 				o |= REG_STARTEND;
 				break;
 			case 't':	/* trace */
 				o |= REG_TRACE;
 				break;
 			case 'l':	/* force long representation */
 				o |= REG_LARGE;
 				break;
 			case 'r':	/* force backref use */
 				o |= REG_BACKR;
 				break;
 			}
 	return(o);
 }
 /*
 - opt - is a particular option in a regression string?
 == int opt(int c, char *s);
 */
 int				/* predicate */
 opt(c, s)
 int c;
 char *s;
 {
 	return(strchr(s, c) != NULL);
 }
 /*
 - fixstr - transform magic characters in strings
 == void fixstr(register char *p);
 */
 void
 fixstr(p)
 register char *p;
 {
 	if (p == NULL)
 		return;
 	for (; *p != '\0'; p++)
 		if (*p == 'N')
 			*p = '\n';
 		else if (*p == 'T')
 			*p = '\t';
 		else if (*p == 'S')
 			*p = ' ';
 		else if (*p == 'Z')
 			*p = '\0';
 }
 /*
 - check - check a substring match
 == char *check(char *str, regmatch_t sub, char *should);
 */
 char *				/* NULL or complaint */
 check(str, sub, should)
 char *str;
 regmatch_t sub;
 char *should;
 {
 	register int len;
 	register int shlen;
 	register char *p;
 	static char grump[500];
 	register char *at = NULL;
 	if (should != NULL && strcmp(should, "-") == 0)
 		should = NULL;
 	if (should != NULL && should[0] == '@') {
 		at = should + 1;
 		should = "";
 	}
 	/* check rm_so and rm_eo for consistency */
 	if (sub.rm_so > sub.rm_eo || (sub.rm_so == -1 && sub.rm_eo != -1) ||
 				(sub.rm_so != -1 && sub.rm_eo == -1) ||
 				(sub.rm_so != -1 && sub.rm_so < 0) ||
 				(sub.rm_eo != -1 && sub.rm_eo < 0) ) {
 		sprintf(grump, "start %ld end %ld", (long)sub.rm_so,
 							(long)sub.rm_eo);
 		return(grump);
 	}
 	/* check for no match */
 	if (sub.rm_so == -1 && should == NULL)
 		return(NULL);
 	if (sub.rm_so == -1)
 		return("did not match");
 	/* check for in range */
 	if (sub.rm_eo > strlen(str)) {
 		sprintf(grump, "start %ld end %ld, past end of string",
 					(long)sub.rm_so, (long)sub.rm_eo);
 		return(grump);
 	}
 	len = (int)(sub.rm_eo - sub.rm_so);
 	shlen = (int)strlen(should);
 	p = str + sub.rm_so;
 	/* check for not supposed to match */
 	if (should == NULL) {
 		sprintf(grump, "matched `%.*s'", len, p);
 		return(grump);
 	}
 	/* check for wrong match */
 	if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
 		sprintf(grump, "matched `%.*s' instead", len, p);
 		return(grump);
 	}
 	if (shlen > 0)
 		return(NULL);
 	/* check null match in right place */
 	if (at == NULL)
 		return(NULL);
 	shlen = strlen(at);
 	if (shlen == 0)
 		shlen = 1;	/* force check for end-of-string */
 	if (strncmp(p, at, shlen) != 0) {
 		sprintf(grump, "matched null at `%.20s'", p);
 		return(grump);
 	}
 	return(NULL);
 }
 /*
 - eprint - convert error number to name
 == static char *eprint(int err);
 */
 static char *
 eprint(err)
 int err;
 {
 	static char epbuf[100];
 	size_t len;
 	len = regerror(REG_ITOA|err, (regex_t *)NULL, epbuf, sizeof(epbuf));
 	assert(len <= sizeof(epbuf));
 	return(epbuf);
 }
 /*
 - efind - convert error name to number
 == static int efind(char *name);
 */
 static int
 efind(name)
 char *name;
 {
 	static char efbuf[100];
 	size_t n;
 	regex_t re;
 	sprintf(efbuf, "REG_%s", name);
 	assert(strlen(efbuf) < sizeof(efbuf));
 	re.re_endp = efbuf;
 	(void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
 	return(atoi(efbuf));
 }
--- a/src/regex/re_syntax.n
+++ b/src/regex/re_syntax.n
@@ -1,970 +0,0 @@
 '\"
 '\" Copyright (c) 1998 Sun Microsystems, Inc.
 '\" Copyright (c) 1999 Scriptics Corporation
 '\"
 '\" This software is copyrighted by the Regents of the University of
 '\" California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
 '\" Corporation and other parties.  The following terms apply to all files
 '\" associated with the software unless explicitly disclaimed in
 '\" individual files.
 '\" 
 '\" The authors hereby grant permission to use, copy, modify, distribute,
 '\" and license this software and its documentation for any purpose, provided
 '\" that existing copyright notices are retained in all copies and that this
 '\" notice is included verbatim in any distributions. No written agreement,
 '\" license, or royalty fee is required for any of the authorized uses.
 '\" Modifications to this software may be copyrighted by their authors
 '\" and need not follow the licensing terms described here, provided that
 '\" the new terms are clearly indicated on the first page of each file where
 '\" they apply.
 '\" 
 '\" IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
 '\" FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 '\" ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
 '\" DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
 '\" POSSIBILITY OF SUCH DAMAGE.
 '\" 
 '\" THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
 '\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
 '\" FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
 '\" IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
 '\" NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
 '\" MODIFICATIONS.
 '\" 
 '\" GOVERNMENT USE: If you are acquiring this software on behalf of the
 '\" U.S. government, the Government shall have only "Restricted Rights"
 '\" in the software and related documentation as defined in the Federal 
 '\" Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
 '\" are acquiring the software on behalf of the Department of Defense, the
 '\" software shall be classified as "Commercial Computer Software" and the
 '\" Government shall have only "Restricted Rights" as defined in Clause
 '\" 252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the
 '\" authors grant the U.S. Government and others acting in its behalf
 '\" permission to use and distribute the software in accordance with the
 '\" terms specified in this license. 
 '\" 
 '\" RCS: @(#) Id: re_syntax.n,v 1.3 1999/07/14 19:09:36 jpeek Exp 
 '\"
 .so man.macros
 .TH re_syntax n "8.1" Tcl "Tcl Built-In Commands"
 .BS
 .SH NAME
 re_syntax \- Syntax of Tcl regular expressions.
 .BE
 .SH DESCRIPTION
 .PP
 A \fIregular expression\fR describes strings of characters.
 It's a pattern that matches certain strings and doesn't match others.
 .SH "DIFFERENT FLAVORS OF REs"
 Regular expressions (``RE''s), as defined by POSIX, come in two
 flavors: \fIextended\fR REs (``EREs'') and \fIbasic\fR REs (``BREs'').
 EREs are roughly those of the traditional \fIegrep\fR, while BREs are
 roughly those of the traditional \fIed\fR.  This implementation adds
 a third flavor, \fIadvanced\fR REs (``AREs''), basically EREs with
 some significant extensions.
 .PP
 This manual page primarily describes AREs.  BREs mostly exist for
 backward compatibility in some old programs; they will be discussed at
 the end.  POSIX EREs are almost an exact subset of AREs.  Features of
 AREs that are not present in EREs will be indicated.
 .SH "REGULAR EXPRESSION SYNTAX"
 .PP
 Tcl regular expressions are implemented using the package written by
 Henry Spencer, based on the 1003.2 spec and some (not quite all) of
 the Perl5 extensions (thanks, Henry!).  Much of the description of
 regular expressions below is copied verbatim from his manual entry.
 .PP
 An ARE is one or more \fIbranches\fR,
 separated by `\fB|\fR',
 matching anything that matches any of the branches.
 .PP
 A branch is zero or more \fIconstraints\fR or \fIquantified atoms\fR,
 concatenated.
 It matches a match for the first, followed by a match for the second, etc;
 an empty branch matches the empty string.
 .PP
 A quantified atom is an \fIatom\fR possibly followed
 by a single \fIquantifier\fR.
 Without a quantifier, it matches a match for the atom.
 The quantifiers,
 and what a so-quantified atom matches, are:
 .RS 2
 .TP 6
 \fB*\fR
 a sequence of 0 or more matches of the atom
 .TP
 \fB+\fR
 a sequence of 1 or more matches of the atom
 .TP
 \fB?\fR
 a sequence of 0 or 1 matches of the atom
 .TP
 \fB{\fIm\fB}\fR
 a sequence of exactly \fIm\fR matches of the atom
 .TP
 \fB{\fIm\fB,}\fR
 a sequence of \fIm\fR or more matches of the atom
 .TP
 \fB{\fIm\fB,\fIn\fB}\fR
 a sequence of \fIm\fR through \fIn\fR (inclusive) matches of the atom;
 \fIm\fR may not exceed \fIn\fR
 .TP
 \fB*?  +?  ??  {\fIm\fB}?  {\fIm\fB,}?  {\fIm\fB,\fIn\fB}?\fR
 \fInon-greedy\fR quantifiers,
 which match the same possibilities,
 but prefer the smallest number rather than the largest number
 of matches (see MATCHING)
 .RE
 .PP
 The forms using
 \fB{\fR and \fB}\fR
 are known as \fIbound\fRs.
 The numbers
 \fIm\fR and \fIn\fR are unsigned decimal integers
 with permissible values from 0 to 255 inclusive.
 .PP
 An atom is one of:
 .RS 2
 .TP 6
 \fB(\fIre\fB)\fR
 (where \fIre\fR is any regular expression)
 matches a match for
 \fIre\fR, with the match noted for possible reporting
 .TP
 \fB(?:\fIre\fB)\fR
 as previous,
 but does no reporting
 (a ``non-capturing'' set of parentheses)
 .TP
 \fB()\fR
 matches an empty string,
 noted for possible reporting
 .TP
 \fB(?:)\fR
 matches an empty string,
 without reporting
 .TP
 \fB[\fIchars\fB]\fR
 a \fIbracket expression\fR,
 matching any one of the \fIchars\fR (see BRACKET EXPRESSIONS for more detail)
 .TP
 \fB.\fR
 matches any single character
 .TP
 \fB\e\fIk\fR
 (where \fIk\fR is a non-alphanumeric character)
 matches that character taken as an ordinary character,
 e.g. \e\e matches a backslash character
 .TP
 \fB\e\fIc\fR
 where \fIc\fR is alphanumeric
 (possibly followed by other characters),
 an \fIescape\fR (AREs only),
 see ESCAPES below
 .TP
 \fB{\fR
 when followed by a character other than a digit,
 matches the left-brace character `\fB{\fR';
 when followed by a digit, it is the beginning of a
 \fIbound\fR (see above)
 .TP
 \fIx\fR
 where \fIx\fR is
 a single character with no other significance, matches that character.
 .RE
 .PP
 A \fIconstraint\fR matches an empty string when specific conditions
 are met.
 A constraint may not be followed by a quantifier.
 The simple constraints are as follows; some more constraints are
 described later, under ESCAPES.
 .RS 2
 .TP 8
 \fB^\fR
 matches at the beginning of a line
 .TP
 \fB$\fR
 matches at the end of a line
 .TP
 \fB(?=\fIre\fB)\fR
 \fIpositive lookahead\fR (AREs only), matches at any point
 where a substring matching \fIre\fR begins
 .TP
 \fB(?!\fIre\fB)\fR
 \fInegative lookahead\fR (AREs only), matches at any point
 where no substring matching \fIre\fR begins
 .RE
 .PP
 The lookahead constraints may not contain back references (see later),
 and all parentheses within them are considered non-capturing.
 .PP
 An RE may not end with `\fB\e\fR'.
 .SH "BRACKET EXPRESSIONS"
 A \fIbracket expression\fR is a list of characters enclosed in `\fB[\|]\fR'.
 It normally matches any single character from the list (but see below).
 If the list begins with `\fB^\fR',
 it matches any single character
 (but see below) \fInot\fR from the rest of the list.
 .PP
 If two characters in the list are separated by `\fB\-\fR',
 this is shorthand
 for the full \fIrange\fR of characters between those two (inclusive) in the
 collating sequence,
 e.g.
 \fB[0\-9]\fR
 in ASCII matches any decimal digit.
 Two ranges may not share an
 endpoint, so e.g.
 \fBa\-c\-e\fR
 is illegal.
 Ranges are very collating-sequence-dependent,
 and portable programs should avoid relying on them.
 .PP
 To include a literal
 \fB]\fR
 or
 \fB\-\fR
 in the list,
 the simplest method is to
 enclose it in
 \fB[.\fR and \fB.]\fR
 to make it a collating element (see below).
 Alternatively,
 make it the first character
 (following a possible `\fB^\fR'),
 or (AREs only) precede it with `\fB\e\fR'.
 Alternatively, for `\fB\-\fR',
 make it the last character,
 or the second endpoint of a range.
 To use a literal
 \fB\-\fR
 as the first endpoint of a range,
 make it a collating element
 or (AREs only) precede it with `\fB\e\fR'.
 With the exception of these, some combinations using
 \fB[\fR
 (see next
 paragraphs), and escapes,
 all other special characters lose their
 special significance within a bracket expression.
 .PP
 Within a bracket expression, a collating element (a character,
 a multi-character sequence that collates as if it were a single character,
 or a collating-sequence name for either)
 enclosed in
 \fB[.\fR and \fB.]\fR
 stands for the
 sequence of characters of that collating element.
 The sequence is a single element of the bracket expression's list.
 A bracket expression in a locale that has
 multi-character collating elements
 can thus match more than one character.
 .VS 8.2
 So (insidiously), a bracket expression that starts with \fB^\fR
 can match multi-character collating elements even if none of them
 appear in the bracket expression!
 (\fINote:\fR Tcl currently has no multi-character collating elements.
 This information is only for illustration.)
 .PP
 For example, assume the collating sequence includes a \fBch\fR
 multi-character collating element.
 Then the RE \fB[[.ch.]]*c\fR (zero or more \fBch\fP's followed by \fBc\fP)
 matches the first five characters of `\fBchchcc\fR'.
 Also, the RE \fB[^c]b\fR matches all of `\fBchb\fR'
 (because \fB[^c]\fR matches the multi-character \fBch\fR).
 .VE 8.2
 .PP
 Within a bracket expression, a collating element enclosed in
 \fB[=\fR
 and
 \fB=]\fR
 is an equivalence class, standing for the sequences of characters
 of all collating elements equivalent to that one, including itself.
 (If there are no other equivalent collating elements,
 the treatment is as if the enclosing delimiters were `\fB[.\fR'\&
 and `\fB.]\fR'.)
 For example, if
 \fBo\fR
 and
 \fB\o'o^'\fR
 are the members of an equivalence class,
 then `\fB[[=o=]]\fR', `\fB[[=\o'o^'=]]\fR',
 and `\fB[o\o'o^']\fR'\&
 are all synonymous.
 An equivalence class may not be an endpoint
 of a range.
 .VS 8.2
 (\fINote:\fR 
 Tcl currently implements only the Unicode locale.
 It doesn't define any equivalence classes.
 The examples above are just illustrations.)
 .VE 8.2
 .PP
 Within a bracket expression, the name of a \fIcharacter class\fR enclosed
 in
 \fB[:\fR
 and
 \fB:]\fR
 stands for the list of all characters
 (not all collating elements!)
 belonging to that
 class.
 Standard character classes are:
 .PP
 .RS
 .ne 5
 .nf
 .ta 3c
 \fBalpha\fR	A letter. 
 \fBupper\fR	An upper-case letter. 
 \fBlower\fR	A lower-case letter. 
 \fBdigit\fR	A decimal digit. 
 \fBxdigit\fR	A hexadecimal digit. 
 \fBalnum\fR	An alphanumeric (letter or digit). 
 \fBprint\fR	An alphanumeric (same as alnum).
 \fBblank\fR	A space or tab character.
 \fBspace\fR	A character producing white space in displayed text. 
 \fBpunct\fR	A punctuation character. 
 \fBgraph\fR	A character with a visible representation. 
 \fBcntrl\fR	A control character. 
 .fi
 .RE
 .PP
 A locale may provide others.
 .VS 8.2
 (Note that the current Tcl implementation has only one locale:
 the Unicode locale.)
 .VE 8.2
 A character class may not be used as an endpoint of a range.
 .PP
 There are two special cases of bracket expressions:
 the bracket expressions
 \fB[[:<:]]\fR
 and
 \fB[[:>:]]\fR
 are constraints, matching empty strings at
 the beginning and end of a word respectively.
 '\" note, discussion of escapes below references this definition of word
 A word is defined as a sequence of
 word characters
 that is neither preceded nor followed by
 word characters.
 A word character is an
 \fIalnum\fR
 character
 or an underscore
 (\fB_\fR).
 These special bracket expressions are deprecated;
 users of AREs should use constraint escapes instead (see below).
 .SH ESCAPES
 Escapes (AREs only), which begin with a
 \fB\e\fR
 followed by an alphanumeric character,
 come in several varieties:
 character entry, class shorthands, constraint escapes, and back references.
 A
 \fB\e\fR
 followed by an alphanumeric character but not constituting
 a valid escape is illegal in AREs.
 In EREs, there are no escapes:
 outside a bracket expression,
 a
 \fB\e\fR
 followed by an alphanumeric character merely stands for that
 character as an ordinary character,
 and inside a bracket expression,
 \fB\e\fR
 is an ordinary character.
 (The latter is the one actual incompatibility between EREs and AREs.)
 .PP
 Character-entry escapes (AREs only) exist to make it easier to specify
 non-printing and otherwise inconvenient characters in REs:
 .RS 2
 .TP 5
 \fB\ea\fR
 alert (bell) character, as in C
 .TP
 \fB\eb\fR
 backspace, as in C
 .TP
 \fB\eB\fR
 synonym for
 \fB\e\fR
 to help reduce backslash doubling in some
 applications where there are multiple levels of backslash processing
 .TP
 \fB\ec\fIX\fR
 (where X is any character) the character whose
 low-order 5 bits are the same as those of
 \fIX\fR,
 and whose other bits are all zero
 .TP
 \fB\ee\fR
 the character whose collating-sequence name
 is `\fBESC\fR',
 or failing that, the character with octal value 033
 .TP
 \fB\ef\fR
 formfeed, as in C
 .TP
 \fB\en\fR
 newline, as in C
 .TP
 \fB\er\fR
 carriage return, as in C
 .TP
 \fB\et\fR
 horizontal tab, as in C
 .TP
 \fB\eu\fIwxyz\fR
 (where
 \fIwxyz\fR
 is exactly four hexadecimal digits)
 the Unicode character
 \fBU+\fIwxyz\fR
 in the local byte ordering
 .TP
 \fB\eU\fIstuvwxyz\fR
 (where
 \fIstuvwxyz\fR
 is exactly eight hexadecimal digits)
 reserved for a somewhat-hypothetical Unicode extension to 32 bits
 .TP
 \fB\ev\fR
 vertical tab, as in C
 are all available.
 .TP
 \fB\ex\fIhhh\fR
 (where
 \fIhhh\fR
 is any sequence of hexadecimal digits)
 the character whose hexadecimal value is
 \fB0x\fIhhh\fR
 (a single character no matter how many hexadecimal digits are used).
 .TP
 \fB\e0\fR
 the character whose value is
 \fB0\fR
 .TP
 \fB\e\fIxy\fR
 (where
 \fIxy\fR
 is exactly two octal digits,
 and is not a
 \fIback reference\fR (see below))
 the character whose octal value is
 \fB0\fIxy\fR
 .TP
 \fB\e\fIxyz\fR
 (where
 \fIxyz\fR
 is exactly three octal digits,
 and is not a
 back reference (see below))
 the character whose octal value is
 \fB0\fIxyz\fR
 .RE
 .PP
 Hexadecimal digits are `\fB0\fR'-`\fB9\fR', `\fBa\fR'-`\fBf\fR',
 and `\fBA\fR'-`\fBF\fR'.
 Octal digits are `\fB0\fR'-`\fB7\fR'.
 .PP
 The character-entry escapes are always taken as ordinary characters.
 For example,
 \fB\e135\fR
 is
 \fB]\fR
 in ASCII,
 but
 \fB\e135\fR
 does not terminate a bracket expression.
 Beware, however, that some applications (e.g., C compilers) interpret 
 such sequences themselves before the regular-expression package
 gets to see them, which may require doubling (quadrupling, etc.) the `\fB\e\fR'.
 .PP
 Class-shorthand escapes (AREs only) provide shorthands for certain commonly-used
 character classes:
 .RS 2
 .TP 10
 \fB\ed\fR
 \fB[[:digit:]]\fR
 .TP
 \fB\es\fR
 \fB[[:space:]]\fR
 .TP
 \fB\ew\fR
 \fB[[:alnum:]_]\fR
 (note underscore)
 .TP
 \fB\eD\fR
 \fB[^[:digit:]]\fR
 .TP
 \fB\eS\fR
 \fB[^[:space:]]\fR
 .TP
 \fB\eW\fR
 \fB[^[:alnum:]_]\fR
 (note underscore)
 .RE
 .PP
 Within bracket expressions, `\fB\ed\fR', `\fB\es\fR',
 and `\fB\ew\fR'\&
 lose their outer brackets,
 and `\fB\eD\fR', `\fB\eS\fR',
 and `\fB\eW\fR'\&
 are illegal.
 .VS 8.2
 (So, for example, \fB[a-c\ed]\fR is equivalent to \fB[a-c[:digit:]]\fR.
 Also, \fB[a-c\eD]\fR, which is equivalent to \fB[a-c^[:digit:]]\fR, is illegal.)
 .VE 8.2
 .PP
 A constraint escape (AREs only) is a constraint,
 matching the empty string if specific conditions are met,
 written as an escape:
 .RS 2
 .TP 6
 \fB\eA\fR
 matches only at the beginning of the string
 (see MATCHING, below, for how this differs from `\fB^\fR')
 .TP
 \fB\em\fR
 matches only at the beginning of a word
 .TP
 \fB\eM\fR
 matches only at the end of a word
 .TP
 \fB\ey\fR
 matches only at the beginning or end of a word
 .TP
 \fB\eY\fR
 matches only at a point that is not the beginning or end of a word
 .TP
 \fB\eZ\fR
 matches only at the end of the string
 (see MATCHING, below, for how this differs from `\fB$\fR')
 .TP
 \fB\e\fIm\fR
 (where
 \fIm\fR
 is a nonzero digit) a \fIback reference\fR, see below
 .TP
 \fB\e\fImnn\fR
 (where
 \fIm\fR
 is a nonzero digit, and
 \fInn\fR
 is some more digits,
 and the decimal value
 \fImnn\fR
 is not greater than the number of closing capturing parentheses seen so far)
 a \fIback reference\fR, see below
 .RE
 .PP
 A word is defined as in the specification of
 \fB[[:<:]]\fR
 and
 \fB[[:>:]]\fR
 above.
 Constraint escapes are illegal within bracket expressions.
 .PP
 A back reference (AREs only) matches the same string matched by the parenthesized
 subexpression specified by the number,
 so that (e.g.)
 \fB([bc])\e1\fR
 matches
 \fBbb\fR
 or
 \fBcc\fR
 but not `\fBbc\fR'.
 The subexpression must entirely precede the back reference in the RE.
 Subexpressions are numbered in the order of their leading parentheses.
 Non-capturing parentheses do not define subexpressions.
 .PP
 There is an inherent historical ambiguity between octal character-entry 
 escapes and back references, which is resolved by heuristics,
 as hinted at above.
 A leading zero always indicates an octal escape.
 A single non-zero digit, not followed by another digit,
 is always taken as a back reference.
 A multi-digit sequence not starting with a zero is taken as a back 
 reference if it comes after a suitable subexpression
 (i.e. the number is in the legal range for a back reference),
 and otherwise is taken as octal.
 .SH "METASYNTAX"
 In addition to the main syntax described above, there are some special
 forms and miscellaneous syntactic facilities available.
 .PP
 Normally the flavor of RE being used is specified by
 application-dependent means.
 However, this can be overridden by a \fIdirector\fR.
 If an RE of any flavor begins with `\fB***:\fR',
 the rest of the RE is an ARE.
 If an RE of any flavor begins with `\fB***=\fR',
 the rest of the RE is taken to be a literal string,
 with all characters considered ordinary characters.
 .PP
 An ARE may begin with \fIembedded options\fR:
 a sequence
 \fB(?\fIxyz\fB)\fR
 (where
 \fIxyz\fR
 is one or more alphabetic characters)
 specifies options affecting the rest of the RE.
 These supplement, and can override,
 any options specified by the application.
 The available option letters are:
 .RS 2
 .TP 3
 \fBb\fR
 rest of RE is a BRE
 .TP 3
 \fBc\fR
 case-sensitive matching (usual default)
 .TP 3
 \fBe\fR
 rest of RE is an ERE
 .TP 3
 \fBi\fR
 case-insensitive matching (see MATCHING, below)
 .TP 3
 \fBm\fR
 historical synonym for
 \fBn\fR
 .TP 3
 \fBn\fR
 newline-sensitive matching (see MATCHING, below)
 .TP 3
 \fBp\fR
 partial newline-sensitive matching (see MATCHING, below)
 .TP 3
 \fBq\fR
 rest of RE is a literal (``quoted'') string, all ordinary characters
 .TP 3
 \fBs\fR
 non-newline-sensitive matching (usual default)
 .TP 3
 \fBt\fR
 tight syntax (usual default; see below)
 .TP 3
 \fBw\fR
 inverse partial newline-sensitive (``weird'') matching (see MATCHING, below)
 .TP 3
 \fBx\fR
 expanded syntax (see below)
 .RE
 .PP
 Embedded options take effect at the
 \fB)\fR
 terminating the sequence.
 They are available only at the start of an ARE,
 and may not be used later within it.
 .PP
 In addition to the usual (\fItight\fR) RE syntax, in which all characters are
 significant, there is an \fIexpanded\fR syntax,
 available in all flavors of RE
 with the \fB-expanded\fR switch, or in AREs with the embedded x option.
 In the expanded syntax,
 white-space characters are ignored
 and all characters between a
 \fB#\fR
 and the following newline (or the end of the RE) are ignored,
 permitting paragraphing and commenting a complex RE.
 There are three exceptions to that basic rule:
 .RS 2
 .PP
 a white-space character or `\fB#\fR' preceded by `\fB\e\fR' is retained
 .PP
 white space or `\fB#\fR' within a bracket expression is retained
 .PP
 white space and comments are illegal within multi-character symbols
 like the ARE `\fB(?:\fR' or the BRE `\fB\e(\fR'
 .RE
 .PP
 Expanded-syntax white-space characters are blank, tab, newline, and
 .VS 8.2
 any character that belongs to the \fIspace\fR character class.
 .VE 8.2
 .PP
 Finally, in an ARE,
 outside bracket expressions, the sequence `\fB(?#\fIttt\fB)\fR'
 (where
 \fIttt\fR
 is any text not containing a `\fB)\fR')
 is a comment,
 completely ignored.
 Again, this is not allowed between the characters of
 multi-character symbols like `\fB(?:\fR'.
 Such comments are more a historical artifact than a useful facility,
 and their use is deprecated;
 use the expanded syntax instead.
 .PP
 \fINone\fR of these metasyntax extensions is available if the application
 (or an initial
 \fB***=\fR
 director)
 has specified that the user's input be treated as a literal string
 rather than as an RE.
 .SH MATCHING
 In the event that an RE could match more than one substring of a given
 string,
 the RE matches the one starting earliest in the string.
 If the RE could match more than one substring starting at that point,
 its choice is determined by its \fIpreference\fR:
 either the longest substring, or the shortest.
 .PP
 Most atoms, and all constraints, have no preference.
 A parenthesized RE has the same preference (possibly none) as the RE.
 A quantified atom with quantifier
 \fB{\fIm\fB}\fR
 or
 \fB{\fIm\fB}?\fR
 has the same preference (possibly none) as the atom itself.
 A quantified atom with other normal quantifiers (including
 \fB{\fIm\fB,\fIn\fB}\fR
 with
 \fIm\fR
 equal to
 \fIn\fR)
 prefers longest match.
 A quantified atom with other non-greedy quantifiers (including
 \fB{\fIm\fB,\fIn\fB}?\fR
 with
 \fIm\fR
 equal to
 \fIn\fR)
 prefers shortest match.
 A branch has the same preference as the first quantified atom in it
 which has a preference.
 An RE consisting of two or more branches connected by the
 \fB|\fR
 operator prefers longest match.
 .PP
 Subject to the constraints imposed by the rules for matching the whole RE,
 subexpressions also match the longest or shortest possible substrings,
 based on their preferences,
 with subexpressions starting earlier in the RE taking priority over
 ones starting later.
 Note that outer subexpressions thus take priority over
 their component subexpressions.
 .PP
 Note that the quantifiers
 \fB{1,1}\fR
 and
 \fB{1,1}?\fR
 can be used to force longest and shortest preference, respectively,
 on a subexpression or a whole RE.
 .PP
 Match lengths are measured in characters, not collating elements.
 An empty string is considered longer than no match at all.
 For example,
 \fBbb*\fR
 matches the three middle characters of `\fBabbbc\fR',
 \fB(week|wee)(night|knights)\fR
 matches all ten characters of `\fBweeknights\fR',
 when
 \fB(.*).*\fR
 is matched against
 \fBabc\fR
 the parenthesized subexpression
 matches all three characters, and
 when
 \fB(a*)*\fR
 is matched against
 \fBbc\fR
 both the whole RE and the parenthesized
 subexpression match an empty string.
 .PP
 If case-independent matching is specified,
 the effect is much as if all case distinctions had vanished from the
 alphabet.
 When an alphabetic that exists in multiple cases appears as an
 ordinary character outside a bracket expression, it is effectively
 transformed into a bracket expression containing both cases,
 so that
 \fBx\fR
 becomes `\fB[xX]\fR'.
 When it appears inside a bracket expression, all case counterparts
 of it are added to the bracket expression, so that
 \fB[x]\fR
 becomes
 \fB[xX]\fR
 and
 \fB[^x]\fR
 becomes `\fB[^xX]\fR'.
 .PP
 If newline-sensitive matching is specified, \fB.\fR
 and bracket expressions using
 \fB^\fR
 will never match the newline character
 (so that matches will never cross newlines unless the RE
 explicitly arranges it)
 and
 \fB^\fR
 and
 \fB$\fR
 will match the empty string after and before a newline
 respectively, in addition to matching at beginning and end of string
 respectively.
 ARE
 \fB\eA\fR
 and
 \fB\eZ\fR
 continue to match beginning or end of string \fIonly\fR.
 .PP
 If partial newline-sensitive matching is specified,
 this affects \fB.\fR
 and bracket expressions
 as with newline-sensitive matching, but not
 \fB^\fR
 and `\fB$\fR'.
 .PP
 If inverse partial newline-sensitive matching is specified,
 this affects
 \fB^\fR
 and
 \fB$\fR
 as with
 newline-sensitive matching,
 but not \fB.\fR
 and bracket expressions.
 This isn't very useful but is provided for symmetry.
 .SH "LIMITS AND COMPATIBILITY"
 No particular limit is imposed on the length of REs.
 Programs intended to be highly portable should not employ REs longer
 than 256 bytes,
 as a POSIX-compliant implementation can refuse to accept such REs.
 .PP
 The only feature of AREs that is actually incompatible with
 POSIX EREs is that
 \fB\e\fR
 does not lose its special
 significance inside bracket expressions.
 All other ARE features use syntax which is illegal or has
 undefined or unspecified effects in POSIX EREs;
 the
 \fB***\fR
 syntax of directors likewise is outside the POSIX
 syntax for both BREs and EREs.
 .PP
 Many of the ARE extensions are borrowed from Perl, but some have
 been changed to clean them up, and a few Perl extensions are not present.
 Incompatibilities of note include `\fB\eb\fR', `\fB\eB\fR',
 the lack of special treatment for a trailing newline,
 the addition of complemented bracket expressions to the things
 affected by newline-sensitive matching,
 the restrictions on parentheses and back references in lookahead constraints,
 and the longest/shortest-match (rather than first-match) matching semantics.
 .PP
 The matching rules for REs containing both normal and non-greedy quantifiers
 have changed since early beta-test versions of this package.
 (The new rules are much simpler and cleaner,
 but don't work as hard at guessing the user's real intentions.)
 .PP
 Henry Spencer's original 1986 \fIregexp\fR package,
 still in widespread use (e.g., in pre-8.1 releases of Tcl),
 implemented an early version of today's EREs.
 There are four incompatibilities between \fIregexp\fR's near-EREs
 (`RREs' for short) and AREs.
 In roughly increasing order of significance:
 .PP
 .RS
 In AREs,
 \fB\e\fR
 followed by an alphanumeric character is either an
 escape or an error,
 while in RREs, it was just another way of writing the 
 alphanumeric.
 This should not be a problem because there was no reason to write
 such a sequence in RREs.
 .PP
 \fB{\fR
 followed by a digit in an ARE is the beginning of a bound,
 while in RREs,
 \fB{\fR
 was always an ordinary character.
 Such sequences should be rare,
 and will often result in an error because following characters
 will not look like a valid bound.
 .PP
 In AREs,
 \fB\e\fR
 remains a special character within `\fB[\|]\fR',
 so a literal
 \fB\e\fR
 within
 \fB[\|]\fR
 must be written `\fB\e\e\fR'.
 \fB\e\e\fR
 also gives a literal
 \fB\e\fR
 within
 \fB[\|]\fR
 in RREs,
 but only truly paranoid programmers routinely doubled the backslash.
 .PP
 AREs report the longest/shortest match for the RE,
 rather than the first found in a specified search order.
 This may affect some RREs which were written in the expectation that
 the first match would be reported.
 (The careful crafting of RREs to optimize the search order for fast
 matching is obsolete (AREs examine all possible matches
 in parallel, and their performance is largely insensitive to their
 complexity) but cases where the search order was exploited to deliberately 
 find a match which was \fInot\fR the longest/shortest will need rewriting.)
 .RE
 .SH "BASIC REGULAR EXPRESSIONS"
 BREs differ from EREs in several respects.  `\fB|\fR', `\fB+\fR',
 and
 \fB?\fR
 are ordinary characters and there is no equivalent
 for their functionality.
 The delimiters for bounds are
 \fB\e{\fR
 and `\fB\e}\fR',
 with
 \fB{\fR
 and
 \fB}\fR
 by themselves ordinary characters.
 The parentheses for nested subexpressions are
 \fB\e(\fR
 and `\fB\e)\fR',
 with
 \fB(\fR
 and
 \fB)\fR
 by themselves ordinary characters.
 \fB^\fR
 is an ordinary character except at the beginning of the
 RE or the beginning of a parenthesized subexpression,
 \fB$\fR
 is an ordinary character except at the end of the
 RE or the end of a parenthesized subexpression,
 and
 \fB*\fR
 is an ordinary character if it appears at the beginning of the
 RE or the beginning of a parenthesized subexpression
 (after a possible leading `\fB^\fR').
 Finally,
 single-digit back references are available,
 and
 \fB\e<\fR
 and
 \fB\e>\fR
 are synonyms for
 \fB[[:<:]]\fR
 and
 \fB[[:>:]]\fR
 respectively;
 no other escapes are available.
 .SH "SEE ALSO"
 RegExp(3), regexp(n), regsub(n), lsearch(n), switch(n), text(n)
 .SH KEYWORDS
 match, regular expression, string
--- a/src/regex/regc_color.c
+++ b/src/regex/regc_color.c
@@ -1,780 +0,0 @@
 /*
 * colorings of characters
 * This file is #included by regcomp.c.
 *
 * Copyright (c) 1998, 1999 Henry Spencer.	All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation
 * of software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Header$
 *
 *
 * Note that there are some incestuous relationships between this code and
 * NFA arc maintenance, which perhaps ought to be cleaned up sometime.
 */
 #define CISERR()	VISERR(cm->v)
 #define CERR(e)		VERR(cm->v, (e))
 /*
 * initcm - set up new colormap
 */
 static void
 initcm(struct vars * v,
 	   struct colormap * cm)
 {
 	int			i;
 	int			j;
 	union tree *t;
 	union tree *nextt;
 	struct colordesc *cd;
 	cm->magic = CMMAGIC;
 	cm->v = v;
 	cm->ncds = NINLINECDS;
 	cm->cd = cm->cdspace;
 	cm->max = 0;
 	cm->free = 0;
 	cd = cm->cd;				/* cm->cd[WHITE] */
 	cd->sub = NOSUB;
 	cd->arcs = NULL;
 	cd->flags = 0;
 	cd->nchrs = CHR_MAX - CHR_MIN + 1;
 	/* upper levels of tree */
 	for (t = &cm->tree[0], j = NBYTS - 1; j > 0; t = nextt, j--)
 	{
 		nextt = t + 1;
 		for (i = BYTTAB - 1; i >= 0; i--)
 			t->tptr[i] = nextt;
 	}
 	/* bottom level is solid white */
 	t = &cm->tree[NBYTS - 1];
 	for (i = BYTTAB - 1; i >= 0; i--)
 		t->tcolor[i] = WHITE;
 	cd->block = t;
 }
 /*
 * freecm - free dynamically-allocated things in a colormap
 */
 static void
 freecm(struct colormap * cm)
 {
 	size_t		i;
 	union tree *cb;
 	cm->magic = 0;
 	if (NBYTS > 1)
 		cmtreefree(cm, cm->tree, 0);
 	for (i = 1; i <= cm->max; i++)		/* skip WHITE */
 		if (!UNUSEDCOLOR(&cm->cd[i]))
 		{
 			cb = cm->cd[i].block;
 			if (cb != NULL)
 				FREE(cb);
 		}
 	if (cm->cd != cm->cdspace)
 		FREE(cm->cd);
 }
 /*
 * cmtreefree - free a non-terminal part of a colormap tree
 */
 static void
 cmtreefree(struct colormap * cm,
 		   union tree * tree,
 		   int level)			/* level number (top == 0) of this block */
 {
 	int			i;
 	union tree *t;
 	union tree *fillt = &cm->tree[level + 1];
 	union tree *cb;
 	assert(level < NBYTS - 1);	/* this level has pointers */
 	for (i = BYTTAB - 1; i >= 0; i--)
 	{
 		t = tree->tptr[i];
 		assert(t != NULL);
 		if (t != fillt)
 		{
 			if (level < NBYTS - 2)
 			{					/* more pointer blocks below */
 				cmtreefree(cm, t, level + 1);
 				FREE(t);
 			}
 			else
 			{					/* color block below */
 				cb = cm->cd[t->tcolor[0]].block;
 				if (t != cb)	/* not a solid block */
 					FREE(t);
 			}
 		}
 	}
 }
 /*
 * setcolor - set the color of a character in a colormap
 */
 static color					/* previous color */
 setcolor(struct colormap * cm,
 		 chr c,
 		 pcolor co)
 {
 	uchr		uc = c;
 	int			shift;
 	int			level;
 	int			b;
 	int			bottom;
 	union tree *t;
 	union tree *newt;
 	union tree *fillt;
 	union tree *lastt;
 	union tree *cb;
 	color		prev;
 	assert(cm->magic == CMMAGIC);
 	if (CISERR() || co == COLORLESS)
 		return COLORLESS;
 	t = cm->tree;
 	for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
 		 level++, shift -= BYTBITS)
 	{
 		b = (uc >> shift) & BYTMASK;
 		lastt = t;
 		t = lastt->tptr[b];
 		assert(t != NULL);
 		fillt = &cm->tree[level + 1];
 		bottom = (shift <= BYTBITS) ? 1 : 0;
 		cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;
 		if (t == fillt || t == cb)
 		{						/* must allocate a new block */
 			newt = (union tree *) MALLOC((bottom) ?
 							sizeof(struct colors) : sizeof(struct ptrs));
 			if (newt == NULL)
 			{
 				CERR(REG_ESPACE);
 				return COLORLESS;
 			}
 			if (bottom)
 				memcpy(VS(newt->tcolor), VS(t->tcolor),
 					   BYTTAB * sizeof(color));
 			else
 				memcpy(VS(newt->tptr), VS(t->tptr),
 					   BYTTAB * sizeof(union tree *));
 			t = newt;
 			lastt->tptr[b] = t;
 		}
 	}
 	b = uc & BYTMASK;
 	prev = t->tcolor[b];
 	t->tcolor[b] = (color) co;
 	return prev;
 }
 /*
 * maxcolor - report largest color number in use
 */
 static color
 maxcolor(struct colormap * cm)
 {
 	if (CISERR())
 		return COLORLESS;
 	return (color) cm->max;
 }
 /*
 * newcolor - find a new color (must be subject of setcolor at once)
 * Beware:	may relocate the colordescs.
 */
 static color					/* COLORLESS for error */
 newcolor(struct colormap * cm)
 {
 	struct colordesc *cd;
 	struct colordesc *new;
 	size_t		n;
 	if (CISERR())
 		return COLORLESS;
 	if (cm->free != 0)
 	{
 		assert(cm->free > 0);
 		assert((size_t) cm->free < cm->ncds);
 		cd = &cm->cd[cm->free];
 		assert(UNUSEDCOLOR(cd));
 		assert(cd->arcs == NULL);
 		cm->free = cd->sub;
 	}
 	else if (cm->max < cm->ncds - 1)
 	{
 		cm->max++;
 		cd = &cm->cd[cm->max];
 	}
 	else
 	{
 		/* oops, must allocate more */
 		n = cm->ncds * 2;
 		if (cm->cd == cm->cdspace)
 		{
 			new = (struct colordesc *) MALLOC(n *
 											  sizeof(struct colordesc));
 			if (new != NULL)
 				memcpy(VS(new), VS(cm->cdspace), cm->ncds *
 					   sizeof(struct colordesc));
 		}
 		else
 			new = (struct colordesc *) REALLOC(cm->cd,
 										   n * sizeof(struct colordesc));
 		if (new == NULL)
 		{
 			CERR(REG_ESPACE);
 			return COLORLESS;
 		}
 		cm->cd = new;
 		cm->ncds = n;
 		assert(cm->max < cm->ncds - 1);
 		cm->max++;
 		cd = &cm->cd[cm->max];
 	}
 	cd->nchrs = 0;
 	cd->sub = NOSUB;
 	cd->arcs = NULL;
 	cd->flags = 0;
 	cd->block = NULL;
 	return (color) (cd - cm->cd);
 }
 /*
 * freecolor - free a color (must have no arcs or subcolor)
 */
 static void
 freecolor(struct colormap * cm,
 		  pcolor co)
 {
 	struct colordesc *cd = &cm->cd[co];
 	color		pco,
 				nco;			/* for freelist scan */
 	assert(co >= 0);
 	if (co == WHITE)
 		return;
 	assert(cd->arcs == NULL);
 	assert(cd->sub == NOSUB);
 	assert(cd->nchrs == 0);
 	cd->flags = FREECOL;
 	if (cd->block != NULL)
 	{
 		FREE(cd->block);
 		cd->block = NULL;		/* just paranoia */
 	}
 	if ((size_t) co == cm->max)
 	{
 		while (cm->max > WHITE && UNUSEDCOLOR(&cm->cd[cm->max]))
 			cm->max--;
 		assert(cm->free >= 0);
 		while ((size_t) cm->free > cm->max)
 			cm->free = cm->cd[cm->free].sub;
 		if (cm->free > 0)
 		{
 			assert(cm->free < cm->max);
 			pco = cm->free;
 			nco = cm->cd[pco].sub;
 			while (nco > 0)
 				if ((size_t) nco > cm->max)
 				{
 					/* take this one out of freelist */
 					nco = cm->cd[nco].sub;
 					cm->cd[pco].sub = nco;
 				}
 				else
 				{
 					assert(nco < cm->max);
 					pco = nco;
 					nco = cm->cd[pco].sub;
 				}
 		}
 	}
 	else
 	{
 		cd->sub = cm->free;
 		cm->free = (color) (cd - cm->cd);
 	}
 }
 /*
 * pseudocolor - allocate a false color, to be managed by other means
 */
 static color
 pseudocolor(struct colormap * cm)
 {
 	color		co;
 	co = newcolor(cm);
 	if (CISERR())
 		return COLORLESS;
 	cm->cd[co].nchrs = 1;
 	cm->cd[co].flags = PSEUDO;
 	return co;
 }
 /*
 * subcolor - allocate a new subcolor (if necessary) to this chr
 */
 static color
 subcolor(struct colormap * cm, chr c)
 {
 	color		co;				/* current color of c */
 	color		sco;			/* new subcolor */
 	co = GETCOLOR(cm, c);
 	sco = newsub(cm, co);
 	if (CISERR())
 		return COLORLESS;
 	assert(sco != COLORLESS);
 	if (co == sco)				/* already in an open subcolor */
 		return co;				/* rest is redundant */
 	cm->cd[co].nchrs--;
 	cm->cd[sco].nchrs++;
 	setcolor(cm, c, sco);
 	return sco;
 }
 /*
 * newsub - allocate a new subcolor (if necessary) for a color
 */
 static color
 newsub(struct colormap * cm,
 	   pcolor co)
 {
 	color		sco;			/* new subcolor */
 	sco = cm->cd[co].sub;
 	if (sco == NOSUB)
 	{							/* color has no open subcolor */
 		if (cm->cd[co].nchrs == 1)		/* optimization */
 			return co;
 		sco = newcolor(cm);		/* must create subcolor */
 		if (sco == COLORLESS)
 		{
 			assert(CISERR());
 			return COLORLESS;
 		}
 		cm->cd[co].sub = sco;
 		cm->cd[sco].sub = sco;	/* open subcolor points to self */
 	}
 	assert(sco != NOSUB);
 	return sco;
 }
 /*
 * subrange - allocate new subcolors to this range of chrs, fill in arcs
 */
 static void
 subrange(struct vars * v,
 		 chr from,
 		 chr to,
 		 struct state * lp,
 		 struct state * rp)
 {
 	uchr		uf;
 	int			i;
 	assert(from <= to);
 	/* first, align "from" on a tree-block boundary */
 	uf = (uchr) from;
 	i = (int) (((uf + BYTTAB - 1) & (uchr) ~BYTMASK) - uf);
 	for (; from <= to && i > 0; i--, from++)
 		newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
 	if (from > to)				/* didn't reach a boundary */
 		return;
 	/* deal with whole blocks */
 	for (; to - from >= BYTTAB; from += BYTTAB)
 		subblock(v, from, lp, rp);
 	/* clean up any remaining partial table */
 	for (; from <= to; from++)
 		newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
 }
 /*
 * subblock - allocate new subcolors for one tree block of chrs, fill in arcs
 */
 static void
 subblock(struct vars * v,
 		 chr start,				/* first of BYTTAB chrs */
 		 struct state * lp,
 		 struct state * rp)
 {
 	uchr		uc = start;
 	struct colormap *cm = v->cm;
 	int			shift;
 	int			level;
 	int			i;
 	int			b;
 	union tree *t;
 	union tree *cb;
 	union tree *fillt;
 	union tree *lastt;
 	int			previ;
 	int			ndone;
 	color		co;
 	color		sco;
 	assert((uc % BYTTAB) == 0);
 	/* find its color block, making new pointer blocks as needed */
 	t = cm->tree;
 	fillt = NULL;
 	for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
 		 level++, shift -= BYTBITS)
 	{
 		b = (uc >> shift) & BYTMASK;
 		lastt = t;
 		t = lastt->tptr[b];
 		assert(t != NULL);
 		fillt = &cm->tree[level + 1];
 		if (t == fillt && shift > BYTBITS)
 		{						/* need new ptr block */
 			t = (union tree *) MALLOC(sizeof(struct ptrs));
 			if (t == NULL)
 			{
 				CERR(REG_ESPACE);
 				return;
 			}
 			memcpy(VS(t->tptr), VS(fillt->tptr),
 				   BYTTAB * sizeof(union tree *));
 			lastt->tptr[b] = t;
 		}
 	}
 	/* special cases:  fill block or solid block */
 	co = t->tcolor[0];
 	cb = cm->cd[co].block;
 	if (t == fillt || t == cb)
 	{
 		/* either way, we want a subcolor solid block */
 		sco = newsub(cm, co);
 		t = cm->cd[sco].block;
 		if (t == NULL)
 		{						/* must set it up */
 			t = (union tree *) MALLOC(sizeof(struct colors));
 			if (t == NULL)
 			{
 				CERR(REG_ESPACE);
 				return;
 			}
 			for (i = 0; i < BYTTAB; i++)
 				t->tcolor[i] = sco;
 			cm->cd[sco].block = t;
 		}
 		/* find loop must have run at least once */
 		lastt->tptr[b] = t;
 		newarc(v->nfa, PLAIN, sco, lp, rp);
 		cm->cd[co].nchrs -= BYTTAB;
 		cm->cd[sco].nchrs += BYTTAB;
 		return;
 	}
 	/* general case, a mixed block to be altered */
 	i = 0;
 	while (i < BYTTAB)
 	{
 		co = t->tcolor[i];
 		sco = newsub(cm, co);
 		newarc(v->nfa, PLAIN, sco, lp, rp);
 		previ = i;
 		do
 		{
 			t->tcolor[i++] = sco;
 		} while (i < BYTTAB && t->tcolor[i] == co);
 		ndone = i - previ;
 		cm->cd[co].nchrs -= ndone;
 		cm->cd[sco].nchrs += ndone;
 	}
 }
 /*
 * okcolors - promote subcolors to full colors
 */
 static void
 okcolors(struct nfa * nfa,
 		 struct colormap * cm)
 {
 	struct colordesc *cd;
 	struct colordesc *end = CDEND(cm);
 	struct colordesc *scd;
 	struct arc *a;
 	color		co;
 	color		sco;
 	for (cd = cm->cd, co = 0; cd < end; cd++, co++)
 	{
 		sco = cd->sub;
 		if (UNUSEDCOLOR(cd) || sco == NOSUB)
 		{
 			/* has no subcolor, no further action */
 		}
 		else if (sco == co)
 		{
 			/* is subcolor, let parent deal with it */
 		}
 		else if (cd->nchrs == 0)
 		{
 			/* parent empty, its arcs change color to subcolor */
 			cd->sub = NOSUB;
 			scd = &cm->cd[sco];
 			assert(scd->nchrs > 0);
 			assert(scd->sub == sco);
 			scd->sub = NOSUB;
 			while ((a = cd->arcs) != NULL)
 			{
 				assert(a->co == co);
 				/* uncolorchain(cm, a); */
 				cd->arcs = a->colorchain;
 				a->co = sco;
 				/* colorchain(cm, a); */
 				a->colorchain = scd->arcs;
 				scd->arcs = a;
 			}
 			freecolor(cm, co);
 		}
 		else
 		{
 			/* parent's arcs must gain parallel subcolor arcs */
 			cd->sub = NOSUB;
 			scd = &cm->cd[sco];
 			assert(scd->nchrs > 0);
 			assert(scd->sub == sco);
 			scd->sub = NOSUB;
 			for (a = cd->arcs; a != NULL; a = a->colorchain)
 			{
 				assert(a->co == co);
 				newarc(nfa, a->type, sco, a->from, a->to);
 			}
 		}
 	}
 }
 /*
 * colorchain - add this arc to the color chain of its color
 */
 static void
 colorchain(struct colormap * cm,
 		   struct arc * a)
 {
 	struct colordesc *cd = &cm->cd[a->co];
 	a->colorchain = cd->arcs;
 	cd->arcs = a;
 }
 /*
 * uncolorchain - delete this arc from the color chain of its color
 */
 static void
 uncolorchain(struct colormap * cm,
 			 struct arc * a)
 {
 	struct colordesc *cd = &cm->cd[a->co];
 	struct arc *aa;
 	aa = cd->arcs;
 	if (aa == a)				/* easy case */
 		cd->arcs = a->colorchain;
 	else
 	{
 		for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain)
 			continue;
 		assert(aa != NULL);
 		aa->colorchain = a->colorchain;
 	}
 	a->colorchain = NULL;		/* paranoia */
 }
 /*
 * singleton - is this character in its own color?
 */
 static int						/* predicate */
 singleton(struct colormap * cm,
 		  chr c)
 {
 	color		co;				/* color of c */
 	co = GETCOLOR(cm, c);
 	if (cm->cd[co].nchrs == 1 && cm->cd[co].sub == NOSUB)
 		return 1;
 	return 0;
 }
 /*
 * rainbow - add arcs of all full colors (but one) between specified states
 */
 static void
 rainbow(struct nfa * nfa,
 		struct colormap * cm,
 		int type,
 		pcolor but,				/* COLORLESS if no exceptions */
 		struct state * from,
 		struct state * to)
 {
 	struct colordesc *cd;
 	struct colordesc *end = CDEND(cm);
 	color		co;
 	for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
 		if (!UNUSEDCOLOR(cd) && cd->sub != co && co != but &&
 			!(cd->flags & PSEUDO))
 			newarc(nfa, type, co, from, to);
 }
 /*
 * colorcomplement - add arcs of complementary colors
 *
 * The calling sequence ought to be reconciled with cloneouts().
 */
 static void
 colorcomplement(struct nfa * nfa,
 				struct colormap * cm,
 				int type,
 				struct state * of,		/* complements of this guy's PLAIN
 										 * outarcs */
 				struct state * from,
 				struct state * to)
 {
 	struct colordesc *cd;
 	struct colordesc *end = CDEND(cm);
 	color		co;
 	assert(of != from);
 	for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
 		if (!UNUSEDCOLOR(cd) && !(cd->flags & PSEUDO))
 			if (findarc(of, PLAIN, co) == NULL)
 				newarc(nfa, type, co, from, to);
 }
 #ifdef REG_DEBUG
 /*
 * dumpcolors - debugging output
 */
 static void
 dumpcolors(struct colormap * cm,
 		   FILE *f)
 {
 	struct colordesc *cd;
 	struct colordesc *end;
 	color		co;
 	chr			c;
 	char	   *has;
 	fprintf(f, "max %ld\n", (long) cm->max);
 	if (NBYTS > 1)
 		fillcheck(cm, cm->tree, 0, f);
 	end = CDEND(cm);
 	for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++) /* skip 0 */
 		if (!UNUSEDCOLOR(cd))
 		{
 			assert(cd->nchrs > 0);
 			has = (cd->block != NULL) ? "#" : "";
 			if (cd->flags & PSEUDO)
 				fprintf(f, "#%2ld%s(ps): ", (long) co, has);
 			else
 				fprintf(f, "#%2ld%s(%2d): ", (long) co,
 						has, cd->nchrs);
 			/* it's hard to do this more efficiently */
 			for (c = CHR_MIN; c < CHR_MAX; c++)
 				if (GETCOLOR(cm, c) == co)
 					dumpchr(c, f);
 			assert(c == CHR_MAX);
 			if (GETCOLOR(cm, c) == co)
 				dumpchr(c, f);
 			fprintf(f, "\n");
 		}
 }
 /*
 * fillcheck - check proper filling of a tree
 */
 static void
 fillcheck(struct colormap * cm,
 		  union tree * tree,
 		  int level,			/* level number (top == 0) of this block */
 		  FILE *f)
 {
 	int			i;
 	union tree *t;
 	union tree *fillt = &cm->tree[level + 1];
 	assert(level < NBYTS - 1);	/* this level has pointers */
 	for (i = BYTTAB - 1; i >= 0; i--)
 	{
 		t = tree->tptr[i];
 		if (t == NULL)
 			fprintf(f, "NULL found in filled tree!\n");
 		else if (t == fillt)
 		{
 		}
 		else if (level < NBYTS - 2)		/* more pointer blocks below */
 			fillcheck(cm, t, level + 1, f);
 	}
 }
 /*
 * dumpchr - print a chr
 *
 * Kind of char-centric but works well enough for debug use.
 */
 static void
 dumpchr(chr c,
 		FILE *f)
 {
 	if (c == '\\')
 		fprintf(f, "\\\\");
 	else if (c > ' ' && c <= '~')
 		putc((char) c, f);
 	else
 		fprintf(f, "\\u%04lx", (long) c);
 }
 #endif   /* REG_DEBUG */
--- a/src/regex/regc_cvec.c
+++ b/src/regex/regc_cvec.c
@@ -1,189 +0,0 @@
 /*
 * Utility functions for handling cvecs
 * This file is #included by regcomp.c.
 *
 * Copyright (c) 1998, 1999 Henry Spencer.	All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation
 * of software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Header$
 *
 */
 /*
 * newcvec - allocate a new cvec
 */
 static struct cvec *
 newcvec(int nchrs,				/* to hold this many chrs... */
 		int nranges,			/* ... and this many ranges... */
 		int nmcces)				/* ... and this many MCCEs */
 {
 	size_t		n;
 	size_t		nc;
 	struct cvec *cv;
 	nc = (size_t) nchrs + (size_t) nmcces *(MAXMCCE + 1) + (size_t) nranges *2;
 	n = sizeof(struct cvec) + (size_t) (nmcces - 1) * sizeof(chr *)
 		+ nc * sizeof(chr);
 	cv = (struct cvec *) MALLOC(n);
 	if (cv == NULL)
 		return NULL;
 	cv->chrspace = nchrs;
 	cv->chrs = (chr *) &cv->mcces[nmcces];		/* chrs just after MCCE
 												 * ptrs */
 	cv->mccespace = nmcces;
 	cv->ranges = cv->chrs + nchrs + nmcces * (MAXMCCE + 1);
 	cv->rangespace = nranges;
 	return clearcvec(cv);
 }
 /*
 * clearcvec - clear a possibly-new cvec
 * Returns pointer as convenience.
 */
 static struct cvec *
 clearcvec(struct cvec * cv)
 {
 	int			i;
 	assert(cv != NULL);
 	cv->nchrs = 0;
 	assert(cv->chrs == (chr *) &cv->mcces[cv->mccespace]);
 	cv->nmcces = 0;
 	cv->nmccechrs = 0;
 	cv->nranges = 0;
 	for (i = 0; i < cv->mccespace; i++)
 		cv->mcces[i] = NULL;
 	return cv;
 }
 /*
 * addchr - add a chr to a cvec
 */
 static void
 addchr(struct cvec * cv,		/* character vector */
 	   chr c)					/* character to add */
 {
 	assert(cv->nchrs < cv->chrspace - cv->nmccechrs);
 	cv->chrs[cv->nchrs++] = (chr) c;
 }
 /*
 * addrange - add a range to a cvec
 */
 static void
 addrange(struct cvec * cv,		/* character vector */
 		 chr from,				/* first character of range */
 		 chr to)				/* last character of range */
 {
 	assert(cv->nranges < cv->rangespace);
 	cv->ranges[cv->nranges * 2] = (chr) from;
 	cv->ranges[cv->nranges * 2 + 1] = (chr) to;
 	cv->nranges++;
 }
 /*
 * addmcce - add an MCCE to a cvec
 */
 static void
 addmcce(struct cvec * cv,		/* character vector */
 		chr *startp,			/* beginning of text */
 		chr *endp)				/* just past end of text */
 {
 	int			len;
 	int			i;
 	chr		   *s;
 	chr		   *d;
 	if (startp == NULL && endp == NULL)
 		return;
 	len = endp - startp;
 	assert(len > 0);
 	assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs);
 	assert(cv->nmcces < cv->mccespace);
 	d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1];
 	cv->mcces[cv->nmcces++] = d;
 	for (s = startp, i = len; i > 0; s++, i--)
 		*d++ = *s;
 	*d++ = 0;					/* endmarker */
 	assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]);
 	cv->nmccechrs += len + 1;
 }
 /*
 * haschr - does a cvec contain this chr?
 */
 static int						/* predicate */
 haschr(struct cvec * cv,		/* character vector */
 	   chr c)					/* character to test for */
 {
 	int			i;
 	chr		   *p;
 	for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--)
 	{
 		if (*p == c)
 			return 1;
 	}
 	for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--)
 	{
 		if ((*p <= c) && (c <= *(p + 1)))
 			return 1;
 	}
 	return 0;
 }
 /*
 * getcvec - get a cvec, remembering it as v->cv
 */
 static struct cvec *
 getcvec(struct vars * v,		/* context */
 		int nchrs,				/* to hold this many chrs... */
 		int nranges,			/* ... and this many ranges... */
 		int nmcces)				/* ... and this many MCCEs */
 {
 	if (v->cv != NULL && nchrs <= v->cv->chrspace &&
 		nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace)
 		return clearcvec(v->cv);
 	if (v->cv != NULL)
 		freecvec(v->cv);
 	v->cv = newcvec(nchrs, nranges, nmcces);
 	if (v->cv == NULL)
 		ERR(REG_ESPACE);
 	return v->cv;
 }
 /*
 * freecvec - free a cvec
 */
 static void
 freecvec(struct cvec * cv)
 {
 	FREE(cv);
 }
--- a/src/regex/regc_lex.c
+++ b/src/regex/regc_lex.c
--- a/src/regex/regc_locale.c
+++ b/src/regex/regc_locale.c
@@ -1,838 +0,0 @@
 /*
 * regc_locale.c --
 *
 *	This file contains locale-specific regexp routines.
 *	This file is #included by regcomp.c.
 *
 * Copyright (c) 1998 by Scriptics Corporation.
 *
 * This software is copyrighted by the Regents of the University of
 * California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
 * Corporation and other parties.  The following terms apply to all files
 * associated with the software unless explicitly disclaimed in
 * individual files.
 *
 * The authors hereby grant permission to use, copy, modify, distribute,
 * and license this software and its documentation for any purpose, provided
 * that existing copyright notices are retained in all copies and that this
 * notice is included verbatim in any distributions. No written agreement,
 * license, or royalty fee is required for any of the authorized uses.
 * Modifications to this software may be copyrighted by their authors
 * and need not follow the licensing terms described here, provided that
 * the new terms are clearly indicated on the first page of each file where
 * they apply.
 *
 * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
 * DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.	THIS SOFTWARE
 * IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
 * NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
 * MODIFICATIONS.
 *
 * GOVERNMENT USE: If you are acquiring this software on behalf of the
 * U.S. government, the Government shall have only "Restricted Rights"
 * in the software and related documentation as defined in the Federal
 * Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).	If you
 * are acquiring the software on behalf of the Department of Defense, the
 * software shall be classified as "Commercial Computer Software" and the
 * Government shall have only "Restricted Rights" as defined in Clause
 * 252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the
 * authors grant the U.S. Government and others acting in its behalf
 * permission to use and distribute the software in accordance with the
 * terms specified in this license.
 *
 * $Header$
 */
 int char_and_wchar_strncmp (const char* cp, const wx_wchar* wp, size_t nNum)
 {
 	while(*cp++ == (const char)*wp++ && --nNum){}
 	return nNum;
 }
 /* ASCII character-name table */
 static struct cname
 {
 	char	   *name;
 	char		code;
 }	cnames[] =
 {
 	{
 		"NUL", '\0'
 	},
 	{
 		"SOH", '\001'
 	},
 	{
 		"STX", '\002'
 	},
 	{
 		"ETX", '\003'
 	},
 	{
 		"EOT", '\004'
 	},
 	{
 		"ENQ", '\005'
 	},
 	{
 		"ACK", '\006'
 	},
 	{
 		"BEL", '\007'
 	},
 	{
 		"alert", '\007'
 	},
 	{
 		"BS", '\010'
 	},
 	{
 		"backspace", '\b'
 	},
 	{
 		"HT", '\011'
 	},
 	{
 		"tab", '\t'
 	},
 	{
 		"LF", '\012'
 	},
 	{
 		"newline", '\n'
 	},
 	{
 		"VT", '\013'
 	},
 	{
 		"vertical-tab", '\v'
 	},
 	{
 		"FF", '\014'
 	},
 	{
 		"form-feed", '\f'
 	},
 	{
 		"CR", '\015'
 	},
 	{
 		"carriage-return", '\r'
 	},
 	{
 		"SO", '\016'
 	},
 	{
 		"SI", '\017'
 	},
 	{
 		"DLE", '\020'
 	},
 	{
 		"DC1", '\021'
 	},
 	{
 		"DC2", '\022'
 	},
 	{
 		"DC3", '\023'
 	},
 	{
 		"DC4", '\024'
 	},
 	{
 		"NAK", '\025'
 	},
 	{
 		"SYN", '\026'
 	},
 	{
 		"ETB", '\027'
 	},
 	{
 		"CAN", '\030'
 	},
 	{
 		"EM", '\031'
 	},
 	{
 		"SUB", '\032'
 	},
 	{
 		"ESC", '\033'
 	},
 	{
 		"IS4", '\034'
 	},
 	{
 		"FS", '\034'
 	},
 	{
 		"IS3", '\035'
 	},
 	{
 		"GS", '\035'
 	},
 	{
 		"IS2", '\036'
 	},
 	{
 		"RS", '\036'
 	},
 	{
 		"IS1", '\037'
 	},
 	{
 		"US", '\037'
 	},
 	{
 		"space", ' '
 	},
 	{
 		"exclamation-mark", '!'
 	},
 	{
 		"quotation-mark", '"'
 	},
 	{
 		"number-sign", '#'
 	},
 	{
 		"dollar-sign", '$'
 	},
 	{
 		"percent-sign", '%'
 	},
 	{
 		"ampersand", '&'
 	},
 	{
 		"apostrophe", '\''
 	},
 	{
 		"left-parenthesis", '('
 	},
 	{
 		"right-parenthesis", ')'
 	},
 	{
 		"asterisk", '*'
 	},
 	{
 		"plus-sign", '+'
 	},
 	{
 		"comma", ','
 	},
 	{
 		"hyphen", '-'
 	},
 	{
 		"hyphen-minus", '-'
 	},
 	{
 		"period", '.'
 	},
 	{
 		"full-stop", '.'
 	},
 	{
 		"slash", '/'
 	},
 	{
 		"solidus", '/'
 	},
 	{
 		"zero", '0'
 	},
 	{
 		"one", '1'
 	},
 	{
 		"two", '2'
 	},
 	{
 		"three", '3'
 	},
 	{
 		"four", '4'
 	},
 	{
 		"five", '5'
 	},
 	{
 		"six", '6'
 	},
 	{
 		"seven", '7'
 	},
 	{
 		"eight", '8'
 	},
 	{
 		"nine", '9'
 	},
 	{
 		"colon", ':'
 	},
 	{
 		"semicolon", ';'
 	},
 	{
 		"less-than-sign", '<'
 	},
 	{
 		"equals-sign", '='
 	},
 	{
 		"greater-than-sign", '>'
 	},
 	{
 		"question-mark", '?'
 	},
 	{
 		"commercial-at", '@'
 	},
 	{
 		"left-square-bracket", '['
 	},
 	{
 		"backslash", '\\'
 	},
 	{
 		"reverse-solidus", '\\'
 	},
 	{
 		"right-square-bracket", ']'
 	},
 	{
 		"circumflex", '^'
 	},
 	{
 		"circumflex-accent", '^'
 	},
 	{
 		"underscore", '_'
 	},
 	{
 		"low-line", '_'
 	},
 	{
 		"grave-accent", '`'
 	},
 	{
 		"left-brace", '{'
 	},
 	{
 		"left-curly-bracket", '{'
 	},
 	{
 		"vertical-line", '|'
 	},
 	{
 		"right-brace", '}'
 	},
 	{
 		"right-curly-bracket", '}'
 	},
 	{
 		"tilde", '~'
 	},
 	{
 		"DEL", '\177'
 	},
 	{
 		NULL, 0
 	}
 };
 /*
 * some ctype functions with non-ascii-char guard
 */
 static int
 wx_isdigit(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && isdigit((unsigned char) c));
 }
 static int
 wx_isalpha(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && isalpha((unsigned char) c));
 }
 static int
 wx_isalnum(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && isalnum((unsigned char) c));
 }
 static int
 wx_isupper(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && isupper((unsigned char) c));
 }
 static int
 wx_islower(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && islower((unsigned char) c));
 }
 static int
 wx_isgraph(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && isgraph((unsigned char) c));
 }
 static int
 wx_ispunct(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && ispunct((unsigned char) c));
 }
 static int
 wx_isspace(wx_wchar c)
 {
 	return (c >= 0 && c <= UCHAR_MAX && isspace((unsigned char) c));
 }
 static wx_wchar
 wx_toupper(wx_wchar c)
 {
 	if (c >= 0 && c <= UCHAR_MAX)
 		return toupper((unsigned char) c);
 	return c;
 }
 static wx_wchar
 wx_tolower(wx_wchar c)
 {
 	if (c >= 0 && c <= UCHAR_MAX)
 		return tolower((unsigned char) c);
 	return c;
 }
 /*
 * nmcces - how many distinct MCCEs are there?
 */
 static int
 nmcces(struct vars * v)
 {
 	/*
 	 * No multi-character collating elements defined at the moment.
 	 */
 	return 0;
 }
 /*
 * nleaders - how many chrs can be first chrs of MCCEs?
 */
 static int
 nleaders(struct vars * v)
 {
 	return 0;
 }
 /*
 * allmcces - return a cvec with all the MCCEs of the locale
 */
 static struct cvec *
 allmcces(struct vars * v,		/* context */
 		 struct cvec * cv)		/* this is supposed to have enough room */
 {
 	return clearcvec(cv);
 }
 /*
 * element - map collating-element name to celt
 */
 static celt
 element(struct vars * v,		/* context */
 		chr *startp,			/* points to start of name */
 		chr *endp)				/* points just past end of name */
 {
 	struct cname *cn;
 	size_t		len;
 	/* generic:  one-chr names stand for themselves */
 	assert(startp < endp);
 	len = endp - startp;
 	if (len == 1)
 		return *startp;
 	NOTE(REG_ULOCALE);
 	/* search table */
 	for (cn = cnames; cn->name != NULL; cn++)
 	{
 		if (strlen(cn->name) == len &&
 			char_and_wchar_strncmp(cn->name, startp, len) == 0)
 		{
 			break;				/* NOTE BREAK OUT */
 		}
 	}
 	if (cn->name != NULL)
 		return CHR(cn->code);
 	/* couldn't find it */
 	ERR(REG_ECOLLATE);
 	return 0;
 }
 /*
 * range - supply cvec for a range, including legality check
 */
 static struct cvec *
 range(struct vars * v,			/* context */
 	  celt a,					/* range start */
 	  celt b,					/* range end, might equal a */
 	  int cases)				/* case-independent? */
 {
 	int			nchrs;
 	struct cvec *cv;
 	celt		c,
 				lc,
 				uc;
 	if (a != b && !before(a, b))
 	{
 		ERR(REG_ERANGE);
 		return NULL;
 	}
 	if (!cases)
 	{							/* easy version */
 		cv = getcvec(v, 0, 1, 0);
 		NOERRN();
 		addrange(cv, a, b);
 		return cv;
 	}
 	/*
 	 * When case-independent, it's hard to decide when cvec ranges are
 	 * usable, so for now at least, we won't try.  We allocate enough
 	 * space for two case variants plus a little extra for the two title
 	 * case variants.
 	 */
 	nchrs = (b - a + 1) * 2 + 4;
 	cv = getcvec(v, nchrs, 0, 0);
 	NOERRN();
 	for (c = a; c <= b; c++)
 	{
 		addchr(cv, c);
 		lc = wx_tolower((chr) c);
 		if (c != lc)
 			addchr(cv, lc);
 		uc = wx_toupper((chr) c);
 		if (c != uc)
 			addchr(cv, uc);
 	}
 	return cv;
 }
 /*
 * before - is celt x before celt y, for purposes of range legality?
 */
 static int						/* predicate */
 before(celt x, celt y)
 {
 	/* trivial because no MCCEs */
 	if (x < y)
 		return 1;
 	return 0;
 }
 /*
 * eclass - supply cvec for an equivalence class
 * Must include case counterparts on request.
 */
 static struct cvec *
 eclass(struct vars * v,			/* context */
 	   celt c,					/* Collating element representing the
 								 * equivalence class. */
 	   int cases)				/* all cases? */
 {
 	struct cvec *cv;
 	/* crude fake equivalence class for testing */
 	if ((v->cflags & REG_FAKE) && c == 'x')
 	{
 		cv = getcvec(v, 4, 0, 0);
 		addchr(cv, (chr) 'x');
 		addchr(cv, (chr) 'y');
 		if (cases)
 		{
 			addchr(cv, (chr) 'X');
 			addchr(cv, (chr) 'Y');
 		}
 		return cv;
 	}
 	/* otherwise, none */
 	if (cases)
 		return allcases(v, c);
 	cv = getcvec(v, 1, 0, 0);
 	assert(cv != NULL);
 	addchr(cv, (chr) c);
 	return cv;
 }
 /*
 * cclass - supply cvec for a character class
 *
 * Must include case counterparts on request.
 */
 static struct cvec *
 cclass(struct vars * v,			/* context */
 	   chr *startp,				/* where the name starts */
 	   chr *endp,				/* just past the end of the name */
 	   int cases)				/* case-independent? */
 {
 	size_t		len;
 	struct cvec *cv = NULL;
 	char	  **namePtr;
 	int			i,
 				index;
 	/*
 	 * The following arrays define the valid character class names.
 	 */
 	static char *classNames[] = {
 		"alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph",
 		"lower", "print", "punct", "space", "upper", "xdigit", NULL
 	};
 	enum classes
 	{
 		CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH,
 		CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_XDIGIT
 	};
 	/*
 	 * Map the name to the corresponding enumerated value.
 	 */
 	len = endp - startp;
 	index = -1;
 	for (namePtr = classNames, i = 0; *namePtr != NULL; namePtr++, i++)
 	{
 		if (strlen(*namePtr) == len &&
 			char_and_wchar_strncmp(*namePtr, startp, len) == 0)
 		{
 			index = i;
 			break;
 		}
 	}
 	if (index == -1)
 	{
 		ERR(REG_ECTYPE);
 		return NULL;
 	}
 	/*
 	 * Remap lower and upper to alpha if the match is case insensitive.
 	 */
 	if (cases &&
 		((enum classes) index == CC_LOWER ||
 		 (enum classes) index == CC_UPPER))
 		index = (int) CC_ALPHA;
 	/*
 	 * Now compute the character class contents.
 	 *
 	 * For the moment, assume that only char codes < 256 can be in these
 	 * classes.
 	 */
 	switch ((enum classes) index)
 	{
 		case CC_PRINT:
 		case CC_ALNUM:
 			cv = getcvec(v, UCHAR_MAX, 1, 0);
 			if (cv)
 			{
 				for (i = 0; i <= UCHAR_MAX; i++)
 				{
 					if (wx_isalpha((chr) i))
 						addchr(cv, (chr) i);
 				}
 				addrange(cv, (chr) '0', (chr) '9');
 			}
 			break;
 		case CC_ALPHA:
 			cv = getcvec(v, UCHAR_MAX, 0, 0);
 			if (cv)
 			{
 				for (i = 0; i <= UCHAR_MAX; i++)
 				{
 					if (wx_isalpha((chr) i))
 						addchr(cv, (chr) i);
 				}
 			}
 			break;
 		case CC_ASCII:
 			cv = getcvec(v, 0, 1, 0);
 			if (cv)
 				addrange(cv, 0, 0x7f);
 			break;
 		case CC_BLANK:
 			cv = getcvec(v, 2, 0, 0);
 			addchr(cv, '\t');
 			addchr(cv, ' ');
 			break;
 		case CC_CNTRL:
 			cv = getcvec(v, 0, 2, 0);
 			addrange(cv, 0x0, 0x1f);
 			addrange(cv, 0x7f, 0x9f);
 			break;
 		case CC_DIGIT:
 			cv = getcvec(v, 0, 1, 0);
 			if (cv)
 				addrange(cv, (chr) '0', (chr) '9');
 			break;
 		case CC_PUNCT:
 			cv = getcvec(v, UCHAR_MAX, 0, 0);
 			if (cv)
 			{
 				for (i = 0; i <= UCHAR_MAX; i++)
 				{
 					if (wx_ispunct((chr) i))
 						addchr(cv, (chr) i);
 				}
 			}
 			break;
 		case CC_XDIGIT:
 			cv = getcvec(v, 0, 3, 0);
 			if (cv)
 			{
 				addrange(cv, '0', '9');
 				addrange(cv, 'a', 'f');
 				addrange(cv, 'A', 'F');
 			}
 			break;
 		case CC_SPACE:
 			cv = getcvec(v, UCHAR_MAX, 0, 0);
 			if (cv)
 			{
 				for (i = 0; i <= UCHAR_MAX; i++)
 				{
 					if (wx_isspace((chr) i))
 						addchr(cv, (chr) i);
 				}
 			}
 			break;
 		case CC_LOWER:
 			cv = getcvec(v, UCHAR_MAX, 0, 0);
 			if (cv)
 			{
 				for (i = 0; i <= UCHAR_MAX; i++)
 				{
 					if (wx_islower((chr) i))
 						addchr(cv, (chr) i);
 				}
 			}
 			break;
 		case CC_UPPER:
 			cv = getcvec(v, UCHAR_MAX, 0, 0);
 			if (cv)
 			{
 				for (i = 0; i <= UCHAR_MAX; i++)
 				{
 					if (wx_isupper((chr) i))
 						addchr(cv, (chr) i);
 				}
 			}
 			break;
 		case CC_GRAPH:
 			cv = getcvec(v, UCHAR_MAX, 0, 0);
 			if (cv)
 			{
 				for (i = 0; i <= UCHAR_MAX; i++)
 				{
 					if (wx_isgraph((chr) i))
 						addchr(cv, (chr) i);
 				}
 			}
 			break;
 	}
 	if (cv == NULL)
 		ERR(REG_ESPACE);
 	return cv;
 }
 /*
 * allcases - supply cvec for all case counterparts of a chr (including itself)
 *
 * This is a shortcut, preferably an efficient one, for simple characters;
 * messy cases are done via range().
 */
 static struct cvec *
 allcases(struct vars * v,		/* context */
 		 chr pc)				/* character to get case equivs of */
 {
 	struct cvec *cv;
 	chr			c = (chr) pc;
 	chr			lc,
 				uc;
 	lc = wx_tolower((chr) c);
 	uc = wx_toupper((chr) c);
 	cv = getcvec(v, 2, 0, 0);
 	addchr(cv, lc);
 	if (lc != uc)
 		addchr(cv, uc);
 	return cv;
 }
 /*
 * cmp - chr-substring compare
 *
 * Backrefs need this.	It should preferably be efficient.
 * Note that it does not need to report anything except equal/unequal.
 * Note also that the length is exact, and the comparison should not
 * stop at embedded NULs!
 */
 static int						/* 0 for equal, nonzero for unequal */
 cmp(const chr *x, const chr *y, /* strings to compare */
 	size_t len)					/* exact length of comparison */
 {
 	return memcmp(VS(x), VS(y), len * sizeof(chr));
 }
 /*
 * casecmp - case-independent chr-substring compare
 *
 * REG_ICASE backrefs need this.  It should preferably be efficient.
 * Note that it does not need to report anything except equal/unequal.
 * Note also that the length is exact, and the comparison should not
 * stop at embedded NULs!
 */
 static int						/* 0 for equal, nonzero for unequal */
 casecmp(const chr *x, const chr *y,		/* strings to compare */
 		size_t len)				/* exact length of comparison */
 {
 	for (; len > 0; len--, x++, y++)
 	{
 		if ((*x != *y) && (wx_tolower(*x) != wx_tolower(*y)))
 			return 1;
 	}
 	return 0;
 }
--- a/src/regex/regc_nfa.c
+++ b/src/regex/regc_nfa.c
--- a/src/regex/rege_dfa.c
+++ b/src/regex/rege_dfa.c
@@ -1,699 +0,0 @@
 /*
 * DFA routines
 * This file is #included by regexec.c.
 *
 * Copyright (c) 1998, 1999 Henry Spencer.	All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation
 * of software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Header$
 *
 */
 /*
 * longest - longest-preferred matching engine
 */
 static chr *					/* endpoint, or NULL */
 longest(struct vars * v,		/* used only for debug and exec flags */
 		struct dfa * d,
 		chr *start,				/* where the match should start */
 		chr *stop,				/* match must end at or before here */
 		int *hitstopp)			/* record whether hit v->stop, if non-NULL */
 {
 	chr		   *cp;
 	chr		   *realstop = (stop == v->stop) ? stop : stop + 1;
 	color		co;
 	struct sset *css;
 	struct sset *ss;
 	chr		   *post;
 	int			i;
 	struct colormap *cm = d->cm;
 	/* initialize */
 	css = initialize(v, d, start);
 	cp = start;
 	if (hitstopp != NULL)
 		*hitstopp = 0;
 	/* startup */
 	FDEBUG(("+++ startup +++\n"));
 	if (cp == v->start)
 	{
 		co = d->cnfa->bos[(v->eflags & REG_NOTBOL) ? 0 : 1];
 		FDEBUG(("color %ld\n", (long) co));
 	}
 	else
 	{
 		co = GETCOLOR(cm, *(cp - 1));
 		FDEBUG(("char %c, color %ld\n", (char) *(cp - 1), (long) co));
 	}
 	css = miss(v, d, css, co, cp, start);
 	if (css == NULL)
 		return NULL;
 	css->lastseen = cp;
 	/* main loop */
 	if (v->eflags & REG_FTRACE)
 		while (cp < realstop)
 		{
 			FDEBUG(("+++ at c%d +++\n", css - d->ssets));
 			co = GETCOLOR(cm, *cp);
 			FDEBUG(("char %c, color %ld\n", (char) *cp, (long) co));
 			ss = css->outs[co];
 			if (ss == NULL)
 			{
 				ss = miss(v, d, css, co, cp + 1, start);
 				if (ss == NULL)
 					break;		/* NOTE BREAK OUT */
 			}
 			cp++;
 			ss->lastseen = cp;
 			css = ss;
 		}
 	else
 		while (cp < realstop)
 		{
 			co = GETCOLOR(cm, *cp);
 			ss = css->outs[co];
 			if (ss == NULL)
 			{
 				ss = miss(v, d, css, co, cp + 1, start);
 				if (ss == NULL)
 					break;		/* NOTE BREAK OUT */
 			}
 			cp++;
 			ss->lastseen = cp;
 			css = ss;
 		}
 	/* shutdown */
 	FDEBUG(("+++ shutdown at c%d +++\n", css - d->ssets));
 	if (cp == v->stop && stop == v->stop)
 	{
 		if (hitstopp != NULL)
 			*hitstopp = 1;
 		co = d->cnfa->eos[(v->eflags & REG_NOTEOL) ? 0 : 1];
 		FDEBUG(("color %ld\n", (long) co));
 		ss = miss(v, d, css, co, cp, start);
 		/* special case:  match ended at eol? */
 		if (ss != NULL && (ss->flags & POSTSTATE))
 			return cp;
 		else if (ss != NULL)
 			ss->lastseen = cp;	/* to be tidy */
 	}
 	/* find last match, if any */
 	post = d->lastpost;
 	for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
 		if ((ss->flags & POSTSTATE) && post != ss->lastseen &&
 			(post == NULL || post < ss->lastseen))
 			post = ss->lastseen;
 	if (post != NULL)			/* found one */
 		return post - 1;
 	return NULL;
 }
 /*
 * shortest - shortest-preferred matching engine
 */
 static chr *					/* endpoint, or NULL */
 shortest(struct vars * v,
 		 struct dfa * d,
 		 chr *start,			/* where the match should start */
 		 chr *min,				/* match must end at or after here */
 		 chr *max,				/* match must end at or before here */
 		 chr **coldp,			/* store coldstart pointer here, if
 								 * nonNULL */
 		 int *hitstopp)			/* record whether hit v->stop, if non-NULL */
 {
 	chr		   *cp;
 	chr		   *realmin = (min == v->stop) ? min : min + 1;
 	chr		   *realmax = (max == v->stop) ? max : max + 1;
 	color		co;
 	struct sset *css;
 	struct sset *ss;
 	struct colormap *cm = d->cm;
 	/* initialize */
 	css = initialize(v, d, start);
 	cp = start;
 	if (hitstopp != NULL)
 		*hitstopp = 0;
 	/* startup */
 	FDEBUG(("--- startup ---\n"));
 	if (cp == v->start)
 	{
 		co = d->cnfa->bos[(v->eflags & REG_NOTBOL) ? 0 : 1];
 		FDEBUG(("color %ld\n", (long) co));
 	}
 	else
 	{
 		co = GETCOLOR(cm, *(cp - 1));
 		FDEBUG(("char %c, color %ld\n", (char) *(cp - 1), (long) co));
 	}
 	css = miss(v, d, css, co, cp, start);
 	if (css == NULL)
 		return NULL;
 	css->lastseen = cp;
 	ss = css;
 	/* main loop */
 	if (v->eflags & REG_FTRACE)
 		while (cp < realmax)
 		{
 			FDEBUG(("--- at c%d ---\n", css - d->ssets));
 			co = GETCOLOR(cm, *cp);
 			FDEBUG(("char %c, color %ld\n", (char) *cp, (long) co));
 			ss = css->outs[co];
 			if (ss == NULL)
 			{
 				ss = miss(v, d, css, co, cp + 1, start);
 				if (ss == NULL)
 					break;		/* NOTE BREAK OUT */
 			}
 			cp++;
 			ss->lastseen = cp;
 			css = ss;
 			if ((ss->flags & POSTSTATE) && cp >= realmin)
 				break;			/* NOTE BREAK OUT */
 		}
 	else
 		while (cp < realmax)
 		{
 			co = GETCOLOR(cm, *cp);
 			ss = css->outs[co];
 			if (ss == NULL)
 			{
 				ss = miss(v, d, css, co, cp + 1, start);
 				if (ss == NULL)
 					break;		/* NOTE BREAK OUT */
 			}
 			cp++;
 			ss->lastseen = cp;
 			css = ss;
 			if ((ss->flags & POSTSTATE) && cp >= realmin)
 				break;			/* NOTE BREAK OUT */
 		}
 	if (ss == NULL)
 		return NULL;
 	if (coldp != NULL)			/* report last no-progress state set, if
 								 * any */
 		*coldp = lastcold(v, d);
 	if ((ss->flags & POSTSTATE) && cp > min)
 	{
 		assert(cp >= realmin);
 		cp--;
 	}
 	else if (cp == v->stop && max == v->stop)
 	{
 		co = d->cnfa->eos[(v->eflags & REG_NOTEOL) ? 0 : 1];
 		FDEBUG(("color %ld\n", (long) co));
 		ss = miss(v, d, css, co, cp, start);
 		/* match might have ended at eol */
 		if ((ss == NULL || !(ss->flags & POSTSTATE)) && hitstopp != NULL)
 			*hitstopp = 1;
 	}
 	if (ss == NULL || !(ss->flags & POSTSTATE))
 		return NULL;
 	return cp;
 }
 /*
 * lastcold - determine last point at which no progress had been made
 */
 static chr *					/* endpoint, or NULL */
 lastcold(struct vars * v,
 		 struct dfa * d)
 {
 	struct sset *ss;
 	chr		   *nopr;
 	int			i;
 	nopr = d->lastnopr;
 	if (nopr == NULL)
 		nopr = v->start;
 	for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
 		if ((ss->flags & NOPROGRESS) && nopr < ss->lastseen)
 			nopr = ss->lastseen;
 	return nopr;
 }
 /*
 * newdfa - set up a fresh DFA
 */
 static struct dfa *
 newdfa(struct vars * v,
 	   struct cnfa * cnfa,
 	   struct colormap * cm,
 	   struct smalldfa * small) /* preallocated space, may be NULL */
 {
 	struct dfa *d;
 	size_t		nss = cnfa->nstates * 2;
 	int			wordsper = (cnfa->nstates + UBITS - 1) / UBITS;
 	struct smalldfa *smallwas = small;
 	assert(cnfa != NULL && cnfa->nstates != 0);
 	if (nss <= FEWSTATES && cnfa->ncolors <= FEWCOLORS)
 	{
 		assert(wordsper == 1);
 		if (small == NULL)
 		{
 			small = (struct smalldfa *) MALLOC(
 											   sizeof(struct smalldfa));
 			if (small == NULL)
 			{
 				ERR(REG_ESPACE);
 				return NULL;
 			}
 		}
 		d = &small->dfa;
 		d->ssets = small->ssets;
 		d->statesarea = small->statesarea;
 		d->work = &d->statesarea[nss];
 		d->outsarea = small->outsarea;
 		d->incarea = small->incarea;
 		d->cptsmalloced = 0;
 		d->mallocarea = (smallwas == NULL) ? (char *) small : NULL;
 	}
 	else
 	{
 		d = (struct dfa *) MALLOC(sizeof(struct dfa));
 		if (d == NULL)
 		{
 			ERR(REG_ESPACE);
 			return NULL;
 		}
 		d->ssets = (struct sset *) MALLOC(nss * sizeof(struct sset));
 		d->statesarea = (unsigned *) MALLOC((nss + WORK) * wordsper *
 											sizeof(unsigned));
 		d->work = &d->statesarea[nss * wordsper];
 		d->outsarea = (struct sset **) MALLOC(nss * cnfa->ncolors *
 											  sizeof(struct sset *));
 		d->incarea = (struct arcp *) MALLOC(nss * cnfa->ncolors *
 											sizeof(struct arcp));
 		d->cptsmalloced = 1;
 		d->mallocarea = (char *) d;
 		if (d->ssets == NULL || d->statesarea == NULL ||
 			d->outsarea == NULL || d->incarea == NULL)
 		{
 			freedfa(d);
 			ERR(REG_ESPACE);
 			return NULL;
 		}
 	}
 	d->nssets = (v->eflags & REG_SMALL) ? 7 : nss;
 	d->nssused = 0;
 	d->nstates = cnfa->nstates;
 	d->ncolors = cnfa->ncolors;
 	d->wordsper = wordsper;
 	d->cnfa = cnfa;
 	d->cm = cm;
 	d->lastpost = NULL;
 	d->lastnopr = NULL;
 	d->search = d->ssets;
 	/* initialization of sset fields is done as needed */
 	return d;
 }
 /*
 * freedfa - free a DFA
 */
 static void
 freedfa(struct dfa * d)
 {
 	if (d->cptsmalloced)
 	{
 		if (d->ssets != NULL)
 			FREE(d->ssets);
 		if (d->statesarea != NULL)
 			FREE(d->statesarea);
 		if (d->outsarea != NULL)
 			FREE(d->outsarea);
 		if (d->incarea != NULL)
 			FREE(d->incarea);
 	}
 	if (d->mallocarea != NULL)
 		FREE(d->mallocarea);
 }
 /*
 * hash - construct a hash code for a bitvector
 *
 * There are probably better ways, but they're more expensive.
 */
 static unsigned
 hash(unsigned *uv,
 	 int n)
 {
 	int			i;
 	unsigned	h;
 	h = 0;
 	for (i = 0; i < n; i++)
 		h ^= uv[i];
 	return h;
 }
 /*
 * initialize - hand-craft a cache entry for startup, otherwise get ready
 */
 static struct sset *
 initialize(struct vars * v,		/* used only for debug flags */
 		   struct dfa * d,
 		   chr *start)
 {
 	struct sset *ss;
 	int			i;
 	/* is previous one still there? */
 	if (d->nssused > 0 && (d->ssets[0].flags & STARTER))
 		ss = &d->ssets[0];
 	else
 	{							/* no, must (re)build it */
 		ss = getvacant(v, d, start, start);
 		for (i = 0; i < d->wordsper; i++)
 			ss->states[i] = 0;
 		BSET(ss->states, d->cnfa->pre);
 		ss->hash = HASH(ss->states, d->wordsper);
 		assert(d->cnfa->pre != d->cnfa->post);
 		ss->flags = STARTER | LOCKED | NOPROGRESS;
 		/* lastseen dealt with below */
 	}
 	for (i = 0; i < d->nssused; i++)
 		d->ssets[i].lastseen = NULL;
 	ss->lastseen = start;		/* maybe untrue, but harmless */
 	d->lastpost = NULL;
 	d->lastnopr = NULL;
 	return ss;
 }
 /*
 * miss - handle a cache miss
 */
 static struct sset *			/* NULL if goes to empty set */
 miss(struct vars * v,			/* used only for debug flags */
 	 struct dfa * d,
 	 struct sset * css,
 	 pcolor co,
 	 chr *cp,					/* next chr */
 	 chr *start)				/* where the attempt got started */
 {
 	struct cnfa *cnfa = d->cnfa;
 	int			i;
 	unsigned	h;
 	struct carc *ca;
 	struct sset *p;
 	int			ispost;
 	int			noprogress;
 	int			gotstate;
 	int			dolacons;
 	int			sawlacons;
 	/* for convenience, we can be called even if it might not be a miss */
 	if (css->outs[co] != NULL)
 	{
 		FDEBUG(("hit\n"));
 		return css->outs[co];
 	}
 	FDEBUG(("miss\n"));
 	/* first, what set of states would we end up in? */
 	for (i = 0; i < d->wordsper; i++)
 		d->work[i] = 0;
 	ispost = 0;
 	noprogress = 1;
 	gotstate = 0;
 	for (i = 0; i < d->nstates; i++)
 		if (ISBSET(css->states, i))
 			for (ca = cnfa->states[i] + 1; ca->co != COLORLESS; ca++)
 				if (ca->co == co)
 				{
 					BSET(d->work, ca->to);
 					gotstate = 1;
 					if (ca->to == cnfa->post)
 						ispost = 1;
 					if (!cnfa->states[ca->to]->co)
 						noprogress = 0;
 					FDEBUG(("%d -> %d\n", i, ca->to));
 				}
 	dolacons = (gotstate) ? (cnfa->flags & HASLACONS) : 0;
 	sawlacons = 0;
 	while (dolacons)
 	{							/* transitive closure */
 		dolacons = 0;
 		for (i = 0; i < d->nstates; i++)
 			if (ISBSET(d->work, i))
 				for (ca = cnfa->states[i] + 1; ca->co != COLORLESS;
 					 ca++)
 				{
 					if (ca->co <= cnfa->ncolors)
 						continue;		/* NOTE CONTINUE */
 					sawlacons = 1;
 					if (ISBSET(d->work, ca->to))
 						continue;		/* NOTE CONTINUE */
 					if (!lacon(v, cnfa, cp, ca->co))
 						continue;		/* NOTE CONTINUE */
 					BSET(d->work, ca->to);
 					dolacons = 1;
 					if (ca->to == cnfa->post)
 						ispost = 1;
 					if (!cnfa->states[ca->to]->co)
 						noprogress = 0;
 					FDEBUG(("%d :> %d\n", i, ca->to));
 				}
 	}
 	if (!gotstate)
 		return NULL;
 	h = HASH(d->work, d->wordsper);
 	/* next, is that in the cache? */
 	for (p = d->ssets, i = d->nssused; i > 0; p++, i--)
 		if (HIT(h, d->work, p, d->wordsper))
 		{
 			FDEBUG(("cached c%d\n", p - d->ssets));
 			break;				/* NOTE BREAK OUT */
 		}
 	if (i == 0)
 	{							/* nope, need a new cache entry */
 		p = getvacant(v, d, cp, start);
 		assert(p != css);
 		for (i = 0; i < d->wordsper; i++)
 			p->states[i] = d->work[i];
 		p->hash = h;
 		p->flags = (ispost) ? POSTSTATE : 0;
 		if (noprogress)
 			p->flags |= NOPROGRESS;
 		/* lastseen to be dealt with by caller */
 	}
 	if (!sawlacons)
 	{							/* lookahead conds. always cache miss */
 		FDEBUG(("c%d[%d]->c%d\n", css - d->ssets, co, p - d->ssets));
 		css->outs[co] = p;
 		css->inchain[co] = p->ins;
 		p->ins.ss = css;
 		p->ins.co = (color) co;
 	}
 	return p;
 }
 /*
 * lacon - lookahead-constraint checker for miss()
 */
 static int						/* predicate:  constraint satisfied? */
 lacon(struct vars * v,
 	  struct cnfa * pcnfa,		/* parent cnfa */
 	  chr *cp,
 	  pcolor co)				/* "color" of the lookahead constraint */
 {
 	int			n;
 	struct subre *sub;
 	struct dfa *d;
 	struct smalldfa sd;
 	chr		   *end;
 	n = co - pcnfa->ncolors;
 	assert(n < v->g->nlacons && v->g->lacons != NULL);
 	FDEBUG(("=== testing lacon %d\n", n));
 	sub = &v->g->lacons[n];
 	d = newdfa(v, &sub->cnfa, &v->g->cmap, &sd);
 	if (d == NULL)
 	{
 		ERR(REG_ESPACE);
 		return 0;
 	}
 	end = longest(v, d, cp, v->stop, (int *) NULL);
 	freedfa(d);
 	FDEBUG(("=== lacon %d match %d\n", n, (end != NULL)));
 	return (sub->subno) ? (end != NULL) : (end == NULL);
 }
 /*
 * getvacant - get a vacant state set
 * This routine clears out the inarcs and outarcs, but does not otherwise
 * clear the innards of the state set -- that's up to the caller.
 */
 static struct sset *
 getvacant(struct vars * v,		/* used only for debug flags */
 		  struct dfa * d,
 		  chr *cp,
 		  chr *start)
 {
 	int			i;
 	struct sset *ss;
 	struct sset *p;
 	struct arcp ap;
 	struct arcp lastap;
 	color		co;
 	ss = pickss(v, d, cp, start);
 	assert(!(ss->flags & LOCKED));
 	/* clear out its inarcs, including self-referential ones */
 	ap = ss->ins;
 	while ((p = ap.ss) != NULL)
 	{
 		co = ap.co;
 		FDEBUG(("zapping c%d's %ld outarc\n", p - d->ssets, (long) co));
 		p->outs[co] = NULL;
 		ap = p->inchain[co];
 		p->inchain[co].ss = NULL;		/* paranoia */
 	}
 	ss->ins.ss = NULL;
 	/* take it off the inarc chains of the ssets reached by its outarcs */
 	for (i = 0; i < d->ncolors; i++)
 	{
 		p = ss->outs[i];
 		assert(p != ss);		/* not self-referential */
 		if (p == NULL)
 			continue;			/* NOTE CONTINUE */
 		FDEBUG(("del outarc %d from c%d's in chn\n", i, p - d->ssets));
 		if (p->ins.ss == ss && p->ins.co == i)
 			p->ins = ss->inchain[i];
 		else
 		{
 			assert(p->ins.ss != NULL);
 			for (ap = p->ins; ap.ss != NULL &&
 				 !(ap.ss == ss && ap.co == i);
 				 ap = ap.ss->inchain[ap.co])
 				lastap = ap;
 			assert(ap.ss != NULL);
 			lastap.ss->inchain[lastap.co] = ss->inchain[i];
 		}
 		ss->outs[i] = NULL;
 		ss->inchain[i].ss = NULL;
 	}
 	/* if ss was a success state, may need to remember location */
 	if ((ss->flags & POSTSTATE) && ss->lastseen != d->lastpost &&
 		(d->lastpost == NULL || d->lastpost < ss->lastseen))
 		d->lastpost = ss->lastseen;
 	/* likewise for a no-progress state */
 	if ((ss->flags & NOPROGRESS) && ss->lastseen != d->lastnopr &&
 		(d->lastnopr == NULL || d->lastnopr < ss->lastseen))
 		d->lastnopr = ss->lastseen;
 	return ss;
 }
 /*
 * pickss - pick the next stateset to be used
 */
 static struct sset *
 pickss(struct vars * v,			/* used only for debug flags */
 	   struct dfa * d,
 	   chr *cp,
 	   chr *start)
 {
 	int			i;
 	struct sset *ss;
 	struct sset *end;
 	chr		   *ancient;
 	/* shortcut for cases where cache isn't full */
 	if (d->nssused < d->nssets)
 	{
 		i = d->nssused;
 		d->nssused++;
 		ss = &d->ssets[i];
 		FDEBUG(("new c%d\n", i));
 		/* set up innards */
 		ss->states = &d->statesarea[i * d->wordsper];
 		ss->flags = 0;
 		ss->ins.ss = NULL;
 		ss->ins.co = WHITE;		/* give it some value */
 		ss->outs = &d->outsarea[i * d->ncolors];
 		ss->inchain = &d->incarea[i * d->ncolors];
 		for (i = 0; i < d->ncolors; i++)
 		{
 			ss->outs[i] = NULL;
 			ss->inchain[i].ss = NULL;
 		}
 		return ss;
 	}
 	/* look for oldest, or old enough anyway */
 	if (cp - start > d->nssets * 2 / 3) /* oldest 33% are expendable */
 		ancient = cp - d->nssets * 2 / 3;
 	else
 		ancient = start;
 	for (ss = d->search, end = &d->ssets[d->nssets]; ss < end; ss++)
 		if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
 			!(ss->flags & LOCKED))
 		{
 			d->search = ss + 1;
 			FDEBUG(("replacing c%d\n", ss - d->ssets));
 			return ss;
 		}
 	for (ss = d->ssets, end = d->search; ss < end; ss++)
 		if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
 			!(ss->flags & LOCKED))
 		{
 			d->search = ss + 1;
 			FDEBUG(("replacing c%d\n", ss - d->ssets));
 			return ss;
 		}
 	/* nobody's old enough?!? -- something's really wrong */
 	FDEBUG(("can't find victim to replace!\n"));
 	assert(NOTREACHED);
 	ERR(REG_ASSERT);
 	return d->ssets;
 }
--- a/src/regex/regerrs.h
+++ b/src/regex/regerrs.h
@@ -1,75 +0,0 @@
 /*
 * $Id$
 */
 {
 	REG_OKAY, "REG_OKAY", "no errors detected"
 },
 {
 	REG_NOMATCH, "REG_NOMATCH", "failed to match"
 },
 {
 	REG_BADPAT, "REG_BADPAT", "invalid regexp (reg version 0.8)"
 },
 {
 	REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element"
 },
 {
 	REG_ECTYPE, "REG_ECTYPE", "invalid character class"
 },
 {
 	REG_EESCAPE, "REG_EESCAPE", "invalid escape \\ sequence"
 },
 {
 	REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"
 },
 {
 	REG_EBRACK, "REG_EBRACK", "brackets [] not balanced"
 },
 {
 	REG_EPAREN, "REG_EPAREN", "parentheses () not balanced"
 },
 {
 	REG_EBRACE, "REG_EBRACE", "braces {} not balanced"
 },
 {
 	REG_BADBR, "REG_BADBR", "invalid repetition count(s)"
 },
 {
 	REG_ERANGE, "REG_ERANGE", "invalid character range"
 },
 {
 	REG_ESPACE, "REG_ESPACE", "out of memory"
 },
 {
 	REG_BADRPT, "REG_BADRPT", "quantifier operand invalid"
 },
 {
 	REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug"
 },
 {
 	REG_INVARG, "REG_INVARG", "invalid argument to regex function"
 },
 {
 	REG_MIXED, "REG_MIXED", "character widths of regex and string differ"
 },
 {
 	REG_BADOPT, "REG_BADOPT", "invalid embedded option"
 },
--- a/src/regex/regex.7
+++ b/src/regex/regex.7
@@ -0,0 +1,235 @@
 .TH REGEX 7 "25 Oct 1995"
 .BY "Henry Spencer"
 .SH NAME
 regex \- POSIX 1003.2 regular expressions
 .SH DESCRIPTION
 Regular expressions (``RE''s),
 as defined in POSIX 1003.2, come in two forms:
 modern REs (roughly those of
 .IR egrep ;
 1003.2 calls these ``extended'' REs)
 and obsolete REs (roughly those of
 .IR ed ;
 1003.2 ``basic'' REs).
 Obsolete REs mostly exist for backward compatibility in some old programs;
 they will be discussed at the end.
 1003.2 leaves some aspects of RE syntax and semantics open;
 `\(dg' marks decisions on these aspects that
 may not be fully portable to other 1003.2 implementations.
 .PP
 A (modern) RE is one\(dg or more non-empty\(dg \fIbranches\fR,
 separated by `|'.
 It matches anything that matches one of the branches.
 .PP
 A branch is one\(dg or more \fIpieces\fR, concatenated.
 It matches a match for the first, followed by a match for the second, etc.
 .PP
 A piece is an \fIatom\fR possibly followed
 by a single\(dg `*', `+', `?', or \fIbound\fR.
 An atom followed by `*' matches a sequence of 0 or more matches of the atom.
 An atom followed by `+' matches a sequence of 1 or more matches of the atom.
 An atom followed by `?' matches a sequence of 0 or 1 matches of the atom.
 .PP
 A \fIbound\fR is `{' followed by an unsigned decimal integer,
 possibly followed by `,'
 possibly followed by another unsigned decimal integer,
 always followed by `}'.
 The integers must lie between 0 and RE_DUP_MAX (255\(dg) inclusive,
 and if there are two of them, the first may not exceed the second.
 An atom followed by a bound containing one integer \fIi\fR
 and no comma matches
 a sequence of exactly \fIi\fR matches of the atom.
 An atom followed by a bound
 containing one integer \fIi\fR and a comma matches
 a sequence of \fIi\fR or more matches of the atom.
 An atom followed by a bound
 containing two integers \fIi\fR and \fIj\fR matches
 a sequence of \fIi\fR through \fIj\fR (inclusive) matches of the atom.
 .PP
 An atom is a regular expression enclosed in `()' (matching a match for the
 regular expression),
 an empty set of `()' (matching the null string)\(dg,
 a \fIbracket expression\fR (see below), `.'
 (matching any single character), `^' (matching the null string at the
 beginning of a line), `$' (matching the null string at the
 end of a line), a `\e' followed by one of the characters
 `^.[$()|*+?{\e'
 (matching that character taken as an ordinary character),
 a `\e' followed by any other character\(dg
 (matching that character taken as an ordinary character,
 as if the `\e' had not been present\(dg),
 or a single character with no other significance (matching that character).
 A `{' followed by a character other than a digit is an ordinary
 character, not the beginning of a bound\(dg.
 It is illegal to end an RE with `\e'.
 .PP
 A \fIbracket expression\fR is a list of characters enclosed in `[]'.
 It normally matches any single character from the list (but see below).
 If the list begins with `^',
 it matches any single character
 (but see below) \fInot\fR from the rest of the list.
 If two characters in the list are separated by `\-', this is shorthand
 for the full \fIrange\fR of characters between those two (inclusive) in the
 collating sequence,
 e.g. `[0\-9]' in ASCII matches any decimal digit.
 It is illegal\(dg for two ranges to share an
 endpoint, e.g. `a\-c\-e'.
 Ranges are very collating-sequence-dependent,
 and portable programs should avoid relying on them.
 .PP
 To include a literal `]' in the list, make it the first character
 (following a possible `^').
 To include a literal `\-', make it the first or last character,
 or the second endpoint of a range.
 To use a literal `\-' as the first endpoint of a range,
 enclose it in `[.' and `.]' to make it a collating element (see below).
 With the exception of these and some combinations using `[' (see next
 paragraphs), all other special characters, including `\e', lose their
 special significance within a bracket expression.
 .PP
 Within a bracket expression, a collating element (a character,
 a multi-character sequence that collates as if it were a single character,
 or a collating-sequence name for either)
 enclosed in `[.' and `.]' stands for the
 sequence of characters of that collating element.
 The sequence is a single element of the bracket expression's list.
 A bracket expression containing a multi-character collating element 
 can thus match more than one character,
 e.g. if the collating sequence includes a `ch' collating element,
 then the RE `[[.ch.]]*c' matches the first five characters
 of `chchcc'.
 .PP
 Within a bracket expression, a collating element enclosed in `[=' and
 `=]' is an equivalence class, standing for the sequences of characters
 of all collating elements equivalent to that one, including itself.
 (If there are no other equivalent collating elements,
 the treatment is as if the enclosing delimiters were `[.' and `.]'.)
 For example, if o and \o'o^' are the members of an equivalence class,
 then `[[=o=]]', `[[=\o'o^'=]]', and `[o\o'o^']' are all synonymous.
 An equivalence class may not\(dg be an endpoint
 of a range.
 .PP
 Within a bracket expression, the name of a \fIcharacter class\fR enclosed
 in `[:' and `:]' stands for the list of all characters belonging to that
 class.
 Standard character class names are:
 .PP
 .RS
 .nf
 .ta 3c 6c 9c
 alnum	digit	punct
 alpha	graph	space
 blank	lower	upper
 cntrl	print	xdigit
 .fi
 .RE
 .PP
 These stand for the character classes defined in
 .IR ctype (3).
 A locale may provide others.
 A character class may not be used as an endpoint of a range.
 .PP
 There are two special cases\(dg of bracket expressions:
 the bracket expressions `[[:<:]]' and `[[:>:]]' match the null string at
 the beginning and end of a word respectively.
 A word is defined as a sequence of
 word characters
 which is neither preceded nor followed by
 word characters.
 A word character is an
 .I alnum
 character (as defined by
 .IR ctype (3))
 or an underscore.
 This is an extension,
 compatible with but not specified by POSIX 1003.2,
 and should be used with
 caution in software intended to be portable to other systems.
 .PP
 In the event that an RE could match more than one substring of a given
 string,
 the RE matches the one starting earliest in the string.
 If the RE could match more than one substring starting at that point,
 it matches the longest.
 Subexpressions also match the longest possible substrings, subject to
 the constraint that the whole match be as long as possible,
 with subexpressions starting earlier in the RE taking priority over
 ones starting later.
 Note that higher-level subexpressions thus take priority over
 their lower-level component subexpressions.
 .PP
 Match lengths are measured in characters, not collating elements.
 A null string is considered longer than no match at all.
 For example,
 `bb*' matches the three middle characters of `abbbc',
 `(wee|week)(knights|nights)' matches all ten characters of `weeknights',
 when `(.*).*' is matched against `abc' the parenthesized subexpression
 matches all three characters, and
 when `(a*)*' is matched against `bc' both the whole RE and the parenthesized
 subexpression match the null string.
 .PP
 If case-independent matching is specified,
 the effect is much as if all case distinctions had vanished from the
 alphabet.
 When an alphabetic that exists in multiple cases appears as an
 ordinary character outside a bracket expression, it is effectively
 transformed into a bracket expression containing both cases,
 e.g. `x' becomes `[xX]'.
 When it appears inside a bracket expression, all case counterparts
 of it are added to the bracket expression, so that (e.g.) `[x]'
 becomes `[xX]' and `[^x]' becomes `[^xX]'.
 .PP
 No particular limit is imposed on the length of REs\(dg.
 Programs intended to be portable should not employ REs longer
 than 256 bytes,
 as an implementation can refuse to accept such REs and remain
 POSIX-compliant.
 .PP
 Obsolete (``basic'') regular expressions differ in several respects.
 `|', `+', and `?' are ordinary characters and there is no equivalent
 for their functionality.
 The delimiters for bounds are `\e{' and `\e}',
 with `{' and `}' by themselves ordinary characters.
 The parentheses for nested subexpressions are `\e(' and `\e)',
 with `(' and `)' by themselves ordinary characters.
 `^' is an ordinary character except at the beginning of the
 RE or\(dg the beginning of a parenthesized subexpression,
 `$' is an ordinary character except at the end of the
 RE or\(dg the end of a parenthesized subexpression,
 and `*' is an ordinary character if it appears at the beginning of the
 RE or the beginning of a parenthesized subexpression
 (after a possible leading `^').
 Finally, there is one new type of atom, a \fIback reference\fR:
 `\e' followed by a non-zero decimal digit \fId\fR
 matches the same sequence of characters
 matched by the \fId\fRth parenthesized subexpression
 (numbering subexpressions by the positions of their opening parentheses,
 left to right),
 so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
 .SH SEE ALSO
 regex(3)
 .PP
 POSIX 1003.2, section 2.8 (Regular Expression Notation).
 .SH HISTORY
 Written by Henry Spencer, based on the 1003.2 spec.
 .SH BUGS
 Having two kinds of REs is a botch.
 .PP
 The current 1003.2 spec says that `)' is an ordinary character in
 the absence of an unmatched `(';
 this was an unintentional result of a wording error,
 and change is likely.
 Avoid relying on it.
 .PP
 Back references are a dreadful botch,
 posing major problems for efficient implementations.
 They are also somewhat vaguely defined
 (does
 `a\e(\e(b\e)*\e2\e)*d' match `abbbd'?).
 Avoid using them.
 .PP
 1003.2's specification of case-independent matching is vague.
 The ``one case implies all cases'' definition given above
 is current consensus among implementors as to the right interpretation.
 .PP
 The syntax for word boundaries is incredibly ugly.
--- a/src/regex/regex.h
+++ b/src/regex/regex.h
@@ -1,202 +1,74 @@
 #ifndef _REGEX_H_
 #define	_REGEX_H_	/* never again */
-/*
+/* ========= begin header generated by ./mkh ========= */
 * regular expressions
 *
 * Copyright (c) 1998, 1999 Henry Spencer.	All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation
 * of software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Id$
 */
 /*
 * Add your own defines, if needed, here.
 */
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include <sys/types.h>
+/* === regex2.h === */
-#include <stdio.h>
+typedef off_t regoff_t;
-#include <stdlib.h>
+typedef struct {
-
+	int re_magic;
-#ifndef wxCHECK_GCC_VERSION
+	size_t re_nsub;		/* number of parenthesized subexpressions */
-#define wxCHECK_GCC_VERSION( major, minor ) \
+	const char *re_endp;	/* end pointer for REG_PEND */
-    ( defined(__GNUC__) && defined(__GNUC_MINOR__) \
+	struct re_guts *re_g;	/* none of your business :-) */
    && ( ( __GNUC__ > (major) ) \
        || ( __GNUC__ == (major) && __GNUC_MINOR__ >= (minor) ) ) )
 #endif
 #if !wxUSE_UNICODE
 #	define wx_wchar char
 #else // Unicode
    #if (defined(__GNUC__) && !wxCHECK_GCC_VERSION(2, 96))
 #		define wx_wchar __WCHAR_TYPE__ 
    #else // __WCHAR_TYPE__ and gcc < 2.96
 		// standard case
 #		define wx_wchar wchar_t         
    #endif // __WCHAR_TYPE__
 #endif // ASCII/Unicode
 /*
 * interface types etc.
 */
 /*
 * regoff_t has to be large enough to hold either off_t or ssize_t,
 * and must be signed; it's only a guess that long is suitable.
 */
 typedef long regoff_t;
 /*
 * other interface types
 */
 /* the biggie, a compiled RE (or rather, a front end to same) */
 typedef struct
 {
 	int			re_magic;		/* magic number */
 	size_t		re_nsub;		/* number of subexpressions */
 	long		re_info;		/* information about RE */
 #define  REG_UBACKREF		 000001
 #define  REG_ULOOKAHEAD		 000002
 #define  REG_UBOUNDS	 000004
 #define  REG_UBRACES	 000010
 #define  REG_UBSALNUM		 000020
 #define  REG_UPBOTCH	 000040
 #define  REG_UBBS		 000100
 #define  REG_UNONPOSIX		 000200
 #define  REG_UUNSPEC	 000400
 #define  REG_UUNPORT	 001000
 #define  REG_ULOCALE	 002000
 #define  REG_UEMPTYMATCH	 004000
 #define  REG_UIMPOSSIBLE	 010000
 #define  REG_USHORTEST		 020000
 	int			re_csize;		/* sizeof(character) */
 	char	   *re_endp;		/* backward compatibility kludge */
 	/* the rest is opaque pointers to hidden innards */
 	char	   *re_guts;		/* `char *' is more portable than `void *' */
 	char	   *re_fns;
 } regex_t;
-
+typedef struct {
-/* result reporting (may acquire more fields later) */
+	regoff_t rm_so;		/* start of match */
-typedef struct
+	regoff_t rm_eo;		/* end of match */
 {
 	regoff_t	rm_so;			/* start of substring */
 	regoff_t	rm_eo;			/* end of substring */
 } regmatch_t;
-/* supplementary control and reporting */
+
-typedef struct
+/* === regcomp.c === */
-{
+extern int regcomp(regex_t *, const char *, int);
-	regmatch_t	rm_extend;		/* see REG_EXPECT */
+#define	REG_BASIC	0000
-} rm_detail_t;
+#define	REG_EXTENDED	0001
 #define	REG_ICASE	0002
 #define	REG_NOSUB	0004
 #define	REG_NEWLINE	0010
 #define	REG_NOSPEC	0020
 #define	REG_PEND	0040
 #define	REG_DUMP	0200
-
+/* === regerror.c === */
-/*
+#define	REG_OKAY	 0
- * regex compilation flags
+#define	REG_NOMATCH	 1
- */
+#define	REG_BADPAT	 2
-#define REG_BASIC	000000		/* BREs (convenience) */
+#define	REG_ECOLLATE	 3
-#define REG_EXTENDED	000001	/* EREs */
+#define	REG_ECTYPE	 4
-#define REG_ADVF	000002		/* advanced features in EREs */
+#define	REG_EESCAPE	 5
-#define REG_ADVANCED	000003	/* AREs (which are also EREs) */
+#define	REG_ESUBREG	 6
-#define REG_QUOTE	000004		/* no special characters, none */
+#define	REG_EBRACK	 7
-#define REG_NOSPEC	REG_QUOTE	/* historical synonym */
+#define	REG_EPAREN	 8
-#define REG_ICASE	000010		/* ignore case */
+#define	REG_EBRACE	 9
-#define REG_NOSUB	000020		/* don't care about subexpressions */
+#define	REG_BADBR	10
-#define REG_EXPANDED	000040	/* expanded format, white space & comments */
+#define	REG_ERANGE	11
-#define REG_NLSTOP	000100		/* \n doesn't match . or [^ ] */
+#define	REG_ESPACE	12
-#define REG_NLANCH	000200		/* ^ matches after \n, $ before */
+#define	REG_BADRPT	13
-#define REG_NEWLINE 000300		/* newlines are line terminators */
+#define	REG_EMPTY	14
-#define REG_PEND	000400		/* ugh -- backward-compatibility hack */
+#define	REG_ASSERT	15
-#define REG_EXPECT	001000		/* report details on partial/limited
+#define	REG_INVARG	16
-								 * matches */
+#define	REG_ATOI	255	/* convert name to number (!) */
-#define REG_BOSONLY 002000		/* temporary kludge for BOS-only matches */
+#define	REG_ITOA	0400	/* convert number to name (!) */
 #define REG_DUMP	004000		/* none of your business :-) */
 #define REG_FAKE	010000		/* none of your business :-) */
 #define REG_PROGRESS	020000	/* none of your business :-) */
 /*
 * regex execution flags
 */
 #define REG_NOTBOL	0001		/* BOS is not BOL */
 #define REG_NOTEOL	0002		/* EOS is not EOL */
 #define REG_STARTEND	0004	/* backward compatibility kludge */
 #define REG_FTRACE	0010		/* none of your business */
 #define REG_MTRACE	0020		/* none of your business */
 #define REG_SMALL	0040		/* none of your business */
 /*
 * error reporting
 * Be careful if modifying the list of error codes -- the table used by
 * regerror() is generated automatically from this file!
 */
 #define REG_OKAY	 0			/* no errors detected */
 #define REG_NOMATCH  1			/* failed to match */
 #define REG_BADPAT	 2			/* invalid regexp */
 #define REG_ECOLLATE	 3		/* invalid collating element */
 #define REG_ECTYPE	 4			/* invalid character class */
 #define REG_EESCAPE  5			/* invalid escape \ sequence */
 #define REG_ESUBREG  6			/* invalid backreference number */
 #define REG_EBRACK	 7			/* brackets [] not balanced */
 #define REG_EPAREN	 8			/* parentheses () not balanced */
 #define REG_EBRACE	 9			/* braces {} not balanced */
 #define REG_BADBR	10			/* invalid repetition count(s) */
 #define REG_ERANGE	11			/* invalid character range */
 #define REG_ESPACE	12			/* out of memory */
 #define REG_BADRPT	13			/* quantifier operand invalid */
 #define REG_ASSERT	15			/* "can't happen" -- you found a bug */
 #define REG_INVARG	16			/* invalid argument to regex function */
 #define REG_MIXED	17			/* character widths of regex and string
 								 * differ */
 #define REG_BADOPT	18			/* invalid embedded option */
 /* two specials for debugging and testing */
 #define REG_ATOI	101			/* convert error-code name to number */
 #define REG_ITOA	102			/* convert error-code number to name */
 /*
 * the prototypes for exported functions
 */
 extern int	wx_regcomp(regex_t *, const wx_wchar *, size_t, int);
 extern int	regcomp(regex_t *, const wx_wchar *, int);
 extern int	wx_regexec(regex_t *, const wx_wchar *, size_t, rm_detail_t *, size_t, regmatch_t[], int);
 extern int	regexec(regex_t *, const wx_wchar *, size_t, regmatch_t[], int);
 extern void regfree(regex_t *);
 extern size_t regerror(int, const regex_t *, char *, size_t);
-extern void wx_regfree(regex_t *);
+
-extern size_t wx_regerror(int, const regex_t *, char *, size_t);
+
 /* === regexec.c === */
 extern int regexec(const regex_t *, const char *, size_t, regmatch_t [], int);
 #define	REG_NOTBOL	00001
 #define	REG_NOTEOL	00002
 #define	REG_STARTEND	00004
 #define	REG_TRACE	00400	/* tracing of execution */
 #define	REG_LARGE	01000	/* force large representation */
 #define	REG_BACKR	02000	/* force use of backref code */
 /* === regfree.c === */
 extern void regfree(regex_t *);
 #ifdef __cplusplus
 }
 #endif
-
+/* ========= end header generated by ./mkh ========= */
-#endif   /* _REGEX_H_ */
+#endif
--- a/src/regex/regex2.h
+++ b/src/regex/regex2.h
@@ -0,0 +1,134 @@
 /*
 * First, the stuff that ends up in the outside-world include file
 = typedef off_t regoff_t;
 = typedef struct {
 = 	int re_magic;
 = 	size_t re_nsub;		// number of parenthesized subexpressions
 = 	const char *re_endp;	// end pointer for REG_PEND
 = 	struct re_guts *re_g;	// none of your business :-)
 = } regex_t;
 = typedef struct {
 = 	regoff_t rm_so;		// start of match
 = 	regoff_t rm_eo;		// end of match
 = } regmatch_t;
 */
 /*
 * internals of regex_t
 */
 #define	MAGIC1	((('r'^0200)<<8) | 'e')
 /*
 * The internal representation is a *strip*, a sequence of
 * operators ending with an endmarker.  (Some terminology etc. is a
 * historical relic of earlier versions which used multiple strips.)
 * Certain oddities in the representation are there to permit running
 * the machinery backwards; in particular, any deviation from sequential
 * flow must be marked at both its source and its destination.  Some
 * fine points:
 *
 * - OPLUS_ and O_PLUS are *inside* the loop they create.
 * - OQUEST_ and O_QUEST are *outside* the bypass they create.
 * - OCH_ and O_CH are *outside* the multi-way branch they create, while
 *   OOR1 and OOR2 are respectively the end and the beginning of one of
 *   the branches.  Note that there is an implicit OOR2 following OCH_
 *   and an implicit OOR1 preceding O_CH.
 *
 * In state representations, an operator's bit is on to signify a state
 * immediately *preceding* "execution" of that operator.
 */
 typedef long sop;		/* strip operator */
 typedef long sopno;
 #define	OPRMASK	0x7c000000
 #define	OPDMASK	0x03ffffff
 #define	OPSHIFT	(26)
 #define	OP(n)	((n)&OPRMASK)
 #define	OPND(n)	((n)&OPDMASK)
 #define	SOP(op, opnd)	((op)|(opnd))
 /* operators			   meaning	operand			*/
 /*						(back, fwd are offsets)	*/
 #define	OEND	(1<<OPSHIFT)	/* endmarker	-			*/
 #define	OCHAR	(2<<OPSHIFT)	/* character	unsigned char		*/
 #define	OBOL	(3<<OPSHIFT)	/* left anchor	-			*/
 #define	OEOL	(4<<OPSHIFT)	/* right anchor	-			*/
 #define	OANY	(5<<OPSHIFT)	/* .		-			*/
 #define	OANYOF	(6<<OPSHIFT)	/* [...]	set number		*/
 #define	OBACK_	(7<<OPSHIFT)	/* begin \d	paren number		*/
 #define	O_BACK	(8<<OPSHIFT)	/* end \d	paren number		*/
 #define	OPLUS_	(9<<OPSHIFT)	/* + prefix	fwd to suffix		*/
 #define	O_PLUS	(10<<OPSHIFT)	/* + suffix	back to prefix		*/
 #define	OQUEST_	(11<<OPSHIFT)	/* ? prefix	fwd to suffix		*/
 #define	O_QUEST	(12<<OPSHIFT)	/* ? suffix	back to prefix		*/
 #define	OLPAREN	(13<<OPSHIFT)	/* (		fwd to )		*/
 #define	ORPAREN	(14<<OPSHIFT)	/* )		back to (		*/
 #define	OCH_	(15<<OPSHIFT)	/* begin choice	fwd to OOR2		*/
 #define	OOR1	(16<<OPSHIFT)	/* | pt. 1	back to OOR1 or OCH_	*/
 #define	OOR2	(17<<OPSHIFT)	/* | pt. 2	fwd to OOR2 or O_CH	*/
 #define	O_CH	(18<<OPSHIFT)	/* end choice	back to OOR1		*/
 #define	OBOW	(19<<OPSHIFT)	/* begin word	-			*/
 #define	OEOW	(20<<OPSHIFT)	/* end word	-			*/
 /*
 * Structure for [] character-set representation.  Character sets are
 * done as bit vectors, grouped 8 to a byte vector for compactness.
 * The individual set therefore has both a pointer to the byte vector
 * and a mask to pick out the relevant bit of each byte.  A hash code
 * simplifies testing whether two sets could be identical.
 *
 * This will get trickier for multicharacter collating elements.  As
 * preliminary hooks for dealing with such things, we also carry along
 * a string of multi-character elements, and decide the size of the
 * vectors at run time.
 */
 typedef struct {
 	uch *ptr;		/* -> uch [csetsize] */
 	uch mask;		/* bit within array */
 	uch hash;		/* hash code */
 	size_t smultis;
 	char *multis;		/* -> char[smulti]  ab\0cd\0ef\0\0 */
 } cset;
 /* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
 #define	CHadd(cs, c)	((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
 #define	CHsub(cs, c)	((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
 #define	CHIN(cs, c)	((cs)->ptr[(uch)(c)] & (cs)->mask)
 #define	MCadd(p, cs, cp)	mcadd(p, cs, cp)	/* regcomp() internal fns */
 #define	MCsub(p, cs, cp)	mcsub(p, cs, cp)
 #define	MCin(p, cs, cp)	mcin(p, cs, cp)
 /* stuff for character categories */
 typedef unsigned char cat_t;
 /*
 * main compiled-expression structure
 */
 struct re_guts {
 	int magic;
 #		define	MAGIC2	((('R'^0200)<<8)|'E')
 	sop *strip;		/* malloced area for strip */
 	int csetsize;		/* number of bits in a cset vector */
 	int ncsets;		/* number of csets in use */
 	cset *sets;		/* -> cset [ncsets] */
 	uch *setbits;		/* -> uch[csetsize][ncsets/CHAR_BIT] */
 	int cflags;		/* copy of regcomp() cflags argument */
 	sopno nstates;		/* = number of sops */
 	sopno firststate;	/* the initial OEND (normally 0) */
 	sopno laststate;	/* the final OEND */
 	int iflags;		/* internal flags */
 #		define	USEBOL	01	/* used ^ */
 #		define	USEEOL	02	/* used $ */
 #		define	BAD	04	/* something wrong */
 	int nbol;		/* number of ^ used */
 	int neol;		/* number of $ used */
 	int ncategories;	/* how many character categories */
 	cat_t *categories;	/* ->catspace[-CHAR_MIN] */
 	char *must;		/* match must contain this string */
 	int mlen;		/* length of must */
 	size_t nsub;		/* copy of re_nsub */
 	int backrefs;		/* does it use back references? */
 	sopno nplus;		/* how deep does it nest +s? */
 	/* catspace must be last */
 	cat_t catspace[1];	/* actually [NC] */
 };
 /* misc utilities */
 #define	OUT	(CHAR_MAX+1)	/* a non-character value */
 #define	ISWORD(c)	(isalnum(c) || (c) == '_')
--- a/src/regex/regfronts.c
+++ b/src/regex/regfronts.c
@@ -1,83 +0,0 @@
 /*
 * regcomp and regexec - front ends to re_ routines
 *
 * Mostly for implementation of backward-compatibility kludges.  Note
 * that these routines exist ONLY in char versions.
 *
 * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
 * 
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them. 
 * 
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 * 
 * I'd appreciate being given credit for this package in the documentation
 * of software which uses it, but that is not a requirement.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 #include "regguts.h"
 /*
 - regcomp - compile regular expression
 */
 int
 regcomp(re, str, flags)
 regex_t *re;
 CONST char *str;
 int flags;
 {
 	size_t len;
 	int f = flags;
 	if (f&REG_PEND) {
 		len = re->re_endp - str;
 		f &= ~REG_PEND;
 	} else
 		len = strlen(str);
 	return re_comp(re, str, len, f);
 }
 /*
 - regexec - execute regular expression
 */
 int
 regexec(re, str, nmatch, pmatch, flags)
 regex_t *re;
 CONST char *str;
 size_t nmatch;
 regmatch_t pmatch[];
 int flags;
 {
 	CONST char *start;
 	size_t len;
 	int f = flags;
 	if (f&REG_STARTEND) {
 		start = str + pmatch[0].rm_so;
 		len = pmatch[0].rm_eo - pmatch[0].rm_so;
 		f &= ~REG_STARTEND;
 	} else {
 		start = str;
 		len = strlen(str);
 	}
 	return re_exec(re, start, len, nmatch, pmatch, f);
 }
--- a/src/regex/regguts.h
+++ b/src/regex/regguts.h
@@ -1,417 +0,0 @@
 /*
 * Internal interface definitions, etc., for the reg package
 *
 * Copyright (c) 1998, 1999 Henry Spencer.	All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation
 * of software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Id$
 */
 /*
 * Environmental customization.  It should not (I hope) be necessary to
 * alter the file you are now reading -- regcustom.h should handle it all,
 * given care here and elsewhere.
 */
 #include "regcustom.h"
 /*
 * Things that regcustom.h might override.
 */
 /* assertions */
 #ifndef assert
 #ifndef REG_DEBUG
 #	ifndef NDEBUG
 #		define  NDEBUG					/* no assertions */
 #	endif
 #endif
 #include <assert.h>
 #endif
 /* voids */
 #ifndef DISCARD
 #define DISCARD void			/* for throwing values away */
 #endif
 #ifndef VS
 #define VS(x)	((void *)(x))	/* cast something to generic ptr */
 #endif
 /* function-pointer declarator */
 #ifndef FUNCPTR
 #define FUNCPTR(name, args) (*name) args
 #endif
 /* memory allocation */
 #ifndef MALLOC
 #define MALLOC(n)	malloc(n)
 #endif
 #ifndef REALLOC
 #define REALLOC(p, n)	realloc(VS(p), n)
 #endif
 #ifndef FREE
 #define FREE(p)		free(VS(p))
 #endif
 /* want size of a char in bits, and max value in bounded quantifiers */
 #ifndef CHAR_BIT
 #include <limits.h>
 #endif
 #ifndef _POSIX2_RE_DUP_MAX
 #define _POSIX2_RE_DUP_MAX	255 /* normally from <limits.h> */
 #endif
 /*
 * misc
 */
 #define NOTREACHED	0
 #define xxx		1
 #define DUPMAX	_POSIX2_RE_DUP_MAX
 #define INFINITY	(DUPMAX+1)
 #define REMAGIC 0xfed7			/* magic number for main struct */
 /*
 * debugging facilities
 */
 #ifdef REG_DEBUG
 /* FDEBUG does finite-state tracing */
 #define FDEBUG(arglist) { if (v->eflags&REG_FTRACE) printf arglist; }
 /* MDEBUG does higher-level tracing */
 #define MDEBUG(arglist) { if (v->eflags&REG_MTRACE) printf arglist; }
 #else
 #define FDEBUG(arglist) {}
 #define MDEBUG(arglist) {}
 #endif
 /*
 * bitmap manipulation
 */
 #define UBITS	(CHAR_BIT * sizeof(unsigned))
 #define BSET(uv, sn)	((uv)[(sn)/UBITS] |= (unsigned)1 << ((sn)%UBITS))
 #define ISBSET(uv, sn)	((uv)[(sn)/UBITS] & ((unsigned)1 << ((sn)%UBITS)))
 /*
 * We dissect a chr into byts for colormap table indexing.	Here we define
 * a byt, which will be the same as a byte on most machines...	The exact
 * size of a byt is not critical, but about 8 bits is good, and extraction
 * of 8-bit chunks is sometimes especially fast.
 */
 #ifndef BYTBITS
 #define BYTBITS 8				/* bits in a byt */
 #endif
 #define BYTTAB	(1<<BYTBITS)	/* size of table with one entry per byt
 								 * value */
 #define BYTMASK (BYTTAB-1)		/* bit mask for byt */
 #define NBYTS	((CHRBITS+BYTBITS-1)/BYTBITS)
 /* the definition of GETCOLOR(), below, assumes NBYTS <= 4 */
 /*
 * As soon as possible, we map chrs into equivalence classes -- "colors" --
 * which are of much more manageable number.
 */
 typedef short color;			/* colors of characters */
 typedef int pcolor;				/* what color promotes to */
 #define COLORLESS	(-1)		/* impossible color */
 #define WHITE		0			/* default color, parent of all others */
 /*
 * A colormap is a tree -- more precisely, a DAG -- indexed at each level
 * by a byt of the chr, to map the chr to a color efficiently.	Because
 * lower sections of the tree can be shared, it can exploit the usual
 * sparseness of such a mapping table.	The tree is always NBYTS levels
 * deep (in the past it was shallower during construction but was "filled"
 * to full depth at the end of that); areas that are unaltered as yet point
 * to "fill blocks" which are entirely WHITE in color.
 */
 /* the tree itself */
 struct colors
 {
 	color		ccolor[BYTTAB];
 };
 struct ptrs
 {
 	union tree *pptr[BYTTAB];
 };
 union tree
 {
 	struct colors colors;
 	struct ptrs ptrs;
 };
 #define tcolor	colors.ccolor
 #define tptr	ptrs.pptr
 /* internal per-color structure for the color machinery */
 struct colordesc
 {
 	uchr		nchrs;			/* number of chars of this color */
 	color		sub;			/* open subcolor (if any); free chain ptr */
 #define  NOSUB	 COLORLESS
 	struct arc *arcs;			/* color chain */
 	int			flags;
 #define  FREECOL 01				/* currently free */
 #define  PSEUDO  02				/* pseudocolor, no real chars */
 #define  UNUSEDCOLOR(cd) ((cd)->flags&FREECOL)
 	union tree *block;			/* block of solid color, if any */
 };
 /* the color map itself */
 struct colormap
 {
 	int			magic;
 #define  CMMAGIC 0x876
 	struct vars *v;				/* for compile error reporting */
 	size_t		ncds;			/* number of colordescs */
 	size_t		max;			/* highest in use */
 	color		free;			/* beginning of free chain (if non-0) */
 	struct colordesc *cd;
 #define  CDEND(cm)	 (&(cm)->cd[(cm)->max + 1])
 #define  NINLINECDS  ((size_t)10)
 	struct colordesc cdspace[NINLINECDS];
 	union tree	tree[NBYTS];	/* tree top, plus fill blocks */
 };
 /* optimization magic to do fast chr->color mapping */
 #define B0(c)	((c) & BYTMASK)
 #define B1(c)	(((c)>>BYTBITS) & BYTMASK)
 #define B2(c)	(((c)>>(2*BYTBITS)) & BYTMASK)
 #define B3(c)	(((c)>>(3*BYTBITS)) & BYTMASK)
 #if NBYTS == 1
 #define GETCOLOR(cm, c) ((cm)->tree->tcolor[B0(c)])
 #endif
 /* beware, for NBYTS>1, GETCOLOR() is unsafe -- 2nd arg used repeatedly */
 #if NBYTS == 2
 #define GETCOLOR(cm, c) ((cm)->tree->tptr[B1(c)]->tcolor[B0(c)])
 #endif
 #if NBYTS == 4
 #define GETCOLOR(cm, c) ((cm)->tree->tptr[B3(c)]->tptr[B2(c)]->tptr[B1(c)]->tcolor[B0(c)])
 #endif
 /*
 * Interface definitions for locale-interface functions in locale.c.
 * Multi-character collating elements (MCCEs) cause most of the trouble.
 */
 struct cvec
 {
 	int			nchrs;			/* number of chrs */
 	int			chrspace;		/* number of chrs possible */
 	chr		   *chrs;			/* pointer to vector of chrs */
 	int			nranges;		/* number of ranges (chr pairs) */
 	int			rangespace;		/* number of chrs possible */
 	chr		   *ranges;			/* pointer to vector of chr pairs */
 	int			nmcces;			/* number of MCCEs */
 	int			mccespace;		/* number of MCCEs possible */
 	int			nmccechrs;		/* number of chrs used for MCCEs */
 	chr		   *mcces[1];		/* pointers to 0-terminated MCCEs */
 	/* and both batches of chrs are on the end */
 };
 /* caution:  this value cannot be changed easily */
 #define MAXMCCE 2				/* length of longest MCCE */
 /*
 * definitions for NFA internal representation
 *
 * Having a "from" pointer within each arc may seem redundant, but it
 * saves a lot of hassle.
 */
 struct state;
 struct arc
 {
 	int			type;
 #define  ARCFREE '\0'
 	color		co;
 	struct state *from;			/* where it's from (and contained within) */
 	struct state *to;			/* where it's to */
 	struct arc *outchain;		/* *from's outs chain or free chain */
 #define  freechain	 outchain
 	struct arc *inchain;		/* *to's ins chain */
 	struct arc *colorchain;		/* color's arc chain */
 };
 struct arcbatch
 {								/* for bulk allocation of arcs */
 	struct arcbatch *next;
 #define  ABSIZE  10
 	struct arc	a[ABSIZE];
 };
 struct state
 {
 	int			no;
 #define  FREESTATE	 (-1)
 	char		flag;			/* marks special states */
 	int			nins;			/* number of inarcs */
 	struct arc *ins;			/* chain of inarcs */
 	int			nouts;			/* number of outarcs */
 	struct arc *outs;			/* chain of outarcs */
 	struct arc *free;			/* chain of free arcs */
 	struct state *tmp;			/* temporary for traversal algorithms */
 	struct state *next;			/* chain for traversing all */
 	struct state *prev;			/* back chain */
 	struct arcbatch oas;		/* first arcbatch, avoid malloc in easy
 								 * case */
 	int			noas;			/* number of arcs used in first arcbatch */
 };
 struct nfa
 {
 	struct state *pre;			/* pre-initial state */
 	struct state *init;			/* initial state */
 	struct state *final;		/* final state */
 	struct state *post;			/* post-final state */
 	int			nstates;		/* for numbering states */
 	struct state *states;		/* state-chain header */
 	struct state *slast;		/* tail of the chain */
 	struct state *free;			/* free list */
 	struct colormap *cm;		/* the color map */
 	color		bos[2];			/* colors, if any, assigned to BOS and BOL */
 	color		eos[2];			/* colors, if any, assigned to EOS and EOL */
 	struct vars *v;				/* simplifies compile error reporting */
 	struct nfa *parent;			/* parent NFA, if any */
 };
 /*
 * definitions for compacted NFA
 */
 struct carc
 {
 	color		co;				/* COLORLESS is list terminator */
 	int			to;				/* state number */
 };
 struct cnfa
 {
 	int			nstates;		/* number of states */
 	int			ncolors;		/* number of colors */
 	int			flags;
 #define  HASLACONS	 01			/* uses lookahead constraints */
 	int			pre;			/* setup state number */
 	int			post;			/* teardown state number */
 	color		bos[2];			/* colors, if any, assigned to BOS and BOL */
 	color		eos[2];			/* colors, if any, assigned to EOS and EOL */
 	struct carc **states;		/* vector of pointers to outarc lists */
 	struct carc *arcs;			/* the area for the lists */
 };
 #define ZAPCNFA(cnfa)	((cnfa).nstates = 0)
 #define NULLCNFA(cnfa)	((cnfa).nstates == 0)
 /*
 * subexpression tree
 */
 struct subre
 {
 	char		op;				/* '|', '.' (concat), 'b' (backref), '(',
 								 * '=' */
 	char		flags;
 #define  LONGER  01				/* prefers longer match */
 #define  SHORTER 02				/* prefers shorter match */
 #define  MIXED	 04				/* mixed preference below */
 #define  CAP 010				/* capturing parens below */
 #define  BACKR	 020			/* back reference below */
 #define  INUSE	 0100			/* in use in final tree */
 #define  LOCAL	 03				/* bits which may not propagate up */
 #define  LMIX(f) ((f)<<2)		/* LONGER -> MIXED */
 #define  SMIX(f) ((f)<<1)		/* SHORTER -> MIXED */
 #define  UP(f)	 (((f)&~LOCAL) | (LMIX(f) & SMIX(f) & MIXED))
 #define  MESSY(f)	 ((f)&(MIXED|CAP|BACKR))
 #define  PREF(f) ((f)&LOCAL)
 #define  PREF2(f1, f2)	 ((PREF(f1) != 0) ? PREF(f1) : PREF(f2))
 #define  COMBINE(f1, f2) (UP((f1)|(f2)) | PREF2(f1, f2))
 	short		retry;			/* index into retry memory */
 	int			subno;			/* subexpression number (for 'b' and '(') */
 	short		min;			/* min repetitions, for backref only */
 	short		max;			/* max repetitions, for backref only */
 	struct subre *left;			/* left child, if any (also freelist
 								 * chain) */
 	struct subre *right;		/* right child, if any */
 	struct state *begin;		/* outarcs from here... */
 	struct state *end;			/* ...ending in inarcs here */
 	struct cnfa cnfa;			/* compacted NFA, if any */
 	struct subre *chain;		/* for bookkeeping and error cleanup */
 };
 /*
 * table of function pointers for generic manipulation functions
 * A regex_t's re_fns points to one of these.
 */
 struct fns
 {
 	void		FUNCPTR(free, (regex_t *));
 };
 /*
 * the insides of a regex_t, hidden behind a void *
 */
 struct guts
 {
 	int			magic;
 #define  GUTSMAGIC	 0xfed9
 	int			cflags;			/* copy of compile flags */
 	long		info;			/* copy of re_info */
 	size_t		nsub;			/* copy of re_nsub */
 	struct subre *tree;
 	struct cnfa search;			/* for fast preliminary search */
 	int			ntree;
 	struct colormap cmap;
 	int			FUNCPTR(compare, (const chr *, const chr *, size_t));
 	struct subre *lacons;		/* lookahead-constraint vector */
 	int			nlacons;		/* size of lacons */
 };
--- a/src/regex/split.c
+++ b/src/regex/split.c
@@ -0,0 +1,316 @@
 #include <stdio.h>
 #include <string.h>
 /*
 - split - divide a string into fields, like awk split()
 = int split(char *string, char *fields[], int nfields, char *sep);
 */
 int				/* number of fields, including overflow */
 split(string, fields, nfields, sep)
 char *string;
 char *fields[];			/* list is not NULL-terminated */
 int nfields;			/* number of entries available in fields[] */
 char *sep;			/* "" white, "c" single char, "ab" [ab]+ */
 {
 	register char *p = string;
 	register char c;			/* latest character */
 	register char sepc = sep[0];
 	register char sepc2;
 	register int fn;
 	register char **fp = fields;
 	register char *sepp;
 	register int trimtrail;
 	/* white space */
 	if (sepc == '\0') {
 		while ((c = *p++) == ' ' || c == '\t')
 			continue;
 		p--;
 		trimtrail = 1;
 		sep = " \t";	/* note, code below knows this is 2 long */
 		sepc = ' ';
 	} else
 		trimtrail = 0;
 	sepc2 = sep[1];		/* now we can safely pick this up */
 	/* catch empties */
 	if (*p == '\0')
 		return(0);
 	/* single separator */
 	if (sepc2 == '\0') {
 		fn = nfields;
 		for (;;) {
 			*fp++ = p;
 			fn--;
 			if (fn == 0)
 				break;
 			while ((c = *p++) != sepc)
 				if (c == '\0')
 					return(nfields - fn);
 			*(p-1) = '\0';
 		}
 		/* we have overflowed the fields vector -- just count them */
 		fn = nfields;
 		for (;;) {
 			while ((c = *p++) != sepc)
 				if (c == '\0')
 					return(fn);
 			fn++;
 		}
 		/* not reached */
 	}
 	/* two separators */
 	if (sep[2] == '\0') {
 		fn = nfields;
 		for (;;) {
 			*fp++ = p;
 			fn--;
 			while ((c = *p++) != sepc && c != sepc2)
 				if (c == '\0') {
 					if (trimtrail && **(fp-1) == '\0')
 						fn++;
 					return(nfields - fn);
 				}
 			if (fn == 0)
 				break;
 			*(p-1) = '\0';
 			while ((c = *p++) == sepc || c == sepc2)
 				continue;
 			p--;
 		}
 		/* we have overflowed the fields vector -- just count them */
 		fn = nfields;
 		while (c != '\0') {
 			while ((c = *p++) == sepc || c == sepc2)
 				continue;
 			p--;
 			fn++;
 			while ((c = *p++) != '\0' && c != sepc && c != sepc2)
 				continue;
 		}
 		/* might have to trim trailing white space */
 		if (trimtrail) {
 			p--;
 			while ((c = *--p) == sepc || c == sepc2)
 				continue;
 			p++;
 			if (*p != '\0') {
 				if (fn == nfields+1)
 					*p = '\0';
 				fn--;
 			}
 		}
 		return(fn);
 	}
 	/* n separators */
 	fn = 0;
 	for (;;) {
 		if (fn < nfields)
 			*fp++ = p;
 		fn++;
 		for (;;) {
 			c = *p++;
 			if (c == '\0')
 				return(fn);
 			sepp = sep;
 			while ((sepc = *sepp++) != '\0' && sepc != c)
 				continue;
 			if (sepc != '\0')	/* it was a separator */
 				break;
 		}
 		if (fn < nfields)
 			*(p-1) = '\0';
 		for (;;) {
 			c = *p++;
 			sepp = sep;
 			while ((sepc = *sepp++) != '\0' && sepc != c)
 				continue;
 			if (sepc == '\0')	/* it wasn't a separator */
 				break;
 		}
 		p--;
 	}
 	/* not reached */
 }
 #ifdef TEST_SPLIT
 /*
 * test program
 * pgm		runs regression
 * pgm sep	splits stdin lines by sep
 * pgm str sep	splits str by sep
 * pgm str sep n	splits str by sep n times
 */
 int
 main(argc, argv)
 int argc;
 char *argv[];
 {
 	char buf[512];
 	register int n;
 #	define	MNF	10
 	char *fields[MNF];
 	if (argc > 4)
 		for (n = atoi(argv[3]); n > 0; n--) {
 			(void) strcpy(buf, argv[1]);
 		}
 	else if (argc > 3)
 		for (n = atoi(argv[3]); n > 0; n--) {
 			(void) strcpy(buf, argv[1]);
 			(void) split(buf, fields, MNF, argv[2]);
 		}
 	else if (argc > 2)
 		dosplit(argv[1], argv[2]);
 	else if (argc > 1)
 		while (fgets(buf, sizeof(buf), stdin) != NULL) {
 			buf[strlen(buf)-1] = '\0';	/* stomp newline */
 			dosplit(buf, argv[1]);
 		}
 	else
 		regress();
 	exit(0);
 }
 dosplit(string, seps)
 char *string;
 char *seps;
 {
 #	define	NF	5
 	char *fields[NF];
 	register int nf;
 	nf = split(string, fields, NF, seps);
 	print(nf, NF, fields);
 }
 print(nf, nfp, fields)
 int nf;
 int nfp;
 char *fields[];
 {
 	register int fn;
 	register int bound;
 	bound = (nf > nfp) ? nfp : nf;
 	printf("%d:\t", nf);
 	for (fn = 0; fn < bound; fn++)
 		printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
 }
 #define	RNF	5		/* some table entries know this */
 struct {
 	char *str;
 	char *seps;
 	int nf;
 	char *fi[RNF];
 } tests[] = {
 	"",		" ",	0,	{ "" },
 	" ",		" ",	2,	{ "", "" },
 	"x",		" ",	1,	{ "x" },
 	"xy",		" ",	1,	{ "xy" },
 	"x y",		" ",	2,	{ "x", "y" },
 	"abc def  g ",	" ",	5,	{ "abc", "def", "", "g", "" },
 	"  a bcd",	" ",	4,	{ "", "", "a", "bcd" },
 	"a b c d e f",	" ",	6,	{ "a", "b", "c", "d", "e f" },
 	" a b c d ",	" ",	6,	{ "", "a", "b", "c", "d " },
 	"",		" _",	0,	{ "" },
 	" ",		" _",	2,	{ "", "" },
 	"x",		" _",	1,	{ "x" },
 	"x y",		" _",	2,	{ "x", "y" },
 	"ab _ cd",	" _",	2,	{ "ab", "cd" },
 	" a_b  c ",	" _",	5,	{ "", "a", "b", "c", "" },
 	"a b c_d e f",	" _",	6,	{ "a", "b", "c", "d", "e f" },
 	" a b c d ",	" _",	6,	{ "", "a", "b", "c", "d " },
 	"",		" _~",	0,	{ "" },
 	" ",		" _~",	2,	{ "", "" },
 	"x",		" _~",	1,	{ "x" },
 	"x y",		" _~",	2,	{ "x", "y" },
 	"ab _~ cd",	" _~",	2,	{ "ab", "cd" },
 	" a_b  c~",	" _~",	5,	{ "", "a", "b", "c", "" },
 	"a b_c d~e f",	" _~",	6,	{ "a", "b", "c", "d", "e f" },
 	"~a b c d ",	" _~",	6,	{ "", "a", "b", "c", "d " },
 	"",		" _~-",	0,	{ "" },
 	" ",		" _~-",	2,	{ "", "" },
 	"x",		" _~-",	1,	{ "x" },
 	"x y",		" _~-",	2,	{ "x", "y" },
 	"ab _~- cd",	" _~-",	2,	{ "ab", "cd" },
 	" a_b  c~",	" _~-",	5,	{ "", "a", "b", "c", "" },
 	"a b_c-d~e f",	" _~-",	6,	{ "a", "b", "c", "d", "e f" },
 	"~a-b c d ",	" _~-",	6,	{ "", "a", "b", "c", "d " },
 	"",		"  ",	0,	{ "" },
 	" ",		"  ",	2,	{ "", "" },
 	"x",		"  ",	1,	{ "x" },
 	"xy",		"  ",	1,	{ "xy" },
 	"x y",		"  ",	2,	{ "x", "y" },
 	"abc def  g ",	"  ",	4,	{ "abc", "def", "g", "" },
 	"  a bcd",	"  ",	3,	{ "", "a", "bcd" },
 	"a b c d e f",	"  ",	6,	{ "a", "b", "c", "d", "e f" },
 	" a b c d ",	"  ",	6,	{ "", "a", "b", "c", "d " },
 	"",		"",	0,	{ "" },
 	" ",		"",	0,	{ "" },
 	"x",		"",	1,	{ "x" },
 	"xy",		"",	1,	{ "xy" },
 	"x y",		"",	2,	{ "x", "y" },
 	"abc def  g ",	"",	3,	{ "abc", "def", "g" },
 	"\t a bcd",	"",	2,	{ "a", "bcd" },
 	"  a \tb\t c ",	"",	3,	{ "a", "b", "c" },
 	"a b c d e ",	"",	5,	{ "a", "b", "c", "d", "e" },
 	"a b\tc d e f",	"",	6,	{ "a", "b", "c", "d", "e f" },
 	" a b c d e f ",	"",	6,	{ "a", "b", "c", "d", "e f " },
 	NULL,		NULL,	0,	{ NULL },
 };
 regress()
 {
 	char buf[512];
 	register int n;
 	char *fields[RNF+1];
 	register int nf;
 	register int i;
 	register int printit;
 	register char *f;
 	for (n = 0; tests[n].str != NULL; n++) {
 		(void) strcpy(buf, tests[n].str);
 		fields[RNF] = NULL;
 		nf = split(buf, fields, RNF, tests[n].seps);
 		printit = 0;
 		if (nf != tests[n].nf) {
 			printf("split `%s' by `%s' gave %d fields, not %d\n",
 				tests[n].str, tests[n].seps, nf, tests[n].nf);
 			printit = 1;
 		} else if (fields[RNF] != NULL) {
 			printf("split() went beyond array end\n");
 			printit = 1;
 		} else {
 			for (i = 0; i < nf && i < RNF; i++) {
 				f = fields[i];
 				if (f == NULL)
 					f = "(NULL)";
 				if (strcmp(f, tests[n].fi[i]) != 0) {
 					printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
 						tests[n].str, tests[n].seps,
 						i, fields[i], tests[n].fi[i]);
 					printit = 1;
 				}
 			}
 		}
 		if (printit)
 			print(nf, RNF, fields);
 	}
 }
 #endif
--- a/src/regex/tclUniData.c
+++ b/src/regex/tclUniData.c
@@ -1,904 +0,0 @@
 /*
 * tclUniData.c --
 *
 *	Declarations of Unicode character information tables.  This file is
 *	automatically generated by the tools/uniParse.tcl script.  Do not
 *	modify this file by hand.
 *
 * Copyright (c) 1998 by Scriptics Corporation.
 * All rights reserved.
 *
 * RCS: @(#) $Id$
 */
 /*
 * A 16-bit Unicode character is split into two parts in order to index
 * into the following tables.  The lower OFFSET_BITS comprise an offset
 * into a page of characters.  The upper bits comprise the page number.
 */
 #define OFFSET_BITS 5
 /*
 * The pageMap is indexed by page number and returns an alternate page number
 * that identifies a unique page of characters.  Many Unicode characters map
 * to the same alternate page number.
 */
 static unsigned char pageMap[] = {
    0, 1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 7, 15, 16, 17, 
    18, 19, 20, 21, 22, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 7, 32, 
    7, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 47, 
    48, 49, 50, 51, 52, 35, 47, 53, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 
    58, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 80, 81, 
    84, 85, 80, 86, 87, 88, 89, 90, 91, 92, 35, 93, 94, 95, 35, 96, 97, 
    98, 99, 100, 101, 102, 35, 47, 103, 104, 35, 35, 105, 106, 107, 47, 
    47, 108, 47, 47, 109, 47, 110, 111, 47, 112, 47, 113, 114, 115, 116, 
    114, 47, 117, 118, 35, 47, 47, 119, 90, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 120, 121, 47, 47, 122, 
    35, 35, 35, 35, 47, 123, 124, 125, 126, 47, 127, 128, 47, 129, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 7, 7, 7, 7, 130, 7, 7, 131, 132, 133, 134, 
    135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 
    149, 150, 151, 152, 153, 154, 155, 156, 156, 156, 156, 156, 156, 156, 
    157, 158, 159, 160, 161, 162, 35, 35, 35, 160, 163, 164, 165, 166, 
    167, 168, 169, 160, 160, 160, 160, 170, 171, 172, 173, 174, 160, 160, 
    175, 35, 35, 35, 35, 176, 177, 178, 179, 180, 181, 35, 35, 160, 160, 
    160, 160, 160, 160, 160, 160, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    182, 160, 160, 155, 160, 160, 160, 160, 160, 160, 170, 183, 184, 185, 
    90, 47, 186, 90, 47, 187, 188, 189, 47, 47, 190, 128, 35, 35, 191, 
    192, 193, 194, 192, 195, 196, 197, 160, 160, 160, 198, 160, 160, 199, 
    197, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 200, 35, 35, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 201, 35, 35, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    202, 203, 204, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 205, 35, 35, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 47, 47, 47, 47, 47, 47, 47, 47, 47, 208, 35, 35, 35, 35, 
    35, 35, 209, 210, 211, 47, 47, 212, 213, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 214, 215, 47, 216, 47, 217, 218, 35, 219, 220, 221, 47, 
    47, 47, 222, 223, 2, 224, 225, 226, 227, 228, 229, 230, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 231, 35, 232, 233, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
    47, 208, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 47, 234, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 235, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
    207, 207, 207, 236, 207, 207, 207, 207, 207, 207, 207, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
    35, 35, 35, 35, 35
 };
 /*
 * The groupMap is indexed by combining the alternate page number with
 * the page offset and returns a group number that identifies a unique
 * set of character attributes.
 */
 static unsigned char groupMap[] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 3, 3, 3, 5, 6, 3, 7, 3, 8, 
    3, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 7, 7, 7, 3, 3, 10, 10, 10, 
    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
    10, 10, 10, 10, 10, 10, 5, 3, 6, 11, 12, 11, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 5, 7, 6, 7, 1, 2, 3, 4, 4, 4, 4, 14, 14, 11, 14, 15, 16, 
    7, 8, 14, 11, 14, 7, 17, 17, 11, 18, 14, 3, 11, 17, 15, 19, 17, 17, 
    17, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
    10, 10, 10, 10, 10, 10, 10, 10, 7, 10, 10, 10, 10, 10, 10, 10, 15, 
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 13, 13, 13, 7, 13, 13, 13, 13, 13, 13, 13, 20, 21, 22, 
    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 23, 24, 21, 22, 21, 
    22, 21, 22, 15, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
    22, 21, 22, 15, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 25, 
    21, 22, 21, 22, 21, 22, 26, 15, 27, 21, 22, 21, 22, 28, 21, 22, 29, 
    29, 21, 22, 15, 30, 31, 32, 21, 22, 29, 33, 34, 35, 36, 21, 22, 15, 
    15, 35, 37, 15, 38, 21, 22, 21, 22, 21, 22, 39, 21, 22, 39, 15, 15, 
    21, 22, 39, 21, 22, 40, 40, 21, 22, 21, 22, 41, 21, 22, 15, 42, 21, 
    22, 15, 43, 42, 42, 42, 42, 44, 45, 46, 44, 45, 46, 44, 45, 46, 21, 
    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 47, 21, 
    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
    15, 44, 45, 46, 21, 22, 48, 49, 21, 22, 21, 22, 21, 22, 21, 22, 0, 
    0, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
    21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 50, 51, 15, 52, 52, 15, 53, 15, 
    54, 15, 15, 15, 15, 52, 15, 15, 55, 15, 15, 15, 15, 56, 57, 15, 15, 
    15, 15, 15, 57, 15, 15, 58, 15, 15, 59, 15, 15, 15, 15, 15, 15, 15, 
    15, 15, 15, 60, 15, 15, 60, 15, 15, 15, 15, 60, 15, 61, 61, 15, 15, 
    15, 15, 15, 15, 62, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 63, 
    63, 63, 63, 63, 63, 63, 63, 63, 11, 11, 63, 63, 63, 63, 63, 63, 63, 
    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 63, 11, 
    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 63, 63, 63, 
    63, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 65, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 
    64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, 
    0, 0, 0, 0, 63, 0, 0, 0, 3, 0, 0, 0, 0, 0, 11, 11, 66, 3, 67, 67, 67, 
    0, 68, 0, 69, 69, 15, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
    10, 10, 10, 10, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 70, 71, 
    71, 71, 15, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 72, 13, 13, 13, 13, 13, 13, 13, 13, 13, 73, 74, 74, 0, 
    75, 76, 77, 77, 77, 78, 79, 15, 0, 0, 21, 22, 21, 22, 21, 22, 21, 22, 
    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 80, 81, 47, 
    15, 82, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 84, 84, 84, 84, 84, 84, 
    84, 84, 84, 84, 84, 84, 84, 84, 84, 10, 10, 10, 10, 10, 10, 10, 10, 
    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
    10, 10, 10, 10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 13, 13, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 
    81, 81, 81, 81, 21, 22, 14, 64, 64, 64, 64, 0, 85, 85, 0, 0, 21, 22, 
    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
    22, 77, 21, 22, 21, 22, 0, 0, 21, 22, 0, 0, 21, 22, 0, 0, 0, 21, 22, 
    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
    21, 22, 0, 0, 21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 86, 86, 86, 86, 
    86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 
    86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 
    0, 0, 63, 3, 3, 3, 3, 3, 3, 0, 87, 87, 87, 87, 87, 87, 87, 87, 87, 
    87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 
    87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 15, 0, 3, 8, 0, 0, 
    0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 3, 64, 3, 64, 
    64, 3, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 0, 0, 0, 0, 0, 42, 42, 42, 3, 3, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 0, 0, 0, 0, 0, 63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 0, 0, 64, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 3, 42, 64, 
    64, 64, 64, 64, 64, 64, 85, 85, 64, 64, 64, 64, 64, 64, 63, 63, 64, 
    64, 14, 64, 64, 64, 64, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 42, 42, 
    42, 14, 14, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 88, 42, 
    64, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 64, 64, 64, 64, 
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 
    64, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 0, 0, 64, 42, 89, 89, 89, 64, 64, 64, 64, 64, 64, 
    64, 64, 89, 89, 89, 89, 64, 0, 0, 42, 64, 64, 64, 64, 0, 0, 0, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 64, 64, 3, 3, 9, 9, 9, 9, 9, 9, 
    9, 9, 9, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 
    89, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 0, 0, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42, 0, 0, 0, 42, 
    42, 42, 42, 0, 0, 64, 0, 89, 89, 89, 64, 64, 64, 64, 0, 0, 89, 89, 
    0, 0, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 42, 42, 
    0, 42, 42, 42, 64, 64, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 42, 42, 
    4, 4, 17, 17, 17, 17, 17, 17, 14, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 42, 
    42, 42, 42, 42, 42, 0, 0, 0, 0, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 
    42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 0, 42, 42, 0, 42, 42, 0, 0, 
    64, 0, 89, 89, 89, 64, 64, 0, 0, 0, 0, 64, 64, 0, 0, 64, 64, 64, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 0, 42, 0, 0, 0, 0, 0, 
    0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 64, 64, 42, 42, 42, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 89, 0, 42, 42, 42, 42, 42, 42, 42, 
    0, 42, 0, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 
    42, 42, 0, 42, 42, 0, 42, 42, 42, 42, 42, 0, 0, 64, 42, 89, 89, 89, 
    64, 64, 64, 64, 64, 0, 64, 64, 89, 0, 89, 89, 64, 0, 0, 42, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 9, 9, 9, 9, 
    9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42, 
    42, 0, 0, 42, 42, 42, 42, 0, 0, 64, 42, 89, 64, 89, 64, 64, 64, 0, 
    0, 0, 89, 89, 0, 0, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 64, 89, 0, 
    0, 0, 0, 42, 42, 0, 42, 42, 42, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 
    9, 9, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 89, 
    0, 42, 42, 42, 42, 42, 42, 0, 0, 0, 42, 42, 42, 0, 42, 42, 42, 42, 
    0, 0, 0, 42, 42, 0, 42, 0, 42, 42, 0, 0, 0, 42, 42, 0, 0, 0, 42, 42, 
    42, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 0, 0, 0, 
    0, 89, 89, 64, 89, 89, 0, 0, 0, 89, 89, 89, 0, 89, 89, 89, 64, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 89, 89, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 
    42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 0, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 89, 89, 
    89, 89, 0, 64, 64, 64, 0, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 64, 
    64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 
    9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 
    89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 0, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 
    42, 42, 0, 0, 0, 0, 89, 64, 89, 89, 89, 89, 89, 0, 64, 89, 89, 0, 89, 
    89, 64, 64, 0, 0, 0, 0, 0, 0, 0, 89, 89, 0, 0, 0, 0, 0, 0, 0, 42, 0, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 89, 89, 89, 64, 64, 
    64, 0, 0, 89, 89, 89, 0, 89, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 89, 0, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 0, 0, 
    42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 64, 0, 0, 0, 0, 89, 89, 89, 64, 
    64, 64, 0, 64, 0, 89, 89, 89, 89, 89, 89, 89, 89, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 89, 3, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 64, 42, 42, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 4, 42, 42, 
    42, 42, 42, 42, 63, 64, 64, 64, 64, 64, 64, 64, 64, 3, 9, 9, 9, 9, 
    9, 9, 9, 9, 9, 9, 3, 3, 0, 0, 0, 0, 0, 42, 42, 0, 42, 0, 0, 42, 42, 
    0, 42, 0, 0, 42, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 0, 42, 42, 42, 42, 
    42, 42, 42, 0, 42, 42, 42, 0, 42, 0, 42, 0, 0, 42, 42, 0, 42, 42, 42, 
    42, 64, 42, 42, 64, 64, 64, 64, 64, 64, 0, 64, 64, 42, 0, 0, 42, 42, 
    42, 42, 42, 0, 63, 0, 64, 64, 64, 64, 64, 64, 0, 0, 9, 9, 9, 9, 9, 
    9, 9, 9, 9, 9, 0, 0, 42, 42, 0, 0, 42, 14, 14, 14, 3, 3, 3, 3, 3, 3, 
    3, 3, 3, 3, 3, 3, 3, 3, 3, 14, 14, 14, 14, 14, 64, 64, 14, 14, 14, 
    14, 14, 14, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 17, 17, 17, 17, 
    17, 17, 17, 14, 64, 14, 64, 14, 64, 5, 6, 5, 6, 89, 89, 42, 42, 42, 
    42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 64, 64, 64, 64, 89, 64, 64, 64, 64, 64, 3, 64, 64, 42, 
    42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    0, 14, 14, 14, 14, 14, 14, 14, 14, 64, 14, 14, 14, 14, 14, 14, 0, 0, 
    14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 0, 42, 
    42, 42, 42, 42, 0, 42, 42, 0, 89, 64, 64, 64, 64, 89, 64, 0, 0, 0, 
    64, 64, 89, 64, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 
    3, 3, 3, 3, 3, 42, 42, 42, 42, 42, 42, 89, 89, 64, 64, 0, 0, 0, 0, 
    0, 0, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 
    77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 
    77, 77, 77, 77, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    0, 0, 0, 0, 3, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 
    0, 0, 0, 0, 42, 42, 42, 42, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 42, 42, 42, 
    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 
    0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42, 
    0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 
    42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 0, 
    42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 
    3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 3, 3, 42, 42, 42, 42, 42, 
    42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 5, 6, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    3, 3, 3, 90, 90, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 89, 89, 89, 64, 64, 64, 64, 64, 64, 64, 89, 89, 89, 89, 89, 
    89, 89, 89, 64, 89, 89, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    3, 3, 3, 3, 3, 3, 3, 4, 3, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 
    3, 3, 3, 3, 8, 3, 3, 3, 3, 88, 88, 88, 88, 0, 9, 9, 9, 9, 9, 9, 9, 
    9, 9, 9, 0, 0, 0, 0, 0, 0, 42, 42, 42, 63, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 
    0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 64, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 21, 22, 21, 22, 21, 
    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 15, 15, 
    15, 15, 15, 91, 0, 0, 0, 0, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 0, 
    0, 0, 0, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 
    93, 93, 93, 92, 92, 92, 92, 92, 92, 0, 0, 93, 93, 93, 93, 93, 93, 0, 
    0, 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 
    92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 92, 
    92, 92, 92, 92, 92, 0, 0, 93, 93, 93, 93, 93, 93, 0, 0, 15, 92, 15, 
    92, 15, 92, 15, 92, 0, 93, 0, 93, 0, 93, 0, 93, 92, 92, 92, 92, 92, 
    92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 94, 94, 95, 95, 95, 95, 
    96, 96, 97, 97, 98, 98, 99, 99, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 
    100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 92, 92, 92, 92, 92, 
    92, 100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 92, 92, 92, 92, 
    92, 92, 100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 15, 101, 15, 
    0, 15, 15, 93, 93, 102, 102, 103, 11, 104, 11, 11, 11, 15, 101, 15, 
    0, 15, 15, 105, 105, 105, 105, 103, 11, 11, 11, 92, 92, 15, 15, 0, 
    0, 15, 15, 93, 93, 106, 106, 0, 11, 11, 11, 92, 92, 15, 15, 15, 107, 
    15, 15, 93, 93, 108, 108, 109, 11, 11, 11, 0, 0, 15, 101, 15, 0, 15, 
    15, 110, 110, 111, 111, 103, 11, 11, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
    2, 2, 2, 88, 88, 88, 88, 8, 8, 8, 8, 8, 8, 3, 3, 16, 19, 5, 16, 16, 
    19, 5, 16, 3, 3, 3, 3, 3, 3, 3, 3, 112, 113, 88, 88, 88, 88, 88, 2, 
    3, 3, 3, 3, 3, 3, 3, 3, 3, 16, 19, 3, 3, 3, 3, 12, 12, 3, 3, 3, 7, 
    5, 6, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 88, 88, 88, 88, 88, 17, 
    0, 0, 0, 17, 17, 17, 17, 17, 17, 7, 7, 7, 5, 6, 15, 17, 17, 17, 17, 
    17, 17, 17, 17, 17, 17, 7, 7, 7, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
    64, 64, 64, 85, 85, 85, 85, 64, 85, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 77, 
    14, 14, 14, 14, 77, 14, 14, 15, 77, 77, 77, 15, 15, 77, 77, 77, 15, 
    14, 77, 14, 14, 14, 77, 77, 77, 77, 77, 14, 14, 14, 14, 14, 14, 77, 
    14, 114, 14, 77, 14, 115, 116, 77, 77, 14, 15, 77, 77, 14, 77, 15, 
    42, 42, 42, 42, 15, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 17, 17, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 
    117, 117, 117, 117, 117, 118, 118, 118, 118, 118, 118, 118, 118, 118, 
    118, 118, 118, 118, 118, 118, 118, 90, 90, 90, 90, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 7, 7, 14, 14, 
    14, 14, 7, 14, 14, 7, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 7, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 14, 14, 7, 
    14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 7, 7, 14, 14, 14, 14, 14, 14, 14, 5, 6, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 119, 119, 119, 119, 119, 119, 
    119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 
    119, 119, 119, 119, 119, 119, 120, 120, 120, 120, 120, 120, 120, 120, 
    120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 
    120, 120, 120, 120, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 7, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 
    14, 14, 14, 0, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 0, 14, 0, 14, 14, 14, 14, 0, 0, 0, 14, 0, 14, 14, 
    14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 17, 17, 14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 
    0, 0, 0, 2, 3, 3, 3, 14, 63, 42, 90, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 
    14, 14, 5, 6, 5, 6, 5, 6, 5, 6, 8, 5, 6, 6, 14, 90, 90, 90, 90, 90, 
    90, 90, 90, 90, 64, 64, 64, 64, 64, 64, 8, 63, 63, 63, 63, 63, 14, 
    14, 90, 90, 90, 0, 0, 0, 14, 14, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 
    11, 11, 63, 63, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 12, 63, 
    63, 63, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 14, 14, 17, 17, 17, 
    17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
    17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 0, 14, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, 121, 121, 121, 121, 121, 121, 
    121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 
    121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 122, 122, 122, 
    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
    122, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 
    15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 0, 
    0, 0, 0, 0, 42, 64, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 7, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 
    42, 0, 42, 0, 42, 42, 0, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 64, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 8, 8, 12, 12, 5, 6, 5, 6, 5, 
    6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 0, 0, 3, 3, 3, 3, 12, 12, 12, 
    3, 3, 3, 0, 3, 3, 3, 3, 8, 5, 6, 5, 6, 5, 6, 3, 3, 3, 7, 8, 7, 7, 7, 
    0, 3, 4, 3, 3, 0, 0, 0, 0, 42, 42, 42, 0, 42, 0, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    0, 0, 88, 0, 3, 3, 3, 4, 3, 3, 3, 5, 6, 3, 7, 3, 8, 3, 3, 9, 9, 9, 
    9, 9, 9, 9, 9, 9, 9, 3, 3, 7, 7, 7, 3, 11, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
    13, 13, 13, 5, 7, 6, 7, 0, 0, 3, 5, 6, 3, 12, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 63, 
    63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 
    42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 
    42, 42, 42, 42, 0, 0, 42, 42, 42, 0, 0, 0, 4, 4, 7, 11, 14, 4, 4, 0, 
    14, 7, 7, 7, 7, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 88, 88, 14, 
    14, 42, 17, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 123, 123, 123, 
    126, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 89, 64, 14, 14, 14, 
    14, 14, 0, 0, 77, 77, 15, 15, 77, 15, 15, 77, 77, 15, 77, 77, 15, 77, 
    77, 15, 15, 77, 15, 15, 77, 77, 15, 77, 77, 15, 77, 77, 15, 15, 77, 
    15, 15, 77, 77, 15, 77, 77, 15, 77, 77, 15, 15, 77, 77, 15, 15, 77, 
    15, 15, 77, 77, 15, 15, 77, 15, 15, 77, 77, 15, 15, 9, 9, 9, 42, 42, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 88, 0, 88, 88, 88, 88, 88, 88, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 122, 
    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
    122
 };
 /*
 * Each group represents a unique set of character attributes.  The attributes
 * are encoded into a 32-bit value as follows:
 *
 * Bits 0-4	Character category: see the constants listed below.
 *
 * Bits 5-7	Case delta type: 000 = identity
 *				 010 = add delta for lower
 *				 011 = add delta for lower, add 1 for title
 *				 100 = sutract delta for title/upper
 *				 101 = sub delta for upper, sub 1 for title
 *				 110 = sub delta for upper, add delta for lower
 *
 * Bits 8-21	Reserved for future use.
 *
 * Bits 22-31	Case delta: delta for case conversions.  This should be the
 *			    highest field so we can easily sign extend.
 */
 static int groups[] = {
    0, 15, 12, 25, 27, 21, 22, 26, 20, 9, 134217793, 28, 19, 134217858, 
    29, 2, 23, 11, 1178599554, 24, -507510654, 4194369, 4194434, -834666431, 
    973078658, -507510719, 1258291330, 880803905, 864026689, 859832385, 
    331350081, 847249473, 851443777, 868220993, -406847358, 884998209, 
    876609601, 893386817, 897581121, 914358337, 910164033, 918552641, 
    5, -234880894, 8388705, 4194499, 8388770, 331350146, -406847423, 
    -234880959, 880803970, 864026754, 859832450, 847249538, 851443842, 
    868221058, 876609666, 884998274, 893386882, 897581186, 914358402, 
    910164098, 918552706, 4, 6, -352321402, 159383617, 155189313, 
    268435521, 264241217, 159383682, 155189378, 130023554, 268435586, 
    264241282, 260046978, 239075458, 1, 197132418, 226492546, 360710274, 
    335544450, -251658175, 402653314, 335544385, 7, 201326657, 201326722, 
    16, 8, 10, 247464066, -33554302, -33554367, -310378366, -360710014, 
    -419430270, -536870782, -469761918, -528482174, -33554365, -37748606, 
    -310378431, -37748669, 155189378, -360710079, -419430335, -29359998, 
    -469761983, -29360063, -536870847, -528482239, 13, 14, -1463812031, 
    -801111999, -293601215, 67108938, 67109002, 109051997, 109052061, 
    18, 17, 8388673, 12582977, 8388738, 12583042
 };
 /*
 * The following constants are used to determine the category of a
 * Unicode character.
 */
 #define UNICODE_CATEGORY_MASK 0X1F
 enum {
    UNASSIGNED,
    UPPERCASE_LETTER,
    LOWERCASE_LETTER,
    TITLECASE_LETTER,
    MODIFIER_LETTER,
    OTHER_LETTER,
    NON_SPACING_MARK,
    ENCLOSING_MARK,
    COMBINING_SPACING_MARK,
    DECIMAL_DIGIT_NUMBER,
    LETTER_NUMBER,
    OTHER_NUMBER,
    SPACE_SEPARATOR,
    LINE_SEPARATOR,
    PARAGRAPH_SEPARATOR,
    CONTROL,
    FORMAT,
    PRIVATE_USE,
    SURROGATE,
    CONNECTOR_PUNCTUATION,
    DASH_PUNCTUATION,
    OPEN_PUNCTUATION,
    CLOSE_PUNCTUATION,
    INITIAL_QUOTE_PUNCTUATION,
    FINAL_QUOTE_PUNCTUATION,
    OTHER_PUNCTUATION,
    MATH_SYMBOL,
    CURRENCY_SYMBOL,
    MODIFIER_SYMBOL,
    OTHER_SYMBOL
 };
 /*
 * The following macros extract the fields of the character info.  The
 * GetDelta() macro is complicated because we can't rely on the C compiler
 * to do sign extension on right shifts.
 */
 #define GetCaseType(info) (((info) & 0xE0) >> 5)
 #define GetCategory(info) ((info) & 0x1F)
 #define GetDelta(info) (((info) > 0) ? ((info) >> 22) : (~(~((info)) >> 22)))
 /*
 * This macro extracts the information about a character from the
 * Unicode character tables.
 */
 #define GetUniCharInfo(ch) (groups[groupMap[(pageMap[(((int)(ch)) & 0xffff) >> OFFSET_BITS] << OFFSET_BITS) | ((ch) & ((1 << OFFSET_BITS)-1))]])
--- a/src/regex/utils.h
+++ b/src/regex/utils.h
@@ -0,0 +1,22 @@
 /* utility definitions */
 #ifdef _POSIX2_RE_DUP_MAX
 #define	DUPMAX	_POSIX2_RE_DUP_MAX
 #else
 #define	DUPMAX	255
 #endif
 #define	INFINITY	(DUPMAX + 1)
 #define	NC		(CHAR_MAX - CHAR_MIN + 1)
 typedef unsigned char uch;
 /* switch off assertions (if not already off) if no REDEBUG */
 #ifndef REDEBUG
 #ifndef NDEBUG
 #define	NDEBUG	/* no assertions please */
 #endif
 #endif
 #include <assert.h>
 /* for old systems with bcopy() but no memmove() */
 #ifdef USEBCOPY
 #define	memmove(d, s, c)	bcopy(s, d, c)
 #endif
--- a/utils/wxPython/src/makefile.nt
+++ b/utils/wxPython/src/makefile.nt
@@ -0,0 +1,339 @@
 #----------------------------------------------------------------------------
 # Name:		makefile.nt
 # Purpose:	Win32, VC++ 5 makefile for wxPython
 #
 # Author:       Robin Dunn
 #
 # Created:	3/27/97
 # RCS-ID:       $Id$
 # Copyright:    (c) 1998 by Total Control Software
 # Licence:      wxWindows license
 #----------------------------------------------------------------------------
 VERSION=0.5.4
 # Set WXDIR to the root wxWindows directory for your system
 WXDIR = $(WXWIN)
 # Set this to the root of the Python installation
 PYTHONDIR=d:\Python
 # Set this to 1 for a non-debug, optimised compile
 FINAL=0
 # Set this to where you want the stuff installed at.  It should
 # be a directory contained in a PYTHONPATH directory, and should be
 # named wxPython
 TARGETDIR=..
 # Set this to 1 for make to pre-compile the Python modules, 0 to
 # just copy the sources and let Python compile them at the first
 # runtime.
 COMPILEPY=0
 SEPARATE=0
 #----------------------------------------------------------------------
 WXUSINGDLL=0
 NOPCH=1
 THISDIR=$(WXDIR)\utils\wxPython
 EXTRALIBS=$(PYTHONDIR)\libs\python15.lib
 EXTRAINC=-I$(PYTHONDIR)\include -I.
 EXTRAFLAGS=/Fpwxp.pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H
 OVERRIDEFLAGS=/GX-
 SWIGFLAGS=-c++ -shadow -python -dnone -D__WXMSW__
 GENCODEDIR=msw
 !include $(WXDIR)\src\ntwxwin.mak
 #----------------------------------------------------------------------
 TARGET = wxc
 OBJECTS = wx.obj         helpers.obj    windows.obj    events.obj     \
 	  misc.obj       gdi.obj        mdi.obj        controls.obj   \
 	  controls2.obj  windows2.obj   cmndlgs.obj    stattool.obj   \
 	  frames.obj     windows3.obj \
 !if "$(SEPARATE)" == "0"
 	  utils.obj
 !else
 TARGET2 = utilsc
 OBJECTS2 = utils.obj
 target2=$(TARGETDIR)\$(TARGET2).pyd
 !endif
 PYMODULES = $(TARGETDIR)\wx.py        $(TARGETDIR)\events.py    \
 	    $(TARGETDIR)\windows.py   $(TARGETDIR)\misc.py      \
 	    $(TARGETDIR)\gdi.py       $(TARGETDIR)\mdi.py       \
 	    $(TARGETDIR)\controls.py  $(TARGETDIR)\controls2.py \
            $(TARGETDIR)\windows2.py  $(TARGETDIR)\cmndlgs.py   \
 	    $(TARGETDIR)\stattool.py  $(TARGETDIR)\frames.py    \
 	    $(TARGETDIR)\utils.py     $(TARGETDIR)\windows3.py  \
 	    $(TARGETDIR)\__init__.py
 #----------------------------------------------------------------------
 !if "$(FINAL)" == "0"
 DEBUGLFLAGS = /DEBUG /INCREMENTAL:YES
 !else
 DEBUGLFLAGS = /INCREMENTAL:NO
 !endif
 LFLAGS= $(DEBUGLFLAGS) /DLL /def:$(TARGET).def /subsystem:windows,3.50 \
 	/machine:I386 /implib:./$(TARGET).lib /nologo
 LFLAGS2=$(DEBUGLFLAGS) /DLL /def:$(TARGET2).def /subsystem:windows,3.50 \
 	/machine:I386 /implib:./$(TARGET2).lib /nologo
 #----------------------------------------------------------------------
 default: $(TARGETDIR)\$(TARGET).pyd $(target2) pycfiles
 all:	wx $(TARGET) $(TARGET2)
 wx:
        cd $(WXDIR)\src\msw
        nmake -f makefile.nt FINAL=$(FINAL)
        cd $(THISDIR)
 wxclean:
        cd $(WXDIR)\src\msw
        nmake -f makefile.nt clean
        cd $(THISDIR)
 pycfiles : $(PYMODULES)
 !if "$(COMPILEPY)" == "1"
 	$(PYTHONDIR)\python $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
 	$(PYTHONDIR)\python -O $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
 !endif
 #----------------------------------------------------------------------
 $(TARGETDIR)\$(TARGET).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(TARGET).res
 	$(link) @<<
 /out:$@ /dll
 $(LFLAGS)
 $(DUMMYOBJ) $(OBJECTS) $(TARGET).res
 $(LIBS)
 <<
 $(TARGETDIR)\$(TARGET2).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS2)
 	$(link) @<<
 /out:$@ /dll
 $(LFLAGS2)
 $(DUMMYOBJ) $(OBJECTS2)
 $(LIBS)
 <<
 $(TARGET).res :      $(TARGET).rc $(WXDIR)\include\wx\msw\wx.rc
    $(rc) -r /i$(WXDIR)\include -fo$@ $(TARGET).rc
 # implicit rule for compiling .cpp files
 {}.cpp{}.obj:
        $(cc) @<<
 $(CPPFLAGS) /c /Tp $<
 <<
 {$(GENCODEDIR)}.cpp{}.obj:
        $(cc) @<<
 $(CPPFLAGS) /c /Tp $<
 <<
 clean:
        -erase *.obj
        -erase *.exe
        -erase *.res
        -erase *.map
        -erase *.sbr
        -erase *.pdb
 	-erase *.pch
 	-erase $(TARGET).exp
 	-erase $(TARGET).lib
 	-erase $(TARGETDIR)\$(TARGET).*
 !if "$(SEPARATE)" != "0"
 	-erase $(TARGET2).exp
 	-erase $(TARGET2).lib
 	-erase $(TARGETDIR)\$(TARGET2).*
 !endif
 	-erase $(TARGETDIR)\$(TARGET).pyd
 	-erase $(TARGETDIR)\*.py
 	-erase $(TARGETDIR)\*.pyc
 	-erase $(TARGETDIR)\*.pyo
 #------------------------------------------------------------------------
 .SUFFIXES : .i .py
 # Implicit rules to run SWIG
 {}.i{$(GENCODEDIR)}.cpp:
 	swig $(SWIGFLAGS) -c -o $@ $<
 {}.i{$(GENCODEDIR)}.py:
 	swig $(SWIGFLAGS) -c -o $@ $<
 {$(GENCODEDIR)}.py{$(TARGETDIR)}.py:
 	copy $< $@
 {}.py{$(TARGETDIR)}.py:
 	copy $< $@
 #{}.py{$(TARGETDIR)}.$(PYEXT):
 #	$(PYTHON) -c "import py_compile; py_compile.compile('$<', '$@')"
 # This one must leave out the -c flag so we define the whole rule
 $(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py : wx.i my_typemaps.i _defs.i _extras.py
        swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
 # Define some dependencies.  These MUST use forward slashes so SWIG
 # will write the shadow file to the right directory.
 $(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py   : windows.i    my_typemaps.i _defs.i
 $(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py  : windows2.i   my_typemaps.i _defs.i
 $(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py  : windows3.i   my_typemaps.i _defs.i
 $(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py    : events.i     my_typemaps.i _defs.i
 $(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py      : misc.i       my_typemaps.i _defs.i
 $(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py       : gdi.i        my_typemaps.i _defs.i
 $(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py       : mdi.i        my_typemaps.i _defs.i
 $(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py  : controls.i   my_typemaps.i _defs.i
 $(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i  my_typemaps.i _defs.i
 $(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py   : cmndlgs.i    my_typemaps.i _defs.i
 $(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py  : stattool.i   my_typemaps.i _defs.i
 $(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py    : frames.i     my_typemaps.i _defs.i
 !if "$(SEPARATE)" == "1"
 $(GENCODEDIR)\utils.cpp $(GENCODEDIR)\utils.py : utils.i my_typemaps.i
        swig $(SWIGFLAGS) -o $(GENCODEDIR)/utils.cpp utils.i
 !else
 $(GENCODEDIR)/utils.cpp    $(GENCODEDIR)/utils.py    : utils.i     my_typemaps.i _defs.i
 !endif
 $(TARGETDIR)\wx.py        : $(GENCODEDIR)\wx.py
 $(TARGETDIR)\windows.py   : $(GENCODEDIR)\windows.py
 $(TARGETDIR)\windows2.py  : $(GENCODEDIR)\windows2.py
 $(TARGETDIR)\windows3.py  : $(GENCODEDIR)\windows3.py
 $(TARGETDIR)\events.py    : $(GENCODEDIR)\events.py
 $(TARGETDIR)\misc.py      : $(GENCODEDIR)\misc.py
 $(TARGETDIR)\gdi.py       : $(GENCODEDIR)\gdi.py
 $(TARGETDIR)\mdi.py       : $(GENCODEDIR)\mdi.py
 $(TARGETDIR)\controls.py  : $(GENCODEDIR)\controls.py
 $(TARGETDIR)\controls2.py : $(GENCODEDIR)\controls2.py
 $(TARGETDIR)\cmndlgs.py   : $(GENCODEDIR)\cmndlgs.py
 $(TARGETDIR)\frames.py    : $(GENCODEDIR)\frames.py
 $(TARGETDIR)\stattool.py  : $(GENCODEDIR)\stattool.py
 $(TARGETDIR)\utils.py     : $(GENCODEDIR)\utils.py
 $(TARGETDIR)\__init__.py  : __init__.py
 SOURCES = $(GENCODEDIR)\wx.cpp        $(GENCODEDIR)\wx.py       \
 	  $(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py  \
 	  $(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py \
 	  $(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py \
 	  $(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py   \
 	  $(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py     \
 	  $(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py      \
 	  $(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py      \
 	  $(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py \
 	  $(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py\
 	  $(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py  \
 	  $(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py \
 	  $(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py   \
 	  $(GENCODEDIR)/utils.cpp     $(GENCODEDIR)/utils.py    \
 sources : $(SOURCES)
 dist:
 	cd ..\..
 	wxPython\distrib\zipit.bat $(VERSION)
 #------------------------------------------------------------------------
 #
 # $Log$
 # Revision 1.12  1999/06/28 21:39:47  VZ
 # 1. wxStaticLine implemented (generic (ugly) and MSW versions)
 # 2. wxTextDialog looks fine under MSW again
 # 3. startup tips added: code, sample, docs
 # 4. read-only text controls don't participate in TAB traversal
 #
 # Revision 1.11  1999/02/06 23:47:02  RD
 #
 # Changing makefile.nt to makefile.vc as in rest of wxWindows
 #
 # Revision 1.10  1999/02/01 00:10:40  RD
 #
 # Added the missing EVT_LIST_ITEM_SELECTED and friends.
 #
 # Revision 1.9  1999/01/30 07:30:13  RD
 #
 # Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
 #
 # Various cleanup, tweaks, minor additions, etc. to maintain
 # compatibility with the current wxWindows.
 #
 # Revision 1.8  1998/12/21 19:58:06  RD
 #
 # Now compiles with /GX- on MSW.
 #
 # Revision 1.7  1998/12/15 20:41:20  RD
 # Changed the import semantics from "from wxPython import *" to "from
 # wxPython.wx import *"  This is for people who are worried about
 # namespace pollution, they can use "from wxPython import wx" and then
 # prefix all the wxPython identifiers with "wx."
 #
 # Added wxTaskbarIcon for wxMSW.
 #
 # Made the events work for wxGrid.
 #
 # Added wxConfig.
 #
 # Added wxMiniFrame for wxGTK, (untested.)
 #
 # Changed many of the args and return values that were pointers to gdi
 # objects to references to reflect changes in the wxWindows API.
 #
 # Other assorted fixes and additions.
 #
 # Revision 1.6  1998/10/02 06:40:41  RD
 #
 # Version 0.4 of wxPython for MSW.
 #
 # Revision 1.5  1998/08/19 00:38:23  RD
 #
 # A few tweaks
 #
 # Revision 1.4  1998/08/18 21:55:10  RD
 #
 # New build directory structure
 #
 # Revision 1.3  1998/08/15 07:36:37  RD
 # - Moved the header in the .i files out of the code that gets put into
 # the .cpp files.  It caused CVS conflicts because of the RCS ID being
 # different each time.
 #
 # - A few minor fixes.
 #
 # Revision 1.2  1998/08/14 03:34:23  RD
 # made pre-compiling the python files optional
 #
 # Revision 1.1  1998/08/09 08:25:51  RD
 # Initial version
 #
--- a/utils/wxPython/src/wxp.cpp
+++ b/utils/wxPython/src/wxp.cpp
--- a/wxPython/b.bat
+++ b/wxPython/b.bat
@@ -33,6 +33,7 @@ rem just remove the *.pyd's
 elseiff "%1" == "d" then
 	shift
 	set CMD=del wxPython\*.pyd
 	set OTHERCMD=del wxPython\*.pdb
 rem touch all the *.i files so swig will regenerate
 elseiff "%1" == "t" then
--- a/wxPython/distrib/README.devel.txt
+++ b/wxPython/distrib/README.devel.txt
@@ -0,0 +1,27 @@
 This tarball contains all the files needed (I hope!) to allow you to
 write win32 programs or Python extension modules that link to the same
 wxWindows DLL that wxPython does.  Files for both the normal (ANSI)
 and unicode builds are included.
 You'll need to add the following directories to your Include path (the
 /I flag for MSVC):
 	wxPython-[version]\lib\mswdllh   [for ANSI builds]
 	wxPython-[version]\lib\mswdlluh  [for Unicode builds]
 	wxPython-[version]\include
 And also you should link with one of the wxmsw*.lib files in the lib
 dir, use the one with the 'u' in the name for the Unicode build and
 the one without for the ANSI build.
 I've also included some makefiles in the src dir to give you an idea
 of what compiler and linker flags are required.  You can also get this
 info from wxPython's setup.py script.
 I'm sure I've forgotten something, so when you discover what it is
 please let me know.  Also, if anyone feels like turning this text into
 a more detailed HOW-TO please send your text to me.
 Robin
--- a/wxPython/distrib/make_installer.py
+++ b/wxPython/distrib/make_installer.py
@@ -67,6 +67,7 @@ Name: tools;   Description: "Tools";                         Types: full
 [Files]
 Source: "%(SYSDIR)s\MSVCRT.dll";            DestDir: "{sys}"; CopyMode: alwaysskipifsameorolder; Flags: sharedfile uninsneveruninstall restartreplace; Components: core
 Source: "%(SYSDIR)s\MSVCIRT.dll";           DestDir: "{sys}"; CopyMode: alwaysskipifsameorolder; Flags: sharedfile uninsneveruninstall restartreplace; Components: core
 Source: "%(SYSDIR)s\MSVCP60.dll";           DestDir: "{sys}"; CopyMode: alwaysskipifsameorolder; Flags: sharedfile uninsneveruninstall restartreplace; Components: core
 Source: "%(WXDIR)s\lib\%(WXDLL)s";          DestDir: "{app}\wxPython"; Components: core
 %(MSLU)s
@@ -76,6 +77,7 @@ Source: "wxPython\gridc.pyd";               DestDir: "{app}\wxPython"; Component
 Source: "wxPython\helpc.pyd";               DestDir: "{app}\wxPython"; Components: core
 Source: "wxPython\htmlc.pyd";               DestDir: "{app}\wxPython"; Components: core
 Source: "wxPython\calendarc.pyd";           DestDir: "{app}\wxPython"; Components: core
 Source: "wxPython\wizardc.pyd";             DestDir: "{app}\wxPython"; Components: core
 Source: "wxPython\glcanvasc.pyd";           DestDir: "{app}\wxPython"; Components: core
 Source: "wxPython\oglc.pyd";                DestDir: "{app}\wxPython"; Components: core
 Source: "wxPython\stc_c.pyd";               DestDir: "{app}\wxPython"; Components: core
@@ -189,7 +191,8 @@ Source: "samples\embedded\*.xpm";          DestDir: "{app}\wxPython\samples\embe
 [Run]
 ;; Recreate the tool scripts to use the paths on the users machine
-Filename: "{code:GetPythonDir}\python.exe";  Parameters: "CreateBatchFiles.py";  WorkingDir: "{code:GetPythonDir}\Scripts";  Components: tools
+Filename: "{code:GetPythonDir}\python.exe";  Parameters: "{code:GetPythonDir}\Lib\compileall.py {app}\wxPython"; Description: "Compile Python .py files to .pyc"; Flags: postinstall; Components: core
 Filename: "{code:GetPythonDir}\python.exe";  Parameters: "CreateBatchFiles.py";  WorkingDir: "{code:GetPythonDir}\Scripts";  Description: "Create batch files for tool scripts"; Flags: postinstall; Components: tools
 ;;------------------------------------------------------------
@@ -244,6 +247,15 @@ Type: files; Name: "{app}\wxPython\samples\stxview\StructuredText\*.pyc";
 Type: files; Name: "{app}\wxPython\samples\stxview\StructuredText\*.pyo";
 Type: files; Name: "{app}\wxPython\samples\frogedit\*.pyc";
 Type: files; Name: "{app}\wxPython\samples\frogedit\*.pyo";
 Type: files; Name: "{app}\wxPython\demo\data\*.pyc";
 Type: files; Name: "{app}\wxPython\demo\data\*.pyo";
 Type: files; Name: "{app}\wxPython\demo\dllwidget\*.pyc";
 Type: files; Name: "{app}\wxPython\demo\dllwidget\*.pyo";
 Type: files; Name: "{app}\wxPython\samples\embedded\*.pyc";
 Type: files; Name: "{app}\wxPython\samples\embedded\*.pyo";
 Type: files; Name: "{app}\wxPython\samples\pySketch\*.pyc";
 Type: files; Name: "{app}\wxPython\samples\pySketch\*.pyo";
 '''
--- a/wxPython/distrib/makedemo
+++ b/wxPython/distrib/makedemo
@@ -28,8 +28,8 @@ rm -f `find  _distrib_tgz/wxPython-$1 -name *.so`
 cd _distrib_tgz
-tar cvf ../dist/wxPython-demo-$1.tar wxPython-$1
+tar cvf ../dist/wxPythonDemo-$1.tar wxPython-$1
-gzip ../dist/wxPython-demo-$1.tar
+gzip ../dist/wxPythonDemo-$1.tar
 cd ..
 rm -r _distrib_tgz
--- a/wxPython/distrib/makedev.bat
+++ b/wxPython/distrib/makedev.bat
@@ -1,47 +1,70 @@
@echo off
 rem   Builds a zip containing stuff needed to link with the wxWindows DLL
-rem   shipped with wxPython.  This allows other developers to create apps
+rem   shipped with wxPython.  This should allow other developers to create apps
 rem   or extensions that can share the same DLL.
 setlocal
 set BASE=_distrib_zip\wxPython-%1
-set BASE=wxPython-devel
+rem **** Make a directory to build up a distribution tree
-
+mkdir _distrib_zip
 mkdir %BASE%
 mkdir %BASE%\ReleaseDLL
 mkdir %BASE%\HybridDLL
 copy /s %WXWIN%\ReleaseDLL %BASE%\ReleaseDLL
 copy /s %WXWIN%\HybridDLL %BASE%\HybridDLL
-mkdir %BASE%\lib
+rem *** copy files
-copy %WXWIN%\lib\*.lib %BASE\lib
+copy distrib\README.devel.txt %BASE%\README.txt
 del %BASE%\lib\*d.lib
 copy %WXWIN%\lib\*.dll %BASE\lib
 del %BASE%\lib\*d.dll
 copy %WXWIN%\lib\*.pdb %BASE\lib
 del %BASE%\lib\*d.pdb
 copy /s %WXWIN%\lib\mswdll %BASE\lib\mswdll
 copy /s %WXWIN%\lib\mswdllh %BASE\lib\mswdllh
 mkdir %BASE%\src
 copy %WXWIN%\src\makevc.env %BASE%\src
 copy %WXWIN%\src\*.vc %BASE%\src
 mkdir %BASE%\src\msw
 mkdir %BASE%\src\msw\ReleaseDLL
 copy %WXWIN%\src\msw\ReleaseDLL\dummy*.obj %BASE%\src\msw\ReleaseDLL
 mkdir %BASE%\src\msw\HybridDLL
 copy %WXWIN%\src\msw\HybridDLL\dummy*.obj %BASE%\src\msw\HybridDLL
 mkdir %BASE%\include
 mkdir %BASE%\include\wx
-copy /s %WXWIN%\include\wx\* %BASE%\include\wx
+copy /s %WXWIN%\include\wx\* 	%BASE%\include\wx
 mkdir %BASE%\lib
 mkdir %BASE%\lib\mswdllh
 mkdir %BASE%\lib\mswdlluh
 copy /s %WXWIN%\lib\mswdllh\* 	%BASE%\lib\mswdllh
 copy /s %WXWIN%\lib\mswdlluh\* 	%BASE%\lib\mswdlluh
 copy %WXWIN%\lib\wxmsw*h.lib 	%BASE%\lib
 copy %WXWIN%\lib\wxmsw*h.dll 	%BASE%\lib
 copy %WXWIN%\lib\mslu.txt 	%BASE%\lib
 copy %WXWIN%\lib\unicows.dll 	%BASE%\lib
 copy %WXWIN%\lib\unicows.lib 	%BASE%\lib
 mkdir %BASE%\src
 copy %WXWIN%\src\makevc.env 	%BASE%\src
 copy %WXWIN%\src\makelib.vc 	%BASE%\src
-zip -r dist\wxPython-devel-win32-%1.zip %BASE%
+rem *** remove unneeded files
-del /sxzy %BASE%
+del /sxzy %BASE%\include\wx\CVS
 del /sxzy %BASE%\include\wx\generic\CVS
 del /sxzy %BASE%\include\wx\gtk\CVS
 del /sxzy %BASE%\include\wx\html\CVS
 del /sxzy %BASE%\include\wx\mac\CVS
 del /sxzy %BASE%\include\wx\mgl\CVS
 del /sxzy %BASE%\include\wx\motif\CVS
 del /sxzy %BASE%\include\wx\msw\CVS
 del /sxzy %BASE%\include\wx\msw\ctl3d\CVS
 del /sxzy %BASE%\include\wx\msw\gnuwin32\CVS
 del /sxzy %BASE%\include\wx\msw\gnuwin32\gl\CVS
 del /sxzy %BASE%\include\wx\msw\ole\CVS
 del /sxzy %BASE%\include\wx\os2\CVS
 del /sxzy %BASE%\include\wx\protocol\CVS
 del /sxzy %BASE%\include\wx\univ\CVS
 del /sxzy %BASE%\include\wx\unix\CVS
 del /sxzy %BASE%\include\wx\x11\CVS
 del /sxzy %BASE%\include\wx\x11\nanox\CVS
 del /sxzy %BASE%\include\wx\x11\nanox\X11\CVS
 rem *** bundle it all up
 cd _distrib_zip
 tar cvf ..\dist\wxPythonWIN32-devel-%1.tar wxPython-%1
 gzip -9 ..\dist\wxPythonWIN32-devel-%1.tar
 rem *** cleanup
 cd ..
 del /sxzy _distrib_zip
 endlocal
--- a/wxPython/distrib/makedocs.bat
+++ b/wxPython/distrib/makedocs.bat
@@ -0,0 +1,26 @@
@echo off
 rem **** Make a directory to build up a distribution tree
 md _distrib_zip
 md _distrib_zip\wxPython-%1
 cd _distrib_zip
 rem **** copy the docs into the tree
 md wxPython-%1\docs
 md wxPython-%1\docs\wx
 md wxPython-%1\docs\ogl
 copy %WXWIN%\docs\html\wx\*.* wxPython-%1\docs\wx
 copy wxPython-%1\docs\wx\wx.htm wxPython-%1\docs\wx\index.htm
 copy %WXWIN%\docs\html\ogl\*.* wxPython-%1\docs\ogl
 copy wxPython-%1\docs\ogl\ogl.htm wxPython-%1\docs\ogl\index.htm
 rem **** zip up the docs
 rem zip -r ..\distrib\wxPython-docs-%1.zip wxPython-%1\docs
 tar cvf ..\dist\wxPythonDocs-%1.tar wxPython-%1
 gzip -9 ..\dist\wxPythonDocs-%1.tar
 rem **** Cleanup
 cd ..
 del /sxzy _distrib_zip