svn merge ^/branches/released .

1 files changed, 1663 insertions, 0 deletions

diff --git a/tools/bison++/output.cc b/tools/bison++/output.cc
new file mode 100644
index 000000000..6753fdac7
--- /dev/null
+++ b/tools/bison++/output.cc
@@ -0,0 +1,1663 @@
+/* Output the generated parsing program 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.  */
+
+
+/* functions to output parsing data to various files.  Entries are:
+
+  output_headers ()
+
+Output constant strings to the beginning of certain files.
+
+  output_trailers()
+
+Output constant strings to the ends of certain files.
+
+  output ()
+
+Output the parsing tables and the parser code to ftable.
+
+The parser tables consist of these tables.
+Starred ones needed only for the semantic parser.
+
+yytranslate = vector mapping yylex's token numbers into bison's token numbers.
+
+yytname = vector of string-names indexed by bison token number
+
+yyrline = vector of line-numbers of all rules.  For yydebug printouts.
+
+yyrhs = vector of items of all rules.
+        This is exactly what ritems contains.  For yydebug and for semantic
+	parser.
+
+yyprhs[r] = index in yyrhs of first item for rule r.
+
+yyr1[r] = symbol number of symbol that rule r derives.
+
+yyr2[r] = number of symbols composing right hand side of rule r.
+
+* yystos[s] = the symbol number of the symbol that leads to state s.
+
+yydefact[s] = default rule to reduce with in state s,
+	      when yytable doesn't specify something else to do.
+	      Zero means the default is an error.
+
+yydefgoto[i] = default state to go to after a reduction of a rule that
+	       generates variable ntokens + i, except when yytable
+	       specifies something else to do.
+
+yypact[s] = index in yytable of the portion describing state s.
+            The lookahead token's type is used to index that portion
+            to find out what to do.
+
+	    If the value in yytable is positive,
+	    we shift the token and go to that state.
+
+	    If the value is negative, it is minus a rule number to reduce by.
+
+	    If the value is zero, the default action from yydefact[s] is used.
+
+yypgoto[i] = the index in yytable of the portion describing 
+             what to do after reducing a rule that derives variable i + ntokens.
+             This portion is indexed by the parser state number
+	     as of before the text for this nonterminal was read.
+	     The value from yytable is the state to go to.
+
+yytable = a vector filled with portions for different uses,
+          found via yypact and yypgoto.
+
+yycheck = a vector indexed in parallel with yytable.
+	  It indicates, in a roundabout way, the bounds of the
+	  portion you are trying to examine.
+
+	  Suppose that the portion of yytable starts at index p
+	  and the index to be examined within the portion is i.
+	  Then if yycheck[p+i] != i, i is outside the bounds
+	  of what is actually allocated, and the default
+	  (from yydefact or yydefgoto) should be used.
+	  Otherwise, yytable[p+i] should be used.
+
+YYFINAL = the state number of the termination state.
+YYFLAG = most negative short int.  Used to flag ??
+YYNTBASE = ntokens.
+
+*/
+
+#include <stdio.h>
+#include "system.h"
+#include "machine.h"
+#include "new.h"
+#include "files.h"
+#include "gram.h"
+#include "state.h"
+#include "symtab.h"
+
+
+extern bool bison_compability;
+extern int debugflag;
+extern int nolinesflag;
+extern int definesflag;
+char *quoted_filename(char* f);
+extern char **tags;
+extern int tokensetsize;
+extern int final_state;
+extern core **state_table;
+extern shifts **shift_table;
+extern errs **err_table;
+extern reductions **reduction_table;
+extern short *accessing_symbol;
+extern unsigned *LA;
+extern short *LAruleno;
+extern short *lookaheads;
+extern char *consistent;
+extern short *goto_map;
+extern short *from_state;
+extern short *to_state;
+
+extern char* xmalloc(unsigned);
+
+
+void output_token_translations();
+void output_gram();
+void output_stos();
+void output_rule_data();
+void output_defines();
+void output_actions();
+void token_actions();
+void save_row(int);
+void goto_actions();
+void save_column(int,int);
+void sort_actions();
+void pack_table();
+void output_base();
+void output_table();
+void output_check();
+void output_parser();
+void output_program();
+void free_itemset();
+void free_shifts();
+void free_reductions();
+void free_itemsets();
+int action_row(int);
+int default_goto(int);
+int matching_state(int);
+int pack_vector(int);
+
+extern void berror(char*);
+extern void fatal(const char*);
+extern void fatals(const char*,void*);
+extern void fatals(const char*,void*,void*);
+extern void fatals(const char*,void*,void*,void*);
+extern void fatals(const char*,void*,void*,void*,void*);
+extern void fatals(const char*,void*,void*,void*,void*,void*);
+
+static int nvectors;
+static int nentries;
+static short **froms;
+static short **tos;
+static short *tally;
+static short *width;
+static short *actrow;
+static short *state_count;
+static short *order;
+static short *base;
+static short *pos;
+static short *table;
+static short *check;
+static int lowzero;
+static int high;
+
+void output_section(FILE* fin,FILE* fout);
+void output_token_defines_fmt(FILE* file,char* fmt,int notrans);
+extern bucket *errtoken;
+void output_token_defines(FILE* file);
+void output_token_const_def(FILE* file);
+void output_token_const_decl(FILE* file);
+void output_token_enum(FILE* file);
+extern int line_fparser;
+extern int line_fhskel;
+extern char *parser_fname;
+extern char *hskel_fname;
+extern char *version_string;
+
+
+
+
+#define	GUARDSTR	"\n#include \"%s\"\nextern int yyerror;\n\
+extern int yycost;\nextern char * yymsg;\nextern YYSTYPE yyval;\n\n\
+yyguard(n, yyvsp, yylsp)\nregister int n;\nregister YYSTYPE *yyvsp;\n\
+register YYLTYPE *yylsp;\n\
+{\n  yyerror = 0;\nyycost = 0;\n  yymsg = 0;\nswitch (n)\n    {"
+
+#define	ACTSTR		"\n#include \"%s\"\nextern YYSTYPE yyval;\
+\nextern int yychar;\
+yyaction(n, yyvsp, yylsp)\nregister int n;\nregister YYSTYPE *yyvsp;\n\
+register YYLTYPE *yylsp;\n{\n  switch (n)\n{"
+
+#define	ACTSTR_SIMPLE	"\n  switch (yyn) {\n"
+
+void
+output_before_read()
+{ 
+  fprintf(ftable, "\n/*  A Bison++ parser, made from %s  */\n\n", infile);
+  fprintf(ftable, " /* with Bison++ version %s  */\n\n", version_string);
+  /* Redefine certain symbols if -p was specified.  */
+  if (spec_name_prefix)
+    {
+      fprintf(ftable, "#define yyparse %sparse\n",spec_name_prefix);
+      fprintf(ftable, "#define yylex %slex\n",spec_name_prefix);
+      fprintf(ftable, "#define yyerror %serror\n",spec_name_prefix);
+      fprintf(ftable, "#define yylval %slval\n",spec_name_prefix);
+      fprintf(ftable, "#define yychar %schar\n",spec_name_prefix);
+      fprintf(ftable, "#define yydebug %sdebug\n",spec_name_prefix);
+    }
+  if(bison_compability==false)    
+    fprintf(ftable,"#define YY_USE_CLASS\n");
+  output_section(fparser,ftable);
+  if(definesflag) output_section(fhskel,fdefines);
+};
+
+void
+output_headers()
+{
+  if(bison_compability==false)
+    {
+    fprintf(fbisoncomp,"#define YY_USE_CLASS\n");
+    }
+  else
+    {
+      fprintf(fbisoncomp,"/*#define YY_USE_CLASS \n*/");
+    }
+  output_section(fhskel,fbisoncomp);
+  if(definesflag) output_section(fhskel,fdefines);
+  output_section(fparser,ftable);
+  if (pure_parser)
+    {
+     fprintf(ftable, "#define YY_%s_PURE 1\n",parser_name);
+     if(definesflag) fprintf(fdefines, "#define YY_%s_PURE 1\n\n",parser_name);
+    }
+  /* start writing the guard and action files, if they are needed.  */
+  if (semantic_parser)
+    fprintf(fguard, GUARDSTR, attrsfile);
+  fprintf(faction, (semantic_parser ? ACTSTR : ACTSTR_SIMPLE), attrsfile);
+  if(definesflag) output_section(fhskel,fdefines);
+  output_section(fparser,ftable);
+
+
+  /* Rename certain symbols if -p was specified.  */
+  if (spec_name_prefix)
+    {
+      fprintf(ftable, "#define YY_%s_PARSE %sparse\n",
+          parser_name, spec_name_prefix);
+      fprintf(ftable, "#define YY_%s_LEX %slex\n",
+          parser_name, spec_name_prefix);
+      fprintf(ftable, "#define YY_%s_ERROR %serror\n",
+          parser_name, spec_name_prefix);
+      fprintf(ftable, "#define YY_%s_LVAL %slval\n",
+          parser_name, spec_name_prefix);
+      fprintf(ftable, "#define YY_%s_CHAR %schar\n",
+          parser_name, spec_name_prefix);
+      fprintf(ftable, "#define YY_%s_DEBUG %sdebug\n",
+          parser_name, spec_name_prefix);
+    }
+  if (spec_name_prefix && definesflag)
+    {
+      fprintf(fdefines, "#define YY_%s_PARSE %sparse\n",
+          parser_name, spec_name_prefix);
+      fprintf(fdefines, "#define YY_%s_LEX %slex\n",
+          parser_name, spec_name_prefix);
+      fprintf(fdefines, "#define YY_%s_ERROR %serror\n",
+          parser_name, spec_name_prefix);
+      fprintf(fdefines, "#define YY_%s_LVAL %slval\n",
+          parser_name, spec_name_prefix);
+      fprintf(fdefines, "#define YY_%s_CHAR %schar\n",
+          parser_name, spec_name_prefix);
+      fprintf(fdefines, "#define YY_%s_DEBUG %sdebug\n",
+          parser_name, spec_name_prefix);
+    }
+
+}
+
+
+void
+output_trailers()
+{
+  if(definesflag) output_section(fhskel,fdefines);
+  output_section(fparser,ftable);
+  /* output the definition of YYLTYPE into the fattrs and fdefines files.  */
+  if(debugflag)
+   {fprintf(ftable, 
+    "#define YY_%s_DEBUG %d\n"
+	    ,parser_name,!!debugflag);
+    if (definesflag)
+     fprintf(fdefines, 
+      "#define YY_%s_DEBUG %d\n",
+            parser_name,!!debugflag);
+    }
+  if(definesflag) output_section(fhskel,fdefines);
+  output_section(fparser,ftable);
+  /* Now we know whether we need the line-number stack.
+     If we do, write its type into the .tab.h file.  */
+  if (yylsp_needed)
+    {
+     /* fattrs winds up in the .tab.c file, before bison.simple.  */
+      fprintf(ftable, "#define YYLSP_%s_NEEDED\n",parser_name);
+      if (debugflag)
+
+      if (definesflag)
+	{
+         fprintf(fdefines, 
+             "#define YY_%s_LSP_NEEDED\n",
+              parser_name);
+        }
+    }
+  if (semantic_parser)
+    {
+      fprintf(fguard, "\n    }\n}\n");
+      fprintf(faction, "\n    }\n}\n");
+    }
+  else
+    fprintf(faction, "\n}\n");
+}
+
+
+void
+output()
+{
+  int c;
+
+   if (!semantic_parser)		/* JF Put out other stuff */
+    {
+      rewind(fattrs);
+      while ((c=getc(fattrs))!=EOF)
+        putc(c,ftable);
+    }
+
+  if (semantic_parser)
+    fprintf(ftable, "#include \"%s\"\n", attrsfile);
+
+
+  free_itemsets();
+  output_defines();
+  output_token_translations();
+/*   if (semantic_parser) */
+  /* This is now unconditional because debugging printouts can use it.  */
+  output_gram();
+  FREE(ritem);
+  if (semantic_parser)
+    output_stos();
+  output_rule_data();
+  output_actions();
+  output_parser();
+  output_program();
+}
+
+
+void
+output_token_translations()
+{
+  register int i, j;
+/*   register short *sp; JF unused */
+
+  if (translations)
+    {
+      fprintf(ftable,
+	      "\n#define YYTRANSLATE(x) ((unsigned)(x) <= %d ? yytranslate[x] : %d)\n",
+	      max_user_token_number, nsyms);
+    
+      if (ntokens < 127)  /* play it very safe; check maximum element value.  */
+        fprintf(ftable, "\nstatic const char yytranslate[] = {     0");
+      else
+	fprintf(ftable, "\nstatic const short yytranslate[] = {     0");
+    
+      j = 10;
+      for (i = 1; i <= max_user_token_number; i++)
+	{
+	  putc(',', ftable);
+    
+	  if (j >= 10)
+	    {
+	      putc('\n', ftable);
+	      j = 1;
+	    }
+	  else
+	    {
+	      j++;
+	    }
+    
+	  fprintf(ftable, "%6d", token_translations[i]);
+	}
+    
+      fprintf(ftable, "\n};\n");
+    }
+  else
+    {
+      fprintf(ftable, "\n#define YYTRANSLATE(x) (x)\n");
+    } 
+}
+
+
+void
+output_gram()
+{
+  register int i;
+  register int j;
+  register short *sp;
+
+  /* With the ordinary parser,
+     yyprhs and yyrhs are needed only for yydebug.  */
+  if (!semantic_parser)
+    fprintf(ftable, "\n#if YY_%s_DEBUG != 0",parser_name);
+
+  fprintf(ftable, "\nstatic const short yyprhs[] = {     0");
+
+  j = 10;
+  for (i = 1; i <= nrules; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", rrhs[i]);
+    }
+
+  fprintf(ftable, "\n};\n");
+
+  fprintf(ftable, "\nstatic const short yyrhs[] = {%6d", ritem[0]);
+
+  j = 10;
+  for (sp = ritem + 1; *sp; sp++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      if (*sp > 0)
+	fprintf(ftable, "%6d", *sp);
+      else
+	fprintf(ftable, "     0");
+    }
+
+  fprintf(ftable, "\n};\n");
+  if(!semantic_parser)
+    fprintf(ftable, "\n#endif\n");
+
+}
+
+
+void
+output_stos()
+{
+  register int i;
+  register int j;
+
+  fprintf(ftable, "\nstatic const short yystos[] = {     0");
+
+  j = 10;
+  for (i = 1; i < nstates; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", accessing_symbol[i]);
+    }
+
+  fprintf(ftable, "\n};\n");
+}
+
+
+void
+output_rule_data()
+{
+  register int i;
+  register int j;
+
+  fprintf(ftable, 
+     "\n#if (YY_%s_DEBUG != 0) || defined(YY_%s_ERROR_VERBOSE) \nstatic const short yyrline[] = { 0",parser_name,parser_name);
+
+  j = 10;
+  for (i = 1; i <= nrules; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", rline[i]);
+    }
+
+  /* Output the table of symbol names.  */
+
+  fprintf(ftable,
+          "\n};\n\nstatic const char * const yytname[] = {   \"%s\"",
+          tags[0]);
+
+  j = strlen (tags[0]) + 44;
+  for (i = 1; i <= nsyms; i++)
+    {
+      register char *p;
+      putc(',', ftable);
+      j++;
+
+      if (j > 75)
+	{
+	  putc('\n', ftable);
+	  j = 0;
+	}
+
+      putc ('\"', ftable);
+      j++;
+
+      for (p = tags[i]; p && *p; p++)
+	{
+	  if (*p == '"' || *p == '\\')
+	    {
+	      fprintf(ftable, "\\%c", *p);
+	      j += 2;
+	    }
+	  else if (*p == '\n')
+	    {
+	      fprintf(ftable, "\\n");
+	      j += 2;
+	    }
+	  else if (*p == '\t')
+	    {
+	      fprintf(ftable, "\\t");
+	      j += 2;
+	    }
+	  else if (*p == '\b')
+	    {
+	      fprintf(ftable, "\\b");
+	      j += 2;
+	    }
+	  else if (*p < 040 || *p >= 0177)
+	    {
+	      fprintf(ftable, "\\%03o", *p);
+	      j += 4;
+	    }
+	  else
+	    {
+	      putc(*p, ftable);
+	      j++;
+	    }
+	}
+
+      putc ('\"', ftable);
+      j++;
+    }
+
+  fprintf(ftable, "\n};\n#endif\n\nstatic const short yyr1[] = {     0");
+
+  j = 10;
+  for (i = 1; i <= nrules; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", rlhs[i]);
+    }
+
+  FREE(rlhs + 1);
+
+  fprintf(ftable, "\n};\n\nstatic const short yyr2[] = {     0");
+
+  j = 10;
+  for (i = 1; i < nrules; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", rrhs[i + 1] - rrhs[i] - 1);
+    }
+
+  putc(',', ftable);
+  if (j >= 10)
+    putc('\n', ftable);
+
+  fprintf(ftable, "%6d\n};\n", nitems - rrhs[nrules] - 1);
+  FREE(rrhs + 1);
+}
+
+
+void
+output_defines()
+{
+  fprintf(ftable, "\n\n#define\tYYFINAL\t\t%d\n", final_state);
+  fprintf(ftable, "#define\tYYFLAG\t\t%d\n", MINSHORT);
+  fprintf(ftable, "#define\tYYNTBASE\t%d\n", ntokens);
+}
+
+
+
+/* compute and output yydefact, yydefgoto, yypact, yypgoto, yytable and yycheck.  */
+
+void
+output_actions()
+{
+  nvectors = nstates + nvars;
+
+  froms = NEW2(nvectors, short *);
+  tos = NEW2(nvectors, short *);
+  tally = NEW2(nvectors, short);
+  width = NEW2(nvectors, short);
+
+  token_actions();
+  free_shifts();
+  free_reductions();
+  FREE(lookaheads);
+  FREE(LA);
+  FREE(LAruleno);
+  FREE(accessing_symbol);
+
+  goto_actions();
+  FREE(goto_map + ntokens);
+  FREE(from_state);
+  FREE(to_state);
+
+  sort_actions();
+  pack_table();
+  output_base();
+  output_table();
+  output_check();
+}
+
+
+
+/* figure out the actions for the specified state, indexed by lookahead token type.
+
+   The yydefact table is output now.  The detailed info
+   is saved for putting into yytable later.  */
+
+void
+token_actions()
+{
+  register int i;
+  register int j;
+  register int k;
+
+  actrow = NEW2(ntokens, short);
+
+  k = action_row(0);
+  fprintf(ftable, "\nstatic const short yydefact[] = {%6d", k);
+  save_row(0);
+
+  j = 10;
+  for (i = 1; i < nstates; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      k = action_row(i);
+      fprintf(ftable, "%6d", k);
+      save_row(i);
+    }
+
+  fprintf(ftable, "\n};\n");
+  FREE(actrow);
+}
+
+
+
+/* Decide what to do for each type of token if seen as the lookahead token in specified state.
+   The value returned is used as the default action (yydefact) for the state.
+   In addition, actrow is filled with what to do for each kind of token,
+   index by symbol number, with zero meaning do the default action.
+   The value MINSHORT, a very negative number, means this situation
+   is an error.  The parser recognizes this value specially.
+
+   This is where conflicts are resolved.  The loop over lookahead rules
+   considered lower-numbered rules last, and the last rule considered that likes
+   a token gets to handle it.  */
+
+int
+action_row(int state)
+{
+  register int i;
+  register int j;
+  register int k;
+  register int m;
+  register int n;
+  register int count;
+  register int default_rule;
+  register int nreds;
+  register int max;
+  register int rule;
+  register int shift_state;
+  register int symbol;
+  register unsigned mask;
+  register unsigned *wordp;
+  register reductions *redp;
+  register shifts *shiftp;
+  register errs *errp;
+  int nodefault = 0;  /* set nonzero to inhibit having any default reduction */
+
+  for (i = 0; i < ntokens; i++)
+    actrow[i] = 0;
+
+  default_rule = 0;
+  nreds = 0;
+  redp = reduction_table[state];
+
+  if (redp)
+    {
+      nreds = redp->nreds;
+
+      if (nreds >= 1)
+	{
+	  /* loop over all the rules available here which require lookahead */
+	  m = lookaheads[state];
+	  n = lookaheads[state + 1];
+
+	  for (i = n - 1; i >= m; i--)
+	    {
+	      rule = - LAruleno[i];
+	      wordp = LA + i * tokensetsize;
+	      mask = 1;
+
+	      /* and find each token which the rule finds acceptable to come next */
+	      for (j = 0; j < ntokens; j++)
+		{
+		  /* and record this rule as the rule to use if that token follows.  */
+		  if (mask & *wordp)
+		    actrow[j] = rule;
+
+		  mask <<= 1;
+		  if (mask == 0)
+		    {
+		      mask = 1;
+		      wordp++;
+		    }
+		}
+	    }
+	}
+    }
+
+  shiftp = shift_table[state];
+
+  /* now see which tokens are allowed for shifts in this state.
+     For them, record the shift as the thing to do.  So shift is preferred to reduce.  */
+
+  if (shiftp)
+    {
+      k = shiftp->nshifts;
+
+      for (i = 0; i < k; i++)
+	{
+	  shift_state = shiftp->internalShifts[i];
+	  if (! shift_state) continue;
+
+	  symbol = accessing_symbol[shift_state];
+
+	  if (ISVAR(symbol))
+	    break;
+
+	  actrow[symbol] = shift_state;
+
+	  /* do not use any default reduction if there is a shift for error */
+
+	  if (symbol == error_token_number) nodefault = 1;
+	}
+    }
+
+  errp = err_table[state];
+
+  /* See which tokens are an explicit error in this state
+     (due to %nonassoc).  For them, record MINSHORT as the action.  */
+
+  if (errp)
+    {
+      k = errp->nerrs;
+
+      for (i = 0; i < k; i++)
+	{
+	  symbol = errp->internalErrs[i];
+	  actrow[symbol] = MINSHORT;
+	}
+    }
+
+  /* now find the most common reduction and make it the default action for this state.  */
+
+  if (nreds >= 1 && ! nodefault)
+    {
+      if (consistent[state])
+	default_rule = redp->rules[0];
+      else
+	{
+	  max = 0;
+	  for (i = m; i < n; i++)
+	    {
+	      count = 0;
+	      rule = - LAruleno[i];
+    
+	      for (j = 0; j < ntokens; j++)
+		{
+		  if (actrow[j] == rule)
+		    count++;
+		}
+    
+	      if (count > max)
+		{
+		  max = count;
+		  default_rule = rule;
+		}
+	    }
+    
+	  /* actions which match the default are replaced with zero,
+	     which means "use the default" */
+    
+	  if (max > 0)
+	    {
+	      for (j = 0; j < ntokens; j++)
+		{
+		  if (actrow[j] == default_rule)
+		    actrow[j] = 0;
+		}
+    
+	      default_rule = - default_rule;
+	    }
+	}
+    }
+
+  /* If have no default rule, the default is an error.
+     So replace any action which says "error" with "use default".  */
+
+  if (default_rule == 0)
+    for (j = 0; j < ntokens; j++)
+      {
+	if (actrow[j] == MINSHORT)
+	  actrow[j] = 0;
+      }
+
+  return (default_rule);
+}
+
+
+void
+save_row(int state)
+{
+  register int i;
+  register int count;
+  register short *sp;
+  register short *sp1;
+  register short *sp2;
+
+  count = 0;
+  for (i = 0; i < ntokens; i++)
+    {
+      if (actrow[i] != 0)
+	count++;
+    }
+
+  if (count == 0)
+    return;
+
+  froms[state] = sp1 = sp = NEW2(count, short);
+  tos[state] = sp2 = NEW2(count, short);
+
+  for (i = 0; i < ntokens; i++)
+    {
+      if (actrow[i] != 0)
+	{
+	  *sp1++ = i;
+	  *sp2++ = actrow[i];
+	}
+    }
+
+  tally[state] = count;
+  width[state] = sp1[-1] - sp[0] + 1;
+}
+
+
+
+/* figure out what to do after reducing with each rule,
+   depending on the saved state from before the beginning
+   of parsing the data that matched this rule.
+
+   The yydefgoto table is output now.  The detailed info
+   is saved for putting into yytable later.  */
+
+void
+goto_actions()
+{
+  register int i;
+  register int j;
+  register int k;
+
+  state_count = NEW2(nstates, short);
+
+  k = default_goto(ntokens);
+  fprintf(ftable, "\nstatic const short yydefgoto[] = {%6d", k);
+  save_column(ntokens, k);
+
+  j = 10;
+  for (i = ntokens + 1; i < nsyms; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      k = default_goto(i);
+      fprintf(ftable, "%6d", k);
+      save_column(i, k);
+    }
+
+  fprintf(ftable, "\n};\n");
+  FREE(state_count);
+}
+
+
+
+int
+default_goto(int symbol)
+{
+  register int i;
+  register int m;
+  register int n;
+  register int default_state;
+  register int max;
+
+  m = goto_map[symbol];
+  n = goto_map[symbol + 1];
+
+  if (m == n)
+    return (-1);
+
+  for (i = 0; i < nstates; i++)
+    state_count[i] = 0;
+
+  for (i = m; i < n; i++)
+    state_count[to_state[i]]++;
+
+  max = 0;
+  default_state = -1;
+
+  for (i = 0; i < nstates; i++)
+    {
+      if (state_count[i] > max)
+	{
+	  max = state_count[i];
+	  default_state = i;
+	}
+    }
+
+  return (default_state);
+}
+
+
+void
+save_column(int symbol, int default_state)
+{
+  register int i;
+  register int m;
+  register int n;
+  register short *sp;
+  register short *sp1;
+  register short *sp2;
+  register int count;
+  register int symno;
+
+  m = goto_map[symbol];
+  n = goto_map[symbol + 1];
+
+  count = 0;
+  for (i = m; i < n; i++)
+    {
+      if (to_state[i] != default_state)
+	count++;
+    }
+
+  if (count == 0)
+    return;
+
+  symno = symbol - ntokens + nstates;
+
+  froms[symno] = sp1 = sp = NEW2(count, short);
+  tos[symno] = sp2 = NEW2(count, short);
+
+  for (i = m; i < n; i++)
+    {
+      if (to_state[i] != default_state)
+	{
+	  *sp1++ = from_state[i];
+	  *sp2++ = to_state[i];
+	}
+    }
+
+  tally[symno] = count;
+  width[symno] = sp1[-1] - sp[0] + 1;
+}
+
+
+
+/* the next few functions decide how to pack 
+   the actions and gotos information into yytable. */
+
+void
+sort_actions()
+{
+  register int i;
+  register int j;
+  register int k;
+  register int t;
+  register int w;
+
+  order = NEW2(nvectors, short);
+  nentries = 0;
+
+  for (i = 0; i < nvectors; i++)
+    {
+      if (tally[i] > 0)
+	{
+	  t = tally[i];
+	  w = width[i];
+	  j = nentries - 1;
+
+	  while (j >= 0 && (width[order[j]] < w))
+	    j--;
+
+	  while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t))
+	    j--;
+
+	  for (k = nentries - 1; k > j; k--)
+	    order[k + 1] = order[k];
+
+	  order[j + 1] = i;
+	  nentries++;
+	}
+    }
+}
+
+
+void
+pack_table()
+{
+  register int i;
+  register int place;
+  register int state;
+
+  base = NEW2(nvectors, short);
+  pos = NEW2(nentries, short);
+  table = NEW2(MAXTABLE, short);
+  check = NEW2(MAXTABLE, short);
+
+  lowzero = 0;
+  high = 0;
+
+  for (i = 0; i < nvectors; i++)
+    base[i] = MINSHORT;
+
+  for (i = 0; i < MAXTABLE; i++)
+    check[i] = -1;
+
+  for (i = 0; i < nentries; i++)
+    {
+      state = matching_state(i);
+
+      if (state < 0)
+	place = pack_vector(i);
+      else
+	place = base[state];
+
+      pos[i] = place;
+      base[order[i]] = place;
+    }
+
+  for (i = 0; i < nvectors; i++)
+    {
+      if (froms[i])
+	FREE(froms[i]);
+      if (tos[i])
+	FREE(tos[i]);
+    }
+
+  FREE(froms);
+  FREE(tos);
+  FREE(pos);
+}
+
+
+
+int
+matching_state(int vector)
+{
+  register int i;
+  register int j;
+  register int k;
+  register int t;
+  register int w;
+  register int match;
+  register int prev;
+
+  i = order[vector];
+  if (i >= nstates)
+    return (-1);
+
+  t = tally[i];
+  w = width[i];
+
+  for (prev = vector - 1; prev >= 0; prev--)
+    {
+      j = order[prev];
+      if (width[j] != w || tally[j] != t)
+	return (-1);
+
+      match = 1;
+      for (k = 0; match && k < t; k++)
+	{
+	  if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k])
+	    match = 0;
+	}
+
+      if (match)
+	return (j);
+    }
+
+  return (-1);
+}
+
+
+
+int
+pack_vector(int vector)
+{
+  register int i;
+  register int j;
+  register int k;
+  register int t;
+  register int loc;
+  register int ok;
+  register short *from;
+  register short *to;
+
+  i = order[vector];
+  t = tally[i];
+
+  if (t == 0)
+    berror("pack_vector");
+
+  from = froms[i];
+  to = tos[i];
+
+  for (j = lowzero - from[0]; j < MAXTABLE; j++)
+    {
+      ok = 1;
+
+      for (k = 0; ok && k < t; k++)
+	{
+	  loc = j + from[k];
+	  if (loc > MAXTABLE)
+	    fatals("maximum table size (%d) exceeded",(void*) MAXTABLE);
+
+	  if (table[loc] != 0)
+	    ok = 0;
+	}
+
+      for (k = 0; ok && k < vector; k++)
+	{
+	  if (pos[k] == j)
+	    ok = 0;
+	}
+
+      if (ok)
+	{
+	  for (k = 0; k < t; k++)
+	    {
+	      loc = j + from[k];
+	      table[loc] = to[k];
+	      check[loc] = from[k];
+	    }
+
+	  while (table[lowzero] != 0)
+	    lowzero++;
+
+	  if (loc > high)
+	    high = loc;
+
+	  return (j);
+	}
+    }
+
+  berror("pack_vector");
+  return 0;	/* JF keep lint happy */
+}
+
+
+
+/* the following functions output yytable, yycheck
+   and the vectors whose elements index the portion starts */
+
+void
+output_base()
+{
+  register int i;
+  register int j;
+
+  fprintf(ftable, "\nstatic const short yypact[] = {%6d", base[0]);
+
+  j = 10;
+  for (i = 1; i < nstates; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", base[i]);
+    }
+
+  fprintf(ftable, "\n};\n\nstatic const short yypgoto[] = {%6d", base[nstates]);
+
+  j = 10;
+  for (i = nstates + 1; i < nvectors; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", base[i]);
+    }
+
+  fprintf(ftable, "\n};\n");
+  FREE(base);
+}
+
+
+void
+output_table()
+{
+  register int i;
+  register int j;
+
+  fprintf(ftable, "\n\n#define\tYYLAST\t\t%d\n\n", high);
+  fprintf(ftable, "\nstatic const short yytable[] = {%6d", table[0]);
+
+  j = 10;
+  for (i = 1; i <= high; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", table[i]);
+    }
+
+  fprintf(ftable, "\n};\n");
+  FREE(table);
+}
+
+
+void
+output_check()
+{
+  register int i;
+  register int j;
+
+  fprintf(ftable, "\nstatic const short yycheck[] = {%6d", check[0]);
+
+  j = 10;
+  for (i = 1; i <= high; i++)
+    {
+      putc(',', ftable);
+
+      if (j >= 10)
+	{
+	  putc('\n', ftable);
+	  j = 1;
+	}
+      else
+	{
+	  j++;
+	}
+
+      fprintf(ftable, "%6d", check[i]);
+    }
+
+  fprintf(ftable, "\n};\n");
+  FREE(check);
+}
+
+
+
+/* copy the parser code into the ftable file at the end.  */
+
+void
+ output_parser()
+{
+ register int c;
+ output_section(fparser,ftable);
+ rewind(faction);
+ for(c=getc(faction);c!=EOF;c=getc(faction))
+		putc(c,ftable);
+ output_section(fparser,ftable);
+}
+void
+output_section(FILE* fin,FILE* fout)
+{
+  register int c;
+  int dummy;
+  int *pcounter=&dummy;
+  char *fil_name;
+  fil_name="?";
+  if(fin==fparser) 
+   {pcounter=&line_fparser;fil_name=parser_fname;}
+  else if(fin==fhskel) 
+   {pcounter=&line_fhskel;fil_name=hskel_fname;}
+  /* Loop over lines in the standard parser file.  */
+  if (!nolinesflag)
+    fprintf(fout, "\n#line %d \"%s\"\n", (*pcounter), quoted_filename(fil_name));
+
+  while (1)
+    {
+      
+
+      /* now write out the line... */
+      for ( c = getc(fin); c != '\n' && c != EOF; c = getc(fin))
+	  {if (c == '$')
+	    {
+  	    if (!nolinesflag)
+   		{//something is wrong                "\n/* #line %d \"%s\" */\n#line @\n",
+		  fprintf(fout, "\n #line %d \"%s\"\n", (*pcounter), quoted_filename(fil_name));
+                }
+	      return;
+	    }
+           else if(c=='@')
+	    {fprintf(fout,"%s",parser_name);
+	    }
+	   else
+	    putc(c, fout);
+          }
+      if (c == EOF)
+	break;
+      else if(c=='\n') (*pcounter)++;
+      putc(c, fout);
+    }
+}
+
+
+void
+output_program()
+{
+  register int c;
+  extern int lineno;
+  int is_escaped=0,is_commented=0;
+  char quoted='\0',last='\0';
+  int len_match=0,i;
+  char *match_open="%header{";
+  char *match_close="%}";
+  char *match_wait=match_open;
+  if (!nolinesflag)
+    fprintf(ftable, "#line %d \"%s\"\n", lineno, quoted_filename(infile));
+
+  
+  for (c = getc(finput);c != EOF;last=c,c = getc(finput))
+    {
+     if(!match_wait[len_match])
+       {if(match_wait==match_open)
+         {match_wait=match_close;
+          if (!nolinesflag && definesflag)
+	   fprintf(fdefines, "\n#line %d \"%s\"\n", lineno, quoted_filename(infile));
+
+         }
+        else 
+         {match_wait=match_open;}
+        len_match=0;
+       }
+     else if(c!=match_wait[len_match] || is_escaped || is_commented || quoted)
+       {for(i=0;i<len_match;i++)
+          {if(match_wait==match_close && definesflag)
+             putc(match_wait[i],fdefines);
+           putc(match_wait[i],ftable);}
+         len_match=0;
+       };
+     if(c==match_wait[len_match] && !is_escaped && !is_commented && !quoted) 
+       {len_match++;}
+     else
+       {if(match_wait==match_close && definesflag)
+          putc(c,fdefines);
+        putc(c,ftable);
+       }
+     if(c=='\n') lineno++;
+     if(is_escaped)
+       {is_escaped=0;}
+     else if(c=='\\') 
+         {is_escaped=1;}
+     else if(is_commented==1) 
+       {if(last=='*' && c=='/') 
+         is_commented=0;}
+     else if(is_commented==2) 
+       {if(c=='\n') 
+         is_commented=0;}
+     else if((c=='"'|| c== '\'')) 
+         {if(!quoted) quoted=c;
+          else if(quoted==c) quoted='\0';
+         }
+     else if(quoted) {}
+     else if(last=='/' && c=='*') is_commented=1;
+     else if(last=='/' && c=='/') is_commented=2;
+     
+      
+    }
+}
+
+
+void
+free_itemsets()
+{
+  register core *cp,*cptmp;
+
+  FREE(state_table);
+
+  for (cp = first_state; cp; cp = cptmp) {
+    cptmp=cp->next;
+    FREE(cp);
+  }
+}
+
+
+void
+free_shifts()
+{
+  register shifts *sp,*sptmp;/* JF derefrenced freed ptr */
+
+  FREE(shift_table);
+
+  for (sp = first_shift; sp; sp = sptmp) {
+    sptmp=sp->next;
+    FREE(sp);
+  }
+}
+
+
+void
+free_reductions()
+{
+  register reductions *rp,*rptmp;/* JF fixed freed ptr */
+
+  FREE(reduction_table);
+
+  for (rp = first_reduction; rp; rp = rptmp) {
+    rptmp=rp->next;
+    FREE(rp);
+  }
+}
+void output_token_defines();
+void output_token_const_def();
+void output_token_const_decl();
+
+void output_about_token()
+{ register int i;
+ 
+  output_section(fparser,ftable);
+  output_token_defines(ftable);
+  output_section(fparser,ftable);
+  output_token_const_decl(ftable);
+  output_section(fparser,ftable);  /* new section */
+  output_token_enum(ftable); /* enum */
+  output_section(fparser,ftable);
+  output_token_const_def(ftable);
+  output_section(fparser,ftable);
+  if (definesflag)
+    {
+      output_section(fhskel,fdefines);
+      output_token_defines(fdefines);
+      output_section(fhskel,fdefines);
+      output_token_const_decl(fdefines);
+      output_section(fhskel,fdefines);  /* new section */
+      output_token_enum(fdefines); /* enum */
+      output_section(fhskel,fdefines);
+      if (semantic_parser)
+	for (i = ntokens; i < nsyms; i++)
+	  {
+	    /* don't make these for dummy nonterminals made by gensym.  */
+	    if (*tags[i] != '@')
+	      fprintf(fdefines, "#define\tNT%s\t%d\n", tags[i], i);
+	  }
+    }
+
+};
+void output_token_defines(FILE* file)
+{output_token_defines_fmt(file,"#define\t%s\t%d\n",0);
+ if (semantic_parser)
+  output_token_defines_fmt(file,"#define\tT%s\t%d\n",1);
+};
+void output_token_const_def(FILE* file)
+{char line[256];
+ sprintf(line,"const int YY_%s_CLASS::%%s=%%d;\n",parser_name);
+ output_token_defines_fmt(file,line,0);
+ sprintf(line,"const int YY_%s_CLASS::T%%s=%%d;\n",parser_name);
+ if (semantic_parser)
+  output_token_defines_fmt(file,line,1);
+};
+void output_token_const_decl(FILE* file)
+{char line[256];
+ output_token_defines_fmt(file,"static const int %s;\n",0);
+ if (semantic_parser)
+  output_token_defines_fmt(file,"static const int T%s;\n",1);
+};
+/* create a list like 
+	,FIRST_TOKEN=256
+	,SECOND_TOKEN=257
+*/
+void output_token_enum(FILE* file)
+{
+ output_token_defines_fmt(file,"\t,%s=%d\n",0);
+ if (semantic_parser) /* just for compatibility with semantic parser */
+  output_token_defines_fmt(file,"\t,T%s=%d\n",1);
+};
+
+
+void
+output_token_defines_fmt(FILE* file,char* fmt,int notrans)
+{
+  bucket *bp;
+
+  for (bp = firstsymbol; bp; bp = bp->next)
+    {
+      if (bp->value >= ntokens) continue;
+
+      /* For named tokens, but not literal ones, define the name.  */
+      /* The value is the user token number.  */
+
+      if ('\'' != *tags[bp->value] && bp != errtoken)
+	{
+	  register char *cp = tags[bp->value];
+	  register char c;
+
+	  /* Don't #define nonliteral tokens whose names contain periods.  */
+
+	  while ((c = *cp++) && c != '.');
+	  if (!c)
+	    {
+              fprintf(file, fmt, tags[bp->value],
+			    (translations && !notrans ? bp->user_token_number : bp->value));
+	    }
+	}
+    }
+
+  putc('\n', file);
+}
+
+
+char *quoted_filename(char* f)
+{
+ static char *buffer=NULL;
+ static int buff_size=0;
+ char *p;
+ if(buff_size<strlen(f)*2+1)
+  {
+   if(buffer !=NULL ) free(buffer);
+   buffer=xmalloc(strlen(f)*2+1);
+  }
+ for(p=buffer;*f;f++)
+  {if(*f=='\\')
+    *p++ ='\\';
+   *p++ =*f;
+  }
+ *p++='\0';
+ return buffer;
+}