Source code upload

eoe/cmd/gnu/Makefile

@@ -0,0 +1,29 @@
+#
+# Makefile for irix/cmd/gnu
+#
+# $Revision: 1.1 $
+
+include	$(ROOT)/usr/include/make/commondefs
+
+#
+# Alphabetized, grouped list of subdirectories.
+#
+SUBDIRS= \
+	bison flex
+
+HEADERS_SUBDIRS=
+EXPORTS_SUBDIRS=
+
+default install $(COMMONTARGS): $(_FORCE)
+	$(SUBDIRS_MAKERULE)
+
+headers: $(_FORCE)
+	$(HEADERS_SUBDIRS_MAKERULE)
+
+exports: $(_FORCE)
+	$(EXPORTS_SUBDIRS_MAKERULE)
+
+$(SUBDIRS): $(_FORCE)
+	cd $@; $(MAKE)
+
+$(_FORCE):

eoe/cmd/gnu/bison/LR0.c

@@ -0,0 +1,702 @@
+/* Generate the nondeterministic finite state machine for bison,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* See comments in state.h for the data structures that represent it.
+   The entry point is generate_states.  */
+
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"
+#include "new.h"
+#include "gram.h"
+#include "state.h"
+
+
+extern char *nullable;
+extern short *itemset;
+extern short *itemsetend;
+
+
+int nstates;
+int final_state;
+core *first_state;
+shifts *first_shift;
+reductions *first_reduction;
+
+int get_state();
+core *new_state();
+
+void new_itemsets();
+void append_states();
+void initialize_states();
+void save_shifts();
+void save_reductions();
+void augment_automaton();
+void insert_start_shift();
+extern void initialize_closure();
+extern void closure();
+extern void finalize_closure();
+extern void toomany();
+
+static core *this_state;
+static core *last_state;
+static shifts *last_shift;
+static reductions *last_reduction;
+
+static int nshifts;
+static short *shift_symbol;
+
+static short *redset;
+static short *shiftset;
+
+static short **kernel_base;
+static short **kernel_end;
+static short *kernel_items;
+
+/* hash table for states, to recognize equivalent ones.  */
+
+#define	STATE_TABLE_SIZE	1009
+static core **state_table;
+
+
+
+void
+allocate_itemsets()
+{
+  register short *itemp;
+  register int symbol;
+  register int i;
+  register int count;
+  register short *symbol_count;
+
+  count = 0;
+  symbol_count = NEW2(nsyms, short);
+
+  itemp = ritem;
+  symbol = *itemp++;
+  while (symbol)
+    {
+      if (symbol > 0)
+	{
+	  count++;
+	  symbol_count[symbol]++;
+	}
+      symbol = *itemp++;
+    }
+
+  /* see comments before new_itemsets.  All the vectors of items
+     live inside kernel_items.  The number of active items after
+     some symbol cannot be more than the number of times that symbol
+     appears as an item, which is symbol_count[symbol].
+     We allocate that much space for each symbol.  */
+
+  kernel_base = NEW2(nsyms, short *);
+  kernel_items = NEW2(count, short);
+
+  count = 0;
+  for (i = 0; i < nsyms; i++)
+    {
+      kernel_base[i] = kernel_items + count;
+      count += symbol_count[i];
+    }
+
+  shift_symbol = symbol_count;
+  kernel_end = NEW2(nsyms, short *);
+}
+
+
+void
+allocate_storage()
+{
+  allocate_itemsets();
+
+  shiftset = NEW2(nsyms, short);
+  redset = NEW2(nrules + 1, short);
+  state_table = NEW2(STATE_TABLE_SIZE, core *);
+}
+
+
+void
+free_storage()
+{
+  FREE(shift_symbol);
+  FREE(redset);
+  FREE(shiftset);
+  FREE(kernel_base);
+  FREE(kernel_end);
+  FREE(kernel_items);
+  FREE(state_table);
+}
+
+
+
+/* compute the nondeterministic finite state machine (see state.h for details)
+from the grammar.  */
+void
+generate_states()
+{
+  allocate_storage();
+  initialize_closure(nitems);
+  initialize_states();
+
+  while (this_state)
+    {
+      /* Set up ruleset and itemset for the transitions out of this state.
+         ruleset gets a 1 bit for each rule that could reduce now.
+	 itemset gets a vector of all the items that could be accepted next.  */
+      closure(this_state->items, this_state->nitems);
+      /* record the reductions allowed out of this state */
+      save_reductions();
+      /* find the itemsets of the states that shifts can reach */
+      new_itemsets();
+      /* find or create the core structures for those states */
+      append_states();
+
+      /* create the shifts structures for the shifts to those states,
+         now that the state numbers transitioning to are known */
+      if (nshifts > 0)
+        save_shifts();
+
+      /* states are queued when they are created; process them all */
+      this_state = this_state->next;
+    }
+
+  /* discard various storage */
+  finalize_closure();
+  free_storage();
+
+  /* set up initial and final states as parser wants them */
+  augment_automaton();
+}
+
+
+
+/* Find which symbols can be shifted in the current state,
+   and for each one record which items would be active after that shift.
+   Uses the contents of itemset.
+   shift_symbol is set to a vector of the symbols that can be shifted.
+   For each symbol in the grammar, kernel_base[symbol] points to
+   a vector of item numbers activated if that symbol is shifted,
+   and kernel_end[symbol] points after the end of that vector.  */
+void
+new_itemsets()
+{
+  register int i;
+  register int shiftcount;
+  register short *isp;
+  register short *ksp;
+  register int symbol;
+
+#ifdef	TRACE
+  fprintf(stderr, "Entering new_itemsets\n");
+#endif
+
+  for (i = 0; i < nsyms; i++)
+    kernel_end[i] = NULL;
+
+  shiftcount = 0;
+
+  isp = itemset;
+
+  while (isp < itemsetend)
+    {
+      i = *isp++;
+      symbol = ritem[i];
+      if (symbol > 0)
+	{
+          ksp = kernel_end[symbol];
+
+          if (!ksp)
+	    {
+	      shift_symbol[shiftcount++] = symbol;
+	      ksp = kernel_base[symbol];
+	    }
+
+          *ksp++ = i + 1;
+          kernel_end[symbol] = ksp;
+	}
+    }
+
+  nshifts = shiftcount;
+}
+
+
+
+/* Use the information computed by new_itemsets to find the state numbers
+   reached by each shift transition from the current state.
+
+   shiftset is set up as a vector of state numbers of those states.  */
+void
+append_states()
+{
+  register int i;
+  register int j;
+  register int symbol;
+
+#ifdef	TRACE
+  fprintf(stderr, "Entering append_states\n");
+#endif
+
+  /* first sort shift_symbol into increasing order */
+
+  for (i = 1; i < nshifts; i++)
+    {
+      symbol = shift_symbol[i];
+      j = i;
+      while (j > 0 && shift_symbol[j - 1] > symbol)
+	{
+	  shift_symbol[j] = shift_symbol[j - 1];
+	  j--;
+	}
+      shift_symbol[j] = symbol;
+    }
+
+  for (i = 0; i < nshifts; i++)
+    {
+      symbol = shift_symbol[i];
+      shiftset[i] = get_state(symbol);
+    }
+}
+
+
+
+/* find the state number for the state we would get to
+(from the current state) by shifting symbol.
+Create a new state if no equivalent one exists already.
+Used by append_states  */
+
+int
+get_state(symbol)
+int symbol;
+{
+  register int key;
+  register short *isp1;
+  register short *isp2;
+  register short *iend;
+  register core *sp;
+  register int found;
+
+  int n;
+
+#ifdef	TRACE
+  fprintf(stderr, "Entering get_state, symbol = %d\n", symbol);
+#endif
+
+  isp1 = kernel_base[symbol];
+  iend = kernel_end[symbol];
+  n = iend - isp1;
+
+  /* add up the target state's active item numbers to get a hash key */
+  key = 0;
+  while (isp1 < iend)
+    key += *isp1++;
+
+  key = key % STATE_TABLE_SIZE;
+
+  sp = state_table[key];
+
+  if (sp)
+    {
+      found = 0;
+      while (!found)
+	{
+	  if (sp->nitems == n)
+	    {
+	      found = 1;
+	      isp1 = kernel_base[symbol];
+	      isp2 = sp->items;
+
+	      while (found && isp1 < iend)
+		{
+		  if (*isp1++ != *isp2++)
+		    found = 0;
+		}
+	    }
+
+	  if (!found)
+	    {
+	      if (sp->link)
+		{
+		  sp = sp->link;
+		}
+	      else   /* bucket exhausted and no match */
+		{
+		  sp = sp->link = new_state(symbol);
+		  found = 1;
+		}
+	    }
+	}
+    }
+  else      /* bucket is empty */
+    {
+      state_table[key] = sp = new_state(symbol);
+    }
+
+  return (sp->number);
+}
+
+
+
+/* subroutine of get_state.  create a new state for those items, if necessary.  */
+
+core *
+new_state(symbol)
+int symbol;
+{
+  register int n;
+  register core *p;
+  register short *isp1;
+  register short *isp2;
+  register short *iend;
+
+#ifdef	TRACE
+  fprintf(stderr, "Entering new_state, symbol = %d\n", symbol);
+#endif
+
+  if (nstates >= MAXSHORT)
+    toomany("states");
+
+  isp1 = kernel_base[symbol];
+  iend = kernel_end[symbol];
+  n = iend - isp1;
+
+  p = (core *) mallocate((unsigned) (sizeof(core) + (n - 1) * sizeof(short)));
+  p->accessing_symbol = symbol;
+  p->number = nstates;
+  p->nitems = n;
+
+  isp2 = p->items;
+  while (isp1 < iend)
+    *isp2++ = *isp1++;
+
+  last_state->next = p;
+  last_state = p;
+
+  nstates++;
+
+  return (p);
+}
+
+
+void
+initialize_states()
+{
+  register core *p;
+/*  register unsigned *rp1; JF unused */
+/*  register unsigned *rp2; JF unused */
+/*  register unsigned *rend; JF unused */
+
+  p = (core *) mallocate((unsigned) (sizeof(core) - sizeof(short)));
+  first_state = last_state = this_state = p;
+  nstates = 1;
+}
+
+
+void
+save_shifts()
+{
+  register shifts *p;
+  register short *sp1;
+  register short *sp2;
+  register short *send;
+
+  p = (shifts *) mallocate((unsigned) (sizeof(shifts) +
+				       (nshifts - 1) * sizeof(short)));
+
+  p->number = this_state->number;
+  p->nshifts = nshifts;
+
+  sp1 = shiftset;
+  sp2 = p->shifts;
+  send = shiftset + nshifts;
+
+  while (sp1 < send)
+    *sp2++ = *sp1++;
+
+  if (last_shift)
+    {
+      last_shift->next = p;
+      last_shift = p;
+    }
+  else
+    {
+      first_shift = p;
+      last_shift = p;
+    }
+}
+
+
+
+/* find which rules can be used for reduction transitions from the current state
+   and make a reductions structure for the state to record their rule numbers.  */
+void
+save_reductions()
+{
+  register short *isp;
+  register short *rp1;
+  register short *rp2;
+  register int item;
+  register int count;
+  register reductions *p;
+
+  short *rend;
+
+  /* find and count the active items that represent ends of rules */
+
+  count = 0;
+  for (isp = itemset; isp < itemsetend; isp++)
+    {
+      item = ritem[*isp];
+      if (item < 0)
+	{
+	  redset[count++] = -item;
+	}
+    }
+
+  /* make a reductions structure and copy the data into it.  */
+
+  if (count)
+    {
+      p = (reductions *) mallocate((unsigned) (sizeof(reductions) +
+					       (count - 1) * sizeof(short)));
+
+      p->number = this_state->number;
+      p->nreds = count;
+
+      rp1 = redset;
+      rp2 = p->rules;
+      rend = rp1 + count;
+
+      while (rp1 < rend)
+	*rp2++ = *rp1++;
+
+      if (last_reduction)
+	{
+	  last_reduction->next = p;
+	  last_reduction = p;
+	}
+      else
+	{
+	  first_reduction = p;
+	  last_reduction = p;
+	}
+    }
+}
+
+
+
+/* Make sure that the initial state has a shift that accepts the
+grammar's start symbol and goes to the next-to-final state,
+which has a shift going to the final state, which has a shift
+to the termination state.
+Create such states and shifts if they don't happen to exist already.  */
+void
+augment_automaton()
+{
+  register int i;
+  register int k;
+/*  register int found; JF unused */
+  register core *statep;
+  register shifts *sp;
+  register shifts *sp2;
+  register shifts *sp1;
+
+  sp = first_shift;
+
+  if (sp)
+    {
+      if (sp->number == 0)
+	{
+	  k = sp->nshifts;
+	  statep = first_state->next;
+
+	  /* The states reached by shifts from first_state are numbered 1...K.
+	     Look for one reached by start_symbol.  */
+	  while (statep->accessing_symbol < start_symbol
+		  && statep->number < k)
+	    statep = statep->next;
+
+	  if (statep->accessing_symbol == start_symbol)
+	    {
+	      /* We already have a next-to-final state.
+		 Make sure it has a shift to what will be the final state.  */
+	      k = statep->number;
+
+	      while (sp && sp->number < k)
+		{
+		  sp1 = sp;
+		  sp = sp->next;
+		}
+
+	      if (sp && sp->number == k)
+		{
+		  sp2 = (shifts *) mallocate((unsigned) (sizeof(shifts)
+							 + sp->nshifts * sizeof(short)));
+		  sp2->number = k;
+		  sp2->nshifts = sp->nshifts + 1;
+		  sp2->shifts[0] = nstates;
+		  for (i = sp->nshifts; i > 0; i--)
+		    sp2->shifts[i] = sp->shifts[i - 1];
+
+		  /* Patch sp2 into the chain of shifts in place of sp,
+		     following sp1.  */
+		  sp2->next = sp->next;
+		  sp1->next = sp2;
+		  if (sp == last_shift)
+		    last_shift = sp2;
+		  FREE(sp);
+		}
+	      else
+		{
+		  sp2 = NEW(shifts);
+		  sp2->number = k;
+		  sp2->nshifts = 1;
+		  sp2->shifts[0] = nstates;
+
+		  /* Patch sp2 into the chain of shifts between sp1 and sp.  */
+		  sp2->next = sp;
+		  sp1->next = sp2;
+		  if (sp == 0)
+		    last_shift = sp2;
+		}
+	    }
+	  else
+	    {
+	      /* There is no next-to-final state as yet.  */
+	      /* Add one more shift in first_shift,
+		 going to the next-to-final state (yet to be made).  */
+	      sp = first_shift;
+
+	      sp2 = (shifts *) mallocate(sizeof(shifts)
+					 + sp->nshifts * sizeof(short));
+	      sp2->nshifts = sp->nshifts + 1;
+
+	      /* Stick this shift into the vector at the proper place.  */
+	      statep = first_state->next;
+	      for (k = 0, i = 0; i < sp->nshifts; k++, i++)
+		{
+		  if (statep->accessing_symbol > start_symbol && i == k)
+		    sp2->shifts[k++] = nstates;
+		  sp2->shifts[k] = sp->shifts[i];
+		  statep = statep->next;
+		}
+
+	      /* Patch sp2 into the chain of shifts
+		 in place of sp, at the beginning.  */
+	      sp2->next = sp->next;
+	      first_shift = sp2;
+	      if (last_shift == sp)
+		last_shift = sp2;
+
+	      FREE(sp);
+
+	      /* Create the next-to-final state, with shift to
+		 what will be the final state.  */
+	      insert_start_shift();
+	    }
+	}
+      else
+	{
+	  /* The initial state didn't even have any shifts.
+	     Give it one shift, to the next-to-final state.  */
+	  sp = NEW(shifts);
+	  sp->nshifts = 1;
+	  sp->shifts[0] = nstates;
+
+	  /* Patch sp into the chain of shifts at the beginning.  */
+	  sp->next = first_shift;
+	  first_shift = sp;
+
+	  /* Create the next-to-final state, with shift to
+	     what will be the final state.  */
+	  insert_start_shift();
+	}
+    }
+  else
+    {
+      /* There are no shifts for any state.
+	 Make one shift, from the initial state to the next-to-final state.  */
+
+      sp = NEW(shifts);
+      sp->nshifts = 1;
+      sp->shifts[0] = nstates;
+
+      /* Initialize the chain of shifts with sp.  */
+      first_shift = sp;
+      last_shift = sp;
+
+      /* Create the next-to-final state, with shift to
+	 what will be the final state.  */
+      insert_start_shift();
+    }
+
+  /* Make the final state--the one that follows a shift from the
+     next-to-final state.
+     The symbol for that shift is 0 (end-of-file).  */
+  statep = (core *) mallocate((unsigned) (sizeof(core) - sizeof(short)));
+  statep->number = nstates;
+  last_state->next = statep;
+  last_state = statep;
+
+  /* Make the shift from the final state to the termination state.  */
+  sp = NEW(shifts);
+  sp->number = nstates++;
+  sp->nshifts = 1;
+  sp->shifts[0] = nstates;
+  last_shift->next = sp;
+  last_shift = sp;
+
+  /* Note that the variable `final_state' refers to what we sometimes call
+     the termination state.  */
+  final_state = nstates;
+
+  /* Make the termination state.  */
+  statep = (core *) mallocate((unsigned) (sizeof(core) - sizeof(short)));
+  statep->number = nstates++;
+  last_state->next = statep;
+  last_state = statep;
+}
+
+
+/* subroutine of augment_automaton.
+   Create the next-to-final state, to which a shift has already been made in
+   the initial state.  */
+void
+insert_start_shift()
+{
+  register core *statep;
+  register shifts *sp;
+
+  statep = (core *) mallocate((unsigned) (sizeof(core) - sizeof(short)));
+  statep->number = nstates;
+  statep->accessing_symbol = start_symbol;
+
+  last_state->next = statep;
+  last_state = statep;
+
+  /* Make a shift from this state to (what will be) the final state.  */
+  sp = NEW(shifts);
+  sp->number = nstates++;
+  sp->nshifts = 1;
+  sp->shifts[0] = nstates;
+
+  last_shift->next = sp;
+  last_shift = sp;
+}

eoe/cmd/gnu/bison/Makefile

@@ -0,0 +1,25 @@
+#
+include	$(ROOT)/usr/include/make/commondefs
+
+CFILES= LR0.c allocate.c closure.c conflicts.c derives.c files.c \
+	getargs.c getopt.c getopt1.c gram.c lalr.c lex.c main.c nullable.c \
+	output.c print.c reader.c reduce.c symtab.c version.c warshall.c alloca.c
+
+SIMPLE=bison.simple
+HAIRY=bison.hairy
+TARGETS=bison
+LLDLIBS=-lw
+LCOPTS=-DXPFILE=\"$(ROOT)/usr/lib/$(SIMPLE)\" \
+		-DXPFILE1=\"$(ROOT)/usr/lib/$(HAIRY)\"
+
+default: $(TARGETS)
+
+include $(COMMONRULES)
+
+bison: $(OBJECTS)
+	$(CCF) $(OBJECTS) $(LDFLAGS) -o $@
+
+install: default
+	$(INSTALL) -F /usr/sbin $(TARGETS)
+	$(INSTALL) -F /usr/lib $(SIMPLE)
+	$(INSTALL) -F /usr/lib $(HAIRY)

eoe/cmd/gnu/bison/alloca.c

@@ -0,0 +1,191 @@
+/*
+	alloca -- (mostly) portable public-domain implementation -- D A Gwyn
+
+	last edit:	86/05/30	rms
+	   include config.h, since on VMS it renames some symbols.
+	   Use xmalloc instead of malloc.
+
+	This implementation of the PWB library alloca() function,
+	which is used to allocate space off the run-time stack so
+	that it is automatically reclaimed upon procedure exit, 
+	was inspired by discussions with J. Q. Johnson of Cornell.
+
+	It should work under any C implementation that uses an
+	actual procedure stack (as opposed to a linked list of
+	frames).  There are some preprocessor constants that can
+	be defined when compiling for your specific system, for
+	improved efficiency; however, the defaults should be okay.
+
+	The general concept of this implementation is to keep
+	track of all alloca()-allocated blocks, and reclaim any
+	that are found to be deeper in the stack than the current
+	invocation.  This heuristic does not reclaim storage as
+	soon as it becomes invalid, but it will do so eventually.
+
+	As a special case, alloca(0) reclaims storage without
+	allocating any.  It is a good idea to use alloca(0) in
+	your main control loop, etc. to force garbage collection.
+*/
+#ifndef lint
+static char	SCCSid[] = "@(#)alloca.c	1.1";	/* for the "what" utility */
+#endif
+
+#ifdef emacs
+#include "config.h"
+#ifdef static
+/* actually, only want this if static is defined as ""
+   -- this is for usg, in which emacs must undefine static
+   in order to make unexec workable
+   */
+#ifndef STACK_DIRECTION
+you
+lose
+-- must know STACK_DIRECTION at compile-time
+#endif /* STACK_DIRECTION undefined */
+#endif /* static */
+#endif /* emacs */
+
+#ifdef __STDC__
+typedef void	*pointer;		/* generic pointer type */
+#else
+typedef char	*pointer;		/* generic pointer type */
+#endif
+
+#define	NULL	0			/* null pointer constant */
+
+extern void	free();
+extern pointer	xmalloc();
+
+/*
+	Define STACK_DIRECTION if you know the direction of stack
+	growth for your system; otherwise it will be automatically
+	deduced at run-time.
+
+	STACK_DIRECTION > 0 => grows toward higher addresses
+	STACK_DIRECTION < 0 => grows toward lower addresses
+	STACK_DIRECTION = 0 => direction of growth unknown
+*/
+
+#ifndef STACK_DIRECTION
+#define	STACK_DIRECTION	0		/* direction unknown */
+#endif
+
+#if STACK_DIRECTION != 0
+
+#define	STACK_DIR	STACK_DIRECTION	/* known at compile-time */
+
+#else	/* STACK_DIRECTION == 0; need run-time code */
+
+static int	stack_dir;		/* 1 or -1 once known */
+#define	STACK_DIR	stack_dir
+
+static void
+find_stack_direction (/* void */)
+{
+  static char	*addr = NULL;	/* address of first
+				   `dummy', once known */
+  auto char	dummy;		/* to get stack address */
+
+  if (addr == NULL)
+    {				/* initial entry */
+      addr = &dummy;
+
+      find_stack_direction ();	/* recurse once */
+    }
+  else				/* second entry */
+    if (&dummy > addr)
+      stack_dir = 1;		/* stack grew upward */
+    else
+      stack_dir = -1;		/* stack grew downward */
+}
+
+#endif	/* STACK_DIRECTION == 0 */
+
+/*
+	An "alloca header" is used to:
+	(a) chain together all alloca()ed blocks;
+	(b) keep track of stack depth.
+
+	It is very important that sizeof(header) agree with malloc()
+	alignment chunk size.  The following default should work okay.
+*/
+
+#ifndef	ALIGN_SIZE
+#define	ALIGN_SIZE	sizeof(double)
+#endif
+
+typedef union hdr
+{
+  char	align[ALIGN_SIZE];	/* to force sizeof(header) */
+  struct
+    {
+      union hdr *next;		/* for chaining headers */
+      char *deep;		/* for stack depth measure */
+    } h;
+} header;
+
+/*
+	alloca( size ) returns a pointer to at least `size' bytes of
+	storage which will be automatically reclaimed upon exit from
+	the procedure that called alloca().  Originally, this space
+	was supposed to be taken from the current stack frame of the
+	caller, but that method cannot be made to work for some
+	implementations of C, for example under Gould's UTX/32.
+*/
+
+static header *last_alloca_header = NULL; /* -> last alloca header */
+
+pointer
+alloca (size)			/* returns pointer to storage */
+     unsigned	size;		/* # bytes to allocate */
+{
+  auto char	probe;		/* probes stack depth: */
+  register char	*depth = &probe;
+
+#if STACK_DIRECTION == 0
+  if (STACK_DIR == 0)		/* unknown growth direction */
+    find_stack_direction ();
+#endif
+
+				/* Reclaim garbage, defined as all alloca()ed storage that
+				   was allocated from deeper in the stack than currently. */
+
+  {
+    register header	*hp;	/* traverses linked list */
+
+    for (hp = last_alloca_header; hp != NULL;)
+      if ((STACK_DIR > 0 && hp->h.deep > depth)
+	  || (STACK_DIR < 0 && hp->h.deep < depth))
+	{
+	  register header	*np = hp->h.next;
+
+	  free ((pointer) hp);	/* collect garbage */
+
+	  hp = np;		/* -> next header */
+	}
+      else
+	break;			/* rest are not deeper */
+
+    last_alloca_header = hp;	/* -> last valid storage */
+  }
+
+  if (size == 0)
+    return NULL;		/* no allocation required */
+
+  /* Allocate combined header + user data storage. */
+
+  {
+    register pointer	new = xmalloc (sizeof (header) + size);
+    /* address of header */
+
+    ((header *)new)->h.next = last_alloca_header;
+    ((header *)new)->h.deep = depth;
+
+    last_alloca_header = (header *)new;
+
+    /* User storage begins just after header. */
+
+    return (pointer)((char *)new + sizeof(header));
+  }
+}
+

eoe/cmd/gnu/bison/allocate.c

@@ -0,0 +1,54 @@
+/* Allocate and clear storage for bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include <stdio.h>
+
+extern char *calloc();
+extern void done();
+
+extern char *program_name;
+
+char *
+mallocate(n)
+register unsigned n;
+{
+  register char *block;
+
+  /* Avoid uncertainty about what an arg of 0 will do.  */
+  if (n == 0)
+    n = 1;
+  block = calloc(n,1);
+  if (block == NULL)
+    {
+      fprintf(stderr, "%s: memory exhausted\n", program_name);
+      done(1);
+    }
+
+  return (block);
+}
+
+/* This name is used by alloca.c.  */
+
+char *
+xmalloc (n)
+     unsigned int n;
+{
+  return mallocate (n);
+}

eoe/cmd/gnu/bison/bison.hairy

@@ -0,0 +1,334 @@
+
+extern int timeclock;
+
+
+int yyerror;		/*  Yyerror and yycost are set by guards.	*/
+int yycost;		/*  If yyerror is set to a nonzero value by a	*/
+			/*  guard, the reduction with which the guard	*/
+			/*  is associated is not performed, and the	*/
+			/*  error recovery mechanism is invoked.	*/
+			/*  Yycost indicates the cost of performing	*/
+			/*  the reduction given the attributes of the	*/
+			/*  symbols.					*/
+
+
+/*  YYMAXDEPTH indicates the size of the parser's state and value	*/
+/*  stacks.								*/
+
+#ifndef	YYMAXDEPTH
+#define	YYMAXDEPTH	500
+#endif
+
+/*  YYMAXRULES must be at least as large as the number of rules that	*/
+/*  could be placed in the rule queue.  That number could be determined	*/
+/*  from the grammar and the size of the stack, but, as yet, it is not.	*/
+
+#ifndef	YYMAXRULES
+#define	YYMAXRULES	100
+#endif
+
+#ifndef	YYMAXBACKUP
+#define YYMAXBACKUP	100
+#endif
+
+
+short	yyss[YYMAXDEPTH];	/*  the state stack			*/
+YYSTYPE	yyvs[YYMAXDEPTH];	/*  the semantic value stack		*/
+YYLTYPE yyls[YYMAXDEPTH];	/*  the location stack			*/
+short	yyrq[YYMAXRULES];	/*  the rule queue			*/
+int	yychar;			/*  the lookahead symbol		*/
+
+YYSTYPE	yylval;			/*  the semantic value of the		*/
+				/*  lookahead symbol			*/
+
+YYSTYPE yytval;			/*  the semantic value for the state	*/
+				/*  at the top of the state stack.	*/
+
+YYSTYPE yyval;			/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
+
+YYLTYPE yylloc;		/*  location data for the lookahead	*/
+				/*  symbol				*/
+
+YYLTYPE yytloc;		/*  location data for the state at the	*/
+				/*  top of the state stack		*/
+
+
+int	yynunlexed;
+short	yyunchar[YYMAXBACKUP];
+YYSTYPE	yyunval[YYMAXBACKUP];
+YYLTYPE yyunloc[YYMAXBACKUP];
+
+short *yygssp;			/*  a pointer to the top of the state	*/
+				/*  stack; only set during error	*/
+				/*  recovery.				*/
+
+YYSTYPE *yygvsp;		/*  a pointer to the top of the value	*/
+				/*  stack; only set during error	*/
+				/*  recovery.				*/
+
+YYLTYPE *yyglsp;		/*  a pointer to the top of the		*/
+				/*  location stack; only set during	*/
+				/*  error recovery.			*/
+
+
+/*  Yyget is an interface between the parser and the lexical analyzer.	*/
+/*  It is costly to provide such an interface, but it avoids requiring	*/
+/*  the lexical analyzer to be able to back up the scan.		*/
+
+yyget()
+{
+  if (yynunlexed > 0)
+    {
+      yynunlexed--;
+      yychar = yyunchar[yynunlexed];
+      yylval = yyunval[yynunlexed];
+      yylloc = yyunloc[yynunlexed];
+    }
+  else if (yychar <= 0)
+    yychar = 0;
+  else
+    {
+      yychar = yylex();
+      if (yychar < 0)
+	yychar = 0;
+      else yychar = YYTRANSLATE(yychar);
+    }
+}
+
+
+
+yyunlex(chr, val, loc)
+int chr;
+YYSTYPE val;
+YYLTYPE loc;
+{
+  yyunchar[yynunlexed] = chr;
+  yyunval[yynunlexed] = val;
+  yyunloc[yynunlexed] = loc;
+  yynunlexed++;
+}
+
+
+
+yyrestore(first, last)
+register short *first;
+register short *last;
+{
+  register short *ssp;
+  register short *rp;
+  register int symbol;
+  register int state;
+  register int tvalsaved;
+
+  ssp = yygssp;
+  yyunlex(yychar, yylval, yylloc);
+
+  tvalsaved = 0;
+  while (first != last)
+    {
+      symbol = yystos[*ssp];
+      if (symbol < YYNTBASE)
+	{
+	  yyunlex(symbol, yytval, yytloc);
+	  tvalsaved = 1;
+	  ssp--;
+	}
+
+      ssp--;
+
+      if (first == yyrq)
+	first = yyrq + YYMAXRULES;
+
+      first--;
+
+      for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
+	{
+	  if (symbol < YYNTBASE)
+	    state = yytable[yypact[*ssp] + symbol];
+	  else
+	    {
+	      state = yypgoto[symbol - YYNTBASE] + *ssp;
+
+	      if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
+		state = yytable[state];
+	      else
+		state = yydefgoto[symbol - YYNTBASE];
+	    }
+
+	  *++ssp = state;
+	}
+    }
+
+  if ( ! tvalsaved && ssp > yyss)
+    {
+      yyunlex(yystos[*ssp], yytval, yytloc);
+      ssp--;
+    }
+
+  yygssp = ssp;
+}
+
+
+
+int
+yyparse()
+{
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register short *yyrq0;
+  register short *yyptr;
+  register YYSTYPE *yyvsp;
+
+  int yylen;
+  YYLTYPE *yylsp;
+  short *yyrq1;
+  short *yyrq2;
+
+  yystate = 0;
+  yyssp = yyss - 1;
+  yyvsp = yyvs - 1;
+  yylsp = yyls - 1;
+  yyrq0 = yyrq;
+  yyrq1 = yyrq0;
+  yyrq2 = yyrq0;
+
+  yychar = yylex();
+  if (yychar < 0)
+    yychar = 0;
+  else yychar = YYTRANSLATE(yychar);
+
+yynewstate:
+
+  if (yyssp >= yyss + YYMAXDEPTH - 1)
+    {
+      yyabort("Parser Stack Overflow");
+      YYABORT;
+    }
+
+  *++yyssp = yystate;
+
+yyresume:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  yyn += yychar;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  yystate = yyn;
+
+  yyptr = yyrq2;
+  while (yyptr != yyrq1)
+    {
+      yyn = *yyptr++;
+      yylen = yyr2[yyn];
+      yyvsp -= yylen;
+      yylsp -= yylen;
+
+      yyguard(yyn, yyvsp, yylsp);
+      if (yyerror)
+	goto yysemerr;
+
+      yyaction(yyn, yyvsp, yylsp);
+      *++yyvsp = yyval;
+
+      yylsp++;
+      if (yylen == 0)
+	{
+	  yylsp->timestamp = timeclock;
+	  yylsp->first_line = yytloc.first_line;
+	  yylsp->first_column = yytloc.first_column;
+	  yylsp->last_line = (yylsp-1)->last_line;
+	  yylsp->last_column = (yylsp-1)->last_column;
+	  yylsp->text = 0;
+	}
+      else
+	{
+	  yylsp->last_line = (yylsp+yylen-1)->last_line;
+	  yylsp->last_column = (yylsp+yylen-1)->last_column;
+	}
+	  
+      if (yyptr == yyrq + YYMAXRULES)
+        yyptr = yyrq;
+    }
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  yyrq2 = yyptr;
+  yyrq1 = yyrq0;
+
+  *++yyvsp = yytval;
+  *++yylsp = yytloc;
+  yytval = yylval;
+  yytloc = yylloc;
+  yyget();
+
+  goto yynewstate;
+
+yydefault:
+
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+
+yyreduce:
+
+  *yyrq0++ = yyn;
+
+  if (yyrq0 == yyrq + YYMAXRULES)
+    yyrq0 = yyrq;
+
+  if (yyrq0 == yyrq2)
+    {
+      yyabort("Parser Rule Queue Overflow");
+      YYABORT;
+    }
+
+  yyssp -= yyr2[yyn];
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+yysemerr:
+  *--yyptr = yyn;
+  yyrq2 = yyptr;
+  yyvsp += yyr2[yyn];
+
+yyerrlab:
+
+  yygssp = yyssp;
+  yygvsp = yyvsp;
+  yyglsp = yylsp;
+  yyrestore(yyrq0, yyrq2);
+  yyrecover();
+  yystate = *yygssp;
+  yyssp = yygssp;
+  yyvsp = yygvsp;
+  yyrq0 = yyrq;
+  yyrq1 = yyrq0;
+  yyrq2 = yyrq0;
+  goto yyresume;
+}
+
+$

eoe/cmd/gnu/bison/bison.simple

@@ -0,0 +1,625 @@
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "bison.simple"
+
+/* Skeleton output parser for bison,
+   Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 1, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#ifndef alloca
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* not GNU C.  */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
+#include <alloca.h>
+#else /* not sparc */
+#if defined (MSDOS) && !defined (__TURBOC__)
+#include <malloc.h>
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+#include <malloc.h>
+ #pragma alloca
+#endif /* not _AIX */
+#endif /* not MSDOS, or __TURBOC__ */
+#endif /* not sparc.  */
+#endif /* not GNU C.  */
+#endif /* alloca not defined.  */
+
+/* This is the parser code that is written into each bison parser
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
+
+/* Note: there must be only one dollar sign in this file.
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		-2
+#define YYEOF		0
+#define YYACCEPT	return(0)
+#define YYABORT 	return(1)
+#define YYERROR		goto yyerrlab1
+/* Like YYERROR except do call yyerror.
+   This remains here temporarily to ease the
+   transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+#define YYFAIL		goto yyerrlab
+#define YYRECOVERING()  (!!yyerrstatus)
+#define YYBACKUP(token, value) \
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    { yychar = (token), yylval = (value);			\
+      yychar1 = YYTRANSLATE (yychar);				\
+      YYPOPSTACK;						\
+      goto yybackup;						\
+    }								\
+  else								\
+    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
+while (0)
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+#ifndef YYPURE
+#define YYLEX		yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#define YYLEX		yylex(&yylval, &yylloc)
+#else
+#define YYLEX		yylex(&yylval)
+#endif
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+int	yychar;			/*  the lookahead symbol		*/
+YYSTYPE	yylval;			/*  the semantic value of the		*/
+				/*  lookahead symbol			*/
+
+#ifdef YYLSP_NEEDED
+YYLTYPE yylloc;			/*  location data for the lookahead	*/
+				/*  symbol				*/
+#endif
+
+int yynerrs;			/*  number of parse errors so far       */
+#endif  /* not YYPURE */
+
+#if YYDEBUG != 0
+int yydebug;			/*  nonzero means print parse trace	*/
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
+#endif
+
+/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+
+#ifndef	YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/*  YYMAXDEPTH is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
+#define __yy_bcopy(FROM,TO,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
+#else				/* not GNU C or C++ */
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_bcopy (from, to, count)
+     char *from;
+     char *to;
+     int count;
+{
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_bcopy (char *from, char *to, int count)
+{
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#endif
+#endif
+
+#line 169 "bison.simple"
+int
+yyparse()
+{
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register YYSTYPE *yyvsp;
+  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int yychar1;		/*  lookahead token as an internal (translated) token number */
+
+  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
+  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
+
+  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+
+#define YYPOPSTACK   (yyvsp--, yysp--, yylsp--)
+#else
+#define YYPOPSTACK   (yyvsp--, yysp--)
+#endif
+
+  int yystacksize = YYINITDEPTH;
+
+#ifdef YYPURE
+  int yychar;
+  YYSTYPE yylval;
+  int yynerrs;
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylloc;
+#endif
+#endif
+
+  YYSTYPE yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
+
+  int yylen;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Starting parse\n");
+#endif
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.  */
+
+  yyssp = yyss - 1;
+  yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+  yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+yynewstate:
+
+  *++yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+      YYSTYPE *yyvs1 = yyvs;
+      short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+      YYLTYPE *yyls1 = yyls;
+#endif
+
+      /* Get the current used size of the three stacks, in elements.  */
+      int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      /* Each stack pointer address is followed by the size of
+	 the data in use in that stack, in bytes.  */
+      yyoverflow("parser stack overflow",
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+#ifdef YYLSP_NEEDED
+		 &yyls1, size * sizeof (*yylsp),
+#endif
+		 &yystacksize);
+
+      yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+      yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+      /* Extend the stack our own way.  */
+      if (yystacksize >= YYMAXDEPTH)
+	{
+	  yyerror("parser stack overflow");
+	  return 2;
+	}
+      yystacksize *= 2;
+      if (yystacksize > YYMAXDEPTH)
+	yystacksize = YYMAXDEPTH;
+      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+      __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+      __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+      __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + size - 1;
+      yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+      yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+      if (yyssp >= yyss + yystacksize - 1)
+	YYABORT;
+    }
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+ yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (yychar == YYEMPTY)
+    {
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Reading a token: ");
+#endif
+      yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+  if (yychar <= 0)		/* This means end of input. */
+    {
+      yychar1 = 0;
+      yychar = YYEOF;		/* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Now at end of input.\n");
+#endif
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+      if (yydebug)
+	{
+	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+	  /* Give the individual parser a way to print the precise meaning
+	     of a token, for further debugging info.  */
+#ifdef YYPRINT
+	  YYPRINT (stderr, yychar, yylval);
+#endif
+	  fprintf (stderr, ")\n");
+	}
+#endif
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+/* Do the default action for the current state.  */
+yydefault:
+
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+yyreduce:
+  yylen = yyr2[yyn];
+  yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      int i;
+
+      fprintf (stderr, "Reducing via rule %d (line %d), ",
+	       yyn, yyrline[yyn]);
+
+      /* Print the symboles being reduced, and their result.  */
+      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
+#endif
+
+$   /* the action file gets copied in in place of this dollarsign */
+#line 440 "bison.simple"
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+  *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+  yylsp++;
+  if (yylen == 0)
+    {
+      yylsp->first_line = yylloc.first_line;
+      yylsp->first_column = yylloc.first_column;
+      yylsp->last_line = (yylsp-1)->last_line;
+      yylsp->last_column = (yylsp-1)->last_column;
+      yylsp->text = 0;
+    }
+  else
+    {
+      yylsp->last_line = (yylsp+yylen-1)->last_line;
+      yylsp->last_column = (yylsp+yylen-1)->last_column;
+    }
+#endif
+
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+yyerrlab:   /* here on detecting error */
+
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
+      ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (yyn > YYFLAG && yyn < YYLAST)
+	{
+	  int size = 0;
+	  char *msg;
+	  int x, count;
+
+	  count = 0;
+	  for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+	    if (yycheck[x + yyn] == x)
+	      size += strlen(yytname[x]) + 15, count++;
+	  msg = (char *) xmalloc(size + 15);
+	  strcpy(msg, "parse error");
+
+	  if (count < 5)
+	    {
+	      count = 0;
+	      for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+		if (yycheck[x + yyn] == x)
+		  {
+		    strcat(msg, count == 0 ? ", expecting `" : " or `");
+		    strcat(msg, yytname[x]);
+		    strcat(msg, "'");
+		    count++;
+		  }
+	    }
+	  yyerror(msg);
+	  free(msg);
+	}
+      else
+#endif /* YYERROR_VERBOSE */
+	yyerror("parse error");
+    }
+
+yyerrlab1:   /* here on error raised explicitly by an action */
+
+  if (yyerrstatus == 3)
+    {
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+	YYABORT;
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+      yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
+
+  yyerrstatus = 3;		/* Each real token shifted decrements this */
+
+  goto yyerrhandle;
+
+yyerrdefault:  /* current state does not do anything special for the error token. */
+
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
+#endif
+
+yyerrpop:   /* pop the current state because it cannot handle the error token */
+
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+  yylsp--;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "Error: state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+yyerrhandle:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting error token, ");
+#endif
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  yystate = yyn;
+  goto yynewstate;
+}

eoe/cmd/gnu/bison/closure.c

@@ -0,0 +1,351 @@
+/* Subroutines for bison
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* subroutines of file LR0.c.
+
+Entry points:
+
+  closure (items, n)
+
+Given a vector of item numbers items, of length n,
+set up ruleset and itemset to indicate what rules could be run
+and which items could be accepted when those items are the active ones.
+
+ruleset contains a bit for each rule.  closure sets the bits
+for all rules which could potentially describe the next input to be read.
+
+itemset is a vector of item numbers; itemsetend points to just beyond the end
+ of the part of it that is significant.
+closure places there the indices of all items which represent units of
+input that could arrive next.
+
+  initialize_closure (n)
+
+Allocates the itemset and ruleset vectors,
+and precomputes useful data so that closure can be called.
+n is the number of elements to allocate for itemset.
+
+  finalize_closure ()
+
+Frees itemset, ruleset and internal data.
+
+*/
+
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"
+#include "new.h"
+#include "gram.h"
+
+
+extern short **derives;
+extern char **tags;
+
+void set_fderives();
+void set_firsts();
+
+extern void RTC();
+
+short *itemset;
+short *itemsetend;
+static unsigned *ruleset;
+
+/* internal data.  See comments before set_fderives and set_firsts.  */
+static unsigned *fderives;
+static unsigned *firsts;
+
+/* number of words required to hold a bit for each rule */
+static int rulesetsize;
+
+/* number of words required to hold a bit for each variable */
+static int varsetsize;
+
+
+void
+initialize_closure(n)
+int n;
+{
+  itemset = NEW2(n, short);
+
+  rulesetsize = WORDSIZE(nrules + 1);
+  ruleset = NEW2(rulesetsize, unsigned);
+
+  set_fderives();
+}
+
+
+
+/* set fderives to an nvars by nrules matrix of bits
+   indicating which rules can help derive the beginning of the data
+   for each nonterminal.  For example, if symbol 5 can be derived as
+   the sequence of symbols 8 3 20, and one of the rules for deriving
+   symbol 8 is rule 4, then the [5 - ntokens, 4] bit in fderives is set.  */
+void
+set_fderives()
+{
+  register unsigned *rrow;
+  register unsigned *vrow;
+  register int j;
+  register unsigned cword;
+  register short *rp;
+  register int b;
+
+  int ruleno;
+  int i;
+
+  fderives = NEW2(nvars * rulesetsize, unsigned) - ntokens * rulesetsize;
+
+  set_firsts();
+
+  rrow = fderives + ntokens * rulesetsize;
+
+  for (i = ntokens; i < nsyms; i++)
+    {
+      vrow = firsts + ((i - ntokens) * varsetsize);
+      cword = *vrow++;
+      b = 0;
+      for (j = ntokens; j < nsyms; j++)
+	{
+	  if (cword & (1 << b))
+	    {
+	      rp = derives[j];
+	      while ((ruleno = *rp++) > 0)
+		{
+		  SETBIT(rrow, ruleno);
+		}
+	    }
+
+	  b++;
+	  if (b >= BITS_PER_WORD && j + 1 < nsyms)
+	    {
+	      cword = *vrow++;
+	      b = 0;
+	    }
+	}
+
+      rrow += rulesetsize;
+    }
+
+#ifdef	DEBUG
+  print_fderives();
+#endif
+
+  FREE(firsts);
+}
+
+
+
+/* set firsts to be an nvars by nvars bit matrix indicating which items
+   can represent the beginning of the input corresponding to which other items.
+   For example, if some rule expands symbol 5 into the sequence of symbols 8 3 20,
+   the symbol 8 can be the beginning of the data for symbol 5,
+   so the bit [8 - ntokens, 5 - ntokens] in firsts is set. */
+void
+set_firsts()
+{
+  register unsigned *row;
+/*   register int done; JF unused */
+  register int symbol;
+  register short *sp;
+  register int rowsize;
+
+  int i;
+
+  varsetsize = rowsize = WORDSIZE(nvars);
+
+  firsts = NEW2(nvars * rowsize, unsigned);
+
+  row = firsts;
+  for (i = ntokens; i < nsyms; i++)
+    {
+      sp = derives[i];
+      while (*sp >= 0)
+	{
+	  symbol = ritem[rrhs[*sp++]];
+	  if (ISVAR(symbol))
+	    {
+	      symbol -= ntokens;
+	      SETBIT(row, symbol);
+	    }
+	}
+
+      row += rowsize;
+    }
+
+  RTC(firsts, nvars);
+
+#ifdef	DEBUG
+  print_firsts();
+#endif
+}
+
+
+void
+closure(core, n)
+short *core;
+int n;
+{
+  register int ruleno;
+  register unsigned word;
+  register short *csp;
+  register unsigned *dsp;
+  register unsigned *rsp;
+
+  short *csend;
+  unsigned *rsend;
+  int symbol;
+  int itemno;
+
+  rsp = ruleset;
+  rsend = ruleset + rulesetsize;
+  csend = core + n;
+
+  if (n == 0)
+    {
+      dsp = fderives + start_symbol * rulesetsize;
+      while (rsp < rsend)
+	*rsp++ = *dsp++;
+    }
+  else
+    {
+      while (rsp < rsend)
+	*rsp++ = 0;
+
+      csp = core;
+      while (csp < csend)
+	{
+	  symbol = ritem[*csp++];
+	  if (ISVAR(symbol))
+	    {
+	      dsp = fderives + symbol * rulesetsize;
+	      rsp = ruleset;
+	      while (rsp < rsend)
+		*rsp++ |= *dsp++;
+	    }
+	}
+    }
+
+  ruleno = 0;
+  itemsetend = itemset;
+  csp = core;
+  rsp = ruleset;
+  while (rsp < rsend)
+    {
+      word = *rsp++;
+      if (word == 0)
+	{
+	  ruleno += BITS_PER_WORD;
+	}
+      else
+	{
+	  register int b;
+
+	  for (b = 0; b < BITS_PER_WORD; b++)
+	    {
+	      if (word & (1 << b))
+		{
+		  itemno = rrhs[ruleno];
+		  while (csp < csend && *csp < itemno)
+		    *itemsetend++ = *csp++;
+		  *itemsetend++ = itemno;
+		}
+
+	      ruleno++;
+	    }
+	}
+    }
+
+  while (csp < csend)
+    *itemsetend++ = *csp++;
+
+#ifdef	DEBUG
+  print_closure(n);
+#endif
+}
+
+
+void
+finalize_closure()
+{
+  FREE(itemset);
+  FREE(ruleset);
+  FREE(fderives + ntokens * rulesetsize);
+}
+
+
+
+#ifdef	DEBUG
+
+print_closure(n)
+int n;
+{
+  register short *isp;
+
+  printf("\n\nn = %d\n\n", n);
+  for (isp = itemset; isp < itemsetend; isp++)
+    printf("   %d\n", *isp);
+}
+
+
+
+print_firsts()
+{
+  register int i;
+  register int j;
+  register unsigned *rowp;
+
+  printf("\n\n\nFIRSTS\n\n");
+
+  for (i = ntokens; i < nsyms; i++)
+    {
+      printf("\n\n%s firsts\n\n", tags[i]);
+
+      rowp = firsts + ((i - ntokens) * varsetsize);
+
+      for (j = 0; j < nvars; j++)
+	if (BITISSET (rowp, j))
+	  printf("   %s\n", tags[j + ntokens]);
+    }
+}
+
+
+
+print_fderives()
+{
+  register int i;
+  register int j;
+  register unsigned *rp;
+
+  printf("\n\n\nFDERIVES\n");
+
+  for (i = ntokens; i < nsyms; i++)
+    {
+      printf("\n\n%s derives\n\n", tags[i]);
+      rp = fderives + i * rulesetsize;
+
+      for (j = 0; j <= nrules; j++)
+	if (BITISSET (rp, j))
+	  printf("   %d\n", j);
+    }
+
+  fflush(stdout);
+}
+
+#endif

eoe/cmd/gnu/bison/conflicts.c

@@ -0,0 +1,773 @@
+/* Find and resolve or report look-ahead conflicts for bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifdef _AIX
+ #pragma alloca
+#endif
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"
+#include "new.h"
+#include "files.h"
+#include "gram.h"
+#include "state.h"
+
+
+#if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__)
+#define bcopy(s, d, n) memcpy ((d), (s), (n))
+#else
+#ifdef USG
+#include <memory.h>
+#define bcopy(src, dst, num) memcpy((dst), (src), (num))
+#endif
+#endif
+
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else
+#ifdef sparc
+#include <alloca.h>
+#else
+#ifndef _AIX
+extern char *alloca ();
+#endif
+#endif
+#endif
+
+extern char **tags;
+extern int tokensetsize;
+extern char *consistent;
+extern short *accessing_symbol;
+extern shifts **shift_table;
+extern unsigned *LA;
+extern short *LAruleno;
+extern short *lookaheads;
+extern int verboseflag;
+
+void set_conflicts();
+void resolve_sr_conflict();
+void flush_shift();
+void log_resolution();
+void total_conflicts();
+void count_sr_conflicts();
+void count_rr_conflicts();
+
+char any_conflicts;
+char *conflicts;
+errs **err_table;
+int expected_conflicts;
+
+
+static unsigned *shiftset;
+static unsigned *lookaheadset;
+static int src_total;
+static int rrc_total;
+static int src_count;
+static int rrc_count;
+
+
+void
+initialize_conflicts()
+{
+  register int i;
+/*  register errs *sp; JF unused */
+
+  conflicts = NEW2(nstates, char);
+  shiftset = NEW2(tokensetsize, unsigned);
+  lookaheadset = NEW2(tokensetsize, unsigned);
+
+  err_table = NEW2(nstates, errs *);
+
+  any_conflicts = 0;
+
+  for (i = 0; i < nstates; i++)
+    set_conflicts(i);
+}
+
+
+void
+set_conflicts(state)
+int state;
+{
+  register int i;
+  register int k;
+  register shifts *shiftp;
+  register unsigned *fp2;
+  register unsigned *fp3;
+  register unsigned *fp4;
+  register unsigned *fp1;
+  register int symbol;
+
+  if (consistent[state]) return;
+
+  for (i = 0; i < tokensetsize; i++)
+    lookaheadset[i] = 0;
+
+  shiftp = shift_table[state];
+  if (shiftp)
+    {
+      k = shiftp->nshifts;
+      for (i = 0; i < k; i++)
+	{
+	  symbol = accessing_symbol[shiftp->shifts[i]];
+	  if (ISVAR(symbol)) break;
+	  SETBIT(lookaheadset, symbol);
+	}
+    }
+
+  k = lookaheads[state + 1];
+  fp4 = lookaheadset + tokensetsize;
+
+  /* loop over all rules which require lookahead in this state */
+  /* first check for shift-reduce conflict, and try to resolve using precedence  */
+
+  for (i = lookaheads[state]; i < k; i++)
+    if (rprec[LAruleno[i]])
+      {
+	fp1 = LA + i * tokensetsize;
+	fp2 = fp1;
+	fp3 = lookaheadset;
+  
+	while (fp3 < fp4)
+	  {
+	    if (*fp2++ & *fp3++)
+	      {
+		resolve_sr_conflict(state, i);
+		break;
+	      }
+	  }
+      }
+
+  /* loop over all rules which require lookahead in this state */
+  /* Check for conflicts not resolved above.  */
+
+  for (i = lookaheads[state]; i < k; i++)
+    {
+      fp1 = LA + i * tokensetsize;
+      fp2 = fp1;
+      fp3 = lookaheadset;
+
+      while (fp3 < fp4)
+	{
+	  if (*fp2++ & *fp3++)
+	    {
+	      conflicts[state] = 1;
+	      any_conflicts = 1;
+	    }
+	}
+
+      fp2 = fp1;
+      fp3 = lookaheadset;
+
+      while (fp3 < fp4)
+	*fp3++ |= *fp2++;
+    }
+}
+
+
+
+/* Attempt to resolve shift-reduce conflict for one rule
+by means of precedence declarations.
+It has already been checked that the rule has a precedence.
+A conflict is resolved by modifying the shift or reduce tables
+so that there is no longer a conflict.  */
+
+void
+resolve_sr_conflict(state, lookaheadnum)
+int state;
+int lookaheadnum;
+{
+  register int i;
+  register int mask;
+  register unsigned *fp1;
+  register unsigned *fp2;
+  register int redprec;
+  errs *errp = (errs *) alloca (sizeof(errs) + ntokens * sizeof(short));
+  short *errtokens = errp->errs;
+
+  /* find the rule to reduce by to get precedence of reduction  */
+  redprec = rprec[LAruleno[lookaheadnum]];
+
+  mask = 1;
+  fp1 = LA + lookaheadnum * tokensetsize;
+  fp2 = lookaheadset;
+  for (i = 0; i < ntokens; i++)
+    {
+      if ((mask & *fp2 & *fp1) && sprec[i])
+	/* Shift-reduce conflict occurs for token number i
+	   and it has a precedence.
+	   The precedence of shifting is that of token i.  */
+	{
+	  if (sprec[i] < redprec)
+	    {
+	      if (verboseflag) log_resolution(state, lookaheadnum, i, "reduce");
+	      *fp2 &= ~mask;  /* flush the shift for this token */
+	      flush_shift(state, i);
+	    }
+	  else if (sprec[i] > redprec)
+	    {
+	      if (verboseflag) log_resolution(state, lookaheadnum, i, "shift");
+	      *fp1 &= ~mask;  /* flush the reduce for this token */
+	    }
+	  else
+	    {
+	      /* Matching precedence levels.
+		 For left association, keep only the reduction.
+		 For right association, keep only the shift.
+		 For nonassociation, keep neither.  */
+
+	      switch (sassoc[i])
+		{
+
+		case RIGHT_ASSOC:
+	          if (verboseflag) log_resolution(state, lookaheadnum, i, "shift");
+		  break;
+
+		case LEFT_ASSOC:
+	          if (verboseflag) log_resolution(state, lookaheadnum, i, "reduce");
+		  break;
+
+		case NON_ASSOC:
+	          if (verboseflag) log_resolution(state, lookaheadnum, i, "an error");
+		  break;
+		}
+
+	      if (sassoc[i] != RIGHT_ASSOC)
+		{
+		  *fp2 &= ~mask;  /* flush the shift for this token */
+		  flush_shift(state, i);
+		}
+	      if (sassoc[i] != LEFT_ASSOC)
+	        {
+		  *fp1 &= ~mask;  /* flush the reduce for this token */
+		}
+	      if (sassoc[i] == NON_ASSOC)
+		{
+		  /* Record an explicit error for this token.  */
+		  *errtokens++ = i;
+		}
+	    }
+	}
+
+      mask <<= 1;
+      if (mask == 0)
+	{
+	  mask = 1;
+	  fp2++;  fp1++;
+	}
+    }
+  errp->nerrs = errtokens - errp->errs;
+  if (errp->nerrs)
+    {
+      /* Some tokens have been explicitly made errors.  Allocate
+	 a permanent errs structure for this state, to record them.  */
+      i = (char *) errtokens - (char *) errp;
+      err_table[state] = (errs *) mallocate ((unsigned int)i);
+      bcopy (errp, err_table[state], i);
+    }
+  else
+    err_table[state] = 0;
+}
+
+
+
+/* turn off the shift recorded for the specified token in the specified state.
+Used when we resolve a shift-reduce conflict in favor of the reduction.  */
+
+void
+flush_shift(state, token)
+int state;
+int token;
+{
+  register shifts *shiftp;
+  register int k, i;
+/*  register unsigned symbol; JF unused */
+
+  shiftp = shift_table[state];
+
+  if (shiftp)
+    {
+      k = shiftp->nshifts;
+      for (i = 0; i < k; i++)
+	{
+	  if (shiftp->shifts[i] && token == accessing_symbol[shiftp->shifts[i]])
+	    (shiftp->shifts[i]) = 0;
+	}
+    }
+}
+
+
+void
+log_resolution(state, LAno, token, resolution)
+int state, LAno, token;
+char *resolution;
+{
+  fprintf(foutput,
+	  "Conflict in state %d between rule %d and token %s resolved as %s.\n",
+	  state, LAruleno[LAno], tags[token], resolution);
+}
+
+
+void
+conflict_log()
+{
+  register int i;
+
+  src_total = 0;
+  rrc_total = 0;
+
+  for (i = 0; i < nstates; i++)
+    {
+      if (conflicts[i])
+	{
+	  count_sr_conflicts(i);
+	  count_rr_conflicts(i);
+	  src_total += src_count;
+	  rrc_total += rrc_count;
+	}
+    }
+
+  total_conflicts();
+}
+  
+
+void
+verbose_conflict_log()
+{
+  register int i;
+
+  src_total = 0;
+  rrc_total = 0;
+
+  for (i = 0; i < nstates; i++)
+    {
+      if (conflicts[i])
+	{
+	  count_sr_conflicts(i);
+	  count_rr_conflicts(i);
+	  src_total += src_count;
+	  rrc_total += rrc_count;
+
+	  fprintf(foutput, "State %d contains", i);
+
+	  if (src_count == 1)
+	    fprintf(foutput, " 1 shift/reduce conflict");
+	  else if (src_count > 1)
+	    fprintf(foutput, " %d shift/reduce conflicts", src_count);
+
+	  if (src_count > 0 && rrc_count > 0)
+	    fprintf(foutput, " and");
+
+	  if (rrc_count == 1)
+	    fprintf(foutput, " 1 reduce/reduce conflict");
+	  else if (rrc_count > 1)
+	    fprintf(foutput, " %d reduce/reduce conflicts", rrc_count);
+
+	  putc('.', foutput);
+	  putc('\n', foutput);
+	}
+    }
+
+  total_conflicts();
+}
+
+
+void
+total_conflicts()
+{
+  extern int fixed_outfiles;
+
+  if (src_total == expected_conflicts && rrc_total == 0)
+    return;
+
+  if (fixed_outfiles)
+    {
+      /* If invoked under the name `yacc', use the output format
+	 specified by POSIX.  */
+      fprintf(stderr, "conflicts: ", infile);
+      if (src_total > 0)
+	fprintf(stderr, " %d shift/reduce", src_total);
+      if (src_total > 0 && rrc_total > 0)
+	fprintf(stderr, ",");
+      if (rrc_total > 0)
+	fprintf(stderr, " %d reduce/reduce", rrc_total);
+      putc('\n', stderr);
+    }
+  else
+    {
+      fprintf(stderr, "%s contains", infile);
+
+      if (src_total == 1)
+	fprintf(stderr, " 1 shift/reduce conflict");
+      else if (src_total > 1)
+	fprintf(stderr, " %d shift/reduce conflicts", src_total);
+
+      if (src_total > 0 && rrc_total > 0)
+	fprintf(stderr, " and");
+
+      if (rrc_total == 1)
+	fprintf(stderr, " 1 reduce/reduce conflict");
+      else if (rrc_total > 1)
+	fprintf(stderr, " %d reduce/reduce conflicts", rrc_total);
+
+      putc('.', stderr);
+      putc('\n', stderr);
+    }
+}
+
+
+void
+count_sr_conflicts(state)
+int state;
+{
+  register int i;
+  register int k;
+  register int mask;
+  register shifts *shiftp;
+  register unsigned *fp1;
+  register unsigned *fp2;
+  register unsigned *fp3;
+  register int symbol;
+
+  src_count = 0;
+
+  shiftp = shift_table[state];
+  if (!shiftp) return;
+
+  for (i = 0; i < tokensetsize; i++)
+    {
+      shiftset[i] = 0;
+      lookaheadset[i] = 0;
+    }
+
+  k = shiftp->nshifts;
+  for (i = 0; i < k; i++)
+    {
+      if (! shiftp->shifts[i]) continue;
+      symbol = accessing_symbol[shiftp->shifts[i]];
+      if (ISVAR(symbol)) break;
+      SETBIT(shiftset, symbol);
+    }
+
+  k = lookaheads[state + 1];
+  fp3 = lookaheadset + tokensetsize;
+
+  for (i = lookaheads[state]; i < k; i++)
+    {
+      fp1 = LA + i * tokensetsize;
+      fp2 = lookaheadset;
+
+      while (fp2 < fp3)
+	*fp2++ |= *fp1++;
+    }
+
+  fp1 = shiftset;
+  fp2 = lookaheadset;
+
+  while (fp2 < fp3)
+    *fp2++ &= *fp1++;
+
+  mask = 1;
+  fp2 = lookaheadset;
+  for (i = 0; i < ntokens; i++)
+    {
+      if (mask & *fp2)
+	src_count++;
+
+      mask <<= 1;
+      if (mask == 0)
+	{
+	  mask = 1;
+	  fp2++;
+	}
+    }
+}
+
+
+void
+count_rr_conflicts(state)
+int state;
+{
+  register int i;
+  register int j;
+  register int count;
+  register unsigned mask;
+  register unsigned *baseword;
+  register unsigned *wordp;
+  register int m;
+  register int n;
+
+  rrc_count = 0;
+
+  m = lookaheads[state];
+  n = lookaheads[state + 1];
+
+  if (n - m < 2) return;
+
+  mask = 1;
+  baseword = LA + m * tokensetsize;
+  for (i = 0; i < ntokens; i++)
+    {
+      wordp = baseword;
+
+      count = 0;
+      for (j = m; j < n; j++)
+	{
+	  if (mask & *wordp)
+	    count++;
+
+	  wordp += tokensetsize;
+	}
+
+      if (count >= 2) rrc_count++;
+
+      mask <<= 1;
+      if (mask == 0)
+	{
+	  mask = 1;
+	  baseword++;
+	}
+    }
+}
+
+
+void
+print_reductions(state)
+int state;
+{
+  register int i;
+  register int j;
+  register int k;
+  register unsigned *fp1;
+  register unsigned *fp2;
+  register unsigned *fp3;
+  register unsigned *fp4;
+  register int rule;
+  register int symbol;
+  register unsigned mask;
+  register int m;
+  register int n;
+  register int default_LA;
+  register int default_rule;
+  register int cmax;
+  register int count;
+  register shifts *shiftp;
+  register errs *errp;
+  int nodefault = 0;
+
+  for (i = 0; i < tokensetsize; i++)
+    shiftset[i] = 0;
+
+  shiftp = shift_table[state];
+  if (shiftp)
+    {
+      k = shiftp->nshifts;
+      for (i = 0; i < k; i++)
+	{
+	  if (! shiftp->shifts[i]) continue;
+	  symbol = accessing_symbol[shiftp->shifts[i]];
+	  if (ISVAR(symbol)) break;
+	  /* if this state has a shift for the error token,
+	     don't use a default rule.  */
+	  if (symbol == error_token_number) nodefault = 1;
+	  SETBIT(shiftset, symbol);
+	}
+    }
+
+  errp = err_table[state];
+  if (errp)
+    {
+      k = errp->nerrs;
+      for (i = 0; i < k; i++)
+	{
+	  if (! errp->errs[i]) continue;
+	  symbol = errp->errs[i];
+	  SETBIT(shiftset, symbol);
+	}
+    }
+
+  m = lookaheads[state];
+  n = lookaheads[state + 1];
+
+  if (n - m == 1 && ! nodefault)
+    {
+      default_rule = LAruleno[m];
+
+      fp1 = LA + m * tokensetsize;
+      fp2 = shiftset;
+      fp3 = lookaheadset;
+      fp4 = lookaheadset + tokensetsize;
+
+      while (fp3 < fp4)
+	*fp3++ = *fp1++ & *fp2++;
+
+      mask = 1;
+      fp3 = lookaheadset;
+
+      for (i = 0; i < ntokens; i++)
+	{
+	  if (mask & *fp3)
+	    fprintf(foutput, "    %-4s\t[reduce using rule %d (%s)]\n",
+		    tags[i], default_rule, tags[rlhs[default_rule]]);
+
+	  mask <<= 1;
+	  if (mask == 0)
+	    {
+	      mask = 1;
+	      fp3++;
+	    }
+	}
+
+      fprintf(foutput, "    $default\treduce using rule %d (%s)\n\n",
+	      default_rule, tags[rlhs[default_rule]]);
+    }
+  else if (n - m >= 1)
+    {
+      cmax = 0;
+      default_LA = -1;
+      fp4 = lookaheadset + tokensetsize;
+
+      if (! nodefault)
+	for (i = m; i < n; i++)
+	  {
+	    fp1 = LA + i * tokensetsize;
+	    fp2 = shiftset;
+	    fp3 = lookaheadset;
+  
+	    while (fp3 < fp4)
+	      *fp3++ = *fp1++ & ( ~ (*fp2++));
+  
+	    count = 0;
+	    mask = 1;
+	    fp3 = lookaheadset;
+	    for (j = 0; j < ntokens; j++)
+	      {
+		if (mask & *fp3)
+		  count++;
+  
+		mask <<= 1;
+		if (mask == 0)
+		  {
+		    mask = 1;
+		    fp3++;
+		  }
+	      }
+  
+	    if (count > cmax)
+	      {
+		cmax = count;
+		default_LA = i;
+		default_rule = LAruleno[i];
+	      }
+  
+	    fp2 = shiftset;
+	    fp3 = lookaheadset;
+  
+	    while (fp3 < fp4)
+	      *fp2++ |= *fp3++;
+	  }
+
+      for (i = 0; i < tokensetsize; i++)
+        shiftset[i] = 0;
+
+      if (shiftp)
+        {
+          k = shiftp->nshifts;
+          for (i = 0; i < k; i++)
+	    {
+	      if (! shiftp->shifts[i]) continue;
+	      symbol = accessing_symbol[shiftp->shifts[i]];
+	      if (ISVAR(symbol)) break;
+	      SETBIT(shiftset, symbol);
+	    }
+        }
+
+      mask = 1;
+      fp1 = LA + m * tokensetsize;
+      fp2 = shiftset;
+      for (i = 0; i < ntokens; i++)
+	{
+	  int defaulted = 0;
+
+	  if (mask & *fp2)
+	    count = 1;
+	  else
+	    count = 0;
+
+	  fp3 = fp1;
+	  for (j = m; j < n; j++)
+	    {
+	      if (mask & *fp3)
+		{
+		  if (count == 0)
+		    {
+		      if (j != default_LA)
+			{
+			  rule = LAruleno[j];
+			  fprintf(foutput, "    %-4s\treduce using rule %d (%s)\n",
+				  tags[i], rule, tags[rlhs[rule]]);
+			}
+		      else defaulted = 1;
+
+		      count++;
+		    }
+		  else
+		    {
+		      if (defaulted)
+			{
+			  rule = LAruleno[default_LA];
+			  fprintf(foutput, "    %-4s\treduce using rule %d (%s)\n",
+				  tags[i], rule, tags[rlhs[rule]]);
+			  defaulted = 0;
+			}
+		      rule = LAruleno[j];
+		      fprintf(foutput, "    %-4s\t[reduce using rule %d (%s)]\n",
+			      tags[i], rule, tags[rlhs[rule]]);
+		    }
+		}
+
+	      fp3 += tokensetsize;
+	    }
+
+	  mask <<= 1;
+	  if (mask == 0)
+	    {
+	      mask = 1;
+	      fp1++;
+	    }
+	}
+
+      if (default_LA >= 0)
+	{
+	  fprintf(foutput, "    $default\treduce using rule %d (%s)\n",
+		  default_rule, tags[rlhs[default_rule]]);
+	}
+
+      putc('\n', foutput);
+    }
+}
+
+
+void
+finalize_conflicts()
+{
+  FREE(conflicts);
+  FREE(shiftset);
+  FREE(lookaheadset);
+}

eoe/cmd/gnu/bison/derives.c

@@ -0,0 +1,118 @@
+/* Match rules with nonterminals for bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* set_derives finds, for each variable (nonterminal), which rules can derive it.
+   It sets up the value of derives so that
+   derives[i - ntokens] points to a vector of rule numbers,
+   terminated with -1.  */
+
+#include <stdio.h>
+#include "system.h"
+#include "new.h"
+#include "types.h"
+#include "gram.h"
+
+
+short **derives;
+
+void
+set_derives()
+{
+  register int i;
+  register int lhs;
+  register shorts *p;
+  register short *q;
+  register shorts **dset;
+  register shorts *delts;
+
+  dset = NEW2(nvars, shorts *) - ntokens;
+  delts = NEW2(nrules + 1, shorts);
+
+  p = delts;
+  for (i = nrules; i > 0; i--)
+    {
+      lhs = rlhs[i];
+      if (lhs >= 0)
+	{
+	  p->next = dset[lhs];
+	  p->value = i;
+	  dset[lhs] = p;
+	  p++;
+	}
+    }
+
+  derives = NEW2(nvars, short *) - ntokens;
+  q = NEW2(nvars + nrules, short);
+
+  for (i = ntokens; i < nsyms; i++)
+    {
+      derives[i] = q;
+      p = dset[i];
+      while (p)
+	{
+	  *q++ = p->value;
+	  p = p->next;
+	}
+      *q++ = -1;
+    }
+
+#ifdef	DEBUG
+  print_derives();
+#endif
+
+  FREE(dset + ntokens);
+  FREE(delts);
+}
+
+void
+free_derives()
+{
+  FREE(derives[ntokens]);
+  FREE(derives + ntokens);
+}
+
+
+
+#ifdef	DEBUG
+
+print_derives()
+{
+  register int i;
+  register short *sp;
+
+  extern char **tags;
+
+  printf("\n\n\nDERIVES\n\n");
+
+  for (i = ntokens; i < nsyms; i++)
+    {
+      printf("%s derives", tags[i]);
+      for (sp = derives[i]; *sp > 0; sp++)
+	{
+	  printf("  %d", *sp);
+	}
+      putchar('\n');
+    }
+
+  putchar('\n');
+}
+
+#endif
+

eoe/cmd/gnu/bison/files.c

@@ -0,0 +1,376 @@
+/* Open and close files for bison,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#ifdef VMS
+#include <ssdef.h>
+#define unlink delete
+#ifndef XPFILE
+#define XPFILE "GNU_BISON:[000000]BISON.SIMPLE"
+#endif
+#ifndef XPFILE1
+#define XPFILE1 "GNU_BISON:[000000]BISON.HAIRY"
+#endif
+#endif
+
+#include <stdio.h>
+#include "system.h"
+#include "files.h"
+#include "new.h"
+#include "gram.h"
+
+FILE *finput = NULL;
+FILE *foutput = NULL;
+FILE *fdefines = NULL;
+FILE *ftable = NULL;
+FILE *fattrs = NULL;
+FILE *fguard = NULL;
+FILE *faction = NULL;
+FILE *fparser = NULL;
+
+/* File name specified with -o for the output file, or 0 if no -o.  */
+char *spec_outfile;
+
+char *infile;
+char *outfile;
+char *defsfile;
+char *tabfile;
+char *attrsfile;
+char *guardfile;
+char *actfile;
+char *tmpattrsfile;
+char *tmptabfile;
+
+extern char	*mktemp();	/* So the compiler won't complain */
+extern char	*getenv();
+extern void	perror();
+extern void	exit();
+FILE	*tryopen();	/* This might be a good idea */
+void done();
+
+extern char *program_name;
+extern int verboseflag;
+extern int definesflag;
+int fixed_outfiles = 0;
+
+
+char*
+stringappend(string1, end1, string2)
+char *string1;
+int end1;
+char *string2;
+{
+  register char *ostring;
+  register char *cp, *cp1;
+  register int i;
+
+  cp = string2;  i = 0;
+  while (*cp++) i++;
+
+  ostring = NEW2(i+end1+1, char);
+
+  cp = ostring;
+  cp1 = string1;
+  for (i = 0; i < end1; i++)
+    *cp++ = *cp1++;
+
+  cp1 = string2;
+  while (*cp++ = *cp1++) ;
+
+  return ostring;
+}
+
+
+/* JF this has been hacked to death.  Nowaday it sets up the file names for
+   the output files, and opens the tmp files and the parser */
+void
+openfiles()
+{
+  char *name_base;
+  register char *cp;
+  char *filename;
+  int base_length;
+  int short_base_length;
+
+#ifdef VMS
+  char *tmp_base = "sys$scratch:b_";
+#else
+  char *tmp_base = "/tmp/b.";
+#endif
+  int tmp_len;
+
+#ifdef MSDOS
+  tmp_base = getenv ("TMP");
+  if (tmp_base == 0)
+    tmp_base = "";
+  strlwr (infile);
+#endif /* MSDOS */
+
+  tmp_len = strlen (tmp_base);
+
+  if (spec_outfile)
+    {
+      /* -o was specified.  The precise -o name will be used for ftable.
+	 For other output files, remove the ".c" or ".tab.c" suffix.  */
+      name_base = spec_outfile;
+#ifdef MSDOS
+      strlwr (name_base);
+#endif /* MSDOS */
+      /* BASE_LENGTH includes ".tab" but not ".c".  */
+      base_length = strlen (name_base);
+      if (!strcmp (name_base + base_length - 2, ".c"))
+	base_length -= 2;
+      /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
+      short_base_length = base_length;
+      if (!strncmp (name_base + short_base_length - 4, ".tab", 4))
+	short_base_length -= 4;
+      else if (!strncmp (name_base + short_base_length - 4, "_tab", 4))
+	short_base_length -= 4;
+    }
+  else if (spec_file_prefix)
+    {
+      /* -b was specified.  Construct names from it.  */
+      /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
+      short_base_length = strlen (spec_file_prefix);
+      /* Count room for `.tab'.  */
+      base_length = short_base_length + 4;
+      name_base = (char *) mallocate (base_length + 1);
+      /* Append `.tab'.  */
+      strcpy (name_base, spec_file_prefix);
+      strcat (name_base, ".tab");
+#ifdef MSDOS
+      strlwr (name_base);
+#endif /* MSDOS */
+    }
+  else
+    {
+      /* -o was not specified; compute output file name from input
+	 or use y.tab.c, etc., if -y was specified.  */
+
+      name_base = fixed_outfiles ? "y.y" : infile;
+
+      /* BASE_LENGTH gets length of NAME_BASE, sans ".y" suffix if any.  */
+
+      base_length = strlen (name_base);
+      if (!strcmp (name_base + base_length - 2, ".y"))
+	base_length -= 2;
+      short_base_length = base_length;
+
+#ifdef VMS
+      name_base = stringappend(name_base, short_base_length, "_tab");
+#else
+#ifdef MSDOS
+      name_base = stringappend(name_base, short_base_length, "_tab");
+#else
+      name_base = stringappend(name_base, short_base_length, ".tab");
+#endif /* not MSDOS */
+#endif
+      base_length = short_base_length + 4;
+    }
+
+  finput = tryopen(infile, "r");
+
+  filename = getenv("BISON_SIMPLE");
+#ifdef MSDOS
+  /* File doesn't exist in current directory; try in INIT directory.  */
+  cp = getenv("INIT");
+  if (filename == 0 && cp != 0)
+    {
+      filename = malloc(strlen(cp) + strlen(PFILE) + 2);
+      strcpy(filename, cp);
+      cp = filename + strlen(filename);
+      *cp++ = '/';
+      strcpy(cp, PFILE);
+    }
+#endif /* MSDOS */
+  fparser = tryopen(filename ? filename : PFILE, "r");
+
+  if (verboseflag)
+    {
+#ifdef MSDOS
+      outfile = stringappend(name_base, short_base_length, ".out");
+#else
+      if (spec_name_prefix)
+	outfile = stringappend(name_base, short_base_length, ".out");
+      else
+	outfile = stringappend(name_base, short_base_length, ".output");
+#endif
+      foutput = tryopen(outfile, "w");
+    }
+
+  if (definesflag)
+    {
+      defsfile = stringappend(name_base, base_length, ".h");
+      fdefines = tryopen(defsfile, "w");
+    }
+
+#ifdef MSDOS
+  actfile = mktemp(stringappend(tmp_base, tmp_len, "acXXXXXX"));
+  tmpattrsfile = mktemp(stringappend(tmp_base, tmp_len, "atXXXXXX"));
+  tmptabfile = mktemp(stringappend(tmp_base, tmp_len, "taXXXXXX"));
+#else
+  actfile = mktemp(stringappend(tmp_base, tmp_len, "act.XXXXXX"));
+  tmpattrsfile = mktemp(stringappend(tmp_base, tmp_len, "attrs.XXXXXX"));
+  tmptabfile = mktemp(stringappend(tmp_base, tmp_len, "tab.XXXXXX"));
+#endif /* not MSDOS */
+
+  faction = tryopen(actfile, "w+");
+  fattrs = tryopen(tmpattrsfile,"w+");
+  ftable = tryopen(tmptabfile, "w+");
+
+#ifndef MSDOS
+  unlink(actfile);
+  unlink(tmpattrsfile);
+  unlink(tmptabfile);
+#endif
+
+	/* These are opened by `done' or `open_extra_files', if at all */
+  if (spec_outfile)
+    tabfile = spec_outfile;
+  else
+    tabfile = stringappend(name_base, base_length, ".c");
+
+#ifdef VMS
+  attrsfile = stringappend(name_base, short_base_length, "_stype.h");
+  guardfile = stringappend(name_base, short_base_length, "_guard.c");
+#else
+#ifdef MSDOS
+  attrsfile = stringappend(name_base, short_base_length, ".sth");
+  guardfile = stringappend(name_base, short_base_length, ".guc");
+#else
+  attrsfile = stringappend(name_base, short_base_length, ".stype.h");
+  guardfile = stringappend(name_base, short_base_length, ".guard.c");
+#endif /* not MSDOS */
+#endif /* not VMS */
+}
+
+
+
+/* open the output files needed only for the semantic parser.
+This is done when %semantic_parser is seen in the declarations section.  */
+
+void
+open_extra_files()
+{
+  FILE *ftmp;
+  int c;
+  char *filename, *cp;
+
+  fclose(fparser);
+
+  filename = (char *) getenv ("BISON_HAIRY");
+#ifdef MSDOS
+  /* File doesn't exist in current directory; try in INIT directory.  */
+  cp = getenv("INIT");
+  if (filename == 0 && cp != 0)
+    {
+      filename = malloc(strlen(cp) + strlen(PFILE1) + 2);
+      strcpy(filename, cp);
+      cp = filename + strlen(filename);
+      *cp++ = '/';
+      strcpy(cp, PFILE1);
+    }
+#endif
+  fparser= tryopen(filename ? filename : PFILE1, "r");
+
+		/* JF change from inline attrs file to separate one */
+  ftmp = tryopen(attrsfile, "w");
+  rewind(fattrs);
+  while((c=getc(fattrs))!=EOF)	/* Thank god for buffering */
+    putc(c,ftmp);
+  fclose(fattrs);
+  fattrs=ftmp;
+
+  fguard = tryopen(guardfile, "w");
+
+}
+
+	/* JF to make file opening easier.  This func tries to open file
+	   NAME with mode MODE, and prints an error message if it fails. */
+FILE *
+tryopen(name, mode)
+char *name;
+char *mode;
+{
+  FILE	*ptr;
+
+  ptr = fopen(name, mode);
+  if (ptr == NULL)
+    {
+      fprintf(stderr, "%s: ", program_name);
+      perror(name);
+      done(2);
+    }
+  return ptr;
+}
+
+void
+done(k)
+int k;
+{
+  if (faction)
+    fclose(faction);
+
+  if (fattrs)
+    fclose(fattrs);
+
+  if (fguard)
+    fclose(fguard);
+
+  if (finput)
+    fclose(finput);
+
+  if (fparser)
+    fclose(fparser);
+
+  if (foutput)
+    fclose(foutput);
+
+	/* JF write out the output file */
+  if (k == 0 && ftable)
+    {
+      FILE *ftmp;
+      register int c;
+
+      ftmp=tryopen(tabfile, "w");
+      rewind(ftable);
+      while((c=getc(ftable)) != EOF)
+        putc(c,ftmp);
+      fclose(ftmp);
+      fclose(ftable);
+    }
+
+#ifdef VMS
+  if (faction)
+    delete(actfile);
+  if (fattrs)
+    delete(tmpattrsfile);
+  if (ftable)
+    delete(tmptabfile);
+  if (k==0) sys$exit(SS$_NORMAL);
+  sys$exit(SS$_ABORT);
+#else
+#ifdef MSDOS
+  if (actfile) unlink(actfile);
+  if (tmpattrsfile) unlink(tmpattrsfile);
+  if (tmptabfile) unlink(tmptabfile);
+#endif /* MSDOS */
+  exit(k);
+#endif /* not VMS */
+}

eoe/cmd/gnu/bison/files.h

@@ -0,0 +1,52 @@
+/* File names and variables for bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* These two should be pathnames for opening the sample parser files.
+   When bison is installed, they should be absolute pathnames.
+   XPFILE1 and XPFILE2 normally come from the Makefile.  */
+
+#define PFILE	XPFILE		/* Simple parser */
+#define PFILE1	XPFILE1		/* Semantic parser */
+
+extern FILE *finput;   /* read grammar specifications */
+extern FILE *foutput;  /* optionally output messages describing the actions taken */
+extern FILE *fdefines; /* optionally output #define's for token numbers. */
+extern FILE *ftable;   /* output the tables and the parser */
+extern FILE *fattrs;   /* if semantic parser, output a .h file that defines YYSTYPE */
+		       /* and also contains all the %{ ... %} definitions.  */
+extern FILE *fguard;   /* if semantic parser, output yyguard, containing all the guard code */
+extern FILE *faction;  /* output all the action code; precise form depends on which parser */
+extern FILE *fparser;  /* read the parser to copy into ftable */
+
+/* File name specified with -o for the output file, or 0 if no -o.  */
+extern char *spec_outfile;
+
+extern char *spec_name_prefix; /* for -a, from getargs.c */
+
+/* File name pfx specified with -b, or 0 if no -b.  */
+extern char *spec_file_prefix;
+
+extern char *infile;
+extern char *outfile;
+extern char *defsfile;
+extern char *tabfile;
+extern char *attrsfile;
+extern char *guardfile;
+extern char *actfile;

eoe/cmd/gnu/bison/getargs.c

@@ -0,0 +1,130 @@
+/* Parse command line arguments for bison,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include <stdio.h>
+#include "getopt.h"
+#include "system.h"
+#include "files.h"
+
+int verboseflag;
+int definesflag;
+int debugflag;
+int nolinesflag;
+char *spec_name_prefix; /* for -p.  */
+char *spec_file_prefix; /* for -b. */
+extern int fixed_outfiles;/* for -y */
+
+extern void fatal();
+
+struct option longopts[] =
+{
+  {"debug", 0, &debugflag, 1},
+  {"defines", 0, &definesflag, 1},
+  {"file-prefix", 1, 0, 'b'},
+  {"fixed-output-files", 0, &fixed_outfiles, 1},
+  {"name-prefix", 1, 0, 'a'},
+  {"no-lines", 0, &nolinesflag, 1},
+  {"output-file", 1, 0, 'o'},
+  {"verbose", 0, &verboseflag, 1},
+  {"version", 0, 0, 'V'},
+  {"yacc", 0, &fixed_outfiles, 1},
+  {0, 0, 0, 0}
+};
+
+void
+getargs(argc, argv)
+     int argc;
+     char *argv[];
+{
+  register int c;
+  int longind;
+  extern char *program_name;
+  extern char *version_string;
+
+  verboseflag = 0;
+  definesflag = 0;
+  debugflag = 0;
+  fixed_outfiles = 0;
+
+  while ((c = getopt_long (argc, argv, "yvdltVo:b:p:", longopts, &longind))
+	 != EOF)
+    {
+      if (c == 0 && longopts[longind].flag == 0)
+	c = longopts[longind].val;
+      switch (c)
+	{
+	case 'y':
+	  fixed_outfiles = 1;
+	  break;
+	  
+	case 'V':
+	  printf("%s", version_string);
+	  break;
+	  
+	case 'v':
+	  verboseflag = 1;
+	  break;
+	  
+	case 'd':
+	  definesflag = 1;
+	  break;
+	  
+	case 'l':
+	  nolinesflag = 1;
+	  break;
+	  
+	case 't':
+	  debugflag = 1;
+	  break;
+	  
+	case 'o':
+	  spec_outfile = optarg;
+	  break;
+	  
+	case 'b':
+	  spec_file_prefix = optarg;
+	  break;
+	  
+	case 'p':
+	  spec_name_prefix = optarg;
+	  break;
+	  
+	default:
+	  fprintf (stderr, "\
+Usage: %s [-dltvyV] [-b file-prefix] [-o outfile] [-p name-prefix]\n\
+       [--debug] [--defines] [--fixed-output-files] [--no-lines]\n\
+       [--verbose] [--version] [--yacc]\n\
+       [--file-prefix=prefix] [--name-prefix=prefix]\n\
+       [--output-file=outfile] grammar-file\n",
+		   program_name);
+	  exit (1);
+	}
+    }
+
+  if (optind == argc)
+    {
+      fprintf(stderr, "%s: no grammar file given\n", program_name);
+      exit(1);
+    }
+  if (optind < argc - 1)
+    fprintf(stderr, "%s: warning: extra arguments ignored\n", program_name);
+
+  infile = argv[optind];
+}

eoe/cmd/gnu/bison/getopt.c

@@ -0,0 +1,675 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 1992 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* AIX requires this to be the first thing in the file. */
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* not __GNUC__ */
+#ifdef sparc
+#include <alloca.h>
+#else
+#ifdef _AIX
+ #pragma alloca
+#else
+char *alloca ();
+#endif
+#endif /* sparc */
+#endif /* not __GNUC__ */
+
+#ifdef	LIBC
+/* For when compiled as part of the GNU C library.  */
+#include <ansidecl.h>
+#endif
+
+#include <stdio.h>
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef	__GNU_LIBRARY__
+#undef	alloca
+#include <stdlib.h>
+#else	/* Not GNU C library.  */
+#define	__alloca	alloca
+#endif	/* GNU C library.  */
+
+
+#ifndef __STDC__
+#define const
+#endif
+
+/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
+   long-named option.  Because this is not POSIX.2 compliant, it is
+   being phased out. */
+#define GETOPT_COMPAT
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg = 0;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+int optind = 0;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+#ifdef	__GNU_LIBRARY__
+#include <string.h>
+#define	my_index	strchr
+#define	my_bcopy(src, dst, n)	memcpy ((dst), (src), (n))
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+char *getenv ();
+
+static char *
+my_index (string, chr)
+     char *string;
+     int chr;
+{
+  while (*string)
+    {
+      if (*string == chr)
+	return string;
+      string++;
+    }
+  return 0;
+}
+
+static void
+my_bcopy (from, to, size)
+     char *from, *to;
+     int size;
+{
+  int i;
+  for (i = 0; i < size; i++)
+    to[i] = from[i];
+}
+#endif				/* GNU C library.  */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+static void
+exchange (argv)
+     char **argv;
+{
+  int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
+  char **temp = (char **) __alloca (nonopts_size);
+
+  /* Interchange the two blocks of data in ARGV.  */
+
+  my_bcopy (&argv[first_nonopt], temp, nonopts_size);
+  my_bcopy (&argv[last_nonopt], &argv[first_nonopt],
+	    (optind - last_nonopt) * sizeof (char *));
+  my_bcopy (temp, &argv[first_nonopt + optind - last_nonopt], nonopts_size);
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (optind - last_nonopt);
+  last_nonopt = optind;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns `EOF'.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+int
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+     const struct option *longopts;
+     int *longind;
+     int long_only;
+{
+  int option_index;
+
+  optarg = 0;
+
+  /* Initialize the internal data when the first call is made.
+     Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  if (optind == 0)
+    {
+      first_nonopt = last_nonopt = optind = 1;
+
+      nextchar = NULL;
+
+      /* Determine how to handle the ordering of options and nonoptions.  */
+
+      if (optstring[0] == '-')
+	{
+	  ordering = RETURN_IN_ORDER;
+	  ++optstring;
+	}
+      else if (optstring[0] == '+')
+	{
+	  ordering = REQUIRE_ORDER;
+	  ++optstring;
+	}
+      else if (getenv ("POSIXLY_CORRECT") != NULL)
+	ordering = REQUIRE_ORDER;
+      else
+	ordering = PERMUTE;
+    }
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      if (ordering == PERMUTE)
+	{
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (last_nonopt != optind)
+	    first_nonopt = optind;
+
+	  /* Now skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
+
+	  while (optind < argc
+		 && (argv[optind][0] != '-' || argv[optind][1] == '\0')
+#ifdef GETOPT_COMPAT
+		 && (longopts == NULL
+		     || argv[optind][0] != '+' || argv[optind][1] == '\0')
+#endif				/* GETOPT_COMPAT */
+		 )
+	    optind++;
+	  last_nonopt = optind;
+	}
+
+      /* Special ARGV-element `--' means premature end of options.
+	 Skip it like a null option,
+	 then exchange with previous non-options as if it were an option,
+	 then skip everything else like a non-option.  */
+
+      if (optind != argc && !strcmp (argv[optind], "--"))
+	{
+	  optind++;
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (first_nonopt == last_nonopt)
+	    first_nonopt = optind;
+	  last_nonopt = argc;
+
+	  optind = argc;
+	}
+
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+
+      if (optind == argc)
+	{
+	  /* Set the next-arg-index to point at the non-options
+	     that we previously skipped, so the caller will digest them.  */
+	  if (first_nonopt != last_nonopt)
+	    optind = first_nonopt;
+	  return EOF;
+	}
+
+      /* If we have come to a non-option and did not permute it,
+	 either stop the scan or describe it to the caller and pass it by.  */
+
+      if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
+#ifdef GETOPT_COMPAT
+	  && (longopts == NULL
+	      || argv[optind][0] != '+' || argv[optind][1] == '\0')
+#endif				/* GETOPT_COMPAT */
+	  )
+	{
+	  if (ordering == REQUIRE_ORDER)
+	    return EOF;
+	  optarg = argv[optind++];
+	  return 1;
+	}
+
+      /* We have found another option-ARGV-element.
+	 Start decoding its characters.  */
+
+      nextchar = (argv[optind] + 1
+		  + (longopts != NULL && argv[optind][1] == '-'));
+    }
+
+  if (longopts != NULL
+      && ((argv[optind][0] == '-'
+	   && (argv[optind][1] == '-' || long_only))
+#ifdef GETOPT_COMPAT
+	  || argv[optind][0] == '+'
+#endif				/* GETOPT_COMPAT */
+	  ))
+    {
+      const struct option *p;
+      char *s = nextchar;
+      int exact = 0;
+      int ambig = 0;
+      const struct option *pfound = NULL;
+      int indfound;
+
+      while (*s && *s != '=')
+	s++;
+
+      /* Test all options for either exact match or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name;
+	   p++, option_index++)
+	if (!strncmp (p->name, nextchar, s - nextchar))
+	  {
+	    if (s - nextchar == strlen (p->name))
+	      {
+		/* Exact match found.  */
+		pfound = p;
+		indfound = option_index;
+		exact = 1;
+		break;
+	      }
+	    else if (pfound == NULL)
+	      {
+		/* First nonexact match found.  */
+		pfound = p;
+		indfound = option_index;
+	      }
+	    else
+	      /* Second nonexact match found.  */
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (opterr)
+	    fprintf (stderr, "%s: option `%s' is ambiguous\n",
+		     argv[0], argv[optind]);
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  return '?';
+	}
+
+      if (pfound != NULL)
+	{
+	  option_index = indfound;
+	  optind++;
+	  if (*s)
+	    {
+	      if (pfound->has_arg > 0)
+		optarg = s + 1;
+	      else
+		{
+		  if (opterr)
+		    {
+		      if (argv[optind - 1][1] == '-')
+			/* --option */
+			fprintf (stderr,
+				 "%s: option `--%s' doesn't allow an argument\n",
+				 argv[0], pfound->name);
+		      else
+			/* +option or -option */
+			fprintf (stderr,
+			     "%s: option `%c%s' doesn't allow an argument\n",
+			     argv[0], argv[optind - 1][0], pfound->name);
+		    }
+		  nextchar += strlen (nextchar);
+		  return '?';
+		}
+	    }
+	  else if (pfound->has_arg == 1)
+	    {
+	      if (optind < argc)
+		optarg = argv[optind++];
+	      else
+		{
+		  if (opterr)
+		    fprintf (stderr, "%s: option `%s' requires an argument\n",
+			     argv[0], argv[optind - 1]);
+		  nextchar += strlen (nextchar);
+		  return '?';
+		}
+	    }
+	  nextchar += strlen (nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
+	    {
+	      *(pfound->flag) = pfound->val;
+	      return 0;
+	    }
+	  return pfound->val;
+	}
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+	 or the option starts with '--' or is not a valid short
+	 option, then it's an error.
+	 Otherwise interpret it as a short option. */
+      if (!long_only || argv[optind][1] == '-'
+#ifdef GETOPT_COMPAT
+	  || argv[optind][0] == '+'
+#endif				/* GETOPT_COMPAT */
+	  || my_index (optstring, *nextchar) == NULL)
+	{
+	  if (opterr)
+	    {
+	      if (argv[optind][1] == '-')
+		/* --option */
+		fprintf (stderr, "%s: unrecognized option `--%s'\n",
+			 argv[0], nextchar);
+	      else
+		/* +option or -option */
+		fprintf (stderr, "%s: unrecognized option `%c%s'\n",
+			 argv[0], argv[optind][0], nextchar);
+	    }
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  return '?';
+	}
+    }
+
+  /* Look at and handle the next option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `optind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      optind++;
+
+    if (temp == NULL || c == ':')
+      {
+	if (opterr)
+	  {
+	    if (c < 040 || c >= 0177)
+	      fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
+		       argv[0], c);
+	    else
+	      fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
+	  }
+	return '?';
+      }
+    if (temp[1] == ':')
+      {
+	if (temp[2] == ':')
+	  {
+	    /* This is an option that accepts an argument optionally.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		optind++;
+	      }
+	    else
+	      optarg = 0;
+	    nextchar = NULL;
+	  }
+	else
+	  {
+	    /* This is an option that requires an argument.  */
+	    if (*nextchar != 0)
+	      {
+		optarg = nextchar;
+		/* If we end this ARGV-element by taking the rest as an arg,
+		   we must advance to the next element now.  */
+		optind++;
+	      }
+	    else if (optind == argc)
+	      {
+		if (opterr)
+		  fprintf (stderr, "%s: option `-%c' requires an argument\n",
+			   argv[0], c);
+		c = '?';
+	      }
+	    else
+	      /* We already incremented `optind' once;
+		 increment it again when taking next ARGV-elt as argument.  */
+	      optarg = argv[optind++];
+	    nextchar = NULL;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+getopt (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  return _getopt_internal (argc, argv, optstring,
+			   (const struct option *) 0,
+			   (int *) 0,
+			   0);
+}
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `getopt'.  */
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+
+      c = getopt (argc, argv, "abc:d:0123456789");
+      if (c == EOF)
+	break;
+
+      switch (c)
+	{
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_optind != 0 && digit_optind != this_option_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_optind = this_option_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+	printf ("%s ", argv[optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */

eoe/cmd/gnu/bison/getopt.h

@@ -0,0 +1,107 @@
+/* Declarations for getopt.
+   Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _GETOPT_H_
+#define _GETOPT_H_
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+extern char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+extern int optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+   for unrecognized options.  */
+
+extern int opterr;
+
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct option' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument		(or 0) if the option does not take an argument,
+   required_argument	(or 1) if the option requires an argument,
+   optional_argument 	(or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `optarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct option
+{
+#ifdef	__STDC__
+  const char *name;
+#else
+  char *name;
+#endif
+  enum
+    {
+      no_argument,
+      required_argument,
+      optional_argument
+    } has_arg;
+  int *flag;
+  int val;
+};
+
+#ifdef __STDC__
+extern int getopt (int argc, char *const *argv, const char *shortopts);
+extern int getopt_long (int argc, char *const *argv, const char *shortopts,
+		        const struct option *longopts, int *longind);
+extern int getopt_long_only (int argc, char *const *argv,
+			     const char *shortopts,
+		             const struct option *longopts, int *longind);
+
+/* Internal only.  Users should not call this directly.  */
+extern int _getopt_internal (int argc, char *const *argv,
+			     const char *shortopts,
+		             const struct option *longopts, int *longind,
+			     int long_only);
+#else /* not __STDC__ */
+extern int getopt ();
+extern int getopt_long ();
+extern int getopt_long_only ();
+
+extern int _getopt_internal ();
+#endif /* not __STDC__ */
+
+#endif /* _GETOPT_H_ */

eoe/cmd/gnu/bison/getopt1.c

@@ -0,0 +1,158 @@
+/* Getopt for GNU.
+   Copyright (C) 1987, 88, 89, 90, 91, 1992 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifdef	LIBC
+/* For when compiled as part of the GNU C library.  */
+#include <ansidecl.h>
+#endif
+
+#include "getopt.h"
+
+#ifndef __STDC__
+#define const
+#endif
+
+#if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__) || defined (LIBC)
+#include <stdlib.h>
+#else /* STDC_HEADERS or __GNU_LIBRARY__ */
+char *getenv ();
+#endif /* STDC_HEADERS or __GNU_LIBRARY__ */
+
+#if !defined (NULL)
+#define NULL 0
+#endif
+
+int
+getopt_long (argc, argv, options, long_options, opt_index)
+     int argc;
+     char *const *argv;
+     const char *options;
+     const struct option *long_options;
+     int *opt_index;
+{
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+}
+
+/* Like getopt_long, but '-' as well as '--' can indicate a long option.
+   If an option that starts with '-' (not '--') doesn't match a long option,
+   but does match a short option, it is parsed as a short option
+   instead. */
+
+int 
+getopt_long_only (argc, argv, options, long_options, opt_index)
+     int argc;
+     char *const *argv;
+     const char *options;
+     const struct option *long_options;
+     int *opt_index;
+{
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+}
+
+#ifdef TEST
+
+#include <stdio.h>
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+      int option_index = 0;
+      static struct option long_options[] =
+      {
+	{"add", 1, 0, 0},
+	{"append", 0, 0, 0},
+	{"delete", 1, 0, 0},
+	{"verbose", 0, 0, 0},
+	{"create", 0, 0, 0},
+	{"file", 1, 0, 0},
+	{0, 0, 0, 0}
+      };
+
+      c = getopt_long (argc, argv, "abc:d:0123456789",
+		       long_options, &option_index);
+      if (c == EOF)
+	break;
+
+      switch (c)
+	{
+	case 0:
+	  printf ("option %s", long_options[option_index].name);
+	  if (optarg)
+	    printf (" with arg %s", optarg);
+	  printf ("\n");
+	  break;
+
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_optind != 0 && digit_optind != this_option_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_optind = this_option_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", optarg);
+	  break;
+
+	case 'd':
+	  printf ("option d with value `%s'\n", optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+	printf ("%s ", argv[optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */

eoe/cmd/gnu/bison/gram.c

@@ -0,0 +1,58 @@
+/* Allocate input grammar variables for bison,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* comments for these variables are in gram.h  */
+
+int nitems;
+int nrules;
+int nsyms;
+int ntokens;
+int nvars;
+
+short *ritem;
+short *rlhs;
+short *rrhs;
+short *rprec;
+short *rprecsym;
+short *sprec;
+short *rassoc;
+short *sassoc;
+short *token_translations;
+short *rline;
+
+int start_symbol;
+
+int translations;
+
+int max_user_token_number;
+
+int semantic_parser;
+
+int pure_parser;
+
+int error_token_number;
+
+/* This is to avoid linker problems which occur on VMS when using GCC,
+   when the file in question contains data definitions only.  */
+
+void
+dummy()
+{
+}

eoe/cmd/gnu/bison/gram.h

@@ -0,0 +1,120 @@
+/* Data definitions for internal representation of bison's input,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* representation of the grammar rules:
+
+ntokens is the number of tokens, and nvars is the number of variables
+(nonterminals).  nsyms is the total number, ntokens + nvars.
+
+Each symbol (either token or variable) receives a symbol number.
+Numbers 0 to ntokens-1 are for tokens, and ntokens to nsyms-1 are for
+variables.  Symbol number zero is the end-of-input token.  This token
+is counted in ntokens.
+
+The rules receive rule numbers 1 to nrules in the order they are written.
+Actions and guards are accessed via the rule number.
+
+The rules themselves are described by three arrays: rrhs, rlhs and
+ritem.  rlhs[R] is the symbol number of the left hand side of rule R.
+The right hand side is stored as symbol numbers in a portion of
+ritem.  rrhs[R] contains the index in ritem of the beginning of the
+portion for rule R.
+
+If rlhs[R] is -1, the rule has been thrown out by reduce.c
+and should be ignored.
+
+The length of the portion is one greater
+ than the number of symbols in the rule's right hand side.
+The last element in the portion contains minus R, which
+identifies it as the end of a portion and says which rule it is for.
+
+The portions of ritem come in order of increasing rule number and are
+followed by an element which is zero to mark the end.  nitems is the
+total length of ritem, not counting the final zero.  Each element of
+ritem is called an "item" and its index in ritem is an item number.
+
+Item numbers are used in the finite state machine to represent
+places that parsing can get to.
+
+Precedence levels are recorded in the vectors sprec and rprec.
+sprec records the precedence level of each symbol,
+rprec the precedence level of each rule.
+rprecsym is the symbol-number of the symbol in %prec for this rule (if any).
+
+Precedence levels are assigned in increasing order starting with 1 so
+that numerically higher precedence values mean tighter binding as they
+ought to.  Zero as a symbol or rule's precedence means none is
+assigned.
+
+Associativities are recorded similarly in rassoc and sassoc.  */
+
+
+#define	ISTOKEN(s)	((s) < ntokens)
+#define	ISVAR(s)	((s) >= ntokens)
+
+
+extern int nitems;
+extern int nrules;
+extern int nsyms;
+extern int ntokens;
+extern int nvars;
+
+extern short *ritem;
+extern short *rlhs;
+extern short *rrhs;
+extern short *rprec;
+extern short *rprecsym;
+extern short *sprec;
+extern short *rassoc;
+extern short *sassoc;
+extern short *rline;		/* Source line number of each rule */
+
+extern int start_symbol;
+
+
+/* associativity values in elements of rassoc, sassoc.  */
+
+#define RIGHT_ASSOC 1
+#define LEFT_ASSOC 2
+#define NON_ASSOC 3
+
+/* token translation table:
+indexed by a token number as returned by the user's yylex routine,
+it yields the internal token number used by the parser and throughout bison.
+If translations is zero, the translation table is not used because
+the two kinds of token numbers are the same.  */
+
+extern short *token_translations;
+extern int translations;
+extern int max_user_token_number;
+
+/* semantic_parser is nonzero if the input file says to use the hairy parser
+that provides for semantic error recovery.  If it is zero, the yacc-compatible
+simplified parser is used.  */
+
+extern int semantic_parser;
+
+/* pure_parser is nonzero if should generate a parser that is all pure and reentrant. */
+
+extern int pure_parser;
+
+/* error_token_number is the token number of the error token.  */
+
+extern int error_token_number;

eoe/cmd/gnu/bison/lalr.c

@@ -0,0 +1,770 @@
+/* Compute look-ahead criteria for bison,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* Compute how to make the finite state machine deterministic;
+ find which rules need lookahead in each state, and which lookahead tokens they accept.
+
+lalr(), the entry point, builds these data structures:
+
+goto_map, from_state and to_state 
+ record each shift transition which accepts a variable (a nonterminal).
+ngotos is the number of such transitions.
+from_state[t] is the state number which a transition leads from
+and to_state[t] is the state number it leads to.
+All the transitions that accept a particular variable are grouped together and
+goto_map[i - ntokens] is the index in from_state and to_state of the first of them.
+
+consistent[s] is nonzero if no lookahead is needed to decide what to do in state s.
+
+LAruleno is a vector which records the rules that need lookahead in various states.
+The elements of LAruleno that apply to state s are those from
+ lookaheads[s] through lookaheads[s+1]-1.
+Each element of LAruleno is a rule number.
+
+If lr is the length of LAruleno, then a number from 0 to lr-1 
+can specify both a rule and a state where the rule might be applied.
+
+LA is a lr by ntokens matrix of bits.
+LA[l, i] is 1 if the rule LAruleno[l] is applicable in the appropriate state
+ when the next token is symbol i.
+If LA[l, i] and LA[l, j] are both 1 for i != j, it is a conflict.
+*/
+
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"
+#include "types.h"
+#include "state.h"
+#include "new.h"
+#include "gram.h"
+
+
+extern short **derives;
+extern char *nullable;
+
+
+int tokensetsize;
+short *lookaheads;
+short *LAruleno;
+unsigned *LA;
+short *accessing_symbol;
+char *consistent;
+core **state_table;
+shifts **shift_table;
+reductions **reduction_table;
+short *goto_map;
+short *from_state;
+short *to_state;
+
+short **transpose();
+void set_state_table();
+void set_accessing_symbol();
+void set_shift_table();
+void set_reduction_table();
+void set_maxrhs();
+void initialize_LA();
+void set_goto_map();
+void initialize_F();
+void build_relations();
+void add_lookback_edge();
+void compute_FOLLOWS();
+void compute_lookaheads();
+void digraph();
+void traverse();
+
+extern void toomany();
+extern void berror();
+
+static int infinity;
+static int maxrhs;
+static int ngotos;
+static unsigned *F;
+static short **includes;
+static shorts **lookback;
+static short **R;
+static short *INDEX;
+static short *VERTICES;
+static int top;
+
+
+void
+lalr()
+{
+  tokensetsize = WORDSIZE(ntokens);
+
+  set_state_table();
+  set_accessing_symbol();
+  set_shift_table();
+  set_reduction_table();
+  set_maxrhs();
+  initialize_LA();
+  set_goto_map();
+  initialize_F();
+  build_relations();
+  compute_FOLLOWS();
+  compute_lookaheads();
+}
+
+
+void
+set_state_table()
+{
+  register core *sp;
+
+  state_table = NEW2(nstates, core *);
+
+  for (sp = first_state; sp; sp = sp->next)
+    state_table[sp->number] = sp;
+}
+
+
+void
+set_accessing_symbol()
+{
+  register core *sp;
+
+  accessing_symbol = NEW2(nstates, short);
+
+  for (sp = first_state; sp; sp = sp->next)
+    accessing_symbol[sp->number] = sp->accessing_symbol;
+}
+
+
+void
+set_shift_table()
+{
+  register shifts *sp;
+
+  shift_table = NEW2(nstates, shifts *);
+
+  for (sp = first_shift; sp; sp = sp->next)
+    shift_table[sp->number] = sp;
+}
+
+
+void
+set_reduction_table()
+{
+  register reductions *rp;
+
+  reduction_table = NEW2(nstates, reductions *);
+
+  for (rp = first_reduction; rp; rp = rp->next)
+    reduction_table[rp->number] = rp;
+}
+
+
+void
+set_maxrhs()
+{
+  register short *itemp;
+  register int length;
+  register int max;
+
+  length = 0;
+  max = 0;
+  for (itemp = ritem; *itemp; itemp++)
+    {
+      if (*itemp > 0)
+	{
+	  length++;
+	}
+      else
+	{
+	  if (length > max) max = length;
+	  length = 0;
+	}
+    }
+
+  maxrhs = max;
+}
+
+
+void
+initialize_LA()
+{
+  register int i;
+  register int j;
+  register int count;
+  register reductions *rp;
+  register shifts *sp;
+  register short *np;
+
+  consistent = NEW2(nstates, char);
+  lookaheads = NEW2(nstates + 1, short);
+
+  count = 0;
+  for (i = 0; i < nstates; i++)
+    {
+      register int k;
+
+      lookaheads[i] = count;
+
+      rp = reduction_table[i];
+      sp = shift_table[i];
+      if (rp && (rp->nreds > 1
+          || (sp && ! ISVAR(accessing_symbol[sp->shifts[0]]))))
+	count += rp->nreds;
+      else
+	consistent[i] = 1;
+
+      if (sp)
+	for (k = 0; k < sp->nshifts; k++)
+	  {
+	    if (accessing_symbol[sp->shifts[k]] == error_token_number)
+	      {
+		consistent[i] = 0;
+		break;
+	      }
+	  }
+    }
+
+  lookaheads[nstates] = count;
+
+  if (count == 0)
+    {
+      LA = NEW2(1 * tokensetsize, unsigned);
+      LAruleno = NEW2(1, short);
+      lookback = NEW2(1, shorts *);
+    }
+  else
+    {
+      LA = NEW2(count * tokensetsize, unsigned);
+      LAruleno = NEW2(count, short);
+      lookback = NEW2(count, shorts *);
+    }
+
+  np = LAruleno;
+  for (i = 0; i < nstates; i++)
+    {
+      if (!consistent[i])
+	{
+	  if (rp = reduction_table[i])
+	    for (j = 0; j < rp->nreds; j++)
+	      *np++ = rp->rules[j];
+	}
+    }
+}
+
+
+void
+set_goto_map()
+{
+  register shifts *sp;
+  register int i;
+  register int symbol;
+  register int k;
+  register short *temp_map;
+  register int state2;
+  register int state1;
+
+  goto_map = NEW2(nvars + 1, short) - ntokens;
+  temp_map = NEW2(nvars + 1, short) - ntokens;
+
+  ngotos = 0;
+  for (sp = first_shift; sp; sp = sp->next)
+    {
+      for (i = sp->nshifts - 1; i >= 0; i--)
+	{
+	  symbol = accessing_symbol[sp->shifts[i]];
+
+	  if (ISTOKEN(symbol)) break;
+
+	  if (ngotos == MAXSHORT)
+	    toomany("gotos");
+
+	  ngotos++;
+	  goto_map[symbol]++;
+        }
+    }
+
+  k = 0;
+  for (i = ntokens; i < nsyms; i++)
+    {
+      temp_map[i] = k;
+      k += goto_map[i];
+    }
+
+  for (i = ntokens; i < nsyms; i++)
+    goto_map[i] = temp_map[i];
+
+  goto_map[nsyms] = ngotos;
+  temp_map[nsyms] = ngotos;
+
+  from_state = NEW2(ngotos, short);
+  to_state = NEW2(ngotos, short);
+
+  for (sp = first_shift; sp; sp = sp->next)
+    {
+      state1 = sp->number;
+      for (i = sp->nshifts - 1; i >= 0; i--)
+	{
+	  state2 = sp->shifts[i];
+	  symbol = accessing_symbol[state2];
+
+	  if (ISTOKEN(symbol)) break;
+
+	  k = temp_map[symbol]++;
+	  from_state[k] = state1;
+	  to_state[k] = state2;
+	}
+    }
+
+  FREE(temp_map + ntokens);
+}
+
+
+
+/*  Map_goto maps a state/symbol pair into its numeric representation.	*/
+
+int
+map_goto(state, symbol)
+int state;
+int symbol;
+{
+  register int high;
+  register int low;
+  register int middle;
+  register int s;
+
+  low = goto_map[symbol];
+  high = goto_map[symbol + 1] - 1;
+
+  while (low <= high)
+    {
+      middle = (low + high) / 2;
+      s = from_state[middle];
+      if (s == state)
+	return (middle);
+      else if (s < state)
+	low = middle + 1;
+      else
+	high = middle - 1;
+    }
+
+  berror("map_goto");
+/* NOTREACHED */
+  return 0;
+}
+
+
+void
+initialize_F()
+{
+  register int i;
+  register int j;
+  register int k;
+  register shifts *sp;
+  register short *edge;
+  register unsigned *rowp;
+  register short *rp;
+  register short **reads;
+  register int nedges;
+  register int stateno;
+  register int symbol;
+  register int nwords;
+
+  nwords = ngotos * tokensetsize;
+  F = NEW2(nwords, unsigned);
+
+  reads = NEW2(ngotos, short *);
+  edge = NEW2(ngotos + 1, short);
+  nedges = 0;
+
+  rowp = F;
+  for (i = 0; i < ngotos; i++)
+    {
+      stateno = to_state[i];
+      sp = shift_table[stateno];
+
+      if (sp)
+	{
+	  k = sp->nshifts;
+
+	  for (j = 0; j < k; j++)
+	    {
+	      symbol = accessing_symbol[sp->shifts[j]];
+	      if (ISVAR(symbol))
+		break;
+	      SETBIT(rowp, symbol);
+	    }
+
+	  for (; j < k; j++)
+	    {
+	      symbol = accessing_symbol[sp->shifts[j]];
+	      if (nullable[symbol])
+		edge[nedges++] = map_goto(stateno, symbol);
+	    }
+	
+	  if (nedges)
+	    {
+	      reads[i] = rp = NEW2(nedges + 1, short);
+
+	      for (j = 0; j < nedges; j++)
+		rp[j] = edge[j];
+
+	      rp[nedges] = -1;
+	      nedges = 0;
+	    }
+	}
+
+      rowp += tokensetsize;
+    }
+
+  digraph(reads);
+
+  for (i = 0; i < ngotos; i++)
+    {
+      if (reads[i])
+	FREE(reads[i]);
+    }
+
+  FREE(reads);
+  FREE(edge);
+}
+
+
+void
+build_relations()
+{
+  register int i;
+  register int j;
+  register int k;
+  register short *rulep;
+  register short *rp;
+  register shifts *sp;
+  register int length;
+  register int nedges;
+  register int done;
+  register int state1;
+  register int stateno;
+  register int symbol1;
+  register int symbol2;
+  register short *shortp;
+  register short *edge;
+  register short *states;
+  register short **new_includes;
+
+  includes = NEW2(ngotos, short *);
+  edge = NEW2(ngotos + 1, short);
+  states = NEW2(maxrhs + 1, short);
+
+  for (i = 0; i < ngotos; i++)
+    {
+      nedges = 0;
+      state1 = from_state[i];
+      symbol1 = accessing_symbol[to_state[i]];
+
+      for (rulep = derives[symbol1]; *rulep > 0; rulep++)
+	{
+	  length = 1;
+	  states[0] = state1;
+	  stateno = state1;
+
+	  for (rp = ritem + rrhs[*rulep]; *rp > 0; rp++)
+	    {
+	      symbol2 = *rp;
+	      sp = shift_table[stateno];
+	      k = sp->nshifts;
+
+	      for (j = 0; j < k; j++)
+		{
+		  stateno = sp->shifts[j];
+		  if (accessing_symbol[stateno] == symbol2) break;
+		}
+
+	      states[length++] = stateno;
+	    }
+
+	  if (!consistent[stateno])
+	    add_lookback_edge(stateno, *rulep, i);
+
+	  length--;
+	  done = 0;
+	  while (!done)
+	    {
+	      done = 1;
+	      rp--;
+			/* JF added rp>=ritem &&   I hope to god its right! */
+	      if (rp>=ritem && ISVAR(*rp))
+		{
+		  stateno = states[--length];
+		  edge[nedges++] = map_goto(stateno, *rp);
+		  if (nullable[*rp]) done = 0;
+		}
+	    }
+	}
+
+      if (nedges)
+	{
+	  includes[i] = shortp = NEW2(nedges + 1, short);
+	  for (j = 0; j < nedges; j++)
+	    shortp[j] = edge[j];
+	  shortp[nedges] = -1;
+	}
+    }
+
+  new_includes = transpose(includes, ngotos);
+
+  for (i = 0; i < ngotos; i++)
+    if (includes[i])
+      FREE(includes[i]);
+
+  FREE(includes);
+
+  includes = new_includes;
+
+  FREE(edge);
+  FREE(states);
+}
+
+
+void
+add_lookback_edge(stateno, ruleno, gotono)
+int stateno;
+int ruleno;
+int gotono;
+{
+  register int i;
+  register int k;
+  register int found;
+  register shorts *sp;
+
+  i = lookaheads[stateno];
+  k = lookaheads[stateno + 1];
+  found = 0;
+  while (!found && i < k)
+    {
+      if (LAruleno[i] == ruleno)
+	found = 1;
+      else
+	i++;
+    }
+
+  if (found == 0)
+    berror("add_lookback_edge");
+
+  sp = NEW(shorts);
+  sp->next = lookback[i];
+  sp->value = gotono;
+  lookback[i] = sp;
+}
+
+
+
+short **
+transpose(R_arg, n)
+short **R_arg;
+int n;
+{
+  register short **new_R;
+  register short **temp_R;
+  register short *nedges;
+  register short *sp;
+  register int i;
+  register int k;
+
+  nedges = NEW2(n, short);
+
+  for (i = 0; i < n; i++)
+    {
+      sp = R_arg[i];
+      if (sp)
+	{
+	  while (*sp >= 0)
+	    nedges[*sp++]++;
+	}
+    }
+
+  new_R = NEW2(n, short *);
+  temp_R = NEW2(n, short *);
+
+  for (i = 0; i < n; i++)
+    {
+      k = nedges[i];
+      if (k > 0)
+	{
+	  sp = NEW2(k + 1, short);
+	  new_R[i] = sp;
+	  temp_R[i] = sp;
+	  sp[k] = -1;
+	}
+    }
+
+  FREE(nedges);
+
+  for (i = 0; i < n; i++)
+    {
+      sp = R_arg[i];
+      if (sp)
+	{
+	  while (*sp >= 0)
+	    *temp_R[*sp++]++ = i;
+	}
+    }
+
+  FREE(temp_R);
+
+  return (new_R);
+}
+
+
+void
+compute_FOLLOWS()
+{
+  register int i;
+
+  digraph(includes);
+
+  for (i = 0; i < ngotos; i++)
+    {
+      if (includes[i]) FREE(includes[i]);
+    }
+
+  FREE(includes);
+}
+
+
+void
+compute_lookaheads()
+{
+  register int i;
+  register int n;
+  register unsigned *fp1;
+  register unsigned *fp2;
+  register unsigned *fp3;
+  register shorts *sp;
+  register unsigned *rowp;
+/*   register short *rulep; JF unused */
+/*  register int count; JF unused */
+  register shorts *sptmp;/* JF */
+
+  rowp = LA;
+  n = lookaheads[nstates];
+  for (i = 0; i < n; i++)
+    {
+      fp3 = rowp + tokensetsize;
+      for (sp = lookback[i]; sp; sp = sp->next)
+	{
+	  fp1 = rowp;
+	  fp2 = F + tokensetsize * sp->value;
+	  while (fp1 < fp3)
+	    *fp1++ |= *fp2++;
+	}
+
+      rowp = fp3;
+    }
+
+  for (i = 0; i < n; i++)
+    {/* JF removed ref to freed storage */
+      for (sp = lookback[i]; sp; sp = sptmp) {
+	sptmp=sp->next;
+	FREE(sp);
+      }
+    }
+
+  FREE(lookback);
+  FREE(F);
+}
+
+
+void
+digraph(relation)
+short **relation;
+{
+  register int i;
+
+  infinity = ngotos + 2;
+  INDEX = NEW2(ngotos + 1, short);
+  VERTICES = NEW2(ngotos + 1, short);
+  top = 0;
+
+  R = relation;
+
+  for (i = 0; i < ngotos; i++)
+    INDEX[i] = 0;
+
+  for (i = 0; i < ngotos; i++)
+    {
+      if (INDEX[i] == 0 && R[i])
+	traverse(i);
+    }
+
+  FREE(INDEX);
+  FREE(VERTICES);
+}
+
+
+void
+traverse(i)
+register int i;
+{
+  register unsigned *fp1;
+  register unsigned *fp2;
+  register unsigned *fp3;
+  register int j;
+  register short *rp;
+
+  int height;
+  unsigned *base;
+
+  VERTICES[++top] = i;
+  INDEX[i] = height = top;
+
+  base = F + i * tokensetsize;
+  fp3 = base + tokensetsize;
+
+  rp = R[i];
+  if (rp)
+    {
+      while ((j = *rp++) >= 0)
+	{
+	  if (INDEX[j] == 0)
+	    traverse(j);
+
+	  if (INDEX[i] > INDEX[j])
+	    INDEX[i] = INDEX[j];
+
+	  fp1 = base;
+	  fp2 = F + j * tokensetsize;
+
+	  while (fp1 < fp3)
+	    *fp1++ |= *fp2++;
+	}
+    }
+
+  if (INDEX[i] == height)
+    {
+      for (;;)
+	{
+	  j = VERTICES[top--];
+	  INDEX[j] = infinity;
+
+	  if (i == j)
+	    break;
+
+	  fp1 = base;
+	  fp2 = F + j * tokensetsize;
+
+	  while (fp1 < fp3)
+	    *fp2++ = *fp1++;
+	}
+    }
+}

eoe/cmd/gnu/bison/lex.c

@@ -0,0 +1,501 @@
+/* Token-reader for Bison's input parser,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* 
+   lex() is the entry point.  It is called from reader.c.
+   It returns one of the token-type codes defined in lex.h.
+   When an identifier is seen, the code IDENTIFIER is returned
+   and the name is looked up in the symbol table using symtab.c;
+   symval is set to a pointer to the entry found.  */
+
+#include <stdio.h>
+#include <ctype.h>
+#include "system.h"
+#include "files.h"
+#include "symtab.h"
+#include "lex.h"
+#include "new.h"
+
+
+extern int lineno;
+extern int translations;
+
+int parse_percent_token();
+
+extern void fatals();
+extern void fatal();
+
+/* Buffer for storing the current token.  */
+char *token_buffer;
+
+/* Allocated size of token_buffer, not including space for terminator.  */
+static int maxtoken;
+
+bucket *symval;
+int numval;
+
+static int unlexed;		/* these two describe a token to be reread */
+static bucket *unlexed_symval;	/* by the next call to lex */
+
+
+void
+init_lex()
+{
+  maxtoken = 100;
+  token_buffer = NEW2 (maxtoken + 1, char);
+  unlexed = -1;
+}
+
+
+static char *
+grow_token_buffer (p)
+     char *p;
+{
+  int offset = p - token_buffer;
+  maxtoken *= 2;
+  token_buffer = (char *) realloc(token_buffer, maxtoken + 1);
+  if (token_buffer == 0)
+    fatal("virtual memory exhausted");
+  return token_buffer + offset;
+}
+
+
+int
+skip_white_space()
+{
+  register int c;
+  register int inside;
+
+  c = getc(finput);
+
+  for (;;)
+    {
+      switch (c)
+	{
+	case '/':
+	  c = getc(finput);
+	  if (c != '*')
+	    fatals("unexpected `/%c' found",c);
+
+	  c = getc(finput);
+
+	  inside = 1;
+	  while (inside)
+	    {
+	      if (c == '*')
+		{
+		  while (c == '*')
+		    c = getc(finput);
+
+		  if (c == '/')
+		    {
+		      inside = 0;
+		      c = getc(finput);
+		    }
+		}
+	      else if (c == '\n')
+		{
+		  lineno++;
+		  c = getc(finput);
+		}
+	      else if (c == EOF)
+		fatal("unterminated comment");
+	      else
+		c = getc(finput);
+	    }
+
+	  break;
+
+	case '\n':
+	  lineno++;
+
+	case ' ':
+	case '\t':
+	case '\f':
+	  c = getc(finput);
+	  break;
+
+	default:
+	  return (c);
+	}
+    }
+}
+
+
+void
+unlex(token)
+int token;
+{
+  unlexed = token;
+  unlexed_symval = symval;
+}
+
+
+
+int
+lex()
+{
+  register int c;
+  register char *p;
+
+  if (unlexed >= 0)
+    {
+      symval = unlexed_symval;
+      c = unlexed;
+      unlexed = -1;
+      return (c);
+    }
+
+  c = skip_white_space();
+
+  switch (c)
+    {
+    case EOF:
+      return (ENDFILE);
+
+    case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
+    case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
+    case 'K':  case 'L':  case 'M':  case 'N':  case 'O':
+    case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
+    case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
+    case 'Z':
+    case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
+    case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
+    case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
+    case 'p':  case 'q':  case 'r':  case 's':  case 't':
+    case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
+    case 'z':
+    case '.':  case '_':
+      p = token_buffer;
+      while (isalnum(c) || c == '_' || c == '.')
+	{
+	  if (p == token_buffer + maxtoken)
+	    p = grow_token_buffer(p);
+
+	  *p++ = c;
+	  c = getc(finput);
+	}
+
+      *p = 0;
+      ungetc(c, finput);
+      symval = getsym(token_buffer);
+      return (IDENTIFIER);
+
+    case '0':  case '1':  case '2':  case '3':  case '4':
+    case '5':  case '6':  case '7':  case '8':  case '9':
+      {
+	numval = 0;
+
+	while (isdigit(c))
+	  {
+	    numval = numval*10 + c - '0';
+	    c = getc(finput);
+	  }
+	ungetc(c, finput);
+	return (NUMBER);
+      }
+
+    case '\'':
+      translations = -1;
+
+      /* parse the literal token and compute character code in  code  */
+
+      c = getc(finput);
+      {
+	register int code = 0;
+
+	if (c == '\\')
+	  {
+	    c = getc(finput);
+
+	    if (c <= '7' && c >= '0')
+	      {
+		while (c <= '7' && c >= '0')
+		  {
+		    code = (code * 8) + (c - '0');
+		    c = getc(finput);
+		    if (code >= 256 || code < 0)
+		      fatals("malformatted literal token `\\%03o'", code);
+		  }
+	      }
+	    else
+	      {
+		if (c == 't')
+		  code = '\t';
+		else if (c == 'n')
+		  code = '\n';
+		else if (c == 'a')
+		  code = '\007';
+		else if (c == 'r')
+		  code = '\r';
+		else if (c == 'f')
+		  code = '\f';
+		else if (c == 'b')
+		  code = '\b';
+		else if (c == 'v')
+		  code = 013;
+		else if (c == 'x')
+		  {
+		    c = getc(finput);
+		    while ((c <= '9' && c >= '0')
+			   || (c >= 'a' && c <= 'z')
+			   || (c >= 'A' && c <= 'Z'))
+		      {
+			code *= 16;
+			if (c <= '9' && c >= '0')
+			  code += c - '0';
+			else if (c >= 'a' && c <= 'z')
+			  code += c - 'a' + 10;
+			else if (c >= 'A' && c <= 'Z')
+			  code += c - 'A' + 10;
+			if (code >= 256 || code<0)/* JF this said if(c>=128) */
+			  fatals("malformatted literal token `\\x%x'",code);
+			c = getc(finput);
+		      }
+		    ungetc(c, finput);
+		  }
+		else if (c == '\\')
+		  code = '\\';
+		else if (c == '\'')
+		  code = '\'';
+		else if (c == '\"')	/* JF this is a good idea */
+		  code = '\"';
+		else
+		  {
+		    if (c >= 040 && c <= 0177)
+		      fatals ("unknown escape sequence `\\%c'", c);
+		    else
+		      fatals ("unknown escape sequence: `\\' followed by char code 0x%x", c);
+		  }
+
+		c = getc(finput);
+	      }
+	  }
+	else
+	  {
+	    code = c;
+	    c = getc(finput);
+	  }
+	if (c != '\'')
+	  fatal("multicharacter literal tokens not supported");
+
+	/* now fill token_buffer with the canonical name for this character
+	   as a literal token.  Do not use what the user typed,
+	   so that '\012' and '\n' can be interchangeable.  */
+
+	p = token_buffer;
+	*p++ = '\'';
+	if (code == '\\')
+	  {
+	    *p++ = '\\';
+	    *p++ = '\\';
+	  }
+	else if (code == '\'')
+	  {
+	    *p++ = '\\';
+	    *p++ = '\'';
+	  }
+	else if (code >= 040 && code != 0177)
+	  *p++ = code;
+	else if (code == '\t')
+	  {
+	    *p++ = '\\';
+	    *p++ = 't';
+	  }
+	else if (code == '\n')
+	  {
+	    *p++ = '\\';
+	    *p++ = 'n';
+	  }
+	else if (code == '\r')
+	  {
+	    *p++ = '\\';
+	    *p++ = 'r';
+	  }
+	else if (code == '\v')
+	  {
+	    *p++ = '\\';
+	    *p++ = 'v';
+	  }
+	else if (code == '\b')
+	  {
+	    *p++ = '\\';
+	    *p++ = 'b';
+	  }
+	else if (code == '\f')
+	  {
+	    *p++ = '\\';
+	    *p++ = 'f';
+	  }
+        else
+	  {
+	    *p++ = code / 0100 + '0';
+	    *p++ = ((code / 010) & 07) + '0';
+	    *p++ = (code & 07) + '0';
+	  }
+	*p++ = '\'';
+	*p = 0;
+	symval = getsym(token_buffer);
+	symval->class = STOKEN;
+	if (! symval->user_token_number)
+	  symval->user_token_number = code;
+	return (IDENTIFIER);
+      }
+
+    case ',':
+      return (COMMA);
+
+    case ':':
+      return (COLON);
+
+    case ';':
+      return (SEMICOLON);
+
+    case '|':
+      return (BAR);
+
+    case '{':
+      return (LEFT_CURLY);
+
+    case '=':
+      do
+	{
+	  c = getc(finput);
+	  if (c == '\n') lineno++;
+	}
+      while(c==' ' || c=='\n' || c=='\t');
+
+      if (c == '{')
+      	return(LEFT_CURLY);
+      else
+	{
+	  ungetc(c, finput);
+	  return(ILLEGAL);
+	}
+
+    case '<':
+      p = token_buffer;
+      c = getc(finput);
+      while (c != '>')
+	{
+	  if (c == '\n' || c == EOF)
+	    fatal("unterminated type name");
+
+	  if (p == token_buffer + maxtoken)
+	    p = grow_token_buffer(p);
+
+	  *p++ = c;
+	  c = getc(finput);
+	}
+      *p = 0;
+      return (TYPENAME);
+	    
+
+    case '%':
+      return (parse_percent_token());
+
+    default:
+      return (ILLEGAL);
+    }
+}
+
+
+/* parse a token which starts with %.  Assumes the % has already been read and discarded.  */
+
+int
+parse_percent_token ()
+{
+  register int c;
+  register char *p;
+
+  p = token_buffer;
+  c = getc(finput);
+
+  switch (c)
+    {
+    case '%':
+      return (TWO_PERCENTS);
+
+    case '{':
+      return (PERCENT_LEFT_CURLY);
+
+    case '<':
+      return (LEFT);
+
+    case '>':
+      return (RIGHT);
+
+    case '2':
+      return (NONASSOC);
+
+    case '0':
+      return (TOKEN);
+
+    case '=':
+      return (PREC);
+    }
+  if (!isalpha(c))
+    return (ILLEGAL);
+
+  while (isalpha(c) || c == '_')
+    {
+      if (p == token_buffer + maxtoken)
+	p = grow_token_buffer(p);
+
+      *p++ = c;
+      c = getc(finput);
+    }
+
+  ungetc(c, finput);
+
+  *p = 0;
+
+  if (strcmp(token_buffer, "token") == 0
+      ||
+      strcmp(token_buffer, "term") == 0)
+    return (TOKEN);
+  else if (strcmp(token_buffer, "nterm") == 0)
+    return (NTERM);
+  else if (strcmp(token_buffer, "type") == 0)
+    return (TYPE);
+  else if (strcmp(token_buffer, "guard") == 0)
+    return (GUARD);
+  else if (strcmp(token_buffer, "union") == 0)
+    return (UNION);
+  else if (strcmp(token_buffer, "expect") == 0)
+    return (EXPECT);
+  else if (strcmp(token_buffer, "start") == 0)
+    return (START);
+  else if (strcmp(token_buffer, "left") == 0)
+    return (LEFT);
+  else if (strcmp(token_buffer, "right") == 0)
+    return (RIGHT);
+  else if (strcmp(token_buffer, "nonassoc") == 0
+	   ||
+	   strcmp(token_buffer, "binary") == 0)
+    return (NONASSOC);
+  else if (strcmp(token_buffer, "semantic_parser") == 0)
+    return (SEMANTIC_PARSER);
+  else if (strcmp(token_buffer, "pure_parser") == 0)
+    return (PURE_PARSER);
+  else if (strcmp(token_buffer, "prec") == 0)
+    return (PREC);
+  else return (ILLEGAL);
+}

eoe/cmd/gnu/bison/lex.h

@@ -0,0 +1,47 @@
+/* Token type definitions for bison's input reader,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#define	ENDFILE		0
+#define	IDENTIFIER	1
+#define	COMMA		2
+#define COLON		3
+#define	SEMICOLON	4
+#define	BAR		5
+#define LEFT_CURLY	6
+#define TWO_PERCENTS	7
+#define PERCENT_LEFT_CURLY	8
+#define	TOKEN		9
+#define	NTERM		10
+#define GUARD	       11
+#define	TYPE	       12
+#define	UNION	       13
+#define START	       14
+#define LEFT	       15
+#define RIGHT	       16
+#define NONASSOC       17
+#define PREC	       18
+#define SEMANTIC_PARSER 19
+#define PURE_PARSER    20
+#define TYPENAME       21
+#define NUMBER	       22
+#define EXPECT	       23
+#define	ILLEGAL	       24
+
+#define	MAXTOKEN	1024

eoe/cmd/gnu/bison/machine.h

@@ -0,0 +1,39 @@
+/* Define machine-dependencies for bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifdef	eta10
+#define	MAXSHORT	2147483647
+#define	MINSHORT	-2147483648
+#else
+#define	MAXSHORT	32767
+#define	MINSHORT	-32768
+#endif
+
+#if defined (MSDOS) && !defined (__GO32__)
+#define	BITS_PER_WORD	16
+#define MAXTABLE	16383
+#else
+#define	BITS_PER_WORD	32
+#define MAXTABLE	32767
+#endif
+
+#define	WORDSIZE(n)	(((n) + BITS_PER_WORD - 1) / BITS_PER_WORD)
+#define	SETBIT(x, i)	((x)[(i)/BITS_PER_WORD] |= (1<<((i) % BITS_PER_WORD)))
+#define RESETBIT(x, i)	((x)[(i)/BITS_PER_WORD] &= ~(1<<((i) % BITS_PER_WORD)))
+#define BITISSET(x, i)	(((x)[(i)/BITS_PER_WORD] & (1<<((i) % BITS_PER_WORD))) != 0)

eoe/cmd/gnu/bison/main.c

@@ -0,0 +1,138 @@
+/* Top level entry point of bison,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"	/* JF for MAXSHORT */
+
+extern	int lineno;
+extern	int verboseflag;
+
+/* Nonzero means failure has been detected; don't write a parser file.  */
+int failure;
+
+/* The name this program was run with, for messages. */
+char *program_name;
+
+extern void getargs(), openfiles(), reader(), reduce_grammar();
+extern void set_derives(), set_nullable(), generate_states();
+extern void lalr(), initialize_conflicts(), verbose(), terse();
+extern void output(), done(), abort();
+
+
+/* VMS complained about using `int'.  */
+int
+main(argc, argv)
+int argc;
+char *argv[];
+{
+  program_name = argv[0];
+  failure = 0;
+  lineno = 0;
+  getargs(argc, argv);
+  openfiles();
+
+  /* read the input.  Copy some parts of it to fguard, faction, ftable and fattrs.
+     In file reader.c.
+     The other parts are recorded in the grammar; see gram.h.  */
+  reader();
+
+  /* find useless nonterminals and productions and reduce the grammar.  In
+     file reduce.c */
+  reduce_grammar();
+
+  /* record other info about the grammar.  In files derives and nullable.  */
+  set_derives();
+  set_nullable();
+
+  /* convert to nondeterministic finite state machine.  In file LR0.
+     See state.h for more info.  */
+  generate_states();
+
+  /* make it deterministic.  In file lalr.  */
+  lalr();
+
+  /* Find and record any conflicts: places where one token of lookahead is not
+     enough to disambiguate the parsing.  In file conflicts.
+     Currently this does not do anything to resolve them;
+     the trivial form of conflict resolution that exists is done in output.  */
+  initialize_conflicts();
+
+  /* print information about results, if requested.  In file print. */
+  if (verboseflag)
+    verbose();
+  else
+    terse();
+
+  /* output the tables and the parser to ftable.  In file output. */
+  output();
+  done(failure);
+}
+
+/* functions to report errors which prevent a parser from being generated */
+
+void
+fatal(s)
+char *s;
+{
+  extern char *infile;
+
+  if (infile == 0)
+    fprintf(stderr, "fatal error: %s\n", s);
+  else
+    fprintf(stderr, "\"%s\", line %d: %s\n", infile, lineno, s);
+  done(1);
+}
+
+
+/* JF changed to accept/deal with variable args.  Is a real kludge since
+   we don't support _doprnt calls */
+/*VARARGS1*/
+
+void
+fatals(fmt,x1,x2,x3,x4,x5,x6,x7,x8)
+char *fmt;
+{
+  char buffer[200];
+
+  sprintf(buffer, fmt, x1,x2,x3,x4,x5,x6,x7,x8);
+  fatal(buffer);
+}
+
+
+void
+toomany(s)
+char *s;
+{
+  char buffer[200];
+
+	/* JF new msg */
+  sprintf(buffer, "limit of %d exceeded, too many %s", MAXSHORT, s);
+  fatal(buffer);
+}
+
+
+void
+berror(s)
+char *s;
+{
+  fprintf(stderr, "internal error, %s\n", s);
+  abort();
+}

eoe/cmd/gnu/bison/new.h

@@ -0,0 +1,30 @@
+/* Storage allocation interface for bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#define	NEW(t)		((t *) mallocate((unsigned) sizeof(t)))
+#define	NEW2(n, t)	((t *) mallocate((unsigned) ((n) * sizeof(t))))
+
+#ifdef __STDC__
+#define	FREE(x)		(x ? (void) free((char *) (x)) : (void)0)
+#else
+#define	FREE(x)		(x && free((char *) (x)))
+#endif
+
+extern	char *mallocate();

eoe/cmd/gnu/bison/nullable.c

@@ -0,0 +1,136 @@
+/* Part of the bison parser generator,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* set up nullable, a vector saying which nonterminals can expand into the null string.
+   nullable[i - ntokens] is nonzero if symbol i can do so.  */
+
+#include <stdio.h>
+#include "system.h"
+#include "types.h"
+#include "gram.h"
+#include "new.h"
+
+
+char *nullable;
+
+
+void
+set_nullable()
+{
+  register short *r;
+  register short *s1;
+  register short *s2;
+  register int ruleno;
+  register int symbol;
+  register shorts *p;
+
+  short *squeue;
+  short *rcount;
+  shorts **rsets;
+  shorts *relts;
+  char any_tokens;
+  short *r1;
+
+#ifdef	TRACE
+  fprintf(stderr, "Entering set_nullable");
+#endif
+
+  nullable = NEW2(nvars, char) - ntokens;
+
+  squeue = NEW2(nvars, short);
+  s1 = s2 = squeue;
+
+  rcount = NEW2(nrules + 1, short);
+  rsets = NEW2(nvars, shorts *) - ntokens;
+  /* This is said to be more elements than we actually use.
+     Supposedly nitems - nrules is enough.
+     But why take the risk?  */
+  relts = NEW2(nitems + nvars + 1, shorts);
+  p = relts;
+
+  r = ritem;
+  while (*r)
+    {
+      if (*r < 0)
+	{
+	  symbol = rlhs[-(*r++)];
+	  if (symbol >= 0 && !nullable[symbol])
+	    {
+	      nullable[symbol] = 1;
+	      *s2++ = symbol;
+	    }
+	}
+      else
+	{
+	  r1 = r;
+	  any_tokens = 0;
+	  for (symbol = *r++; symbol > 0; symbol = *r++)
+	    {
+	      if (ISTOKEN(symbol))
+		any_tokens = 1;
+	    }
+
+	  if (!any_tokens)
+	    {
+	      ruleno = -symbol;
+	      r = r1;
+	      for (symbol = *r++; symbol > 0; symbol = *r++)
+		{
+		  rcount[ruleno]++;
+		  p->next = rsets[symbol];
+		  p->value = ruleno;
+		  rsets[symbol] = p;
+		  p++;
+		}
+	    }
+	}
+    }
+
+  while (s1 < s2)
+    {
+      p = rsets[*s1++];
+      while (p)
+	{
+	  ruleno = p->value;
+	  p = p->next;
+	  if (--rcount[ruleno] == 0)
+	    {
+	      symbol = rlhs[ruleno];
+	      if (symbol >= 0 && !nullable[symbol])
+		{
+		  nullable[symbol] = 1;
+		  *s2++ = symbol;
+		}
+	    }
+	}
+    }
+
+  FREE(squeue);
+  FREE(rcount);
+  FREE(rsets + ntokens);
+  FREE(relts);
+}
+
+
+void
+free_nullable()
+{
+  FREE(nullable + ntokens);
+}

eoe/cmd/gnu/bison/print.c

@@ -0,0 +1,373 @@
+/* Print information on generated parser, for bison,
+   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"
+#include "new.h"
+#include "files.h"
+#include "gram.h"
+#include "state.h"
+
+
+extern char **tags;
+extern int nstates;
+extern short *accessing_symbol;
+extern core **state_table;
+extern shifts **shift_table;
+extern errs **err_table;
+extern reductions **reduction_table;
+extern char *consistent;
+extern char any_conflicts;
+extern char *conflicts;
+extern int final_state;
+
+extern void conflict_log();
+extern void verbose_conflict_log();
+extern void print_reductions();
+
+void print_token();
+void print_state();
+void print_core();
+void print_actions();
+void print_grammar();
+
+void
+terse()
+{
+  if (any_conflicts)
+    {
+      conflict_log();
+    }
+}
+
+
+void
+verbose()
+{
+  register int i;
+
+  if (any_conflicts)
+    verbose_conflict_log();
+
+  print_grammar();
+
+  for (i = 0; i < nstates; i++)
+    {
+      print_state(i);
+    }
+}
+
+
+void
+print_token(extnum, token)
+int extnum, token;
+{
+  fprintf(foutput, " type %d is %s\n", extnum, tags[token]);
+}
+
+
+void
+print_state(state)
+int state;
+{
+  fprintf(foutput, "\n\nstate %d\n\n", state);
+  print_core(state);
+  print_actions(state);
+}
+
+
+void
+print_core(state)
+int state;
+{
+  register int i;
+  register int k;
+  register int rule;
+  register core *statep;
+  register short *sp;
+  register short *sp1;
+
+  statep = state_table[state];
+  k = statep->nitems;
+
+  if (k == 0) return;
+
+  for (i = 0; i < k; i++)
+    {
+      sp1 = sp = ritem + statep->items[i];
+
+      while (*sp > 0)
+	sp++;
+
+      rule = -(*sp);
+      fprintf(foutput, "    %s  ->  ", tags[rlhs[rule]]);
+
+      for (sp = ritem + rrhs[rule]; sp < sp1; sp++)
+	{
+	  fprintf(foutput, "%s ", tags[*sp]);
+	}
+
+      putc('.', foutput);
+
+      while (*sp > 0)
+	{
+	  fprintf(foutput, " %s", tags[*sp]);
+	  sp++;
+	}
+
+      fprintf (foutput, "   (rule %d)", rule);
+      putc('\n', foutput);
+    }
+
+  putc('\n', foutput);
+}
+
+
+void
+print_actions(state)
+int state;
+{
+  register int i;
+  register int k;
+  register int state1;
+  register int symbol;
+  register shifts *shiftp;
+  register errs *errp;
+  register reductions *redp;
+  register int rule;
+
+  shiftp = shift_table[state];
+  redp = reduction_table[state];
+  errp = err_table[state];
+
+  if (!shiftp && !redp)
+    {
+      if (final_state == state)
+	fprintf(foutput, "    $default\taccept\n");
+      else
+	fprintf(foutput, "    NO ACTIONS\n");
+      return;
+    }
+
+  if (shiftp)
+    {
+      k = shiftp->nshifts;
+
+      for (i = 0; i < k; i++)
+	{
+	  if (! shiftp->shifts[i]) continue;
+	  state1 = shiftp->shifts[i];
+	  symbol = accessing_symbol[state1];
+	  /* The following line used to be turned off.  */
+	  if (ISVAR(symbol)) break;
+          if (symbol==0)      /* I.e. strcmp(tags[symbol],"$")==0 */
+            fprintf(foutput, "    $   \tgo to state %d\n", state1);
+          else
+            fprintf(foutput, "    %-4s\tshift, and go to state %d\n",
+                    tags[symbol], state1);
+	}
+
+      if (i > 0)
+	putc('\n', foutput);
+    }
+  else
+    {
+      i = 0;
+      k = 0;
+    }
+
+  if (errp)
+    {
+      int j, nerrs;
+
+      nerrs = errp->nerrs;
+
+      for (j = 0; j < nerrs; j++)
+	{
+	  if (! errp->errs[j]) continue;
+	  symbol = errp->errs[j];
+	  fprintf(foutput, "    %-4s\terror (nonassociative)\n", tags[symbol]);
+	}
+
+      if (j > 0)
+	putc('\n', foutput);
+    }
+
+  if (consistent[state] && redp)
+    {
+      rule = redp->rules[0];
+      symbol = rlhs[rule];
+      fprintf(foutput, "    $default\treduce using rule %d (%s)\n\n",
+     	        rule, tags[symbol]);
+    }
+  else if (redp)
+    {
+      print_reductions(state);
+    }
+
+  if (i < k)
+    {
+      for (; i < k; i++)
+	{
+	  if (! shiftp->shifts[i]) continue;
+	  state1 = shiftp->shifts[i];
+	  symbol = accessing_symbol[state1];
+	  fprintf(foutput, "    %-4s\tgo to state %d\n", tags[symbol], state1);
+	}
+
+      putc('\n', foutput);
+    }
+}
+
+#define END_TEST(end) \
+  if (column + strlen(buffer) > (end))					 \
+    { fprintf (foutput, "%s\n   ", buffer); column = 3; buffer[0] = 0; } \
+  else
+
+void
+print_grammar()
+{
+  int i, j;
+  short* rule;
+  char buffer[90];
+  int column = 0;
+
+  /* rule # : LHS -> RHS */
+  fputs("\nGrammar\n", foutput);
+  for (i = 1; i <= nrules; i++)
+    /* Don't print rules disabled in reduce_grammar_tables.  */
+    if (rlhs[i] >= 0)
+      {
+	fprintf(foutput, "rule %-4d %s ->", i, tags[rlhs[i]]);
+	rule = &ritem[rrhs[i]];
+	if (*rule > 0)
+	  while (*rule > 0)
+	    fprintf(foutput, " %s", tags[*rule++]);
+	else
+	  fputs ("		/* empty */", foutput);
+	putc('\n', foutput);
+      }
+
+  /* TERMINAL (type #) : rule #s terminal is on RHS */
+  fputs("\nTerminals, with rules where they appear\n\n", foutput);
+  fprintf(foutput, "%s (-1)\n", tags[0]);
+  if (translations)
+    {
+      for (i = 0; i <= max_user_token_number; i++)
+	if (token_translations[i] != 2)
+	  {
+	    buffer[0] = 0;
+	    column = strlen (tags[token_translations[i]]);
+	    fprintf(foutput, "%s", tags[token_translations[i]]);
+	    END_TEST (50);
+	    sprintf (buffer, " (%d)", i);
+
+	    for (j = 1; j <= nrules; j++)
+	      {
+		for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
+		  if (*rule == token_translations[i])
+		    {
+		      END_TEST (65);
+		      sprintf (buffer + strlen(buffer), " %d", j);
+		      break;
+		    }
+	      }
+	    fprintf (foutput, "%s\n", buffer);
+	  }
+    }
+  else
+    for (i = 1; i < ntokens; i++)
+      {
+	buffer[0] = 0;
+	column = strlen (tags[i]);
+	fprintf(foutput, "%s", tags[i]);
+	END_TEST (50);
+	sprintf (buffer, " (%d)", i);
+
+	for (j = 1; j <= nrules; j++)
+	  {
+	    for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
+	      if (*rule == i)
+		{
+		  END_TEST (65);
+		  sprintf (buffer + strlen(buffer), " %d", j);
+		  break;
+		}
+	  }
+	fprintf (foutput, "%s\n", buffer);
+      }
+
+  fputs("\nNonterminals, with rules where they appear\n\n", foutput);
+  for (i = ntokens; i <= nsyms - 1; i++)
+    {
+      int left_count = 0, right_count = 0;
+
+      for (j = 1; j <= nrules; j++)
+	{
+	  if (rlhs[j] == i)
+	    left_count++;
+	  for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
+	    if (*rule == i)
+	      {
+		right_count++;
+		break;
+	      }
+	}
+
+      buffer[0] = 0;
+      fprintf(foutput, "%s", tags[i]);
+      column = strlen (tags[i]);
+      sprintf (buffer, " (%d)", i);
+      END_TEST (0);
+
+      if (left_count > 0)
+	{
+	  END_TEST (50);
+	  sprintf (buffer + strlen(buffer), " on left:");
+
+	  for (j = 1; j <= nrules; j++)
+	    {
+	      END_TEST (65);
+	      if (rlhs[j] == i)
+		sprintf (buffer + strlen(buffer), " %d", j);
+	    }
+	}
+
+      if (right_count > 0)
+	{
+	  if (left_count > 0)
+	    sprintf (buffer + strlen(buffer), ",");
+	  END_TEST (50);
+	  sprintf (buffer + strlen(buffer), " on right:");
+	  for (j = 1; j <= nrules; j++)
+	    {
+	      for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
+		if (*rule == i)
+		  {
+		    END_TEST (65);
+		    sprintf (buffer + strlen(buffer), " %d", j);
+		    break;
+		  }
+	    }
+	}
+      fprintf (foutput, "%s\n", buffer);
+    }
+}

eoe/cmd/gnu/bison/reduce.c

@@ -0,0 +1,598 @@
+/* Grammar reduction for Bison.
+   Copyright (C) 1988, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/*
+ * Reduce the grammar:  Find and eliminate unreachable terminals,
+ * nonterminals, and productions.  David S. Bakin.
+ */
+
+/*
+ * Don't eliminate unreachable terminals:  They may be used by the user's
+ * parser.
+ */
+
+#include <stdio.h>
+#include "system.h"
+#include "files.h"
+#include "gram.h"
+#include "machine.h"
+#include "new.h"
+
+
+extern char   **tags;		/* reader.c */
+extern int      verboseflag;	/* getargs.c */
+static int      statisticsflag;	/* XXXXXXX */
+
+#ifndef TRUE
+#define TRUE	(1)
+#define FALSE	(0)
+#endif
+typedef int bool;
+typedef unsigned *BSet;
+typedef short  *rule;
+
+
+/*
+ * N is set of all nonterminals which are not useless.  P is set of all rules
+ * which have no useless nonterminals in their RHS.  V is the set of all
+ * accessible symbols.
+ */
+
+static BSet     N, P, V, V1;
+
+static int      nuseful_productions, nuseless_productions,
+                nuseful_nonterminals, nuseless_nonterminals;
+
+
+static void useless_nonterminals();
+static void inaccessable_symbols();
+static void reduce_grammar_tables();
+static void print_results();
+static void print_notices();
+void dump_grammar();
+
+extern void fatals ();
+
+
+bool
+bits_equal (L, R, n)
+BSet L;
+BSet R;
+int n;
+{
+  int i;
+
+  for (i = n - 1; i >= 0; i--)
+    if (L[i] != R[i])
+      return FALSE;
+  return TRUE;
+}
+
+
+int
+nbits (i)
+unsigned i;
+{
+  int count = 0;
+
+  while (i != 0) {
+    i ^= (i & -i);
+    ++count;
+  }
+  return count;
+}
+
+
+int
+bits_size (S, n)
+BSet S;
+int n;
+{
+  int i, count = 0;
+
+  for (i = n - 1; i >= 0; i--)
+    count += nbits(S[i]);
+  return count;
+}
+
+void
+reduce_grammar ()
+{
+  bool reduced;
+
+  /* Allocate the global sets used to compute the reduced grammar */
+
+  N = NEW2(WORDSIZE(nvars), unsigned);
+  P = NEW2(WORDSIZE(nrules + 1), unsigned);
+  V = NEW2(WORDSIZE(nsyms), unsigned);
+  V1 = NEW2(WORDSIZE(nsyms), unsigned);
+
+  useless_nonterminals();
+  inaccessable_symbols();
+
+  reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0);
+
+  if (verboseflag)
+    print_results();
+
+  if (reduced == FALSE)
+    goto done_reducing;
+
+  print_notices();
+
+  if (!BITISSET(N, start_symbol - ntokens))
+    fatals("Start symbol %s does not derive any sentence.",
+	   tags[start_symbol]);
+
+  reduce_grammar_tables();
+  /* if (verboseflag) {
+     fprintf(foutput, "REDUCED GRAMMAR\n\n");
+     dump_grammar();
+     }
+     */
+
+  /**/ statisticsflag = FALSE; /* someday getopts should handle this */
+  if (statisticsflag == TRUE)
+    fprintf(stderr,
+	    "reduced %s defines %d terminal%s, %d nonterminal%s\
+, and %d production%s.\n", infile,
+	    ntokens, (ntokens == 1 ? "" : "s"),
+	    nvars,   (nvars   == 1 ? "" : "s"),
+	    nrules,  (nrules  == 1 ? "" : "s"));
+
+ done_reducing:
+
+  /* Free the global sets used to compute the reduced grammar */
+
+  FREE(N);
+  FREE(V);
+  FREE(P);
+
+}
+
+/*
+ * Another way to do this would be with a set for each production and then do
+ * subset tests against N, but even for the C grammar the whole reducing
+ * process takes only 2 seconds on my 8Mhz AT.
+ */
+
+static bool 
+useful_production (i, N)
+int  i;
+BSet N;
+{
+  rule  r;
+  short n;
+
+  /*
+   * A production is useful if all of the nonterminals in its RHS
+   * appear in the set of useful nonterminals.
+   */
+
+  for (r = &ritem[rrhs[i]]; *r > 0; r++)
+    if (ISVAR(n = *r))
+      if (!BITISSET(N, n - ntokens))
+	return FALSE;
+  return TRUE;
+}
+
+
+/* Remember that rules are 1-origin, symbols are 0-origin. */
+
+static void 
+useless_nonterminals ()
+{
+  BSet Np, Ns;
+  int  i, n;
+
+  /*
+   * N is set as built.  Np is set being built this iteration. P is set
+   * of all productions which have a RHS all in N.
+   */
+
+  Np = NEW2(WORDSIZE(nvars), unsigned);
+
+  /*
+   * The set being computed is a set of nonterminals which can derive
+   * the empty string or strings consisting of all terminals. At each
+   * iteration a nonterminal is added to the set if there is a
+   * production with that nonterminal as its LHS for which all the
+   * nonterminals in its RHS are already in the set.  Iterate until the
+   * set being computed remains unchanged.  Any nonterminals not in the
+   * set at that point are useless in that they will never be used in
+   * deriving a sentence of the language.
+   * 
+   * This iteration doesn't use any special traversal over the
+   * productions.  A set is kept of all productions for which all the
+   * nonterminals in the RHS are in useful.  Only productions not in
+   * this set are scanned on each iteration.  At the end, this set is
+   * saved to be used when finding useful productions: only productions
+   * in this set will appear in the final grammar.
+   */
+
+  n = 0;
+  while (1)
+    {
+      for (i = WORDSIZE(nvars) - 1; i >= 0; i--)
+	Np[i] = N[i];
+      for (i = 1; i <= nrules; i++)
+	{
+	  if (!BITISSET(P, i))
+	    {
+	      if (useful_production(i, N))
+		{
+		  SETBIT(Np, rlhs[i] - ntokens);
+		  SETBIT(P, i);
+		}
+	    }
+	}
+      if (bits_equal(N, Np, WORDSIZE(nvars)))
+	break;
+      Ns = Np;
+      Np = N;
+      N = Ns;
+    }
+  FREE(N);
+  N = Np;
+}
+
+static void 
+inaccessable_symbols ()
+{
+  BSet  Vp, Vs, Pp;
+  int   i, n;
+  short t;
+  rule  r;
+
+  /*
+   * Find out which productions are reachable and which symbols are
+   * used.  Starting with an empty set of productions and a set of
+   * symbols which only has the start symbol in it, iterate over all
+   * productions until the set of productions remains unchanged for an
+   * iteration.  For each production which has a LHS in the set of
+   * reachable symbols, add the production to the set of reachable
+   * productions, and add all of the nonterminals in the RHS of the
+   * production to the set of reachable symbols.
+   * 
+   * Consider only the (partially) reduced grammar which has only
+   * nonterminals in N and productions in P.
+   * 
+   * The result is the set P of productions in the reduced grammar, and
+   * the set V of symbols in the reduced grammar.
+   * 
+   * Although this algorithm also computes the set of terminals which are
+   * reachable, no terminal will be deleted from the grammar. Some
+   * terminals might not be in the grammar but might be generated by
+   * semantic routines, and so the user might want them available with
+   * specified numbers.  (Is this true?)  However, the nonreachable
+   * terminals are printed (if running in verbose mode) so that the user
+   * can know.
+   */
+
+  Vp = NEW2(WORDSIZE(nsyms), unsigned);
+  Pp = NEW2(WORDSIZE(nrules + 1), unsigned);
+
+  /* If the start symbol isn't useful, then nothing will be useful. */
+  if (!BITISSET(N, start_symbol - ntokens))
+    goto end_iteration;
+
+  SETBIT(V, start_symbol);
+
+  n = 0;
+  while (1)
+    {
+      for (i = WORDSIZE(nsyms) - 1; i >= 0; i--)
+	Vp[i] = V[i];
+      for (i = 1; i <= nrules; i++)
+	{
+	  if (!BITISSET(Pp, i) && BITISSET(P, i) && 
+	      BITISSET(V, rlhs[i]))
+	    {
+	      for (r = &ritem[rrhs[i]]; *r >= 0; r++)
+		{
+		  if (ISTOKEN(t = *r)
+		      || BITISSET(N, t - ntokens))
+		    {
+		      SETBIT(Vp, t);
+		    }
+		}
+	      SETBIT(Pp, i);
+	    }
+	}
+      if (bits_equal(V, Vp, WORDSIZE(nsyms)))
+	{
+	  break;
+	}
+      Vs = Vp;
+      Vp = V;
+      V = Vs;
+    }
+ end_iteration:
+
+  FREE(V);
+  V = Vp;
+
+  /* Tokens 0, 1, and 2 are internal to Bison.  Consider them useful. */
+  SETBIT(V, 0);			/* end-of-input token */
+  SETBIT(V, 1);			/* error token */
+  SETBIT(V, 2);			/* illegal token */
+
+  FREE(P);
+  P = Pp;
+
+  nuseful_productions = bits_size(P, WORDSIZE(nrules + 1));
+  nuseless_productions = nrules - nuseful_productions;
+
+  nuseful_nonterminals = 0;
+  for (i = ntokens; i < nsyms; i++)
+    if (BITISSET(V, i))
+      nuseful_nonterminals++;
+  nuseless_nonterminals = nvars - nuseful_nonterminals;
+
+  /* A token that was used in %prec should not be warned about.  */
+  for (i = 1; i < nrules; i++)
+    if (rprecsym[i] != 0)
+      SETBIT(V1, rprecsym[i]);
+}
+
+static void 
+reduce_grammar_tables ()
+{
+/* This is turned off because we would need to change the numbers
+   in the case statements in the actions file.  */
+#if 0
+  /* remove useless productions */
+  if (nuseless_productions > 0)
+    {
+      short np, pn, ni, pi;
+
+      np = 0;
+      ni = 0;
+      for (pn = 1; pn <= nrules; pn++)
+	{
+	  if (BITISSET(P, pn))
+	    {
+	      np++;
+	      if (pn != np)
+		{
+		  rlhs[np] = rlhs[pn];
+		  rline[np] = rline[pn];
+		  rprec[np] = rprec[pn];
+		  rassoc[np] = rassoc[pn];
+		  rrhs[np] = rrhs[pn];
+		  if (rrhs[np] != ni)
+		    {
+		      pi = rrhs[np];
+		      rrhs[np] = ni;
+		      while (ritem[pi] >= 0)
+			ritem[ni++] = ritem[pi++];
+		      ritem[ni++] = -np;
+		    }
+		} else {
+		  while (ritem[ni++] >= 0);
+		}
+	    }
+	}
+      ritem[ni] = 0;
+      nrules -= nuseless_productions;
+      nitems = ni;
+
+      /*
+       * Is it worth it to reduce the amount of memory for the
+       * grammar? Probably not.
+       */
+
+    }
+#endif /* 0 */
+  /* Disable useless productions,
+     since they may contain useless nonterms
+     that would get mapped below to -1 and confuse everyone.  */
+  if (nuseless_productions > 0)
+    {
+      int pn;
+
+      for (pn = 1; pn <= nrules; pn++)
+	{
+	  if (!BITISSET(P, pn))
+	    {
+	      rlhs[pn] = -1;
+	    }
+	}
+    }
+
+  /* remove useless symbols */
+  if (nuseless_nonterminals > 0)
+    {
+
+      int    i, n;
+/*      short  j; JF unused */
+      short *nontermmap;
+      rule   r;
+
+      /*
+       * create a map of nonterminal number to new nonterminal
+       * number. -1 in the map means it was useless and is being
+       * eliminated.
+       */
+
+      nontermmap = NEW2(nvars, short) - ntokens;
+      for (i = ntokens; i < nsyms; i++)
+	nontermmap[i] = -1;
+
+      n = ntokens;
+      for (i = ntokens; i < nsyms; i++)
+	if (BITISSET(V, i))
+	  nontermmap[i] = n++;
+
+      /* Shuffle elements of tables indexed by symbol number.  */
+
+      for (i = ntokens; i < nsyms; i++)
+	{
+	  n = nontermmap[i];
+	  if (n >= 0)
+	    {
+	      sassoc[n] = sassoc[i];
+	      sprec[n] = sprec[i];
+	      tags[n] = tags[i];
+	    } else {
+	      free(tags[i]);
+	    }
+	}
+
+      /* Replace all symbol numbers in valid data structures.  */
+
+      for (i = 1; i <= nrules; i++)
+	{
+	  /* Ignore the rules disabled above.  */
+	  if (rlhs[i] >= 0)
+	    rlhs[i] = nontermmap[rlhs[i]];
+	  if (ISVAR (rprecsym[i]))
+	    /* Can this happen?  */
+	    rprecsym[i] = nontermmap[rprecsym[i]];
+	}
+
+      for (r = ritem; *r; r++)
+	if (ISVAR(*r))
+	  *r = nontermmap[*r];
+
+      start_symbol = nontermmap[start_symbol];
+
+      nsyms -= nuseless_nonterminals;
+      nvars -= nuseless_nonterminals;
+
+      free(&nontermmap[ntokens]);
+    }
+}
+
+static void 
+print_results ()
+{
+  int   i;
+/*  short j; JF unused */
+  rule  r;
+  bool  b;
+
+  if (nuseless_nonterminals > 0)
+    {
+      fprintf(foutput, "Useless nonterminals:\n\n");
+      for (i = ntokens; i < nsyms; i++)
+	if (!BITISSET(V, i))
+	  fprintf(foutput, "   %s\n", tags[i]);
+    }
+  b = FALSE;
+  for (i = 0; i < ntokens; i++)
+    {
+      if (!BITISSET(V, i) && !BITISSET(V1, i))
+	{
+	  if (!b)
+	    {
+	      fprintf(foutput, "\n\nTerminals which are not used:\n\n");
+	      b = TRUE;
+	    }
+	  fprintf(foutput, "   %s\n", tags[i]);
+	}
+    }
+
+  if (nuseless_productions > 0)
+    {
+      fprintf(foutput, "\n\nUseless rules:\n\n");
+      for (i = 1; i <= nrules; i++)
+	{
+	  if (!BITISSET(P, i))
+	    {
+	      fprintf(foutput, "#%-4d  ", i);
+	      fprintf(foutput, "%s :\t", tags[rlhs[i]]);
+	      for (r = &ritem[rrhs[i]]; *r >= 0; r++)
+		{
+		  fprintf(foutput, " %s", tags[*r]);
+		}
+	      fprintf(foutput, ";\n");
+	    }
+	}
+    }
+  if (nuseless_nonterminals > 0 || nuseless_productions > 0 || b)
+    fprintf(foutput, "\n\n");
+}
+
+void 
+dump_grammar ()
+{
+  int i;
+  rule r;
+
+  fprintf(foutput,
+	  "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d\n\n",
+	  ntokens, nvars, nsyms, nrules, nitems);
+  fprintf(foutput, "Variables\n---------\n\n");
+  fprintf(foutput, "Value  Sprec    Sassoc    Tag\n");
+  for (i = ntokens; i < nsyms; i++)
+    fprintf(foutput, "%5d  %5d  %5d  %s\n",
+	    i, sprec[i], sassoc[i], tags[i]);
+  fprintf(foutput, "\n\n");
+  fprintf(foutput, "Rules\n-----\n\n");
+  for (i = 1; i <= nrules; i++)
+    {
+      fprintf(foutput, "%-5d(%5d%5d)%5d : (@%-5d)", 
+	      i, rprec[i], rassoc[i], rlhs[i], rrhs[i]);
+      for (r = &ritem[rrhs[i]]; *r > 0; r++)
+	fprintf(foutput, "%5d", *r);
+      fprintf(foutput, " [%d]\n", -(*r));
+    }
+  fprintf(foutput, "\n\n");
+  fprintf(foutput, "Rules interpreted\n-----------------\n\n");
+  for (i = 1; i <= nrules; i++)
+    {
+      fprintf(foutput, "%-5d  %s :", i, tags[rlhs[i]]);
+      for (r = &ritem[rrhs[i]]; *r > 0; r++)
+	fprintf(foutput, " %s", tags[*r]);
+      fprintf(foutput, "\n");
+    }
+  fprintf(foutput, "\n\n");
+}
+
+
+static void 
+print_notices ()
+{
+  extern int fixed_outfiles;
+
+  if (fixed_outfiles && nuseless_productions)
+    fprintf(stderr, "%d rules never reduced\n", nuseless_productions);
+
+  fprintf(stderr, "%s contains ", infile);
+
+  if (nuseless_nonterminals > 0)
+    {
+      fprintf(stderr, "%d useless nonterminal%s",
+	      nuseless_nonterminals,
+	      (nuseless_nonterminals == 1 ? "" : "s"));
+    }
+  if (nuseless_nonterminals > 0 && nuseless_productions > 0)
+    fprintf(stderr, " and ");
+
+  if (nuseless_productions > 0)
+    {
+      fprintf(stderr, "%d useless rule%s",
+	      nuseless_productions,
+	      (nuseless_productions == 1 ? "" : "s"));
+    }
+  fprintf(stderr, ".\n");
+  fflush(stderr);
+}

eoe/cmd/gnu/bison/state.h

@@ -0,0 +1,137 @@
+/* Type definitions for nondeterministic finite state machine for bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* These type definitions are used to represent a nondeterministic
+   finite state machine that parses the specified grammar.
+   This information is generated by the function generate_states
+   in the file LR0.
+
+Each state of the machine is described by a set of items --
+particular positions in particular rules -- that are the possible
+places where parsing could continue when the machine is in this state.
+These symbols at these items are the allowable inputs that can follow now.
+
+A core represents one state.  States are numbered in the number field.
+When generate_states is finished, the starting state is state 0
+and nstates is the number of states.  (A transition to a state
+whose state number is nstates indicates termination.)  All the cores
+are chained together and first_state points to the first one (state 0).
+
+For each state there is a particular symbol which must have been the
+last thing accepted to reach that state.  It is the accessing_symbol
+of the core.
+
+Each core contains a vector of nitems items which are the indices
+in the ritems vector of the items that are selected in this state.
+
+The link field is used for chaining buckets that hash states by
+their itemsets.  This is for recognizing equivalent states and
+combining them when the states are generated.
+
+The two types of transitions are shifts (push the lookahead token
+and read another) and reductions (combine the last n things on the
+stack via a rule, replace them with the symbol that the rule derives,
+and leave the lookahead token alone).  When the states are generated,
+these transitions are represented in two other lists.
+
+Each shifts structure describes the possible shift transitions out
+of one state, the state whose number is in the number field.
+The shifts structures are linked through next and first_shift points to them.
+Each contains a vector of numbers of the states that shift transitions
+can go to.  The accessing_symbol fields of those states' cores say what kind
+of input leads to them.
+
+A shift to state zero should be ignored.  Conflict resolution
+deletes shifts by changing them to zero.
+
+Each reductions structure describes the possible reductions at the state
+whose number is in the number field.  The data is a list of nreds rules,
+represented by their rule numbers.   first_reduction points to the list
+of these structures.
+
+Conflict resolution can decide that certain tokens in certain
+states should explicitly be errors (for implementing %nonassoc).
+For each state, the tokens that are errors for this reason
+are recorded in an errs structure, which has the state number
+in its number field.  The rest of the errs structure is full
+of token numbers.
+
+There is at least one shift transition present in state zero.
+It leads to a next-to-final state whose accessing_symbol is
+the grammar's start symbol.  The next-to-final state has one shift
+to the final state, whose accessing_symbol is zero (end of input).
+The final state has one shift, which goes to the termination state
+(whose number is nstates-1).
+The reason for the extra state at the end is to placate the parser's
+strategy of making all decisions one token ahead of its actions.  */
+
+
+typedef
+  struct core
+    {
+      struct core *next;
+      struct core *link;
+      short number;
+      short accessing_symbol;
+      short nitems;
+      short items[1];
+    }
+  core;
+
+
+
+typedef
+  struct shifts
+    {
+      struct shifts *next;
+      short number;
+      short nshifts;
+      short shifts[1];
+    }
+  shifts;
+
+
+
+typedef
+  struct errs
+    {
+      short nerrs;
+      short errs[1];
+    }
+  errs;
+
+
+
+typedef
+  struct reductions
+    {
+      struct reductions *next;
+      short number;
+      short nreds;
+      short rules[1];
+    }
+  reductions;
+
+
+
+extern int nstates;
+extern core *first_state;
+extern shifts *first_shift;
+extern reductions *first_reduction;

eoe/cmd/gnu/bison/symtab.c

@@ -0,0 +1,150 @@
+/* Symbol table manager for Bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include <stdio.h>
+#include "system.h"
+#include "new.h"
+#include "symtab.h"
+#include "gram.h"
+
+
+bucket **symtab;
+bucket *firstsymbol;
+bucket *lastsymbol;
+
+
+
+int
+hash(key)
+char *key;
+{
+  register char *cp;
+  register int k;
+
+  cp = key;
+  k = 0;
+  while (*cp)
+    k = ((k << 1) ^ (*cp++)) & 0x3fff;
+
+  return (k % TABSIZE);
+}
+
+
+
+char *
+copys(s)
+char *s;
+{
+  register int i;
+  register char *cp;
+  register char *result;
+
+  i = 1;
+  for (cp = s; *cp; cp++)
+    i++;
+
+  result =  mallocate((unsigned int)i);
+  strcpy(result, s);
+  return (result);
+}
+
+
+void
+tabinit()
+{
+/*   register int i; JF unused */
+
+  symtab = NEW2(TABSIZE, bucket *);
+
+  firstsymbol = NULL;
+  lastsymbol = NULL;
+}
+
+
+bucket *
+getsym(key)
+char *key;
+{
+  register int hashval;
+  register bucket *bp;
+  register int found;
+
+  hashval = hash(key);
+  bp = symtab[hashval];
+
+  found = 0;
+  while (bp != NULL && found == 0)
+    {
+      if (strcmp(key, bp->tag) == 0)
+	found = 1;
+      else
+	bp = bp->link;
+    }
+
+  if (found == 0)
+    {
+      nsyms++;
+
+      bp = NEW(bucket);
+      bp->link = symtab[hashval];
+      bp->next = NULL;
+      bp->tag = copys(key);
+      bp->class = SUNKNOWN;
+
+      if (firstsymbol == NULL)
+	{
+	  firstsymbol = bp;
+	  lastsymbol = bp;
+	}
+      else
+	{
+	  lastsymbol->next = bp;
+	  lastsymbol = bp;
+	}
+
+      symtab[hashval] = bp;
+    }
+
+  return (bp);
+}
+
+
+void
+free_symtab()
+{
+  register int i;
+  register bucket *bp,*bptmp;/* JF don't use ptr after free */
+
+  for (i = 0; i < TABSIZE; i++)
+    {
+      bp = symtab[i];
+      while (bp)
+	{
+	  bptmp = bp->link;
+#if 0 /* This causes crashes because one string can appear more than once.  */
+	  if (bp->type_name)
+	    FREE(bp->type_name);
+#endif
+	  FREE(bp);
+	  bp = bptmp;
+	}
+    }
+  FREE(symtab);
+}

eoe/cmd/gnu/bison/symtab.h

@@ -0,0 +1,50 @@
+/* Definitions for symtab.c and callers, part of bison,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#define	TABSIZE	1009
+
+
+/*  symbol classes  */
+
+#define SUNKNOWN 0
+#define STOKEN	 1
+#define SNTERM	 2
+
+
+typedef
+  struct bucket
+    {
+      struct bucket *link;
+      struct bucket *next;
+      char *tag;
+      char *type_name;
+      short value;
+      short prec;
+      short assoc;
+      short user_token_number;
+      char class;
+    }
+  bucket;
+
+
+extern bucket **symtab;
+extern bucket *firstsymbol;
+
+extern bucket *getsym();

eoe/cmd/gnu/bison/system.h

@@ -0,0 +1,14 @@
+#ifdef MSDOS
+#include <stdlib.h>
+#include <io.h>
+#endif /* MSDOS */
+
+#ifdef USG
+#include <string.h>
+#else /* not USG */
+#ifdef MSDOS
+#include <string.h>
+#else
+#include <strings.h>
+#endif /* not MSDOS */
+#endif /* not USG */

eoe/cmd/gnu/bison/types.h

@@ -0,0 +1,27 @@
+/* Define data type for representing bison's grammar input as it is parsed,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+typedef
+  struct shorts
+    {
+      struct shorts *next;
+      short value;
+    }
+  shorts;

eoe/cmd/gnu/bison/version.c

@@ -0,0 +1,20 @@
+/* The version number for this version of Bison
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+char *version_string = "GNU Bison version 1.16\n";

eoe/cmd/gnu/bison/warshall.c

@@ -0,0 +1,119 @@
+/* Generate transitive closure of a matrix,
+   Copyright (C) 1984, 1989 Free Software Foundation, Inc.
+
+This file is part of Bison, the GNU Compiler Compiler.
+
+Bison is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+Bison is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bison; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"
+
+
+/* given n by n matrix of bits R, modify its contents
+   to be the transive closure of what was given.  */
+
+void
+TC(R, n)
+unsigned *R;
+int n;
+{
+  register int rowsize;
+  register unsigned mask;
+  register unsigned *rowj;
+  register unsigned *rp;
+  register unsigned *rend;
+  register unsigned *ccol;
+
+  unsigned *relend;
+  unsigned *cword;
+  unsigned *rowi;
+
+  rowsize = WORDSIZE(n) * sizeof(unsigned);
+  relend = (unsigned *) ((char *) R + (n * rowsize));
+
+  cword = R;
+  mask = 1;
+  rowi = R;
+  while (rowi < relend)
+    {
+      ccol = cword;
+      rowj = R;
+
+      while (rowj < relend)
+	{
+	  if (*ccol & mask)
+	    {
+	      rp = rowi;
+	      rend = (unsigned *) ((char *) rowj + rowsize);
+
+	      while (rowj < rend)
+		*rowj++ |= *rp++;
+	    }
+	  else
+	    {
+	      rowj = (unsigned *) ((char *) rowj + rowsize);
+	    }
+
+	  ccol = (unsigned *) ((char *) ccol + rowsize);
+	}
+
+      mask <<= 1;
+      if (mask == 0)
+	{
+	  mask = 1;
+	  cword++;
+	}
+
+      rowi = (unsigned *) ((char *) rowi + rowsize);
+    }
+}
+
+
+/* Reflexive Transitive Closure.  Same as TC
+   and then set all the bits on the diagonal of R.  */
+
+void
+RTC(R, n)
+unsigned *R;
+int n;
+{
+  register int rowsize;
+  register unsigned mask;
+  register unsigned *rp;
+  register unsigned *relend;
+
+  TC(R, n);
+
+  rowsize = WORDSIZE(n) * sizeof(unsigned);
+  relend = (unsigned *) ((char *) R + n*rowsize);
+
+  mask = 1;
+  rp = R;
+  while (rp < relend)
+    {
+      *rp |= mask;
+
+      mask <<= 1;
+      if (mask == 0)
+	{
+	  mask = 1;
+	  rp++;
+	}
+
+      rp = (unsigned *) ((char *) rp + rowsize);
+    }
+}

eoe/cmd/gnu/flex/Makefile

@@ -0,0 +1,54 @@
+#
+include	$(ROOT)/usr/include/make/commondefs
+
+CFILES=ccl.c dfa.c ecs.c gen.c main.c misc.c nfa.c parse.c \
+	scan.c sym.c tblcmp.c yylex.c
+
+TARGETS=flex
+ 
+FLEX=./flex
+FLEXLIB=libfl.a
+SKELTON_FILE=flex.skel
+FLEX_FLAGS=-ist8 -Sflex.skel
+
+LDIRT=parse.h parse.c scan.c $(FLEXLIB)
+LCOPTS= -D__STDC__ -DUSG -DDEFAULT_SKELETON_FILE=\"$(ROOT)/usr/lib/$(SKELTON_FILE)\"
+
+default: $(TARGETS) $(FLEXLIB)
+
+include $(COMMONRULES)
+
+scan.c: initscan.c
+	cp initscan.c scan.c
+
+newscan.c : scan.l
+	$(FLEX) $(FLEX_FLAGS) $(COMPRESSION) scan.l >scan.c
+
+flex: $(OBJECTS)
+	$(CCF) $(OBJECTS) $(LDFLAGS) -o $@
+
+$(FLEXLIB): libmain.o
+	$(AR) cru $(FLEXLIB) libmain.o
+
+parse.c parse.h: parse.y
+	$(YACC) -d parse.y
+	@mv y.tab.c parse.c
+	@mv y.tab.h parse.h
+
+install: default
+	$(INSTALL) -F /usr/sbin $(TARGETS)
+	$(INSTALL) -F /usr/lib $(SKELTON_FILE)
+	$(INSTALL) -F /usr/lib $(FLEXLIB)
+
+test : flex
+	./flex $(FLEX_FLAGS) $(COMPRESSION) scan.l | diff scan.c -
+
+bigtest :
+	rm -f scan.c ; $(MAKE) COMPRESSION="-C" test
+	rm -f scan.c ; $(MAKE) COMPRESSION="-Ce" test
+	rm -f scan.c ; $(MAKE) COMPRESSION="-Cm" test
+	rm -f scan.c ; $(MAKE) COMPRESSION="-Cfe" test
+	rm -f scan.c ; $(MAKE) COMPRESSION="-CFe" test
+	rm -f scan.c ; $(MAKE) COMPRESSION="-Cf" test
+	rm -f scan.c ; $(MAKE) COMPRESSION="-CF" test
+	rm -f scan.c ; $(MAKE)

eoe/cmd/gnu/flex/ccl.c

@@ -0,0 +1,175 @@
+/* ccl - routines for character classes */
+
+/*-
+ * 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/ccl.c,v 1.1 1992/05/05 22:30:01 wicinski Exp $ (LBL)";
+#endif
+
+#include "flexdef.h"
+
+/* ccladd - add a single character to a ccl
+ *
+ * synopsis
+ *    int cclp;
+ *    int ch;
+ *    ccladd( cclp, ch );
+ */
+
+void ccladd( cclp, ch )
+int cclp;
+int ch;
+
+    {
+    int ind, len, newpos, i;
+
+    len = ccllen[cclp];
+    ind = cclmap[cclp];
+
+    /* check to see if the character is already in the ccl */
+
+    for ( i = 0; i < len; ++i )
+	if ( ccltbl[ind + i] == ch )
+	    return;
+
+    newpos = ind + len;
+
+    if ( newpos >= current_max_ccl_tbl_size )
+	{
+	current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT;
+
+	++num_reallocs;
+
+	ccltbl = reallocate_character_array( ccltbl, current_max_ccl_tbl_size );
+	}
+
+    ccllen[cclp] = len + 1;
+    ccltbl[newpos] = ch;
+    }
+
+
+/* cclinit - make an empty ccl
+ *
+ * synopsis
+ *    int cclinit();
+ *    new_ccl = cclinit();
+ */
+
+int cclinit()
+
+    {
+    if ( ++lastccl >= current_maxccls )
+	{
+	current_maxccls += MAX_CCLS_INCREMENT;
+
+	++num_reallocs;
+
+	cclmap = reallocate_integer_array( cclmap, current_maxccls );
+	ccllen = reallocate_integer_array( ccllen, current_maxccls );
+	cclng = reallocate_integer_array( cclng, current_maxccls );
+	}
+
+    if ( lastccl == 1 )
+	/* we're making the first ccl */
+	cclmap[lastccl] = 0;
+
+    else
+	/* the new pointer is just past the end of the last ccl.  Since
+	 * the cclmap points to the \first/ character of a ccl, adding the
+	 * length of the ccl to the cclmap pointer will produce a cursor
+	 * to the first free space
+	 */
+	cclmap[lastccl] = cclmap[lastccl - 1] + ccllen[lastccl - 1];
+
+    ccllen[lastccl] = 0;
+    cclng[lastccl] = 0;	/* ccl's start out life un-negated */
+
+    return ( lastccl );
+    }
+
+
+/* cclnegate - negate a ccl
+ *
+ * synopsis
+ *    int cclp;
+ *    cclnegate( ccl );
+ */
+
+void cclnegate( cclp )
+int cclp;
+
+    {
+    cclng[cclp] = 1;
+    }
+
+
+/* list_character_set - list the members of a set of characters in CCL form
+ *
+ * synopsis
+ *     int cset[CSIZE];
+ *     FILE *file;
+ *     list_character_set( cset );
+ *
+ * writes to the given file a character-class representation of those
+ * characters present in the given set.  A character is present if it
+ * has a non-zero value in the set array.
+ */
+
+void list_character_set( file, cset )
+FILE *file;
+int cset[];
+
+    {
+    register int i;
+    char *readable_form();
+
+    putc( '[', file );
+
+    for ( i = 0; i < csize; ++i )
+	{
+	if ( cset[i] )
+	    {
+	    register int start_char = i;
+
+	    putc( ' ', file );
+
+	    fputs( readable_form( i ), file );
+
+	    while ( ++i < csize && cset[i] )
+		;
+
+	    if ( i - 1 > start_char )
+		/* this was a run */
+		fprintf( file, "-%s", readable_form( i - 1 ) );
+
+	    putc( ' ', file );
+	    }
+	}
+
+    putc( ']', file );
+    }

eoe/cmd/gnu/flex/ecs.c

@@ -0,0 +1,349 @@
+/* ecs - equivalence class 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/ecs.c,v 1.1 1992/05/05 22:30:12 wicinski Exp $ (LBL)";
+#endif
+
+#include "flexdef.h"
+
+/* ccl2ecl - convert character classes to set of equivalence classes
+ *
+ * synopsis
+ *    ccl2ecl();
+ */
+
+void ccl2ecl()
+
+    {
+    int i, ich, newlen, cclp, ccls, cclmec;
+
+    for ( i = 1; i <= lastccl; ++i )
+	{
+	/* we loop through each character class, and for each character
+	 * in the class, add the character's equivalence class to the
+	 * new "character" class we are creating.  Thus when we are all
+	 * done, character classes will really consist of collections
+	 * of equivalence classes
+	 */
+
+	newlen = 0;
+	cclp = cclmap[i];
+
+	for ( ccls = 0; ccls < ccllen[i]; ++ccls )
+	    {
+	    ich = ccltbl[cclp + ccls];
+	    cclmec = ecgroup[ich];
+
+	    if ( xlation && cclmec < 0 )
+		{
+		/* special hack--if we're doing %t tables then it's
+		 * possible that no representative of this character's
+		 * equivalence class is in the ccl.  So waiting till
+		 * we see the representative would be disastrous.  Instead,
+		 * we add this character's equivalence class anyway, if it's
+		 * not already present.
+		 */
+		int j;
+
+		/* this loop makes this whole process n^2; but we don't
+		 * really care about %t performance anyway
+		 */
+		for ( j = 0; j < newlen; ++j )
+		    if ( ccltbl[cclp + j] == -cclmec )
+			break;
+
+		if ( j >= newlen )
+		    { /* no representative yet, add this one in */
+		    ccltbl[cclp + newlen] = -cclmec;
+		    ++newlen;
+		    }
+		}
+
+	    else if ( cclmec > 0 )
+		{
+		ccltbl[cclp + newlen] = cclmec;
+		++newlen;
+		}
+	    }
+
+	ccllen[i] = newlen;
+	}
+    }
+
+
+/* cre8ecs - associate equivalence class numbers with class members
+ *
+ * synopsis
+ *    int cre8ecs();
+ *    number of classes = cre8ecs( fwd, bck, num );
+ *
+ *  fwd is the forward linked-list of equivalence class members.  bck
+ *  is the backward linked-list, and num is the number of class members.
+ *
+ *  Returned is the number of classes.
+ */
+
+int cre8ecs( fwd, bck, num )
+int fwd[], bck[], num;
+
+    {
+    int i, j, numcl;
+
+    numcl = 0;
+
+    /* create equivalence class numbers.  From now on, abs( bck(x) )
+     * is the equivalence class number for object x.  If bck(x)
+     * is positive, then x is the representative of its equivalence
+     * class.
+     */
+    for ( i = 1; i <= num; ++i )
+	if ( bck[i] == NIL )
+	    {
+	    bck[i] = ++numcl;
+	    for ( j = fwd[i]; j != NIL; j = fwd[j] )
+		bck[j] = -numcl;
+	    }
+
+    return ( numcl );
+    }
+
+
+/* ecs_from_xlation - associate equivalence class numbers using %t table
+ *
+ * synopsis
+ *    numecs = ecs_from_xlation( ecmap );
+ *
+ *  Upon return, ecmap will map each character code to its equivalence
+ *  class.  The mapping will be positive if the character is the representative
+ *  of its class, negative otherwise.
+ *
+ *  Returns the number of equivalence classes used.
+ */
+
+int ecs_from_xlation( ecmap )
+int ecmap[];
+
+    {
+    int i;
+    int nul_is_alone = false;
+    int did_default_xlation_class = false;
+
+    if ( xlation[0] != 0 )
+	{
+	/* if NUL shares its translation with other characters, choose one
+	 * of the other characters as the representative for the equivalence
+	 * class.  This allows a cheap test later to see whether we can
+	 * do away with NUL's equivalence class.
+	 */
+	for ( i = 1; i < csize; ++i )
+	    if ( xlation[i] == -xlation[0] )
+		{
+		xlation[i] = xlation[0];
+		ecmap[0] = -xlation[0];
+		break;
+		}
+
+	if ( i >= csize )
+	    /* didn't find a companion character--remember this fact */
+	    nul_is_alone = true;
+	}
+
+    for ( i = 1; i < csize; ++i )
+	if ( xlation[i] == 0 )
+	    {
+	    if ( did_default_xlation_class )
+		ecmap[i] = -num_xlations;
+	    
+	    else
+		{
+		/* make an equivalence class for those characters not
+		 * specified in the %t table
+		 */
+		++num_xlations;
+		ecmap[i] = num_xlations;
+		did_default_xlation_class = true;
+		}
+	    }
+
+	else
+	    ecmap[i] = xlation[i];
+
+    if ( nul_is_alone )
+	/* force NUL's equivalence class to be the last one */
+	{
+	++num_xlations;
+	ecmap[0] = num_xlations;
+
+	/* there's actually a bug here: if someone is fanatic enough to
+	 * put every character in its own translation class, then right
+	 * now we just promoted NUL's equivalence class to be csize + 1;
+	 * we can handle NUL's class number being == csize (by instead
+	 * putting it in its own table), but we can't handle some *other*
+	 * character having to be put in its own table, too.  So in
+	 * this case we bail out.
+	 */
+	if ( num_xlations > csize )
+	    flexfatal( "too many %t classes!" );
+	}
+
+    return num_xlations;
+    }
+
+
+/* mkeccl - update equivalence classes based on character class xtions
+ *
+ * synopsis
+ *    Char ccls[];
+ *    int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
+ *    mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping );
+ *
+ * where ccls contains the elements of the character class, lenccl is the
+ * number of elements in the ccl, fwd is the forward link-list of equivalent
+ * characters, bck is the backward link-list, and llsiz size of the link-list
+ *
+ * NUL_mapping is the value which NUL (0) should be mapped to.
+ */
+
+void mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping )
+Char ccls[];
+int lenccl, fwd[], bck[], llsiz, NUL_mapping;
+
+    {
+    int cclp, oldec, newec;
+    int cclm, i, j;
+    static unsigned char cclflags[CSIZE];	/* initialized to all '\0' */
+
+    /* note that it doesn't matter whether or not the character class is
+     * negated.  The same results will be obtained in either case.
+     */
+
+    cclp = 0;
+
+    while ( cclp < lenccl )
+	{
+	cclm = ccls[cclp];
+
+	if ( NUL_mapping && cclm == 0 )
+	    cclm = NUL_mapping;
+
+	oldec = bck[cclm];
+	newec = cclm;
+
+	j = cclp + 1;
+
+	for ( i = fwd[cclm]; i != NIL && i <= llsiz; i = fwd[i] )
+	    { /* look for the symbol in the character class */
+	    for ( ; j < lenccl; ++j )
+		{
+		register int ccl_char;
+
+		if ( NUL_mapping && ccls[j] == 0 )
+		    ccl_char = NUL_mapping;
+		else
+		    ccl_char = ccls[j];
+
+		if ( ccl_char > i )
+		    break;
+
+		if ( ccl_char == i && ! cclflags[j] )
+		    {
+		    /* we found an old companion of cclm in the ccl.
+		     * link it into the new equivalence class and flag it as
+		     * having been processed
+		     */
+
+		    bck[i] = newec;
+		    fwd[newec] = i;
+		    newec = i;
+		    cclflags[j] = 1;	/* set flag so we don't reprocess */
+
+		    /* get next equivalence class member */
+		    /* continue 2 */
+		    goto next_pt;
+		    }
+		}
+
+	    /* symbol isn't in character class.  Put it in the old equivalence
+	     * class
+	     */
+
+	    bck[i] = oldec;
+
+	    if ( oldec != NIL )
+		fwd[oldec] = i;
+
+	    oldec = i;
+next_pt:
+	    ;
+	    }
+
+	if ( bck[cclm] != NIL || oldec != bck[cclm] )
+	    {
+	    bck[cclm] = NIL;
+	    fwd[oldec] = NIL;
+	    }
+
+	fwd[newec] = NIL;
+
+	/* find next ccl member to process */
+
+	for ( ++cclp; cclflags[cclp] && cclp < lenccl; ++cclp )
+	    {
+	    /* reset "doesn't need processing" flag */
+	    cclflags[cclp] = 0;
+	    }
+	}
+    }
+
+
+/* mkechar - create equivalence class for single character
+ *
+ * synopsis
+ *    int tch, fwd[], bck[];
+ *    mkechar( tch, fwd, bck );
+ */
+
+void mkechar( tch, fwd, bck )
+int tch, fwd[], bck[];
+
+    {
+    /* if until now the character has been a proper subset of
+     * an equivalence class, break it away to create a new ec
+     */
+
+    if ( fwd[tch] != NIL )
+	bck[fwd[tch]] = bck[tch];
+
+    if ( bck[tch] != NIL )
+	fwd[bck[tch]] = fwd[tch];
+
+    fwd[tch] = NIL;
+    bck[tch] = NIL;
+    }

eoe/cmd/gnu/flex/flex.skel

@@ -0,0 +1,836 @@
+/* A lexical scanner generated by flex */
+
+/* scanner skeleton version:
+ * $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/flex.skel,v 1.1 1992/05/05 22:30:15 wicinski Exp $
+ */
+
+#define FLEX_SCANNER
+
+#include <stdio.h>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <osfcn.h>
+
+/* use prototypes in function declarations */
+#define YY_USE_PROTOS
+
+/* the "const" storage-class-modifier is valid */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+#ifdef __STDC__
+
+#ifdef __GNUC__
+#include <stddef.h>
+void *malloc( size_t );
+void free( void* );
+#else
+#include <stdlib.h>
+#endif	/* __GNUC__ */
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif	/* __STDC__ */
+#endif	/* ! __cplusplus */
+
+
+#ifdef __TURBOC__
+#define YY_USE_CONST
+#endif
+
+
+#ifndef YY_USE_CONST
+#define const
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+/* we can't get here if it's an ANSI C compiler, or a C++ compiler,
+ * so it's got to be a K&R compiler, and therefore there's no standard
+ * place from which to include these definitions
+ */
+char *malloc();
+int free();
+int read();
+#endif
+
+
+/* amount of stuff to slurp up with each read */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* returned upon end-of-file */
+#define YY_END_TOK 0
+
+/* copy whatever the last rule matched to the standard output */
+
+/* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
+/* this used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite()
+ */
+#define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )
+
+/* gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#define YY_INPUT(buf,result,max_size) \
+	if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
+	    YY_FATAL_ERROR( "read() in flex scanner failed" );
+#define YY_NULL 0
+
+/* no semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#define yyterminate() return ( YY_NULL )
+
+/* report a fatal error */
+
+/* The funky do-while is used to turn this macro definition into
+ * a single C statement (which needs a semi-colon terminator).
+ * This avoids problems with code like:
+ *
+ * 	if ( something_happens )
+ *		YY_FATAL_ERROR( "oops, the something happened" );
+ *	else
+ *		everything_okay();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the YY_FATAL_ERROR() call.
+ */
+
+#define YY_FATAL_ERROR(msg) \
+	do \
+		{ \
+		(void) fputs( msg, stderr ); \
+		(void) putc( '\n', stderr ); \
+		exit( 1 ); \
+		} \
+	while ( 0 )
+
+/* default yywrap function - always treat EOF as an EOF */
+#define yywrap() 1
+
+/* enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* action number for EOF rule of a given start state */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* special action meaning "start processing a new file" */
+#define YY_NEW_FILE \
+	do \
+		{ \
+		yy_init_buffer( yy_current_buffer, yyin ); \
+		yy_load_buffer_state(); \
+		} \
+	while ( 0 )
+
+/* default declaration of generated scanner - a define so the user can
+ * easily add parameters
+ */
+#define YY_DECL int yylex YY_PROTO(( void )) 
+
+/* code executed at the end of each rule */
+#define YY_BREAK break;
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+#ifndef YY_BUF_SIZE
+#define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
+#endif
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+%% section 1 definitions go here
+
+/* done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext
+ */
+#define YY_DO_BEFORE_ACTION \
+	yytext = yy_bp; \
+%% code to fiddle yytext and yyleng for yymore() goes here
+	yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yy_c_buf_p = yy_cp;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* return all but the first 'n' matched characters back to the input stream */
+#define yyless(n) \
+	do \
+		{ \
+		/* undo effects of setting up yytext */ \
+		*yy_cp = yy_hold_char; \
+		yy_c_buf_p = yy_cp = yy_bp + n; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, yytext )
+
+
+struct yy_buffer_state
+    {
+    FILE *yy_input_file;
+
+    YY_CHAR *yy_ch_buf;		/* input buffer */
+    YY_CHAR *yy_buf_pos;	/* current position in input buffer */
+
+    /* size of input buffer in bytes, not including room for EOB characters*/
+    int yy_buf_size;	
+
+    /* number of characters read into yy_ch_buf, not including EOB characters */
+    int yy_n_chars;
+
+    int yy_eof_status;		/* whether we've seen an EOF on this buffer */
+#define EOF_NOT_SEEN 0
+    /* "pending" happens when the EOF has been seen but there's still
+     * some text process
+     */
+#define EOF_PENDING 1
+#define EOF_DONE 2
+    };
+
+static YY_BUFFER_STATE yy_current_buffer;
+
+/* we provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state"
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed */
+static YY_CHAR yy_hold_char;
+
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+
+
+
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+#ifndef YY_USER_INIT
+#define YY_USER_INIT
+#endif
+
+extern YY_CHAR *yytext;
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+YY_CHAR *yytext;
+int yyleng;
+
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+
+%% data tables for the DFA go here
+
+/* these variables are all declared out here so that section 3 code can
+ * manipulate them
+ */
+/* points to current character in buffer */
+static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
+static int yy_init = 1;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
+void yyrestart YY_PROTO(( FILE *input_file ));
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+
+#define yy_new_buffer yy_create_buffer
+
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+
+YY_DECL
+    {
+    register yy_state_type yy_current_state;
+    register YY_CHAR *yy_cp, *yy_bp;
+    register int yy_act;
+
+%% user's declarations go here
+
+    if ( yy_init )
+	{
+	YY_USER_INIT;
+
+	if ( ! yy_start )
+	    yy_start = 1;	/* first start state */
+
+	if ( ! yyin )
+	    yyin = stdin;
+
+	if ( ! yyout )
+	    yyout = stdout;
+
+	if ( yy_current_buffer )
+	    yy_init_buffer( yy_current_buffer, yyin );
+	else
+	    yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+	yy_load_buffer_state();
+
+	yy_init = 0;
+	}
+
+    while ( 1 )		/* loops until end-of-file is reached */
+	{
+%% yymore()-related code goes here
+	yy_cp = yy_c_buf_p;
+
+	/* support of yytext */
+	*yy_cp = yy_hold_char;
+
+	/* yy_bp points to the position in yy_ch_buf of the start of the
+	 * current run.
+	 */
+	yy_bp = yy_cp;
+
+%% code to set up and find next match goes here
+
+yy_find_action:
+%% code to find the action number goes here
+
+	YY_DO_BEFORE_ACTION;
+	YY_USER_ACTION;
+
+do_action:	/* this label is used only to access EOF actions */
+
+%% debug code goes here
+
+	switch ( yy_act )
+	    {
+%% actions go here
+
+	    case YY_END_OF_BUFFER:
+		{
+		/* amount of text matched not including the EOB char */
+		int yy_amount_of_matched_text = yy_cp - yytext - 1;
+
+		/* undo the effects of YY_DO_BEFORE_ACTION */
+		*yy_cp = yy_hold_char;
+
+		/* note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the end-
+		 * of-buffer state).  Contrast this with the test in yyinput().
+		 */
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+		    /* this was really a NUL */
+		    {
+		    yy_state_type yy_next_state;
+
+		    yy_c_buf_p = yytext + yy_amount_of_matched_text;
+
+		    yy_current_state = yy_get_previous_state();
+
+		    /* okay, we're now positioned to make the
+		     * NUL transition.  We couldn't have
+		     * yy_get_previous_state() go ahead and do it
+		     * for us because it doesn't know how to deal
+		     * with the possibility of jamming (and we
+		     * don't want to build jamming into it because
+		     * then it will run more slowly)
+		     */
+
+		    yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+		    yy_bp = yytext + YY_MORE_ADJ;
+
+		    if ( yy_next_state )
+			{
+			/* consume the NUL */
+			yy_cp = ++yy_c_buf_p;
+			yy_current_state = yy_next_state;
+			goto yy_match;
+			}
+
+		    else
+			{
+%% code to do backtracking for compressed tables and set up yy_cp goes here
+			goto yy_find_action;
+			}
+		    }
+
+		else switch ( yy_get_next_buffer() )
+		    {
+		    case EOB_ACT_END_OF_FILE:
+			{
+			yy_did_buffer_switch_on_eof = 0;
+
+			if ( yywrap() )
+			    {
+			    /* note: because we've taken care in
+			     * yy_get_next_buffer() to have set up yytext,
+			     * we can now set up yy_c_buf_p so that if some
+			     * total hoser (like flex itself) wants
+			     * to call the scanner after we return the
+			     * YY_NULL, it'll still work - another YY_NULL
+			     * will get returned.
+			     */
+			    yy_c_buf_p = yytext + YY_MORE_ADJ;
+
+			    yy_act = YY_STATE_EOF((yy_start - 1) / 2);
+			    goto do_action;
+			    }
+
+			else
+			    {
+			    if ( ! yy_did_buffer_switch_on_eof )
+				YY_NEW_FILE;
+			    }
+			}
+			break;
+
+		    case EOB_ACT_CONTINUE_SCAN:
+			yy_c_buf_p = yytext + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state();
+
+			yy_cp = yy_c_buf_p;
+			yy_bp = yytext + YY_MORE_ADJ;
+			goto yy_match;
+
+		    case EOB_ACT_LAST_MATCH:
+			yy_c_buf_p =
+			    &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+			yy_current_state = yy_get_previous_state();
+
+			yy_cp = yy_c_buf_p;
+			yy_bp = yytext + YY_MORE_ADJ;
+			goto yy_find_action;
+		    }
+		break;
+		}
+
+	    default:
+#ifdef FLEX_DEBUG
+		printf( "action # %d\n", yy_act );
+#endif
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	    }
+	}
+    }
+
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * synopsis
+ *     int yy_get_next_buffer();
+ *     
+ * returns a code representing an action
+ *     EOB_ACT_LAST_MATCH - 
+ *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *     EOB_ACT_END_OF_FILE - end of file
+ */
+
+static int yy_get_next_buffer()
+
+    {
+    register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
+    register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
+    register int number_to_move, i;
+    int ret_val;
+
+    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+	YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+    /* try to read more data */
+
+    /* first move last chars to start of buffer */
+    number_to_move = yy_c_buf_p - yytext;
+
+    for ( i = 0; i < number_to_move; ++i )
+	*(dest++) = *(source++);
+
+    if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
+	/* don't do the read, it's not guaranteed to return an EOF,
+	 * just force an EOF
+	 */
+	yy_n_chars = 0;
+
+    else
+	{
+	int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+	if ( num_to_read > YY_READ_BUF_SIZE )
+	    num_to_read = YY_READ_BUF_SIZE;
+
+	else if ( num_to_read <= 0 )
+	    YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
+
+	/* read in more data */
+	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+		  yy_n_chars, num_to_read );
+	}
+
+    if ( yy_n_chars == 0 )
+	{
+	if ( number_to_move == 1 )
+	    {
+	    ret_val = EOB_ACT_END_OF_FILE;
+	    yy_current_buffer->yy_eof_status = EOF_DONE;
+	    }
+
+	else
+	    {
+	    ret_val = EOB_ACT_LAST_MATCH;
+	    yy_current_buffer->yy_eof_status = EOF_PENDING;
+	    }
+	}
+
+    else
+	ret_val = EOB_ACT_CONTINUE_SCAN;
+
+    yy_n_chars += number_to_move;
+    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+    /* yytext begins at the second character in yy_ch_buf; the first
+     * character is the one which preceded it before reading in the latest
+     * buffer; it needs to be kept around in case it's a newline, so
+     * yy_get_previous_state() will have with '^' rules active
+     */
+
+    yytext = &yy_current_buffer->yy_ch_buf[1];
+
+    return ( ret_val );
+    }
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached
+ *
+ * synopsis
+ *     yy_state_type yy_get_previous_state();
+ */
+
+static yy_state_type yy_get_previous_state()
+
+    {
+    register yy_state_type yy_current_state;
+    register YY_CHAR *yy_cp;
+
+%% code to get the start state into yy_current_state goes here
+
+    for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+	{
+%% code to find the next state goes here
+	}
+
+    return ( yy_current_state );
+    }
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *     next_state = yy_try_NUL_trans( current_state );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+register yy_state_type yy_current_state;
+#endif
+
+    {
+    register int yy_is_jam;
+%% code to find the next state, and perhaps do backtracking, goes here
+
+    return ( yy_is_jam ? 0 : yy_current_state );
+    }
+
+
+#ifdef YY_USE_PROTOS
+static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+YY_CHAR c;
+register YY_CHAR *yy_bp;
+#endif
+
+    {
+    register YY_CHAR *yy_cp = yy_c_buf_p;
+
+    /* undo effects of setting up yytext */
+    *yy_cp = yy_hold_char;
+
+    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+	{ /* need to shift things up to make room */
+	register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
+	register YY_CHAR *dest =
+	    &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
+	register YY_CHAR *source =
+	    &yy_current_buffer->yy_ch_buf[number_to_move];
+
+	while ( source > yy_current_buffer->yy_ch_buf )
+	    *--dest = *--source;
+
+	yy_cp += dest - source;
+	yy_bp += dest - source;
+	yy_n_chars = yy_current_buffer->yy_buf_size;
+
+	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+	    YY_FATAL_ERROR( "flex scanner push-back overflow" );
+	}
+
+    if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
+	yy_cp[-2] = '\n';
+
+    *--yy_cp = c;
+
+    /* note: the formal parameter *must* be called "yy_bp" for this
+     *       macro to now work correctly
+     */
+    YY_DO_BEFORE_ACTION; /* set up yytext again */
+    }
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+
+    {
+    int c;
+    YY_CHAR *yy_cp = yy_c_buf_p;
+
+    *yy_cp = yy_hold_char;
+
+    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+	{
+	/* yy_c_buf_p now points to the character we want to return.
+	 * If this occurs *before* the EOB characters, then it's a
+	 * valid NUL; if not, then we've hit the end of the buffer.
+	 */
+	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+	    /* this was really a NUL */
+	    *yy_c_buf_p = '\0';
+
+	else
+	    { /* need more input */
+	    yytext = yy_c_buf_p;
+	    ++yy_c_buf_p;
+
+	    switch ( yy_get_next_buffer() )
+		{
+		case EOB_ACT_END_OF_FILE:
+		    {
+		    if ( yywrap() )
+			{
+			yy_c_buf_p = yytext + YY_MORE_ADJ;
+			return ( EOF );
+			}
+
+		    YY_NEW_FILE;
+
+#ifdef __cplusplus
+		    return ( yyinput() );
+#else
+		    return ( input() );
+#endif
+		    }
+		    break;
+
+		case EOB_ACT_CONTINUE_SCAN:
+		    yy_c_buf_p = yytext + YY_MORE_ADJ;
+		    break;
+
+		case EOB_ACT_LAST_MATCH:
+#ifdef __cplusplus
+		    YY_FATAL_ERROR( "unexpected last match in yyinput()" );
+#else
+		    YY_FATAL_ERROR( "unexpected last match in input()" );
+#endif
+		}
+	    }
+	}
+
+    c = *yy_c_buf_p;
+    yy_hold_char = *++yy_c_buf_p;
+
+    return ( c );
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+
+    {
+    yy_init_buffer( yy_current_buffer, input_file );
+    yy_load_buffer_state();
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+
+    {
+    if ( yy_current_buffer == new_buffer )
+	return;
+
+    if ( yy_current_buffer )
+	{
+	/* flush out information for old buffer */
+	*yy_c_buf_p = yy_hold_char;
+	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+	yy_current_buffer->yy_n_chars = yy_n_chars;
+	}
+
+    yy_current_buffer = new_buffer;
+    yy_load_buffer_state();
+
+    /* we don't actually know whether we did this switch during
+     * EOF (yywrap()) processing, but the only time this flag
+     * is looked at is after yywrap() is called, so it's safe
+     * to go ahead and always set it.
+     */
+    yy_did_buffer_switch_on_eof = 1;
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+
+    {
+    yy_n_chars = yy_current_buffer->yy_n_chars;
+    yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+    yyin = yy_current_buffer->yy_input_file;
+    yy_hold_char = *yy_c_buf_p;
+    }
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+
+    {
+    YY_BUFFER_STATE b;
+
+    b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
+
+    if ( ! b )
+	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+    b->yy_buf_size = size;
+
+    /* yy_ch_buf has to be 2 characters longer than the size given because
+     * we need to put in 2 end-of-buffer characters.
+     */
+    b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
+
+    if ( ! b->yy_ch_buf )
+	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+    yy_init_buffer( b, file );
+
+    return ( b );
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+    {
+    if ( b == yy_current_buffer )
+	yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+    free( (char *) b->yy_ch_buf );
+    free( (char *) b );
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+    {
+    b->yy_input_file = file;
+
+    /* we put in the '\n' and start reading from [1] so that an
+     * initial match-at-newline will be true.
+     */
+
+    b->yy_ch_buf[0] = '\n';
+    b->yy_n_chars = 1;
+
+    /* we always need two end-of-buffer characters.  The first causes
+     * a transition to the end-of-buffer state.  The second causes
+     * a jam in that state.
+     */
+    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+    b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
+
+    b->yy_buf_pos = &b->yy_ch_buf[1];
+
+    b->yy_eof_status = EOF_NOT_SEEN;
+    }

eoe/cmd/gnu/flex/flexdef.h

@@ -0,0 +1,864 @@
+/* flexdef - definitions file for flex */
+
+/*-
+ * 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/flexdef.h,v 1.2 1996/01/04 05:14:54 olson Exp $ (LBL) */
+
+#ifndef FILE
+#include <stdio.h>
+#endif
+
+/* always be prepared to generate an 8-bit scanner */
+#define FLEX_8_BIT_CHARS
+
+#ifdef FLEX_8_BIT_CHARS
+#define CSIZE 256
+#define Char unsigned char
+#else
+#define Char char
+#define CSIZE 128
+#endif
+
+/* size of input alphabet - should be size of ASCII set */
+#ifndef DEFAULT_CSIZE
+#define DEFAULT_CSIZE 128
+#endif
+
+#ifndef PROTO
+#ifdef __STDC__
+#define PROTO(proto) proto
+#else
+#define PROTO(proto) ()
+#endif
+#endif
+
+
+#ifdef USG
+#define SYS_V
+#endif
+
+#ifdef SYS_V
+#include <string.h>
+#else
+
+#include <strings.h>
+#ifdef lint
+char *sprintf(); /* keep lint happy */
+#endif
+#ifdef SCO_UNIX
+void *memset();
+#else
+char *memset();
+#endif
+#endif
+
+#ifdef AMIGA
+#define bzero(s, n) setmem((char *)(s), n, '\0')
+#ifndef abs
+#define abs(x) ((x) < 0 ? -(x) : (x))
+#endif
+#else
+#define bzero(s, n) (void) memset((char *)(s), '\0', n)
+#endif
+
+#ifdef VMS
+#define unlink delete
+#define SHORT_FILE_NAMES
+#endif
+
+#ifdef __STDC__
+
+#ifdef __GNUC__
+#include <stddef.h>
+void *malloc( size_t );
+void free( void* );
+#else
+#include <stdlib.h>
+#endif
+
+#else	/* ! __STDC__ */
+char *malloc(), *realloc();
+#endif
+
+
+/* maximum line length we'll have to deal with */
+#define MAXLINE BUFSIZ
+
+/* maximum size of file name */
+#define FILENAMESIZE 1024
+
+#ifndef min
+#define min(x,y) ((x) < (y) ? (x) : (y))
+#endif
+#ifndef max
+#define max(x,y) ((x) > (y) ? (x) : (y))
+#endif
+
+#ifdef MS_DOS
+#ifndef abs
+#define abs(x) ((x) < 0 ? -(x) : (x))
+#endif
+#define SHORT_FILE_NAMES
+#endif
+
+#define true 1
+#define false 0
+
+
+#ifndef DEFAULT_SKELETON_FILE
+#define DEFAULT_SKELETON_FILE "flex.skel"
+#endif
+
+/* special chk[] values marking the slots taking by end-of-buffer and action
+ * numbers
+ */
+#define EOB_POSITION -1
+#define ACTION_POSITION -2
+
+/* number of data items per line for -f output */
+#define NUMDATAITEMS 10
+
+/* number of lines of data in -f output before inserting a blank line for
+ * readability.
+ */
+#define NUMDATALINES 10
+
+/* transition_struct_out() definitions */
+#define TRANS_STRUCT_PRINT_LENGTH 15
+
+/* returns true if an nfa state has an epsilon out-transition slot
+ * that can be used.  This definition is currently not used.
+ */
+#define FREE_EPSILON(state) \
+	(transchar[state] == SYM_EPSILON && \
+	 trans2[state] == NO_TRANSITION && \
+	 finalst[state] != state)
+
+/* returns true if an nfa state has an epsilon out-transition character
+ * and both slots are free
+ */
+#define SUPER_FREE_EPSILON(state) \
+	(transchar[state] == SYM_EPSILON && \
+	 trans1[state] == NO_TRANSITION) \
+
+/* maximum number of NFA states that can comprise a DFA state.  It's real
+ * big because if there's a lot of rules, the initial state will have a
+ * huge epsilon closure.
+ */
+#define INITIAL_MAX_DFA_SIZE 750
+#define MAX_DFA_SIZE_INCREMENT 750
+
+
+/* a note on the following masks.  They are used to mark accepting numbers
+ * as being special.  As such, they implicitly limit the number of accepting
+ * numbers (i.e., rules) because if there are too many rules the rule numbers
+ * will overload the mask bits.  Fortunately, this limit is \large/ (0x2000 ==
+ * 8192) so unlikely to actually cause any problems.  A check is made in
+ * new_rule() to ensure that this limit is not reached.
+ */
+
+/* mask to mark a trailing context accepting number */
+#define YY_TRAILING_MASK 0x2000
+
+/* mask to mark the accepting number of the "head" of a trailing context rule */
+#define YY_TRAILING_HEAD_MASK 0x4000
+
+/* maximum number of rules, as outlined in the above note */
+#define MAX_RULE (YY_TRAILING_MASK - 1)
+
+
+/* NIL must be 0.  If not, its special meaning when making equivalence classes
+ * (it marks the representative of a given e.c.) will be unidentifiable
+ */
+#define NIL 0
+
+#define JAM -1	/* to mark a missing DFA transition */
+#define NO_TRANSITION NIL
+#define UNIQUE -1	/* marks a symbol as an e.c. representative */
+#define INFINITY -1	/* for x{5,} constructions */
+
+#define INITIAL_MAX_CCLS 100	/* max number of unique character classes */
+#define MAX_CCLS_INCREMENT 100
+
+/* size of table holding members of character classes */
+#define INITIAL_MAX_CCL_TBL_SIZE 500
+#define MAX_CCL_TBL_SIZE_INCREMENT 250
+
+#define INITIAL_MAX_RULES 100	/* default maximum number of rules */
+#define MAX_RULES_INCREMENT 100
+
+#define INITIAL_MNS 2000	/* default maximum number of nfa states */
+#define MNS_INCREMENT 1000	/* amount to bump above by if it's not enough */
+
+#define INITIAL_MAX_DFAS 1000	/* default maximum number of dfa states */
+#define MAX_DFAS_INCREMENT 1000
+
+#define JAMSTATE -32766	/* marks a reference to the state that always jams */
+
+/* enough so that if it's subtracted from an NFA state number, the result
+ * is guaranteed to be negative
+ */
+#define MARKER_DIFFERENCE 32000
+#define MAXIMUM_MNS 31999
+
+/* maximum number of nxt/chk pairs for non-templates */
+#define INITIAL_MAX_XPAIRS 2000
+#define MAX_XPAIRS_INCREMENT 2000
+
+/* maximum number of nxt/chk pairs needed for templates */
+#define INITIAL_MAX_TEMPLATE_XPAIRS 2500
+#define MAX_TEMPLATE_XPAIRS_INCREMENT 2500
+
+#define SYM_EPSILON (CSIZE + 1)	/* to mark transitions on the symbol epsilon */
+
+#define INITIAL_MAX_SCS 40	/* maximum number of start conditions */
+#define MAX_SCS_INCREMENT 40	/* amount to bump by if it's not enough */
+
+#define ONE_STACK_SIZE 500	/* stack of states with only one out-transition */
+#define SAME_TRANS -1	/* transition is the same as "default" entry for state */
+
+/* the following percentages are used to tune table compression:
+
+ * the percentage the number of out-transitions a state must be of the
+ * number of equivalence classes in order to be considered for table
+ * compaction by using protos
+ */
+#define PROTO_SIZE_PERCENTAGE 15
+
+/* the percentage the number of homogeneous out-transitions of a state
+ * must be of the number of total out-transitions of the state in order
+ * that the state's transition table is first compared with a potential 
+ * template of the most common out-transition instead of with the first
+ * proto in the proto queue
+ */
+#define CHECK_COM_PERCENTAGE 50
+
+/* the percentage the number of differences between a state's transition
+ * table and the proto it was first compared with must be of the total
+ * number of out-transitions of the state in order to keep the first
+ * proto as a good match and not search any further
+ */
+#define FIRST_MATCH_DIFF_PERCENTAGE 10
+
+/* the percentage the number of differences between a state's transition
+ * table and the most similar proto must be of the state's total number
+ * of out-transitions to use the proto as an acceptable close match
+ */
+#define ACCEPTABLE_DIFF_PERCENTAGE 50
+
+/* the percentage the number of homogeneous out-transitions of a state
+ * must be of the number of total out-transitions of the state in order
+ * to consider making a template from the state
+ */
+#define TEMPLATE_SAME_PERCENTAGE 60
+
+/* the percentage the number of differences between a state's transition
+ * table and the most similar proto must be of the state's total number
+ * of out-transitions to create a new proto from the state
+ */
+#define NEW_PROTO_DIFF_PERCENTAGE 20
+
+/* the percentage the total number of out-transitions of a state must be
+ * of the number of equivalence classes in order to consider trying to
+ * fit the transition table into "holes" inside the nxt/chk table.
+ */
+#define INTERIOR_FIT_PERCENTAGE 15
+
+/* size of region set aside to cache the complete transition table of
+ * protos on the proto queue to enable quick comparisons
+ */
+#define PROT_SAVE_SIZE 2000
+
+#define MSP 50	/* maximum number of saved protos (protos on the proto queue) */
+
+/* maximum number of out-transitions a state can have that we'll rummage
+ * around through the interior of the internal fast table looking for a
+ * spot for it
+ */
+#define MAX_XTIONS_FULL_INTERIOR_FIT 4
+
+/* maximum number of rules which will be reported as being associated
+ * with a DFA state
+ */
+#define MAX_ASSOC_RULES 100
+
+/* number that, if used to subscript an array, has a good chance of producing
+ * an error; should be small enough to fit into a short
+ */
+#define BAD_SUBSCRIPT -32767
+
+/* absolute value of largest number that can be stored in a short, with a
+ * bit of slop thrown in for general paranoia.
+ */
+#define MAX_SHORT 32766
+
+
+/* Declarations for global variables. */
+
+/* variables for symbol tables:
+ * sctbl - start-condition symbol table
+ * ndtbl - name-definition symbol table
+ * ccltab - character class text symbol table
+ */
+
+struct hash_entry
+    {
+    struct hash_entry *prev, *next;
+    char *name;
+    char *str_val;
+    int int_val;
+    } ;
+
+typedef struct hash_entry *hash_table[];
+
+#define NAME_TABLE_HASH_SIZE 101
+#define START_COND_HASH_SIZE 101
+#define CCL_HASH_SIZE 101
+
+extern struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE]; 
+extern struct hash_entry *sctbl[START_COND_HASH_SIZE];
+extern struct hash_entry *ccltab[CCL_HASH_SIZE];
+
+
+/* variables for flags:
+ * printstats - if true (-v), dump statistics
+ * syntaxerror - true if a syntax error has been found
+ * eofseen - true if we've seen an eof in the input file
+ * ddebug - if true (-d), make a "debug" scanner
+ * trace - if true (-T), trace processing
+ * spprdflt - if true (-s), suppress the default rule
+ * interactive - if true (-I), generate an interactive scanner
+ * caseins - if true (-i), generate a case-insensitive scanner
+ * useecs - if true (-Ce flag), use equivalence classes
+ * fulltbl - if true (-Cf flag), don't compress the DFA state table
+ * usemecs - if true (-Cm flag), use meta-equivalence classes
+ * fullspd - if true (-F flag), use Jacobson method of table representation
+ * gen_line_dirs - if true (i.e., no -L flag), generate #line directives
+ * performance_report - if true (i.e., -p flag), generate a report relating
+ *   to scanner performance
+ * backtrack_report - if true (i.e., -b flag), generate "lex.backtrack" file
+ *   listing backtracking states
+ * csize - size of character set for the scanner we're generating;
+ *   128 for 7-bit chars and 256 for 8-bit
+ * yymore_used - if true, yymore() is used in input rules
+ * reject - if true, generate backtracking tables for REJECT macro
+ * real_reject - if true, scanner really uses REJECT (as opposed to just
+ *   having "reject" set for variable trailing context)
+ * continued_action - true if this rule's action is to "fall through" to
+ *   the next rule's action (i.e., the '|' action)
+ * yymore_really_used - has a REALLY_xxx value indicating whether a
+ *   %used or %notused was used with yymore()
+ * reject_really_used - same for REJECT
+ */
+
+extern int printstats, syntaxerror, eofseen, ddebug, trace, spprdflt;
+extern int interactive, caseins, useecs, fulltbl, usemecs;
+extern int fullspd, gen_line_dirs, performance_report, backtrack_report, csize;
+extern int yymore_used, reject, real_reject, continued_action;
+
+#define REALLY_NOT_DETERMINED 0
+#define REALLY_USED 1
+#define REALLY_NOT_USED 2
+extern int yymore_really_used, reject_really_used;
+
+
+/* variables used in the flex input routines:
+ * datapos - characters on current output line
+ * dataline - number of contiguous lines of data in current data
+ *    statement.  Used to generate readable -f output
+ * linenum - current input line number
+ * skelfile - the skeleton file
+ * yyin - input file
+ * temp_action_file - temporary file to hold actions
+ * backtrack_file - file to summarize backtracking states to
+ * infilename - name of input file
+ * action_file_name - name of the temporary file
+ * input_files - array holding names of input files
+ * num_input_files - size of input_files array
+ * program_name - name with which program was invoked 
+ */
+
+extern int datapos, dataline, linenum;
+extern FILE *skelfile, *yyin, *temp_action_file, *backtrack_file;
+extern char *infilename;
+extern char *action_file_name;
+extern char **input_files;
+extern int num_input_files;
+extern char *program_name;
+
+
+/* variables for stack of states having only one out-transition:
+ * onestate - state number
+ * onesym - transition symbol
+ * onenext - target state
+ * onedef - default base entry
+ * onesp - stack pointer
+ */
+
+extern int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
+extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
+
+
+/* variables for nfa machine data:
+ * current_mns - current maximum on number of NFA states
+ * num_rules - number of the last accepting state; also is number of
+ *             rules created so far
+ * current_max_rules - current maximum number of rules
+ * lastnfa - last nfa state number created
+ * firstst - physically the first state of a fragment
+ * lastst - last physical state of fragment
+ * finalst - last logical state of fragment
+ * transchar - transition character
+ * trans1 - transition state
+ * trans2 - 2nd transition state for epsilons
+ * accptnum - accepting number
+ * assoc_rule - rule associated with this NFA state (or 0 if none)
+ * state_type - a STATE_xxx type identifying whether the state is part
+ *              of a normal rule, the leading state in a trailing context
+ *              rule (i.e., the state which marks the transition from
+ *              recognizing the text-to-be-matched to the beginning of
+ *              the trailing context), or a subsequent state in a trailing
+ *              context rule
+ * rule_type - a RULE_xxx type identifying whether this a a ho-hum
+ *             normal rule or one which has variable head & trailing
+ *             context
+ * rule_linenum - line number associated with rule
+ */
+
+extern int current_mns, num_rules, current_max_rules, lastnfa;
+extern int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
+extern int *accptnum, *assoc_rule, *state_type, *rule_type, *rule_linenum;
+
+/* different types of states; values are useful as masks, as well, for
+ * routines like check_trailing_context()
+ */
+#define STATE_NORMAL 0x1
+#define STATE_TRAILING_CONTEXT 0x2
+
+/* global holding current type of state we're making */
+
+extern int current_state_type;
+
+/* different types of rules */
+#define RULE_NORMAL 0
+#define RULE_VARIABLE 1
+
+/* true if the input rules include a rule with both variable-length head
+ * and trailing context, false otherwise
+ */
+extern int variable_trailing_context_rules;
+
+
+/* variables for protos:
+ * numtemps - number of templates created
+ * numprots - number of protos created
+ * protprev - backlink to a more-recently used proto
+ * protnext - forward link to a less-recently used proto
+ * prottbl - base/def table entry for proto
+ * protcomst - common state of proto
+ * firstprot - number of the most recently used proto
+ * lastprot - number of the least recently used proto
+ * protsave contains the entire state array for protos
+ */
+
+extern int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
+extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
+
+
+/* variables for managing equivalence classes:
+ * numecs - number of equivalence classes
+ * nextecm - forward link of Equivalence Class members
+ * ecgroup - class number or backward link of EC members
+ * nummecs - number of meta-equivalence classes (used to compress
+ *   templates)
+ * tecfwd - forward link of meta-equivalence classes members
+ * tecbck - backward link of MEC's
+ * xlation - maps character codes to their translations, or nil if no %t table
+ * num_xlations - number of different xlation values
+ */
+
+/* reserve enough room in the equivalence class arrays so that we
+ * can use the CSIZE'th element to hold equivalence class information
+ * for the NUL character.  Later we'll move this information into
+ * the 0th element.
+ */
+extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs;
+
+/* meta-equivalence classes are indexed starting at 1, so it's possible
+ * that they will require positions from 1 .. CSIZE, i.e., CSIZE + 1
+ * slots total (since the arrays are 0-based).  nextecm[] and ecgroup[]
+ * don't require the extra position since they're indexed from 1 .. CSIZE - 1.
+ */
+extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1];
+
+extern int *xlation;
+extern int num_xlations;
+
+
+/* variables for start conditions:
+ * lastsc - last start condition created
+ * current_max_scs - current limit on number of start conditions
+ * scset - set of rules active in start condition
+ * scbol - set of rules active only at the beginning of line in a s.c.
+ * scxclu - true if start condition is exclusive
+ * sceof - true if start condition has EOF rule
+ * scname - start condition name
+ * actvsc - stack of active start conditions for the current rule
+ */
+
+extern int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
+extern char **scname;
+
+
+/* variables for dfa machine data:
+ * current_max_dfa_size - current maximum number of NFA states in DFA
+ * current_max_xpairs - current maximum number of non-template xtion pairs
+ * current_max_template_xpairs - current maximum number of template pairs
+ * current_max_dfas - current maximum number DFA states
+ * lastdfa - last dfa state number created
+ * nxt - state to enter upon reading character
+ * chk - check value to see if "nxt" applies
+ * tnxt - internal nxt table for templates
+ * base - offset into "nxt" for given state
+ * def - where to go if "chk" disallows "nxt" entry
+ * nultrans - NUL transition for each state
+ * NUL_ec - equivalence class of the NUL character
+ * tblend - last "nxt/chk" table entry being used
+ * firstfree - first empty entry in "nxt/chk" table
+ * dss - nfa state set for each dfa
+ * dfasiz - size of nfa state set for each dfa
+ * dfaacc - accepting set for each dfa state (or accepting number, if
+ *    -r is not given)
+ * accsiz - size of accepting set for each dfa state
+ * dhash - dfa state hash value
+ * numas - number of DFA accepting states created; note that this
+ *    is not necessarily the same value as num_rules, which is the analogous
+ *    value for the NFA
+ * numsnpairs - number of state/nextstate transition pairs
+ * jambase - position in base/def where the default jam table starts
+ * jamstate - state number corresponding to "jam" state
+ * end_of_buffer_state - end-of-buffer dfa state number
+ */
+
+extern int current_max_dfa_size, current_max_xpairs;
+extern int current_max_template_xpairs, current_max_dfas;
+extern int lastdfa, lasttemp, *nxt, *chk, *tnxt;
+extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
+extern union dfaacc_union
+    {
+    int *dfaacc_set;
+    int dfaacc_state;
+    } *dfaacc;
+extern int *accsiz, *dhash, numas;
+extern int numsnpairs, jambase, jamstate;
+extern int end_of_buffer_state;
+
+/* variables for ccl information:
+ * lastccl - ccl index of the last created ccl
+ * current_maxccls - current limit on the maximum number of unique ccl's
+ * cclmap - maps a ccl index to its set pointer
+ * ccllen - gives the length of a ccl
+ * cclng - true for a given ccl if the ccl is negated
+ * cclreuse - counts how many times a ccl is re-used
+ * current_max_ccl_tbl_size - current limit on number of characters needed
+ *	to represent the unique ccl's
+ * ccltbl - holds the characters in each ccl - indexed by cclmap
+ */
+
+extern int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
+extern int current_max_ccl_tbl_size;
+extern Char *ccltbl;
+
+
+/* variables for miscellaneous information:
+ * starttime - real-time when we started
+ * endtime - real-time when we ended
+ * nmstr - last NAME scanned by the scanner
+ * sectnum - section number currently being parsed
+ * nummt - number of empty nxt/chk table entries
+ * hshcol - number of hash collisions detected by snstods
+ * dfaeql - number of times a newly created dfa was equal to an old one
+ * numeps - number of epsilon NFA states created
+ * eps2 - number of epsilon states which have 2 out-transitions
+ * num_reallocs - number of times it was necessary to realloc() a group
+ *		  of arrays
+ * tmpuses - number of DFA states that chain to templates
+ * totnst - total number of NFA states used to make DFA states
+ * peakpairs - peak number of transition pairs we had to store internally
+ * numuniq - number of unique transitions
+ * numdup - number of duplicate transitions
+ * hshsave - number of hash collisions saved by checking number of states
+ * num_backtracking - number of DFA states requiring back-tracking
+ * bol_needed - whether scanner needs beginning-of-line recognition
+ */
+
+extern char *starttime, *endtime, nmstr[MAXLINE];
+extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
+extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
+extern int num_backtracking, bol_needed;
+
+void *allocate_array(), *reallocate_array();
+
+#define allocate_integer_array(size) \
+	(int *) allocate_array( size, sizeof( int ) )
+
+#define reallocate_integer_array(array,size) \
+	(int *) reallocate_array( (void *) array, size, sizeof( int ) )
+
+#define allocate_int_ptr_array(size) \
+	(int **) allocate_array( size, sizeof( int * ) )
+
+#define allocate_char_ptr_array(size) \
+	(char **) allocate_array( size, sizeof( char * ) )
+
+#define allocate_dfaacc_union(size) \
+	(union dfaacc_union *) \
+		allocate_array( size, sizeof( union dfaacc_union ) )
+
+#define reallocate_int_ptr_array(array,size) \
+	(int **) reallocate_array( (void *) array, size, sizeof( int * ) )
+
+#define reallocate_char_ptr_array(array,size) \
+	(char **) reallocate_array( (void *) array, size, sizeof( char * ) )
+
+#define reallocate_dfaacc_union(array, size) \
+	(union dfaacc_union *) \
+	reallocate_array( (void *) array, size, sizeof( union dfaacc_union ) )
+
+#define allocate_character_array(size) \
+	(Char *) allocate_array( size, sizeof( Char ) )
+
+#define reallocate_character_array(array,size) \
+	(Char *) reallocate_array( (void *) array, size, sizeof( Char ) )
+
+
+/* used to communicate between scanner and parser.  The type should really
+ * be YYSTYPE, but we can't easily get our hands on it.
+ */
+extern int yylval;
+
+
+/* external functions that are cross-referenced among the flex source files */
+
+
+/* from file ccl.c */
+
+extern void ccladd PROTO((int, int));	/* Add a single character to a ccl */
+extern int cclinit PROTO(());	/* make an empty ccl */
+extern void cclnegate PROTO((int));	/* negate a ccl */
+
+/* list the members of a set of characters in CCL form */
+extern void list_character_set PROTO((FILE*, int[]));
+
+
+/* from file dfa.c */
+
+/* increase the maximum number of dfas */
+extern void increase_max_dfas PROTO(());
+
+extern void ntod PROTO(());	/* convert a ndfa to a dfa */
+
+
+/* from file ecs.c */
+
+/* convert character classes to set of equivalence classes */
+extern void ccl2ecl PROTO(());
+
+/* associate equivalence class numbers with class members */
+extern int cre8ecs PROTO((int[], int[], int));
+
+/* associate equivalence class numbers using %t table */
+extern int ecs_from_xlation PROTO((int[]));
+
+/* update equivalence classes based on character class transitions */
+extern void mkeccl PROTO((Char[], int, int[], int[], int, int));
+
+/* create equivalence class for single character */
+extern void mkechar PROTO((int, int[], int[]));
+
+
+/* from file gen.c */
+
+extern void make_tables PROTO(());	/* generate transition tables */
+
+
+/* from file main.c */
+
+extern void flexend PROTO((int));
+
+
+/* from file misc.c */
+
+/* write out the actions from the temporary file to lex.yy.c */
+extern void action_out PROTO(());
+
+/* true if a string is all lower case */
+extern int all_lower PROTO((register Char *));
+
+/* true if a string is all upper case */
+extern int all_upper PROTO((register Char *));
+
+/* bubble sort an integer array */
+extern void bubble PROTO((int [], int));
+
+/* shell sort a character array */
+extern void cshell PROTO((Char [], int, int));
+
+extern void dataend PROTO(());	/* finish up a block of data declarations */
+
+/* report an error message and terminate */
+extern void flexerror PROTO((char[]));
+
+/* report a fatal error message and terminate */
+extern void flexfatal PROTO((char[]));
+
+/* report an error message formatted with one integer argument */
+extern void lerrif PROTO((char[], int));
+
+/* report an error message formatted with one string argument */
+extern void lerrsf PROTO((char[], char[]));
+
+/* spit out a "# line" statement */
+extern void line_directive_out PROTO((FILE*));
+
+/* generate a data statment for a two-dimensional array */
+extern void mk2data PROTO((int));
+
+extern void mkdata PROTO((int));	/* generate a data statement */
+
+/* return the integer represented by a string of digits */
+extern int myctoi PROTO((Char []));
+
+/* write out one section of the skeleton file */
+extern void skelout PROTO(());
+
+/* output a yy_trans_info structure */
+extern void transition_struct_out PROTO((int, int));
+
+
+/* from file nfa.c */
+
+/* add an accepting state to a machine */
+extern void add_accept PROTO((int, int));
+
+/* make a given number of copies of a singleton machine */
+extern int copysingl PROTO((int, int));
+
+/* debugging routine to write out an nfa */
+extern void dumpnfa PROTO((int));
+
+/* finish up the processing for a rule */
+extern void finish_rule PROTO((int, int, int, int));
+
+/* connect two machines together */
+extern int link_machines PROTO((int, int));
+
+/* mark each "beginning" state in a machine as being a "normal" (i.e.,
+ * not trailing context associated) state
+ */
+extern void mark_beginning_as_normal PROTO((register int));
+
+/* make a machine that branches to two machines */
+extern int mkbranch PROTO((int, int));
+
+extern int mkclos PROTO((int));	/* convert a machine into a closure */
+extern int mkopt PROTO((int));	/* make a machine optional */
+
+/* make a machine that matches either one of two machines */
+extern int mkor PROTO((int, int));
+
+/* convert a machine into a positive closure */
+extern int mkposcl PROTO((int));
+
+extern int mkrep PROTO((int, int, int));	/* make a replicated machine */
+
+/* create a state with a transition on a given symbol */
+extern int mkstate PROTO((int));
+
+extern void new_rule PROTO(());	/* initialize for a new rule */
+
+
+/* from file parse.y */
+
+/* write out a message formatted with one string, pinpointing its location */
+extern void format_pinpoint_message PROTO((char[], char[]));
+
+/* write out a message, pinpointing its location */
+extern void pinpoint_message PROTO((char[]));
+
+extern void synerr PROTO((char []));	/* report a syntax error */
+extern int yyparse PROTO(());	/* the YACC parser */
+
+
+/* from file scan.l */
+
+extern int flexscan PROTO(());	/* the Flex-generated scanner for flex */
+
+/* open the given file (if NULL, stdin) for scanning */
+extern void set_input_file PROTO((char*));
+
+extern int yywrap PROTO(());	/* wrapup a file in the lexical analyzer */
+
+
+/* from file sym.c */
+
+/* save the text of a character class */
+extern void cclinstal PROTO ((Char [], int));
+
+/* lookup the number associated with character class */
+extern int ccllookup PROTO((Char []));
+
+extern void ndinstal PROTO((char[], Char[]));	/* install a name definition */
+extern void scinstal PROTO((char[], int));	/* make a start condition */
+
+/* lookup the number associated with a start condition */
+extern int sclookup PROTO((char[]));
+
+
+/* from file tblcmp.c */
+
+/* build table entries for dfa state */
+extern void bldtbl PROTO((int[], int, int, int, int));
+
+extern void cmptmps PROTO(());	/* compress template table entries */
+extern void inittbl PROTO(());	/* initialize transition tables */
+extern void mkdeftbl PROTO(());	/* make the default, "jam" table entries */
+
+/* create table entries for a state (or state fragment) which has
+ * only one out-transition */
+extern void mk1tbl PROTO((int, int, int, int));
+
+/* place a state into full speed transition table */
+extern void place_state PROTO((int*, int, int));
+
+/* save states with only one out-transition to be processed later */
+extern void stack1 PROTO((int, int, int, int));
+
+
+/* from file yylex.c */
+
+extern int yylex PROTO(());

eoe/cmd/gnu/flex/libmain.c

@@ -0,0 +1,13 @@
+/* libmain - flex run-time support library "main" function */
+
+/* $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/libmain.c,v 1.1 1992/05/05 22:30:31 wicinski Exp $ */
+
+extern int yylex();
+
+int main( argc, argv )
+int argc;
+char *argv[];
+
+    {
+    return yylex();
+    }

eoe/cmd/gnu/flex/main.c

@@ -0,0 +1,767 @@
+/* flex - tool to generate fast lexical analyzers */
+
+/*-
+ * 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1990 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/main.c,v 1.1 1992/05/05 22:30:34 wicinski Exp $ (LBL)";
+#endif
+
+
+#include "flexdef.h"
+
+static char flex_version[] = "2.3";
+
+
+/* declare functions that have forward references */
+
+void flexinit PROTO((int, char**));
+void readin PROTO(());
+void set_up_initial_allocations PROTO(());
+
+
+/* these globals are all defined and commented in flexdef.h */
+int printstats, syntaxerror, eofseen, ddebug, trace, spprdflt;
+int interactive, caseins, useecs, fulltbl, usemecs;
+int fullspd, gen_line_dirs, performance_report, backtrack_report, csize;
+int yymore_used, reject, real_reject, continued_action;
+int yymore_really_used, reject_really_used;
+int datapos, dataline, linenum;
+FILE *skelfile = NULL;
+char *infilename = NULL;
+int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
+int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
+int current_mns, num_rules, current_max_rules, lastnfa;
+int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
+int *accptnum, *assoc_rule, *state_type, *rule_type, *rule_linenum;
+int current_state_type;
+int variable_trailing_context_rules;
+int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
+int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
+int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
+int tecbck[CSIZE + 1];
+int *xlation = (int *) 0;
+int num_xlations;
+int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
+char **scname;
+int current_max_dfa_size, current_max_xpairs;
+int current_max_template_xpairs, current_max_dfas;
+int lastdfa, *nxt, *chk, *tnxt;
+int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
+union dfaacc_union *dfaacc;
+int *accsiz, *dhash, numas;
+int numsnpairs, jambase, jamstate;
+int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
+int current_max_ccl_tbl_size;
+Char *ccltbl;
+char *starttime, *endtime, nmstr[MAXLINE];
+int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
+int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
+int num_backtracking, bol_needed;
+FILE *temp_action_file;
+FILE *backtrack_file;
+int end_of_buffer_state;
+char *action_file_name = NULL;
+char **input_files;
+int num_input_files;
+char *program_name;
+
+#ifndef SHORT_FILE_NAMES
+static char *outfile = "lex.yy.c";
+#else
+static char *outfile = "lexyy.c";
+#endif
+static int outfile_created = 0;
+static int use_stdout;
+static char *skelname = NULL;
+
+
+int main( argc, argv )
+int argc;
+char **argv;
+
+    {
+    flexinit( argc, argv );
+
+    readin();
+
+    if ( syntaxerror )
+	flexend( 1 );
+
+    if ( yymore_really_used == REALLY_USED )
+	yymore_used = true;
+    else if ( yymore_really_used == REALLY_NOT_USED )
+	yymore_used = false;
+
+    if ( reject_really_used == REALLY_USED )
+	reject = true;
+    else if ( reject_really_used == REALLY_NOT_USED )
+	reject = false;
+
+    if ( performance_report )
+	{
+	if ( interactive )
+	    fprintf( stderr,
+		     "-I (interactive) entails a minor performance penalty\n" );
+
+	if ( yymore_used )
+	    fprintf( stderr, "yymore() entails a minor performance penalty\n" );
+
+	if ( reject )
+	    fprintf( stderr, "REJECT entails a large performance penalty\n" );
+
+	if ( variable_trailing_context_rules )
+	    fprintf( stderr,
+"Variable trailing context rules entail a large performance penalty\n" );
+	}
+
+    if ( reject )
+	real_reject = true;
+
+    if ( variable_trailing_context_rules )
+	reject = true;
+
+    if ( (fulltbl || fullspd) && reject )
+	{
+	if ( real_reject )
+	    flexerror( "REJECT cannot be used with -f or -F" );
+	else
+	    flexerror(
+	"variable trailing context rules cannot be used with -f or -F" );
+	}
+
+    ntod();
+
+    /* generate the C state transition tables from the DFA */
+    make_tables();
+
+    /* note, flexend does not return.  It exits with its argument as status. */
+
+    flexend( 0 );
+
+    /*NOTREACHED*/
+    }
+
+
+/* flexend - terminate flex
+ *
+ * synopsis
+ *    int status;
+ *    flexend( status );
+ *
+ *    status is exit status.
+ *
+ * note
+ *    This routine does not return.
+ */
+
+void flexend( status )
+int status;
+
+    {
+    int tblsiz;
+    char *flex_gettime();
+
+    if ( skelfile != NULL )
+	{
+	if ( ferror( skelfile ) )
+	    flexfatal( "error occurred when writing skeleton file" );
+
+	else if ( fclose( skelfile ) )
+	    flexfatal( "error occurred when closing skeleton file" );
+	}
+
+    if ( temp_action_file )
+	{
+	if ( ferror( temp_action_file ) )
+	    flexfatal( "error occurred when writing temporary action file" );
+
+	else if ( fclose( temp_action_file ) )
+	    flexfatal( "error occurred when closing temporary action file" );
+
+	else if ( unlink( action_file_name ) )
+	    flexfatal( "error occurred when deleting temporary action file" );
+	}
+
+    if ( status != 0 && outfile_created )
+	{
+	if ( ferror( stdout ) )
+	    flexfatal( "error occurred when writing output file" );
+
+	else if ( fclose( stdout ) )
+	    flexfatal( "error occurred when closing output file" );
+
+	else if ( unlink( outfile ) )
+	    flexfatal( "error occurred when deleting output file" );
+	}
+
+    if ( backtrack_report && backtrack_file )
+	{
+	if ( num_backtracking == 0 )
+	    fprintf( backtrack_file, "No backtracking.\n" );
+	else if ( fullspd || fulltbl )
+	    fprintf( backtrack_file,
+		     "%d backtracking (non-accepting) states.\n",
+		     num_backtracking );
+	else
+	    fprintf( backtrack_file, "Compressed tables always backtrack.\n" );
+
+	if ( ferror( backtrack_file ) )
+	    flexfatal( "error occurred when writing backtracking file" );
+
+	else if ( fclose( backtrack_file ) )
+	    flexfatal( "error occurred when closing backtracking file" );
+	}
+
+    if ( printstats )
+	{
+	endtime = flex_gettime();
+
+	fprintf( stderr, "%s version %s usage statistics:\n", program_name,
+		 flex_version );
+	fprintf( stderr, "  started at %s, finished at %s\n",
+		 starttime, endtime );
+
+	fprintf( stderr, "  scanner options: -" );
+
+	if ( backtrack_report )
+	    putc( 'b', stderr );
+	if ( ddebug )
+	    putc( 'd', stderr );
+	if ( interactive )
+	    putc( 'I', stderr );
+	if ( caseins )
+	    putc( 'i', stderr );
+	if ( ! gen_line_dirs )
+	    putc( 'L', stderr );
+	if ( performance_report )
+	    putc( 'p', stderr );
+	if ( spprdflt )
+	    putc( 's', stderr );
+	if ( use_stdout )
+	    putc( 't', stderr );
+	if ( trace )
+	    putc( 'T', stderr );
+	if ( printstats )
+	    putc( 'v', stderr );	/* always true! */
+	if ( csize == 256 )
+	    putc( '8', stderr );
+
+	fprintf( stderr, " -C" );
+
+	if ( fulltbl )
+	    putc( 'f', stderr );
+	if ( fullspd )
+	    putc( 'F', stderr );
+	if ( useecs )
+	    putc( 'e', stderr );
+	if ( usemecs )
+	    putc( 'm', stderr );
+
+	if ( strcmp( skelname, DEFAULT_SKELETON_FILE ) )
+	    fprintf( stderr, " -S%s", skelname );
+
+	putc( '\n', stderr );
+
+	fprintf( stderr, "  %d/%d NFA states\n", lastnfa, current_mns );
+	fprintf( stderr, "  %d/%d DFA states (%d words)\n", lastdfa,
+		 current_max_dfas, totnst );
+	fprintf( stderr,
+		 "  %d rules\n", num_rules - 1 /* - 1 for def. rule */ );
+
+	if ( num_backtracking == 0 )
+	    fprintf( stderr, "  No backtracking\n" );
+	else if ( fullspd || fulltbl )
+	    fprintf( stderr, "  %d backtracking (non-accepting) states\n",
+		     num_backtracking );
+	else
+	    fprintf( stderr, "  compressed tables always backtrack\n" );
+
+	if ( bol_needed )
+	    fprintf( stderr, "  Beginning-of-line patterns used\n" );
+
+	fprintf( stderr, "  %d/%d start conditions\n", lastsc,
+		 current_max_scs );
+	fprintf( stderr, "  %d epsilon states, %d double epsilon states\n",
+		 numeps, eps2 );
+
+	if ( lastccl == 0 )
+	    fprintf( stderr, "  no character classes\n" );
+	else
+	    fprintf( stderr,
+	"  %d/%d character classes needed %d/%d words of storage, %d reused\n",
+		     lastccl, current_maxccls,
+		     cclmap[lastccl] + ccllen[lastccl],
+		     current_max_ccl_tbl_size, cclreuse );
+
+	fprintf( stderr, "  %d state/nextstate pairs created\n", numsnpairs );
+	fprintf( stderr, "  %d/%d unique/duplicate transitions\n",
+		 numuniq, numdup );
+
+	if ( fulltbl )
+	    {
+	    tblsiz = lastdfa * numecs;
+	    fprintf( stderr, "  %d table entries\n", tblsiz );
+	    }
+
+	else
+	    {
+	    tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
+
+	    fprintf( stderr, "  %d/%d base-def entries created\n",
+		     lastdfa + numtemps, current_max_dfas );
+	    fprintf( stderr, "  %d/%d (peak %d) nxt-chk entries created\n",
+		     tblend, current_max_xpairs, peakpairs );
+	    fprintf( stderr,
+		     "  %d/%d (peak %d) template nxt-chk entries created\n",
+		     numtemps * nummecs, current_max_template_xpairs,
+		     numtemps * numecs );
+	    fprintf( stderr, "  %d empty table entries\n", nummt );
+	    fprintf( stderr, "  %d protos created\n", numprots );
+	    fprintf( stderr, "  %d templates created, %d uses\n",
+		     numtemps, tmpuses );
+	    }
+
+	if ( useecs )
+	    {
+	    tblsiz = tblsiz + csize;
+	    fprintf( stderr, "  %d/%d equivalence classes created\n",
+		     numecs, csize );
+	    }
+
+	if ( usemecs )
+	    {
+	    tblsiz = tblsiz + numecs;
+	    fprintf( stderr, "  %d/%d meta-equivalence classes created\n",
+		     nummecs, csize );
+	    }
+
+	fprintf( stderr, "  %d (%d saved) hash collisions, %d DFAs equal\n",
+		 hshcol, hshsave, dfaeql );
+	fprintf( stderr, "  %d sets of reallocations needed\n", num_reallocs );
+	fprintf( stderr, "  %d total table entries needed\n", tblsiz );
+	}
+
+#ifndef VMS
+    exit( status );
+#else
+    exit( status + 1 );
+#endif
+    }
+
+
+/* flexinit - initialize flex
+ *
+ * synopsis
+ *    int argc;
+ *    char **argv;
+ *    flexinit( argc, argv );
+ */
+
+void flexinit( argc, argv )
+int argc;
+char **argv;
+
+    {
+    int i, sawcmpflag;
+    char *arg, *flex_gettime(), *mktemp();
+
+    printstats = syntaxerror = trace = spprdflt = interactive = caseins = false;
+    backtrack_report = performance_report = ddebug = fulltbl = fullspd = false;
+    yymore_used = continued_action = reject = false;
+    yymore_really_used = reject_really_used = false;
+    gen_line_dirs = usemecs = useecs = true;
+
+    sawcmpflag = false;
+    use_stdout = false;
+
+    csize = DEFAULT_CSIZE;
+
+    program_name = argv[0];
+
+    /* read flags */
+    for ( --argc, ++argv; argc ; --argc, ++argv )
+	{
+	if ( argv[0][0] != '-' || argv[0][1] == '\0' )
+	    break;
+
+	arg = argv[0];
+
+	for ( i = 1; arg[i] != '\0'; ++i )
+	    switch ( arg[i] )
+		{
+		case 'b':
+		    backtrack_report = true;
+		    break;
+
+		case 'c':
+		    fprintf( stderr,
+	"%s: Assuming use of deprecated -c flag is really intended to be -C\n",
+			     program_name );
+
+		    /* fall through */
+
+		case 'C':
+		    if ( i != 1 )
+			flexerror( "-C flag must be given separately" );
+
+		    if ( ! sawcmpflag )
+			{
+			useecs = false;
+			usemecs = false;
+			fulltbl = false;
+			sawcmpflag = true;
+			}
+
+		    for ( ++i; arg[i] != '\0'; ++i )
+			switch ( arg[i] )
+			    {
+			    case 'e':
+				useecs = true;
+				break;
+
+			    case 'F':
+				fullspd = true;
+				break;
+
+			    case 'f':
+				fulltbl = true;
+				break;
+
+			    case 'm':
+				usemecs = true;
+				break;
+
+			    default:
+				lerrif( "unknown -C option '%c'",
+					(int) arg[i] );
+				break;
+			    }
+
+		    goto get_next_arg;
+
+		case 'd':
+		    ddebug = true;
+		    break;
+
+		case 'f':
+		    useecs = usemecs = false;
+		    fulltbl = true;
+		    break;
+
+		case 'F':
+		    useecs = usemecs = false;
+		    fullspd = true;
+		    break;
+
+		case 'I':
+		    interactive = true;
+		    break;
+
+		case 'i':
+		    caseins = true;
+		    break;
+
+		case 'L':
+		    gen_line_dirs = false;
+		    break;
+
+		case 'n':
+		    /* stupid do-nothing deprecated option */
+		    break;
+
+		case 'p':
+		    performance_report = true;
+		    break;
+
+		case 'S':
+		    if ( i != 1 )
+			flexerror( "-S flag must be given separately" );
+
+		    skelname = arg + i + 1;
+		    goto get_next_arg;
+
+		case 's':
+		    spprdflt = true;
+		    break;
+
+		case 't':
+		    use_stdout = true;
+		    break;
+
+		case 'T':
+		    trace = true;
+		    break;
+
+		case 'v':
+		    printstats = true;
+		    break;
+
+		case '8':
+		    csize = CSIZE;
+		    break;
+
+		default:
+		    lerrif( "unknown flag '%c'", (int) arg[i] );
+		    break;
+		}
+
+get_next_arg: /* used by -C and -S flags in lieu of a "continue 2" control */
+	;
+	}
+
+    if ( (fulltbl || fullspd) && usemecs )
+	flexerror( "full table and -Cm don't make sense together" );
+
+    if ( (fulltbl || fullspd) && interactive )
+	flexerror( "full table and -I are (currently) incompatible" );
+
+    if ( fulltbl && fullspd )
+	flexerror( "full table and -F are mutually exclusive" );
+
+    if ( ! skelname )
+	{
+	static char skeleton_name_storage[400];
+
+	skelname = skeleton_name_storage;
+	(void) strcpy( skelname, DEFAULT_SKELETON_FILE );
+	}
+
+    if ( ! use_stdout )
+	{
+	FILE *prev_stdout = freopen( outfile, "w", stdout );
+
+	if ( prev_stdout == NULL )
+	    lerrsf( "could not create %s", outfile );
+
+	outfile_created = 1;
+	}
+
+    num_input_files = argc;
+    input_files = argv;
+    set_input_file( num_input_files > 0 ? input_files[0] : NULL );
+
+    if ( backtrack_report )
+	{
+#ifndef SHORT_FILE_NAMES
+	backtrack_file = fopen( "lex.backtrack", "w" );
+#else
+	backtrack_file = fopen( "lex.bck", "w" );
+#endif
+
+	if ( backtrack_file == NULL )
+	    flexerror( "could not create lex.backtrack" );
+	}
+
+    else
+	backtrack_file = NULL;
+
+
+    lastccl = 0;
+    lastsc = 0;
+
+    /* initialize the statistics */
+    starttime = flex_gettime();
+
+    if ( (skelfile = fopen( skelname, "r" )) == NULL )
+	lerrsf( "can't open skeleton file %s", skelname );
+
+#ifdef SYS_V
+    action_file_name = tmpnam( NULL );
+#endif
+
+    if ( action_file_name == NULL )
+	{
+	static char temp_action_file_name[32];
+
+#ifndef SHORT_FILE_NAMES
+	(void) strcpy( temp_action_file_name, "/tmp/flexXXXXXX" );
+#else
+	(void) strcpy( temp_action_file_name, "flexXXXXXX.tmp" );
+#endif
+	(void) mktemp( temp_action_file_name );
+
+	action_file_name = temp_action_file_name;
+	}
+
+    if ( (temp_action_file = fopen( action_file_name, "w" )) == NULL )
+	lerrsf( "can't open temporary action file %s", action_file_name );
+
+    lastdfa = lastnfa = num_rules = numas = numsnpairs = tmpuses = 0;
+    numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
+    numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
+    num_backtracking = onesp = numprots = 0;
+    variable_trailing_context_rules = bol_needed = false;
+
+    linenum = sectnum = 1;
+    firstprot = NIL;
+
+    /* used in mkprot() so that the first proto goes in slot 1
+     * of the proto queue
+     */
+    lastprot = 1;
+
+    if ( useecs )
+	{ /* set up doubly-linked equivalence classes */
+	/* We loop all the way up to csize, since ecgroup[csize] is the
+	 * position used for NUL characters
+	 */
+	ecgroup[1] = NIL;
+
+	for ( i = 2; i <= csize; ++i )
+	    {
+	    ecgroup[i] = i - 1;
+	    nextecm[i - 1] = i;
+	    }
+
+	nextecm[csize] = NIL;
+	}
+
+    else
+	{ /* put everything in its own equivalence class */
+	for ( i = 1; i <= csize; ++i )
+	    {
+	    ecgroup[i] = i;
+	    nextecm[i] = BAD_SUBSCRIPT;	/* to catch errors */
+	    }
+	}
+
+    set_up_initial_allocations();
+    }
+
+
+/* readin - read in the rules section of the input file(s)
+ *
+ * synopsis
+ *    readin();
+ */
+
+void readin()
+
+    {
+    skelout();
+
+    if ( ddebug )
+	puts( "#define FLEX_DEBUG" );
+
+    if ( csize == 256 )
+	puts( "#define YY_CHAR unsigned char" );
+    else
+	puts( "#define YY_CHAR char" );
+
+    line_directive_out( stdout );
+
+    if ( yyparse() )
+	{
+	pinpoint_message( "fatal parse error" );
+	flexend( 1 );
+	}
+
+    if ( xlation )
+	{
+	numecs = ecs_from_xlation( ecgroup );
+	useecs = true;
+	}
+
+    else if ( useecs )
+	numecs = cre8ecs( nextecm, ecgroup, csize );
+
+    else
+	numecs = csize;
+
+    /* now map the equivalence class for NUL to its expected place */
+    ecgroup[0] = ecgroup[csize];
+    NUL_ec = abs( ecgroup[0] );
+
+    if ( useecs )
+	ccl2ecl();
+    }
+
+
+
+/* set_up_initial_allocations - allocate memory for internal tables */
+
+void set_up_initial_allocations()
+
+    {
+    current_mns = INITIAL_MNS;
+    firstst = allocate_integer_array( current_mns );
+    lastst = allocate_integer_array( current_mns );
+    finalst = allocate_integer_array( current_mns );
+    transchar = allocate_integer_array( current_mns );
+    trans1 = allocate_integer_array( current_mns );
+    trans2 = allocate_integer_array( current_mns );
+    accptnum = allocate_integer_array( current_mns );
+    assoc_rule = allocate_integer_array( current_mns );
+    state_type = allocate_integer_array( current_mns );
+
+    current_max_rules = INITIAL_MAX_RULES;
+    rule_type = allocate_integer_array( current_max_rules );
+    rule_linenum = allocate_integer_array( current_max_rules );
+
+    current_max_scs = INITIAL_MAX_SCS;
+    scset = allocate_integer_array( current_max_scs );
+    scbol = allocate_integer_array( current_max_scs );
+    scxclu = allocate_integer_array( current_max_scs );
+    sceof = allocate_integer_array( current_max_scs );
+    scname = allocate_char_ptr_array( current_max_scs );
+    actvsc = allocate_integer_array( current_max_scs );
+
+    current_maxccls = INITIAL_MAX_CCLS;
+    cclmap = allocate_integer_array( current_maxccls );
+    ccllen = allocate_integer_array( current_maxccls );
+    cclng = allocate_integer_array( current_maxccls );
+
+    current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
+    ccltbl = allocate_character_array( current_max_ccl_tbl_size );
+
+    current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
+
+    current_max_xpairs = INITIAL_MAX_XPAIRS;
+    nxt = allocate_integer_array( current_max_xpairs );
+    chk = allocate_integer_array( current_max_xpairs );
+
+    current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
+    tnxt = allocate_integer_array( current_max_template_xpairs );
+
+    current_max_dfas = INITIAL_MAX_DFAS;
+    base = allocate_integer_array( current_max_dfas );
+    def = allocate_integer_array( current_max_dfas );
+    dfasiz = allocate_integer_array( current_max_dfas );
+    accsiz = allocate_integer_array( current_max_dfas );
+    dhash = allocate_integer_array( current_max_dfas );
+    dss = allocate_int_ptr_array( current_max_dfas );
+    dfaacc = allocate_dfaacc_union( current_max_dfas );
+
+    nultrans = (int *) 0;
+    }

eoe/cmd/gnu/flex/misc.c

@@ -0,0 +1,826 @@
+/* misc - miscellaneous flex 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/misc.c,v 1.1 1992/05/05 22:30:38 wicinski Exp $ (LBL)";
+#endif
+
+#include <ctype.h>
+#include "flexdef.h"
+
+
+/* ANSI C does not guarantee that isascii() is defined */
+#ifndef isascii
+#define isascii(c) ((c) <= 0177)
+#endif
+
+
+
+/* declare functions that have forward references */
+
+void dataflush PROTO(());
+int otoi PROTO((Char []));
+
+
+/* action_out - write the actions from the temporary file to lex.yy.c
+ *
+ * synopsis
+ *     action_out();
+ *
+ *     Copies the action file up to %% (or end-of-file) to lex.yy.c
+ */
+
+void action_out()
+
+    {
+    char buf[MAXLINE];
+
+    while ( fgets( buf, MAXLINE, temp_action_file ) != NULL )
+	if ( buf[0] == '%' && buf[1] == '%' )
+	    break;
+	else
+	    fputs( buf, stdout );
+    }
+
+
+/* allocate_array - allocate memory for an integer array of the given size */
+
+void *allocate_array( size, element_size )
+int size, element_size;
+
+    {
+    register void *mem;
+
+    /* on 16-bit int machines (e.g., 80286) we might be trying to
+     * allocate more than a signed int can hold, and that won't
+     * work.  Cheap test:
+     */
+    if ( element_size * size <= 0 )
+        flexfatal( "request for < 1 byte in allocate_array()" );
+
+    mem = (void *) malloc( (unsigned) (element_size * size) );
+
+    if ( mem == NULL )
+	flexfatal( "memory allocation failed in allocate_array()" );
+
+    return ( mem );
+    }
+
+
+/* all_lower - true if a string is all lower-case
+ *
+ * synopsis:
+ *    Char *str;
+ *    int all_lower();
+ *    true/false = all_lower( str );
+ */
+
+int all_lower( str )
+register Char *str;
+
+    {
+    while ( *str )
+	{
+	if ( ! isascii( *str ) || ! islower( *str ) )
+	    return ( 0 );
+	++str;
+	}
+
+    return ( 1 );
+    }
+
+
+/* all_upper - true if a string is all upper-case
+ *
+ * synopsis:
+ *    Char *str;
+ *    int all_upper();
+ *    true/false = all_upper( str );
+ */
+
+int all_upper( str )
+register Char *str;
+
+    {
+    while ( *str )
+	{
+	if ( ! isascii( *str ) || ! isupper( (char) *str ) )
+	    return ( 0 );
+	++str;
+	}
+
+    return ( 1 );
+    }
+
+
+/* bubble - bubble sort an integer array in increasing order
+ *
+ * synopsis
+ *   int v[n], n;
+ *   bubble( v, n );
+ *
+ * description
+ *   sorts the first n elements of array v and replaces them in
+ *   increasing order.
+ *
+ * passed
+ *   v - the array to be sorted
+ *   n - the number of elements of 'v' to be sorted */
+
+void bubble( v, n )
+int v[], n;
+
+    {
+    register int i, j, k;
+
+    for ( i = n; i > 1; --i )
+	for ( j = 1; j < i; ++j )
+	    if ( v[j] > v[j + 1] )	/* compare */
+		{
+		k = v[j];	/* exchange */
+		v[j] = v[j + 1];
+		v[j + 1] = k;
+		}
+    }
+
+
+/* clower - replace upper-case letter to lower-case
+ *
+ * synopsis:
+ *    Char clower();
+ *    int c;
+ *    c = clower( c );
+ */
+
+Char clower( c )
+register int c;
+
+    {
+    return ( (isascii( c ) && isupper( c )) ? tolower( c ) : c );
+    }
+
+
+/* copy_string - returns a dynamically allocated copy of a string
+ *
+ * synopsis
+ *    char *str, *copy, *copy_string();
+ *    copy = copy_string( str );
+ */
+
+char *copy_string( str )
+register char *str;
+
+    {
+    register char *c;
+    char *copy;
+
+    /* find length */
+    for ( c = str; *c; ++c )
+	;
+
+    copy = malloc( (unsigned) ((c - str + 1) * sizeof( char )) );
+
+    if ( copy == NULL )
+	flexfatal( "dynamic memory failure in copy_string()" );
+
+    for ( c = copy; (*c++ = *str++); )
+	;
+
+    return ( copy );
+    }
+
+
+/* copy_unsigned_string -
+ *    returns a dynamically allocated copy of a (potentially) unsigned string
+ *
+ * synopsis
+ *    Char *str, *copy, *copy_unsigned_string();
+ *    copy = copy_unsigned_string( str );
+ */
+
+Char *copy_unsigned_string( str )
+register Char *str;
+
+    {
+    register Char *c;
+    Char *copy;
+
+    /* find length */
+    for ( c = str; *c; ++c )
+	;
+
+    copy = (Char *) malloc( (unsigned) ((c - str + 1) * sizeof( Char )) );
+
+    if ( copy == NULL )
+	flexfatal( "dynamic memory failure in copy_unsigned_string()" );
+
+    for ( c = copy; (*c++ = *str++); )
+	;
+
+    return ( copy );
+    }
+
+
+/* cshell - shell sort a character array in increasing order
+ *
+ * synopsis
+ *
+ *   Char v[n];
+ *   int n, special_case_0;
+ *   cshell( v, n, special_case_0 );
+ *
+ * description
+ *   does a shell sort of the first n elements of array v.
+ *   If special_case_0 is true, then any element equal to 0
+ *   is instead assumed to have infinite weight.
+ *
+ * passed
+ *   v - array to be sorted
+ *   n - number of elements of v to be sorted
+ */
+
+void cshell( v, n, special_case_0 )
+Char v[];
+int n, special_case_0;
+
+    {
+    int gap, i, j, jg;
+    Char k;
+
+    for ( gap = n / 2; gap > 0; gap = gap / 2 )
+	for ( i = gap; i < n; ++i )
+	    for ( j = i - gap; j >= 0; j = j - gap )
+		{
+		jg = j + gap;
+
+		if ( special_case_0 )
+		    {
+		    if ( v[jg] == 0 )
+			break;
+
+		    else if ( v[j] != 0 && v[j] <= v[jg] )
+			break;
+		    }
+
+		else if ( v[j] <= v[jg] )
+		    break;
+
+		k = v[j];
+		v[j] = v[jg];
+		v[jg] = k;
+		}
+    }
+
+
+/* dataend - finish up a block of data declarations
+ *
+ * synopsis
+ *    dataend();
+ */
+
+void dataend()
+
+    {
+    if ( datapos > 0 )
+	dataflush();
+
+    /* add terminator for initialization */
+    puts( "    } ;\n" );
+
+    dataline = 0;
+    datapos = 0;
+    }
+
+
+
+/* dataflush - flush generated data statements
+ *
+ * synopsis
+ *    dataflush();
+ */
+
+void dataflush()
+
+    {
+    putchar( '\n' );
+
+    if ( ++dataline >= NUMDATALINES )
+	{
+	/* put out a blank line so that the table is grouped into
+	 * large blocks that enable the user to find elements easily
+	 */
+	putchar( '\n' );
+	dataline = 0;
+	}
+
+    /* reset the number of characters written on the current line */
+    datapos = 0;
+    }
+
+
+/* flexerror - report an error message and terminate
+ *
+ * synopsis
+ *    char msg[];
+ *    flexerror( msg );
+ */
+
+void flexerror( msg )
+char msg[];
+
+    {
+    fprintf( stderr, "%s: %s\n", program_name, msg );
+
+    flexend( 1 );
+    }
+
+
+/* flexfatal - report a fatal error message and terminate
+ *
+ * synopsis
+ *    char msg[];
+ *    flexfatal( msg );
+ */
+
+void flexfatal( msg )
+char msg[];
+
+    {
+    fprintf( stderr, "%s: fatal internal error, %s\n", program_name, msg );
+    flexend( 1 );
+    }
+
+
+/* flex_gettime - return current time
+ *
+ * synopsis
+ *    char *flex_gettime(), *time_str;
+ *    time_str = flex_gettime();
+ *
+ * note
+ *    the routine name has the "flex_" prefix because of name clashes
+ *    with Turbo-C
+ */
+
+/* include sys/types.h to use time_t and make lint happy */
+
+#ifndef MS_DOS
+#ifndef VMS
+#include <sys/types.h>
+#else
+#include <types.h>
+#endif
+#endif
+
+#ifdef MS_DOS
+#include <time.h>
+typedef long time_t;
+#endif
+
+char *flex_gettime()
+
+    {
+    time_t t, time();
+    char *result, *ctime(), *copy_string();
+
+    t = time( (long *) 0 );
+
+    result = copy_string( ctime( &t ) );
+
+    /* get rid of trailing newline */
+    result[24] = '\0';
+
+    return ( result );
+    }
+
+
+/* lerrif - report an error message formatted with one integer argument
+ *
+ * synopsis
+ *    char msg[];
+ *    int arg;
+ *    lerrif( msg, arg );
+ */
+
+void lerrif( msg, arg )
+char msg[];
+int arg;
+
+    {
+    char errmsg[MAXLINE];
+    (void) sprintf( errmsg, msg, arg );
+    flexerror( errmsg );
+    }
+
+
+/* lerrsf - report an error message formatted with one string argument
+ *
+ * synopsis
+ *    char msg[], arg[];
+ *    lerrsf( msg, arg );
+ */
+
+void lerrsf( msg, arg )
+char msg[], arg[];
+
+    {
+    char errmsg[MAXLINE];
+
+    (void) sprintf( errmsg, msg, arg );
+    flexerror( errmsg );
+    }
+
+
+/* htoi - convert a hexadecimal digit string to an integer value
+ *
+ * synopsis:
+ *    int val, htoi();
+ *    Char str[];
+ *    val = htoi( str );
+ */
+
+int htoi( str )
+Char str[];
+
+    {
+    int result;
+
+    (void) sscanf( (char *) str, "%x", &result );
+
+    return ( result );
+    }
+
+
+/* is_hex_digit - returns true if a character is a valid hex digit, false
+ *		  otherwise
+ *
+ * synopsis:
+ *    int true_or_false, is_hex_digit();
+ *    int ch;
+ *    val = is_hex_digit( ch );
+ */
+
+int is_hex_digit( ch )
+int ch;
+
+    {
+    if ( isdigit( ch ) )
+	return ( 1 );
+
+    switch ( clower( ch ) )
+	{
+	case 'a':
+	case 'b':
+	case 'c':
+	case 'd':
+	case 'e':
+	case 'f':
+	    return ( 1 );
+
+	default:
+	    return ( 0 );
+	}
+    }
+
+
+/* line_directive_out - spit out a "# line" statement */
+
+void line_directive_out( output_file_name )
+FILE *output_file_name;
+
+    {
+    if ( infilename && gen_line_dirs )
+        fprintf( output_file_name, "# line %d \"%s\"\n", linenum, infilename );
+    }
+
+
+/* mk2data - generate a data statement for a two-dimensional array
+ *
+ * synopsis
+ *    int value;
+ *    mk2data( value );
+ *
+ *  generates a data statement initializing the current 2-D array to "value"
+ */
+void mk2data( value )
+int value;
+
+    {
+    if ( datapos >= NUMDATAITEMS )
+	{
+	putchar( ',' );
+	dataflush();
+	}
+
+    if ( datapos == 0 )
+	/* indent */
+	fputs( "    ", stdout );
+
+    else
+	putchar( ',' );
+
+    ++datapos;
+
+    printf( "%5d", value );
+    }
+
+
+/* mkdata - generate a data statement
+ *
+ * synopsis
+ *    int value;
+ *    mkdata( value );
+ *
+ *  generates a data statement initializing the current array element to
+ *  "value"
+ */
+void mkdata( value )
+int value;
+
+    {
+    if ( datapos >= NUMDATAITEMS )
+	{
+	putchar( ',' );
+	dataflush();
+	}
+
+    if ( datapos == 0 )
+	/* indent */
+	fputs( "    ", stdout );
+
+    else
+	putchar( ',' );
+
+    ++datapos;
+
+    printf( "%5d", value );
+    }
+
+
+/* myctoi - return the integer represented by a string of digits
+ *
+ * synopsis
+ *    Char array[];
+ *    int val, myctoi();
+ *    val = myctoi( array );
+ *
+ */
+
+int myctoi( array )
+Char array[];
+
+    {
+    int val = 0;
+
+    (void) sscanf( (char *) array, "%d", &val );
+
+    return ( val );
+    }
+
+
+/* myesc - return character corresponding to escape sequence
+ *
+ * synopsis
+ *    Char array[], c, myesc();
+ *    c = myesc( array );
+ *
+ */
+
+Char myesc( array )
+Char array[];
+
+    {
+    Char c, esc_char;
+    register int sptr;
+
+    switch ( array[1] )
+	{
+	case 'a': return ( '\a' );
+	case 'b': return ( '\b' );
+	case 'f': return ( '\f' );
+	case 'n': return ( '\n' );
+	case 'r': return ( '\r' );
+	case 't': return ( '\t' );
+	case 'v': return ( '\v' );
+
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	    { /* \<octal> */
+	    sptr = 1;
+
+	    while ( isascii( array[sptr] ) && isdigit( array[sptr] ) )
+		/* don't increment inside loop control because if
+		 * isdigit() is a macro it might expand into multiple
+		 * increments ...
+		 */
+		++sptr;
+
+	    c = array[sptr];
+	    array[sptr] = '\0';
+
+	    esc_char = otoi( array + 1 );
+
+	    array[sptr] = c;
+
+	    return ( esc_char );
+	    }
+
+	case 'x':
+	    { /* \x<hex> */
+	    int sptr = 2;
+
+	    while ( isascii( array[sptr] ) && is_hex_digit( array[sptr] ) )
+		/* don't increment inside loop control because if
+		 * isdigit() is a macro it might expand into multiple
+		 * increments ...
+		 */
+		++sptr;
+
+	    c = array[sptr];
+	    array[sptr] = '\0';
+
+	    esc_char = htoi( array + 2 );
+
+	    array[sptr] = c;
+
+	    return ( esc_char );
+	    }
+
+	default:
+	    return ( array[1] );
+	}
+    }
+
+
+/* otoi - convert an octal digit string to an integer value
+ *
+ * synopsis:
+ *    int val, otoi();
+ *    Char str[];
+ *    val = otoi( str );
+ */
+
+int otoi( str )
+Char str[];
+
+    {
+    int result;
+
+    (void) sscanf( (char *) str, "%o", &result );
+
+    return ( result );
+    }
+
+
+/* readable_form - return the the human-readable form of a character
+ *
+ * synopsis:
+ *    int c;
+ *    char *readable_form();
+ *    <string> = readable_form( c );
+ *
+ * The returned string is in static storage.
+ */
+
+char *readable_form( c )
+register int c;
+
+    {
+    static char rform[10];
+
+    if ( (c >= 0 && c < 32) || c >= 127 )
+	{
+	switch ( c )
+	    {
+	    case '\n': return ( "\\n" );
+	    case '\t': return ( "\\t" );
+	    case '\f': return ( "\\f" );
+	    case '\r': return ( "\\r" );
+	    case '\b': return ( "\\b" );
+
+	    default:
+		(void) sprintf( rform, "\\%.3o", c );
+		return ( rform );
+	    }
+	}
+
+    else if ( c == ' ' )
+	return ( "' '" );
+
+    else
+	{
+	rform[0] = c;
+	rform[1] = '\0';
+
+	return ( rform );
+	}
+    }
+
+
+/* reallocate_array - increase the size of a dynamic array */
+
+void *reallocate_array( array, size, element_size )
+void *array;
+int size, element_size;
+
+    {
+    register void *new_array;
+
+    /* same worry as in allocate_array(): */
+    if ( size * element_size <= 0 )
+        flexfatal( "attempt to increase array size by less than 1 byte" );
+
+    new_array =
+	(void *) realloc( (char *)array, (unsigned) (size * element_size ));
+
+    if ( new_array == NULL )
+	flexfatal( "attempt to increase array size failed" );
+
+    return ( new_array );
+    }
+
+
+/* skelout - write out one section of the skeleton file
+ *
+ * synopsis
+ *    skelout();
+ *
+ * DESCRIPTION
+ *    Copies from skelfile to stdout until a line beginning with "%%" or
+ *    EOF is found.
+ */
+void skelout()
+
+    {
+    char buf[MAXLINE];
+
+    while ( fgets( buf, MAXLINE, skelfile ) != NULL )
+	if ( buf[0] == '%' && buf[1] == '%' )
+	    break;
+	else
+	    fputs( buf, stdout );
+    }
+
+
+/* transition_struct_out - output a yy_trans_info structure
+ *
+ * synopsis
+ *     int element_v, element_n;
+ *     transition_struct_out( element_v, element_n );
+ *
+ * outputs the yy_trans_info structure with the two elements, element_v and
+ * element_n.  Formats the output with spaces and carriage returns.
+ */
+
+void transition_struct_out( element_v, element_n )
+int element_v, element_n;
+
+    {
+    printf( "%7d, %5d,", element_v, element_n );
+
+    datapos += TRANS_STRUCT_PRINT_LENGTH;
+
+    if ( datapos >= 75 )
+	{
+	putchar( '\n' );
+
+	if ( ++dataline % 10 == 0 )
+	    putchar( '\n' );
+
+	datapos = 0;
+	}
+    }

eoe/cmd/gnu/flex/nfa.c

@@ -0,0 +1,717 @@
+/* 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/nfa.c,v 1.1 1992/05/05 22:30:41 wicinski Exp $ (LBL)";
+#endif
+
+#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
+ *
+ * synopsis
+ *
+ *   add_accept( mach, accepting_number );
+ *
+ * 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;
+	mach = link_machines( mach, astate );
+	}
+    }
+
+
+/* copysingl - make a given number of copies of a singleton machine
+ *
+ * synopsis
+ *
+ *   newsng = copysingl( singl, num );
+ *
+ *     newsng - a new singleton composed of num copies of singl
+ *     singl  - a singleton machine
+ *     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
+ *
+ * synopsis
+ *    int state1;
+ *    dumpnfa( state1 );
+ */
+
+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"
+     * all of the rules together.  So we use our knowledge that the machine
+     * starts at state 1 and ends at lastnfa.
+     */
+
+    /* 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
+ *
+ *   copy = dupmachine( mach );
+ *
+ *     copy - holds duplicate of mach
+ *     mach - machine to be duplicated
+ *
+ * note that the copy of mach is NOT an exact duplicate; rather, all the
+ * transition states values are adjusted so that the copy is self-contained,
+ * as the original should have been.
+ *
+ * also note that the original MUST be contiguous, with its low and high
+ * 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;
+
+    init = mach + state_offset;
+    firstst[init] = firstst[mach] + state_offset;
+    finalst[init] = finalst[mach] + state_offset;
+    lastst[init] = lastst[mach] + state_offset;
+
+    return ( init );
+    }
+
+
+/* finish_rule - finish up the processing for a rule
+ *
+ * synopsis
+ *
+ *   finish_rule( mach, variable_trail_rule, headcnt, trailcnt );
+ *
+ * An accepting number is added to the given machine.  If variable_trail_rule
+ * is true then the rule has trailing context and both the head and trail
+ * are variable size.  Otherwise if headcnt or trailcnt is non-zero then
+ * the machine recognizes a pattern with trailing context and headcnt is
+ * the number of characters in the matched part of the pattern, or zero
+ * if the matched part has variable length.  trailcnt is the number of
+ * trailing context characters in the pattern, or zero if the trailing
+ * context has variable length.
+ */
+
+void finish_rule( mach, variable_trail_rule, headcnt, trailcnt )
+int mach, variable_trail_rule, headcnt, trailcnt;
+
+    {
+    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
+     */
+    rule_linenum[num_rules] = linenum;
+
+    /* 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];
+
+    fprintf( temp_action_file, "case %d:\n", num_rules );
+
+    if ( variable_trail_rule )
+	{
+	rule_type[num_rules] = RULE_VARIABLE;
+
+	if ( performance_report )
+	    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";
+
+	    fprintf( temp_action_file,
+	"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */\n" );
+
+	    if ( headcnt > 0 )
+		fprintf( temp_action_file, "%s = %s + %d;\n",
+			 scanner_cp, scanner_bp, headcnt );
+
+	    else
+		fprintf( temp_action_file,
+			 "%s -= %d;\n", scanner_cp, trailcnt );
+	
+	    fprintf( temp_action_file,
+		     "YY_DO_BEFORE_ACTION; /* set up yytext again */\n" );
+	    }
+	}
+
+    line_directive_out( temp_action_file );
+    }
+
+
+/* link_machines - connect two machines together
+ *
+ * synopsis
+ *
+ *   new = link_machines( first, last );
+ *
+ *     new    - a machine constructed by connecting first to last
+ *     first  - the machine whose successor is to be last
+ *     last   - the machine whose predecessor is to be first
+ *
+ * note: this routine concatenates the machine first with the machine
+ *  last to produce a machine new which will pattern-match first first
+ *  and then last, and will fail if either of the sub-patterns fails.
+ *  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
+ *                            as being a "normal" (i.e., not trailing context-
+ *                            associated) states
+ *
+ * synopsis
+ *
+ *   mark_beginning_as_normal( mach )
+ *
+ *     mach - machine to mark
+ *
+ * The "beginning" states are the epsilon closure of the first state
+ */
+
+void mark_beginning_as_normal( mach )
+register 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
+ *
+ * synopsis
+ *
+ *   branch = mkbranch( first, second );
+ *
+ *     branch - a machine which matches either first's pattern or second's
+ *     first, second - machines whose patterns are to be or'ed (the | operator)
+ *
+ * note that first and second are NEITHER destroyed by the operation.  Also,
+ * the resulting machine CANNOT be used with any other "mk" operation except
+ * 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
+ *
+ * synopsis
+ *   new = mkclos( state );
+ *
+ *     new - a new state which matches the closure of "state"
+ */
+
+int mkclos( state )
+int state;
+
+    {
+    return ( mkopt( mkposcl( state ) ) );
+    }
+
+
+/* mkopt - make a machine optional
+ *
+ * synopsis
+ *
+ *   new = mkopt( mach );
+ *
+ *     new  - a machine which optionally matches whatever mach matched
+ *     mach - the machine to make optional
+ *
+ * notes:
+ *     1. mach must be the last machine created
+ *     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
+ *
+ * synopsis
+ *
+ *   new = mkor( first, second );
+ *
+ *     new - a machine which matches either first's pattern or second's
+ *     first, second - machines whose patterns are to be or'ed (the | operator)
+ *
+ * note that first and second are both destroyed by the operation
+ * the code is rather convoluted because an attempt is made to minimize
+ * 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
+ *
+ * synopsis
+ *   new = mkposcl( state );
+ *
+ *    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
+ *
+ * synopsis
+ *   new = mkrep( mach, lb, ub );
+ *
+ *    new - a machine that matches whatever "mach" matched from "lb"
+ *          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
+ *
+ *   state = mkstate( sym );
+ *
+ *     state - a new state matching sym
+ *     sym   - the symbol the new state is to have an out-transition on
+ *
+ * note that this routine makes new states in ascending order through the
+ * state array (and increments LASTNFA accordingly).  The routine DUPMACHINE
+ * relies on machines being made in ascending order and that they are
+ * CONTIGUOUS.  Change it and you will have to rewrite DUPMACHINE (kludge
+ * 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;
+    lastst[lastnfa] = lastnfa;
+    transchar[lastnfa] = sym;
+    trans1[lastnfa] = NO_TRANSITION;
+    trans2[lastnfa] = NO_TRANSITION;
+    accptnum[lastnfa] = NIL;
+    assoc_rule[lastnfa] = num_rules;
+    state_type[lastnfa] = current_state_type;
+
+    /* fix up equivalence classes base on this transition.  Note that any
+     * character which has its own transition gets its own equivalence class.
+     * Thus only characters which are only in character classes have a chance
+     * at being in the same equivalence class.  E.g. "a|b" puts 'a' and 'b'
+     * into two different equivalence classes.  "[ab]" puts them in the same
+     * equivalence class (barring other differences 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
+	{
+	if ( useecs )
+	    /* map NUL's to csize */
+	    mkechar( sym ? sym : csize, nextecm, ecgroup );
+	}
+
+    return ( lastnfa );
+    }
+
+
+/* mkxtion - make a transition from one state to another
+ *
+ * synopsis
+ *
+ *   mkxtion( statefrom, stateto );
+ *
+ *     statefrom - the state from which the transition is to be made
+ *     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
+ *
+ * synopsis
+ *
+ *   new_rule();
+ *
+ * the global num_rules is incremented and the any corresponding dynamic
+ * arrays (such as rule_type[]) are grown as needed.
+ */
+
+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 );
+	}
+
+    if ( num_rules > MAX_RULE )
+	lerrif( "too many rules (> %d)!", MAX_RULE );
+
+    rule_linenum[num_rules] = linenum;
+    }

eoe/cmd/gnu/flex/parse.y

@@ -0,0 +1,702 @@
+
+/* parse.y - parser for flex input */
+
+%token CHAR NUMBER SECTEND SCDECL XSCDECL WHITESPACE NAME PREVCCL EOF_OP
+
+%{
+/*-
+ * 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/parse.y,v 1.1 1992/05/05 22:30:44 wicinski Exp $ (LBL)";
+#endif
+
+#include "flexdef.h"
+
+int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, actvp, rulelen;
+int trlcontxt, xcluflg, cclsorted, varlength, variable_trail_rule;
+Char clower();
+
+static int madeany = false;  /* whether we've made the '.' character class */
+int previous_continued_action;	/* whether the previous rule's action was '|' */
+
+%}
+
+%%
+goal            :  initlex sect1 sect1end sect2 initforrule
+			{ /* add default rule */
+			int def_rule;
+
+			pat = cclinit();
+			cclnegate( pat );
+
+			def_rule = mkstate( -pat );
+
+			finish_rule( def_rule, false, 0, 0 );
+
+			for ( i = 1; i <= lastsc; ++i )
+			    scset[i] = mkbranch( scset[i], def_rule );
+
+			if ( spprdflt )
+			    fputs( "YY_FATAL_ERROR( \"flex scanner jammed\" )",
+				   temp_action_file );
+			else
+			    fputs( "ECHO", temp_action_file );
+
+			fputs( ";\n\tYY_BREAK\n", temp_action_file );
+			}
+		;
+
+initlex         :
+			{
+			/* initialize for processing rules */
+
+			/* create default DFA start condition */
+			scinstal( "INITIAL", false );
+			}
+		;
+
+sect1		:  sect1 startconddecl WHITESPACE namelist1 '\n'
+		|
+		|  error '\n'
+			{ synerr( "unknown error processing section 1" ); }
+		;
+
+sect1end	:  SECTEND
+		;
+
+startconddecl   :  SCDECL
+			{
+			/* these productions are separate from the s1object
+			 * rule because the semantics must be done before
+			 * we parse the remainder of an s1object
+			 */
+
+			xcluflg = false;
+			}
+
+		|  XSCDECL
+			{ xcluflg = true; }
+		;
+
+namelist1	:  namelist1 WHITESPACE NAME
+			{ scinstal( nmstr, xcluflg ); }
+
+		|  NAME
+			{ scinstal( nmstr, xcluflg ); }
+
+		|  error
+                        { synerr( "bad start condition list" ); }
+		;
+
+sect2           :  sect2 initforrule flexrule '\n'
+		|
+		;
+
+initforrule     :
+			{
+			/* initialize for a parse of one rule */
+			trlcontxt = variable_trail_rule = varlength = false;
+			trailcnt = headcnt = rulelen = 0;
+			current_state_type = STATE_NORMAL;
+			previous_continued_action = continued_action;
+			new_rule();
+			}
+		;
+
+flexrule        :  scon '^' rule
+                        {
+			pat = $3;
+			finish_rule( pat, variable_trail_rule,
+				     headcnt, trailcnt );
+
+			for ( i = 1; i <= actvp; ++i )
+			    scbol[actvsc[i]] =
+				mkbranch( scbol[actvsc[i]], pat );
+
+			if ( ! bol_needed )
+			    {
+			    bol_needed = true;
+
+			    if ( performance_report )
+				pinpoint_message( 
+			    "'^' operator results in sub-optimal performance" );
+			    }
+			}
+
+		|  scon rule
+                        {
+			pat = $2;
+			finish_rule( pat, variable_trail_rule,
+				     headcnt, trailcnt );
+
+			for ( i = 1; i <= actvp; ++i )
+			    scset[actvsc[i]] =
+				mkbranch( scset[actvsc[i]], pat );
+			}
+
+                |  '^' rule
+			{
+			pat = $2;
+			finish_rule( pat, variable_trail_rule,
+				     headcnt, trailcnt );
+
+			/* add to all non-exclusive start conditions,
+			 * including the default (0) start condition
+			 */
+
+			for ( i = 1; i <= lastsc; ++i )
+			    if ( ! scxclu[i] )
+				scbol[i] = mkbranch( scbol[i], pat );
+
+			if ( ! bol_needed )
+			    {
+			    bol_needed = true;
+
+			    if ( performance_report )
+				pinpoint_message(
+			    "'^' operator results in sub-optimal performance" );
+			    }
+			}
+
+                |  rule
+			{
+			pat = $1;
+			finish_rule( pat, variable_trail_rule,
+				     headcnt, trailcnt );
+
+			for ( i = 1; i <= lastsc; ++i )
+			    if ( ! scxclu[i] )
+				scset[i] = mkbranch( scset[i], pat );
+			}
+
+                |  scon EOF_OP
+			{ build_eof_action(); }
+
+                |  EOF_OP
+			{
+			/* this EOF applies to all start conditions
+			 * which don't already have EOF actions
+			 */
+			actvp = 0;
+
+			for ( i = 1; i <= lastsc; ++i )
+			    if ( ! sceof[i] )
+				actvsc[++actvp] = i;
+
+			if ( actvp == 0 )
+			    pinpoint_message(
+		"warning - all start conditions already have <<EOF>> rules" );
+
+			else
+			    build_eof_action();
+			}
+
+                |  error
+			{ synerr( "unrecognized rule" ); }
+		;
+
+scon            :  '<' namelist2 '>'
+		;
+
+namelist2       :  namelist2 ',' NAME
+                        {
+			if ( (scnum = sclookup( nmstr )) == 0 )
+			    format_pinpoint_message(
+				"undeclared start condition %s", nmstr );
+
+			else
+			    actvsc[++actvp] = scnum;
+			}
+
+		|  NAME
+			{
+			if ( (scnum = sclookup( nmstr )) == 0 )
+			    format_pinpoint_message(
+				"undeclared start condition %s", nmstr );
+			else
+			    actvsc[actvp = 1] = scnum;
+			}
+
+		|  error
+			{ synerr( "bad start condition list" ); }
+		;
+
+rule            :  re2 re
+			{
+			if ( transchar[lastst[$2]] != SYM_EPSILON )
+			    /* provide final transition \now/ so it
+			     * will be marked as a trailing context
+			     * state
+			     */
+			    $2 = link_machines( $2, mkstate( SYM_EPSILON ) );
+
+			mark_beginning_as_normal( $2 );
+			current_state_type = STATE_NORMAL;
+
+			if ( previous_continued_action )
+			    {
+			    /* we need to treat this as variable trailing
+			     * context so that the backup does not happen
+			     * in the action but before the action switch
+			     * statement.  If the backup happens in the
+			     * action, then the rules "falling into" this
+			     * one's action will *also* do the backup,
+			     * erroneously.
+			     */
+			    if ( ! varlength || headcnt != 0 )
+				{
+				fprintf( stderr,
+    "%s: warning - trailing context rule at line %d made variable because\n",
+					 program_name, linenum );
+				fprintf( stderr,
+					 "      of preceding '|' action\n" );
+				}
+
+			    /* mark as variable */
+			    varlength = true;
+			    headcnt = 0;
+			    }
+
+			if ( varlength && headcnt == 0 )
+			    { /* variable trailing context rule */
+			    /* mark the first part of the rule as the accepting
+			     * "head" part of a trailing context rule
+			     */
+			    /* by the way, we didn't do this at the beginning
+			     * of this production because back then
+			     * current_state_type was set up for a trail
+			     * rule, and add_accept() can create a new
+			     * state ...
+			     */
+			    add_accept( $1, num_rules | YY_TRAILING_HEAD_MASK );
+			    variable_trail_rule = true;
+			    }
+			
+			else
+			    trailcnt = rulelen;
+
+			$$ = link_machines( $1, $2 );
+			}
+
+		|  re2 re '$'
+			{ synerr( "trailing context used twice" ); }
+
+		|  re '$'
+                        {
+			if ( trlcontxt )
+			    {
+			    synerr( "trailing context used twice" );
+			    $$ = mkstate( SYM_EPSILON );
+			    }
+
+			else if ( previous_continued_action )
+			    {
+			    /* see the comment in the rule for "re2 re"
+			     * above
+			     */
+			    if ( ! varlength || headcnt != 0 )
+				{
+				fprintf( stderr,
+    "%s: warning - trailing context rule at line %d made variable because\n",
+					 program_name, linenum );
+				fprintf( stderr,
+					 "      of preceding '|' action\n" );
+				}
+
+			    /* mark as variable */
+			    varlength = true;
+			    headcnt = 0;
+			    }
+
+			trlcontxt = true;
+
+			if ( ! varlength )
+			    headcnt = rulelen;
+
+			++rulelen;
+			trailcnt = 1;
+
+			eps = mkstate( SYM_EPSILON );
+			$$ = link_machines( $1,
+				 link_machines( eps, mkstate( '\n' ) ) );
+			}
+
+		|  re
+			{
+		        $$ = $1;
+
+			if ( trlcontxt )
+			    {
+			    if ( varlength && headcnt == 0 )
+				/* both head and trail are variable-length */
+				variable_trail_rule = true;
+			    else
+				trailcnt = rulelen;
+			    }
+		        }
+		;
+
+
+re              :  re '|' series
+                        {
+			varlength = true;
+			$$ = mkor( $1, $3 );
+			}
+
+		|  series
+			{ $$ = $1; }
+		;
+
+
+re2		:  re '/'
+			{
+			/* this rule is written separately so
+			 * the reduction will occur before the trailing
+			 * series is parsed
+			 */
+
+			if ( trlcontxt )
+			    synerr( "trailing context used twice" );
+			else
+			    trlcontxt = true;
+
+			if ( varlength )
+			    /* we hope the trailing context is fixed-length */
+			    varlength = false;
+			else
+			    headcnt = rulelen;
+
+			rulelen = 0;
+
+			current_state_type = STATE_TRAILING_CONTEXT;
+			$$ = $1;
+			}
+		;
+
+series          :  series singleton
+                        {
+			/* this is where concatenation of adjacent patterns
+			 * gets done
+			 */
+			$$ = link_machines( $1, $2 );
+			}
+
+		|  singleton
+			{ $$ = $1; }
+		;
+
+singleton       :  singleton '*'
+                        {
+			varlength = true;
+
+			$$ = mkclos( $1 );
+			}
+
+		|  singleton '+'
+			{
+			varlength = true;
+
+			$$ = mkposcl( $1 );
+			}
+
+		|  singleton '?'
+			{
+			varlength = true;
+
+			$$ = mkopt( $1 );
+			}
+
+		|  singleton '{' NUMBER ',' NUMBER '}'
+			{
+			varlength = true;
+
+			if ( $3 > $5 || $3 < 0 )
+			    {
+			    synerr( "bad iteration values" );
+			    $$ = $1;
+			    }
+			else
+			    {
+			    if ( $3 == 0 )
+				$$ = mkopt( mkrep( $1, $3, $5 ) );
+			    else
+				$$ = mkrep( $1, $3, $5 );
+			    }
+			}
+
+		|  singleton '{' NUMBER ',' '}'
+			{
+			varlength = true;
+
+			if ( $3 <= 0 )
+			    {
+			    synerr( "iteration value must be positive" );
+			    $$ = $1;
+			    }
+
+			else
+			    $$ = mkrep( $1, $3, INFINITY );
+			}
+
+		|  singleton '{' NUMBER '}'
+			{
+			/* the singleton could be something like "(foo)",
+			 * in which case we have no idea what its length
+			 * is, so we punt here.
+			 */
+			varlength = true;
+
+			if ( $3 <= 0 )
+			    {
+			    synerr( "iteration value must be positive" );
+			    $$ = $1;
+			    }
+
+			else
+			    $$ = link_machines( $1, copysingl( $1, $3 - 1 ) );
+			}
+
+		|  '.'
+			{
+			if ( ! madeany )
+			    {
+			    /* create the '.' character class */
+			    anyccl = cclinit();
+			    ccladd( anyccl, '\n' );
+			    cclnegate( anyccl );
+
+			    if ( useecs )
+				mkeccl( ccltbl + cclmap[anyccl],
+					ccllen[anyccl], nextecm,
+					ecgroup, csize, csize );
+
+			    madeany = true;
+			    }
+
+			++rulelen;
+
+			$$ = mkstate( -anyccl );
+			}
+
+		|  fullccl
+			{
+			if ( ! cclsorted )
+			    /* sort characters for fast searching.  We use a
+			     * shell sort since this list could be large.
+			     */
+			    cshell( ccltbl + cclmap[$1], ccllen[$1], true );
+
+			if ( useecs )
+			    mkeccl( ccltbl + cclmap[$1], ccllen[$1],
+				    nextecm, ecgroup, csize, csize );
+
+			++rulelen;
+
+			$$ = mkstate( -$1 );
+			}
+
+		|  PREVCCL
+			{
+			++rulelen;
+
+			$$ = mkstate( -$1 );
+			}
+
+		|  '"' string '"'
+			{ $$ = $2; }
+
+		|  '(' re ')'
+			{ $$ = $2; }
+
+		|  CHAR
+			{
+			++rulelen;
+
+			if ( caseins && $1 >= 'A' && $1 <= 'Z' )
+			    $1 = clower( $1 );
+
+			$$ = mkstate( $1 );
+			}
+		;
+
+fullccl		:  '[' ccl ']'
+			{ $$ = $2; }
+
+		|  '[' '^' ccl ']'
+			{
+			/* *Sigh* - to be compatible Unix lex, negated ccls
+			 * match newlines
+			 */
+#ifdef NOTDEF
+			ccladd( $3, '\n' ); /* negated ccls don't match '\n' */
+			cclsorted = false; /* because we added the newline */
+#endif
+			cclnegate( $3 );
+			$$ = $3;
+			}
+		;
+
+ccl             :  ccl CHAR '-' CHAR
+                        {
+			if ( $2 > $4 )
+			    synerr( "negative range in character class" );
+
+			else
+			    {
+			    if ( caseins )
+				{
+				if ( $2 >= 'A' && $2 <= 'Z' )
+				    $2 = clower( $2 );
+				if ( $4 >= 'A' && $4 <= 'Z' )
+				    $4 = clower( $4 );
+				}
+
+			    for ( i = $2; i <= $4; ++i )
+			        ccladd( $1, i );
+
+			    /* keep track if this ccl is staying in alphabetical
+			     * order
+			     */
+			    cclsorted = cclsorted && ($2 > lastchar);
+			    lastchar = $4;
+			    }
+
+			$$ = $1;
+			}
+
+		|  ccl CHAR
+		        {
+			if ( caseins )
+			    if ( $2 >= 'A' && $2 <= 'Z' )
+				$2 = clower( $2 );
+
+			ccladd( $1, $2 );
+			cclsorted = cclsorted && ($2 > lastchar);
+			lastchar = $2;
+			$$ = $1;
+			}
+
+		|
+			{
+			cclsorted = true;
+			lastchar = 0;
+			$$ = cclinit();
+			}
+		;
+
+string		:  string CHAR
+                        {
+			if ( caseins )
+			    if ( $2 >= 'A' && $2 <= 'Z' )
+				$2 = clower( $2 );
+
+			++rulelen;
+
+			$$ = link_machines( $1, mkstate( $2 ) );
+			}
+
+		|
+			{ $$ = mkstate( SYM_EPSILON ); }
+		;
+
+%%
+
+
+/* build_eof_action - build the "<<EOF>>" action for the active start
+ *                    conditions
+ */
+
+void build_eof_action()
+
+    {
+    register int i;
+
+    for ( i = 1; i <= actvp; ++i )
+	{
+	if ( sceof[actvsc[i]] )
+	    format_pinpoint_message(
+		"multiple <<EOF>> rules for start condition %s",
+		    scname[actvsc[i]] );
+
+	else
+	    {
+	    sceof[actvsc[i]] = true;
+	    fprintf( temp_action_file, "case YY_STATE_EOF(%s):\n",
+		     scname[actvsc[i]] );
+	    }
+	}
+
+    line_directive_out( temp_action_file );
+    }
+
+
+/* synerr - report a syntax error */
+
+void synerr( str )
+char str[];
+
+    {
+    syntaxerror = true;
+    pinpoint_message( str );
+    }
+
+
+/* format_pinpoint_message - write out a message formatted with one string,
+ *			     pinpointing its location
+ */
+
+void format_pinpoint_message( msg, arg )
+char msg[], arg[];
+
+    {
+    char errmsg[MAXLINE];
+
+    (void) sprintf( errmsg, msg, arg );
+    pinpoint_message( errmsg );
+    }
+
+
+/* pinpoint_message - write out a message, pinpointing its location */
+
+void pinpoint_message( str )
+char str[];
+
+    {
+    fprintf( stderr, "\"%s\", line %d: %s\n", infilename, linenum, str );
+    }
+
+
+/* yyerror - eat up an error message from the parser;
+ *	     currently, messages are ignore
+ */
+
+void yyerror( msg )
+char msg[];
+
+    {
+    }

eoe/cmd/gnu/flex/scan.l

@@ -0,0 +1,533 @@
+
+/* scan.l - scanner for flex input */
+
+%{
+/*-
+ * 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/scan.l,v 1.1 1992/05/05 22:30:48 wicinski Exp $ (LBL)";
+#endif
+
+#undef yywrap
+
+#include "flexdef.h"
+#include "parse.h"
+
+#define ACTION_ECHO fprintf( temp_action_file, "%s", yytext )
+#define MARK_END_OF_PROLOG fprintf( temp_action_file, "%%%% end of prolog\n" );
+
+#undef YY_DECL
+#define YY_DECL \
+	int flexscan()
+
+#define RETURNCHAR \
+	yylval = yytext[0]; \
+	return ( CHAR );
+
+#define RETURNNAME \
+	(void) strcpy( nmstr, (char *) yytext ); \
+	return ( NAME );
+
+#define PUT_BACK_STRING(str, start) \
+	for ( i = strlen( (char *) (str) ) - 1; i >= start; --i ) \
+	    unput((str)[i])
+
+#define CHECK_REJECT(str) \
+	if ( all_upper( str ) ) \
+	    reject = true;
+
+#define CHECK_YYMORE(str) \
+	if ( all_lower( str ) ) \
+	    yymore_used = true;
+%}
+
+%x SECT2 SECT2PROLOG SECT3 CODEBLOCK PICKUPDEF SC CARETISBOL NUM QUOTE
+%x FIRSTCCL CCL ACTION RECOVER BRACEERROR C_COMMENT ACTION_COMMENT
+%x ACTION_STRING PERCENT_BRACE_ACTION USED_LIST CODEBLOCK_2 XLATION
+
+WS		[ \t\f]+
+OPTWS		[ \t\f]*
+NOT_WS		[^ \t\f\n]
+
+NAME		[a-z_][a-z_0-9-]*
+NOT_NAME	[^a-z_\n]+
+
+SCNAME		{NAME}
+
+ESCSEQ		\\([^\n]|[0-9]{1,3}|x[0-9a-f]{1,2})
+
+%%
+    static int bracelevel, didadef;
+    int i, indented_code, checking_used, new_xlation;
+    int doing_codeblock = false;
+    Char nmdef[MAXLINE], myesc();
+
+^{WS}			indented_code = true; BEGIN(CODEBLOCK);
+^#.*\n			++linenum; /* treat as a comment */
+^"/*"			ECHO; BEGIN(C_COMMENT);
+^"%s"{NAME}?		return ( SCDECL );
+^"%x"{NAME}?		return ( XSCDECL );
+^"%{".*\n		{
+			++linenum;
+			line_directive_out( stdout );
+			indented_code = false;
+			BEGIN(CODEBLOCK);
+			}
+
+{WS}			return ( WHITESPACE );
+
+^"%%".*			{
+			sectnum = 2;
+			line_directive_out( stdout );
+			BEGIN(SECT2PROLOG);
+			return ( SECTEND );
+			}
+
+^"%used"		{
+	pinpoint_message( "warning - %%used/%%unused have been deprecated" );
+			checking_used = REALLY_USED; BEGIN(USED_LIST);
+			}
+^"%unused"		{
+			checking_used = REALLY_NOT_USED; BEGIN(USED_LIST);
+	pinpoint_message( "warning - %%used/%%unused have been deprecated" );
+			checking_used = REALLY_NOT_USED; BEGIN(USED_LIST);
+			}
+
+
+^"%"[aeknopt]" ".*\n	{
+#ifdef NOTDEF
+			fprintf( stderr,
+			     "old-style lex command at line %d ignored:\n\t%s",
+				 linenum, yytext );
+#endif
+			++linenum;
+			}
+
+^"%"[cr]{OPTWS}		/* ignore old lex directive */
+
+%t{OPTWS}\n		{
+			++linenum;
+			xlation =
+			    (int *) malloc( sizeof( int ) * (unsigned) csize );
+
+			if ( ! xlation )
+			    flexfatal(
+				"dynamic memory failure building %t table" );
+
+			for ( i = 0; i < csize; ++i )
+			    xlation[i] = 0;
+
+			num_xlations = 0;
+
+			BEGIN(XLATION);
+			}
+
+^"%"[^sxanpekotcru{}]{OPTWS}	synerr( "unrecognized '%' directive" );
+
+^{NAME}			{
+			(void) strcpy( nmstr, (char *) yytext );
+			didadef = false;
+			BEGIN(PICKUPDEF);
+			}
+
+{SCNAME}		RETURNNAME;
+^{OPTWS}\n		++linenum; /* allows blank lines in section 1 */
+{OPTWS}\n		++linenum; return ( '\n' );
+.			synerr( "illegal character" ); BEGIN(RECOVER);
+
+
+<C_COMMENT>"*/"		ECHO; BEGIN(INITIAL);
+<C_COMMENT>"*/".*\n	++linenum; ECHO; BEGIN(INITIAL);
+<C_COMMENT>[^*\n]+	ECHO;
+<C_COMMENT>"*"		ECHO;
+<C_COMMENT>\n		++linenum; ECHO;
+
+
+<CODEBLOCK>^"%}".*\n	++linenum; BEGIN(INITIAL);
+<CODEBLOCK>"reject"	ECHO; CHECK_REJECT(yytext);
+<CODEBLOCK>"yymore"	ECHO; CHECK_YYMORE(yytext);
+<CODEBLOCK>{NAME}|{NOT_NAME}|.	ECHO;
+<CODEBLOCK>\n		{
+			++linenum;
+			ECHO;
+			if ( indented_code )
+			    BEGIN(INITIAL);
+			}
+
+
+<PICKUPDEF>{WS}		/* separates name and definition */
+
+<PICKUPDEF>{NOT_WS}.*	{
+			(void) strcpy( (char *) nmdef, (char *) yytext );
+
+			for ( i = strlen( (char *) nmdef ) - 1;
+			      i >= 0 &&
+			      nmdef[i] == ' ' || nmdef[i] == '\t';
+			      --i )
+			    ;
+
+			nmdef[i + 1] = '\0';
+
+                        ndinstal( nmstr, nmdef );
+			didadef = true;
+			}
+
+<PICKUPDEF>\n		{
+			if ( ! didadef )
+			    synerr( "incomplete name definition" );
+			BEGIN(INITIAL);
+			++linenum;
+			}
+
+<RECOVER>.*\n		++linenum; BEGIN(INITIAL); RETURNNAME;
+
+
+<USED_LIST>\n		++linenum; BEGIN(INITIAL);
+<USED_LIST>{WS}
+<USED_LIST>"reject"	{
+			if ( all_upper( yytext ) )
+			    reject_really_used = checking_used;
+			else
+			    synerr( "unrecognized %used/%unused construct" );
+			}
+<USED_LIST>"yymore"	{
+			if ( all_lower( yytext ) )
+			    yymore_really_used = checking_used;
+			else
+			    synerr( "unrecognized %used/%unused construct" );
+			}
+<USED_LIST>{NOT_WS}+	synerr( "unrecognized %used/%unused construct" );
+
+
+<XLATION>"%t"{OPTWS}\n	++linenum; BEGIN(INITIAL);
+<XLATION>^{OPTWS}[0-9]+	++num_xlations; new_xlation = true;
+<XLATION>^.		synerr( "bad row in translation table" );
+<XLATION>{WS}		/* ignore whitespace */
+
+<XLATION>{ESCSEQ}	{
+			xlation[myesc( yytext )] =
+				(new_xlation ? num_xlations : -num_xlations);
+			new_xlation = false;
+			}
+<XLATION>.		{
+			xlation[yytext[0]] =
+				(new_xlation ? num_xlations : -num_xlations);
+			new_xlation = false;
+			}
+
+<XLATION>\n		++linenum;
+
+
+<SECT2PROLOG>.*\n/{NOT_WS}	{
+			++linenum;
+			ACTION_ECHO;
+			MARK_END_OF_PROLOG;
+			BEGIN(SECT2);
+			}
+
+<SECT2PROLOG>.*\n	++linenum; ACTION_ECHO;
+
+<SECT2PROLOG><<EOF>>	MARK_END_OF_PROLOG; yyterminate();
+
+<SECT2>^{OPTWS}\n	++linenum; /* allow blank lines in section 2 */
+
+<SECT2>^({WS}|"%{")	{
+			indented_code = (yytext[0] != '%');
+			doing_codeblock = true;
+			bracelevel = 1;
+
+			if ( indented_code )
+			    ACTION_ECHO;
+
+			BEGIN(CODEBLOCK_2);
+			}
+
+<SECT2>"<"		BEGIN(SC); return ( '<' );
+<SECT2>^"^"		return ( '^' );
+<SECT2>\"		BEGIN(QUOTE); return ( '"' );
+<SECT2>"{"/[0-9]		BEGIN(NUM); return ( '{' );
+<SECT2>"{"[^0-9\n][^}\n]*	BEGIN(BRACEERROR);
+<SECT2>"$"/[ \t\n]	return ( '$' );
+
+<SECT2>{WS}"%{"		{
+			bracelevel = 1;
+			BEGIN(PERCENT_BRACE_ACTION);
+			return ( '\n' );
+			}
+<SECT2>{WS}"|".*\n	continued_action = true; ++linenum; return ( '\n' );
+
+<SECT2>{WS}		{
+			/* this rule is separate from the one below because
+			 * otherwise we get variable trailing context, so
+			 * we can't build the scanner using -{f,F}
+			 */
+			bracelevel = 0;
+			continued_action = false;
+			BEGIN(ACTION);
+			return ( '\n' );
+			}
+
+<SECT2>{OPTWS}/\n	{
+			bracelevel = 0;
+			continued_action = false;
+			BEGIN(ACTION);
+			return ( '\n' );
+			}
+
+<SECT2>^{OPTWS}\n	++linenum; return ( '\n' );
+
+<SECT2>"<<EOF>>"	return ( EOF_OP );
+
+<SECT2>^"%%".*		{
+			sectnum = 3;
+			BEGIN(SECT3);
+			return ( EOF ); /* to stop the parser */
+			}
+
+<SECT2>"["([^\\\]\n]|{ESCSEQ})+"]"	{
+			int cclval;
+
+			(void) strcpy( nmstr, (char *) yytext );
+
+			/* check to see if we've already encountered this ccl */
+			if ( (cclval = ccllookup( (Char *) nmstr )) )
+			    {
+			    yylval = cclval;
+			    ++cclreuse;
+			    return ( PREVCCL );
+			    }
+			else
+			    {
+			    /* we fudge a bit.  We know that this ccl will
+			     * soon be numbered as lastccl + 1 by cclinit
+			     */
+			    cclinstal( (Char *) nmstr, lastccl + 1 );
+
+			    /* push back everything but the leading bracket
+			     * so the ccl can be rescanned
+			     */
+			    PUT_BACK_STRING((Char *) nmstr, 1);
+
+			    BEGIN(FIRSTCCL);
+			    return ( '[' );
+			    }
+			}
+
+<SECT2>"{"{NAME}"}"	{
+			register Char *nmdefptr;
+			Char *ndlookup();
+
+			(void) strcpy( nmstr, (char *) yytext );
+			nmstr[yyleng - 1] = '\0';  /* chop trailing brace */
+
+			/* lookup from "nmstr + 1" to chop leading brace */
+			if ( ! (nmdefptr = ndlookup( nmstr + 1 )) )
+			    synerr( "undefined {name}" );
+
+			else
+			    { /* push back name surrounded by ()'s */
+			    unput(')');
+			    PUT_BACK_STRING(nmdefptr, 0);
+			    unput('(');
+			    }
+			}
+
+<SECT2>[/|*+?.()]	return ( yytext[0] );
+<SECT2>.		RETURNCHAR;
+<SECT2>\n		++linenum; return ( '\n' );
+
+
+<SC>","			return ( ',' );
+<SC>">"			BEGIN(SECT2); return ( '>' );
+<SC>">"/"^"		BEGIN(CARETISBOL); return ( '>' );
+<SC>{SCNAME}		RETURNNAME;
+<SC>.			synerr( "bad start condition name" );
+
+<CARETISBOL>"^"		BEGIN(SECT2); return ( '^' );
+
+
+<QUOTE>[^"\n]		RETURNCHAR;
+<QUOTE>\"		BEGIN(SECT2); return ( '"' );
+
+<QUOTE>\n		{
+			synerr( "missing quote" );
+			BEGIN(SECT2);
+			++linenum;
+			return ( '"' );
+			}
+
+
+<FIRSTCCL>"^"/[^-\n]	BEGIN(CCL); return ( '^' );
+<FIRSTCCL>"^"/-		return ( '^' );
+<FIRSTCCL>-		BEGIN(CCL); yylval = '-'; return ( CHAR );
+<FIRSTCCL>.		BEGIN(CCL); RETURNCHAR;
+
+<CCL>-/[^\]\n]		return ( '-' );
+<CCL>[^\]\n]		RETURNCHAR;
+<CCL>"]"		BEGIN(SECT2); return ( ']' );
+
+
+<NUM>[0-9]+		{
+			yylval = myctoi( yytext );
+			return ( NUMBER );
+			}
+
+<NUM>","			return ( ',' );
+<NUM>"}"			BEGIN(SECT2); return ( '}' );
+
+<NUM>.			{
+			synerr( "bad character inside {}'s" );
+			BEGIN(SECT2);
+			return ( '}' );
+			}
+
+<NUM>\n			{
+			synerr( "missing }" );
+			BEGIN(SECT2);
+			++linenum;
+			return ( '}' );
+			}
+
+
+<BRACEERROR>"}"		synerr( "bad name in {}'s" ); BEGIN(SECT2);
+<BRACEERROR>\n		synerr( "missing }" ); ++linenum; BEGIN(SECT2);
+
+
+<PERCENT_BRACE_ACTION,CODEBLOCK_2>{OPTWS}"%}".*		bracelevel = 0;
+<PERCENT_BRACE_ACTION,CODEBLOCK_2,ACTION>"reject"	{
+			ACTION_ECHO;
+			CHECK_REJECT(yytext);
+			}
+<PERCENT_BRACE_ACTION,CODEBLOCK_2,ACTION>"yymore"	{
+			ACTION_ECHO;
+			CHECK_YYMORE(yytext);
+			}
+<PERCENT_BRACE_ACTION,CODEBLOCK_2>{NAME}|{NOT_NAME}|.	ACTION_ECHO;
+<PERCENT_BRACE_ACTION,CODEBLOCK_2>\n			{
+			++linenum;
+			ACTION_ECHO;
+			if ( bracelevel == 0 ||
+			     (doing_codeblock && indented_code) )
+			    {
+			    if ( ! doing_codeblock )
+				fputs( "\tYY_BREAK\n", temp_action_file );
+			    
+			    doing_codeblock = false;
+			    BEGIN(SECT2);
+			    }
+			}
+
+
+	/* Reject and YYmore() are checked for above, in PERCENT_BRACE_ACTION */
+<ACTION>"{"		ACTION_ECHO; ++bracelevel;
+<ACTION>"}"		ACTION_ECHO; --bracelevel;
+<ACTION>[^a-z_{}"'/\n]+	ACTION_ECHO;
+<ACTION>{NAME}		ACTION_ECHO;
+<ACTION>"/*"		ACTION_ECHO; BEGIN(ACTION_COMMENT);
+<ACTION>"'"([^'\\\n]|\\.)*"'"	ACTION_ECHO; /* character constant */
+<ACTION>\"		ACTION_ECHO; BEGIN(ACTION_STRING);
+<ACTION>\n		{
+			++linenum;
+			ACTION_ECHO;
+			if ( bracelevel == 0 )
+			    {
+			    fputs( "\tYY_BREAK\n", temp_action_file );
+			    BEGIN(SECT2);
+			    }
+			}
+<ACTION>.		ACTION_ECHO;
+
+<ACTION_COMMENT>"*/"	ACTION_ECHO; BEGIN(ACTION);
+<ACTION_COMMENT>[^*\n]+	ACTION_ECHO;
+<ACTION_COMMENT>"*"	ACTION_ECHO;
+<ACTION_COMMENT>\n	++linenum; ACTION_ECHO;
+<ACTION_COMMENT>.	ACTION_ECHO;
+
+<ACTION_STRING>[^"\\\n]+	ACTION_ECHO;
+<ACTION_STRING>\\.	ACTION_ECHO;
+<ACTION_STRING>\n	++linenum; ACTION_ECHO;
+<ACTION_STRING>\"	ACTION_ECHO; BEGIN(ACTION);
+<ACTION_STRING>.	ACTION_ECHO;
+
+<ACTION,ACTION_COMMENT,ACTION_STRING><<EOF>>	{
+			synerr( "EOF encountered inside an action" );
+			yyterminate();
+			}
+
+
+<SECT2,QUOTE,CCL>{ESCSEQ}	{
+			yylval = myesc( yytext );
+			return ( CHAR );
+			}
+
+<FIRSTCCL>{ESCSEQ}	{
+			yylval = myesc( yytext );
+			BEGIN(CCL);
+			return ( CHAR );
+			}
+
+
+<SECT3>.*(\n?)		ECHO;
+%%
+
+
+int yywrap()
+
+    {
+    if ( --num_input_files > 0 )
+	{
+	set_input_file( *++input_files );
+	return ( 0 );
+	}
+
+    else
+	return ( 1 );
+    }
+
+
+/* set_input_file - open the given file (if NULL, stdin) for scanning */
+
+void set_input_file( file )
+char *file;
+
+    {
+    if ( file )
+	{
+	infilename = file;
+	yyin = fopen( infilename, "r" );
+
+	if ( yyin == NULL )
+	    lerrsf( "can't open %s", file );
+	}
+
+    else
+	{
+	yyin = stdin;
+	infilename = "<stdin>";
+	}
+    }

eoe/cmd/gnu/flex/sym.c

@@ -0,0 +1,315 @@
+/* sym - symbol table 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/sym.c,v 1.1 1992/05/05 22:30:51 wicinski Exp $ (LBL)";
+#endif
+
+#include "flexdef.h"
+
+
+/* declare functions that have forward references */
+
+int hashfunct PROTO((register char[], int));
+
+
+struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
+struct hash_entry *sctbl[START_COND_HASH_SIZE];
+struct hash_entry *ccltab[CCL_HASH_SIZE];
+
+struct hash_entry *findsym();
+
+
+/* addsym - add symbol and definitions to symbol table
+ *
+ * synopsis
+ *    char sym[], *str_def;
+ *    int int_def;
+ *    hash_table table;
+ *    int table_size;
+ *    0 / -1 = addsym( sym, def, int_def, table, table_size );
+ *
+ * -1 is returned if the symbol already exists, and the change not made.
+ */
+
+int addsym( sym, str_def, int_def, table, table_size )
+register char sym[];
+char *str_def;
+int int_def;
+hash_table table;
+int table_size;
+
+    {
+    int hash_val = hashfunct( sym, table_size );
+    register struct hash_entry *sym_entry = table[hash_val];
+    register struct hash_entry *new_entry;
+    register struct hash_entry *successor;
+
+    while ( sym_entry )
+	{
+	if ( ! strcmp( sym, sym_entry->name ) )
+	    { /* entry already exists */
+	    return ( -1 );
+	    }
+	
+	sym_entry = sym_entry->next;
+	}
+
+    /* create new entry */
+    new_entry = (struct hash_entry *) malloc( sizeof( struct hash_entry ) );
+
+    if ( new_entry == NULL )
+	flexfatal( "symbol table memory allocation failed" );
+
+    if ( (successor = table[hash_val]) )
+	{
+	new_entry->next = successor;
+	successor->prev = new_entry;
+	}
+    else
+	new_entry->next = NULL;
+
+    new_entry->prev = NULL;
+    new_entry->name = sym;
+    new_entry->str_val = str_def;
+    new_entry->int_val = int_def;
+
+    table[hash_val] = new_entry;
+
+    return ( 0 );
+    }
+
+
+/* cclinstal - save the text of a character class
+ *
+ * synopsis
+ *    Char ccltxt[];
+ *    int cclnum;
+ *    cclinstal( ccltxt, cclnum );
+ */
+
+void cclinstal( ccltxt, cclnum )
+Char ccltxt[];
+int cclnum;
+
+    {
+    /* we don't bother checking the return status because we are not called
+     * unless the symbol is new
+     */
+    Char *copy_unsigned_string();
+
+    (void) addsym( (char *) copy_unsigned_string( ccltxt ), (char *) 0, cclnum,
+		   ccltab, CCL_HASH_SIZE );
+    }
+
+
+/* ccllookup - lookup the number associated with character class text
+ *
+ * synopsis
+ *    Char ccltxt[];
+ *    int ccllookup, cclval;
+ *    cclval/0 = ccllookup( ccltxt );
+ */
+
+int ccllookup( ccltxt )
+Char ccltxt[];
+
+    {
+    return ( findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val );
+    }
+
+
+/* findsym - find symbol in symbol table
+ *
+ * synopsis
+ *    char sym[];
+ *    hash_table table;
+ *    int table_size;
+ *    struct hash_entry *sym_entry, *findsym();
+ *    sym_entry = findsym( sym, table, table_size );
+ */
+
+struct hash_entry *findsym( sym, table, table_size )
+register char sym[];
+hash_table table;
+int table_size;
+
+    {
+    register struct hash_entry *sym_entry = table[hashfunct( sym, table_size )];
+    static struct hash_entry empty_entry =
+	{
+	(struct hash_entry *) 0, (struct hash_entry *) 0, NULL, NULL, 0,
+	} ;
+
+    while ( sym_entry )
+	{
+	if ( ! strcmp( sym, sym_entry->name ) )
+	    return ( sym_entry );
+	sym_entry = sym_entry->next;
+	}
+
+    return ( &empty_entry );
+    }
+
+    
+/* hashfunct - compute the hash value for "str" and hash size "hash_size"
+ *
+ * synopsis
+ *    char str[];
+ *    int hash_size, hash_val;
+ *    hash_val = hashfunct( str, hash_size );
+ */
+
+int hashfunct( str, hash_size )
+register char str[];
+int hash_size;
+
+    {
+    register int hashval;
+    register int locstr;
+
+    hashval = 0;
+    locstr = 0;
+
+    while ( str[locstr] )
+	hashval = ((hashval << 1) + str[locstr++]) % hash_size;
+
+    return ( hashval );
+    }
+
+
+/* ndinstal - install a name definition
+ *
+ * synopsis
+ *    char nd[];
+ *    Char def[];
+ *    ndinstal( nd, def );
+ */
+
+void ndinstal( nd, def )
+char nd[];
+Char def[];
+
+    {
+    char *copy_string();
+    Char *copy_unsigned_string();
+
+    if ( addsym( copy_string( nd ), (char *) copy_unsigned_string( def ), 0,
+		 ndtbl, NAME_TABLE_HASH_SIZE ) )
+	synerr( "name defined twice" );
+    }
+
+
+/* ndlookup - lookup a name definition
+ *
+ * synopsis
+ *    char nd[], *def;
+ *    char *ndlookup();
+ *    def/NULL = ndlookup( nd );
+ */
+
+Char *ndlookup( nd )
+char nd[];
+
+    {
+    return ( (Char *) findsym( nd, ndtbl, NAME_TABLE_HASH_SIZE )->str_val );
+    }
+
+
+/* scinstal - make a start condition
+ *
+ * synopsis
+ *    char str[];
+ *    int xcluflg;
+ *    scinstal( str, xcluflg );
+ *
+ * NOTE
+ *    the start condition is Exclusive if xcluflg is true
+ */
+
+void scinstal( str, xcluflg )
+char str[];
+int xcluflg;
+
+    {
+    char *copy_string();
+
+    /* bit of a hack.  We know how the default start-condition is
+     * declared, and don't put out a define for it, because it
+     * would come out as "#define 0 1"
+     */
+    /* actually, this is no longer the case.  The default start-condition
+     * is now called "INITIAL".  But we keep the following for the sake
+     * of future robustness.
+     */
+
+    if ( strcmp( str, "0" ) )
+	printf( "#define %s %d\n", str, lastsc );
+
+    if ( ++lastsc >= current_max_scs )
+	{
+	current_max_scs += MAX_SCS_INCREMENT;
+
+	++num_reallocs;
+
+	scset = reallocate_integer_array( scset, current_max_scs );
+	scbol = reallocate_integer_array( scbol, current_max_scs );
+	scxclu = reallocate_integer_array( scxclu, current_max_scs );
+	sceof = reallocate_integer_array( sceof, current_max_scs );
+	scname = reallocate_char_ptr_array( scname, current_max_scs );
+	actvsc = reallocate_integer_array( actvsc, current_max_scs );
+	}
+
+    scname[lastsc] = copy_string( str );
+
+    if ( addsym( scname[lastsc], (char *) 0, lastsc,
+		 sctbl, START_COND_HASH_SIZE ) )
+	format_pinpoint_message( "start condition %s declared twice", str );
+
+    scset[lastsc] = mkstate( SYM_EPSILON );
+    scbol[lastsc] = mkstate( SYM_EPSILON );
+    scxclu[lastsc] = xcluflg;
+    sceof[lastsc] = false;
+    }
+
+
+/* sclookup - lookup the number associated with a start condition
+ *
+ * synopsis
+ *    char str[], scnum;
+ *    int sclookup;
+ *    scnum/0 = sclookup( str );
+ */
+
+int sclookup( str )
+char str[];
+
+    {
+    return ( findsym( str, sctbl, START_COND_HASH_SIZE )->int_val );
+    }

eoe/cmd/gnu/flex/tblcmp.c

@@ -0,0 +1,925 @@
+/* tblcmp - table compression 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/tblcmp.c,v 1.1 1992/05/05 22:30:54 wicinski Exp $ (LBL)";
+#endif
+
+#include "flexdef.h"
+
+
+/* declarations for functions that have forward references */
+
+void mkentry PROTO((register int*, int, int, int, int));
+void mkprot PROTO((int[], int, int));
+void mktemplate PROTO((int[], int, int));
+void mv2front PROTO((int));
+int tbldiff PROTO((int[], int, int[]));
+
+
+/* bldtbl - build table entries for dfa state
+ *
+ * synopsis
+ *   int state[numecs], statenum, totaltrans, comstate, comfreq;
+ *   bldtbl( state, statenum, totaltrans, comstate, comfreq );
+ *
+ * State is the statenum'th dfa state.  It is indexed by equivalence class and
+ * gives the number of the state to enter for a given equivalence class.
+ * totaltrans is the total number of transitions out of the state.  Comstate
+ * is that state which is the destination of the most transitions out of State.
+ * Comfreq is how many transitions there are out of State to Comstate.
+ *
+ * A note on terminology:
+ *    "protos" are transition tables which have a high probability of
+ * either being redundant (a state processed later will have an identical
+ * transition table) or nearly redundant (a state processed later will have
+ * many of the same out-transitions).  A "most recently used" queue of
+ * protos is kept around with the hope that most states will find a proto
+ * which is similar enough to be usable, and therefore compacting the
+ * output tables.
+ *    "templates" are a special type of proto.  If a transition table is
+ * homogeneous or nearly homogeneous (all transitions go to the same
+ * destination) then the odds are good that future states will also go
+ * to the same destination state on basically the same character set.
+ * These homogeneous states are so common when dealing with large rule
+ * sets that they merit special attention.  If the transition table were
+ * simply made into a proto, then (typically) each subsequent, similar
+ * state will differ from the proto for two out-transitions.  One of these
+ * out-transitions will be that character on which the proto does not go
+ * to the common destination, and one will be that character on which the
+ * state does not go to the common destination.  Templates, on the other
+ * hand, go to the common state on EVERY transition character, and therefore
+ * cost only one difference.
+ */
+
+void bldtbl( state, statenum, totaltrans, comstate, comfreq )
+int state[], statenum, totaltrans, comstate, comfreq;
+
+    {
+    int extptr, extrct[2][CSIZE + 1];
+    int mindiff, minprot, i, d;
+    int checkcom;
+
+    /* If extptr is 0 then the first array of extrct holds the result of the
+     * "best difference" to date, which is those transitions which occur in
+     * "state" but not in the proto which, to date, has the fewest differences
+     * between itself and "state".  If extptr is 1 then the second array of
+     * extrct hold the best difference.  The two arrays are toggled
+     * between so that the best difference to date can be kept around and
+     * also a difference just created by checking against a candidate "best"
+     * proto.
+     */
+
+    extptr = 0;
+
+    /* if the state has too few out-transitions, don't bother trying to
+     * compact its tables
+     */
+
+    if ( (totaltrans * 100) < (numecs * PROTO_SIZE_PERCENTAGE) )
+	mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
+
+    else
+	{
+	/* checkcom is true if we should only check "state" against
+	 * protos which have the same "comstate" value
+	 */
+
+	checkcom = comfreq * 100 > totaltrans * CHECK_COM_PERCENTAGE;
+
+	minprot = firstprot;
+	mindiff = totaltrans;
+
+	if ( checkcom )
+	    {
+	    /* find first proto which has the same "comstate" */
+	    for ( i = firstprot; i != NIL; i = protnext[i] )
+		if ( protcomst[i] == comstate )
+		    {
+		    minprot = i;
+		    mindiff = tbldiff( state, minprot, extrct[extptr] );
+		    break;
+		    }
+	    }
+
+	else
+	    {
+	    /* since we've decided that the most common destination out
+	     * of "state" does not occur with a high enough frequency,
+	     * we set the "comstate" to zero, assuring that if this state
+	     * is entered into the proto list, it will not be considered
+	     * a template.
+	     */
+	    comstate = 0;
+
+	    if ( firstprot != NIL )
+		{
+		minprot = firstprot;
+		mindiff = tbldiff( state, minprot, extrct[extptr] );
+		}
+	    }
+
+	/* we now have the first interesting proto in "minprot".  If
+	 * it matches within the tolerances set for the first proto,
+	 * we don't want to bother scanning the rest of the proto list
+	 * to see if we have any other reasonable matches.
+	 */
+
+	if ( mindiff * 100 > totaltrans * FIRST_MATCH_DIFF_PERCENTAGE )
+	    { /* not a good enough match.  Scan the rest of the protos */
+	    for ( i = minprot; i != NIL; i = protnext[i] )
+		{
+		d = tbldiff( state, i, extrct[1 - extptr] );
+		if ( d < mindiff )
+		    {
+		    extptr = 1 - extptr;
+		    mindiff = d;
+		    minprot = i;
+		    }
+		}
+	    }
+
+	/* check if the proto we've decided on as our best bet is close
+	 * enough to the state we want to match to be usable
+	 */
+
+	if ( mindiff * 100 > totaltrans * ACCEPTABLE_DIFF_PERCENTAGE )
+	    {
+	    /* no good.  If the state is homogeneous enough, we make a
+	     * template out of it.  Otherwise, we make a proto.
+	     */
+
+	    if ( comfreq * 100 >= totaltrans * TEMPLATE_SAME_PERCENTAGE )
+		mktemplate( state, statenum, comstate );
+
+	    else
+		{
+		mkprot( state, statenum, comstate );
+		mkentry( state, numecs, statenum, JAMSTATE, totaltrans );
+		}
+	    }
+
+	else
+	    { /* use the proto */
+	    mkentry( extrct[extptr], numecs, statenum,
+		     prottbl[minprot], mindiff );
+
+	    /* if this state was sufficiently different from the proto
+	     * we built it from, make it, too, a proto
+	     */
+
+	    if ( mindiff * 100 >= totaltrans * NEW_PROTO_DIFF_PERCENTAGE )
+		mkprot( state, statenum, comstate );
+
+	    /* since mkprot added a new proto to the proto queue, it's possible
+	     * that "minprot" is no longer on the proto queue (if it happened
+	     * to have been the last entry, it would have been bumped off).
+	     * If it's not there, then the new proto took its physical place
+	     * (though logically the new proto is at the beginning of the
+	     * queue), so in that case the following call will do nothing.
+	     */
+
+	    mv2front( minprot );
+	    }
+	}
+    }
+
+
+/* cmptmps - compress template table entries
+ *
+ * synopsis
+ *    cmptmps();
+ *
+ *  template tables are compressed by using the 'template equivalence
+ *  classes', which are collections of transition character equivalence
+ *  classes which always appear together in templates - really meta-equivalence
+ *  classes.  until this point, the tables for templates have been stored
+ *  up at the top end of the nxt array; they will now be compressed and have
+ *  table entries made for them.
+ */
+
+void cmptmps()
+
+    {
+    int tmpstorage[CSIZE + 1];
+    register int *tmp = tmpstorage, i, j;
+    int totaltrans, trans;
+
+    peakpairs = numtemps * numecs + tblend;
+
+    if ( usemecs )
+	{
+	/* create equivalence classes base on data gathered on template
+	 * transitions
+	 */
+
+	nummecs = cre8ecs( tecfwd, tecbck, numecs );
+	}
+    
+    else
+	nummecs = numecs;
+
+    if ( lastdfa + numtemps + 1 >= current_max_dfas )
+	increase_max_dfas();
+
+    /* loop through each template */
+
+    for ( i = 1; i <= numtemps; ++i )
+	{
+	totaltrans = 0;	/* number of non-jam transitions out of this template */
+
+	for ( j = 1; j <= numecs; ++j )
+	    {
+	    trans = tnxt[numecs * i + j];
+
+	    if ( usemecs )
+		{
+		/* the absolute value of tecbck is the meta-equivalence class
+		 * of a given equivalence class, as set up by cre8ecs
+		 */
+		if ( tecbck[j] > 0 )
+		    {
+		    tmp[tecbck[j]] = trans;
+
+		    if ( trans > 0 )
+			++totaltrans;
+		    }
+		}
+
+	    else
+		{
+		tmp[j] = trans;
+
+		if ( trans > 0 )
+		    ++totaltrans;
+		}
+	    }
+
+	/* it is assumed (in a rather subtle way) in the skeleton that
+	 * if we're using meta-equivalence classes, the def[] entry for
+	 * all templates is the jam template, i.e., templates never default
+	 * to other non-jam table entries (e.g., another template)
+	 */
+
+	/* leave room for the jam-state after the last real state */
+	mkentry( tmp, nummecs, lastdfa + i + 1, JAMSTATE, totaltrans );
+	}
+    }
+
+
+
+/* expand_nxt_chk - expand the next check arrays */
+
+void expand_nxt_chk()
+
+    {
+    register int old_max = current_max_xpairs;
+
+    current_max_xpairs += MAX_XPAIRS_INCREMENT;
+
+    ++num_reallocs;
+
+    nxt = reallocate_integer_array( nxt, current_max_xpairs );
+    chk = reallocate_integer_array( chk, current_max_xpairs );
+
+    bzero( (char *) (chk + old_max),
+	   MAX_XPAIRS_INCREMENT * sizeof( int ) / sizeof( char ) );
+    }
+
+
+/* find_table_space - finds a space in the table for a state to be placed
+ *
+ * synopsis
+ *     int *state, numtrans, block_start;
+ *     int find_table_space();
+ *
+ *     block_start = find_table_space( state, numtrans );
+ *
+ * State is the state to be added to the full speed transition table.
+ * Numtrans is the number of out-transitions for the state.
+ *
+ * find_table_space() returns the position of the start of the first block (in
+ * chk) able to accommodate the state
+ *
+ * In determining if a state will or will not fit, find_table_space() must take
+ * into account the fact that an end-of-buffer state will be added at [0],
+ * and an action number will be added in [-1].
+ */
+
+int find_table_space( state, numtrans )
+int *state, numtrans;
+    
+    {
+    /* firstfree is the position of the first possible occurrence of two
+     * consecutive unused records in the chk and nxt arrays
+     */
+    register int i;
+    register int *state_ptr, *chk_ptr;
+    register int *ptr_to_last_entry_in_state;
+
+    /* if there are too many out-transitions, put the state at the end of
+     * nxt and chk
+     */
+    if ( numtrans > MAX_XTIONS_FULL_INTERIOR_FIT )
+	{
+	/* if table is empty, return the first available spot in chk/nxt,
+	 * which should be 1
+	 */
+	if ( tblend < 2 )
+	    return ( 1 );
+
+	i = tblend - numecs;	/* start searching for table space near the
+				 * end of chk/nxt arrays
+				 */
+	}
+
+    else
+	i = firstfree;		/* start searching for table space from the
+				 * beginning (skipping only the elements
+				 * which will definitely not hold the new
+				 * state)
+				 */
+
+    while ( 1 )		/* loops until a space is found */
+	{
+	if ( i + numecs > current_max_xpairs )
+	    expand_nxt_chk();
+
+	/* loops until space for end-of-buffer and action number are found */
+	while ( 1 )
+	    {
+	    if ( chk[i - 1] == 0 )	/* check for action number space */
+		{
+		if ( chk[i] == 0 )	/* check for end-of-buffer space */
+		    break;
+
+		else
+		    i += 2;	/* since i != 0, there is no use checking to
+				 * see if (++i) - 1 == 0, because that's the
+				 * same as i == 0, so we skip a space
+				 */
+		}
+
+	    else
+		++i;
+
+	    if ( i + numecs > current_max_xpairs )
+		expand_nxt_chk();
+	    }
+
+	/* if we started search from the beginning, store the new firstfree for
+	 * the next call of find_table_space()
+	 */
+	if ( numtrans <= MAX_XTIONS_FULL_INTERIOR_FIT )
+	    firstfree = i + 1;
+
+	/* check to see if all elements in chk (and therefore nxt) that are
+	 * needed for the new state have not yet been taken
+	 */
+
+	state_ptr = &state[1];
+	ptr_to_last_entry_in_state = &chk[i + numecs + 1];
+
+	for ( chk_ptr = &chk[i + 1]; chk_ptr != ptr_to_last_entry_in_state;
+	      ++chk_ptr )
+	    if ( *(state_ptr++) != 0 && *chk_ptr != 0 )
+		break;
+
+	if ( chk_ptr == ptr_to_last_entry_in_state )
+	    return ( i );
+
+	else
+	    ++i;
+	}
+    }
+
+
+/* inittbl - initialize transition tables
+ *
+ * synopsis
+ *   inittbl();
+ *
+ * Initializes "firstfree" to be one beyond the end of the table.  Initializes
+ * all "chk" entries to be zero.  Note that templates are built in their
+ * own tbase/tdef tables.  They are shifted down to be contiguous
+ * with the non-template entries during table generation.
+ */
+void inittbl()
+
+    {
+    register int i;
+
+    bzero( (char *) chk, current_max_xpairs * sizeof( int ) / sizeof( char ) );
+
+    tblend = 0;
+    firstfree = tblend + 1;
+    numtemps = 0;
+
+    if ( usemecs )
+	{
+	/* set up doubly-linked meta-equivalence classes
+	 * these are sets of equivalence classes which all have identical
+	 * transitions out of TEMPLATES
+	 */
+
+	tecbck[1] = NIL;
+
+	for ( i = 2; i <= numecs; ++i )
+	    {
+	    tecbck[i] = i - 1;
+	    tecfwd[i - 1] = i;
+	    }
+
+	tecfwd[numecs] = NIL;
+	}
+    }
+
+
+/* mkdeftbl - make the default, "jam" table entries
+ *
+ * synopsis
+ *   mkdeftbl();
+ */
+
+void mkdeftbl()
+
+    {
+    int i;
+
+    jamstate = lastdfa + 1;
+
+    ++tblend; /* room for transition on end-of-buffer character */
+
+    if ( tblend + numecs > current_max_xpairs )
+	expand_nxt_chk();
+
+    /* add in default end-of-buffer transition */
+    nxt[tblend] = end_of_buffer_state;
+    chk[tblend] = jamstate;
+
+    for ( i = 1; i <= numecs; ++i )
+	{
+	nxt[tblend + i] = 0;
+	chk[tblend + i] = jamstate;
+	}
+
+    jambase = tblend;
+
+    base[jamstate] = jambase;
+    def[jamstate] = 0;
+
+    tblend += numecs;
+    ++numtemps;
+    }
+
+
+/* mkentry - create base/def and nxt/chk entries for transition array
+ *
+ * synopsis
+ *   int state[numchars + 1], numchars, statenum, deflink, totaltrans;
+ *   mkentry( state, numchars, statenum, deflink, totaltrans );
+ *
+ * "state" is a transition array "numchars" characters in size, "statenum"
+ * is the offset to be used into the base/def tables, and "deflink" is the
+ * entry to put in the "def" table entry.  If "deflink" is equal to
+ * "JAMSTATE", then no attempt will be made to fit zero entries of "state"
+ * (i.e., jam entries) into the table.  It is assumed that by linking to
+ * "JAMSTATE" they will be taken care of.  In any case, entries in "state"
+ * marking transitions to "SAME_TRANS" are treated as though they will be
+ * taken care of by whereever "deflink" points.  "totaltrans" is the total
+ * number of transitions out of the state.  If it is below a certain threshold,
+ * the tables are searched for an interior spot that will accommodate the
+ * state array.
+ */
+
+void mkentry( state, numchars, statenum, deflink, totaltrans )
+register int *state;
+int numchars, statenum, deflink, totaltrans;
+
+    {
+    register int minec, maxec, i, baseaddr;
+    int tblbase, tbllast;
+
+    if ( totaltrans == 0 )
+	{ /* there are no out-transitions */
+	if ( deflink == JAMSTATE )
+	    base[statenum] = JAMSTATE;
+	else
+	    base[statenum] = 0;
+
+	def[statenum] = deflink;
+	return;
+	}
+
+    for ( minec = 1; minec <= numchars; ++minec )
+	{
+	if ( state[minec] != SAME_TRANS )
+	    if ( state[minec] != 0 || deflink != JAMSTATE )
+		break;
+	}
+
+    if ( totaltrans == 1 )
+	{
+	/* there's only one out-transition.  Save it for later to fill
+	 * in holes in the tables.
+	 */
+	stack1( statenum, minec, state[minec], deflink );
+	return;
+	}
+
+    for ( maxec = numchars; maxec > 0; --maxec )
+	{
+	if ( state[maxec] != SAME_TRANS )
+	    if ( state[maxec] != 0 || deflink != JAMSTATE )
+		break;
+	}
+
+    /* Whether we try to fit the state table in the middle of the table
+     * entries we have already generated, or if we just take the state
+     * table at the end of the nxt/chk tables, we must make sure that we
+     * have a valid base address (i.e., non-negative).  Note that not only are
+     * negative base addresses dangerous at run-time (because indexing the
+     * next array with one and a low-valued character might generate an
+     * array-out-of-bounds error message), but at compile-time negative
+     * base addresses denote TEMPLATES.
+     */
+
+    /* find the first transition of state that we need to worry about. */
+    if ( totaltrans * 100 <= numchars * INTERIOR_FIT_PERCENTAGE )
+	{ /* attempt to squeeze it into the middle of the tabls */
+	baseaddr = firstfree;
+
+	while ( baseaddr < minec )
+	    {
+	    /* using baseaddr would result in a negative base address below
+	     * find the next free slot
+	     */
+	    for ( ++baseaddr; chk[baseaddr] != 0; ++baseaddr )
+		;
+	    }
+
+	if ( baseaddr + maxec - minec >= current_max_xpairs )
+	    expand_nxt_chk();
+
+	for ( i = minec; i <= maxec; ++i )
+	    if ( state[i] != SAME_TRANS )
+		if ( state[i] != 0 || deflink != JAMSTATE )
+		    if ( chk[baseaddr + i - minec] != 0 )
+			{ /* baseaddr unsuitable - find another */
+			for ( ++baseaddr;
+			      baseaddr < current_max_xpairs &&
+			      chk[baseaddr] != 0;
+			      ++baseaddr )
+			    ;
+
+			if ( baseaddr + maxec - minec >= current_max_xpairs )
+			    expand_nxt_chk();
+
+			/* reset the loop counter so we'll start all
+			 * over again next time it's incremented
+			 */
+
+			i = minec - 1;
+			}
+	}
+
+    else
+	{
+	/* ensure that the base address we eventually generate is
+	 * non-negative
+	 */
+	baseaddr = max( tblend + 1, minec );
+	}
+
+    tblbase = baseaddr - minec;
+    tbllast = tblbase + maxec;
+
+    if ( tbllast >= current_max_xpairs )
+	expand_nxt_chk();
+
+    base[statenum] = tblbase;
+    def[statenum] = deflink;
+
+    for ( i = minec; i <= maxec; ++i )
+	if ( state[i] != SAME_TRANS )
+	    if ( state[i] != 0 || deflink != JAMSTATE )
+		{
+		nxt[tblbase + i] = state[i];
+		chk[tblbase + i] = statenum;
+		}
+
+    if ( baseaddr == firstfree )
+	/* find next free slot in tables */
+	for ( ++firstfree; chk[firstfree] != 0; ++firstfree )
+	    ;
+
+    tblend = max( tblend, tbllast );
+    }
+
+
+/* mk1tbl - create table entries for a state (or state fragment) which
+ *            has only one out-transition
+ *
+ * synopsis
+ *   int state, sym, onenxt, onedef;
+ *   mk1tbl( state, sym, onenxt, onedef );
+ */
+
+void mk1tbl( state, sym, onenxt, onedef )
+int state, sym, onenxt, onedef;
+
+    {
+    if ( firstfree < sym )
+	firstfree = sym;
+
+    while ( chk[firstfree] != 0 )
+	if ( ++firstfree >= current_max_xpairs )
+	    expand_nxt_chk();
+
+    base[state] = firstfree - sym;
+    def[state] = onedef;
+    chk[firstfree] = state;
+    nxt[firstfree] = onenxt;
+
+    if ( firstfree > tblend )
+	{
+	tblend = firstfree++;
+
+	if ( firstfree >= current_max_xpairs )
+	    expand_nxt_chk();
+	}
+    }
+
+
+/* mkprot - create new proto entry
+ *
+ * synopsis
+ *   int state[], statenum, comstate;
+ *   mkprot( state, statenum, comstate );
+ */
+
+void mkprot( state, statenum, comstate )
+int state[], statenum, comstate;
+
+    {
+    int i, slot, tblbase;
+
+    if ( ++numprots >= MSP || numecs * numprots >= PROT_SAVE_SIZE )
+	{
+	/* gotta make room for the new proto by dropping last entry in
+	 * the queue
+	 */
+	slot = lastprot;
+	lastprot = protprev[lastprot];
+	protnext[lastprot] = NIL;
+	}
+
+    else
+	slot = numprots;
+
+    protnext[slot] = firstprot;
+
+    if ( firstprot != NIL )
+	protprev[firstprot] = slot;
+
+    firstprot = slot;
+    prottbl[slot] = statenum;
+    protcomst[slot] = comstate;
+
+    /* copy state into save area so it can be compared with rapidly */
+    tblbase = numecs * (slot - 1);
+
+    for ( i = 1; i <= numecs; ++i )
+	protsave[tblbase + i] = state[i];
+    }
+
+
+/* mktemplate - create a template entry based on a state, and connect the state
+ *              to it
+ *
+ * synopsis
+ *   int state[], statenum, comstate, totaltrans;
+ *   mktemplate( state, statenum, comstate, totaltrans );
+ */
+
+void mktemplate( state, statenum, comstate )
+int state[], statenum, comstate;
+
+    {
+    int i, numdiff, tmpbase, tmp[CSIZE + 1];
+    Char transset[CSIZE + 1];
+    int tsptr;
+
+    ++numtemps;
+
+    tsptr = 0;
+
+    /* calculate where we will temporarily store the transition table
+     * of the template in the tnxt[] array.  The final transition table
+     * gets created by cmptmps()
+     */
+
+    tmpbase = numtemps * numecs;
+
+    if ( tmpbase + numecs >= current_max_template_xpairs )
+	{
+	current_max_template_xpairs += MAX_TEMPLATE_XPAIRS_INCREMENT;
+
+	++num_reallocs;
+
+	tnxt = reallocate_integer_array( tnxt, current_max_template_xpairs );
+	}
+
+    for ( i = 1; i <= numecs; ++i )
+	if ( state[i] == 0 )
+	    tnxt[tmpbase + i] = 0;
+	else
+	    {
+	    transset[tsptr++] = i;
+	    tnxt[tmpbase + i] = comstate;
+	    }
+
+    if ( usemecs )
+	mkeccl( transset, tsptr, tecfwd, tecbck, numecs, 0 );
+
+    mkprot( tnxt + tmpbase, -numtemps, comstate );
+
+    /* we rely on the fact that mkprot adds things to the beginning
+     * of the proto queue
+     */
+
+    numdiff = tbldiff( state, firstprot, tmp );
+    mkentry( tmp, numecs, statenum, -numtemps, numdiff );
+    }
+
+
+/* mv2front - move proto queue element to front of queue
+ *
+ * synopsis
+ *   int qelm;
+ *   mv2front( qelm );
+ */
+
+void mv2front( qelm )
+int qelm;
+
+    {
+    if ( firstprot != qelm )
+	{
+	if ( qelm == lastprot )
+	    lastprot = protprev[lastprot];
+
+	protnext[protprev[qelm]] = protnext[qelm];
+
+	if ( protnext[qelm] != NIL )
+	    protprev[protnext[qelm]] = protprev[qelm];
+
+	protprev[qelm] = NIL;
+	protnext[qelm] = firstprot;
+	protprev[firstprot] = qelm;
+	firstprot = qelm;
+	}
+    }
+
+
+/* place_state - place a state into full speed transition table
+ *
+ * synopsis
+ *     int *state, statenum, transnum;
+ *     place_state( state, statenum, transnum );
+ *
+ * State is the statenum'th state.  It is indexed by equivalence class and
+ * gives the number of the state to enter for a given equivalence class.
+ * Transnum is the number of out-transitions for the state.
+ */
+
+void place_state( state, statenum, transnum )
+int *state, statenum, transnum;
+
+    {
+    register int i;
+    register int *state_ptr;
+    int position = find_table_space( state, transnum );
+
+    /* base is the table of start positions */
+    base[statenum] = position;
+
+    /* put in action number marker; this non-zero number makes sure that
+     * find_table_space() knows that this position in chk/nxt is taken
+     * and should not be used for another accepting number in another state
+     */
+    chk[position - 1] = 1;
+
+    /* put in end-of-buffer marker; this is for the same purposes as above */
+    chk[position] = 1;
+
+    /* place the state into chk and nxt */
+    state_ptr = &state[1];
+
+    for ( i = 1; i <= numecs; ++i, ++state_ptr )
+	if ( *state_ptr != 0 )
+	    {
+	    chk[position + i] = i;
+	    nxt[position + i] = *state_ptr;
+	    }
+
+    if ( position + numecs > tblend )
+	tblend = position + numecs;
+    }
+
+
+/* stack1 - save states with only one out-transition to be processed later
+ *
+ * synopsis
+ *   int statenum, sym, nextstate, deflink;
+ *   stack1( statenum, sym, nextstate, deflink );
+ *
+ * if there's room for another state one the "one-transition" stack, the
+ * state is pushed onto it, to be processed later by mk1tbl.  If there's
+ * no room, we process the sucker right now.
+ */
+
+void stack1( statenum, sym, nextstate, deflink )
+int statenum, sym, nextstate, deflink;
+
+    {
+    if ( onesp >= ONE_STACK_SIZE - 1 )
+	mk1tbl( statenum, sym, nextstate, deflink );
+
+    else
+	{
+	++onesp;
+	onestate[onesp] = statenum;
+	onesym[onesp] = sym;
+	onenext[onesp] = nextstate;
+	onedef[onesp] = deflink;
+	}
+    }
+
+
+/* tbldiff - compute differences between two state tables
+ *
+ * synopsis
+ *   int state[], pr, ext[];
+ *   int tbldiff, numdifferences;
+ *   numdifferences = tbldiff( state, pr, ext )
+ *
+ * "state" is the state array which is to be extracted from the pr'th
+ * proto.  "pr" is both the number of the proto we are extracting from
+ * and an index into the save area where we can find the proto's complete
+ * state table.  Each entry in "state" which differs from the corresponding
+ * entry of "pr" will appear in "ext".
+ * Entries which are the same in both "state" and "pr" will be marked
+ * as transitions to "SAME_TRANS" in "ext".  The total number of differences
+ * between "state" and "pr" is returned as function value.  Note that this
+ * number is "numecs" minus the number of "SAME_TRANS" entries in "ext".
+ */
+
+int tbldiff( state, pr, ext )
+int state[], pr, ext[];
+
+    {
+    register int i, *sp = state, *ep = ext, *protp;
+    register int numdiff = 0;
+
+    protp = &protsave[numecs * (pr - 1)];
+
+    for ( i = numecs; i > 0; --i )
+	{
+	if ( *++protp == *++sp )
+	    *++ep = SAME_TRANS;
+	else
+	    {
+	    *++ep = *sp;
+	    ++numdiff;
+	    }
+	}
+
+    return ( numdiff );
+    }

eoe/cmd/gnu/flex/yylex.c

@@ -0,0 +1,216 @@
+/* yylex - scanner front-end for flex */
+
+/*-
+ * 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 are permitted provided
+ * that: (1) source distributions retain this entire copyright notice and
+ * comment, and (2) distributions including binaries display the following
+ * acknowledgement:  ``This product includes software developed by the
+ * University of California, Berkeley and its contributors'' in the
+ * documentation or other materials provided with the distribution and in
+ * all advertising materials mentioning features or use of this software.
+ * 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.
+ */
+
+#ifndef lint
+static char rcsid[] =
+    "@(#) $Header: /proj/irix6.5.7m/isms/eoe/cmd/gnu/flex/RCS/yylex.c,v 1.1 1992/05/05 22:30:57 wicinski Exp $ (LBL)";
+#endif
+
+#include <ctype.h>
+#include "flexdef.h"
+#include "parse.h"
+
+
+/* ANSI C does not guarantee that isascii() is defined */
+#ifndef isascii
+#define isascii(c) ((c) <= 0177)
+#endif
+
+
+/* yylex - scan for a regular expression token
+ *
+ * synopsis
+ *
+ *   token = yylex();
+ *
+ *     token - return token found
+ */
+
+int yylex()
+
+    {
+    int toktype;
+    static int beglin = false;
+
+    if ( eofseen )
+	toktype = EOF;
+    else
+	toktype = flexscan();
+
+    if ( toktype == EOF || toktype == 0 )
+	{
+	eofseen = 1;
+
+	if ( sectnum == 1 )
+	    {
+	    synerr( "premature EOF" );
+	    sectnum = 2;
+	    toktype = SECTEND;
+	    }
+
+	else if ( sectnum == 2 )
+	    {
+	    sectnum = 3;
+	    toktype = 0;
+	    }
+
+	else
+	    toktype = 0;
+	}
+
+    if ( trace )
+	{
+	if ( beglin )
+	    {
+	    fprintf( stderr, "%d\t", num_rules + 1 );
+	    beglin = 0;
+	    }
+
+	switch ( toktype )
+	    {
+	    case '<':
+	    case '>':
+	    case '^':
+	    case '$':
+	    case '"':
+	    case '[':
+	    case ']':
+	    case '{':
+	    case '}':
+	    case '|':
+	    case '(':
+	    case ')':
+	    case '-':
+	    case '/':
+	    case '\\':
+	    case '?':
+	    case '.':
+	    case '*':
+	    case '+':
+	    case ',':
+		(void) putc( toktype, stderr );
+		break;
+
+	    case '\n':
+		(void) putc( '\n', stderr );
+
+		if ( sectnum == 2 )
+		    beglin = 1;
+
+		break;
+
+	    case SCDECL:
+		fputs( "%s", stderr );
+		break;
+
+	    case XSCDECL:
+		fputs( "%x", stderr );
+		break;
+
+	    case WHITESPACE:
+		(void) putc( ' ', stderr );
+		break;
+
+	    case SECTEND:
+		fputs( "%%\n", stderr );
+
+		/* we set beglin to be true so we'll start
+		 * writing out numbers as we echo rules.  flexscan() has
+		 * already assigned sectnum
+		 */
+
+		if ( sectnum == 2 )
+		    beglin = 1;
+
+		break;
+
+	    case NAME:
+		fprintf( stderr, "'%s'", nmstr );
+		break;
+
+	    case CHAR:
+		switch ( yylval )
+		    {
+		    case '<':
+		    case '>':
+		    case '^':
+		    case '$':
+		    case '"':
+		    case '[':
+		    case ']':
+		    case '{':
+		    case '}':
+		    case '|':
+		    case '(':
+		    case ')':
+		    case '-':
+		    case '/':
+		    case '\\':
+		    case '?':
+		    case '.':
+		    case '*':
+		    case '+':
+		    case ',':
+			fprintf( stderr, "\\%c", yylval );
+			break;
+
+		    default:
+			if ( ! isascii( yylval ) || ! isprint( yylval ) )
+			    fprintf( stderr, "\\%.3o", yylval );
+			else
+			    (void) putc( yylval, stderr );
+			break;
+		    }
+			
+		break;
+
+	    case NUMBER:
+		fprintf( stderr, "%d", yylval );
+		break;
+
+	    case PREVCCL:
+		fprintf( stderr, "[%d]", yylval );
+		break;
+
+	    case EOF_OP:
+		fprintf( stderr, "<<EOF>>" );
+		break;
+
+	    case 0:
+		fprintf( stderr, "End Marker" );
+		break;
+
+	    default:
+		fprintf( stderr, "*Something Weird* - tok: %d val: %d\n",
+			 toktype, yylval );
+		break;
+	    }
+	}
+	    
+    return ( toktype );
+    }