===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/lex/nfa.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -c -r1.9 -r1.10
*** src/usr.bin/lex/nfa.c	2003/06/04 17:34:44	1.9
--- src/usr.bin/lex/nfa.c	2015/11/19 19:43:40	1.10
***************
*** 1,47 ****
! /*	$OpenBSD: nfa.c,v 1.9 2003/06/04 17:34:44 millert Exp $	*/
  
  /* nfa - NFA construction routines */
  
! /*-
!  * Copyright (c) 1990 The Regents of the University of California.
!  * All rights reserved.
!  *
!  * This code is derived from software contributed to Berkeley by
!  * Vern Paxson.
!  * 
!  * The United States Government has rights in this work pursuant
!  * to contract no. DE-AC03-76SF00098 between the United States
!  * Department of Energy and the University of California.
!  *
!  * Redistribution and use in source and binary forms, with or without
!  * modification, are permitted provided that the following conditions
!  * are met:
!  *
!  * 1. Redistributions of source code must retain the above copyright
!  *    notice, this list of conditions and the following disclaimer.
!  * 2. Redistributions in binary form must reproduce the above copyright
!  *    notice, this list of conditions and the following disclaimer in the
!  *    documentation and/or other materials provided with the distribution.
!  *
!  * Neither the name of the University nor the names of its contributors
!  * may be used to endorse or promote products derived from this software
!  * without specific prior written permission.
!  *
!  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
!  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
!  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
!  * PURPOSE.
!  */
  
! /* $Header: /cvsrepo/anoncvs/cvs/src/usr.bin/lex/nfa.c,v 1.9 2003/06/04 17:34:44 millert Exp $ */
  
  #include "flexdef.h"
  
  
  /* declare functions that have forward references */
  
! int dupmachine PROTO((int));
! void mkxtion PROTO((int, int));
  
  
  /* add_accept - add an accepting state to a machine
--- 1,45 ----
! /*	$OpenBSD: nfa.c,v 1.10 2015/11/19 19:43:40 tedu Exp $	*/
  
  /* nfa - NFA construction routines */
  
! /*  Copyright (c) 1990 The Regents of the University of California. */
! /*  All rights reserved. */
  
! /*  This code is derived from software contributed to Berkeley by */
! /*  Vern Paxson. */
  
+ /*  The United States Government has rights in this work pursuant */
+ /*  to contract no. DE-AC03-76SF00098 between the United States */
+ /*  Department of Energy and the University of California. */
+ 
+ /*  This file is part of flex. */
+ 
+ /*  Redistribution and use in source and binary forms, with or without */
+ /*  modification, are permitted provided that the following conditions */
+ /*  are met: */
+ 
+ /*  1. Redistributions of source code must retain the above copyright */
+ /*     notice, this list of conditions and the following disclaimer. */
+ /*  2. Redistributions in binary form must reproduce the above copyright */
+ /*     notice, this list of conditions and the following disclaimer in the */
+ /*     documentation and/or other materials provided with the distribution. */
+ 
+ /*  Neither the name of the University nor the names of its contributors */
+ /*  may be used to endorse or promote products derived from this software */
+ /*  without specific prior written permission. */
+ 
+ /*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+ /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+ /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+ /*  PURPOSE. */
+ 
  #include "flexdef.h"
  
  
  /* declare functions that have forward references */
  
! int dupmachine PROTO ((int));
! void mkxtion PROTO ((int, int));
  
  
  /* add_accept - add an accepting state to a machine
***************
*** 49,73 ****
   * accepting_number becomes mach's accepting number.
   */
  
! void add_accept( mach, accepting_number )
! int mach, accepting_number;
! 	{
  	/* Hang the accepting number off an epsilon state.  if it is associated
  	 * with a state that has a non-epsilon out-transition, then the state
  	 * will accept BEFORE it makes that transition, i.e., one character
  	 * too soon.
  	 */
  
! 	if ( transchar[finalst[mach]] == SYM_EPSILON )
  		accptnum[finalst[mach]] = accepting_number;
  
! 	else
! 		{
! 		int astate = mkstate( SYM_EPSILON );
  		accptnum[astate] = accepting_number;
! 		(void) link_machines( mach, astate );
! 		}
  	}
  
  
  /* copysingl - make a given number of copies of a singleton machine
--- 47,71 ----
   * accepting_number becomes mach's accepting number.
   */
  
! void    add_accept (mach, accepting_number)
!      int     mach, accepting_number;
! {
  	/* Hang the accepting number off an epsilon state.  if it is associated
  	 * with a state that has a non-epsilon out-transition, then the state
  	 * will accept BEFORE it makes that transition, i.e., one character
  	 * too soon.
  	 */
  
! 	if (transchar[finalst[mach]] == SYM_EPSILON)
  		accptnum[finalst[mach]] = accepting_number;
  
! 	else {
! 		int     astate = mkstate (SYM_EPSILON);
! 
  		accptnum[astate] = accepting_number;
! 		(void) link_machines (mach, astate);
  	}
+ }
  
  
  /* copysingl - make a given number of copies of a singleton machine
***************
*** 81,111 ****
   *     num    - the number of copies of singl to be present in newsng
   */
  
! int copysingl( singl, num )
! int singl, num;
! 	{
! 	int copy, i;
  
! 	copy = mkstate( SYM_EPSILON );
  
! 	for ( i = 1; i <= num; ++i )
! 		copy = link_machines( copy, dupmachine( singl ) );
  
  	return copy;
! 	}
  
  
  /* dumpnfa - debugging routine to write out an nfa */
  
! void dumpnfa( state1 )
! int state1;
  
! 	{
! 	int sym, tsp1, tsp2, anum, ns;
  
! 	fprintf( stderr,
! 	_( "\n\n********** beginning dump of nfa with start state %d\n" ),
! 		state1 );
  
  	/* We probably should loop starting at firstst[state1] and going to
  	 * lastst[state1], but they're not maintained properly when we "or"
--- 79,110 ----
   *     num    - the number of copies of singl to be present in newsng
   */
  
! int     copysingl (singl, num)
!      int     singl, num;
! {
! 	int     copy, i;
  
! 	copy = mkstate (SYM_EPSILON);
  
! 	for (i = 1; i <= num; ++i)
! 		copy = link_machines (copy, dupmachine (singl));
  
  	return copy;
! }
  
  
  /* dumpnfa - debugging routine to write out an nfa */
  
! void    dumpnfa (state1)
!      int     state1;
  
! {
! 	int     sym, tsp1, tsp2, anum, ns;
  
! 	fprintf (stderr,
! 		 _
! 		 ("\n\n********** beginning dump of nfa with start state %d\n"),
! 		 state1);
  
  	/* We probably should loop starting at firstst[state1] and going to
  	 * lastst[state1], but they're not maintained properly when we "or"
***************
*** 114,140 ****
  	 */
  
  	/* for ( ns = firstst[state1]; ns <= lastst[state1]; ++ns ) */
! 	for ( ns = 1; ns <= lastnfa; ++ns )
! 		{
! 		fprintf( stderr, _( "state # %4d\t" ), ns );
  
  		sym = transchar[ns];
  		tsp1 = trans1[ns];
  		tsp2 = trans2[ns];
  		anum = accptnum[ns];
  
! 		fprintf( stderr, "%3d:  %4d, %4d", sym, tsp1, tsp2 );
  
! 		if ( anum != NIL )
! 			fprintf( stderr, "  [%d]", anum );
  
! 		fprintf( stderr, "\n" );
! 		}
! 
! 	fprintf( stderr, _( "********** end of dump\n" ) );
  	}
  
  
  /* dupmachine - make a duplicate of a given machine
   *
   * synopsis
--- 113,138 ----
  	 */
  
  	/* for ( ns = firstst[state1]; ns <= lastst[state1]; ++ns ) */
! 	for (ns = 1; ns <= lastnfa; ++ns) {
! 		fprintf (stderr, _("state # %4d\t"), ns);
  
  		sym = transchar[ns];
  		tsp1 = trans1[ns];
  		tsp2 = trans2[ns];
  		anum = accptnum[ns];
  
! 		fprintf (stderr, "%3d:  %4d, %4d", sym, tsp1, tsp2);
  
! 		if (anum != NIL)
! 			fprintf (stderr, "  [%d]", anum);
  
! 		fprintf (stderr, "\n");
  	}
  
+ 	fprintf (stderr, _("********** end of dump\n"));
+ }
  
+ 
  /* dupmachine - make a duplicate of a given machine
   *
   * synopsis
***************
*** 152,183 ****
   * states accessible by the arrays firstst and lastst
   */
  
! int dupmachine( mach )
! int mach;
! 	{
! 	int i, init, state_offset;
! 	int state = 0;
! 	int last = lastst[mach];
  
! 	for ( i = firstst[mach]; i <= last; ++i )
! 		{
! 		state = mkstate( transchar[i] );
  
! 		if ( trans1[i] != NO_TRANSITION )
! 			{
! 			mkxtion( finalst[state], trans1[i] + state - i );
  
! 			if ( transchar[i] == SYM_EPSILON &&
! 			     trans2[i] != NO_TRANSITION )
! 				mkxtion( finalst[state],
! 					trans2[i] + state - i );
! 			}
  
  		accptnum[state] = accptnum[i];
! 		}
  
! 	if ( state == 0 )
! 		flexfatal( _( "empty machine in dupmachine()" ) );
  
  	state_offset = state - i + 1;
  
--- 150,179 ----
   * states accessible by the arrays firstst and lastst
   */
  
! int     dupmachine (mach)
!      int     mach;
! {
! 	int     i, init, state_offset;
! 	int     state = 0;
! 	int     last = lastst[mach];
  
! 	for (i = firstst[mach]; i <= last; ++i) {
! 		state = mkstate (transchar[i]);
  
! 		if (trans1[i] != NO_TRANSITION) {
! 			mkxtion (finalst[state], trans1[i] + state - i);
  
! 			if (transchar[i] == SYM_EPSILON &&
! 			    trans2[i] != NO_TRANSITION)
! 					mkxtion (finalst[state],
! 						 trans2[i] + state - i);
! 		}
  
  		accptnum[state] = accptnum[i];
! 	}
  
! 	if (state == 0)
! 		flexfatal (_("empty machine in dupmachine()"));
  
  	state_offset = state - i + 1;
  
***************
*** 187,193 ****
  	lastst[init] = lastst[mach] + state_offset;
  
  	return init;
! 	}
  
  
  /* finish_rule - finish up the processing for a rule
--- 183,189 ----
  	lastst[init] = lastst[mach] + state_offset;
  
  	return init;
! }
  
  
  /* finish_rule - finish up the processing for a rule
***************
*** 202,213 ****
   * context has variable length.
   */
  
! void finish_rule( mach, variable_trail_rule, headcnt, trailcnt )
! int mach, variable_trail_rule, headcnt, trailcnt;
! 	{
! 	char action_text[MAXLINE];
  
! 	add_accept( mach, num_rules );
  
  	/* We did this in new_rule(), but it often gets the wrong
  	 * number because we do it before we start parsing the current rule.
--- 198,210 ----
   * context has variable length.
   */
  
! void    finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
! 		     pcont_act)
!      int     mach, variable_trail_rule, headcnt, trailcnt, pcont_act;
! {
! 	char    action_text[MAXLINE];
  
! 	add_accept (mach, num_rules);
  
  	/* We did this in new_rule(), but it often gets the wrong
  	 * number because we do it before we start parsing the current rule.
***************
*** 217,286 ****
  	/* If this is a continued action, then the line-number has already
  	 * been updated, giving us the wrong number.
  	 */
! 	if ( continued_action )
  		--rule_linenum[num_rules];
  
- 	snprintf( action_text, sizeof action_text, "case %d:\n", num_rules );
- 	add_action( action_text );
  
! 	if ( variable_trail_rule )
! 		{
  		rule_type[num_rules] = RULE_VARIABLE;
  
! 		if ( performance_report > 0 )
! 			fprintf( stderr,
! 			_( "Variable trailing context rule at line %d\n" ),
! 				rule_linenum[num_rules] );
  
  		variable_trailing_context_rules = true;
! 		}
  
! 	else
! 		{
  		rule_type[num_rules] = RULE_NORMAL;
  
! 		if ( headcnt > 0 || trailcnt > 0 )
! 			{
  			/* Do trailing context magic to not match the trailing
  			 * characters.
  			 */
! 			char *scanner_cp = "yy_c_buf_p = yy_cp";
! 			char *scanner_bp = "yy_bp";
  
! 			add_action(
! 	"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */\n" );
  
! 			if ( headcnt > 0 )
! 				{
! 				snprintf( action_text, sizeof action_text,
! 					"%s = %s + %d;\n",
! 					scanner_cp, scanner_bp, headcnt );
! 				add_action( action_text );
  				}
  
! 			else
! 				{
! 				snprintf( action_text, sizeof action_text,
! 					"%s -= %d;\n",
! 					scanner_cp, trailcnt );
! 				add_action( action_text );
  				}
  
! 			add_action(
! 			"YY_DO_BEFORE_ACTION; /* set up yytext again */\n" );
  			}
  		}
  
  	/* Okay, in the action code at this point yytext and yyleng have
  	 * their proper final values for this rule, so here's the point
  	 * to do any user action.  But don't do it for continued actions,
  	 * as that'll result in multiple YY_RULE_SETUP's.
  	 */
! 	if ( ! continued_action )
! 		add_action( "YY_RULE_SETUP\n" );
  
! 	line_directive_out( (FILE *) 0, 1 );
! 	}
  
  
  /* link_machines - connect two machines together
--- 214,301 ----
  	/* If this is a continued action, then the line-number has already
  	 * been updated, giving us the wrong number.
  	 */
! 	if (continued_action)
  		--rule_linenum[num_rules];
  
  
! 	/* If the previous rule was continued action, then we inherit the
! 	 * previous newline flag, possibly overriding the current one.
! 	 */
! 	if (pcont_act && rule_has_nl[num_rules - 1])
! 		rule_has_nl[num_rules] = true;
! 
! 	snprintf (action_text, sizeof(action_text), "case %d:\n", num_rules);
! 	add_action (action_text);
! 	if (rule_has_nl[num_rules]) {
! 		snprintf (action_text, sizeof(action_text), "/* rule %d can match eol */\n",
! 			 num_rules);
! 		add_action (action_text);
! 	}
! 
! 
! 	if (variable_trail_rule) {
  		rule_type[num_rules] = RULE_VARIABLE;
  
! 		if (performance_report > 0)
! 			fprintf (stderr,
! 				 _
! 				 ("Variable trailing context rule at line %d\n"),
! 				 rule_linenum[num_rules]);
  
  		variable_trailing_context_rules = true;
! 	}
  
! 	else {
  		rule_type[num_rules] = RULE_NORMAL;
  
! 		if (headcnt > 0 || trailcnt > 0) {
  			/* Do trailing context magic to not match the trailing
  			 * characters.
  			 */
! 			char   *scanner_cp = "YY_G(yy_c_buf_p) = yy_cp";
! 			char   *scanner_bp = "yy_bp";
  
! 			add_action
! 				("*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */\n");
  
! 			if (headcnt > 0) {
! 				if (rule_has_nl[num_rules]) {
! 					snprintf (action_text, sizeof(action_text),
! 						"YY_LINENO_REWIND_TO(%s + %d);\n", scanner_bp, headcnt);
! 					add_action (action_text);
  				}
+ 				snprintf (action_text, sizeof(action_text), "%s = %s + %d;\n",
+ 					 scanner_cp, scanner_bp, headcnt);
+ 				add_action (action_text);
+ 			}
  
! 			else {
! 				if (rule_has_nl[num_rules]) {
! 					snprintf (action_text, sizeof(action_text),
! 						 "YY_LINENO_REWIND_TO(yy_cp - %d);\n", trailcnt);
! 					add_action (action_text);
  				}
  
! 				snprintf (action_text, sizeof(action_text), "%s -= %d;\n",
! 					 scanner_cp, trailcnt);
! 				add_action (action_text);
  			}
+ 
+ 			add_action
+ 				("YY_DO_BEFORE_ACTION; /* set up yytext again */\n");
  		}
+ 	}
  
  	/* Okay, in the action code at this point yytext and yyleng have
  	 * their proper final values for this rule, so here's the point
  	 * to do any user action.  But don't do it for continued actions,
  	 * as that'll result in multiple YY_RULE_SETUP's.
  	 */
! 	if (!continued_action)
! 		add_action ("YY_RULE_SETUP\n");
  
! 	line_directive_out ((FILE *) 0, 1);
! }
  
  
  /* link_machines - connect two machines together
***************
*** 299,323 ****
   *  FIRST is set to new by the operation.  last is unmolested.
   */
  
! int link_machines( first, last )
! int first, last;
! 	{
! 	if ( first == NIL )
  		return last;
  
! 	else if ( last == NIL )
  		return first;
  
! 	else
! 		{
! 		mkxtion( finalst[first], last );
  		finalst[first] = finalst[last];
! 		lastst[first] = MAX( lastst[first], lastst[last] );
! 		firstst[first] = MIN( firstst[first], firstst[last] );
  
  		return first;
- 		}
  	}
  
  
  /* mark_beginning_as_normal - mark each "beginning" state in a machine
--- 314,337 ----
   *  FIRST is set to new by the operation.  last is unmolested.
   */
  
! int     link_machines (first, last)
!      int     first, last;
! {
! 	if (first == NIL)
  		return last;
  
! 	else if (last == NIL)
  		return first;
  
! 	else {
! 		mkxtion (finalst[first], last);
  		finalst[first] = finalst[last];
! 		lastst[first] = MAX (lastst[first], lastst[last]);
! 		firstst[first] = MIN (firstst[first], firstst[last]);
  
  		return first;
  	}
+ }
  
  
  /* mark_beginning_as_normal - mark each "beginning" state in a machine
***************
*** 327,362 ****
   * The "beginning" states are the epsilon closure of the first state
   */
  
! void mark_beginning_as_normal( mach )
! int mach;
! 	{
! 	switch ( state_type[mach] )
! 		{
! 		case STATE_NORMAL:
! 			/* Oh, we've already visited here. */
! 			return;
  
! 		case STATE_TRAILING_CONTEXT:
! 			state_type[mach] = STATE_NORMAL;
  
! 			if ( transchar[mach] == SYM_EPSILON )
! 				{
! 				if ( trans1[mach] != NO_TRANSITION )
! 					mark_beginning_as_normal(
! 						trans1[mach] );
  
! 				if ( trans2[mach] != NO_TRANSITION )
! 					mark_beginning_as_normal(
! 						trans2[mach] );
! 				}
! 			break;
! 
! 		default:
! 			flexerror(
! 			_( "bad state type in mark_beginning_as_normal()" ) );
! 			break;
  		}
  	}
  
  
  /* mkbranch - make a machine that branches to two machines
--- 341,372 ----
   * The "beginning" states are the epsilon closure of the first state
   */
  
! void    mark_beginning_as_normal (mach)
!      int mach;
! {
! 	switch (state_type[mach]) {
! 	case STATE_NORMAL:
! 		/* Oh, we've already visited here. */
! 		return;
  
! 	case STATE_TRAILING_CONTEXT:
! 		state_type[mach] = STATE_NORMAL;
  
! 		if (transchar[mach] == SYM_EPSILON) {
! 			if (trans1[mach] != NO_TRANSITION)
! 				mark_beginning_as_normal (trans1[mach]);
  
! 			if (trans2[mach] != NO_TRANSITION)
! 				mark_beginning_as_normal (trans2[mach]);
  		}
+ 		break;
+ 
+ 	default:
+ 		flexerror (_
+ 			   ("bad state type in mark_beginning_as_normal()"));
+ 		break;
  	}
+ }
  
  
  /* mkbranch - make a machine that branches to two machines
***************
*** 373,396 ****
   * more mkbranch's.  Compare with mkor()
   */
  
! int mkbranch( first, second )
! int first, second;
! 	{
! 	int eps;
  
! 	if ( first == NO_TRANSITION )
  		return second;
  
! 	else if ( second == NO_TRANSITION )
  		return first;
  
! 	eps = mkstate( SYM_EPSILON );
  
! 	mkxtion( eps, first );
! 	mkxtion( eps, second );
  
  	return eps;
! 	}
  
  
  /* mkclos - convert a machine into a closure
--- 383,406 ----
   * more mkbranch's.  Compare with mkor()
   */
  
! int     mkbranch (first, second)
!      int     first, second;
! {
! 	int     eps;
  
! 	if (first == NO_TRANSITION)
  		return second;
  
! 	else if (second == NO_TRANSITION)
  		return first;
  
! 	eps = mkstate (SYM_EPSILON);
  
! 	mkxtion (eps, first);
! 	mkxtion (eps, second);
  
  	return eps;
! }
  
  
  /* mkclos - convert a machine into a closure
***************
*** 401,411 ****
   * new - a new state which matches the closure of "state"
   */
  
! int mkclos( state )
! int state;
! 	{
! 	return mkopt( mkposcl( state ) );
! 	}
  
  
  /* mkopt - make a machine optional
--- 411,421 ----
   * new - a new state which matches the closure of "state"
   */
  
! int     mkclos (state)
!      int     state;
! {
! 	return mkopt (mkposcl (state));
! }
  
  
  /* mkopt - make a machine optional
***************
*** 422,449 ****
   *     2. mach is destroyed by the call
   */
  
! int mkopt( mach )
! int mach;
! 	{
! 	int eps;
  
! 	if ( ! SUPER_FREE_EPSILON(finalst[mach]) )
! 		{
! 		eps = mkstate( SYM_EPSILON );
! 		mach = link_machines( mach, eps );
! 		}
  
  	/* Can't skimp on the following if FREE_EPSILON(mach) is true because
  	 * some state interior to "mach" might point back to the beginning
  	 * for a closure.
  	 */
! 	eps = mkstate( SYM_EPSILON );
! 	mach = link_machines( eps, mach );
  
! 	mkxtion( mach, finalst[mach] );
  
  	return mach;
! 	}
  
  
  /* mkor - make a machine that matches either one of two machines
--- 432,458 ----
   *     2. mach is destroyed by the call
   */
  
! int     mkopt (mach)
!      int     mach;
! {
! 	int     eps;
  
! 	if (!SUPER_FREE_EPSILON (finalst[mach])) {
! 		eps = mkstate (SYM_EPSILON);
! 		mach = link_machines (mach, eps);
! 	}
  
  	/* Can't skimp on the following if FREE_EPSILON(mach) is true because
  	 * some state interior to "mach" might point back to the beginning
  	 * for a closure.
  	 */
! 	eps = mkstate (SYM_EPSILON);
! 	mach = link_machines (eps, mach);
  
! 	mkxtion (mach, finalst[mach]);
  
  	return mach;
! }
  
  
  /* mkor - make a machine that matches either one of two machines
***************
*** 460,515 ****
   * the number of epsilon states needed
   */
  
! int mkor( first, second )
! int first, second;
! 	{
! 	int eps, orend;
  
! 	if ( first == NIL )
  		return second;
  
! 	else if ( second == NIL )
  		return first;
  
! 	else
! 		{
  		/* See comment in mkopt() about why we can't use the first
  		 * state of "first" or "second" if they satisfy "FREE_EPSILON".
  		 */
! 		eps = mkstate( SYM_EPSILON );
  
! 		first = link_machines( eps, first );
  
! 		mkxtion( first, second );
  
! 		if ( SUPER_FREE_EPSILON(finalst[first]) &&
! 		     accptnum[finalst[first]] == NIL )
! 			{
  			orend = finalst[first];
! 			mkxtion( finalst[second], orend );
! 			}
  
! 		else if ( SUPER_FREE_EPSILON(finalst[second]) &&
! 			  accptnum[finalst[second]] == NIL )
! 			{
  			orend = finalst[second];
! 			mkxtion( finalst[first], orend );
! 			}
  
! 		else
! 			{
! 			eps = mkstate( SYM_EPSILON );
  
! 			first = link_machines( first, eps );
  			orend = finalst[first];
  
! 			mkxtion( finalst[second], orend );
! 			}
  		}
  
  	finalst[first] = orend;
  	return first;
! 	}
  
  
  /* mkposcl - convert a machine into a positive closure
--- 469,520 ----
   * the number of epsilon states needed
   */
  
! int     mkor (first, second)
!      int     first, second;
! {
! 	int     eps, orend;
  
! 	if (first == NIL)
  		return second;
  
! 	else if (second == NIL)
  		return first;
  
! 	else {
  		/* See comment in mkopt() about why we can't use the first
  		 * state of "first" or "second" if they satisfy "FREE_EPSILON".
  		 */
! 		eps = mkstate (SYM_EPSILON);
  
! 		first = link_machines (eps, first);
  
! 		mkxtion (first, second);
  
! 		if (SUPER_FREE_EPSILON (finalst[first]) &&
! 		    accptnum[finalst[first]] == NIL) {
  			orend = finalst[first];
! 			mkxtion (finalst[second], orend);
! 		}
  
! 		else if (SUPER_FREE_EPSILON (finalst[second]) &&
! 			 accptnum[finalst[second]] == NIL) {
  			orend = finalst[second];
! 			mkxtion (finalst[first], orend);
! 		}
  
! 		else {
! 			eps = mkstate (SYM_EPSILON);
  
! 			first = link_machines (first, eps);
  			orend = finalst[first];
  
! 			mkxtion (finalst[second], orend);
  		}
+ 	}
  
  	finalst[first] = orend;
  	return first;
! }
  
  
  /* mkposcl - convert a machine into a positive closure
***************
*** 520,543 ****
   *    new - a machine matching the positive closure of "state"
   */
  
! int mkposcl( state )
! int state;
! 	{
! 	int eps;
  
! 	if ( SUPER_FREE_EPSILON(finalst[state]) )
! 		{
! 		mkxtion( finalst[state], state );
  		return state;
! 		}
  
! 	else
! 		{
! 		eps = mkstate( SYM_EPSILON );
! 		mkxtion( eps, state );
! 		return link_machines( state, eps );
! 		}
  	}
  
  
  /* mkrep - make a replicated machine
--- 525,546 ----
   *    new - a machine matching the positive closure of "state"
   */
  
! int     mkposcl (state)
!      int     state;
! {
! 	int     eps;
  
! 	if (SUPER_FREE_EPSILON (finalst[state])) {
! 		mkxtion (finalst[state], state);
  		return state;
! 	}
  
! 	else {
! 		eps = mkstate (SYM_EPSILON);
! 		mkxtion (eps, state);
! 		return link_machines (state, eps);
  	}
+ }
  
  
  /* mkrep - make a replicated machine
***************
*** 549,588 ****
   *          number of times to "ub" number of times
   *
   * note
!  *   if "ub" is INFINITY then "new" matches "lb" or more occurrences of "mach"
   */
  
! int mkrep( mach, lb, ub )
! int mach, lb, ub;
! 	{
! 	int base_mach, tail, copy, i;
  
! 	base_mach = copysingl( mach, lb - 1 );
  
! 	if ( ub == INFINITY )
! 		{
! 		copy = dupmachine( mach );
! 		mach = link_machines( mach,
! 		link_machines( base_mach, mkclos( copy ) ) );
! 		}
  
! 	else
! 		{
! 		tail = mkstate( SYM_EPSILON );
  
! 		for ( i = lb; i < ub; ++i )
! 			{
! 			copy = dupmachine( mach );
! 			tail = mkopt( link_machines( copy, tail ) );
! 			}
! 
! 		mach = link_machines( mach, link_machines( base_mach, tail ) );
  		}
  
! 	return mach;
  	}
  
  
  /* mkstate - create a state with a transition on a given symbol
   *
   * synopsis
--- 552,591 ----
   *          number of times to "ub" number of times
   *
   * note
!  *   if "ub" is INFINITE_REPEAT then "new" matches "lb" or more occurrences of "mach"
   */
  
! int     mkrep (mach, lb, ub)
!      int     mach, lb, ub;
! {
! 	int     base_mach, tail, copy, i;
  
! 	base_mach = copysingl (mach, lb - 1);
  
! 	if (ub == INFINITE_REPEAT) {
! 		copy = dupmachine (mach);
! 		mach = link_machines (mach,
! 				      link_machines (base_mach,
! 						     mkclos (copy)));
! 	}
  
! 	else {
! 		tail = mkstate (SYM_EPSILON);
  
! 		for (i = lb; i < ub; ++i) {
! 			copy = dupmachine (mach);
! 			tail = mkopt (link_machines (copy, tail));
  		}
  
! 		mach =
! 			link_machines (mach,
! 				       link_machines (base_mach, tail));
  	}
  
+ 	return mach;
+ }
  
+ 
  /* mkstate - create a state with a transition on a given symbol
   *
   * synopsis
***************
*** 599,628 ****
   * that it admittedly is)
   */
  
! int mkstate( sym )
! int sym;
! 	{
! 	if ( ++lastnfa >= current_mns )
! 		{
! 		if ( (current_mns += MNS_INCREMENT) >= MAXIMUM_MNS )
! 			lerrif(
! 		_( "input rules are too complicated (>= %d NFA states)" ),
! 				current_mns );
  
  		++num_reallocs;
  
! 		firstst = reallocate_integer_array( firstst, current_mns );
! 		lastst = reallocate_integer_array( lastst, current_mns );
! 		finalst = reallocate_integer_array( finalst, current_mns );
! 		transchar = reallocate_integer_array( transchar, current_mns );
! 		trans1 = reallocate_integer_array( trans1, current_mns );
! 		trans2 = reallocate_integer_array( trans2, current_mns );
! 		accptnum = reallocate_integer_array( accptnum, current_mns );
  		assoc_rule =
! 			reallocate_integer_array( assoc_rule, current_mns );
  		state_type =
! 			reallocate_integer_array( state_type, current_mns );
! 		}
  
  	firstst[lastnfa] = lastnfa;
  	finalst[lastnfa] = lastnfa;
--- 602,632 ----
   * that it admittedly is)
   */
  
! int     mkstate (sym)
!      int     sym;
! {
! 	if (++lastnfa >= current_mns) {
! 		if ((current_mns += MNS_INCREMENT) >= maximum_mns)
! 			lerrif (_
! 				("input rules are too complicated (>= %d NFA states)"),
! current_mns);
  
  		++num_reallocs;
  
! 		firstst = reallocate_integer_array (firstst, current_mns);
! 		lastst = reallocate_integer_array (lastst, current_mns);
! 		finalst = reallocate_integer_array (finalst, current_mns);
! 		transchar =
! 			reallocate_integer_array (transchar, current_mns);
! 		trans1 = reallocate_integer_array (trans1, current_mns);
! 		trans2 = reallocate_integer_array (trans2, current_mns);
! 		accptnum =
! 			reallocate_integer_array (accptnum, current_mns);
  		assoc_rule =
! 			reallocate_integer_array (assoc_rule, current_mns);
  		state_type =
! 			reallocate_integer_array (state_type, current_mns);
! 	}
  
  	firstst[lastnfa] = lastnfa;
  	finalst[lastnfa] = lastnfa;
***************
*** 643,670 ****
  	 * elsewhere in the input).
  	 */
  
! 	if ( sym < 0 )
! 		{
  		/* We don't have to update the equivalence classes since
  		 * that was already done when the ccl was created for the
  		 * first time.
  		 */
! 		}
  
! 	else if ( sym == SYM_EPSILON )
  		++numeps;
  
! 	else
! 		{
! 		check_char( sym );
  
! 		if ( useecs )
  			/* Map NUL's to csize. */
! 			mkechar( sym ? sym : csize, nextecm, ecgroup );
! 		}
  
  	return lastnfa;
! 	}
  
  
  /* mkxtion - make a transition from one state to another
--- 647,672 ----
  	 * elsewhere in the input).
  	 */
  
! 	if (sym < 0) {
  		/* We don't have to update the equivalence classes since
  		 * that was already done when the ccl was created for the
  		 * first time.
  		 */
! 	}
  
! 	else if (sym == SYM_EPSILON)
  		++numeps;
  
! 	else {
! 		check_char (sym);
  
! 		if (useecs)
  			/* Map NUL's to csize. */
! 			mkechar (sym ? sym : csize, nextecm, ecgroup);
! 	}
  
  	return lastnfa;
! }
  
  
  /* mkxtion - make a transition from one state to another
***************
*** 677,718 ****
   *     stateto   - the state to which the transition is to be made
   */
  
! void mkxtion( statefrom, stateto )
! int statefrom, stateto;
! 	{
! 	if ( trans1[statefrom] == NO_TRANSITION )
  		trans1[statefrom] = stateto;
  
! 	else if ( (transchar[statefrom] != SYM_EPSILON) ||
! 		  (trans2[statefrom] != NO_TRANSITION) )
! 		flexfatal( _( "found too many transitions in mkxtion()" ) );
  
! 	else
! 		{ /* second out-transition for an epsilon state */
  		++eps2;
  		trans2[statefrom] = stateto;
- 		}
  	}
  
  /* new_rule - initialize for a new rule */
  
! void new_rule()
! 	{
! 	if ( ++num_rules >= current_max_rules )
! 		{
  		++num_reallocs;
  		current_max_rules += MAX_RULES_INCREMENT;
! 		rule_type = reallocate_integer_array( rule_type,
! 							current_max_rules );
! 		rule_linenum = reallocate_integer_array( rule_linenum,
! 							current_max_rules );
! 		rule_useful = reallocate_integer_array( rule_useful,
! 							current_max_rules );
! 		}
  
! 	if ( num_rules > MAX_RULE )
! 		lerrif( _( "too many rules (> %d)!" ), MAX_RULE );
  
  	rule_linenum[num_rules] = linenum;
  	rule_useful[num_rules] = false;
! 	}
--- 679,721 ----
   *     stateto   - the state to which the transition is to be made
   */
  
! void    mkxtion (statefrom, stateto)
!      int     statefrom, stateto;
! {
! 	if (trans1[statefrom] == NO_TRANSITION)
  		trans1[statefrom] = stateto;
  
! 	else if ((transchar[statefrom] != SYM_EPSILON) ||
! 		 (trans2[statefrom] != NO_TRANSITION))
! 		flexfatal (_("found too many transitions in mkxtion()"));
  
! 	else {			/* second out-transition for an epsilon state */
  		++eps2;
  		trans2[statefrom] = stateto;
  	}
+ }
  
  /* new_rule - initialize for a new rule */
  
! void    new_rule ()
! {
! 	if (++num_rules >= current_max_rules) {
  		++num_reallocs;
  		current_max_rules += MAX_RULES_INCREMENT;
! 		rule_type = reallocate_integer_array (rule_type,
! 						      current_max_rules);
! 		rule_linenum = reallocate_integer_array (rule_linenum,
! 							 current_max_rules);
! 		rule_useful = reallocate_integer_array (rule_useful,
! 							current_max_rules);
! 		rule_has_nl = reallocate_bool_array (rule_has_nl,
! 						     current_max_rules);
! 	}
  
! 	if (num_rules > MAX_RULE)
! 		lerrif (_("too many rules (> %d)!"), MAX_RULE);
  
  	rule_linenum[num_rules] = linenum;
  	rule_useful[num_rules] = false;
! 	rule_has_nl[num_rules] = false;
! }