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
-DLLTOOL = dlltool
+AS = $(CROSS)as
+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.
-It bears the following copyright notice:
+Copyright 1992, 1993, 1994, 1997 Henry Spencer.  All rights reserved.
+This software is not subject to any license of the American Telephone
+and Telegraph Company or of the Regents of the University of California.

-**********************************************************************
+Permission is granted to anyone to use this software for any purpose on
+any computer system, and to alter it and redistribute it, subject
+to the following restrictions:

-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.,
-UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
-Corporation, none of whom are responsible for the results.  The author
-thanks all of them. 
+2. The origin of this software must not be misrepresented, either by
+   explicit claim or by omission.  Since few users ever read sources,
+   credits must appear in the documentation.

-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.
-
-**********************************************************************
-
-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.
-****************************************************************************
+3. Altered versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.  Since few users
+   ever read sources, credits must appear in the documentation.

+4. This notice may not be removed or altered.
--- a/src/regex/Makefile
+++ b/src/regex/Makefile
@@ -1,28 +1,130 @@
-#-------------------------------------------------------------------------
-#
-# Makefile--
-#    Makefile for backend/regex
-#
-# IDENTIFICATION
-#    $Header: /projects/cvsroot/pgsql-server/src/backend/regex/Makefile,v 1.20 2003/02/05 17:41:32 tgl Exp $
-#
-#-------------------------------------------------------------------------
+# 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
+# internal assertion checking and some debugging facilities).
+# Put -Dconst= in for a pre-ANSI compiler.
+# Do not take -DPOSIX_MISTAKE out.
+# REGCFLAGS isn't important to you (it's for my use in some special contexts).
+CFLAGS=-I. -DPOSIX_MISTAKE -DREDEBUG $(REGCFLAGS)

-subdir = src/backend/regex
-top_builddir = ../../..
-include $(top_builddir)/src/Makefile.global
+# If you have a pre-ANSI compiler, put -o into MKHFLAGS.  If you want
+# the Berkeley __P macro, put -b in.
+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)
-	$(LD) $(LDREL) $(LDOUT) SUBSYS.o $(OBJS)
+# Internal stuff, should not need changing.
+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
-regcomp.o: regcomp.c regc_lex.c regc_color.c regc_nfa.c regc_cvec.c regc_locale.c
+# Stuff that matters only if you're trying to lint the package.
+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: 
-	rm -f SUBSYS.o $(OBJS)
+default:	r
+
+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 */
-/*
- * 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.
- */
+/* ========= begin header generated by ./mkh ========= */
 #ifdef __cplusplus
 extern "C" {
 #endif

-#include <sys/types.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifndef wxCHECK_GCC_VERSION
-#define wxCHECK_GCC_VERSION( major, minor ) \
-    ( defined(__GNUC__) && defined(__GNUC_MINOR__) \
-    && ( ( __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;
+/* === regex2.h === */
+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;
-
-/* result reporting (may acquire more fields later) */
-typedef struct
-{
-	regoff_t	rm_so;			/* start of substring */
-	regoff_t	rm_eo;			/* end of substring */
+typedef struct {
+	regoff_t rm_so;		/* start of match */
+	regoff_t rm_eo;		/* end of match */
 } regmatch_t;

-/* supplementary control and reporting */
-typedef struct
-{
-	regmatch_t	rm_extend;		/* see REG_EXPECT */
-} rm_detail_t;
+
+/* === regcomp.c === */
+extern int regcomp(regex_t *, const char *, int);
+#define	REG_BASIC	0000
+#define	REG_EXTENDED	0001
+#define	REG_ICASE	0002
+#define	REG_NOSUB	0004
+#define	REG_NEWLINE	0010
+#define	REG_NOSPEC	0020
+#define	REG_PEND	0040
+#define	REG_DUMP	0200


-
-/*
- * regex compilation flags
- */
-#define REG_BASIC	000000		/* BREs (convenience) */
-#define REG_EXTENDED	000001	/* EREs */
-#define REG_ADVF	000002		/* advanced features in EREs */
-#define REG_ADVANCED	000003	/* AREs (which are also EREs) */
-#define REG_QUOTE	000004		/* no special characters, none */
-#define REG_NOSPEC	REG_QUOTE	/* historical synonym */
-#define REG_ICASE	000010		/* ignore case */
-#define REG_NOSUB	000020		/* don't care about subexpressions */
-#define REG_EXPANDED	000040	/* expanded format, white space & comments */
-#define REG_NLSTOP	000100		/* \n doesn't match . or [^ ] */
-#define REG_NLANCH	000200		/* ^ matches after \n, $ before */
-#define REG_NEWLINE 000300		/* newlines are line terminators */
-#define REG_PEND	000400		/* ugh -- backward-compatibility hack */
-#define REG_EXPECT	001000		/* report details on partial/limited
-								 * matches */
-#define REG_BOSONLY 002000		/* temporary kludge for BOS-only matches */
-#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 *);
+/* === regerror.c === */
+#define	REG_OKAY	 0
+#define	REG_NOMATCH	 1
+#define	REG_BADPAT	 2
+#define	REG_ECOLLATE	 3
+#define	REG_ECTYPE	 4
+#define	REG_EESCAPE	 5
+#define	REG_ESUBREG	 6
+#define	REG_EBRACK	 7
+#define	REG_EPAREN	 8
+#define	REG_EBRACE	 9
+#define	REG_BADBR	10
+#define	REG_ERANGE	11
+#define	REG_ESPACE	12
+#define	REG_BADRPT	13
+#define	REG_EMPTY	14
+#define	REG_ASSERT	15
+#define	REG_INVARG	16
+#define	REG_ATOI	255	/* convert name to number (!) */
+#define	REG_ITOA	0400	/* convert number to name (!) */
 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
-
-#endif   /* _REGEX_H_ */
+/* ========= end header generated by ./mkh ========= */
+#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
-gzip ../dist/wxPython-demo-$1.tar
+tar cvf ../dist/wxPythonDemo-$1.tar wxPython-$1
+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
-copy %WXWIN%\lib\*.lib %BASE\lib
-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
+rem *** copy files
+copy distrib\README.devel.txt %BASE%\README.txt

 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%
-del /sxzy %BASE%
+rem *** remove unneeded files
+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