diff -pcdr Tcl_head/generic/regc_nfa.c Tcl_regex_fix/generic/regc_nfa.c
*** Tcl_head/generic/regc_nfa.c	Thu Feb 28 12:09:26 2013
--- Tcl_regex_fix/generic/regc_nfa.c	Sun Mar  3 11:53:57 2013
*************** freearc(
*** 497,502 ****
--- 497,538 ----
  }
  
  /*
+  - nonemptyouts - count non-EMPTY out arcs of a state
+  ^ static int nonemptyouts(struct state *);
+  */
+ static int
+ nonemptyouts(
+     struct state *s)
+ {
+     int n = 0;
+     struct arc *a;
+ 
+     for (a = s->outs; a != NULL; a = a->outchain) {
+ 	if (a->type != EMPTY)
+ 	    n++;
+     }
+     return n;
+ }
+ 
+ /*
+  - nonemptyins - count non-EMPTY in arcs of a state
+  ^ static int nonemptyins(struct state *);
+  */
+ static int
+ nonemptyins(
+     struct state *s)
+ {
+     int n = 0;
+     struct arc *a;
+ 
+     for (a = s->ins; a != NULL; a = a->inchain) {
+ 	if (a->type != EMPTY)
+ 	    n++;
+     }
+     return n;
+ }
+ 
+ /*
   - findarc - find arc, if any, from given source with given type and color
   * If there is more than one such arc, the result is random.
   ^ static struct arc *findarc(struct state *, int, pcolor);
*************** copyins(
*** 578,583 ****
--- 614,639 ----
  }
  
  /*
+  - copynonemptyins - as above, but ignore empty arcs
+  ^ static void copynonemptyins(struct nfa *, struct state *, struct state *);
+  */
+ static void
+ copynonemptyins(
+     struct nfa *nfa,
+     struct state *oldState,
+     struct state *newState)
+ {
+     struct arc *a;
+ 
+     assert(oldState != newState);
+ 
+     for (a=oldState->ins ; a!=NULL ; a=a->inchain) {
+ 	if (a->type != EMPTY)
+ 	    cparc(nfa, a, a->from, newState);
+     }
+ }
+ 
+ /*
   - moveouts - move all out arcs of a state to another state
   ^ static void moveouts(struct nfa *, struct state *, struct state *);
   */
*************** copyouts(
*** 617,622 ****
--- 673,698 ----
  }
  
  /*
+  - copynonemptyouts - as above, but ignore empty arcs
+  ^ static void copynonemptyouts(struct nfa *, struct state *, struct state *);
+  */
+ static void
+ copynonemptyouts(
+     struct nfa *nfa,
+     struct state *oldState,
+     struct state *newState)
+ {
+     struct arc *a;
+ 
+     assert(oldState != newState);
+ 
+     for (a=oldState->outs ; a!=NULL ; a=a->outchain) {
+ 	if (a->type != EMPTY)
+ 	    cparc(nfa, a, newState, a->to);
+     }
+ }
+ 
+ /*
   - cloneouts - copy out arcs of a state to another state pair, modifying type
   ^ static void cloneouts(struct nfa *, struct state *, struct state *,
   ^ 	struct state *, int);
*************** fixempties(
*** 1247,1364 ****
      FILE *f)			/* for debug output; NULL none */
  {
      struct state *s;
      struct state *nexts;
-     struct state *to;
      struct arc *a;
      struct arc *nexta;
-     int progress;
  
      /*
!      * Find and eliminate empties until there are no more.
       */
  
!     do {
! 	progress = 0;
! 	for (s = nfa->states; s != NULL && !NISERR(); s = nexts) {
! 	    nexts = s->next;
! 	    for (a = s->outs; a != NULL && !NISERR(); a = a->outchain) {
! 		if (a->type == EMPTY) {
! 
! 		    /*
! 		     *  Mark a for deletion; copy arcs to preserve graph
! 		     * connectivity after it is gone.
! 		     */
! 
! 		    unempty(nfa, a);
! 		}
  	    }
  
  	    /*
! 	     * Now pass through and delete the marked arcs.  Doing all the
! 	     * deletion after all the marking prevents arc copying from
! 	     * resurrecting deleted arcs which can cause failure to converge.
! 	     * [Tcl Bug 3604074]
  	     */
  
! 	    for (a = s->outs; a != NULL; a = nexta) {
! 		nexta = a->outchain;
! 		if (a->from == NULL) {
! 		    progress = 1;
! 		    to = a->to;
! 		    a->from = s;
! 		    freearc(nfa, a);
! 		    if (to->nins == 0) {
! 			while ((a = to->outs)) {
! 			    freearc(nfa, a);
! 			}
! 			if (nexts == to) {
! 			    nexts = to->next;
! 			}
! 			freestate(nfa, to);
! 		    }
! 		    if (s->nouts == 0) {
! 			while ((a = s->ins)) {
! 			    freearc(nfa, a);
! 			}
! 			freestate(nfa, s);
! 		    }
! 		}
! 	    }
  	}
! 	if (progress && f != NULL) {
! 	    dumpnfa(nfa, f);
  	}
!     } while (progress && !NISERR());
  }
  
  /*
!  - unempty - optimize out an EMPTY arc, if possible
!  * Actually, as it stands this function always succeeds, but the return value
!  * is kept with an eye on possible future changes.
!  ^ static int unempty(struct nfa *, struct arc *);
   */
! static int			/* 0 couldn't, 1 could */
! unempty(
!     struct nfa *nfa,
!     struct arc *a)
  {
!     struct state *from = a->from;
!     struct state *to = a->to;
! 
!     assert(a->type == EMPTY);
!     assert(from != nfa->pre && to != nfa->post);
  
!     if (from == to) {		/* vacuous loop */
! 	freearc(nfa, a);
! 	return 1;
      }
  
      /*
!      *  Mark arc for deletion.
       */
  
!     a->from = NULL;
! 
!     if (from->nouts > to->nins) {
! 	copyouts(nfa, to, from);
! 	return 1;
      }
!     if (from->nouts < to->nins) {
! 	copyins(nfa, from, to);
! 	return 1;
      }
  
      /*
!      * from->nouts == to->nins . decide on secondary issue:  copy fewest arcs
       */
- 
      if (from->nins > to->nouts) {
! 	copyouts(nfa, to, from);
! 	return 1;
      }
- 
-     copyins(nfa, from, to);
-     return 1;
  }
  
  /*
--- 1323,1513 ----
      FILE *f)			/* for debug output; NULL none */
  {
      struct state *s;
+     struct state *s2;
      struct state *nexts;
      struct arc *a;
      struct arc *nexta;
  
      /*
!      * First, get rid of any states whose sole out-arc is an EMPTY, since
!      * they're basically just aliases for their successor.  The parsing
!      * algorithm creates enough of these that it's worth special-casing this.
       */
+     for (s = nfa->states; s != NULL && !NISERR(); s = nexts) {
+ 	nexts = s->next;
+ 	if (s->nouts == 1 && !s->flag) {
+ 	    a = s->outs;
+ 	    assert(a != NULL && a->outchain == NULL);
+ 	    if (a->type == EMPTY) {
+ 		if (s != a->to)
+ 		    moveins(nfa, s, a->to);
+ 		dropstate(nfa, s);
+ 	    }
+ 	}
+     }
  
!     /*
!      * Similarly, get rid of any state with a single EMPTY in-arc, by folding
!      * it into its predecessor.
!      */
!     for (s = nfa->states; s != NULL && !NISERR(); s = nexts) {
! 	nexts = s->next;
! 	/* while we're at it, ensure tmp fields are clear for next step */
! 	s->tmp = NULL;
! 	if (s->nins == 1 && !s->flag) {
! 	    a = s->ins;
! 	    assert(a != NULL && a->inchain == NULL);
! 	    if (a->type == EMPTY) {
! 		if (s != a->from)
! 		    moveouts(nfa, s, a->from);
! 		dropstate(nfa, s);
  	    }
+ 	}
+     }
  
+     /*
+      * For each remaining NFA state, find all other states that are reachable
+      * from it by a chain of one or more EMPTY arcs.  Then generate new arcs
+      * that eliminate the need for each such chain.
+      *
+      * If we just do this straightforwardly, the algorithm gets slow in
+      * complex graphs, because the same arcs get copied to all intermediate
+      * states of an EMPTY chain, and then uselessly pushed repeatedly to the
+      * chain's final state; we waste a lot of time in newarc's duplicate
+      * checking.  To improve matters, we decree that any state with only EMPTY
+      * out-arcs is "doomed" and will not be part of the final NFA. That can be
+      * ensured by not adding any new out-arcs to such a state. Having ensured
+      * that, we need not update the state's in-arcs list either; all arcs that
+      * might have gotten pushed forward to it will just get pushed directly to
+      * successor states.  This eliminates most of the useless duplicate arcs.
+      */
+     for (s = nfa->states; s != NULL && !NISERR(); s = s->next) {
+ 	for (s2 = emptyreachable(s, s); s2 != s && !NISERR(); s2 = nexts) {
  	    /*
! 	     * If s2 is doomed, we decide that (1) we will always push arcs
! 	     * forward to it, not pull them back to s; and (2) we can optimize
! 	     * away the push-forward, per comment above.  So do nothing.
  	     */
+ 	    if (s2->flag || nonemptyouts(s2) > 0)
+ 		replaceempty(nfa, s, s2);
  
! 	    /* Reset the tmp fields as we walk back */
! 	    nexts = s2->tmp;
! 	    s2->tmp = NULL;
  	}
! 	s->tmp = NULL;
!     }
! 
!     /*
!      * Now remove all the EMPTY arcs, since we don't need them anymore.
!      */
!     for (s = nfa->states; s != NULL && !NISERR(); s = s->next) {
! 	for (a = s->outs; a != NULL; a = nexta) {
! 	    nexta = a->outchain;
! 	    if (a->type == EMPTY)
! 		freearc(nfa, a);
  	}
!     }
! 
!     /*
!      * And remove any states that have become useless.  (This cleanup is not
!      * very thorough, and would be even less so if we tried to combine it with
!      * the previous step; but cleanup() will take care of anything we miss.)
!      */
!     for (s = nfa->states; s != NULL && !NISERR(); s = nexts) {
! 	nexts = s->next;
! 	if ((s->nins == 0 || s->nouts == 0) && !s->flag)
! 	    dropstate(nfa, s);
!     }
! 
!     if (f != NULL && !NISERR())
! 	dumpnfa(nfa, f);
  }
  
  /*
!  - emptyreachable - recursively find all states reachable from s by EMPTY arcs
!  * The return value is the last such state found.  Its tmp field links back
!  * to the next-to-last such state, and so on back to s, so that all these
!  * states can be located without searching the whole NFA.
!  * The maximum recursion depth here is equal to the length of the longest
!  * loop-free chain of EMPTY arcs, which is surely no more than the size of
!  * the NFA, and in practice will be a lot less than that.
!  ^ static struct state *emptyreachable(struct state *, struct state *);
   */
! static struct state *
! emptyreachable(
!     struct state *s,
!     struct state *lastfound)
  {
!     struct arc *a;
  
!     s->tmp = lastfound;
!     lastfound = s;
!     for (a = s->outs; a != NULL; a = a->outchain) {
! 	if (a->type == EMPTY && a->to->tmp == NULL)
! 	    lastfound = emptyreachable(a->to, lastfound);
      }
+     return lastfound;
+ }
+ 
+ /*
+  - replaceempty - replace an EMPTY arc chain with some non-empty arcs
+  * The EMPTY arc(s) should be deleted later, but we can't do it here because
+  * they may still be needed to identify other arc chains during fixempties().
+  ^ static void replaceempty(struct nfa *, struct state *, struct state *);
+  */
+ static void
+ replaceempty(
+     struct nfa *nfa,
+     struct state *from,
+     struct state *to)
+ {
+     int fromouts;
+     int toins;
+ 
+     assert(from != to);
  
      /*
!      * Create replacement arcs that bypass the need for the EMPTY chain.  We
!      * can do this either by pushing arcs forward (linking directly from
!      * "from"'s predecessors to "to") or by pulling them back (linking
!      * directly from "from" to "to"'s successors).  In general, we choose
!      * whichever way creates greater fan-out or fan-in, so as to improve the
!      * odds of reducing the other state to zero in-arcs or out-arcs and
!      * thereby being able to delete it.  However, if "from" is doomed (has no
!      * non-EMPTY out-arcs), we must keep it so, so always push forward in that
!      * case.
!      *
!      * The fan-out/fan-in comparison should count only non-EMPTY arcs.  If
!      * "from" is doomed, we can skip counting "to"'s arcs, since we want to
!      * force taking the copynonemptyins path in that case.
       */
+     fromouts = nonemptyouts(from);
+     toins = (fromouts == 0) ? 1 : nonemptyins(to);
  
!     if (fromouts > toins) {
! 	copynonemptyouts(nfa, to, from);
! 	return;
      }
!     if (fromouts < toins) {
! 	copynonemptyins(nfa, from, to);
! 	return;
      }
  
      /*
!      * fromouts == toins.  Decide on secondary issue: copy fewest arcs.
!      *
!      * Doesn't seem to be worth the trouble to exclude empties from these
!      * comparisons; that takes extra time and doesn't seem to improve the
!      * resulting graph much.
       */
      if (from->nins > to->nouts) {
! 	copynonemptyouts(nfa, to, from);
! 	return;
!     } else {
! 	copynonemptyins(nfa, from, to);
! 	return;
      }
  }
  
  /*
diff -pcdr Tcl_head/generic/regcomp.c Tcl_regex_fix/generic/regcomp.c
*** Tcl_head/generic/regcomp.c	Thu Feb 28 12:09:26 2013
--- Tcl_regex_fix/generic/regcomp.c	Sun Mar  3 12:15:48 2013
*************** static void destroystate(struct nfa *, s
*** 121,132 ****
--- 121,136 ----
  static void newarc(struct nfa *, int, pcolor, struct state *, struct state *);
  static struct arc *allocarc(struct nfa *, struct state *);
  static void freearc(struct nfa *, struct arc *);
+ static int nonemptyouts(struct state *);
+ static int nonemptyins(struct state *);
  static struct arc *findarc(struct state *, int, pcolor);
  static void cparc(struct nfa *, struct arc *, struct state *, struct state *);
  static void moveins(struct nfa *, struct state *, struct state *);
  static void copyins(struct nfa *, struct state *, struct state *);
+ static void copynonemptyins(struct nfa *, struct state *, struct state *);
  static void moveouts(struct nfa *, struct state *, struct state *);
  static void copyouts(struct nfa *, struct state *, struct state *);
+ static void copynonemptyouts(struct nfa *, struct state *, struct state *);
  static void cloneouts(struct nfa *, struct state *, struct state *, struct state *, int);
  static void delsub(struct nfa *, struct state *, struct state *);
  static void deltraverse(struct nfa *, struct state *, struct state *);
*************** static int push(struct nfa *, struct arc
*** 144,150 ****
  #define	COMPATIBLE	3	/* compatible but not satisfied yet */
  static int combine(struct arc *, struct arc *);
  static void fixempties(struct nfa *, FILE *);
! static int unempty(struct nfa *, struct arc *);
  static void cleanup(struct nfa *);
  static void markreachable(struct nfa *, struct state *, struct state *, struct state *);
  static void markcanreach(struct nfa *, struct state *, struct state *, struct state *);
--- 148,155 ----
  #define	COMPATIBLE	3	/* compatible but not satisfied yet */
  static int combine(struct arc *, struct arc *);
  static void fixempties(struct nfa *, FILE *);
! static struct state *emptyreachable(struct state *, struct state *);
! static void replaceempty(struct nfa *, struct state *, struct state *);
  static void cleanup(struct nfa *);
  static void markreachable(struct nfa *, struct state *, struct state *, struct state *);
  static void markcanreach(struct nfa *, struct state *, struct state *, struct state *);
