aboutsummaryrefslogtreecommitdiff
path: root/tools/bison++/output.cc
diff options
context:
space:
mode:
Diffstat (limited to 'tools/bison++/output.cc')
-rw-r--r--tools/bison++/output.cc1663
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;
+}