This commit was manufactured by cvs2svn to create tag 'TCL_8_4_5'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/TCL_8_4_5@24565 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/regex/regc_color.c

@@ -0,0 +1,778 @@
+/*
+ * 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.
+ *
+ *
+ *
+ * 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 *, struct colormap *);
+ */
+static VOID
+initcm(v, cm)
+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 *);
+ */
+static VOID
+freecm(cm)
+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 *, union tree *, int);
+ */
+static VOID
+cmtreefree(cm, tree, level)
+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 setcolor(struct colormap *, pchr, pcolor);
+ */
+static color			/* previous color */
+setcolor(cm, c, co)
+struct colormap *cm;
+pchr 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 *);
+ */
+static color
+maxcolor(cm)
+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 newcolor(struct colormap *);
+ */
+static color			/* COLORLESS for error */
+newcolor(cm)
+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 *, pcolor);
+ */
+static VOID
+freecolor(cm, co)
+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 *);
+ */
+static color
+pseudocolor(cm)
+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 *, pchr c);
+ */
+static color
+subcolor(cm, c)
+struct colormap *cm;
+pchr 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 *, pcolor);
+ */
+static color
+newsub(cm, co)
+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 *, pchr, pchr, struct state *,
+ ^ 	struct state *);
+ */
+static VOID
+subrange(v, from, to, lp, rp)
+struct vars *v;
+pchr from;
+pchr 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 *, pchr, struct state *, struct state *);
+ */
+static VOID
+subblock(v, start, lp, rp)
+struct vars *v;
+pchr 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 *, struct colormap *);
+ */
+static VOID
+okcolors(nfa, cm)
+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 *, struct arc *);
+ */
+static VOID
+colorchain(cm, a)
+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 *, struct arc *);
+ */
+static VOID
+uncolorchain(cm, a)
+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 singleton(struct colormap *, pchr c);
+ */
+static int			/* predicate */
+singleton(cm, c)
+struct colormap *cm;
+pchr 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 *, struct colormap *, int, pcolor,
+ ^ 	struct state *, struct state *);
+ */
+static VOID
+rainbow(nfa, cm, type, but, from, to)
+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 *, struct colormap *, int,
+ ^ 	struct state *, struct state *, struct state *);
+ */
+static VOID
+colorcomplement(nfa, cm, type, of, from, to)
+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
+/*
+ ^ #ifdef REG_DEBUG
+ */
+
+/*
+ - dumpcolors - debugging output
+ ^ static VOID dumpcolors(struct colormap *, FILE *);
+ */
+static VOID
+dumpcolors(cm, f)
+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 *, union tree *, int, FILE *);
+ */
+static VOID
+fillcheck(cm, tree, level, f)
+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(pchr, FILE *);
+ */
+static VOID
+dumpchr(c, f)
+pchr c;
+FILE *f;
+{
+	if (c == '\\')
+		fprintf(f, "\\\\");
+	else if (c > ' ' && c <= '~')
+		putc((char)c, f);
+	else
+		fprintf(f, "\\u%04lx", (long)c);
+}
+
+/*
+ ^ #endif
+ */
+#endif				/* ifdef REG_DEBUG */

src/regex/regc_cvec.c

@@ -0,0 +1,208 @@
+/*
+ * 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.
+ *
+ */
+
+/*
+ - newcvec - allocate a new cvec
+ ^ static struct cvec *newcvec(int, int, int);
+ */
+static struct cvec *
+newcvec(nchrs, nranges, nmcces)
+    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 *);
+ */
+static struct cvec *
+clearcvec(cv)
+    struct cvec *cv;			/* character vector */
+{
+    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 *, pchr);
+ */
+static VOID
+addchr(cv, c)
+    struct cvec *cv;			/* character vector */
+    pchr 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 *, pchr, pchr);
+ */
+static VOID
+addrange(cv, from, to)
+    struct cvec *cv;			/* character vector */
+    pchr from;				/* first character of range */
+    pchr 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 *, chr *, chr *);
+ */
+static VOID
+addmcce(cv, startp, endp)
+    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 haschr(struct cvec *, pchr);
+ */
+static int				/* predicate */
+haschr(cv, c)
+    struct cvec *cv;			/* character vector */
+    pchr 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 *, int, int, int);
+ */
+static struct cvec *
+getcvec(v, nchrs, nranges, nmcces)
+    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 *);
+ */
+static VOID
+freecvec(cv)
+    struct cvec *cv;			/* character vector */
+{
+    FREE(cv);
+}

src/regex/regc_locale.c

@@ -0,0 +1,989 @@
+/* 
+ * regc_locale.c --
+ *
+ *	This file contains the Unicode locale specific regexp routines.
+ *	This file is #included by regcomp.c.
+ *
+ * Copyright (c) 1998 by Scriptics Corporation.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id$
+ */
+
+/* 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}
+};
+
+/* Unicode character-class tables */
+
+typedef struct crange {
+    chr start;
+    chr end;
+} crange;
+
+/*
+ *	Declarations of Unicode character ranges.  This code
+ *	is automatically generated by the tools/uniClass.tcl script
+ *	and used in generic/regc_locale.c.  Do not modify by hand.
+ */
+
+/* Unicode: alphabetic characters */
+
+static crange alphaRangeTable[] = {
+    {0x0041, 0x005a}, {0x0061, 0x007a}, {0x00c0, 0x00d6}, {0x00d8, 0x00f6}, 
+    {0x00f8, 0x021f}, {0x0222, 0x0233}, {0x0250, 0x02ad}, {0x02b0, 0x02b8}, 
+    {0x02bb, 0x02c1}, {0x02e0, 0x02e4}, {0x0388, 0x038a}, {0x038e, 0x03a1}, 
+    {0x03a3, 0x03ce}, {0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x0481}, 
+    {0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0561, 0x0587}, 
+    {0x05d0, 0x05ea}, {0x05f0, 0x05f2}, {0x0621, 0x063a}, {0x0640, 0x064a}, 
+    {0x0671, 0x06d3}, {0x06fa, 0x06fc}, {0x0712, 0x072c}, {0x0780, 0x07a5}, 
+    {0x0905, 0x0939}, {0x0958, 0x0961}, {0x0985, 0x098c}, {0x0993, 0x09a8}, 
+    {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09df, 0x09e1}, {0x0a05, 0x0a0a}, 
+    {0x0a13, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a59, 0x0a5c}, {0x0a72, 0x0a74}, 
+    {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0}, 
+    {0x0ab5, 0x0ab9}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b28}, {0x0b2a, 0x0b30}, 
+    {0x0b36, 0x0b39}, {0x0b5f, 0x0b61}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90}, 
+    {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9}, 
+    {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c28}, {0x0c2a, 0x0c33}, 
+    {0x0c35, 0x0c39}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8}, 
+    {0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10}, 
+    {0x0d12, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1}, 
+    {0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0e01, 0x0e30}, {0x0e40, 0x0e46}, 
+    {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb0}, 
+    {0x0ec0, 0x0ec4}, {0x0f40, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f88, 0x0f8b}, 
+    {0x1000, 0x1021}, {0x1023, 0x1027}, {0x1050, 0x1055}, {0x10a0, 0x10c5}, 
+    {0x10d0, 0x10f6}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9}, 
+    {0x1200, 0x1206}, {0x1208, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256}, 
+    {0x125a, 0x125d}, {0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae}, 
+    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce}, 
+    {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315}, 
+    {0x1318, 0x131e}, {0x1320, 0x1346}, {0x1348, 0x135a}, {0x13a0, 0x13f4}, 
+    {0x1401, 0x166c}, {0x166f, 0x1676}, {0x1681, 0x169a}, {0x16a0, 0x16ea}, 
+    {0x1780, 0x17b3}, {0x1820, 0x1877}, {0x1880, 0x18a8}, {0x1e00, 0x1e9b}, 
+    {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, 
+    {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, 
+    {0x1fb6, 0x1fbc}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, 
+    {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, 
+    {0x210a, 0x2113}, {0x2119, 0x211d}, {0x212a, 0x212d}, {0x212f, 0x2131}, 
+    {0x2133, 0x2139}, {0x3031, 0x3035}, {0x3041, 0x3094}, {0x30a1, 0x30fa}, 
+    {0x30fc, 0x30fe}, {0x3105, 0x312c}, {0x3131, 0x318e}, {0x31a0, 0x31b7}, 
+    {0x3400, 0x4db5}, {0x4e00, 0x9fa5}, {0xa000, 0xa48c}, {0xac00, 0xd7a3}, 
+    {0xf900, 0xfa2d}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1f, 0xfb28}, 
+    {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d}, 
+    {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, {0xfe70, 0xfe72}, 
+    {0xfe76, 0xfefc}, {0xff21, 0xff3a}, {0xff41, 0xff5a}, {0xff66, 0xffbe}, 
+    {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc}
+};
+
+#define NUM_ALPHA_RANGE (sizeof(alphaRangeTable)/sizeof(crange))
+
+static chr alphaCharTable[] = {
+    0x00aa, 0x00b5, 0x00ba, 0x02d0, 0x02d1, 0x02ee, 0x037a, 0x0386, 0x038c, 
+    0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0559, 0x06d5, 0x06e5, 
+    0x06e6, 0x0710, 0x093d, 0x0950, 0x098f, 0x0990, 0x09b2, 0x09dc, 0x09dd, 
+    0x09f0, 0x09f1, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 
+    0x0a39, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0abd, 0x0ad0, 0x0ae0, 0x0b0f, 
+    0x0b10, 0x0b32, 0x0b33, 0x0b3d, 0x0b5c, 0x0b5d, 0x0b99, 0x0b9a, 0x0b9c, 
+    0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0c60, 0x0c61, 0x0cde, 0x0ce0, 0x0ce1, 
+    0x0d60, 0x0d61, 0x0dbd, 0x0e32, 0x0e33, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 
+    0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0eb2, 0x0eb3, 
+    0x0ebd, 0x0ec6, 0x0edc, 0x0edd, 0x0f00, 0x1029, 0x102a, 0x1248, 0x1258, 
+    0x1288, 0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x1fbe, 0x207f, 
+    0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x3005, 0x3006, 0x309d, 
+    0x309e, 0xfb1d, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74, 0xfffe
+};
+
+#define NUM_ALPHA_CHAR (sizeof(alphaCharTable)/sizeof(chr))
+
+/* Unicode: decimal digit characters */
+
+static crange digitRangeTable[] = {
+    {0x0030, 0x0039}, {0x0660, 0x0669}, {0x06f0, 0x06f9}, {0x0966, 0x096f}, 
+    {0x09e6, 0x09ef}, {0x0a66, 0x0a6f}, {0x0ae6, 0x0aef}, {0x0b66, 0x0b6f}, 
+    {0x0be7, 0x0bef}, {0x0c66, 0x0c6f}, {0x0ce6, 0x0cef}, {0x0d66, 0x0d6f}, 
+    {0x0e50, 0x0e59}, {0x0ed0, 0x0ed9}, {0x0f20, 0x0f29}, {0x1040, 0x1049}, 
+    {0x1369, 0x1371}, {0x17e0, 0x17e9}, {0x1810, 0x1819}, {0xff10, 0xff19}
+};
+
+#define NUM_DIGIT_RANGE (sizeof(digitRangeTable)/sizeof(crange))
+
+/* no singletons of digit characters */
+
+/* Unicode: punctuation characters */
+
+static crange punctRangeTable[] = {
+    {0x0021, 0x0023}, {0x0025, 0x002a}, {0x002c, 0x002f}, {0x005b, 0x005d}, 
+    {0x055a, 0x055f}, {0x066a, 0x066d}, {0x0700, 0x070d}, {0x0f04, 0x0f12}, 
+    {0x0f3a, 0x0f3d}, {0x104a, 0x104f}, {0x1361, 0x1368}, {0x16eb, 0x16ed}, 
+    {0x17d4, 0x17da}, {0x1800, 0x180a}, {0x2010, 0x2027}, {0x2030, 0x2043}, 
+    {0x2048, 0x204d}, {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f}, 
+    {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe61}, {0xff01, 0xff03}, 
+    {0xff05, 0xff0a}, {0xff0c, 0xff0f}, {0xff3b, 0xff3d}, {0xff61, 0xff65}
+};
+
+#define NUM_PUNCT_RANGE (sizeof(punctRangeTable)/sizeof(crange))
+
+static chr punctCharTable[] = {
+    0x003a, 0x003b, 0x003f, 0x0040, 0x005f, 0x007b, 0x007d, 0x00a1, 0x00ab, 
+    0x00ad, 0x00b7, 0x00bb, 0x00bf, 0x037e, 0x0387, 0x0589, 0x058a, 0x05be, 
+    0x05c0, 0x05c3, 0x05f3, 0x05f4, 0x060c, 0x061b, 0x061f, 0x06d4, 0x0964, 
+    0x0965, 0x0970, 0x0df4, 0x0e4f, 0x0e5a, 0x0e5b, 0x0f85, 0x10fb, 0x166d, 
+    0x166e, 0x169b, 0x169c, 0x17dc, 0x2045, 0x2046, 0x207d, 0x207e, 0x208d, 
+    0x208e, 0x2329, 0x232a, 0x3030, 0x30fb, 0xfd3e, 0xfd3f, 0xfe63, 0xfe68, 
+    0xfe6a, 0xfe6b, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3f, 0xff5b, 0xff5d
+};
+
+#define NUM_PUNCT_CHAR (sizeof(punctCharTable)/sizeof(chr))
+
+/* Unicode: white space characters */
+
+static crange spaceRangeTable[] = {
+    {0x0009, 0x000d}, {0x2000, 0x200b}
+};
+
+#define NUM_SPACE_RANGE (sizeof(spaceRangeTable)/sizeof(crange))
+
+static chr spaceCharTable[] = {
+    0x0020, 0x00a0, 0x1680, 0x2028, 0x2029, 0x202f, 0x3000
+};
+
+#define NUM_SPACE_CHAR (sizeof(spaceCharTable)/sizeof(chr))
+
+/* Unicode: lowercase characters */
+
+static crange lowerRangeTable[] = {
+    {0x0061, 0x007a}, {0x00df, 0x00f6}, {0x00f8, 0x00ff}, {0x017e, 0x0180}, 
+    {0x0199, 0x019b}, {0x01bd, 0x01bf}, {0x0250, 0x02ad}, {0x03ac, 0x03ce}, 
+    {0x03d5, 0x03d7}, {0x03ef, 0x03f3}, {0x0430, 0x045f}, {0x0561, 0x0587}, 
+    {0x1e95, 0x1e9b}, {0x1f00, 0x1f07}, {0x1f10, 0x1f15}, {0x1f20, 0x1f27}, 
+    {0x1f30, 0x1f37}, {0x1f40, 0x1f45}, {0x1f50, 0x1f57}, {0x1f60, 0x1f67}, 
+    {0x1f70, 0x1f7d}, {0x1f80, 0x1f87}, {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7}, 
+    {0x1fb0, 0x1fb4}, {0x1fc2, 0x1fc4}, {0x1fd0, 0x1fd3}, {0x1fe0, 0x1fe7}, 
+    {0x1ff2, 0x1ff4}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xff41, 0xff5a}
+};
+
+#define NUM_LOWER_RANGE (sizeof(lowerRangeTable)/sizeof(crange))
+
+static chr lowerCharTable[] = {
+    0x00aa, 0x00b5, 0x00ba, 0x0101, 0x0103, 0x0105, 0x0107, 0x0109, 0x010b, 
+    0x010d, 0x010f, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011b, 0x011d, 
+    0x011f, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012b, 0x012d, 0x012f, 
+    0x0131, 0x0133, 0x0135, 0x0137, 0x0138, 0x013a, 0x013c, 0x013e, 0x0140, 
+    0x0142, 0x0144, 0x0146, 0x0148, 0x0149, 0x014b, 0x014d, 0x014f, 0x0151, 
+    0x0153, 0x0155, 0x0157, 0x0159, 0x015b, 0x015d, 0x015f, 0x0161, 0x0163, 
+    0x0165, 0x0167, 0x0169, 0x016b, 0x016d, 0x016f, 0x0171, 0x0173, 0x0175, 
+    0x0177, 0x017a, 0x017c, 0x0183, 0x0185, 0x0188, 0x018c, 0x018d, 0x0192, 
+    0x0195, 0x019e, 0x01a1, 0x01a3, 0x01a5, 0x01a8, 0x01aa, 0x01ab, 0x01ad, 
+    0x01b0, 0x01b4, 0x01b6, 0x01b9, 0x01ba, 0x01c6, 0x01c9, 0x01cc, 0x01ce, 
+    0x01d0, 0x01d2, 0x01d4, 0x01d6, 0x01d8, 0x01da, 0x01dc, 0x01dd, 0x01df, 
+    0x01e1, 0x01e3, 0x01e5, 0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, 0x01f0, 
+    0x01f3, 0x01f5, 0x01f9, 0x01fb, 0x01fd, 0x01ff, 0x0201, 0x0203, 0x0205, 
+    0x0207, 0x0209, 0x020b, 0x020d, 0x020f, 0x0211, 0x0213, 0x0215, 0x0217, 
+    0x0219, 0x021b, 0x021d, 0x021f, 0x0223, 0x0225, 0x0227, 0x0229, 0x022b, 
+    0x022d, 0x022f, 0x0231, 0x0233, 0x0390, 0x03d0, 0x03d1, 0x03db, 0x03dd, 
+    0x03df, 0x03e1, 0x03e3, 0x03e5, 0x03e7, 0x03e9, 0x03eb, 0x03ed, 0x03f5, 
+    0x0461, 0x0463, 0x0465, 0x0467, 0x0469, 0x046b, 0x046d, 0x046f, 0x0471, 
+    0x0473, 0x0475, 0x0477, 0x0479, 0x047b, 0x047d, 0x047f, 0x0481, 0x048d, 
+    0x048f, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049b, 0x049d, 0x049f, 
+    0x04a1, 0x04a3, 0x04a5, 0x04a7, 0x04a9, 0x04ab, 0x04ad, 0x04af, 0x04b1, 
+    0x04b3, 0x04b5, 0x04b7, 0x04b9, 0x04bb, 0x04bd, 0x04bf, 0x04c2, 0x04c4, 
+    0x04c8, 0x04cc, 0x04d1, 0x04d3, 0x04d5, 0x04d7, 0x04d9, 0x04db, 0x04dd, 
+    0x04df, 0x04e1, 0x04e3, 0x04e5, 0x04e7, 0x04e9, 0x04eb, 0x04ed, 0x04ef, 
+    0x04f1, 0x04f3, 0x04f5, 0x04f9, 0x1e01, 0x1e03, 0x1e05, 0x1e07, 0x1e09, 
+    0x1e0b, 0x1e0d, 0x1e0f, 0x1e11, 0x1e13, 0x1e15, 0x1e17, 0x1e19, 0x1e1b, 
+    0x1e1d, 0x1e1f, 0x1e21, 0x1e23, 0x1e25, 0x1e27, 0x1e29, 0x1e2b, 0x1e2d, 
+    0x1e2f, 0x1e31, 0x1e33, 0x1e35, 0x1e37, 0x1e39, 0x1e3b, 0x1e3d, 0x1e3f, 
+    0x1e41, 0x1e43, 0x1e45, 0x1e47, 0x1e49, 0x1e4b, 0x1e4d, 0x1e4f, 0x1e51, 
+    0x1e53, 0x1e55, 0x1e57, 0x1e59, 0x1e5b, 0x1e5d, 0x1e5f, 0x1e61, 0x1e63, 
+    0x1e65, 0x1e67, 0x1e69, 0x1e6b, 0x1e6d, 0x1e6f, 0x1e71, 0x1e73, 0x1e75, 
+    0x1e77, 0x1e79, 0x1e7b, 0x1e7d, 0x1e7f, 0x1e81, 0x1e83, 0x1e85, 0x1e87, 
+    0x1e89, 0x1e8b, 0x1e8d, 0x1e8f, 0x1e91, 0x1e93, 0x1ea1, 0x1ea3, 0x1ea5, 
+    0x1ea7, 0x1ea9, 0x1eab, 0x1ead, 0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7, 
+    0x1eb9, 0x1ebb, 0x1ebd, 0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x1ec9, 
+    0x1ecb, 0x1ecd, 0x1ecf, 0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9, 0x1edb, 
+    0x1edd, 0x1edf, 0x1ee1, 0x1ee3, 0x1ee5, 0x1ee7, 0x1ee9, 0x1eeb, 0x1eed, 
+    0x1eef, 0x1ef1, 0x1ef3, 0x1ef5, 0x1ef7, 0x1ef9, 0x1fb6, 0x1fb7, 0x1fbe, 
+    0x1fc6, 0x1fc7, 0x1fd6, 0x1fd7, 0x1ff6, 0x1ff7, 0x207f, 0x210a, 0x210e, 
+    0x210f, 0x2113, 0x212f, 0x2134, 0x2139
+};
+
+#define NUM_LOWER_CHAR (sizeof(lowerCharTable)/sizeof(chr))
+
+/* Unicode: uppercase characters */
+
+static crange upperRangeTable[] = {
+    {0x0041, 0x005a}, {0x00c0, 0x00d6}, {0x00d8, 0x00de}, {0x0189, 0x018b}, 
+    {0x018e, 0x0191}, {0x0196, 0x0198}, {0x01b1, 0x01b3}, {0x01f6, 0x01f8}, 
+    {0x0388, 0x038a}, {0x0391, 0x03a1}, {0x03a3, 0x03ab}, {0x03d2, 0x03d4}, 
+    {0x0400, 0x042f}, {0x0531, 0x0556}, {0x10a0, 0x10c5}, {0x1f08, 0x1f0f}, 
+    {0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d}, 
+    {0x1f68, 0x1f6f}, {0x1fb8, 0x1fbb}, {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb}, 
+    {0x1fe8, 0x1fec}, {0x1ff8, 0x1ffb}, {0x210b, 0x210d}, {0x2110, 0x2112}, 
+    {0x2119, 0x211d}, {0x212a, 0x212d}, {0xff21, 0xff3a}
+};
+
+#define NUM_UPPER_RANGE (sizeof(upperRangeTable)/sizeof(crange))
+
+static chr upperCharTable[] = {
+    0x0100, 0x0102, 0x0104, 0x0106, 0x0108, 0x010a, 0x010c, 0x010e, 0x0110, 
+    0x0112, 0x0114, 0x0116, 0x0118, 0x011a, 0x011c, 0x011e, 0x0120, 0x0122, 
+    0x0124, 0x0126, 0x0128, 0x012a, 0x012c, 0x012e, 0x0130, 0x0132, 0x0134, 
+    0x0136, 0x0139, 0x013b, 0x013d, 0x013f, 0x0141, 0x0143, 0x0145, 0x0147, 
+    0x014a, 0x014c, 0x014e, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158, 0x015a, 
+    0x015c, 0x015e, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016a, 0x016c, 
+    0x016e, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179, 0x017b, 0x017d, 
+    0x0181, 0x0182, 0x0184, 0x0186, 0x0187, 0x0193, 0x0194, 0x019c, 0x019d, 
+    0x019f, 0x01a0, 0x01a2, 0x01a4, 0x01a6, 0x01a7, 0x01a9, 0x01ac, 0x01ae, 
+    0x01af, 0x01b5, 0x01b7, 0x01b8, 0x01bc, 0x01c4, 0x01c7, 0x01ca, 0x01cd, 
+    0x01cf, 0x01d1, 0x01d3, 0x01d5, 0x01d7, 0x01d9, 0x01db, 0x01de, 0x01e0, 
+    0x01e2, 0x01e4, 0x01e6, 0x01e8, 0x01ea, 0x01ec, 0x01ee, 0x01f1, 0x01f4, 
+    0x01fa, 0x01fc, 0x01fe, 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a, 
+    0x020c, 0x020e, 0x0210, 0x0212, 0x0214, 0x0216, 0x0218, 0x021a, 0x021c, 
+    0x021e, 0x0222, 0x0224, 0x0226, 0x0228, 0x022a, 0x022c, 0x022e, 0x0230, 
+    0x0232, 0x0386, 0x038c, 0x038e, 0x038f, 0x03da, 0x03dc, 0x03de, 0x03e0, 
+    0x03e2, 0x03e4, 0x03e6, 0x03e8, 0x03ea, 0x03ec, 0x03ee, 0x03f4, 0x0460, 
+    0x0462, 0x0464, 0x0466, 0x0468, 0x046a, 0x046c, 0x046e, 0x0470, 0x0472, 
+    0x0474, 0x0476, 0x0478, 0x047a, 0x047c, 0x047e, 0x0480, 0x048c, 0x048e, 
+    0x0490, 0x0492, 0x0494, 0x0496, 0x0498, 0x049a, 0x049c, 0x049e, 0x04a0, 
+    0x04a2, 0x04a4, 0x04a6, 0x04a8, 0x04aa, 0x04ac, 0x04ae, 0x04b0, 0x04b2, 
+    0x04b4, 0x04b6, 0x04b8, 0x04ba, 0x04bc, 0x04be, 0x04c0, 0x04c1, 0x04c3, 
+    0x04c7, 0x04cb, 0x04d0, 0x04d2, 0x04d4, 0x04d6, 0x04d8, 0x04da, 0x04dc, 
+    0x04de, 0x04e0, 0x04e2, 0x04e4, 0x04e6, 0x04e8, 0x04ea, 0x04ec, 0x04ee, 
+    0x04f0, 0x04f2, 0x04f4, 0x04f8, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08, 
+    0x1e0a, 0x1e0c, 0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, 0x1e18, 0x1e1a, 
+    0x1e1c, 0x1e1e, 0x1e20, 0x1e22, 0x1e24, 0x1e26, 0x1e28, 0x1e2a, 0x1e2c, 
+    0x1e2e, 0x1e30, 0x1e32, 0x1e34, 0x1e36, 0x1e38, 0x1e3a, 0x1e3c, 0x1e3e, 
+    0x1e40, 0x1e42, 0x1e44, 0x1e46, 0x1e48, 0x1e4a, 0x1e4c, 0x1e4e, 0x1e50, 
+    0x1e52, 0x1e54, 0x1e56, 0x1e58, 0x1e5a, 0x1e5c, 0x1e5e, 0x1e60, 0x1e62, 
+    0x1e64, 0x1e66, 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70, 0x1e72, 0x1e74, 
+    0x1e76, 0x1e78, 0x1e7a, 0x1e7c, 0x1e7e, 0x1e80, 0x1e82, 0x1e84, 0x1e86, 
+    0x1e88, 0x1e8a, 0x1e8c, 0x1e8e, 0x1e90, 0x1e92, 0x1e94, 0x1ea0, 0x1ea2, 
+    0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac, 0x1eae, 0x1eb0, 0x1eb2, 0x1eb4, 
+    0x1eb6, 0x1eb8, 0x1eba, 0x1ebc, 0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6, 
+    0x1ec8, 0x1eca, 0x1ecc, 0x1ece, 0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8, 
+    0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2, 0x1ee4, 0x1ee6, 0x1ee8, 0x1eea, 
+    0x1eec, 0x1eee, 0x1ef0, 0x1ef2, 0x1ef4, 0x1ef6, 0x1ef8, 0x1f59, 0x1f5b, 
+    0x1f5d, 0x1f5f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2130, 
+    0x2131, 0x2133
+};
+
+#define NUM_UPPER_CHAR (sizeof(upperCharTable)/sizeof(chr))
+
+/* Unicode: unicode print characters excluding space */
+
+static crange graphRangeTable[] = {
+    {0x0021, 0x007e}, {0x00a0, 0x011f}, {0x0121, 0x021f}, {0x0222, 0x0233}, 
+    {0x0250, 0x02ad}, {0x02b0, 0x02ee}, {0x0300, 0x031f}, {0x0321, 0x034e}, 
+    {0x0360, 0x0362}, {0x0384, 0x038a}, {0x038e, 0x03a1}, {0x03a3, 0x03ce}, 
+    {0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x041f}, {0x0421, 0x0486}, 
+    {0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0559, 0x055f}, 
+    {0x0561, 0x0587}, {0x0591, 0x05a1}, {0x05a3, 0x05b9}, {0x05bb, 0x05c4}, 
+    {0x05d0, 0x05ea}, {0x05f0, 0x05f4}, {0x0621, 0x063a}, {0x0640, 0x0655}, 
+    {0x0660, 0x066d}, {0x0670, 0x06ed}, {0x06f0, 0x06fe}, {0x0700, 0x070d}, 
+    {0x0710, 0x071f}, {0x0721, 0x072c}, {0x0730, 0x074a}, {0x0780, 0x07b0}, 
+    {0x0901, 0x0903}, {0x0905, 0x091f}, {0x0921, 0x0939}, {0x093c, 0x094d}, 
+    {0x0950, 0x0954}, {0x0958, 0x0970}, {0x0981, 0x0983}, {0x0985, 0x098c}, 
+    {0x0993, 0x09a8}, {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09be, 0x09c4}, 
+    {0x09cb, 0x09cd}, {0x09df, 0x09e3}, {0x09e6, 0x09fa}, {0x0a05, 0x0a0a}, 
+    {0x0a13, 0x0a1f}, {0x0a21, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a3e, 0x0a42}, 
+    {0x0a4b, 0x0a4d}, {0x0a59, 0x0a5c}, {0x0a66, 0x0a74}, {0x0a81, 0x0a83}, 
+    {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0}, 
+    {0x0ab5, 0x0ab9}, {0x0abc, 0x0ac5}, {0x0ac7, 0x0ac9}, {0x0acb, 0x0acd}, 
+    {0x0ae6, 0x0aef}, {0x0b01, 0x0b03}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b1f}, 
+    {0x0b21, 0x0b28}, {0x0b2a, 0x0b30}, {0x0b36, 0x0b39}, {0x0b3c, 0x0b43}, 
+    {0x0b4b, 0x0b4d}, {0x0b5f, 0x0b61}, {0x0b66, 0x0b70}, {0x0b85, 0x0b8a}, 
+    {0x0b8e, 0x0b90}, {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, 
+    {0x0bb7, 0x0bb9}, {0x0bbe, 0x0bc2}, {0x0bc6, 0x0bc8}, {0x0bca, 0x0bcd}, 
+    {0x0be7, 0x0bf2}, {0x0c01, 0x0c03}, {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, 
+    {0x0c12, 0x0c1f}, {0x0c21, 0x0c28}, {0x0c2a, 0x0c33}, {0x0c35, 0x0c39}, 
+    {0x0c3e, 0x0c44}, {0x0c46, 0x0c48}, {0x0c4a, 0x0c4d}, {0x0c66, 0x0c6f}, 
+    {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8}, {0x0caa, 0x0cb3}, 
+    {0x0cb5, 0x0cb9}, {0x0cbe, 0x0cc4}, {0x0cc6, 0x0cc8}, {0x0cca, 0x0ccd}, 
+    {0x0ce6, 0x0cef}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10}, {0x0d12, 0x0d1f}, 
+    {0x0d21, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d3e, 0x0d43}, {0x0d46, 0x0d48}, 
+    {0x0d4a, 0x0d4d}, {0x0d66, 0x0d6f}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1}, 
+    {0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0dcf, 0x0dd4}, {0x0dd8, 0x0ddf}, 
+    {0x0df2, 0x0df4}, {0x0e01, 0x0e1f}, {0x0e21, 0x0e3a}, {0x0e3f, 0x0e5b}, 
+    {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb9}, 
+    {0x0ebb, 0x0ebd}, {0x0ec0, 0x0ec4}, {0x0ec8, 0x0ecd}, {0x0ed0, 0x0ed9}, 
+    {0x0f00, 0x0f1f}, {0x0f21, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f71, 0x0f8b}, 
+    {0x0f90, 0x0f97}, {0x0f99, 0x0fbc}, {0x0fbe, 0x0fcc}, {0x1000, 0x101f}, 
+    {0x1023, 0x1027}, {0x102c, 0x1032}, {0x1036, 0x1039}, {0x1040, 0x1059}, 
+    {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x111f}, {0x1121, 0x1159}, 
+    {0x115f, 0x11a2}, {0x11a8, 0x11f9}, {0x1200, 0x1206}, {0x1208, 0x121f}, 
+    {0x1221, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256}, {0x125a, 0x125d}, 
+    {0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b2, 0x12b5}, 
+    {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce}, {0x12d0, 0x12d6}, 
+    {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315}, {0x1318, 0x131e}, 
+    {0x1321, 0x1346}, {0x1348, 0x135a}, {0x1361, 0x137c}, {0x13a0, 0x13f4}, 
+    {0x1401, 0x141f}, {0x1421, 0x151f}, {0x1521, 0x161f}, {0x1621, 0x1676}, 
+    {0x1680, 0x169c}, {0x16a0, 0x16f0}, {0x1780, 0x17dc}, {0x17e0, 0x17e9}, 
+    {0x1800, 0x180a}, {0x1810, 0x1819}, {0x1821, 0x1877}, {0x1880, 0x18a9}, 
+    {0x1e00, 0x1e1f}, {0x1e21, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, 
+    {0x1f18, 0x1f1d}, {0x1f21, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, 
+    {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3}, 
+    {0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe}, 
+    {0x2000, 0x200b}, {0x2010, 0x201f}, {0x2021, 0x2029}, {0x202f, 0x2046}, 
+    {0x2048, 0x204d}, {0x2074, 0x208e}, {0x20a0, 0x20af}, {0x20d0, 0x20e3}, 
+    {0x2100, 0x211f}, {0x2121, 0x213a}, {0x2153, 0x2183}, {0x2190, 0x21f3}, 
+    {0x2200, 0x221f}, {0x2221, 0x22f1}, {0x2300, 0x231f}, {0x2321, 0x237b}, 
+    {0x237d, 0x239a}, {0x2400, 0x241f}, {0x2421, 0x2426}, {0x2440, 0x244a}, 
+    {0x2460, 0x24ea}, {0x2500, 0x251f}, {0x2521, 0x2595}, {0x25a0, 0x25f7}, 
+    {0x2600, 0x2613}, {0x2619, 0x261f}, {0x2621, 0x2671}, {0x2701, 0x2704}, 
+    {0x2706, 0x2709}, {0x270c, 0x271f}, {0x2721, 0x2727}, {0x2729, 0x274b}, 
+    {0x274f, 0x2752}, {0x2758, 0x275e}, {0x2761, 0x2767}, {0x2776, 0x2794}, 
+    {0x2798, 0x27af}, {0x27b1, 0x27be}, {0x2800, 0x281f}, {0x2821, 0x28ff}, 
+    {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2f1f}, {0x2f21, 0x2fd5}, 
+    {0x2ff0, 0x2ffb}, {0x3000, 0x301f}, {0x3021, 0x303a}, {0x3041, 0x3094}, 
+    {0x3099, 0x309e}, {0x30a1, 0x30fe}, {0x3105, 0x311f}, {0x3121, 0x312c}, 
+    {0x3131, 0x318e}, {0x3190, 0x31b7}, {0x3200, 0x321c}, {0x3221, 0x3243}, 
+    {0x3260, 0x327b}, {0x327f, 0x32b0}, {0x32c0, 0x32cb}, {0x32d0, 0x32fe}, 
+    {0x3300, 0x331f}, {0x3321, 0x3376}, {0x337b, 0x33dd}, {0x33e0, 0x33fe}, 
+    {0x3400, 0x341f}, {0x3421, 0x351f}, {0x3521, 0x361f}, {0x3621, 0x371f}, 
+    {0x3721, 0x381f}, {0x3821, 0x391f}, {0x3921, 0x3a1f}, {0x3a21, 0x3b1f}, 
+    {0x3b21, 0x3c1f}, {0x3c21, 0x3d1f}, {0x3d21, 0x3e1f}, {0x3e21, 0x3f1f}, 
+    {0x3f21, 0x401f}, {0x4021, 0x411f}, {0x4121, 0x421f}, {0x4221, 0x431f}, 
+    {0x4321, 0x441f}, {0x4421, 0x451f}, {0x4521, 0x461f}, {0x4621, 0x471f}, 
+    {0x4721, 0x481f}, {0x4821, 0x491f}, {0x4921, 0x4a1f}, {0x4a21, 0x4b1f}, 
+    {0x4b21, 0x4c1f}, {0x4c21, 0x4d1f}, {0x4d21, 0x4db5}, {0x4e00, 0x4e1f}, 
+    {0x4e21, 0x4f1f}, {0x4f21, 0x501f}, {0x5021, 0x511f}, {0x5121, 0x521f}, 
+    {0x5221, 0x531f}, {0x5321, 0x541f}, {0x5421, 0x551f}, {0x5521, 0x561f}, 
+    {0x5621, 0x571f}, {0x5721, 0x581f}, {0x5821, 0x591f}, {0x5921, 0x5a1f}, 
+    {0x5a21, 0x5b1f}, {0x5b21, 0x5c1f}, {0x5c21, 0x5d1f}, {0x5d21, 0x5e1f}, 
+    {0x5e21, 0x5f1f}, {0x5f21, 0x601f}, {0x6021, 0x611f}, {0x6121, 0x621f}, 
+    {0x6221, 0x631f}, {0x6321, 0x641f}, {0x6421, 0x651f}, {0x6521, 0x661f}, 
+    {0x6621, 0x671f}, {0x6721, 0x681f}, {0x6821, 0x691f}, {0x6921, 0x6a1f}, 
+    {0x6a21, 0x6b1f}, {0x6b21, 0x6c1f}, {0x6c21, 0x6d1f}, {0x6d21, 0x6e1f}, 
+    {0x6e21, 0x6f1f}, {0x6f21, 0x701f}, {0x7021, 0x711f}, {0x7121, 0x721f}, 
+    {0x7221, 0x731f}, {0x7321, 0x741f}, {0x7421, 0x751f}, {0x7521, 0x761f}, 
+    {0x7621, 0x771f}, {0x7721, 0x781f}, {0x7821, 0x791f}, {0x7921, 0x7a1f}, 
+    {0x7a21, 0x7b1f}, {0x7b21, 0x7c1f}, {0x7c21, 0x7d1f}, {0x7d21, 0x7e1f}, 
+    {0x7e21, 0x7f1f}, {0x7f21, 0x801f}, {0x8021, 0x811f}, {0x8121, 0x821f}, 
+    {0x8221, 0x831f}, {0x8321, 0x841f}, {0x8421, 0x851f}, {0x8521, 0x861f}, 
+    {0x8621, 0x871f}, {0x8721, 0x881f}, {0x8821, 0x891f}, {0x8921, 0x8a1f}, 
+    {0x8a21, 0x8b1f}, {0x8b21, 0x8c1f}, {0x8c21, 0x8d1f}, {0x8d21, 0x8e1f}, 
+    {0x8e21, 0x8f1f}, {0x8f21, 0x901f}, {0x9021, 0x911f}, {0x9121, 0x921f}, 
+    {0x9221, 0x931f}, {0x9321, 0x941f}, {0x9421, 0x951f}, {0x9521, 0x961f}, 
+    {0x9621, 0x971f}, {0x9721, 0x981f}, {0x9821, 0x991f}, {0x9921, 0x9a1f}, 
+    {0x9a21, 0x9b1f}, {0x9b21, 0x9c1f}, {0x9c21, 0x9d1f}, {0x9d21, 0x9e1f}, 
+    {0x9e21, 0x9f1f}, {0x9f21, 0x9fa5}, {0xa000, 0xa01f}, {0xa021, 0xa11f}, 
+    {0xa121, 0xa21f}, {0xa221, 0xa31f}, {0xa321, 0xa41f}, {0xa421, 0xa48c}, 
+    {0xa490, 0xa4a1}, {0xa4a4, 0xa4b3}, {0xa4b5, 0xa4c0}, {0xa4c2, 0xa4c4}, 
+    {0xac00, 0xac1f}, {0xac21, 0xad1f}, {0xad21, 0xae1f}, {0xae21, 0xaf1f}, 
+    {0xaf21, 0xb01f}, {0xb021, 0xb11f}, {0xb121, 0xb21f}, {0xb221, 0xb31f}, 
+    {0xb321, 0xb41f}, {0xb421, 0xb51f}, {0xb521, 0xb61f}, {0xb621, 0xb71f}, 
+    {0xb721, 0xb81f}, {0xb821, 0xb91f}, {0xb921, 0xba1f}, {0xba21, 0xbb1f}, 
+    {0xbb21, 0xbc1f}, {0xbc21, 0xbd1f}, {0xbd21, 0xbe1f}, {0xbe21, 0xbf1f}, 
+    {0xbf21, 0xc01f}, {0xc021, 0xc11f}, {0xc121, 0xc21f}, {0xc221, 0xc31f}, 
+    {0xc321, 0xc41f}, {0xc421, 0xc51f}, {0xc521, 0xc61f}, {0xc621, 0xc71f}, 
+    {0xc721, 0xc81f}, {0xc821, 0xc91f}, {0xc921, 0xca1f}, {0xca21, 0xcb1f}, 
+    {0xcb21, 0xcc1f}, {0xcc21, 0xcd1f}, {0xcd21, 0xce1f}, {0xce21, 0xcf1f}, 
+    {0xcf21, 0xd01f}, {0xd021, 0xd11f}, {0xd121, 0xd21f}, {0xd221, 0xd31f}, 
+    {0xd321, 0xd41f}, {0xd421, 0xd51f}, {0xd521, 0xd61f}, {0xd621, 0xd71f}, 
+    {0xd721, 0xd7a3}, {0xf900, 0xf91f}, {0xf921, 0xfa1f}, {0xfa21, 0xfa2d}, 
+    {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb1f}, {0xfb21, 0xfb36}, 
+    {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfc1f}, {0xfc21, 0xfd1f}, 
+    {0xfd21, 0xfd3f}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, 
+    {0xfe21, 0xfe23}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe66}, 
+    {0xfe68, 0xfe6b}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc}, {0xff01, 0xff1f}, 
+    {0xff21, 0xff5e}, {0xff61, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, 
+    {0xffd2, 0xffd7}, {0xffda, 0xffdc}, {0xffe0, 0xffe6}, {0xffe8, 0xffee}, 
+    {0xfffc, 0xffff}
+};
+
+#define NUM_GRAPH_RANGE (sizeof(graphRangeTable)/sizeof(crange))
+
+static chr graphCharTable[] = {
+    0x0374, 0x0375, 0x037a, 0x037e, 0x038c, 0x0488, 0x0489, 0x04c7, 0x04c8, 
+    0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0589, 0x058a, 0x060c, 0x061b, 0x061f, 
+    0x098f, 0x0990, 0x09b2, 0x09bc, 0x09c7, 0x09c8, 0x09d7, 0x09dc, 0x09dd, 
+    0x0a02, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 0x0a39, 
+    0x0a3c, 0x0a47, 0x0a48, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0ad0, 0x0ae0, 
+    0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b47, 0x0b48, 0x0b56, 0x0b57, 0x0b5c, 
+    0x0b5d, 0x0b82, 0x0b83, 0x0b99, 0x0b9a, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3, 
+    0x0ba4, 0x0bd7, 0x0c55, 0x0c56, 0x0c60, 0x0c61, 0x0c82, 0x0c83, 0x0cd5, 
+    0x0cd6, 0x0cde, 0x0ce0, 0x0ce1, 0x0d02, 0x0d03, 0x0d57, 0x0d60, 0x0d61, 
+    0x0d82, 0x0d83, 0x0dbd, 0x0dca, 0x0dd6, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 
+    0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0ec6, 0x0edc, 
+    0x0edd, 0x0fcf, 0x1021, 0x1029, 0x102a, 0x10fb, 0x1248, 0x1258, 0x1288, 
+    0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x2070, 0x274d, 0x2756, 
+    0x303e, 0x303f, 0xa4c6, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74
+};
+
+#define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))
+
+/*
+ *	End of auto-generated Unicode character ranges declarations.
+ */
+
+#define	CH	NOCELT
+
+/*
+ - nmcces - how many distinct MCCEs are there?
+ ^ static int nmcces(struct vars *);
+ */
+static int
+nmcces(v)
+    struct vars *v;			/* context */
+{
+    /*
+     * 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 *);
+ */
+static int
+nleaders(v)
+    struct vars *v;			/* context */
+{
+    return 0;
+}
+
+/*
+ - allmcces - return a cvec with all the MCCEs of the locale
+ ^ static struct cvec *allmcces(struct vars *, struct cvec *);
+ */
+static struct cvec *
+allmcces(v, cv)
+    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 *, chr *, chr *);
+ */
+static celt
+element(v, startp, endp)
+    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;
+    Tcl_DString ds;
+    CONST char *np;
+
+    /* generic:  one-chr names stand for themselves */
+    assert(startp < endp);
+    len = endp - startp;
+    if (len == 1) {
+	return *startp;
+    }
+
+    NOTE(REG_ULOCALE);
+
+    /* search table */
+    Tcl_DStringInit(&ds);
+    np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
+    for (cn=cnames; cn->name!=NULL; cn++) {
+	if (strlen(cn->name)==len && strncmp(cn->name, np, len)==0) {
+	    break;			/* NOTE BREAK OUT */
+	}
+    }
+    Tcl_DStringFree(&ds);
+    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 *, celt, celt, int);
+ */
+static struct cvec *
+range(v, a, b, cases)
+    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, tc;
+
+    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 = Tcl_UniCharToLower((chr)c);
+	uc = Tcl_UniCharToUpper((chr)c);
+	tc = Tcl_UniCharToTitle((chr)c);
+	if (c != lc) {
+	    addchr(cv, lc);
+	}
+	if (c != uc) {
+	    addchr(cv, uc);
+	}
+	if (c != tc && tc != uc) {
+	    addchr(cv, tc);
+	}
+    }
+
+    return cv;
+}
+
+/*
+ - before - is celt x before celt y, for purposes of range legality?
+ ^ static int before(celt, celt);
+ */
+static int				/* predicate */
+before(x, y)
+    celt x, y;				/* collating elements */
+{
+    /* 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 *, celt, int);
+ */
+static struct cvec *
+eclass(v, c, cases)
+    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 *, chr *, chr *, int);
+ */
+static struct cvec *
+cclass(v, startp, endp, cases)
+    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;
+    Tcl_DString ds;
+    CONST char *np;
+    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
+    };
+    
+
+    /*
+     * Extract the class name
+     */
+
+    len = endp - startp;
+    Tcl_DStringInit(&ds);
+    np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
+
+    /*
+     * Remap lower and upper to alpha if the match is case insensitive.
+     */
+
+    if (cases && len == 5 && (strncmp("lower", np, 5) == 0
+	    || strncmp("upper", np, 5) == 0)) {
+	np = "alpha";
+    }
+
+    /*
+     * Map the name to the corresponding enumerated value.
+     */
+
+    index = -1;
+    for (namePtr=classNames,i=0 ; *namePtr!=NULL ; namePtr++,i++) {
+	if ((strlen(*namePtr) == len) && (strncmp(*namePtr, np, len) == 0)) {
+	    index = i;
+	    break;
+	}
+    }
+    Tcl_DStringInit(&ds);
+    if (index == -1) {
+	ERR(REG_ECTYPE);
+	return NULL;
+    }
+    
+    /*
+     * Now compute the character class contents.
+     */
+
+    switch((enum classes) index) {
+    case CC_PRINT:
+    case CC_ALNUM:
+	cv = getcvec(v, NUM_ALPHA_CHAR, NUM_DIGIT_RANGE + NUM_ALPHA_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
+		addchr(cv, alphaCharTable[i]);
+	    }
+	    for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
+		addrange(cv, alphaRangeTable[i].start,
+			alphaRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
+		addrange(cv, digitRangeTable[i].start,
+			digitRangeTable[i].end);
+	    }
+	}
+	break;
+    case CC_ALPHA:
+	cv = getcvec(v, NUM_ALPHA_CHAR, NUM_ALPHA_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
+		addrange(cv, alphaRangeTable[i].start,
+			alphaRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
+		addchr(cv, alphaCharTable[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, NUM_DIGIT_RANGE, 0);
+	if (cv) {	
+	    for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
+		addrange(cv, digitRangeTable[i].start,
+			digitRangeTable[i].end);
+	    }
+	}
+	break;
+    case CC_PUNCT:
+	cv = getcvec(v, NUM_PUNCT_CHAR, NUM_PUNCT_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_PUNCT_RANGE ; i++) {
+		addrange(cv, punctRangeTable[i].start,
+			punctRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_PUNCT_CHAR ; i++) {
+		addchr(cv, punctCharTable[i]);
+	    }
+	}
+	break;
+    case CC_XDIGIT:
+	/*
+	 * This is a 3 instead of (NUM_DIGIT_RANGE+2) because I've no
+	 * idea how to define the digits 'a' through 'f' in
+	 * non-western locales.  The concept is quite possibly non
+	 * portable, or only used in contextx where the characters
+	 * used would be the western ones anyway!  Whatever is
+	 * actually the case, the number of ranges is fixed (until
+	 * someone comes up with a better arrangement!)
+	 */
+	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, NUM_SPACE_CHAR, NUM_SPACE_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_SPACE_RANGE ; i++) {
+		addrange(cv, spaceRangeTable[i].start,
+			spaceRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_SPACE_CHAR ; i++) {
+		addchr(cv, spaceCharTable[i]);
+	    }
+	}
+	break;
+    case CC_LOWER:
+	cv  = getcvec(v, NUM_LOWER_CHAR, NUM_LOWER_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_LOWER_RANGE ; i++) {
+		addrange(cv, lowerRangeTable[i].start,
+			lowerRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_LOWER_CHAR ; i++) {
+		addchr(cv, lowerCharTable[i]);
+	    }
+	}
+	break;
+    case CC_UPPER:
+	cv  = getcvec(v, NUM_UPPER_CHAR, NUM_UPPER_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_UPPER_RANGE ; i++) {
+		addrange(cv, upperRangeTable[i].start,
+			upperRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_UPPER_CHAR ; i++) {
+		addchr(cv, upperCharTable[i]);
+	    }
+	}
+	break;
+    case CC_GRAPH:
+	cv  = getcvec(v, NUM_GRAPH_CHAR, NUM_GRAPH_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_GRAPH_RANGE ; i++) {
+		addrange(cv, graphRangeTable[i].start,
+			graphRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_GRAPH_CHAR ; i++) {
+		addchr(cv, graphCharTable[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 *, pchr);
+ */
+static struct cvec *
+allcases(v, pc)
+    struct vars *v;			/* context */
+    pchr pc;				/* character to get case equivs of */
+{
+    struct cvec *cv;
+    chr c = (chr)pc;
+    chr lc, uc, tc;
+
+    lc = Tcl_UniCharToLower((chr)c);
+    uc = Tcl_UniCharToUpper((chr)c);
+    tc = Tcl_UniCharToTitle((chr)c);
+
+    if (tc != uc) {
+	cv = getcvec(v, 3, 0, 0);
+	addchr(cv, tc);
+    } else {
+	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 cmp(CONST chr *, CONST chr *, size_t);
+ */
+static int				/* 0 for equal, nonzero for unequal */
+cmp(x, y, len)
+    CONST chr *x, *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 casecmp(CONST chr *, CONST chr *, size_t);
+ */
+static int				/* 0 for equal, nonzero for unequal */
+casecmp(x, y, len)
+    CONST chr *x, *y;			/* strings to compare */
+    size_t len;				/* exact length of comparison */
+{
+    for (; len > 0; len--, x++, y++) {
+	if ((*x!=*y) && (Tcl_UniCharToLower(*x) != Tcl_UniCharToLower(*y))) {
+	    return 1;
+	}
+    }
+    return 0;
+}

src/regex/regcustom.h

@@ -0,0 +1,120 @@
+/*
+ * 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.
+ */
+
+/* headers if any */
+#include "tclInt.h"
+
+/* overrides for regguts.h definitions, if any */
+#define	FUNCPTR(name, args)	(*name) _ANSI_ARGS_(args)
+#define	MALLOC(n)		ckalloc(n)
+#define	FREE(p)			ckfree(VS(p))
+#define	REALLOC(p,n)		ckrealloc(VS(p),n)
+
+
+
+/*
+ * Do not insert extras between the "begin" and "end" lines -- this
+ * chunk is automatically extracted to be fitted into regex.h.
+ */
+/* --- begin --- */
+/* ensure certain things don't sneak in from system headers */
+#ifdef __REG_WIDE_T
+#undef __REG_WIDE_T
+#endif
+#ifdef __REG_WIDE_COMPILE
+#undef __REG_WIDE_COMPILE
+#endif
+#ifdef __REG_WIDE_EXEC
+#undef __REG_WIDE_EXEC
+#endif
+#ifdef __REG_REGOFF_T
+#undef __REG_REGOFF_T
+#endif
+#ifdef __REG_VOID_T
+#undef __REG_VOID_T
+#endif
+#ifdef __REG_CONST
+#undef __REG_CONST
+#endif
+#ifdef __REG_NOFRONT
+#undef __REG_NOFRONT
+#endif
+#ifdef __REG_NOCHAR
+#undef __REG_NOCHAR
+#endif
+/* interface types */
+#define	__REG_WIDE_T	Tcl_UniChar
+#define	__REG_REGOFF_T	long	/* not really right, but good enough... */
+#define	__REG_VOID_T	VOID
+#define	__REG_CONST	CONST
+/* names and declarations */
+#define	__REG_WIDE_COMPILE	TclReComp
+#define	__REG_WIDE_EXEC		TclReExec
+#define	__REG_NOFRONT		/* don't want regcomp() and regexec() */
+#define	__REG_NOCHAR		/* or the char versions */
+#define	regfree		TclReFree
+#define	regerror	TclReError
+/* --- end --- */
+
+
+
+/* internal character type and related */
+typedef Tcl_UniChar chr;	/* the type itself */
+typedef int pchr;		/* what it promotes to */
+typedef unsigned uchr;		/* unsigned type that will hold a chr */
+typedef int celt;		/* type to hold chr, MCCE number, or NOCELT */
+#define	NOCELT	(-1)		/* celt value which is not valid chr or MCCE */
+#define	CHR(c)	(UCHAR(c))	/* turn char literal into chr literal */
+#define	DIGITVAL(c)	((c)-'0')	/* turn chr digit into its value */
+#if TCL_UTF_MAX > 3
+#define	CHRBITS	32		/* bits in a chr; must not use sizeof */
+#define	CHR_MIN	0x00000000	/* smallest and largest chr; the value */
+#define	CHR_MAX	0xffffffff	/*  CHR_MAX-CHR_MIN+1 should fit in uchr */
+#else
+#define	CHRBITS	16		/* bits in a chr; must not use sizeof */
+#define	CHR_MIN	0x0000		/* smallest and largest chr; the value */
+#define	CHR_MAX	0xffff		/*  CHR_MAX-CHR_MIN+1 should fit in uchr */
+#endif
+
+/* functions operating on chr */
+#define	iscalnum(x)	Tcl_UniCharIsAlnum(x)
+#define	iscalpha(x)	Tcl_UniCharIsAlpha(x)
+#define	iscdigit(x)	Tcl_UniCharIsDigit(x)
+#define	iscspace(x)	Tcl_UniCharIsSpace(x)
+
+/* name the external functions */
+#define	compile		TclReComp
+#define	exec		TclReExec
+
+/* enable/disable debugging code (by whether REG_DEBUG is defined or not) */
+#if 0		/* no debug unless requested by makefile */
+#define	REG_DEBUG	/* */
+#endif
+
+/* and pick up the standard header */
+#include "regex.h"

src/regex/rege_dfa.c

@@ -0,0 +1,677 @@
+/*
+ * 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.
+ *
+ */
+
+/*
+ - longest - longest-preferred matching engine
+ ^ static chr *longest(struct vars *, struct dfa *, chr *, chr *, int *);
+ */
+static chr *			/* endpoint, or NULL */
+longest(v, d, start, stop, hitstopp)
+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 *shortest(struct vars *, struct dfa *, chr *, chr *, chr *,
+ ^ 	chr **, int *);
+ */
+static chr *			/* endpoint, or NULL */
+shortest(v, d, start, min, max, coldp, hitstopp)
+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 *lastcold(struct vars *, struct dfa *);
+ */
+static chr *			/* endpoint, or NULL */
+lastcold(v, d)
+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 *, struct cnfa *,
+ ^ 	struct colormap *, struct smalldfa *);
+ */
+static struct dfa *
+newdfa(v, cnfa, cm, small)
+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 *);
+ */
+static VOID
+freedfa(d)
+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 *, int);
+ */
+static unsigned
+hash(uv, n)
+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 *, struct dfa *, chr *);
+ */
+static struct sset *
+initialize(v, d, start)
+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 *miss(struct vars *, struct dfa *, struct sset *,
+ ^ 	pcolor, chr *, chr *);
+ */
+static struct sset *		/* NULL if goes to empty set */
+miss(v, d, css, co, cp, start)
+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 lacon(struct vars *, struct cnfa *, chr *, pcolor);
+ */
+static int			/* predicate:  constraint satisfied? */
+lacon(v, pcnfa, cp, co)
+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 *, struct dfa *, chr *, chr *);
+ */
+static struct sset *
+getvacant(v, d, cp, start)
+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 *, struct dfa *, chr *, chr *);
+ */
+static struct sset *
+pickss(v, d, cp, start)
+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;
+}

src/regex/regerror.c

@@ -0,0 +1,109 @@
+/*
+ * regerror - error-code expansion
+ *
+ * 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"
+
+/* unknown-error explanation */
+static char unk[] = "*** unknown regex error code 0x%x ***";
+
+/* struct to map among codes, code names, and explanations */
+static struct rerr {
+	int code;
+	char *name;
+	char *explain;
+} rerrs[] = {
+	/* the actual table is built from regex.h */
+#	include "regerrs.h"
+	{ -1,	"",	"oops" },	/* explanation special-cased in code */
+};
+
+/*
+ - regerror - the interface to error numbers
+ */
+/* ARGSUSED */
+size_t				/* actual space needed (including NUL) */
+regerror(errcode, preg, errbuf, errbuf_size)
+int errcode;			/* error code, or REG_ATOI or REG_ITOA */
+CONST regex_t *preg;		/* associated regex_t (unused at present) */
+char *errbuf;			/* result buffer (unless errbuf_size==0) */
+size_t errbuf_size;		/* available space in errbuf, can be 0 */
+{
+	struct rerr *r;
+	char *msg;
+	char convbuf[sizeof(unk)+50];	/* 50 = plenty for int */
+	size_t len;
+	int icode;
+
+	switch (errcode) {
+	case REG_ATOI:		/* convert name to number */
+		for (r = rerrs; r->code >= 0; r++)
+			if (strcmp(r->name, errbuf) == 0)
+				break;
+		sprintf(convbuf, "%d", r->code);	/* -1 for unknown */
+		msg = convbuf;
+		break;
+	case REG_ITOA:		/* convert number to name */
+		icode = atoi(errbuf);	/* not our problem if this fails */
+		for (r = rerrs; r->code >= 0; r++)
+			if (r->code == icode)
+				break;
+		if (r->code >= 0)
+			msg = r->name;
+		else {			/* unknown; tell him the number */
+			sprintf(convbuf, "REG_%u", (unsigned)icode);
+			msg = convbuf;
+		}
+		break;
+	default:		/* a real, normal error code */
+		for (r = rerrs; r->code >= 0; r++)
+			if (r->code == errcode)
+				break;
+		if (r->code >= 0)
+			msg = r->explain;
+		else {			/* unknown; say so */
+			sprintf(convbuf, unk, errcode);
+			msg = convbuf;
+		}
+		break;
+	}
+
+	len = strlen(msg) + 1;		/* space needed, including NUL */
+	if (errbuf_size > 0) {
+		if (errbuf_size > len)
+			strcpy(errbuf, msg);
+		else {			/* truncate to fit */
+			strncpy(errbuf, msg, errbuf_size-1);
+			errbuf[errbuf_size-1] = '\0';
+		}
+	}
+
+	return len;
+}

src/regex/regerrs.h

@@ -0,0 +1,18 @@
+{ 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" },

src/regex/regex.h

@@ -0,0 +1,341 @@
+#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.
+ *
+ *
+ *
+ * Prototypes etc. marked with "^" within comments get gathered up (and
+ * possibly edited) by the regfwd program and inserted near the bottom of
+ * this file.
+ *
+ * We offer the option of declaring one wide-character version of the
+ * RE functions as well as the char versions.  To do that, define
+ * __REG_WIDE_T to the type of wide characters (unfortunately, there
+ * is no consensus that wchar_t is suitable) and __REG_WIDE_COMPILE and
+ * __REG_WIDE_EXEC to the names to be used for the compile and execute
+ * functions (suggestion:  re_Xcomp and re_Xexec, where X is a letter
+ * suggestive of the wide type, e.g. re_ucomp and re_uexec for Unicode).
+ * For cranky old compilers, it may be necessary to do something like:
+ * #define	__REG_WIDE_COMPILE(a,b,c,d)	re_Xcomp(a,b,c,d)
+ * #define	__REG_WIDE_EXEC(a,b,c,d,e,f,g)	re_Xexec(a,b,c,d,e,f,g)
+ * rather than just #defining the names as parameterless macros.
+ *
+ * For some specialized purposes, it may be desirable to suppress the
+ * declarations of the "front end" functions, regcomp() and regexec(),
+ * or of the char versions of the compile and execute functions.  To
+ * suppress the front-end functions, define __REG_NOFRONT.  To suppress
+ * the char versions, define __REG_NOCHAR.
+ *
+ * The right place to do those defines (and some others you may want, see
+ * below) would be <sys/types.h>.  If you don't have control of that file,
+ * the right place to add your own defines to this file is marked below.
+ * This is normally done automatically, by the makefile and regmkhdr, based
+ * on the contents of regcustom.h.
+ */
+
+
+
+/*
+ * voodoo for C++
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+/*
+ * Add your own defines, if needed, here.
+ */
+
+
+
+/*
+ * Location where a chunk of regcustom.h is automatically spliced into
+ * this file (working from its prototype, regproto.h).
+ */
+/* --- begin --- */
+/* ensure certain things don't sneak in from system headers */
+#ifdef __REG_WIDE_T
+#undef __REG_WIDE_T
+#endif
+#ifdef __REG_WIDE_COMPILE
+#undef __REG_WIDE_COMPILE
+#endif
+#ifdef __REG_WIDE_EXEC
+#undef __REG_WIDE_EXEC
+#endif
+#ifdef __REG_REGOFF_T
+#undef __REG_REGOFF_T
+#endif
+#ifdef __REG_VOID_T
+#undef __REG_VOID_T
+#endif
+#ifdef __REG_CONST
+#undef __REG_CONST
+#endif
+#ifdef __REG_NOFRONT
+#undef __REG_NOFRONT
+#endif
+#ifdef __REG_NOCHAR
+#undef __REG_NOCHAR
+#endif
+/* interface types */
+#define	__REG_WIDE_T	Tcl_UniChar
+#define	__REG_REGOFF_T	long	/* not really right, but good enough... */
+#define	__REG_VOID_T	VOID
+#define	__REG_CONST	CONST
+/* names and declarations */
+#define	__REG_WIDE_COMPILE	TclReComp
+#define	__REG_WIDE_EXEC		TclReExec
+#define	__REG_NOFRONT		/* don't want regcomp() and regexec() */
+#define	__REG_NOCHAR		/* or the char versions */
+#define	regfree		TclReFree
+#define	regerror	TclReError
+/* --- end --- */
+
+
+/*
+ * 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, so we
+ * offer <sys/types.h> an override.
+ */
+#ifdef __REG_REGOFF_T
+typedef __REG_REGOFF_T regoff_t;
+#else
+typedef long regoff_t;
+#endif
+
+/*
+ * For benefit of old compilers, we offer <sys/types.h> the option of
+ * overriding the `void' type used to declare nonexistent return types.
+ */
+#ifdef __REG_VOID_T
+typedef __REG_VOID_T re_void;
+#else
+typedef void re_void;
+#endif
+
+/*
+ * Also for benefit of old compilers, <sys/types.h> can supply a macro
+ * which expands to a substitute for `const'.
+ */
+#ifndef __REG_CONST
+#define	__REG_CONST	const
+#endif
+
+
+
+/*
+ * other interface types
+ */
+
+/* the biggie, a compiled RE (or rather, a front end to same) */
+typedef struct {
+	int re_magic;		/* magic number */
+	size_t re_nsub;		/* number of subexpressions */
+	long re_info;		/* information about RE */
+#		define	REG_UBACKREF		000001
+#		define	REG_ULOOKAHEAD		000002
+#		define	REG_UBOUNDS		000004
+#		define	REG_UBRACES		000010
+#		define	REG_UBSALNUM		000020
+#		define	REG_UPBOTCH		000040
+#		define	REG_UBBS		000100
+#		define	REG_UNONPOSIX		000200
+#		define	REG_UUNSPEC		000400
+#		define	REG_UUNPORT		001000
+#		define	REG_ULOCALE		002000
+#		define	REG_UEMPTYMATCH		004000
+#		define	REG_UIMPOSSIBLE		010000
+#		define	REG_USHORTEST		020000
+	int re_csize;		/* sizeof(character) */
+	char *re_endp;		/* backward compatibility kludge */
+	/* the rest is opaque pointers to hidden innards */
+	char *re_guts;		/* `char *' is more portable than `void *' */
+	char *re_fns;
+} regex_t;
+
+/* result reporting (may acquire more fields later) */
+typedef struct {
+	regoff_t rm_so;		/* start of substring */
+	regoff_t rm_eo;		/* end of substring */
+} regmatch_t;
+
+/* supplementary control and reporting */
+typedef struct {
+	regmatch_t rm_extend;	/* see REG_EXPECT */
+} rm_detail_t;
+
+
+
+/*
+ * compilation
+ ^ #ifndef __REG_NOCHAR
+ ^ int re_comp(regex_t *, __REG_CONST char *, size_t, int);
+ ^ #endif
+ ^ #ifndef __REG_NOFRONT
+ ^ int regcomp(regex_t *, __REG_CONST char *, int);
+ ^ #endif
+ ^ #ifdef __REG_WIDE_T
+ ^ int __REG_WIDE_COMPILE(regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int);
+ ^ #endif
+ */
+#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 :-) */
+
+
+
+/*
+ * execution
+ ^ #ifndef __REG_NOCHAR
+ ^ int re_exec(regex_t *, __REG_CONST char *, size_t,
+ ^				rm_detail_t *, size_t, regmatch_t [], int);
+ ^ #endif
+ ^ #ifndef __REG_NOFRONT
+ ^ int regexec(regex_t *, __REG_CONST char *, size_t, regmatch_t [], int);
+ ^ #endif
+ ^ #ifdef __REG_WIDE_T
+ ^ int __REG_WIDE_EXEC(regex_t *, __REG_CONST __REG_WIDE_T *, size_t,
+ ^				rm_detail_t *, size_t, regmatch_t [], int);
+ ^ #endif
+ */
+#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 */
+
+
+
+/*
+ * misc generics (may be more functions here eventually)
+ ^ re_void regfree(regex_t *);
+ */
+
+
+
+/*
+ * error reporting
+ * Be careful if modifying the list of error codes -- the table used by
+ * regerror() is generated automatically from this file!
+ *
+ * Note that there is no wide-char variant of regerror at this time; what
+ * kind of character is used for error reports is independent of what kind
+ * is used in matching.
+ *
+ ^ extern size_t regerror(int, __REG_CONST regex_t *, char *, size_t);
+ */
+#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, as possibly munched by regfwd
+ */
+/* =====^!^===== begin forwards =====^!^===== */
+/* automatically gathered by fwd; do not hand-edit */
+/* === regproto.h === */
+#ifndef __REG_NOCHAR
+int re_comp _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, int));
+#endif
+#ifndef __REG_NOFRONT
+int regcomp _ANSI_ARGS_((regex_t *, __REG_CONST char *, int));
+#endif
+#ifdef __REG_WIDE_T
+int __REG_WIDE_COMPILE _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int));
+#endif
+#ifndef __REG_NOCHAR
+int re_exec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
+#endif
+#ifndef __REG_NOFRONT
+int regexec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, regmatch_t [], int));
+#endif
+#ifdef __REG_WIDE_T
+int __REG_WIDE_EXEC _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
+#endif
+re_void regfree _ANSI_ARGS_((regex_t *));
+extern size_t regerror _ANSI_ARGS_((int, __REG_CONST regex_t *, char *, size_t));
+/* automatically gathered by fwd; do not hand-edit */
+/* =====^!^===== end forwards =====^!^===== */
+
+
+
+/*
+ * more C++ voodoo
+ */
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif

src/regex/regfree.c

@@ -0,0 +1,53 @@
+/*
+ * regfree - free an RE
+ *
+ * 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.
+ *
+ *
+ *
+ * You might think that this could be incorporated into regcomp.c, and
+ * that would be a reasonable idea... except that this is a generic
+ * function (with a generic name), applicable to all compiled REs
+ * regardless of the size of their characters, whereas the stuff in
+ * regcomp.c gets compiled once per character size.
+ */
+
+#include "regguts.h"
+
+/*
+ - regfree - free an RE (generic function, punts to RE-specific function)
+ *
+ * Ignoring invocation with NULL is a convenience.
+ */
+VOID
+regfree(re)
+regex_t *re;
+{
+	if (re == NULL)
+		return;
+	(*((struct fns *)re->re_fns)->free)(re);
+}

src/regex/regfronts.c

@@ -0,0 +1,83 @@
+/*
+ * 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);
+}

src/regex/regguts.h

@@ -0,0 +1,418 @@
+/*
+ * 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.
+ */
+
+
+
+/*
+ * 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.
+ */
+
+/* standard header files (NULL is a reasonable indicator for them) */
+#ifndef NULL
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <limits.h>
+#include <string.h>
+#endif
+
+/* assertions */
+#ifndef assert
+#	ifndef REG_DEBUG
+#	define	NDEBUG		/* no assertions */
+#	endif
+#include <assert.h>
+#endif
+
+/* voids */
+#ifndef VOID
+#define	VOID	void			/* for function return values */
+#endif
+#ifndef DISCARD
+#define	DISCARD	VOID			/* for throwing values away */
+#endif
+#ifndef PVOID
+#define	PVOID	VOID *			/* generic pointer */
+#endif
+#ifndef VS
+#define	VS(x)	((PVOID)(x))		/* cast something to generic ptr */
+#endif
+#ifndef NOPARMS
+#define	NOPARMS	VOID			/* for empty parm lists */
+#endif
+
+/* const */
+#ifndef CONST
+#define	CONST	const			/* for old compilers, might be empty */
+#endif
+
+/* function-pointer declarator */
+#ifndef FUNCPTR
+#if __STDC__ >= 1
+#define	FUNCPTR(name, args)	(*name)args
+#else
+#define	FUNCPTR(name, args)	(*name)()
+#endif
+#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 */
+};

src/regex/tclUniData.c

@@ -0,0 +1,904 @@
+/*
+ * 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))]])
+

wxPython/wx/py/CHANGES.txt

@@ -1,617 +0,0 @@
-0.9.4 (1/25/2004 to //2004)
-------------------------------
-
-Removed wxd decorators in favor of new SWIG-generated docstrings.
-
-Removed docs tabs from crust interface:
-* wxPython Docs
-* wxSTC Docs
-
-Fixed Calltip tab refresh problem on Windows.
-
-shell.autoCompleteAutoHide added with default of False.
-
-Changed default namespace of Shell to __main__.__dict__, instead of an
-empty dictionary.
-
-
-0.9.3 (9/25/2003 to 1/24/2004)
-------------------------------
-
-Fun and games with dynamic renaming.  Details of any other changes
-were lost in the confusion.  I'll try to do better in the future.
-
-
-0.9.2 (5/3/2003 to 9/25/2003)
------------------------------
-
-Changed to the new prefix-less "wx" package::
-
-    import wx
-
-instead of::
-
-    from wxPython import wx
-
-Fixed typo in ``PyWrap.py``::
-
-    if __name__ == '__main__':
-        main(sys.argv)
-
-should have been::
-
-    if __name__ == '__main__':
-        main()
-
-Added pretty-print Display tab to Crust, based on suggestion from
-Jason Whitlark.
-
-Improved ``Can*`` checks in ``EditWindow``, since STC is too lenient,
-particularly when it is set to read-only but returns True for
-CanPaste() (seems like an STC bug to me)::
-
-    def CanCopy(self):
-        """Return True if text is selected and can be copied."""
-        return self.GetSelectionStart() != self.GetSelectionEnd()
-
-    def CanCut(self):
-        """Return True if text is selected and can be cut."""
-        return self.CanCopy() and self.CanEdit()
-
-    def CanEdit(self):
-        """Return True if editing should succeed."""
-        return not self.GetReadOnly()
-
-    def CanPaste(self):
-        """Return True if pasting should succeed."""
-        return stc.StyledTextCtrl.CanPaste(self) and self.CanEdit()
-
-
-0.9.1 (3/21/2003 to 5/2/2003)
------------------------------
-
-PyCrust is dead!  Long live Py!
-
-* Renamed ``PyCrust`` package to ``py``.
-* Moved code to wxPython's CVS repository.
-
-Fixed bug in ``introspect.py`` on introspecting objects occurring
-immediately after a secondary prompt, like this::
-
-    >>> l = [1, 2, 3]
-    >>> for n in range(3):
-    ...     l.  <-- failed to popup autocomplete list
-
-Added documentation files:
-
-* PyManual.txt
-* wxPythonManual.txt
-* wxPythonPackage.txt
-* wxPythonExamples.txt
-
-Added PyAlaMode and PyAlaCarte code editors.
-
-Major refactoring to support ``editor`` and ``shell`` from the same
-base.
-
-Renamed program files:
-
-* ``PyCrustApp.py`` to ``PyCrust.py``
-* ``PyFillingApp.py`` to ``PyFilling.py``
-* ``PyShellApp.py`` to ``PyShell.py``
-* ``wrap.py`` to ``PyWrap.py``
-
-Removed disabling of autocomplete for lists of 2000 items or more.
-The current implementation of wxSTC can now handle lists this big.
-
-Improved handling of ``sys.path`` to mimic the standard Python shell.
-
-
-0.9 (2/27/2003 to 3/20/2003)
-----------------------------
-
-Added fontIncrease, fontDecrease, fontDefault signals, receivers and
-keybindings::
-
-    Ctrl+]            Increase font size.
-    Ctrl+[            Decrease font size.
-    Ctrl+=            Default font size.
-
-Continued enhancement of the decorator capability to provide better
-documentation and docstrings for wxPython classes and functions.
-
-Introduced new tabbed interface:
-
-* Namespace
-* Calltip
-* Session
-* Dispatcher
-* wxPython Docs
-* wxSTC Docs
-
-``Filling.tree`` now expands tuples as well as lists.  (It should have
-done this all along, I just never noticed this omission before.)
-
-Added this True/False test to all modules::
-
-    try:
-        True
-    except NameError:
-        True = 1==1
-        False = 1==0
-
-Added ``wxd`` directory with decoration classes.
-
-
-0.8.2 (1/5/2003 to 2/26/2003)
------------------------------
-
-Wrapped ``sys.ps1``, ``sys.ps2``, and ``sys.ps3`` in ``str()``.
-(Thanks, Kieran Holland.)
-
-Fixed minor things found by PyChecker.
-
-Changed locals to use ``__main__.__dict__`` and added code to clean up
-the namespace, making it as close to the regular Python environment as
-possible.  This solves the problem of pickling and unpickling
-instances of classes defined in the shell.
-
-Made ``shell.PasteAndRun()`` a little more forgiving when it finds a
-ps2 prompt line with no trailing space, such when you copy code from a
-web page.
-
-Improved autocomplete behavior by adding these to shell::
-
-    self.AutoCompSetAutoHide(False)
-    self.AutoCompStops(' .,;:([)]}\'"\\<>%^&+-=*/|`')
-
-Added ``decor`` directory, ``decorator.py``, ``stcDecor.py``, and
-``stcConstants.py``.  These all serve the purpose of adding docstrings
-to existing wxPython classes, in particular the ``wxStyledTextCtrl``.
-
-Added ``wrap.py``, a command line utility for running a wxPython app
-with additional runtime-tools loaded, such as PyCrust (the only tool
-at this point).
-
-Flushed the clipboard Cut/Copy operations so that selections will
-exist in the clipboard even after PyCrust has been closed.
-
-Improved the suppression of docstrings for simple data types appearing
-in the namespace viewer.
-
-Better handling of autocompletion with numeric types; no
-autocompletion when typing a dot after an integer.  If the
-autocompletion is desired, type a space before the dot::
-
-    func = 3 .
-
-More Filling!!! The namespace tree is now dynamically updated.
-
-
-0.8.1 (12/20/2002 to 12/25/2002)
---------------------------------
-
-Improved keyboard handling with Autocomplete active.  You can now use
-Enter as well as Tab to select an item from the list.
-
-Disabled autocomplete for lists of 2000 items or more.  The current
-implementation of wxSTC can't handle lists this big.
-
-Changed ``filling`` to always display docstrings for objects.  This is
-useful for objects whose docstrings have been decorated, rather than
-coming directly from the source code.  (Hmmm.  Sounds like someone is
-doing some decorating.  I wonder where that would be helpful? <wink>)
-
-Fixed handling of icon.  Added ``images.py`` file.
-
-
-0.8 (10/29/2002 to 12/16/2002)
-------------------------------
-
-Added "help" to startup banner info.
-
-Made all ``wx`` and ``stc`` imports explicit.  No more ``import *``.
-
-Replaced use of the ``wx`` module's ``true`` and ``false`` with
-Python's ``True`` and ``False``.
-
-Changed ``introspect.getRoot()`` to use ``tokenize`` module.  This
-does a slightly better job than the previous parsing routine and the
-code is clearer.
-
-Improved handling of whitespace and empty types during introspection.
-
-Fixed cut/copy clipboard problem under Linux.  (Robin Dunn rocks!!!)
-
-Added shell.about() which works like this::
-
-    >>> shell.about()
-    PyCrust Version: 0.8
-    Shell Revision: 1.80
-    Interpreter Revision: 1.15
-    Python Version: 2.2.2
-    wxPython Version: 2.3.3.1
-    Platform: linux2
-
-Added copy plus and paste plus to shell menu.
-
-Moved shell menu from ``shell.py`` to ``shellmenu.py``.
-
-Added ``sys.stdin.readlines()`` support.
-
-Added ``time.sleep()`` in ``readline()`` and ``OnIdle()`` event
-handler to free up the CPU.
-
-
-0.7.2 (2/22/2002 to 8/27/2002)
-------------------------------
-
-Tweaked ``getAttributeNames()`` to pick up a few more attributes::
-
-    '__bases__', '__class__', '__dict__', '__name__', 'func_closure',
-    'func_code', 'func_defaults', 'func_dict', 'func_doc',
-    'func_globals', 'func_name'
-
-Added a tests directory and unit tests.
-
-Improved support for empty types in the shell: ``[]``, ``()`` and
-``{}`` as far as when call tips and autocompletion are available.
-
-Added support for the other triple string - ``''''''``.
-
-Refactored ``introspect.py`` to improve testability.
-
-Improved call tips for unbound methods by leaving the "self"
-parameter, since unbound methods require an instance be passed.
-
-Fixed call tip bug where a tip was displayed when a "(" was typed
-after an object that wasn't callable.
-
-Fixed ``getAllAttributeNames`` when ``str(object)`` fails.
-
-Added brace highlighting.  (Thank you, Kevin Altis.)
-
-Fixed problem displaying unicode objects in ``PyFilling``.
-
-Changed how ``filling.py`` checks for expandable objects.  Lists are
-now expandable objects.
-
-Made the key handling more robust when there is an active text
-selection that includes text prior to the last primary prompt.  Thanks
-to Raul Cota for pointing this out.
-
-Fixed wxSTC problem with brace highlighting and non-us keyboards.
-(Thank you for the patch, Jean-Michel Fauth.)
-
-Added ``busy = wxBusyCursor()`` to key points in ``shell`` and
-``filling``.
-
-Added ``OnCloseWindow`` handler to ``ShellFrame`` and ``CrustFrame``.
-
-Default to ``SetWrapMode(1)`` for shell and namespace viewer.
-
-Added ``shell.wrap()`` and ``shell.zoom()``.
-
-Added autoCompleteKeys hooks for Raul Cota.
-
-Cleaned up various little key handling bugs.
-
-Changed input methods to get values from shell, rather than dialog
-boxes.  Renamed ``readIn`` to ``readline`` and ``readRaw`` to
-``raw_input``.
-
-
-0.7.1 (12/12/2001 to 2/21/2002)
--------------------------------
-
-Fixed ``OnChar()`` issues effecting European keyboards, as reported by
-Jean-Michel Fauth.
-
-Fixed ``introspect.py`` issue with xmlrpc objects reported by Kevin
-Altis.
-
-Fixed some introspect/PyFilling issues with regard to Python 2.2.
-
-Fixed font background color as reported by Keith J. Farmer.  (Thanks)
-
-Fixed problem with call tips and autocompletion inside multiline
-commands as report by Kevin Altis.
-
-Improved ``OnKeyDown`` handling of cut/copy/paste operations based on
-feedback from Syver Enstad.  (Thanks)
-
-Added a ``shell.help()`` method to display some help info.
-
-Changed sort of items in the namespace viewer to case insensitive.
-
-Changed ``attributes.sort(lambda x, y: cmp(x.upper(), y.upper()))`` in
-advance of an upcoming fix to an autocompletion matching bug in wxSTC.
-
-Improved support for ZODB by allowing namespace drilldown into BTrees.
-
-Added ``shell.PasteAndRun()`` to support pasting multiple commands into
-the shell from the clipboard.  Ctrl+Shift+V or v.
-
-Enter now always processes a command (or copies down a previous one.)
-To insert a line break, press Ctrl+Enter.
-
-Escape key clears the current, unexecuted command.
-
-History retrieval changed to replace current command.  Added new keys
-to insert from history - Shift+Up and Shift+Down.
-
-Better call tips on objects with ``__call__`` methods.
-
-Improved call tip positioning calculation.
-
-
-0.7 (10/15/2001 to 12/11/2001)
-------------------------------
-
-Changed how command history retrieval functions work.  Added Alt-P,
-Alt-N as keybindings for Retrieve-Previous, Retrieve-Next.
-
-Added full support for multi-line commands, similar to IDLE.
-
-Changed ``introspect.getAttributeNames()`` to do a case insensitive
-sort.
-
-Changed Cut/Copy/Paste to deal with prompts intelligently.  Cut and
-Copy remove all prompts.  Paste can handle prompted or not-prompted
-text.
-
-Added ``CopyWithPrompts()`` method attached to Ctrl-Shift-C for those
-times when you really do want all the prompts left intact.
-
-Improved handling of the shell's read-only zone.
-
-Changed ``CrustFrame.__init__`` parameter spec to include all
-parameters allowed by a ``wxFrame``.
-
-Changed ``FillingText`` to be read-only.
-
-Renamed ``PyCrust.py`` to ``PyCrustApp.py`` to eliminate
-package/module name conflicts that kept you from doing ``from PyCrust
-import shell`` inside files located in the ``PyCrust`` directory.
-
-Renamed ``PyFilling.py`` to ``PyFillingApp.py`` and ``PyShell.py`` to
-``PyShellApp.py`` to maintain consistency.
-
-Removed the ``__date__`` property from all modules.
-
-Fixed bug in ``introspect.getCallTip()``, reported by Kevin Altis.
-
-
-0.6.1 (9/19/2001 to 10/12/2001)
--------------------------------
-
-Changed ``Shell.run()`` to always position to the end of existing
-text, as suggested by Raul Cota.
-
-Changed ``introspect.getAllAttributeNames()`` to break circular
-references in ``object.__class__``, which occurs in Zope/ZODB
-extension classes.
-
-Changed ``filling.FillingTree.getChildren()`` to introspect extension
-classes.
-
-Fixed minor bugs in ``introspect.getCallTip()`` that were interfering
-with call tips for Zope/ZODB extension class methods.
-
-In preparation for wxPython 2.3.2, added code to fix a font sizing
-problem.  Versions of wxPython prior to 2.3.2 had a sizing bug on Win
-platform where the font was 2 points larger than what was specified.
-
-Added a hack to ``introspect.getAllAttributeNames()`` to "wake up"
-ZODB objects that are asleep - in a "ghost" state.  Otherwise it
-returns incomplete info.
-
-
-0.6 (8/21/2001 to 9/12/2001)
-----------------------------
-
-Added ``PyFilling.py`` and ``filling.py``.
-
-``PyShell.py`` and ``PyFilling.py`` can now be run standalone, as well
-as ``PyCrust.py``.
-
-Added ``crust.py`` and moved some code from ``PyCrust.py`` to it.
-
-Added command history retrieval features submitted by Richie Hindle.
-
-Changed ``shell.write()`` to replace line endings with OS-specific
-endings.  Changed ``shell.py`` and ``interpreter.py`` to use
-``os.linesep`` in strings having hardcoded line endings.
-
-Added ``shell.redirectStdin()``, ``shell.redirectStdout()`` and
-``shell.redirectStderr()`` to allow the surrounding app to toggle
-requests that the specified ``sys.std*`` be redirected to the shell.
-These can also be run from within the shell itself, of course.
-
-The shell now adds the current working directory "." to the search
-path::
-
-    sys.path.insert(0, os.curdir)
-
-Added support for distutils installations.
-
-
-0.5.4 (8/17/2001 to 8/20/2001)
-------------------------------
-
-Changed default font size under Linux to::
-
-    'size'   : 12,
-    'lnsize' : 10,
-
-Changed ``Shell`` to expect a parameter referencing an Interpreter
-class, rather than an intepreter instance, to facilitate subclassing
-of Interpreter, which effectively broke when the Editor class was
-eliminated.
-
-Fixed ``PyCrustAlaCarte.py``, which had been broken by previous
-changes.
-
-Created ``InterpreterAlaCarte`` class as an example for use in the
-demo.
-
-Split ``PyCrust.py`` into ``PyCrust.py`` and ``PyShell.py`` in
-anticipation of ``PyFilling.py``.
-
-
-0.5.3 (8/16/2001)
------------------
-
-Added patch to ``PyCrust.py`` to fix wxPython bug::
-
-    wxID_SELECTALL = NewId() # This *should* be defined by wxPython.
-
-
-0.5.2 (8/14/2001 to 8/15/2001)
-------------------------------
-
-Shortened module names by dropping "PyCrust" as a prefix.
-
-Changed ``version`` to ``VERSION`` in ``version`` module.
-
-Added Options menu to PyCrust application.
-
-Eliminated the Editor class (and editor module) by merging with Shell.
-This means that Shell "is a" wxStyledTextCtrl rather than "has a".
-There just wasn't enough non-gui code to justify the separation.
-Plus, Shell will be much easier for gui toolkits/designers to deal
-with now.
-
-
-0.5.1 (8/10/2001 to 8/14/2001)
-------------------------------
-
-Added ``introspect`` module.
-
-Moved some functionality from ``PyCrustInterp`` to ``introspect``.
-
-Changed ``introspect.getRoot()`` to no longer remove whitespace from
-the command.  This was a remnant of a previous approach that, when
-left as part of the current approach, turned out to be a really bad
-thing.
-
-Changed ``introspect.getRoot()`` to allow commands of ``''``, ``""``,
-``""""""``, ``[]``, ``()``, and ``{}`` to pass through.  This allows
-you to type them, followed by a dot, and get autocomplete options on
-them.
-
-Changed ``introspect.getRoot()`` to identify some situations where
-strings shouldn't be considered roots.  For example::
-
-    >>> import PyCrust  # To illustrate the potential problem.
-    >>> len('PyCrust.py')
-
-Typing the dot at the end of "PyCrust" in the second line above should
-NOT result in an autocompletion list because "PyCrust" is part of a
-string in this context, not a reference to the PyCrust module object.
-Similar reasoning applies to call tips.  For example::
-
-    >>> len('dir(')
-
-Typing the left paren at the end of "dir" should NOT result in a call
-tip.
-
-Both features now behave properly in the examples given.  However,
-there is still the case where whitespace precedes the potential root
-and that is NOT handled properly.  For example::
-
-    >>> len('this is a dir(')
-
-and::
-
-    >>> len('This is PyCrust.py')
-
-More code needs to be written to handle more complex situations.
-
-Added ``locals=None`` parameter to ``Shell.__init__()``.
-
-Added support for magic attribute retrieval.  Users can change this
-with::
-
-    >>> shell.editor.autoCompleteIncludeMagic = 0
-
-Added the ability to set filters on auto completion to exclude
-attributes prefixed with a single or double underscore.  Users can
-exclude one or the other or both with::
-
-    >>> shell.editor.autoCompleteExcludeSingle = 1
-    >>> shell.editor.autoCompleteExcludeDouble = 1
-
-
-0.5 (8/8/2001)
---------------
-
-Mostly just a final version change before creating a release.
-
-
-0.4 (8/4/2001 to 8/7/2001)
---------------------------
-
-Changed version/revision handling.
-
-Fixed bugs.
-
-
-0.3 (8/2/2001 to 8/3/2001)
---------------------------
-
-Removed lots of cruft.
-
-Added lots of docstrings.
-
-Imported to CVS repository at SourceForge.
-
-Added call tips.
-
-
-0.2 (7/30/2001 to 8/2/2001)
----------------------------
-
-Renamed several files.
-
-Added command autocompletion.
-
-Added menus to PyCrust.py: File, Edit and Help.
-
-Added sample applications: ``PyCrustAlaCarte.py``,
-``PyCrustAlaMode.py``, and ``PyCrustMinimus.py``.
-
-
-0.1 (7/1/2001 to 7/19/2001)
----------------------------
-
-Added basic syntax coloring much like Boa.
-
-Added read-only logging much like IDLE.
-
-Can retrieve a previous command by putting the cursor back on that
-line and hitting enter.
-
-Stdin and raw_input operate properly so you can now do ``help()`` and
-``license()`` without hanging.
-
-Redefined "quit", "exit", and "close" to display a better-than-nothing
-response.
-
-Home key honors the prompt.
-
-Created SourceForge account, but nothing was posted.
-
-
-In the beginning, there was pie... (7/1/2001)
----------------------------------------------
-
-Blame it all on IDLE, Boa and PythonWin.  I was using all three, got
-frustrated with their dissimilarities, and began to let everyone know
-how I felt.  At the same time, Scintilla looked like an interesting
-tool to build a shell around.  And while I didn't receive much in the
-way of positive feedback, let alone encouragement, I just couldn't let
-go of the idea of a Scintilla-based Python shell.  Then the PythonCard
-project got to the point where they were talking about including a
-shell in their development environment.  That was all the incentive I
-needed.  PyCrust had to happen...

wxPython/wx/py/PyAlaCarte.py

@@ -1,36 +0,0 @@
-"""PyAlaCarte is a simple programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from wx import py
-
-import os
-import sys
-
-class App(wx.App):
-    """PyAlaCarte standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.App.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.frame = py.editor.EditorFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    if not filename and len(sys.argv) > 1:
-        filename = sys.argv[1]
-    if filename:
-        filename = os.path.realpath(filename)
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wx/py/PyAlaMode.py

@@ -1,36 +0,0 @@
-"""PyAlaMode is a programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from wx import py
-
-import os
-import sys
-
-class App(wx.App):
-    """PyAlaMode standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.App.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.frame = py.editor.EditorNotebookFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    if not filename and len(sys.argv) > 1:
-        filename = sys.argv[1]
-    if filename:
-        filename = os.path.realpath(filename)
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wx/py/PyAlaModeTest.py

@@ -1,35 +0,0 @@
-"""PyAlaModeTest is a programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from wx import py
-
-import os
-import sys
-
-class App(wx.App):
-    """PyAlaModeTest standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.App.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.frame = py.editor.EditorShellNotebookFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    filename = None
-    if len(sys.argv) > 1:
-        filename = os.path.realpath(sys.argv[1])
-    main(filename)

wxPython/wx/py/PyCrust.py

@@ -1,70 +0,0 @@
-"""PyCrust is a python shell and namespace browser application."""
-
-# The next two lines, and the other code below that makes use of
-# ``__main__`` and ``original``, serve the purpose of cleaning up the
-# main namespace to look as much as possible like the regular Python
-# shell environment.
-import __main__
-original = __main__.__dict__.keys()
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-class App(wx.App):
-    """PyCrust standalone application."""
-
-    def OnInit(self):
-        import wx
-        from wx import py
-        wx.InitAllImageHandlers()
-        self.frame = py.crust.CrustFrame()
-        self.frame.SetSize((800, 600))
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-'''
-The main() function needs to handle being imported, such as with the
-pycrust script that wxPython installs:
-
-    #!/usr/bin/env python
-
-    from wx.py.PyCrust import main
-    main()
-'''
-
-def main():
-    """The main function for the PyCrust program."""
-    # Cleanup the main namespace, leaving the App class.
-    import __main__
-    md = __main__.__dict__
-    keepers = original
-    keepers.append('App')
-    for key in md.keys():
-        if key not in keepers:
-            del md[key]
-    # Create an application instance.
-    app = App(0)
-    # Mimic the contents of the standard Python shell's sys.path.
-    import sys
-    if sys.path[0]:
-        sys.path[0] = ''
-    # Add the application object to the sys module's namespace.
-    # This allows a shell user to do:
-    # >>> import sys
-    # >>> sys.app.whatever
-    sys.app = app
-    del sys
-    # Cleanup the main namespace some more.
-    if md.has_key('App') and md['App'] is App:
-        del md['App']
-    if md.has_key('__main__') and md['__main__'] is __main__:
-        del md['__main__']
-    # Start the wxPython event loop.
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wx/py/PyFilling.py

@@ -1,35 +0,0 @@
-"""PyFilling is a python namespace inspection application."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-# We use this object to get more introspection when run standalone.
-app = None
-
-import filling
-
-# These are imported just to have something interesting to inspect.
-import crust
-import interpreter
-import introspect
-import pseudo
-import shell
-import sys
-import wx
-
-class App(filling.App):
-    def OnInit(self):
-        filling.App.OnInit(self)
-        self.root = self.fillingFrame.filling.tree.root
-        return True
-
-def main():
-    """Create and run the application."""
-    global app
-    app = App(0)
-    app.fillingFrame.filling.tree.Expand(app.root)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wx/py/PyShell.py

@@ -1,71 +0,0 @@
-"""PyShell is a python shell application."""
-
-# The next two lines, and the other code below that makes use of
-# ``__main__`` and ``original``, serve the purpose of cleaning up the
-# main namespace to look as much as possible like the regular Python
-# shell environment.
-import __main__
-original = __main__.__dict__.keys()
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-class App(wx.App):
-    """PyShell standalone application."""
-
-    def OnInit(self):
-        import wx
-        from wx import py
-        wx.InitAllImageHandlers()
-        self.frame = py.shell.ShellFrame()
-        self.frame.SetSize((750, 525))
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        self.frame.shell.SetFocus()
-        return True
-
-'''
-The main() function needs to handle being imported, such as with the
-pyshell script that wxPython installs:
-
-    #!/usr/bin/env python
-
-    from wx.py.PyShell import main
-    main()
-'''
-
-def main():
-    """The main function for the PyShell program."""
-    # Cleanup the main namespace, leaving the App class.
-    import __main__
-    md = __main__.__dict__
-    keepers = original
-    keepers.append('App')
-    for key in md.keys():
-        if key not in keepers:
-            del md[key]
-    # Create an application instance.
-    app = App(0)
-    # Cleanup the main namespace some more.
-    if md.has_key('App') and md['App'] is App:
-        del md['App']
-    if md.has_key('__main__') and md['__main__'] is __main__:
-        del md['__main__']
-    # Mimic the contents of the standard Python shell's sys.path.
-    import sys
-    if sys.path[0]:
-        sys.path[0] = ''
-    # Add the application object to the sys module's namespace.
-    # This allows a shell user to do:
-    # >>> import sys
-    # >>> sys.app.whatever
-    sys.app = app
-    del sys
-    # Start the wxPython event loop.
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wx/py/PyWrap.py

@@ -1,48 +0,0 @@
-"""PyWrap is a command line utility that runs a wxPython program with
-additional runtime-tools, such as PyCrust."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from wx import py
-
-import os
-import sys
-
-def wrap(app):
-    wx.InitAllImageHandlers()
-    frame = py.crust.CrustFrame()
-    frame.SetSize((750, 525))
-    frame.Show(True)
-    frame.shell.interp.locals['app'] = app
-    app.MainLoop()
-
-def main(modulename=None):
-    sys.path.insert(0, os.curdir)
-    if not modulename:
-        if len(sys.argv) < 2:
-            print "Please specify a module name."
-            raise SystemExit
-        modulename = sys.argv[1]
-        if modulename.endswith('.py'):
-            modulename = modulename[:-3]
-    module = __import__(modulename)
-    # Find the App class.
-    App = None
-    d = module.__dict__
-    for item in d.keys():
-        try:
-            if issubclass(d[item], wx.App):
-                App = d[item]
-        except (NameError, TypeError):
-            pass
-    if App is None:
-        print "No App class was found."
-        raise SystemExit
-    app = App()
-    wrap(app)
-
-if __name__ == '__main__':
-    main()

wxPython/wx/py/README.txt

@@ -1,83 +0,0 @@
-=====================================
- PyCrust - The Flakiest Python Shell
-=====================================
-
-Half-baked by Patrick K. O'Brien (pobrien@orbtech.com)
-
-Orbtech - "Your source for Python programming expertise."
-Sample all our half-baked Python goods at www.orbtech.com.
-
-
-What is PyCrust?
-----------------
-
-PyCrust is an interactive Python environment written in Python.
-PyCrust components can run standalone or be integrated into other
-development environments and/or other Python applications.
-
-PyCrust comes with an interactive Python shell (PyShell), an
-interactive namespace/object tree control (PyFilling) and an
-integrated, split-window combination of the two (PyCrust).
-
-
-What is PyCrust good for?
--------------------------
-
-Have you ever tried to bake a pie without one? Well, you shouldn't
-build a Python program without a PyCrust either.
-
-
-What else do I need to use PyCrust?
------------------------------------
-
-PyCrust requires Python 2.2 or later, and wxPython 2.4 or later.
-PyCrust uses wxPython and the Scintilla wrapper (wxStyledTextCtrl).
-Python is available at http://www.python.org/.  wxPython is available
-at http://www.wxpython.org/.
-
-
-Where can I get the latest version of PyCrust?
-----------------------------------------------
-
-The latest production version ships with wxPython.  The latest
-developer version is available in the wxWindows CVS at:
-http://cvs.wxwindows.org/viewcvs.cgi/
-
-
-Where is the PyCrust project hosted?
-------------------------------------
-
-The old answer was "At SourceForge, of course." The SourceForge
-summary page is still available at:
-http://sourceforge.net/projects/pycrust/
-
-The new answer is that there is no longer a need for a separate
-project.  Simply install wxPython and you'll have everything you need.
-
-
-I found a bug in PyCrust, what do I do with it?
------------------------------------------------
-
-You can send it to me at pobrien@orbtech.com.
-
-
-I want a new feature added to PyCrust. Will you do it?
-------------------------------------------------------
-
-Flattery and money will get you anything. Short of that, you can send
-me a request and I'll see what I can do.
-
-
-Does PyCrust have a mailing list full of wonderful people?
-----------------------------------------------------------
-
-As a matter of fact, we do. Join the PyCrust mailing lists at:
-http://sourceforge.net/mail/?group_id=31263
-
-
-What is the CVS information for this README file?
--------------------------------------------------
-
-$Date$
-$Revision$
-$Id$

wxPython/wx/py/__init__.py

@@ -1,20 +0,0 @@
-"""The py package, formerly the PyCrust package."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import buffer
-import crust
-import dispatcher
-import document
-import editor
-import editwindow
-import filling
-import frame
-import images
-import interpreter
-import introspect
-import pseudo
-import shell
-import version

wxPython/wx/py/buffer.py

@@ -1,138 +0,0 @@
-"""Buffer class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from interpreter import Interpreter
-import imp
-import os
-import sys
-
-import document
-
-
-class Buffer:
-    """Buffer class."""
-
-    id = 0
-
-    def __init__(self, filename=None):
-        """Create a Buffer instance."""
-        Buffer.id += 1
-        self.id = Buffer.id
-        self.interp = Interpreter(locals={})
-        self.name = ''
-        self.editors = {}
-        self.editor = None
-        self.modules = sys.modules.keys()
-        self.syspath = sys.path[:]
-        while True:
-            try:
-                self.syspath.remove('')
-            except ValueError:
-                break
-        while True:
-            try:
-                self.syspath.remove('.')
-            except ValueError:
-                break
-        self.open(filename)
-
-    def addEditor(self, editor):
-        """Add an editor."""
-        self.editor = editor
-        self.editors[editor.id] = editor
-
-    def hasChanged(self):
-        """Return True if text in editor has changed since last save."""
-        if self.editor:
-            return self.editor.hasChanged()
-        else:
-            return False
-
-    def new(self, filepath):
-        """New empty buffer."""
-        if not filepath:
-            return
-        if os.path.exists(filepath):
-            self.confirmed = self.overwriteConfirm(filepath)
-        else:
-            self.confirmed = True
-
-    def open(self, filename):
-        """Open file into buffer."""
-        self.doc = document.Document(filename)
-        self.name = self.doc.filename or ('Untitled:' + str(self.id))
-        self.modulename = self.doc.filebase
-        # XXX This should really make sure filedir is first item in syspath.
-        # XXX Or maybe this should be moved to the update namespace method.
-        if self.doc.filedir and self.doc.filedir not in self.syspath:
-            # To create the proper context for updateNamespace.
-            self.syspath.insert(0, self.doc.filedir)
-        if self.doc.filepath and os.path.exists(self.doc.filepath):
-            self.confirmed = True
-        if self.editor:
-            text = self.doc.read()
-            self.editor._setBuffer(buffer=self, text=text)
-
-    def overwriteConfirm(filepath):
-        """Confirm overwriting an existing file."""
-        return False
-
-    def save(self):
-        """Save buffer."""
-        filepath = self.doc.filepath
-        if not filepath:
-            return  # XXX Get filename
-        if not os.path.exists(filepath):
-            self.confirmed = True
-        if not self.confirmed:
-            self.confirmed = self.overwriteConfirm(filepath)
-        if self.confirmed:
-            self.doc.write(self.editor.getText())
-            if self.editor:
-                self.editor.setSavePoint()
-
-    def saveAs(self, filename):
-        """Save buffer."""
-        self.doc = document.Document(filename)
-        self.name = self.doc.filename
-        self.modulename = self.doc.filebase
-        self.save()
-
-    def updateNamespace(self):
-        """Update the namespace for autocompletion and calltips.
-
-        Return True if updated, False if there was an error."""
-        if not self.interp or not hasattr(self.editor, 'getText'):
-            return False
-        syspath = sys.path
-        sys.path = self.syspath
-        text = self.editor.getText()
-        text = text.replace('\r\n', '\n')
-        text = text.replace('\r', '\n')
-        name = self.modulename or self.name
-        module = imp.new_module(name)
-        newspace = module.__dict__.copy()
-        try:
-            try:
-                code = compile(text, name, 'exec')
-            except:
-                raise
-#                return False
-            try:
-                exec code in newspace
-            except:
-                raise
-#                return False
-            else:
-                # No problems, so update the namespace.
-                self.interp.locals.clear()
-                self.interp.locals.update(newspace)
-                return True
-        finally:
-            sys.path = syspath
-            for m in sys.modules.keys():
-                if m not in self.modules:
-                    del sys.modules[m]

wxPython/wx/py/crust.py

@@ -1,218 +0,0 @@
-"""Crust combines the shell and filling into one control."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-import os
-import pprint
-import sys
-
-import dispatcher
-import editwindow
-from filling import Filling
-import frame
-from shell import Shell
-from version import VERSION
-
-
-class Crust(wx.SplitterWindow):
-    """Crust based on SplitterWindow."""
-
-    name = 'Crust'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition, 
-                 size=wx.DefaultSize, style=wx.SP_3D,
-                 name='Crust Window', rootObject=None, rootLabel=None,
-                 rootIsNamespace=True, intro='', locals=None, 
-                 InterpClass=None, *args, **kwds):
-        """Create Crust instance."""
-        wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
-        self.shell = Shell(parent=self, introText=intro, 
-                           locals=locals, InterpClass=InterpClass, 
-                           *args, **kwds)
-        self.editor = self.shell
-        if rootObject is None:
-            rootObject = self.shell.interp.locals
-        self.notebook = wx.Notebook(parent=self, id=-1)
-        self.shell.interp.locals['notebook'] = self.notebook
-        self.filling = Filling(parent=self.notebook, 
-                               rootObject=rootObject, 
-                               rootLabel=rootLabel, 
-                               rootIsNamespace=rootIsNamespace)
-        # Add 'filling' to the interpreter's locals.
-        self.shell.interp.locals['filling'] = self.filling
-        self.notebook.AddPage(page=self.filling, text='Namespace', select=True)
-        self.display = Display(parent=self.notebook)
-        self.notebook.AddPage(page=self.display, text='Display')
-        # Add 'pp' (pretty print) to the interpreter's locals.
-        self.shell.interp.locals['pp'] = self.display.setItem
-        self.calltip = Calltip(parent=self.notebook)
-        self.notebook.AddPage(page=self.calltip, text='Calltip')
-        self.sessionlisting = SessionListing(parent=self.notebook)
-        self.notebook.AddPage(page=self.sessionlisting, text='Session')
-        self.dispatcherlisting = DispatcherListing(parent=self.notebook)
-        self.notebook.AddPage(page=self.dispatcherlisting, text='Dispatcher')
-##         from wxd import wx_
-##         self.wxdocs = Filling(parent=self.notebook, 
-##                               rootObject=wx_,
-##                               rootLabel='wx', 
-##                               rootIsNamespace=False,
-##                               static=True)
-##         self.notebook.AddPage(page=self.wxdocs, text='wxPython Docs')
-##         from wxd import stc_
-##         self.stcdocs = Filling(parent=self.notebook, 
-##                                rootObject=stc_.StyledTextCtrl,
-##                                rootLabel='StyledTextCtrl', 
-##                                rootIsNamespace=False,
-##                                static=True)
-##         self.notebook.AddPage(page=self.stcdocs, text='StyledTextCtrl Docs')
-        self.SplitHorizontally(self.shell, self.notebook, 300)
-        self.SetMinimumPaneSize(1)
-
-
-class Display(editwindow.EditWindow):
-    """STC used to display an object using Pretty Print."""
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER,
-                 static=False):
-        """Create Display instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        # Configure various defaults and user preferences.
-        self.SetReadOnly(True)
-        self.SetWrapMode(False)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.Refresh()
-
-    def Refresh(self):
-        if not hasattr(self, "item"):
-            return
-        self.SetReadOnly(False)
-        text = pprint.pformat(self.item)
-        self.SetText(text)
-        self.SetReadOnly(True)
-
-    def setItem(self, item):
-        """Set item to pretty print in the notebook Display tab."""
-        self.item = item
-        self.Refresh()
-
-
-class Calltip(wx.TextCtrl):
-    """Text control containing the most recent shell calltip."""
-
-    def __init__(self, parent=None, id=-1):
-        style = (wx.TE_MULTILINE | wx.TE_READONLY | wx.TE_RICH2)
-        wx.TextCtrl.__init__(self, parent, id, style=style)
-        self.SetBackgroundColour(wx.Colour(255, 255, 232))
-        dispatcher.connect(receiver=self.display, signal='Shell.calltip')
-
-    def display(self, calltip):
-        """Receiver for Shell.calltip signal."""
-        ## self.SetValue(calltip)  # Caused refresh problem on Windows.
-        self.Clear()
-        self.AppendText(calltip)
-
-
-class SessionListing(wx.TextCtrl):
-    """Text control containing all commands for session."""
-
-    def __init__(self, parent=None, id=-1):
-        style = (wx.TE_MULTILINE | wx.TE_READONLY |
-                 wx.TE_RICH2 | wx.TE_DONTWRAP)
-        wx.TextCtrl.__init__(self, parent, id, style=style)
-        dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        if command and not more:
-            self.SetInsertionPointEnd()
-            start, end = self.GetSelection()
-            if start != end:
-                self.SetSelection(0, 0)
-            self.AppendText(command + '\n')
-
-
-class DispatcherListing(wx.TextCtrl):
-    """Text control containing all dispatches for session."""
-
-    def __init__(self, parent=None, id=-1):
-        style = (wx.TE_MULTILINE | wx.TE_READONLY |
-                 wx.TE_RICH2 | wx.TE_DONTWRAP)
-        wx.TextCtrl.__init__(self, parent, id, style=style)
-        dispatcher.connect(receiver=self.spy)
-
-    def spy(self, signal, sender):
-        """Receiver for Any signal from Any sender."""
-        text = '%r from %s' % (signal, sender)
-        self.SetInsertionPointEnd()
-        start, end = self.GetSelection()
-        if start != end:
-            self.SetSelection(0, 0)
-        self.AppendText(text + '\n')
-
-
-class CrustFrame(frame.Frame):
-    """Frame containing all the PyCrust components."""
-
-    name = 'CrustFrame'
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='PyCrust',
-                 pos=wx.DefaultPosition, size=wx.DefaultSize,
-                 style=wx.DEFAULT_FRAME_STYLE,
-                 rootObject=None, rootLabel=None, rootIsNamespace=True,
-                 locals=None, InterpClass=None, *args, **kwds):
-        """Create CrustFrame instance."""
-        frame.Frame.__init__(self, parent, id, title, pos, size, style)
-        intro = 'PyCrust %s - The Flakiest Python Shell' % VERSION
-        intro += '\nSponsored by Orbtech - '
-        intro += 'Your source for Python programming expertise.'
-        self.SetStatusText(intro.replace('\n', ', '))
-        self.crust = Crust(parent=self, intro=intro,
-                           rootObject=rootObject,
-                           rootLabel=rootLabel,
-                           rootIsNamespace=rootIsNamespace,
-                           locals=locals,
-                           InterpClass=InterpClass, *args, **kwds)
-        self.shell = self.crust.shell
-        # Override the filling so that status messages go to the status bar.
-        self.crust.filling.tree.setStatusText = self.SetStatusText
-        # Override the shell so that status messages go to the status bar.
-        self.shell.setStatusText = self.SetStatusText
-        # Fix a problem with the sash shrinking to nothing.
-        self.crust.filling.SetSashPosition(200)
-        # Set focus to the shell editor.
-        self.shell.SetFocus()
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        self.crust.shell.destroy()
-        self.Destroy()
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyCrust'
-        text = 'PyCrust %s\n\n' % VERSION + \
-               'Yet another Python shell, only flakier.\n\n' + \
-               'Half-baked by Patrick K. O\'Brien,\n' + \
-               'the other half is still in the oven.\n\n' + \
-               'Shell Revision: %s\n' % self.shell.revision + \
-               'Interpreter Revision: %s\n\n' % self.shell.interp.revision + \
-               'Platform: %s\n' % sys.platform + \
-               'Python Version: %s\n' % sys.version.split()[0] + \
-               'wxPython Version: %s\n' % wx.VERSION_STRING + \
-               ('\t(%s)\n' % ", ".join(wx.PlatformInfo[1:])) 
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()

wxPython/wx/py/dispatcher.py

@@ -1,260 +0,0 @@
-"""Provides global signal dispatching services."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import exceptions
-import types
-import weakref
-
-
-class DispatcherError(exceptions.Exception):
-    def __init__(self, args=None):
-        self.args = args
-
-
-class Parameter:
-    """Used to represent default parameter values."""
-    def __repr__(self):
-        return self.__class__.__name__
-
-class Any(Parameter): pass
-Any = Any()
-
-class Anonymous(Parameter): pass
-Anonymous = Anonymous()
-
-
-connections = {}
-senders = {}
-_boundMethods = weakref.WeakKeyDictionary()
-
-
-def connect(receiver, signal=Any, sender=Any, weak=True):
-    """Connect receiver to sender for signal.
-    
-    If sender is Any, receiver will receive signal from any sender.
-    If signal is Any, receiver will receive any signal from sender.
-    If sender is None, receiver will receive signal from Anonymous.
-    If signal is Any and sender is None, receiver will receive any 
-        signal from Anonymous.
-    If signal is Any and sender is Any, receiver will receive any 
-        signal from any sender.
-    If weak is true, weak references will be used."""
-    if signal is None:
-        raise DispatcherError, 'signal cannot be None'
-    if weak:
-        receiver = safeRef(receiver)
-    senderkey = id(sender)
-    signals = {}
-    if connections.has_key(senderkey):
-        signals = connections[senderkey]
-    else:
-        connections[senderkey] = signals
-        # Keep track of senders for cleanup.
-        if sender not in (None, Any):
-            def remove(object, senderkey=senderkey):
-                _removeSender(senderkey=senderkey)
-            # Skip objects that can not be weakly referenced, which means
-            # they won't be automatically cleaned up, but that's too bad.
-            try:
-                weakSender = weakref.ref(sender, remove)
-                senders[senderkey] = weakSender
-            except:
-                pass
-    receivers = []
-    if signals.has_key(signal):
-        receivers = signals[signal]
-    else:
-        signals[signal] = receivers
-    try:
-        receivers.remove(receiver)
-    except ValueError:
-        pass
-    receivers.append(receiver)
-
-def disconnect(receiver, signal=Any, sender=Any, weak=True):
-    """Disconnect receiver from sender for signal.
-    
-    Disconnecting is not required. The use of disconnect is the same as for
-    connect, only in reverse. Think of it as undoing a previous connection."""
-    if signal is None:
-        raise DispatcherError, 'signal cannot be None'
-    if weak:
-        receiver = safeRef(receiver)
-    senderkey = id(sender)
-    try:
-        receivers = connections[senderkey][signal]
-    except KeyError:
-        raise DispatcherError, \
-              'No receivers for signal %r from sender %s' % (signal, sender)
-    try:
-        receivers.remove(receiver)
-    except ValueError:
-        raise DispatcherError, \
-              'No connection to receiver %s for signal %r from sender %s' % \
-              (receiver, signal, sender)
-    _cleanupConnections(senderkey, signal)
-
-def send(signal, sender=Anonymous, **kwds):
-    """Send signal from sender to all connected receivers.
-    
-    Return a list of tuple pairs [(receiver, response), ... ].
-    If sender is not specified, signal is sent anonymously."""
-    senderkey = id(sender)
-    anykey = id(Any)
-    # Get receivers that receive *this* signal from *this* sender.
-    receivers = []
-    try:
-        receivers.extend(connections[senderkey][signal])
-    except KeyError:
-        pass
-    # Add receivers that receive *any* signal from *this* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[senderkey][Any]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Add receivers that receive *this* signal from *any* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[anykey][signal]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Add receivers that receive *any* signal from *any* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[anykey][Any]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Call each receiver with whatever arguments it can accept.
-    # Return a list of tuple pairs [(receiver, response), ... ].
-    responses = []
-    for receiver in receivers:
-        if type(receiver) is weakref.ReferenceType \
-        or isinstance(receiver, BoundMethodWeakref):
-            # Dereference the weak reference.
-            receiver = receiver()
-            if receiver is None:
-                # This receiver is dead, so skip it.
-                continue
-        response = _call(receiver, signal=signal, sender=sender, **kwds)
-        responses += [(receiver, response)]
-    return responses
-
-def _call(receiver, **kwds):
-    """Call receiver with only arguments it can accept."""
-##    if type(receiver) is types.InstanceType:
-    if hasattr(receiver, '__call__') and \
-       (hasattr(receiver.__call__, 'im_func') or hasattr(receiver.__call__, 'im_code')):
-        # receiver is a class instance; assume it is callable.
-        # Reassign receiver to the actual method that will be called.
-        receiver = receiver.__call__
-    if hasattr(receiver, 'im_func'):
-        # receiver is a method. Drop the first argument, usually 'self'.
-        fc = receiver.im_func.func_code
-        acceptable = fc.co_varnames[1:fc.co_argcount]
-    elif hasattr(receiver, 'func_code'):
-        # receiver is a function.
-        fc = receiver.func_code
-        acceptable = fc.co_varnames[0:fc.co_argcount]
-    else:
-        raise DispatcherError, 'Unknown receiver %s of type %s' % (receiver, type(receiver))
-    if not (fc.co_flags & 8):
-        # fc does not have a **kwds type parameter, therefore 
-        # remove unacceptable arguments.
-        for arg in kwds.keys():
-            if arg not in acceptable:
-                del kwds[arg]
-    return receiver(**kwds)
-
-
-def safeRef(object):
-    """Return a *safe* weak reference to a callable object."""
-    if hasattr(object, 'im_self'):
-        if object.im_self is not None:
-            # Turn a bound method into a BoundMethodWeakref instance.
-            # Keep track of these instances for lookup by disconnect().
-            selfkey = object.im_self
-            funckey = object.im_func
-            if not _boundMethods.has_key(selfkey):
-                _boundMethods[selfkey] = weakref.WeakKeyDictionary()
-            if not _boundMethods[selfkey].has_key(funckey):
-                _boundMethods[selfkey][funckey] = \
-                BoundMethodWeakref(boundMethod=object)
-            return _boundMethods[selfkey][funckey]
-    return weakref.ref(object, _removeReceiver)
-
-
-class BoundMethodWeakref:
-    """BoundMethodWeakref class."""
-
-    def __init__(self, boundMethod):
-        """Return a weak-reference-like instance for a bound method."""
-        self.isDead = 0
-        def remove(object, self=self):
-            """Set self.isDead to true when method or instance is destroyed."""
-            self.isDead = 1
-            _removeReceiver(receiver=self)
-        self.weakSelf = weakref.ref(boundMethod.im_self, remove)
-        self.weakFunc = weakref.ref(boundMethod.im_func, remove)
-
-    def __repr__(self):
-        """Return the closest representation."""
-        return '<bound method weakref for %s.%s>' % (self.weakSelf, self.weakFunc)
-
-    def __call__(self):
-        """Return a strong reference to the bound method."""
-        if self.isDead:
-            return None
-        else:
-            object = self.weakSelf()
-            method = self.weakFunc().__name__
-            try:  # wxPython hack to handle wxDead objects.
-                return getattr(object, method)
-            except AttributeError:
-##                 _removeReceiver(receiver=self)
-                return None
-
-
-def _removeReceiver(receiver):
-    """Remove receiver from connections."""
-    for senderkey in connections.keys():
-        for signal in connections[senderkey].keys():
-            receivers = connections[senderkey][signal]
-            try:
-                receivers.remove(receiver)
-            except:
-                pass
-            _cleanupConnections(senderkey, signal)
-            
-def _cleanupConnections(senderkey, signal):
-    """Delete any empty signals for senderkey. Delete senderkey if empty."""
-    receivers = connections[senderkey][signal]
-    if not receivers:
-        # No more connected receivers. Therefore, remove the signal.
-        signals = connections[senderkey]
-        del signals[signal]
-        if not signals:
-            # No more signal connections. Therefore, remove the sender.
-            _removeSender(senderkey)
-            
-def _removeSender(senderkey):
-    """Remove senderkey from connections."""
-    del connections[senderkey]
-    # Senderkey will only be in senders dictionary if sender 
-    # could be weakly referenced.
-    try:
-        del senders[senderkey]
-    except:
-        pass

wxPython/wx/py/document.py

@@ -1,43 +0,0 @@
-"""Document class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-
-
-class Document:
-    """Document class."""
-
-    def __init__(self, filename=None):
-        """Create a Document instance."""
-        self.filename = filename
-        self.filepath = None
-        self.filedir = None
-        self.filebase = None
-        self.fileext = None
-        if self.filename:
-            self.filepath = os.path.realpath(self.filename)
-            self.filedir, self.filename = os.path.split(self.filepath)
-            self.filebase, self.fileext = os.path.splitext(self.filename)
-
-    def read(self):
-        """Return contents of file."""
-        if self.filepath and os.path.exists(self.filepath):
-            f = file(self.filepath, 'rb')
-            try:
-                return f.read()
-            finally:
-                f.close()
-        else:
-            return ''
-
-    def write(self, text):
-        """Write text to file."""
-        try:
-            f = file(self.filepath, 'wb')
-            f.write(text)
-        finally:
-            if f:
-                f.close()

wxPython/wx/py/editor.py

@@ -1,843 +0,0 @@
-"""PyAlaCarte and PyAlaMode editors."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-from buffer import Buffer
-import crust
-import dispatcher
-import editwindow
-import frame
-from shell import Shell
-import version
-
-
-class EditorFrame(frame.Frame):
-    """Frame containing one editor."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaCarte',
-                 pos=wx.DefaultPosition, size=(800, 600), 
-                 style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE,
-                 filename=None):
-        """Create EditorFrame instance."""
-        frame.Frame.__init__(self, parent, id, title, pos, size, style)
-        self.buffers = {}
-        self.buffer = None  # Current buffer.
-        self.editor = None
-        self._defaultText = title + ' - the tastiest Python editor.'
-        self._statusText = self._defaultText
-        self.SetStatusText(self._statusText)
-        wx.EVT_IDLE(self, self.OnIdle)
-        self._setup()
-        if filename:
-            self.bufferCreate(filename)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Useful for subclasses."""
-        pass
-
-    def setEditor(self, editor):
-        self.editor = editor
-        self.buffer = self.editor.buffer
-        self.buffers[self.buffer.id] = self.buffer
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaCarte'
-        text = 'Another fine, flaky program.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        for buffer in self.buffers.values():
-            self.buffer = buffer
-            if buffer.hasChanged():
-                cancel = self.bufferSuggestSave()
-                if cancel and event.CanVeto():
-                    event.Veto()
-                    return
-        self.Destroy()
-
-    def OnIdle(self, event):
-        """Event handler for idle time."""
-        self._updateStatus()
-        if hasattr(self, 'notebook'):
-            self._updateTabText()
-        self._updateTitle()
-        event.Skip()
-
-    def _updateStatus(self):
-        """Show current status information."""
-        if self.editor and hasattr(self.editor, 'getStatus'):
-            status = self.editor.getStatus()
-            text = 'File: %s  |  Line: %d  |  Column: %d' % status
-        else:
-            text = self._defaultText
-        if text != self._statusText:
-            self.SetStatusText(text)
-            self._statusText = text
-
-    def _updateTabText(self):
-        """Show current buffer information on notebook tab."""
-##         suffix = ' **'
-##         notebook = self.notebook
-##         selection = notebook.GetSelection()
-##         if selection == -1:
-##             return
-##         text = notebook.GetPageText(selection)
-##         window = notebook.GetPage(selection)
-##         if window.editor and window.editor.buffer.hasChanged():
-##             if text.endswith(suffix):
-##                 pass
-##             else:
-##                 notebook.SetPageText(selection, text + suffix)
-##         else:
-##             if text.endswith(suffix):
-##                 notebook.SetPageText(selection, text[:len(suffix)])
-
-    def _updateTitle(self):
-        """Show current title information."""
-        title = self.GetTitle()
-        if self.bufferHasChanged():
-            if title.startswith('* '):
-                pass
-            else:
-                self.SetTitle('* ' + title)
-        else:
-            if title.startswith('* '):
-                self.SetTitle(title[2:])
-        
-    def hasBuffer(self):
-        """Return True if there is a current buffer."""
-        if self.buffer:
-            return True
-        else:
-            return False
-
-    def bufferClose(self):
-        """Close buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferDestroy()
-        cancel = False
-        return cancel
-
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        self.bufferDestroy()
-        buffer = Buffer()
-        self.panel = panel = wx.Panel(parent=self, id=-1)
-        wx.EVT_ERASE_BACKGROUND(panel, lambda x: x)        
-        editor = Editor(parent=panel)
-        panel.editor = editor
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(editor.window, 1, wx.EXPAND)
-        panel.SetSizer(sizer)
-        panel.SetAutoLayout(True)
-        sizer.Layout()
-        buffer.addEditor(editor)
-        buffer.open(filename)
-        self.setEditor(editor)
-        self.editor.setFocus()
-        self.SendSizeEvent()
-        
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        if self.buffer:
-            for editor in self.buffer.editors.values():
-                editor.destroy()
-            self.editor = None
-            del self.buffers[self.buffer.id]
-            self.buffer = None
-            self.panel.Destroy()
-
-
-    def bufferHasChanged(self):
-        """Return True if buffer has changed since last save."""
-        if self.buffer:
-            return self.buffer.hasChanged()
-        else:
-            return False
-
-    def bufferNew(self):
-        """Create new buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = openSingle(directory=filedir)
-        if result.path:
-            self.bufferCreate(result.path)
-        cancel = False
-        return cancel
-
-##     def bufferPrint(self):
-##         """Print buffer."""
-##         pass
-
-##     def bufferRevert(self):
-##         """Revert buffer to version of file on disk."""
-##         pass
-
-    def bufferSave(self):
-        """Save buffer to its file."""
-        if self.buffer.doc.filepath:
-            self.buffer.save()
-            cancel = False
-        else:
-            cancel = self.bufferSaveAs()
-        return cancel
-
-    def bufferSaveAs(self):
-        """Save buffer to a new filename."""
-        if self.bufferHasChanged() and self.buffer.doc.filepath:
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = saveSingle(directory=filedir)
-        if result.path:
-            self.buffer.saveAs(result.path)
-            cancel = False
-        else:
-            cancel = True
-        return cancel
-
-    def bufferSuggestSave(self):
-        """Suggest saving changes.  Return True if user selected Cancel."""
-        result = messageDialog(parent=None,
-                               message='%s has changed.\n'
-                                       'Would you like to save it first'
-                                       '?' % self.buffer.name,
-                               title='Save current file?')
-        if result.positive:
-            cancel = self.bufferSave()
-        else:
-            cancel = result.text == 'Cancel'
-        return cancel
-
-    def updateNamespace(self):
-        """Update the buffer namespace for autocompletion and calltips."""
-        if self.buffer.updateNamespace():
-            self.SetStatusText('Namespace updated')
-        else:
-            self.SetStatusText('Error executing, unable to update namespace')
-
-
-class EditorNotebookFrame(EditorFrame):
-    """Frame containing one or more editors in a notebook."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaMode',
-                 pos=wx.DefaultPosition, size=(800, 600), 
-                 style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE,
-                 filename=None):
-        """Create EditorNotebookFrame instance."""
-        self.notebook = None
-        EditorFrame.__init__(self, parent, id, title, pos,
-                             size, style, filename)
-        if self.notebook:
-            dispatcher.connect(receiver=self._editorChange,
-                               signal='EditorChange', sender=self.notebook)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Called automatically by base class during init."""
-        self.notebook = EditorNotebook(parent=self)
-        intro = 'Py %s' % version.VERSION
-        import imp
-        module = imp.new_module('__main__')
-        import __builtin__
-        module.__dict__['__builtins__'] = __builtin__
-        namespace = module.__dict__.copy()
-        self.crust = crust.Crust(parent=self.notebook, intro=intro, locals=namespace)
-        self.shell = self.crust.shell
-        # Override the filling so that status messages go to the status bar.
-        self.crust.filling.tree.setStatusText = self.SetStatusText
-        # Override the shell so that status messages go to the status bar.
-        self.shell.setStatusText = self.SetStatusText
-        # Fix a problem with the sash shrinking to nothing.
-        self.crust.filling.SetSashPosition(200)
-        self.notebook.AddPage(page=self.crust, text='*Shell*', select=True)
-        self.setEditor(self.crust.editor)
-        self.crust.editor.SetFocus()
-
-    def _editorChange(self, editor):
-        """Editor change signal receiver."""
-        self.setEditor(editor)
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaMode'
-        text = 'Another fine, flaky program.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def _updateTitle(self):
-        """Show current title information."""
-        pass
-##         title = self.GetTitle()
-##         if self.bufferHasChanged():
-##             if title.startswith('* '):
-##                 pass
-##             else:
-##                 self.SetTitle('* ' + title)
-##         else:
-##             if title.startswith('* '):
-##                 self.SetTitle(title[2:])
-        
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        buffer = Buffer()
-        panel = wx.Panel(parent=self.notebook, id=-1)
-        wx.EVT_ERASE_BACKGROUND(panel, lambda x: x)        
-        editor = Editor(parent=panel)
-        panel.editor = editor
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(editor.window, 1, wx.EXPAND)
-        panel.SetSizer(sizer)
-        panel.SetAutoLayout(True)
-        sizer.Layout()
-        buffer.addEditor(editor)
-        buffer.open(filename)
-        self.setEditor(editor)
-        self.notebook.AddPage(page=panel, text=self.buffer.name, select=True)
-        self.editor.setFocus()
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        selection = self.notebook.GetSelection()
-##         print "Destroy Selection:", selection
-        if selection > 0:  # Don't destroy the PyCrust tab.
-            if self.buffer:
-                del self.buffers[self.buffer.id]
-                self.buffer = None  # Do this before DeletePage().
-            self.notebook.DeletePage(selection)
-
-    def bufferNew(self):
-        """Create new buffer."""
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = openMultiple(directory=filedir)
-        for path in result.paths:
-            self.bufferCreate(path)
-        cancel = False
-        return cancel
-
-
-class EditorNotebook(wx.Notebook):
-    """A notebook containing a page for each editor."""
-
-    def __init__(self, parent):
-        """Create EditorNotebook instance."""
-        wx.Notebook.__init__(self, parent, id=-1, style=wx.CLIP_CHILDREN)
-        wx.EVT_NOTEBOOK_PAGE_CHANGING(self, self.GetId(),
-                                      self.OnPageChanging)
-        wx.EVT_NOTEBOOK_PAGE_CHANGED(self, self.GetId(),
-                                     self.OnPageChanged)
-        wx.EVT_IDLE(self, self.OnIdle)
-
-    def OnIdle(self, event):
-        """Event handler for idle time."""
-        self._updateTabText()
-        event.Skip()
-
-    def _updateTabText(self):
-        """Show current buffer display name on all but first tab."""
-        size = 3
-        changed = ' **'
-        unchanged = ' --'
-        selection = self.GetSelection()
-        if selection < 1:
-            return
-        text = self.GetPageText(selection)
-        window = self.GetPage(selection)
-        if not window.editor:
-            return
-        if text.endswith(changed) or text.endswith(unchanged):
-            name = text[:-size]
-        else:
-            name = text
-        if name != window.editor.buffer.name:
-            text = window.editor.buffer.name
-        if window.editor.buffer.hasChanged():
-            if text.endswith(changed):
-                text = None
-            elif text.endswith(unchanged):
-                text = text[:-size] + changed
-            else:
-                text += changed
-        else:
-            if text.endswith(changed):
-                text = text[:-size] + unchanged
-            elif text.endswith(unchanged):
-                text = None
-            else:
-                text += unchanged
-        if text is not None:
-            self.SetPageText(selection, text)
-            self.Refresh()  # Needed on Win98.
-
-    def OnPageChanging(self, event):
-        """Page changing event handler."""
-        event.Skip()
-
-    def OnPageChanged(self, event):
-        """Page changed event handler."""
-        new = event.GetSelection()
-        window = self.GetPage(new)
-        dispatcher.send(signal='EditorChange', sender=self,
-                        editor=window.editor)
-        window.SetFocus()
-        event.Skip()
-
-
-class EditorShellNotebookFrame(EditorNotebookFrame):
-    """Frame containing a notebook containing EditorShellNotebooks."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaModeTest',
-                 pos=wx.DefaultPosition, size=(600, 400), 
-                 style=wx.DEFAULT_FRAME_STYLE,
-                 filename=None, singlefile=False):
-        """Create EditorShellNotebookFrame instance."""
-        self._singlefile = singlefile
-        EditorNotebookFrame.__init__(self, parent, id, title, pos,
-                                     size, style, filename)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Called automatically by base class during init."""
-        if not self._singlefile:
-            self.notebook = EditorNotebook(parent=self)
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaModePlus'
-        text = 'Another fine, flaky program.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        if self._singlefile:
-            self.bufferDestroy()
-            notebook = EditorShellNotebook(parent=self,
-                                           filename=filename)
-            self.notebook = notebook
-        else:
-            notebook = EditorShellNotebook(parent=self.notebook,
-                                           filename=filename)
-        self.setEditor(notebook.editor)
-        if not self._singlefile:
-            self.notebook.AddPage(page=notebook, text=self.buffer.name,
-                                  select=True)
-        self.editor.setFocus()
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        if self.buffer:
-            self.editor = None
-            del self.buffers[self.buffer.id]
-            self.buffer = None  # Do this before DeletePage().
-        if self._singlefile:
-            self.notebook.Destroy()
-            self.notebook = None
-        else:
-            selection = self.notebook.GetSelection()
-##             print "Destroy Selection:", selection
-            self.notebook.DeletePage(selection)
-
-    def bufferNew(self):
-        """Create new buffer."""
-        if self._singlefile and self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        if self._singlefile and self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        if self._singlefile:
-            result = openSingle(directory=filedir)
-            if result.path:
-                self.bufferCreate(result.path)
-        else:
-            result = openMultiple(directory=filedir)
-            for path in result.paths:
-                self.bufferCreate(path)
-        cancel = False
-        return cancel
-
-
-class EditorShellNotebook(wx.Notebook):
-    """A notebook containing an editor page and a shell page."""
-
-    def __init__(self, parent, filename=None):
-        """Create EditorShellNotebook instance."""
-        wx.Notebook.__init__(self, parent, id=-1)
-        usePanels = True
-        if usePanels:
-            editorparent = editorpanel = wx.Panel(self, -1)
-            shellparent = shellpanel = wx.Panel(self, -1)
-        else:
-            editorparent = self
-            shellparent = self
-        self.buffer = Buffer()
-        self.editor = Editor(parent=editorparent)
-        self.buffer.addEditor(self.editor)
-        self.buffer.open(filename)
-        self.shell = Shell(parent=shellparent, locals=self.buffer.interp.locals,
-                           style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER)
-        self.buffer.interp.locals.clear()
-        if usePanels:
-            self.AddPage(page=editorpanel, text='Editor', select=True)
-            self.AddPage(page=shellpanel, text='Shell')
-            # Setup sizers
-            editorsizer = wx.BoxSizer(wx.VERTICAL)
-            editorsizer.Add(self.editor.window, 1, wx.EXPAND)
-            editorpanel.SetSizer(editorsizer)
-            editorpanel.SetAutoLayout(True)
-            shellsizer = wx.BoxSizer(wx.VERTICAL)
-            shellsizer.Add(self.shell, 1, wx.EXPAND)
-            shellpanel.SetSizer(shellsizer)
-            shellpanel.SetAutoLayout(True)
-        else:
-            self.AddPage(page=self.editor.window, text='Editor', select=True)
-            self.AddPage(page=self.shell, text='Shell')
-        self.editor.setFocus()
-        wx.EVT_NOTEBOOK_PAGE_CHANGED(self, self.GetId(), self.OnPageChanged)
-
-    def OnPageChanged(self, event):
-        """Page changed event handler."""
-        selection = event.GetSelection()
-        if selection == 0:
-            self.editor.setFocus()
-        else:
-            self.shell.SetFocus()
-        event.Skip()
-
-    def SetFocus(self):
-        wx.Notebook.SetFocus(self)
-        selection = self.GetSelection()
-        if selection == 0:
-            self.editor.setFocus()
-        else:
-            self.shell.SetFocus()
-
-
-class Editor:
-    """Editor having an EditWindow."""
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER):
-        """Create Editor instance."""
-        self.window = EditWindow(self, parent, id, pos, size, style)
-        self.id = self.window.GetId()
-        self.buffer = None
-        # Assign handlers for keyboard events.
-        wx.EVT_CHAR(self.window, self.OnChar)
-        wx.EVT_KEY_DOWN(self.window, self.OnKeyDown)
-
-    def _setBuffer(self, buffer, text):
-        """Set the editor to a buffer.  Private callback called by buffer."""
-        self.buffer = buffer
-        self.autoCompleteKeys = buffer.interp.getAutoCompleteKeys()
-        self.clearAll()
-        self.setText(text)
-        self.emptyUndoBuffer()
-        self.setSavePoint()
-
-    def destroy(self):
-        """Destroy all editor objects."""
-        self.window.Destroy()
-
-    def clearAll(self):
-        self.window.ClearAll()
-
-    def emptyUndoBuffer(self):
-        self.window.EmptyUndoBuffer()
-
-    def getStatus(self):
-        """Return (filepath, line, column) status tuple."""
-        if self.window:
-            pos = self.window.GetCurrentPos()
-            line = self.window.LineFromPosition(pos) + 1
-            col = self.window.GetColumn(pos)
-            if self.buffer:
-                name = self.buffer.doc.filepath or self.buffer.name
-            else:
-                name = ''
-            status = (name, line, col)
-            return status
-        else:
-            return ('', 0, 0)
-
-    def getText(self):
-        """Return contents of editor."""
-        return self.window.GetText()
-
-    def hasChanged(self):
-        """Return True if contents have changed."""
-        return self.window.GetModify()
-
-    def setFocus(self):
-        """Set the input focus to the editor window."""
-        self.window.SetFocus()
-
-    def setSavePoint(self):
-        self.window.SetSavePoint()
-
-    def setText(self, text):
-        """Set contents of editor."""
-        self.window.SetText(text)
-
-    def OnChar(self, event):
-        """Keypress event handler.
-        
-        Only receives an event if OnKeyDown calls event.Skip() for the
-        corresponding event."""
-
-        key = event.KeyCode()
-        if key in self.autoCompleteKeys:
-            # Usually the dot (period) key activates auto completion.
-            if self.window.AutoCompActive(): 
-                self.window.AutoCompCancel()
-            self.window.ReplaceSelection('')
-            self.window.AddText(chr(key))
-            text, pos = self.window.GetCurLine()
-            text = text[:pos]
-            if self.window.autoComplete: 
-                self.autoCompleteShow(text)
-        elif key == ord('('):
-            # The left paren activates a call tip and cancels an
-            # active auto completion.
-            if self.window.AutoCompActive(): 
-                self.window.AutoCompCancel()
-            self.window.ReplaceSelection('')
-            self.window.AddText('(')
-            text, pos = self.window.GetCurLine()
-            text = text[:pos]
-            self.autoCallTipShow(text)
-        else:
-            # Allow the normal event handling to take place.
-            event.Skip()
-
-    def OnKeyDown(self, event):
-        """Key down event handler."""
-
-        key = event.KeyCode()
-        # If the auto-complete window is up let it do its thing.
-        if self.window.AutoCompActive():
-            event.Skip()
-            return
-        controlDown = event.ControlDown()
-        altDown = event.AltDown()
-        shiftDown = event.ShiftDown()
-        # Let Ctrl-Alt-* get handled normally.
-        if controlDown and altDown:
-            event.Skip()
-        # Increase font size.
-        elif controlDown and key in (ord(']'),):
-            dispatcher.send(signal='FontIncrease')
-        # Decrease font size.
-        elif controlDown and key in (ord('['),):
-            dispatcher.send(signal='FontDecrease')
-        # Default font size.
-        elif controlDown and key in (ord('='),):
-            dispatcher.send(signal='FontDefault')
-        else:
-            event.Skip()
-
-    def autoCompleteShow(self, command):
-        """Display auto-completion popup list."""
-        list = self.buffer.interp.getAutoCompleteList(command, 
-                    includeMagic=self.window.autoCompleteIncludeMagic, 
-                    includeSingle=self.window.autoCompleteIncludeSingle, 
-                    includeDouble=self.window.autoCompleteIncludeDouble)
-        if list:
-            options = ' '.join(list)
-            offset = 0
-            self.window.AutoCompShow(offset, options)
-
-    def autoCallTipShow(self, command):
-        """Display argument spec and docstring in a popup window."""
-        if self.window.CallTipActive():
-            self.window.CallTipCancel()
-        (name, argspec, tip) = self.buffer.interp.getCallTip(command)
-        if tip:
-            dispatcher.send(signal='Shell.calltip', sender=self, calltip=tip)
-        if not self.window.autoCallTip:
-            return
-        if argspec:
-            startpos = self.window.GetCurrentPos()
-            self.window.AddText(argspec + ')')
-            endpos = self.window.GetCurrentPos()
-            self.window.SetSelection(endpos, startpos)
-        if tip:
-            curpos = self.window.GetCurrentPos()
-            size = len(name)
-            tippos = curpos - (size + 1)
-            fallback = curpos - self.window.GetColumn(curpos)
-            # In case there isn't enough room, only go back to the
-            # fallback.
-            tippos = max(tippos, fallback)
-            self.window.CallTipShow(tippos, tip)
-            self.window.CallTipSetHighlight(0, size)
-
-
-class EditWindow(editwindow.EditWindow):
-    """EditWindow based on StyledTextCtrl."""
-
-    def __init__(self, editor, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER):
-        """Create EditWindow instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        self.editor = editor
-
-
-class DialogResults:
-    """DialogResults class."""
-
-    def __init__(self, returned):
-        """Create wrapper for results returned by dialog."""
-        self.returned = returned
-        self.positive = returned in (wx.ID_OK, wx.ID_YES)
-        self.text = self._asString()
-        
-
-    def __repr__(self):
-        return str(self.__dict__)
-
-    def _asString(self):
-        returned = self.returned
-        if returned == wx.ID_OK:
-            return "Ok"
-        elif returned == wx.ID_CANCEL:
-            return "Cancel"
-        elif returned == wx.ID_YES:
-            return "Yes"
-        elif returned == wx.ID_NO:
-            return "No"
-
-
-def fileDialog(parent=None, title='Open', directory='', filename='',
-               wildcard='All Files (*.*)|*.*',
-               style=wx.OPEN | wx.MULTIPLE):
-    """File dialog wrapper function."""
-    dialog = wx.FileDialog(parent, title, directory, filename,
-                           wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.paths = dialog.GetPaths()
-    else:
-        result.paths = []
-    dialog.Destroy()
-    return result
-
-
-def openSingle(parent=None, title='Open', directory='', filename='',
-               wildcard='All Files (*.*)|*.*', style=wx.OPEN):
-    """File dialog wrapper function."""
-    dialog = wx.FileDialog(parent, title, directory, filename,
-                           wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def openMultiple(parent=None, title='Open', directory='', filename='',
-                 wildcard='All Files (*.*)|*.*',
-                 style=wx.OPEN | wx.MULTIPLE):
-    """File dialog wrapper function."""
-    return fileDialog(parent, title, directory, filename, wildcard, style)
-
-
-def saveSingle(parent=None, title='Save', directory='', filename='',
-               wildcard='All Files (*.*)|*.*',
-               style=wx.SAVE | wx.HIDE_READONLY | wx.OVERWRITE_PROMPT):
-    """File dialog wrapper function."""
-    dialog = wx.FileDialog(parent, title, directory, filename,
-                           wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def directory(parent=None, message='Choose a directory', path='', style=0,
-              pos=wx.DefaultPosition, size=wx.DefaultSize):
-    """Dir dialog wrapper function."""
-    dialog = wx.DirDialog(parent, message, path, style, pos, size)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def messageDialog(parent=None, message='', title='Message box',
-                  style=wx.YES_NO | wx.CANCEL | wx.CENTRE | wx.ICON_QUESTION,
-                  pos=wx.DefaultPosition):
-    """Message dialog wrapper function."""
-    dialog = wx.MessageDialog(parent, message, title, style, pos)
-    result = DialogResults(dialog.ShowModal())
-    dialog.Destroy()
-    return result

wxPython/wx/py/editwindow.py

@@ -1,225 +0,0 @@
-"""EditWindow class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from wx import stc
-
-import keyword
-import os
-import sys
-import time
-
-import dispatcher
-from version import VERSION
-
-
-if 'wxMSW' in wx.PlatformInfo:
-    FACES = { 'times'     : 'Times New Roman',
-              'mono'      : 'Courier New',
-              'helv'      : 'Arial',
-              'lucida'    : 'Lucida Console',
-              'other'     : 'Comic Sans MS',
-              'size'      : 10,
-              'lnsize'    : 8,
-              'backcol'   : '#FFFFFF',
-              'calltipbg' : '#FFFFB8',
-              'calltipfg' : '#404040',
-            }
-
-elif 'wxGTK' in wx.PlatformInfo and 'gtk2' in wx.PlatformInfo:
-    FACES = { 'times'     : 'Serif',
-              'mono'      : 'Monospace',
-              'helv'      : 'Sans',
-              'other'     : 'new century schoolbook',
-              'size'      : 10,
-              'lnsize'    : 9,
-              'backcol'   : '#FFFFFF',
-              'calltipbg' : '#FFFFB8',
-              'calltipfg' : '#404040',
-            }
-
-elif 'wxMac' in wx.PlatformInfo:
-    FACES = { 'times'     : 'Lucida Grande',
-              'mono'      : 'Courier New',
-              'helv'      : 'Geneva',
-              'other'     : 'new century schoolbook',
-              'size'      : 13,
-              'lnsize'    : 10,
-              'backcol'   : '#FFFFFF',
-              'calltipbg' : '#FFFFB8',
-              'calltipfg' : '#404040',
-            }
-
-else: # GTK1, etc.
-    FACES = { 'times'     : 'Times',
-              'mono'      : 'Courier',
-              'helv'      : 'Helvetica',
-              'other'     : 'new century schoolbook',
-              'size'      : 12,
-              'lnsize'    : 10,
-              'backcol'   : '#FFFFFF',
-              'calltipbg' : '#FFFFB8',
-              'calltipfg' : '#404040',
-            }
-
-
-class EditWindow(stc.StyledTextCtrl):
-    """EditWindow based on StyledTextCtrl."""
-
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER):
-        """Create EditWindow instance."""
-        stc.StyledTextCtrl.__init__(self, parent, id, pos, size, style)
-        self.__config()
-        stc.EVT_STC_UPDATEUI(self, id, self.OnUpdateUI)
-        dispatcher.connect(receiver=self._fontsizer, signal='FontIncrease')
-        dispatcher.connect(receiver=self._fontsizer, signal='FontDecrease')
-        dispatcher.connect(receiver=self._fontsizer, signal='FontDefault')
-
-    def _fontsizer(self, signal):
-        """Receiver for Font* signals."""
-        size = self.GetZoom()
-        if signal == 'FontIncrease':
-            size += 1
-        elif signal == 'FontDecrease':
-            size -= 1
-        elif signal == 'FontDefault':
-            size = 0
-        self.SetZoom(size)
-
-    def __config(self):
-        """Configure shell based on user preferences."""
-        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)
-        self.SetMarginWidth(1, 40)
-
-        self.SetLexer(stc.STC_LEX_PYTHON)
-        self.SetKeyWords(0, ' '.join(keyword.kwlist))
-
-        self.setStyles(FACES)
-        self.SetViewWhiteSpace(False)
-        self.SetTabWidth(4)
-        self.SetUseTabs(False)
-        # Do we want to automatically pop up command completion options?
-        self.autoComplete = True
-        self.autoCompleteIncludeMagic = True
-        self.autoCompleteIncludeSingle = True
-        self.autoCompleteIncludeDouble = True
-        self.autoCompleteCaseInsensitive = True
-        self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive)
-        self.autoCompleteAutoHide = False
-        self.AutoCompSetAutoHide(self.autoCompleteAutoHide)
-        self.AutoCompStops(' .,;:([)]}\'"\\<>%^&+-=*/|`')
-        # Do we want to automatically pop up command argument help?
-        self.autoCallTip = True
-        self.CallTipSetBackground(FACES['calltipbg'])
-        self.CallTipSetForeground(FACES['calltipfg'])
-        self.SetWrapMode(False)
-        try:
-            self.SetEndAtLastLine(False)
-        except AttributeError:
-            pass
-
-    def setStyles(self, faces):
-        """Configure font size, typeface and color for lexer."""
-
-        # Default style
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
-                          "face:%(mono)s,size:%(size)d,back:%(backcol)s" % \
-                          faces)
-
-        self.StyleClearAll()
-
-        # Built in styles
-        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,
-                          "back:#C0C0C0,face:%(mono)s,size:%(lnsize)d" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR,
-                          "face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,
-                          "fore:#0000FF,back:#FFFF88")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
-                          "fore:#FF0000,back:#FFFF88")
-
-        # Python styles
-        self.StyleSetSpec(stc.STC_P_DEFAULT,
-                          "face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_COMMENTLINE,
-                          "fore:#007F00,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_NUMBER,
-                          "")
-        self.StyleSetSpec(stc.STC_P_STRING,
-                          "fore:#7F007F,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_CHARACTER,
-                          "fore:#7F007F,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_WORD,
-                          "fore:#00007F,bold")
-        self.StyleSetSpec(stc.STC_P_TRIPLE,
-                          "fore:#7F0000")
-        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE,
-                          "fore:#000033,back:#FFFFE8")
-        self.StyleSetSpec(stc.STC_P_CLASSNAME,
-                          "fore:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_P_DEFNAME,
-                          "fore:#007F7F,bold")
-        self.StyleSetSpec(stc.STC_P_OPERATOR,
-                          "")
-        self.StyleSetSpec(stc.STC_P_IDENTIFIER,
-                          "")
-        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK,
-                          "fore:#7F7F7F")
-        self.StyleSetSpec(stc.STC_P_STRINGEOL,
-                          "fore:#000000,face:%(mono)s,back:#E0C0E0,eolfilled" % faces)
-
-    def OnUpdateUI(self, event):
-        """Check for matching braces."""
-        # If the auto-complete window is up let it do its thing.
-        if self.AutoCompActive() or self.CallTipActive():
-            return
-        braceAtCaret = -1
-        braceOpposite = -1
-        charBefore = None
-        caretPos = self.GetCurrentPos()
-        if caretPos > 0:
-            charBefore = self.GetCharAt(caretPos - 1)
-            styleBefore = self.GetStyleAt(caretPos - 1)
-
-        # Check before.
-        if charBefore and chr(charBefore) in '[]{}()' \
-        and styleBefore == stc.STC_P_OPERATOR:
-            braceAtCaret = caretPos - 1
-
-        # Check after.
-        if braceAtCaret < 0:
-            charAfter = self.GetCharAt(caretPos)
-            styleAfter = self.GetStyleAt(caretPos)
-            if charAfter and chr(charAfter) in '[]{}()' \
-            and styleAfter == stc.STC_P_OPERATOR:
-                braceAtCaret = caretPos
-
-        if braceAtCaret >= 0:
-            braceOpposite = self.BraceMatch(braceAtCaret)
-
-        if braceAtCaret != -1  and braceOpposite == -1:
-            self.BraceBadLight(braceAtCaret)
-        else:
-            self.BraceHighlight(braceAtCaret, braceOpposite)
-
-    def CanCopy(self):
-        """Return True if text is selected and can be copied."""
-        return self.GetSelectionStart() != self.GetSelectionEnd()
-
-    def CanCut(self):
-        """Return True if text is selected and can be cut."""
-        return self.CanCopy() and self.CanEdit()
-
-    def CanEdit(self):
-        """Return True if editing should succeed."""
-        return not self.GetReadOnly()
-
-    def CanPaste(self):
-        """Return True if pasting should succeed."""
-        return stc.StyledTextCtrl.CanPaste(self) and self.CanEdit()

wxPython/wx/py/filling.py

@@ -1,332 +0,0 @@
-"""Filling is the gui tree control through which a user can navigate
-the local namespace or any object."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-import dispatcher
-import editwindow
-import inspect
-import introspect
-import keyword
-import sys
-import types
-from version import VERSION
-
-
-COMMONTYPES = [getattr(types, t) for t in dir(types) \
-               if not t.startswith('_') \
-               and t not in ('ClassType', 'InstanceType', 'ModuleType')]
-
-DOCTYPES = ('BuiltinFunctionType', 'BuiltinMethodType', 'ClassType',
-            'FunctionType', 'GeneratorType', 'InstanceType',
-            'LambdaType', 'MethodType', 'ModuleType',
-            'UnboundMethodType', 'method-wrapper')
-
-SIMPLETYPES = [getattr(types, t) for t in dir(types) \
-               if not t.startswith('_') and t not in DOCTYPES]
-
-del t
-
-try:
-    COMMONTYPES.append(type(''.__repr__))  # Method-wrapper in version 2.2.x.
-except AttributeError:
-    pass
-
-
-class FillingTree(wx.TreeCtrl):
-    """FillingTree based on TreeCtrl."""
-    
-    name = 'Filling Tree'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.TR_DEFAULT_STYLE,
-                 rootObject=None, rootLabel=None, rootIsNamespace=False,
-                 static=False):
-        """Create FillingTree instance."""
-        wx.TreeCtrl.__init__(self, parent, id, pos, size, style)
-        self.rootIsNamespace = rootIsNamespace
-        import __main__
-        if rootObject is None:
-            rootObject = __main__.__dict__
-            self.rootIsNamespace = True
-        if rootObject is __main__.__dict__ and rootLabel is None:
-            rootLabel = 'locals()'
-        if not rootLabel:
-            rootLabel = 'Ingredients'
-        rootData = wx.TreeItemData(rootObject)
-        self.item = self.root = self.AddRoot(rootLabel, -1, -1, rootData)
-        self.SetItemHasChildren(self.root, self.objHasChildren(rootObject))
-        wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding)
-        wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed)
-        wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
-        wx.EVT_TREE_ITEM_ACTIVATED(self, self.GetId(), self.OnItemActivated)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.display()
-
-    def OnItemExpanding(self, event):
-        """Add children to the item."""
-        busy = wx.BusyCursor()
-        item = event.GetItem()
-        if self.IsExpanded(item):
-            return
-        self.addChildren(item)
-#        self.SelectItem(item)
-
-    def OnItemCollapsed(self, event):
-        """Remove all children from the item."""
-        busy = wx.BusyCursor()
-        item = event.GetItem()
-#        self.CollapseAndReset(item)
-#        self.DeleteChildren(item)
-#        self.SelectItem(item)
-
-    def OnSelChanged(self, event):
-        """Display information about the item."""
-        busy = wx.BusyCursor()
-        self.item = event.GetItem()
-        self.display()
-
-    def OnItemActivated(self, event):
-        """Launch a DirFrame."""
-        item = event.GetItem()
-        text = self.getFullName(item)
-        obj = self.GetPyData(item)
-        frame = FillingFrame(parent=self, size=(600, 100), rootObject=obj,
-                             rootLabel=text, rootIsNamespace=False)
-        frame.Show()
-
-    def objHasChildren(self, obj):
-        """Return true if object has children."""
-        if self.objGetChildren(obj):
-            return True
-        else:
-            return False
-
-    def objGetChildren(self, obj):
-        """Return dictionary with attributes or contents of object."""
-        busy = wx.BusyCursor()
-        otype = type(obj)
-        if otype is types.DictType \
-        or str(otype)[17:23] == 'BTrees' and hasattr(obj, 'keys'):
-            return obj
-        d = {}
-        if otype is types.ListType or otype is types.TupleType:
-            for n in range(len(obj)):
-                key = '[' + str(n) + ']'
-                d[key] = obj[n]
-        if otype not in COMMONTYPES:
-            for key in introspect.getAttributeNames(obj):
-                # Believe it or not, some attributes can disappear,
-                # such as the exc_traceback attribute of the sys
-                # module. So this is nested in a try block.
-                try:
-                    d[key] = getattr(obj, key)
-                except:
-                    pass
-        return d
-
-    def addChildren(self, item):
-        self.DeleteChildren(item)
-        obj = self.GetPyData(item)
-        children = self.objGetChildren(obj)
-        if not children:
-            return
-        keys = children.keys()
-        keys.sort(lambda x, y: cmp(str(x).lower(), str(y).lower()))
-        for key in keys:
-            itemtext = str(key)
-            # Show string dictionary items with single quotes, except
-            # for the first level of items, if they represent a
-            # namespace.
-            if type(obj) is types.DictType \
-            and type(key) is types.StringType \
-            and (item != self.root \
-                 or (item == self.root and not self.rootIsNamespace)):
-                itemtext = repr(key)
-            child = children[key]
-            data = wx.TreeItemData(child)
-            branch = self.AppendItem(parent=item, text=itemtext, data=data)
-            self.SetItemHasChildren(branch, self.objHasChildren(child))
-
-    def display(self):
-        item = self.item
-        if self.IsExpanded(item):
-            self.addChildren(item)
-        self.setText('')
-        obj = self.GetPyData(item)
-        if wx.Platform == '__WXMSW__':
-            if obj is None: # Windows bug fix.
-                return
-        self.SetItemHasChildren(item, self.objHasChildren(obj))
-        otype = type(obj)
-        text = ''
-        text += self.getFullName(item)
-        text += '\n\nType: ' + str(otype)
-        try:
-            value = str(obj)
-        except:
-            value = ''
-        if otype is types.StringType or otype is types.UnicodeType:
-            value = repr(obj)
-        text += '\n\nValue: ' + value
-        if otype not in SIMPLETYPES:
-            try:
-                text += '\n\nDocstring:\n\n"""' + \
-                        inspect.getdoc(obj).strip() + '"""'
-            except:
-                pass
-        if otype is types.InstanceType:
-            try:
-                text += '\n\nClass Definition:\n\n' + \
-                        inspect.getsource(obj.__class__)
-            except:
-                pass
-        else:
-            try:
-                text += '\n\nSource Code:\n\n' + \
-                        inspect.getsource(obj)
-            except:
-                pass
-        self.setText(text)
-
-    def getFullName(self, item, partial=''):
-        """Return a syntactically proper name for item."""
-        name = self.GetItemText(item)
-        parent = None
-        obj = None
-        if item != self.root:
-            parent = self.GetItemParent(item)
-            obj = self.GetPyData(parent)
-        # Apply dictionary syntax to dictionary items, except the root
-        # and first level children of a namepace.
-        if (type(obj) is types.DictType \
-            or str(type(obj))[17:23] == 'BTrees' \
-            and hasattr(obj, 'keys')) \
-        and ((item != self.root and parent != self.root) \
-            or (parent == self.root and not self.rootIsNamespace)):
-            name = '[' + name + ']'
-        # Apply dot syntax to multipart names.
-        if partial:
-            if partial[0] == '[':
-                name += partial
-            else:
-                name += '.' + partial
-        # Repeat for everything but the root item
-        # and first level children of a namespace.
-        if (item != self.root and parent != self.root) \
-        or (parent == self.root and not self.rootIsNamespace):
-            name = self.getFullName(parent, partial=name)
-        return name
-
-    def setText(self, text):
-        """Display information about the current selection."""
-
-        # This method will likely be replaced by the enclosing app to
-        # do something more interesting, like write to a text control.
-        print text
-
-    def setStatusText(self, text):
-        """Display status information."""
-
-        # This method will likely be replaced by the enclosing app to
-        # do something more interesting, like write to a status bar.
-        print text
-
-
-class FillingText(editwindow.EditWindow):
-    """FillingText based on StyledTextCtrl."""
-
-    name = 'Filling Text'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
-                 static=False):
-        """Create FillingText instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        # Configure various defaults and user preferences.
-        self.SetReadOnly(True)
-        self.SetWrapMode(True)
-        self.SetMarginWidth(1, 0)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.Refresh()
-
-    def SetText(self, *args, **kwds):
-        self.SetReadOnly(False)
-        editwindow.EditWindow.SetText(self, *args, **kwds)
-        self.SetReadOnly(True)
-
-
-class Filling(wx.SplitterWindow):
-    """Filling based on wxSplitterWindow."""
-
-    name = 'Filling'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.SP_3D,
-                 name='Filling Window', rootObject=None,
-                 rootLabel=None, rootIsNamespace=False, static=False):
-        """Create a Filling instance."""
-        wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
-        self.tree = FillingTree(parent=self, rootObject=rootObject,
-                                rootLabel=rootLabel,
-                                rootIsNamespace=rootIsNamespace,
-                                static=static)
-        self.text = FillingText(parent=self, static=static)
-        self.SplitVertically(self.tree, self.text, 130)
-        self.SetMinimumPaneSize(1)
-        # Override the filling so that descriptions go to FillingText.
-        self.tree.setText = self.text.SetText
-        # Display the root item.
-##        self.tree.SelectItem(self.tree.root)
-        self.tree.display()
-
-
-class FillingFrame(wx.Frame):
-    """Frame containing the namespace tree component."""
-
-    name = 'Filling Frame'
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='PyFilling',
-                 pos=wx.DefaultPosition, size=(600, 400),
-                 style=wx.DEFAULT_FRAME_STYLE, rootObject=None,
-                 rootLabel=None, rootIsNamespace=False, static=False):
-        """Create FillingFrame instance."""
-        wx.Frame.__init__(self, parent, id, title, pos, size, style)
-        intro = 'PyFilling - The Tastiest Namespace Inspector'
-        self.CreateStatusBar()
-        self.SetStatusText(intro)
-        import images
-        self.SetIcon(images.getPyIcon())
-        self.filling = Filling(parent=self, rootObject=rootObject,
-                               rootLabel=rootLabel,
-                               rootIsNamespace=rootIsNamespace,
-                               static=static)
-        # Override so that status messages go to the status bar.
-        self.filling.tree.setStatusText = self.SetStatusText
-
-
-class App(wx.App):
-    """PyFilling standalone application."""
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.fillingFrame = FillingFrame()
-        self.fillingFrame.Show(True)
-        self.SetTopWindow(self.fillingFrame)
-        return True

wxPython/wx/py/frame.py

@@ -1,362 +0,0 @@
-"""Base frame with menu."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from version import VERSION
-
-
-ID_NEW = wx.ID_NEW
-ID_OPEN = wx.ID_OPEN
-ID_REVERT = wx.ID_REVERT
-ID_CLOSE = wx.ID_CLOSE
-ID_SAVE = wx.ID_SAVE
-ID_SAVEAS = wx.ID_SAVEAS
-ID_PRINT = wx.ID_PRINT
-ID_EXIT = wx.ID_EXIT
-ID_UNDO = wx.ID_UNDO
-ID_REDO = wx.ID_REDO
-ID_CUT = wx.ID_CUT
-ID_COPY = wx.ID_COPY
-ID_PASTE = wx.ID_PASTE
-ID_CLEAR = wx.ID_CLEAR
-ID_SELECTALL = wx.ID_SELECTALL
-ID_ABOUT = wx.ID_ABOUT
-ID_AUTOCOMP = wx.NewId()
-ID_AUTOCOMP_SHOW = wx.NewId()
-ID_AUTOCOMP_MAGIC = wx.NewId()
-ID_AUTOCOMP_SINGLE = wx.NewId()
-ID_AUTOCOMP_DOUBLE = wx.NewId()
-ID_CALLTIPS = wx.NewId()
-ID_CALLTIPS_SHOW = wx.NewId()
-ID_COPY_PLUS = wx.NewId()
-ID_NAMESPACE = wx.NewId()
-ID_PASTE_PLUS = wx.NewId()
-ID_WRAP = wx.NewId()
-ID_USEAA = wx.NewId()
-
-
-class Frame(wx.Frame):
-    """Frame with standard menu items."""
-
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='Editor',
-                 pos=wx.DefaultPosition, size=wx.DefaultSize, 
-                 style=wx.DEFAULT_FRAME_STYLE):
-        """Create a Frame instance."""
-        wx.Frame.__init__(self, parent, id, title, pos, size, style)
-        self.CreateStatusBar()
-        self.SetStatusText('Frame')
-        import images
-        self.SetIcon(images.getPyIcon())
-        self.__createMenus()
-        wx.EVT_CLOSE(self, self.OnClose)
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        self.Destroy()
-
-    def __createMenus(self):
-        m = self.fileMenu = wx.Menu()
-        m.Append(ID_NEW, '&New \tCtrl+N',
-                 'New file')
-        m.Append(ID_OPEN, '&Open... \tCtrl+O',
-                 'Open file')
-        m.AppendSeparator()
-        m.Append(ID_REVERT, '&Revert \tCtrl+R',
-                 'Revert to last saved version')
-        m.Append(ID_CLOSE, '&Close \tCtrl+W',
-                 'Close file')
-        m.AppendSeparator()
-        m.Append(ID_SAVE, '&Save... \tCtrl+S',
-                 'Save file')
-        m.Append(ID_SAVEAS, 'Save &As \tShift+Ctrl+S',
-                 'Save file with new name')
-        m.AppendSeparator()
-        m.Append(ID_PRINT, '&Print... \tCtrl+P',
-                 'Print file')
-        m.AppendSeparator()
-        m.Append(ID_NAMESPACE, '&Update Namespace \tShift+Ctrl+N',
-                 'Update namespace for autocompletion and calltips')
-        m.AppendSeparator()
-        m.Append(ID_EXIT, 'E&xit', 'Exit Program')
-
-        m = self.editMenu = wx.Menu()
-        m.Append(ID_UNDO, '&Undo \tCtrl+Z',
-                 'Undo the last action')
-        m.Append(ID_REDO, '&Redo \tCtrl+Y',
-                 'Redo the last undone action')
-        m.AppendSeparator()
-        m.Append(ID_CUT, 'Cu&t \tCtrl+X',
-                 'Cut the selection')
-        m.Append(ID_COPY, '&Copy \tCtrl+C',
-                 'Copy the selection')
-        m.Append(ID_COPY_PLUS, 'Cop&y Plus \tShift+Ctrl+C',
-                 'Copy the selection - retaining prompts')
-        m.Append(ID_PASTE, '&Paste \tCtrl+V', 'Paste from clipboard')
-        m.Append(ID_PASTE_PLUS, 'Past&e Plus \tShift+Ctrl+V',
-                 'Paste and run commands')
-        m.AppendSeparator()
-        m.Append(ID_CLEAR, 'Cle&ar',
-                 'Delete the selection')
-        m.Append(ID_SELECTALL, 'Select A&ll \tCtrl+A',
-                 'Select all text')
-
-        m = self.autocompMenu = wx.Menu()
-        m.Append(ID_AUTOCOMP_SHOW, 'Show Auto Completion',
-                 'Show auto completion list', wx.ITEM_CHECK)
-        m.Append(ID_AUTOCOMP_MAGIC, 'Include Magic Attributes',
-                 'Include attributes visible to __getattr__ and __setattr__',
-                 wx.ITEM_CHECK)
-        m.Append(ID_AUTOCOMP_SINGLE, 'Include Single Underscores',
-                 'Include attibutes prefixed by a single underscore', wx.ITEM_CHECK)
-        m.Append(ID_AUTOCOMP_DOUBLE, 'Include Double Underscores',
-                 'Include attibutes prefixed by a double underscore', wx.ITEM_CHECK)
-
-        m = self.calltipsMenu = wx.Menu()
-        m.Append(ID_CALLTIPS_SHOW, 'Show Call Tips',
-                 'Show call tips with argument signature and docstring', wx.ITEM_CHECK)
-
-        m = self.optionsMenu = wx.Menu()
-        m.AppendMenu(ID_AUTOCOMP, '&Auto Completion', self.autocompMenu,
-                     'Auto Completion Options')
-        m.AppendMenu(ID_CALLTIPS, '&Call Tips', self.calltipsMenu,
-                     'Call Tip Options')
-        m.Append(ID_WRAP, '&Wrap Lines',
-                 'Wrap lines at right edge', wx.ITEM_CHECK)
-        if wx.Platform == "__WXMAC__":
-            m.Append(ID_USEAA, '&Use AntiAliasing',
-                     'Use anti-aliased fonts', wx.ITEM_CHECK)
-
-        m = self.helpMenu = wx.Menu()
-        m.AppendSeparator()
-        m.Append(ID_ABOUT, '&About...', 'About this program')
-
-        b = self.menuBar = wx.MenuBar()
-        b.Append(self.fileMenu, '&File')
-        b.Append(self.editMenu, '&Edit')
-        b.Append(self.optionsMenu, '&Options')
-        b.Append(self.helpMenu, '&Help')
-        self.SetMenuBar(b)
-
-        wx.EVT_MENU(self, ID_NEW, self.OnFileNew)
-        wx.EVT_MENU(self, ID_OPEN, self.OnFileOpen)
-        wx.EVT_MENU(self, ID_REVERT, self.OnFileRevert)
-        wx.EVT_MENU(self, ID_CLOSE, self.OnFileClose)
-        wx.EVT_MENU(self, ID_SAVE, self.OnFileSave)
-        wx.EVT_MENU(self, ID_SAVEAS, self.OnFileSaveAs)
-        wx.EVT_MENU(self, ID_NAMESPACE, self.OnFileUpdateNamespace)
-        wx.EVT_MENU(self, ID_PRINT, self.OnFilePrint)
-        wx.EVT_MENU(self, ID_EXIT, self.OnExit)
-        wx.EVT_MENU(self, ID_UNDO, self.OnUndo)
-        wx.EVT_MENU(self, ID_REDO, self.OnRedo)
-        wx.EVT_MENU(self, ID_CUT, self.OnCut)
-        wx.EVT_MENU(self, ID_COPY, self.OnCopy)
-        wx.EVT_MENU(self, ID_COPY_PLUS, self.OnCopyPlus)
-        wx.EVT_MENU(self, ID_PASTE, self.OnPaste)
-        wx.EVT_MENU(self, ID_PASTE_PLUS, self.OnPastePlus)
-        wx.EVT_MENU(self, ID_CLEAR, self.OnClear)
-        wx.EVT_MENU(self, ID_SELECTALL, self.OnSelectAll)
-        wx.EVT_MENU(self, ID_ABOUT, self.OnAbout)
-        wx.EVT_MENU(self, ID_AUTOCOMP_SHOW, self.OnAutoCompleteShow)
-        wx.EVT_MENU(self, ID_AUTOCOMP_MAGIC, self.OnAutoCompleteMagic)
-        wx.EVT_MENU(self, ID_AUTOCOMP_SINGLE, self.OnAutoCompleteSingle)
-        wx.EVT_MENU(self, ID_AUTOCOMP_DOUBLE, self.OnAutoCompleteDouble)
-        wx.EVT_MENU(self, ID_CALLTIPS_SHOW, self.OnCallTipsShow)
-        wx.EVT_MENU(self, ID_WRAP, self.OnWrap)
-        wx.EVT_MENU(self, ID_USEAA, self.OnUseAA)
-
-        wx.EVT_UPDATE_UI(self, ID_NEW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_OPEN, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_REVERT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CLOSE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SAVE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SAVEAS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_NAMESPACE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PRINT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_UNDO, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_REDO, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CUT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_COPY, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_COPY_PLUS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PASTE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PASTE_PLUS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CLEAR, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SELECTALL, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_SHOW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_MAGIC, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_SINGLE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_DOUBLE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CALLTIPS_SHOW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_WRAP, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_USEAA, self.OnUpdateMenu)
-
-    def OnFileNew(self, event):
-        self.bufferNew()
-
-    def OnFileOpen(self, event):
-        self.bufferOpen()
-
-    def OnFileRevert(self, event):
-        self.bufferRevert()
-
-    def OnFileClose(self, event):
-        self.bufferClose()
-
-    def OnFileSave(self, event):
-        self.bufferSave()
-
-    def OnFileSaveAs(self, event):
-        self.bufferSaveAs()
-
-    def OnFileUpdateNamespace(self, event):
-        self.updateNamespace()
-
-    def OnFilePrint(self, event):
-        self.bufferPrint()
-
-    def OnExit(self, event):
-        self.Close(False)
-
-    def OnUndo(self, event):
-        win = wx.Window_FindFocus()
-        win.Undo()
-
-    def OnRedo(self, event):
-        win = wx.Window_FindFocus()
-        win.Redo()
-
-    def OnCut(self, event):
-        win = wx.Window_FindFocus()
-        win.Cut()
-
-    def OnCopy(self, event):
-        win = wx.Window_FindFocus()
-        win.Copy()
-
-    def OnCopyPlus(self, event):
-        win = wx.Window_FindFocus()
-        win.CopyWithPrompts()
-
-    def OnPaste(self, event):
-        win = wx.Window_FindFocus()
-        win.Paste()
-
-    def OnPastePlus(self, event):
-        win = wx.Window_FindFocus()
-        win.PasteAndRun()
-
-    def OnClear(self, event):
-        win = wx.Window_FindFocus()
-        win.Clear()
-
-    def OnSelectAll(self, event):
-        win = wx.Window_FindFocus()
-        win.SelectAll()
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About'
-        text = 'Your message here.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def OnAutoCompleteShow(self, event):
-        win = wx.Window_FindFocus()
-        win.autoComplete = event.IsChecked()
-
-    def OnAutoCompleteMagic(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCompleteIncludeMagic = event.IsChecked()
-
-    def OnAutoCompleteSingle(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCompleteIncludeSingle = event.IsChecked()
-
-    def OnAutoCompleteDouble(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCompleteIncludeDouble = event.IsChecked()
-
-    def OnCallTipsShow(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCallTip = event.IsChecked()
-
-    def OnWrap(self, event):
-        win = wx.Window_FindFocus()
-        win.SetWrapMode(event.IsChecked())
-
-    def OnUseAA(self, event):
-        win = wx.Window_FindFocus()
-        win.SetUseAntiAliasing(event.IsChecked())
-        
-
-    def OnUpdateMenu(self, event):
-        """Update menu items based on current status and context."""
-        win = wx.Window_FindFocus()
-        id = event.GetId()
-        event.Enable(True)
-        try:
-            if id == ID_NEW:
-                event.Enable(hasattr(self, 'bufferNew'))
-            elif id == ID_OPEN:
-                event.Enable(hasattr(self, 'bufferOpen'))
-            elif id == ID_REVERT:
-                event.Enable(hasattr(self, 'bufferRevert')
-                             and self.hasBuffer())
-            elif id == ID_CLOSE:
-                event.Enable(hasattr(self, 'bufferClose')
-                             and self.hasBuffer())
-            elif id == ID_SAVE:
-                event.Enable(hasattr(self, 'bufferSave')
-                             and self.bufferHasChanged())
-            elif id == ID_SAVEAS:
-                event.Enable(hasattr(self, 'bufferSaveAs')
-                             and self.hasBuffer())
-            elif id == ID_NAMESPACE:
-                event.Enable(hasattr(self, 'updateNamespace')
-                             and self.hasBuffer())
-            elif id == ID_PRINT:
-                event.Enable(hasattr(self, 'bufferPrint')
-                             and self.hasBuffer())
-            elif id == ID_UNDO:
-                event.Enable(win.CanUndo())
-            elif id == ID_REDO:
-                event.Enable(win.CanRedo())
-            elif id == ID_CUT:
-                event.Enable(win.CanCut())
-            elif id == ID_COPY:
-                event.Enable(win.CanCopy())
-            elif id == ID_COPY_PLUS:
-                event.Enable(win.CanCopy() and hasattr(win, 'CopyWithPrompts'))
-            elif id == ID_PASTE:
-                event.Enable(win.CanPaste())
-            elif id == ID_PASTE_PLUS:
-                event.Enable(win.CanPaste() and hasattr(win, 'PasteAndRun'))
-            elif id == ID_CLEAR:
-                event.Enable(win.CanCut())
-            elif id == ID_SELECTALL:
-                event.Enable(hasattr(win, 'SelectAll'))
-            elif id == ID_AUTOCOMP_SHOW:
-                event.Check(win.autoComplete)
-            elif id == ID_AUTOCOMP_MAGIC:
-                event.Check(win.autoCompleteIncludeMagic)
-            elif id == ID_AUTOCOMP_SINGLE:
-                event.Check(win.autoCompleteIncludeSingle)
-            elif id == ID_AUTOCOMP_DOUBLE:
-                event.Check(win.autoCompleteIncludeDouble)
-            elif id == ID_CALLTIPS_SHOW:
-                event.Check(win.autoCallTip)
-            elif id == ID_WRAP:
-                event.Check(win.GetWrapMode())
-            elif id == ID_USEAA:
-                event.Check(win.GetUseAntiAliasing())
-            else:
-                event.Enable(False)
-        except AttributeError:
-            # This menu option is not supported in the current context.
-            event.Enable(False)

wxPython/wx/py/images.py

@@ -1,72 +0,0 @@
-"""Support for icons."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-import cStringIO
-
-
-def getPyIcon():
-    icon = wx.EmptyIcon()
-    icon.CopyFromBitmap(getPyBitmap())
-    return icon
-
-def getPyBitmap():
-    return wx.BitmapFromImage(getPyImage())
-
-def getPyImage():
-    stream = cStringIO.StringIO(getPyData())
-    return wx.ImageFromStream(stream)
-
-def getPyData():
-    return \
-'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
-\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x04\
-\x95IDATx\x9c\xed\x97?lSG\x1c\xc7?\x97\x98\xd8Q\xa3\xdeY\xa2j\x06\xa4\xf7"QJ\
-\xbb<3@\x01\xa9\xc2\x0c\xa8!\x1d\x1c6\xcaB\xa8D[uI2\xf4\x8f\xe8\x103\xb4\xa2\
-,5\x0b\x03\x032C\xab\xc0\x92dh:t\xc0)*E\xcd@<Q\x01Rl\t\xd4D\xaa\xe4{R\xd0{&\
-\xa5\xd7\xe1\xfc\xec\xe7\xfciR\x08e\xe9O\xb2\xee|\xfe\xbd\xfb}~\xdf\xdf\xbd\
-\xbb\xb3PJ\xf1"\xad\xe3\x85F\xff\x1f\xe0y\x03h\xad\xcdA\xc7~\xb4\xd6f-\x9f\
-\xc4\xf3\x0c>Y\x1c#\x97\xddCUk\xf4B\x8d3\x9f\x8d\x9a\x9bU%\xe2~b\xab\xdf\x82\
-\x83N+\xd3\xe92\\\x1f\xcf\x93\xdd\x9f\xa1\xaa5\x95\xf9\n\xe7\xf3y\xe2\x10[V\
-\x82H\xe6\xd3G\x1dN\xf7\xc3\xa7\xc7a\xc0\x83\xc3\xc7\xf3\xcc\xcc\xcd\xe3(\
-\x85\xdb\xe7\xf2\xc9\xe8X\x1b\xe43+\x10\xd5\xb6\x94\x87Z\xe8\x90NU\x91I@\x00\
-\x06\xbe\x18\xb7J\x98\xca$`\x98\xb9]&{,\x8fRV\x85\xa7V@k\x9bq)o\x83+\t\xe9T\
-\xd5f\x95\x02\x91\xb4~_\r\xd9\xb6\xbaP\x03\x04n\x9f\xcbDa\xb8\t\xfe\xaf\x17a\
-<\xe3\xc8\x94lo\x9b\xd6\xa8\xf4\x80\x07\xb7o\xcd\xe0\x0c\x0e\xa2R\x8a\xb4\
-\x93n\xbal\x1a`e\xe0U\xc1\xd6\xb0\xb8\n\x99\x91"\x93\xaf\xba\xe4\x0ed\xda|6,\
-\x81\xd6\xda\x9c|\xab]\xea\xcd\x04\x8f\x9b\t\xad\nz\xa1\x02\x80\xdb\xe7R\x1a\
-\xcf\xa3\xb56\xeb\x02D5\x9e\xf8\xdc\xe1T\xff\xd3\x05\x8e\x82\x83U\xe1Z\xb1\
-\x18\x9b\xbf\x06\xacQ\x82H\xea\x01/Z@Ut\x08R\xb4$}\x16\xd3\x81A&%\xde\xee\
-\xbev\x80x\xe0]{\xb2\x1cR\xa5\xe6C*\xb5\xf1\xc4Q\xa6"e\xfbQ\x1b\x8dE\xe6\x87\
->\xaa[Q\xadi\x0b\xb0r\x8f\x9e.\xc3t\xb9\xc4]\xaf5\xf6\xfe\xdb\xddt&\x02\xfa\
-\x9c\xf5\x01\xe2A\xa2\xbeX\x01>]ntR\x12\xe3[\x00\x01\x98\x89\x11[_\xed\xafn\
-\xab\x81U\xa0\xe7I7\x00\x97o\x04\xcd\x89\x06<;\xe9\x80\x07]i\x97\xc17\x1f\
-\xd2\xd3\x91`\xe9\xaf?\x01p^Y\x06Z\n\xfau8?a\xfb]i\x97\xec\xa1\x8c\x05(|\xd8\
-N\xba\xb3\xab\x87\xfb\x8f\x97\xd8\xd9\xd5\x03\xc0\xfd\xc7K\xec\xd8\xd6\xdd\
-\xfc\xfd\xc1r\xd0\xf4\x01\xda~\x03H\xf4\x04\xd4j :\xb75\xc7\xae\xfd\xbcLW\
-\xda\xa5\xf0M\x1e\t\xcc\xcc\xcdq\xa9P@\x8c\xf5fL\xdaHF\x16g\x9a\x19\xad\xcc\
-\xee\xcb\xa3\n\xad\xa1\xda\xf1\x08\xef\xe5\x97x\xf8\xc8f\xf8\xc7\x93:\xdb;\
-\x93M\xc8\x08j\xc7\xb6n\x1e,\x07m`\x97o\x04|;>\xd1T\xc4\x17\x8a\x13\xb9\xc3\
-\x88\x01\x0fs\xa4\x9cc}\xf3A\x190\x82\x1f\xddR{-\x1bV\xfc\xd8f\xba\xbd3\xd9\
-\x06\x15\x07\xbb\xf8\xd3\x12\xdf]-"\x93\xb2\xb1C*\xde\xcd\x1d\xde\xccN(\xc1\
-\xae\x17"\xd0#+<j\x17m{\xcd\x9bj\x00.\xaf\xf0Xb\xb8\xdfA\xa6\x14\x18\x03\x06\
-\xb4o\xcf\x8d\xc4\xbervc\x86M\xdaz\x80\x00\x95T\x19?\xd0 @&%~c\xbc\xe3W\xaf\
-\xb4e\x00\xffh\xc6@\xbd\x11\xbc\xde\x1a\xfe\xef.\xa5\xa2q4\n0\x81\xad\xe9\
-\xae7<\x12\xaf\xf5\xc2hy\xaa\xe97\x9cS\\\x98\xb2\x0e\x03\xb1\xcdhW\xdaC\x1a\
-\xa0\xa2\xa0\x0e"\x14`\xb0Y\x85\x1b\x1f\x12\xaa7\x03)\xd9\x84\xa8\xccW\xb8{\
-\xa7L\xe2\xde\x02\x94\xc6Gp_\xcf\x80\x90\x98\xd0g\xf4\xac\x82Pc\x82\x1a\xd5\
-\x10\x08}&\xa7J\xcc\xde.1]m\x80\xf6+\xee\xfd\xae\x9bo\xc4\xf0;\x80\xef\x90\
-\x0e\x04\x06`Q!\x02\x05\xc2 \xb5\xc2\x95\x15d\xb4C&[\xf7\xd2\x04\x80\xbb\xdb\
-\x9e\xd1\x8e\x02\x90\xd8\xd4$ I\x87\x80\xf1\xf1\xdc!4\xc3\x88\x94}\xd8,TH\
-\xbb.5m\xf0C\x9f3\x1f\r\x01\x96.\x82\x1a9\xe9Q\xb8\xd2\xf8\xf25\x0c\xbe\xe7#\
-\x92\x12\x1d[\x03\t\x00E\xf4\xa6\t\xaaZ7`$\x18\x90\xf8\xf8\x80JK\x94\xa1\x01\
-\x07\xb8\x0e~X\xc3\xed\x16\xf8)\xf8~j\x12B\rI\x89_\xf7!0 \x04\xf9Q\xc0\x18\
-\x0c\xd1i\xea\x13\xb7\x04\xc0\x89\x93C\xabj\xb6\xf7@\x96\xd9_J|0:\x86R\n\xb7\
-\xd7@\xaa%\x9d\xa3$\xba.\x90RA]\xe3\x87\x1a\x89\xdd\xefeR\xc2\x1a\'\xa8\x1f\
-\x82\x0e-@m\xd1\xde\x076\xbc\x15\x97~(\x9a\x89b\x9e\xd9[s\xab!\xf7g\xd6\x1c\
-\x8f\xdb\xbel\x8e\xa1S\xc7\xda\xc6\xe6\xee\xccs\xe9\xdcYnV\x95\xd8\xf2?&q+\
-\x9c\x1b1\xf3\xbf\xcd3{\xfdJ\xdb\xf8\xde\xfd\x19.\\\xad\x08\x80\xbf\x01\xd1\
-\x86\xfa\x8b\xc7\xc0\xc8\xb7\x00\x00\x00\x00IEND\xaeB`\x82' 

wxPython/wx/py/interpreter.py

@@ -1,126 +0,0 @@
-"""Interpreter executes Python commands."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-import sys
-from code import InteractiveInterpreter
-import dispatcher
-import introspect
-import wx
-
-class Interpreter(InteractiveInterpreter):
-    """Interpreter based on code.InteractiveInterpreter."""
-    
-    revision = __revision__
-    
-    def __init__(self, locals=None, rawin=None, 
-                 stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
-        """Create an interactive interpreter object."""
-        InteractiveInterpreter.__init__(self, locals=locals)
-        self.stdin = stdin
-        self.stdout = stdout
-        self.stderr = stderr
-        if rawin:
-            import __builtin__
-            __builtin__.raw_input = rawin
-            del __builtin__
-        copyright = 'Type "help", "copyright", "credits" or "license"'
-        copyright += ' for more information.'
-        self.introText = 'Python %s on %s%s%s' % \
-                         (sys.version, sys.platform, os.linesep, copyright)
-        try:
-            sys.ps1
-        except AttributeError:
-            sys.ps1 = '>>> '
-        try:
-            sys.ps2
-        except AttributeError:
-            sys.ps2 = '... '
-        self.more = 0
-        # List of lists to support recursive push().
-        self.commandBuffer = []
-        self.startupScript = os.environ.get('PYTHONSTARTUP')
-
-    def push(self, command):
-        """Send command to the interpreter to be executed.
-        
-        Because this may be called recursively, we append a new list
-        onto the commandBuffer list and then append commands into
-        that.  If the passed in command is part of a multi-line
-        command we keep appending the pieces to the last list in
-        commandBuffer until we have a complete command. If not, we
-        delete that last list."""
-
-        # In case the command is unicode try encoding it
-        if type(command) == unicode:
-            try:
-                command = command.encode(wx.GetDefaultPyEncoding())
-            except UnicodeEncodeError:
-                pass # otherwise leave it alone
-                
-        if not self.more:
-            try: del self.commandBuffer[-1]
-            except IndexError: pass
-        if not self.more: self.commandBuffer.append([])
-        self.commandBuffer[-1].append(command)
-        source = '\n'.join(self.commandBuffer[-1])
-        more = self.more = self.runsource(source)
-        dispatcher.send(signal='Interpreter.push', sender=self,
-                        command=command, more=more, source=source)
-        return more
-        
-    def runsource(self, source):
-        """Compile and run source code in the interpreter."""
-        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
-        sys.stdin, sys.stdout, sys.stderr = \
-                   self.stdin, self.stdout, self.stderr
-        more = InteractiveInterpreter.runsource(self, source)
-        # If sys.std* is still what we set it to, then restore it.
-        # But, if the executed source changed sys.std*, assume it was
-        # meant to be changed and leave it. Power to the people.
-        if sys.stdin == self.stdin:
-            sys.stdin = stdin
-        if sys.stdout == self.stdout:
-            sys.stdout = stdout
-        if sys.stderr == self.stderr:
-            sys.stderr = stderr
-        return more
-        
-    def getAutoCompleteKeys(self):
-        """Return list of auto-completion keycodes."""
-        return [ord('.')]
-
-    def getAutoCompleteList(self, command='', *args, **kwds):
-        """Return list of auto-completion options for a command.
-        
-        The list of options will be based on the locals namespace."""
-        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
-        sys.stdin, sys.stdout, sys.stderr = \
-                   self.stdin, self.stdout, self.stderr
-        l = introspect.getAutoCompleteList(command, self.locals,
-                                           *args, **kwds)
-        sys.stdin, sys.stdout, sys.stderr = stdin, stdout, stderr
-        return l
-
-    def getCallTip(self, command='', *args, **kwds):
-        """Return call tip text for a command.
-        
-        Call tip information will be based on the locals namespace."""
-        return introspect.getCallTip(command, self.locals, *args, **kwds)
-
-
-class InterpreterAlaCarte(Interpreter):
-    """Demo Interpreter."""
-    
-    def __init__(self, locals, rawin, stdin, stdout, stderr, 
-                 ps1='main prompt', ps2='continuation prompt'):
-        """Create an interactive interpreter object."""
-        Interpreter.__init__(self, locals=locals, rawin=rawin, 
-                             stdin=stdin, stdout=stdout, stderr=stderr)
-        sys.ps1 = ps1
-        sys.ps2 = ps2
-
-   

wxPython/wx/py/introspect.py

@@ -1,382 +0,0 @@
-"""Provides a variety of introspective-type support functions for
-things like call tips and command auto completion."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from __future__ import nested_scopes
-
-import cStringIO
-import inspect
-import sys
-import tokenize
-import types
-import wx
-
-def getAutoCompleteList(command='', locals=None, includeMagic=1, 
-                        includeSingle=1, includeDouble=1):
-    """Return list of auto-completion options for command.
-    
-    The list of options will be based on the locals namespace."""
-    attributes = []
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='.')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        pass
-    else:
-        attributes = getAttributeNames(object, includeMagic, 
-                                       includeSingle, includeDouble)
-    return attributes
-    
-def getAttributeNames(object, includeMagic=1, includeSingle=1,
-                      includeDouble=1):
-    """Return list of unique attributes, including inherited, for object."""
-    attributes = []
-    dict = {}
-    if not hasattrAlwaysReturnsTrue(object):
-        # Add some attributes that don't always get picked up.
-        special_attrs = ['__bases__', '__class__', '__dict__', '__name__',
-                         'func_closure', 'func_code', 'func_defaults',
-                         'func_dict', 'func_doc', 'func_globals', 'func_name']
-        attributes += [attr for attr in special_attrs \
-                       if hasattr(object, attr)]
-    if includeMagic:
-        try: attributes += object._getAttributeNames()
-        except: pass
-    # Get all attribute names.
-    str_type = str(type(object))
-    if str_type == "<type 'array'>":
-        attributes += dir(object)
-    else:
-        attrdict = getAllAttributeNames(object)
-        # Store the object's dir.
-        object_dir = dir(object)
-        for (obj_type_name, technique, count), attrlist in attrdict.items():
-            # This complexity is necessary to avoid accessing all the
-            # attributes of the object.  This is very handy for objects
-            # whose attributes are lazily evaluated.
-            if type(object).__name__ == obj_type_name and technique == 'dir':
-                attributes += attrlist
-            else:
-                attributes += [attr for attr in attrlist \
-                               if attr not in object_dir and hasattr(object, attr)]
-            
-    # Remove duplicates from the attribute list.
-    for item in attributes:
-        dict[item] = None
-    attributes = dict.keys()
-    # new-style swig wrappings can result in non-string attributes
-    # e.g. ITK http://www.itk.org/
-    attributes = [attribute for attribute in attributes \
-                  if type(attribute) == str]
-    attributes.sort(lambda x, y: cmp(x.upper(), y.upper()))
-    if not includeSingle:
-        attributes = filter(lambda item: item[0]!='_' \
-                            or item[1]=='_', attributes)
-    if not includeDouble:
-        attributes = filter(lambda item: item[:2]!='__', attributes)
-    return attributes
-
-def hasattrAlwaysReturnsTrue(object):
-    return hasattr(object, 'bogu5_123_aTTri8ute')
-
-def getAllAttributeNames(object):
-    """Return dict of all attributes, including inherited, for an object.
-    
-    Recursively walk through a class and all base classes.
-    """
-    attrdict = {}  # (object, technique, count): [list of attributes]
-    # !!!
-    # Do Not use hasattr() as a test anywhere in this function,
-    # because it is unreliable with remote objects: xmlrpc, soap, etc.
-    # They always return true for hasattr().
-    # !!!
-    try:
-        # This could(?) fail if the type is poorly defined without
-        # even a name.
-        key = type(object).__name__
-    except:
-        key = 'anonymous'
-    # Wake up sleepy objects - a hack for ZODB objects in "ghost" state.
-    wakeupcall = dir(object)
-    del wakeupcall
-    # Get attributes available through the normal convention.
-    attributes = dir(object)
-    attrdict[(key, 'dir', len(attributes))] = attributes
-    # Get attributes from the object's dictionary, if it has one.
-    try:
-        attributes = object.__dict__.keys()
-        attributes.sort()
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        attrdict[(key, '__dict__', len(attributes))] = attributes
-    # For a class instance, get the attributes for the class.
-    try:
-        klass = object.__class__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if klass is object:
-            # Break a circular reference. This happens with extension
-            # classes.
-            pass
-        else:
-            attrdict.update(getAllAttributeNames(klass))
-    # Also get attributes from any and all parent classes.
-    try:
-        bases = object.__bases__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if isinstance(bases, types.TupleType):
-            for base in bases:
-                if type(base) is types.TypeType:
-                    # Break a circular reference. Happens in Python 2.2.
-                    pass
-                else:
-                    attrdict.update(getAllAttributeNames(base))
-    return attrdict
-
-def getCallTip(command='', locals=None):
-    """For a command, return a tuple of object name, argspec, tip text.
-    
-    The call tip information will be based on the locals namespace."""
-    calltip = ('', '', '')  # object name, argspec, tip text.
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='(')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        return calltip
-    name = ''
-    object, dropSelf = getBaseObject(object)
-    try:
-        name = object.__name__
-    except AttributeError:
-        pass
-    tip1 = ''
-    argspec = ''
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        pass
-    elif inspect.isfunction(object):
-        # tip1 is a string like: "getCallTip(command='', locals=None)"
-        argspec = apply(inspect.formatargspec, inspect.getargspec(object))
-        if dropSelf:
-            # The first parameter to a method is a reference to an
-            # instance, usually coded as "self", and is usually passed
-            # automatically by Python; therefore we want to drop it.
-            temp = argspec.split(',')
-            if len(temp) == 1:  # No other arguments.
-                argspec = '()'
-            elif temp[0][:2] == '(*': # first param is like *args, not self
-                pass 
-            else:  # Drop the first argument.
-                argspec = '(' + ','.join(temp[1:]).lstrip()
-        tip1 = name + argspec
-    doc = ''
-    if callable(object):
-        try:
-            doc = inspect.getdoc(object)
-        except:
-            pass
-    if doc:
-        # tip2 is the first separated line of the docstring, like:
-        # "Return call tip text for a command."
-        # tip3 is the rest of the docstring, like:
-        # "The call tip information will be based on ... <snip>
-        firstline = doc.split('\n')[0].lstrip()
-        if tip1 == firstline or firstline[:len(name)+1] == name+'(':
-            tip1 = ''
-        else:
-            tip1 += '\n\n'
-        docpieces = doc.split('\n\n')
-        tip2 = docpieces[0]
-        tip3 = '\n\n'.join(docpieces[1:])
-        tip = '%s%s\n\n%s' % (tip1, tip2, tip3)
-    else:
-        tip = tip1
-    calltip = (name, argspec[1:-1], tip.strip())
-    return calltip
-
-def getRoot(command, terminator=None):
-    """Return the rightmost root portion of an arbitrary Python command.
-    
-    Return only the root portion that can be eval()'d without side
-    effects.  The command would normally terminate with a '(' or
-    '.'. The terminator and anything after the terminator will be
-    dropped."""
-    command = command.split('\n')[-1]
-    if command.startswith(sys.ps2):
-        command = command[len(sys.ps2):]
-    command = command.lstrip()
-    command = rtrimTerminus(command, terminator)
-    tokens = getTokens(command)
-    if not tokens:
-        return ''
-    if tokens[-1][0] is tokenize.ENDMARKER:
-        # Remove the end marker.
-        del tokens[-1]
-    if not tokens:
-        return ''
-    if terminator == '.' and \
-           (tokens[-1][1] <> '.' or tokens[-1][0] is not tokenize.OP):
-        # Trap decimals in numbers, versus the dot operator.
-        return ''
-    else:
-        # Strip off the terminator.
-        if terminator and command.endswith(terminator):
-            size = 0 - len(terminator)
-            command = command[:size]
-    command = command.rstrip()
-    tokens = getTokens(command)
-    tokens.reverse()
-    line = ''
-    start = None
-    prefix = ''
-    laststring = '.'
-    emptyTypes = ('[]', '()', '{}')
-    for token in tokens:
-        tokentype = token[0]
-        tokenstring = token[1]
-        line = token[4]
-        if tokentype is tokenize.ENDMARKER:
-            continue
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        and laststring != '.':
-            # We've reached something that's not part of the root.
-            if prefix and line[token[3][1]] != ' ':
-                # If it doesn't have a space after it, remove the prefix.
-                prefix = ''
-            break
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        or (tokentype is tokenize.OP and tokenstring == '.'):
-            if prefix:
-                # The prefix isn't valid because it comes after a dot.
-                prefix = ''
-                break
-            else:
-                # start represents the last known good point in the line.
-                start = token[2][1]
-        elif len(tokenstring) == 1 and tokenstring in ('[({])}'):
-            # Remember, we're working backwords.
-            # So prefix += tokenstring would be wrong.
-            if prefix in emptyTypes and tokenstring in ('[({'):
-                # We've already got an empty type identified so now we
-                # are in a nested situation and we can break out with
-                # what we've got.
-                break
-            else:
-                prefix = tokenstring + prefix
-        else:
-            # We've reached something that's not part of the root.
-            break
-        laststring = tokenstring
-    if start is None:
-        start = len(line)
-    root = line[start:]
-    if prefix in emptyTypes:
-        # Empty types are safe to be eval()'d and introspected.
-        root = prefix + root
-    return root    
-
-def getTokens(command):
-    """Return list of token tuples for command."""
-
-    # In case the command is unicode try encoding it
-    if type(command) == unicode:
-        try:
-            command = command.encode(wx.GetDefaultPyEncoding())
-        except UnicodeEncodeError:
-            pass # otherwise leave it alone
-                
-    f = cStringIO.StringIO(command)
-    # tokens is a list of token tuples, each looking like: 
-    # (type, string, (srow, scol), (erow, ecol), line)
-    tokens = []
-    # Can't use list comprehension:
-    #   tokens = [token for token in tokenize.generate_tokens(f.readline)]
-    # because of need to append as much as possible before TokenError.
-    try:
-##        This code wasn't backward compatible with Python 2.1.3.
-##
-##        for token in tokenize.generate_tokens(f.readline):
-##            tokens.append(token)
-
-        # This works with Python 2.1.3 (with nested_scopes).
-        def eater(*args):
-            tokens.append(args)
-        tokenize.tokenize_loop(f.readline, eater)
-    except tokenize.TokenError:
-        # This is due to a premature EOF, which we expect since we are
-        # feeding in fragments of Python code.
-        pass
-    return tokens    
-
-def rtrimTerminus(command, terminator=None):
-    """Return command minus anything that follows the final terminator."""
-    if terminator:
-        pieces = command.split(terminator)
-        if len(pieces) > 1:
-            command = terminator.join(pieces[:-1]) + terminator
-    return command
-
-def getBaseObject(object):
-    """Return base object and dropSelf indicator for an object."""
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        dropSelf = 0
-    elif inspect.ismethod(object):
-        # Get the function from the object otherwise
-        # inspect.getargspec() complains that the object isn't a
-        # Python function.
-        try:
-            if object.im_self is None:
-                # This is an unbound method so we do not drop self
-                # from the argspec, since an instance must be passed
-                # as the first arg.
-                dropSelf = 0
-            else:
-                dropSelf = 1
-            object = object.im_func
-        except AttributeError:
-            dropSelf = 0
-    elif inspect.isclass(object):
-        # Get the __init__ method function for the class.
-        constructor = getConstructor(object)
-        if constructor is not None:
-            object = constructor
-            dropSelf = 1
-        else:
-            dropSelf = 0
-    elif callable(object):
-        # Get the __call__ method instead.
-        try:
-            object = object.__call__.im_func
-            dropSelf = 1
-        except AttributeError:
-            dropSelf = 0
-    else:
-        dropSelf = 0
-    return object, dropSelf
-
-def getConstructor(object):
-    """Return constructor for class object, or None if there isn't one."""
-    try:
-        return object.__init__.im_func
-    except AttributeError:
-        for base in object.__bases__:
-            constructor = getConstructor(base)
-            if constructor is not None:
-                return constructor
-    return None

wxPython/wx/py/pseudo.py

@@ -1,101 +0,0 @@
-"""Provides a variety of classes to create pseudo keywords and pseudo files."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-class PseudoKeyword:
-    """A callable class that calls a method passed as a parameter.
-
-    Good for creating a pseudo keyword in the python runtime
-    environment. The keyword is really an object that has a repr()
-    that calls itself which calls the method that was passed in the
-    init of the object. All this just to avoid having to type in the
-    closing parens on a method. So, for example:
-
-        >>> quit = PseudoKeyword(SomeObject.someMethod)
-        >>> quit
-
-    SomeObject.someMethod gets executed as if it had been called
-    directly and the user didn't have to type the parens, like
-    'quit()'. This technique is most applicable for pseudo keywords
-    like quit, exit and help.
-
-    If SomeObject.someMethod can take parameters, they can still be
-    passed by using the keyword in the traditional way with parens."""
-
-    def __init__(self, method):
-        """Create a callable object that executes method when called."""
-
-        if callable(method):
-            self.method = method
-        else:
-            raise ValueError, 'method must be callable'
-
-    def __call__(self, *args, **kwds):
-        self.method(*args, **kwds)
-
-    def __repr__(self):
-        self()
-        return ''
-
-
-class PseudoFile:
-
-    def __init__(self):
-        """Create a file-like object."""
-        pass
-
-    def readline(self):
-        pass
-
-    def write(self, s):
-        pass
-
-    def writelines(self, l):
-        map(self.write, l)
-
-    def flush(self):
-        pass
-
-    def isatty(self):
-        pass
-
-
-class PseudoFileIn(PseudoFile):
-
-    def __init__(self, readline, readlines=None):
-        if callable(readline):
-            self.readline = readline
-        else:
-            raise ValueError, 'readline must be callable'
-        if callable(readlines):
-            self.readlines = readlines
-
-    def isatty(self):
-        return 1
-        
-        
-class PseudoFileOut(PseudoFile):
-
-    def __init__(self, write):
-        if callable(write):
-            self.write = write
-        else:
-            raise ValueError, 'write must be callable'
-
-    def isatty(self):
-        return 1
-
-
-class PseudoFileErr(PseudoFile):
-
-    def __init__(self, write):
-        if callable(write):
-            self.write = write
-        else:
-            raise ValueError, 'write must be callable'
-
-    def isatty(self):
-        return 1

wxPython/wx/py/tests/test_interpreter.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import interpreter
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = interpreter
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.Interpreter)
-        self.assert_(module.Interpreter.push)
-        self.assert_(module.Interpreter.runsource)
-        self.assert_(module.Interpreter.getAutoCompleteList)
-        self.assert_(module.Interpreter.getCallTip)
-        self.assert_(module.InterpreterAlaCarte)
-
-
-class InterpreterTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.output = ''
-        self.i = interpreter.Interpreter(stdout=self)
-
-    def write(self, text):
-        """Capture output from self.i.push()."""
-        self.output += text
-
-    def tearDown(self):
-        self.output = ''
-        self.i = None
-        del self.i
-
-    def test_more(self):
-        self.assertEqual(self.i.push('dir()'), 0)
-        self.assertEqual(self.i.push('for n in range(3):'), 1)
-
-    def test_push(self):
-        values = (
-        ('dir', '<built-in function dir>'),
-        ('dir()', "['__builtins__', '__doc__', '__name__']"),
-        ('2 + 2', '4'),
-        ('d = {}', ''),
-        ('d', '{}'),
-        ('del d', ''),
-        ('len([4,5,6])', '3'),
-        )
-        for input, output in values:
-            if output: output += '\n'
-            self.i.push(input)
-            self.assertEqual(self.output, output)
-            self.output = ''
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wx/py/tests/test_introspect.py

@@ -1,862 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import introspect
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = introspect
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.getAllAttributeNames)
-        self.assert_(module.getAttributeNames)
-        self.assert_(module.getAutoCompleteList)
-        self.assert_(module.getBaseObject)
-        self.assert_(module.getCallTip)
-        self.assert_(module.getConstructor)
-        self.assert_(module.getRoot)
-        self.assert_(module.rtrimTerminus)
-
-
-class RtrimTerminusTestCase(unittest.TestCase):
-
-    def test_rtrimTerminus(self):
-        values = (
-            ('', '', ''),
-            ('', None, ''),
-            ('', '.', ''),
-            ('', '(', ''),
-            
-            ('.', '', '.'),
-            ('.', None, '.'),
-            ('.', '.', '.'),
-            ('.', '(', '.'),
-            
-            ('(', '', '('),
-            ('(', None, '('),
-            ('(', '.', '('),
-            ('(', '(', '('),
-            
-            ('spam', '', 'spam'),
-            ('spam', None, 'spam'),
-            ('spam', '.', 'spam'),
-            ('spam', '(', 'spam'),
-            
-            ('spam.', '', 'spam.'),
-            ('spam.', None, 'spam.'),
-            ('spam.', '.', 'spam.'),
-            ('spam.', '(', 'spam.'),
-            
-            ('spam(', '', 'spam('),
-            ('spam(', None, 'spam('),
-            ('spam(', '.', 'spam('),
-            ('spam(', '(', 'spam('),
-            
-            ('spam.eggs', '.', 'spam.'),
-            ('spam.eggs.', '.', 'spam.eggs.'),
-            ('spam.eggs(', '(', 'spam.eggs('),
-            ('spam.eggs.', '(', 'spam.eggs.'),
-            ('spam.eggs(', '.', 'spam.'),
-            
-            ('x = spam.', '.', 'x = spam.'),
-            ('x = spam.eggs', '.', 'x = spam.'),
-            ('x = spam.eggs.', '.', 'x = spam.eggs.'),
-            ('x = spam.eggs(', '(', 'x = spam.eggs('),
-        )
-        for input, terminator, output in values:
-            result = introspect.rtrimTerminus(input, terminator)
-            self.assertEqual(result, output,
-                             ':in: %r :t: %r :out: %r :result: %r' %
-                             (input, terminator, output, result))
-
-
-class GetRootTestCase(unittest.TestCase):
-
-    def _checkRoot(self, input, terminator, output):
-        root = introspect.getRoot(command=input, terminator=terminator)
-        self.assertEqual(root, output,
-                         ':in: %r :t: %r :out: %r :root: %r' %
-                         (input, terminator, output, root))
-
-    def test_getRoot(self):
-        values = (
-            ('', '', ''),
-            ('', None, ''),
-            ('', '.', ''),
-            ('', '(', ''),
-            
-            ('.', '', '.'),
-            ('.', None, '.'),
-            ('.', '.', ''),
-            ('.', '(', '.'),
-            
-            ('(', '', ''),
-            ('(', None, ''),
-            ('(', '.', ''),
-            ('(', '(', ''),
-            
-            ('spam', '', 'spam'),
-            ('spam', None, 'spam'),
-            ('spam', '.', ''),
-            ('spam', '(', 'spam'),
-            
-            ('spam.', '', 'spam.'),
-            ('spam.', None, 'spam.'),
-            ('spam.', '.', 'spam'),
-            ('spam.', '(', 'spam.'),
-            
-            ('spam(', '', ''),
-            ('spam(', None, ''),
-            ('spam(', '.', ''),
-            ('spam(', '(', 'spam'),
-            
-            ('spam.eggs', '.', 'spam'),
-            ('spam.eggs.', '.', 'spam.eggs'),
-            ('spam.eggs(', '(', 'spam.eggs'),
-            ('spam.eggs.', '(', 'spam.eggs.'),
-            ('spam.eggs(', '.', 'spam'),
-            
-            ('x = spam.', '.', 'spam'),
-            ('x = spam.eggs', '.', 'spam'),
-            ('x = spam.eggs.', '.', 'spam.eggs'),
-            ('x = spam.eggs(', '(', 'spam.eggs'),
-
-            ('for n in range(3):\n    d.', '.', 'd'),
-            ('for n in range(3):\n...    d.', '.', 'd'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-    def test_getRoot_Advanced(self):
-        values = (
-            ('spam_', '', 'spam_'),
-            ('spam_', None, 'spam_'),
-            ('spam_', '.', ''),
-            ('spam_', '(', 'spam_'),
-            
-            ('_spam', '', '_spam'),
-            ('_spam', None, '_spam'),
-            ('_spam', '.', ''),
-            ('_spam', '(', '_spam'),
-            
-            ('spam_eggs', '', 'spam_eggs'),
-            ('spam_eggs', None, 'spam_eggs'),
-            ('spam_eggs', '.', ''),
-            ('spam_eggs', '(', 'spam_eggs'),
-            
-            ('spam123', '', 'spam123'),
-            ('spam123', None, 'spam123'),
-            ('spam123', '.', ''),
-            ('spam123', '(', 'spam123'),
-
-            ('spam_123', '', 'spam_123'),
-            ('spam_123', None, 'spam_123'),
-            ('spam_123', '.', ''),
-            ('spam_123', '(', 'spam_123'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-## The original intent was to detect when we were inside a string.
-## That has proven to be very difficult, for little benefit.
-## The fact that autocomplete or calltips might be triggered inside
-## a string is not a big deal. Sometimes it is even helpful.
-
-##    def test_getRoot_InsideStrings(self):
-##        values = (
-##            ('x = ".', '.', ''),
-##            ("x = '.", '.', ''),
-##            ('x = """.', '.', ''),
-##            ("x = '''.", '.', ''),
-##
-##            ('x = "(', '(', ''),
-##            ("x = '(", '(', ''),
-##            ('x = """(', '(', ''),
-##            ("x = '''(", '(', ''),
-##
-##            ('x = "spam', '.', ''),
-##            ('x = "spam.', '.', ''),
-##            ("x = 'spam.", '.', ''),
-##            ('x = """spam.', '.', ''),
-##            ("x = '''spam.", '.', ''),
-##            
-##            ('x = "spam', '(', ''),
-##            ('x = "spam(', '(', ''),
-##            ("x = 'spam(", '(', ''),
-##            ('x = """spam(', '(', ''),
-##            ("x = '''spam(", '(', ''),
-##            
-##            ('x = "spam.eggs.', '.', ''),
-##            ("x = 'spam.eggs.", '.', ''),
-##            ('x = """spam.eggs.', '.', ''),
-##            ("x = '''spam.eggs.", '.', ''),
-##            
-##            ('x = "spam.eggs(', '(', ''),
-##            ("x = 'spam.eggs(", '(', ''),
-##            ('x = """spam.eggs(', '(', ''),
-##            ("x = '''spam.eggs(", '(', ''),
-##        )
-##        for input, terminator, output in values:
-##            self._checkRoot(input, terminator, output)
-
-    def test_getRoot_EmptyTypes(self):
-        values = (
-            ("''.", '.', "''"),
-            ('"".', '.', '""'),
-            ('"""""".', '.', '""""""'),
-            ("''''''.", '.', "''''''"),
-
-            ('[].', '.', '[]'),
-            ('().', '.', '()'),
-            ('{}.', '.', '{}'),
-            
-            ('[](', '(', '[]'),
-            ('()(', '(', '()'),
-            ('{}(', '(', '{}'),
-            
-            ("x = ''.", '.', "''"),
-            ('x = "".', '.', '""'),
-            ('x = """""".', '.', '""""""'),
-            ("x = ''''''.", '.', "''''''"),
-
-            ('x = [].', '.', '[]'),
-            ('x = ().', '.', '()'),
-            ('x = {}.', '.', '{}'),
-            
-            ('x = [](', '(', '[]'),
-            ('x = ()(', '(', '()'),
-            ('x = {}(', '(', '{}'),
-
-            ('print [].', '.', '[]'),
-            ('print ().', '.', '()'),
-            ('print {}.', '.', '{}'),
-            
-            ('print [](', '(', '[]'),
-            ('print ()(', '(', '()'),
-            ('print {}(', '(', '{}'),
-
-            ("''.attr.", '.', "''.attr"),
-            ('"".attr.', '.', '"".attr'),
-            ('"""""".attr.', '.', '"""""".attr'),
-            ("''''''.attr.", '.', "''''''.attr"),
-
-            ('[].attr.', '.', '[].attr'),
-            ('().attr.', '.', '().attr'),
-            ('{}.attr.', '.', '{}.attr'),
-            
-            ('[].attr(', '(', '[].attr'),
-            ('().attr(', '(', '().attr'),
-            ('{}.attr(', '(', '{}.attr'),
-
-            ('spam().', '.', ''),
-            ('spam_().', '.', ''),
-            ('spam5().', '.', ''),
-            ('spam[]().', '.', ''),
-            ('spam()[].', '.', ''),
-            ('spam[]{}.', '.', ''),
-
-            ("spam(''.", '.', "''"),
-            ('spam("".', '.', '""'),
-            ('spam("""""".', '.', '""""""'),
-            ("spam(''''''.", '.', "''''''"),
-
-            ('spam([].', '.', '[]'),
-            ('spam(().', '.', '()'),
-            ('spam({}.', '.', '{}'),
-            ('spam[[].', '.', '[]'),
-            ('spam[().', '.', '()'),
-            ('spam[{}.', '.', '{}'),
-            ('x = {[].', '.', '[]'),
-            ('x = {().', '.', '()'),
-            ('x = {{}.', '.', '{}'),
-
-            ('spam,[].', '.', '[]'),
-            ('spam+[].', '.', '[]'),
-            ('spam-[].', '.', '[]'),
-            ('spam*[].', '.', '[]'),
-            ('spam/[].', '.', '[]'),
-            ('spam=[].', '.', '[]'),
-            ('spam%[].', '.', '[]'),
-            ('spam<[].', '.', '[]'),
-            ('spam>[].', '.', '[]'),
-            ('spam&[].', '.', '[]'),
-            ('spam|[].', '.', '[]'),
-            ('spam^[].', '.', '[]'),
-            ('spam~[].', '.', '[]'),
-            ('spam:[].', '.', '[]'),
-
-            ('spam,().', '.', '()'),
-            ('spam+().', '.', '()'),
-            ('spam-().', '.', '()'),
-            ('spam*().', '.', '()'),
-            ('spam/().', '.', '()'),
-            ('spam=().', '.', '()'),
-            ('spam%().', '.', '()'),
-            ('spam<().', '.', '()'),
-            ('spam>().', '.', '()'),
-            ('spam&().', '.', '()'),
-            ('spam|().', '.', '()'),
-            ('spam^().', '.', '()'),
-            ('spam~().', '.', '()'),
-            ('spam:().', '.', '()'),
-
-            ('spam,{}.', '.', '{}'),
-            ('spam+{}.', '.', '{}'),
-            ('spam-{}.', '.', '{}'),
-            ('spam*{}.', '.', '{}'),
-            ('spam/{}.', '.', '{}'),
-            ('spam={}.', '.', '{}'),
-            ('spam%{}.', '.', '{}'),
-            ('spam<{}.', '.', '{}'),
-            ('spam>{}.', '.', '{}'),
-            ('spam&{}.', '.', '{}'),
-            ('spam|{}.', '.', '{}'),
-            ('spam^{}.', '.', '{}'),
-            ('spam~{}.', '.', '{}'),
-            ('spam:{}.', '.', '{}'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-
-# Support for GetBaseObjectTestCase and GetAttributeNamesTestCase.
-
-class Foo:
-    def __init__(self):
-        pass
-
-    def __del__(self):
-        pass
-
-    def _private(self):
-        pass
-
-class Bar:
-    pass
-
-class Spam:
-    def __call__(self):
-        pass
-
-    def foo(self):
-        pass
-
-    def bar(spam):
-        # It shouldn't matter what we call "self".
-        pass
-
-    def eggs(self):
-        pass
-
-def ham(eggs):
-    pass
-
-class GetBaseObjectTestCase(unittest.TestCase):
-
-    def test_getBaseObject(self):
-        spam = Spam()
-        eggs = Spam.eggs
-        listappend = [].append
-        spamda = lambda: None
-        values = (
-            ('spam', 'spam', 0),
-            (123, 123, 0),
-            (12.3, 12.3, 0),
-            ([], [], 0),
-            ((), (), 0),
-            ({}, {}, 0),
-            # Builtin function.
-            (len, len, 0),
-            # Builtin method.
-            (listappend, listappend, 0),
-            # User function.
-            (ham, ham, 0),
-            # Byte-compiled code.
-            (ham.func_code, ham.func_code, 0),
-            # Lambda.
-            (spamda, spamda, 0),
-            # Class with init.
-            (Foo, Foo.__init__.im_func, 1),
-            # Class with no init.
-            (Bar, Bar, 0),
-            # Bound method.
-            (spam.foo, spam.foo.im_func, 1),
-            # Bound method with self named something else (spam).
-            (spam.bar, spam.bar.im_func, 1),
-            # Unbound method. (Do not drop the self argument.)
-            (eggs, eggs.im_func, 0),
-            # Callable instance.
-            (spam, spam.__call__.im_func, 1),
-        )
-        for object, baseObject, dropSelf in values:
-            result = introspect.getBaseObject(object)
-            self.assertEqual(result, (baseObject, dropSelf))
-
-
-class GetAttributeTestCase(unittest.TestCase):
-    """Base class for other test case classes."""
-
-    def setUp(self):
-        self.values = (
-            '__abs__',
-            '__add__',
-            '__and__',
-            '__base__',
-            '__bases__',
-            '__basicsize__',
-            '__builtins__',
-            '__call__',
-            '__class__',
-            '__cmp__',
-            '__coerce__',
-            '__contains__',
-            '__del__',
-            '__delattr__',
-            '__delitem__',
-            '__delslice__',
-            '__dict__',
-            '__dictoffset__',
-            '__div__',
-            '__divmod__',
-            '__doc__',
-            '__eq__',
-            '__file__',
-            '__flags__',
-            '__float__',
-            '__floordiv__',
-            '__ge__',
-            '__get__',
-            '__getattr__',
-            '__getattribute__',
-            '__getitem__',
-            '__getslice__',
-            '__gt__',
-            '__hash__',
-            '__hex__',
-            '__iadd__',
-            '__imul__',
-            '__init__',
-            '__int__',
-            '__invert__',
-            '__itemsize__',
-            '__iter__',
-            '__le__',
-            '__len__',
-            '__long__',
-            '__lshift__',
-            '__lt__',
-            '__mod__',
-            '__module__',
-            '__mro__',
-            '__mul__',
-            '__name__',
-            '__ne__',
-            '__neg__',
-            '__new__',
-            '__nonzero__',
-            '__oct__',
-            '__or__',
-            '__path__',
-            '__pos__',
-            '__pow__',
-            '__radd__',
-            '__rand__',
-            '__rdiv__',
-            '__rdivmod__',
-            '__reduce__',
-            '__repr__',
-            '__rfloordiv__',
-            '__rlshift__',
-            '__rmod__',
-            '__rmul__',
-            '__ror__',
-            '__rpow__',
-            '__rrshift__',
-            '__rshift__',
-            '__rsub__',
-            '__rtruediv__',
-            '__rxor__',
-            '__self__',
-            '__setattr__',
-            '__setitem__',
-            '__setslice__',
-            '__str__',
-            '__sub__',
-            '__subclasses__',
-            '__truediv__',
-            '__warningregistry__',
-            '__weakrefoffset__',
-            '__xor__',
-            'append',
-            'capitalize',
-            'center',
-            'clear',
-            'close',
-            'closed',
-            'co_argcount',
-            'co_cellvars',
-            'co_code',
-            'co_consts',
-            'co_filename',
-            'co_firstlineno',
-            'co_flags',
-            'co_freevars',
-            'co_lnotab',
-            'co_name',
-            'co_names',
-            'co_nlocals',
-            'co_stacksize',
-            'co_varnames',
-            'conjugate',
-            'copy',
-            'count',
-            'decode',
-            'encode',
-            'endswith',
-            'expandtabs',
-            'extend',
-            'fileno',
-            'find',
-            'flush',
-            'func_closure',
-            'func_code',
-            'func_defaults',
-            'func_dict',
-            'func_doc',
-            'func_globals',
-            'func_name',
-            'get',
-            'has_key',
-            'im_class',
-            'im_func',
-            'im_self',
-            'imag',
-            'index',
-            'insert',
-            'isalnum',
-            'isalpha',
-            'isatty',
-            'isdigit',
-            'islower',
-            'isspace',
-            'istitle',
-            'isupper',
-            'items',
-            'iteritems',
-            'iterkeys',
-            'itervalues',
-            'join',
-            'keys',
-            'ljust',
-            'lower',
-            'lstrip',
-            'mode',
-            'mro',
-            'name',
-            'pop',
-            'popitem',
-            'real',
-            'read',
-            'readinto',
-            'readline',
-            'readlines',
-            'remove',
-            'replace',
-            'reverse',
-            'rfind',
-            'rindex',
-            'rjust',
-            'rstrip',
-            'seek',
-            'setdefault',
-            'softspace',
-            'sort',
-            'split',
-            'splitlines',
-            'start',
-            'startswith',
-            'step',
-            'stop',
-            'strip',
-            'swapcase',
-            'tell',
-            'title',
-            'tolist',
-            'translate',
-            'truncate',
-            'update',
-            'upper',
-            'values',
-            'write',
-            'writelines',
-            'xreadlines',
-        )
-
-# Since getAllAttributeNames() calls str(object),
-# we need to test for a broken __str__ method.
-class BrokenStr:
-    def __str__(self):
-        raise Exception
-    
-brokenStr = BrokenStr()
-
-class GetAttributeNamesTestCase(GetAttributeTestCase):
-
-    def setUp(self):
-        GetAttributeTestCase.setUp(self)
-        from wx import py
-        spam = Spam()
-        self.f = open('test_introspect.py')
-        self.items = (
-            None,
-            int(123),
-            long(123),
-            float(123),
-            complex(123),
-            "",
-            unicode(""),
-            [],
-            (),
-            xrange(0),
-            {},
-            # Builtin function.
-            len,
-            # Builtin method.
-            [].append,
-            # User function.
-            ham,
-            # Byte-compiled code.
-            ham.func_code,
-            # Lambda.
-            lambda: None,
-            # Class with no init.
-            Bar,
-            # Instance with no init.
-            Bar(),
-            # Class with init and del.
-            Foo,
-            # Instance with init and del.
-            Foo(),
-            # Bound method.
-            spam.foo,
-            # Unbound method.
-            Spam.eggs,
-            # Callable instance.
-            spam,
-            # Module.
-            introspect,
-            # Package.
-            py,
-            # Buffer.
-            buffer(''),
-            # File.
-            self.f,
-            # Slice.
-            slice(0),
-            # Ellipsis.
-            Ellipsis,
-            # BrokenStr class.
-            BrokenStr,
-            # BrokenStr instance.
-            brokenStr,
-        )
-
-    def tearDown(self):
-        self.items = None
-        self.f.close()
-
-    def test_getAttributeNames(self):
-        for item in self.items:
-            self._checkAttributeNames(item)
-        if __builtins__.has_key('object'):
-            self._checkAttributeNames(object)
-
-    def test_getAttributeNames_NoSingle(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeSingle=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_' or attribute[:2] == '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAttributeNames_NoDouble(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[:2] != '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAttributeNames_NoSingleOrDouble(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeSingle=0, 
-                                                  includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def _checkAttributeNames(self, item):
-        result = introspect.getAttributeNames(item)
-        attributes = [attribute for attribute in self.values \
-                      if hasattr(item, attribute)]
-        for attribute in attributes:
-            self.assert_(attribute in result, 
-                         ':item: %r :attribute: %r' % (item, attribute))
-
-
-class GetAutoCompleteListTestCase(GetAttributeTestCase):
-
-    def setUp(self):
-        GetAttributeTestCase.setUp(self)
-        self.items = (
-            'None.',
-            '123 .',
-            '"".',
-            '[].',
-            '().',
-            '{}.',
-            # Builtin function.
-            'len.',
-            # Builtin method.
-            '[].append.',
-        )
-
-    def test_getAutoCompleteList(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item)
-            object = eval(item[:-1])
-            attributes = [attribute for attribute in self.values \
-                          if hasattr(object, attribute)]
-            for attribute in attributes:
-                self.assert_(attribute in result, 
-                             ':item: %r :attribute: %r' % (item, attribute))
-
-    def test_getAutoCompleteList_NoSingle(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeSingle=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_' or attribute[:2] == '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAutoCompleteList_NoDouble(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[:2] != '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAutoCompleteList_NoSingleOrDouble(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeSingle=0, 
-                                                    includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-
-# Support for GetConstructorTestCase.
-
-class A1:
-    def __init__(self, a):
-        self.a = a
-
-class B1(A1):
-    def __init__(self, b):
-        self.b = b
-
-class C1(A1):
-    pass
-
-class D1(C1, B1):
-    pass
-
-if __builtins__.has_key('object'):
-    class A2(object):
-        def __init__(self, a):
-            self.a = a
-
-    class B2(A2):
-        def __init__(self, b):
-            self.b = b
-
-    class C2(A2):
-        pass
-
-    class D2(C2, B2):
-        pass
-    
-class N:
-    pass
-
-class O:
-    def __init__(self, a, b=2, *args, **kwargs):
-        pass
-
-class P(O):
-    pass
-
-class Q(P):
-    def __init__(self, c, d=4):
-        pass
-
-class GetConstructorTestCase(unittest.TestCase):
-
-    def test_getConstructor(self):
-        args = ('self', 'a', 'b', 'args', 'kwargs')
-        varnames = introspect.getConstructor(O).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        varnames = introspect.getConstructor(P).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        args = ('self', 'c', 'd')
-        varnames = introspect.getConstructor(Q).func_code.co_varnames
-        self.assertEqual(varnames, args)
-
-    def test_getConstructor_None(self):
-        values = (N, 1, 'spam', {}, [], (), dir)
-        for value in values:
-            self.assertEqual(introspect.getConstructor(N), None)
-
-    def test_getConstructor_MultipleInheritance(self):
-        # Test old style inheritance rules.
-        args = ('self', 'a')
-        varnames = introspect.getConstructor(D1).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        if __builtins__.has_key('object'):
-            # Test new style inheritance rules as well.
-            args = ('self', 'b')
-            varnames = introspect.getConstructor(D2).func_code.co_varnames
-            self.assertEqual(varnames, args)
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wx/py/tests/test_pseudo.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import pseudo
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = pseudo
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.PseudoFile)
-        self.assert_(module.PseudoFileErr)
-        self.assert_(module.PseudoFileIn)
-        self.assert_(module.PseudoFileOut)
-        self.assert_(module.PseudoKeyword)
-
-
-class PseudoTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-
-class PseudoFileTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-
-class PseudoFileOutTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-    def _write(self):
-        pass
-
-    def test_PseudoFileOut_goodInit(self):
-        self.assert_(pseudo.PseudoFileOut(write=self._write))
-
-    def test_PseudoFileOut_badInit(self):
-        self.assertRaises(ValueError, pseudo.PseudoFileOut, write='bad')
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wx/py/tests/test_version.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-import types
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import version
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = version
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.VERSION)
-
-
-class VersionTestCase(unittest.TestCase):
-
-    def test_VERSION(self):
-        self.assert_(type(version.VERSION) is types.StringType)
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wx/py/tests/testall.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-import unittest
-import glob
-import os
-
-
-def suite():
-    """Return a test suite containing all test cases in all test modules. 
-    Searches the current directory for any modules matching test_*.py."""
-    suite = unittest.TestSuite()
-    for filename in glob.glob('test_*.py'):
-        module = __import__(os.path.splitext(filename)[0])
-        suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(module))
-    return suite
-
-
-if __name__ == '__main__':
-    unittest.main(defaultTest='suite')
-

wxPython/wx/py/version.py

@@ -1,9 +0,0 @@
-"""Provides an object representing the current 'version' or 'release'
-of Py as a whole.  Individual classes, such as the shell, filling and
-interpreter, each have a revision property based on the CVS Revision."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-VERSION = '0.9.4'