#include "defs.h"

Include dependency graph for mkpar.c:

Functions
action *	parse_actions ()

action *	get_shifts ()

action *	add_reductions ()

action *	add_reduce ()

	make_parser ()

action *	parse_actions (int stateno)

action *	get_shifts (int stateno)

action *	add_reductions (int stateno, action *actions)

action *	add_reduce (action *actions, int ruleno, int symbol)

	find_final_state ()

	unused_rules ()

	remove_conflicts ()

	total_conflicts ()

int	sole_reduction (int stateno)

	defreds ()

	free_action_row (action *p)

	free_parser ()

Variables
action **	parser

int	SRtotal

int	RRtotal

short *	SRconflicts

short *	RRconflicts

short *	defred

short *	rules_used

short	nunused

short	final_state

static int	SRcount

static int	RRcount

Function Documentation

action* add_reduce ( )

Referenced by add_reductions().

Here is the caller graph for this function:

action* add_reduce	(	action *	actions,
		int	ruleno,
		int	symbol
	)

Definition at line 113 of file mkpar.c.

References action::action_code, action::assoc, NEW, shorts::next, action::next, action::number, action::prec, rassoc, REDUCE, rprec, SHIFT, and action::symbol.

 {
     register action *temp, *prev, *next;
 
     prev = 0;
     for (next = actions; next && next->symbol < symbol; next = next->next)
         prev = next;
 
     while (next && next->symbol == symbol && next->action_code == SHIFT)
     {
         prev = next;
         next = next->next;
     }
 
     while (next && next->symbol == symbol &&
            next->action_code == REDUCE && next->number < ruleno)
     {
         prev = next;
         next = next->next;
     }
 
     temp = NEW(action);
     temp->next = next;
     temp->symbol = symbol;
     temp->number = ruleno;
     temp->prec = rprec[ruleno];
     temp->action_code = REDUCE;
     temp->assoc = rassoc[ruleno];
 
     if (prev)
         prev->next = temp;
     else
         actions = temp;
 
     return (actions);
 }

action* add_reductions ( )

Referenced by parse_actions().

Here is the caller graph for this function:

action* add_reductions	(	int	stateno,
		action *	actions
	)

Definition at line 87 of file mkpar.c.

References add_reduce(), BIT, LA, LAruleno, lookaheads, ntokens, tokensetsize, and WORDSIZE.

 {
     register int i, j, m, n;
     register int ruleno, tokensetsize;
     register unsigned *rowp;
 
     tokensetsize = WORDSIZE(ntokens);
     m = lookaheads[stateno];
     n = lookaheads[stateno + 1];
     for (i = m; i < n; i++)
     {
         ruleno = LAruleno[i];
         rowp = LA + i * tokensetsize;
         for (j = ntokens - 1; j >= 0; j--)
         {
             if (BIT(rowp, j))
                 actions = add_reduce(actions, ruleno, j);
         }
     }
     return (actions);
 }

Here is the call graph for this function:

defreds ( )

Definition at line 326 of file mkpar.c.

References defred, NEW2, nstates, and sole_reduction().

Referenced by make_parser().

 {
     register int i;
 
     defred = NEW2(nstates, short);
     for (i = 0; i < nstates; i++)
         defred[i] = sole_reduction(i);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

find_final_state ( )

Definition at line 153 of file mkpar.c.

References accessing_symbol, final_state, goal, shifts::nshifts, ritem, shifts::shift, shift_table, and to_state.

Referenced by make_parser().

 {
     register int goal, i;
     register short *to_state;
     register shifts *p;
 
     p = shift_table[0];
     to_state = p->shift;
     goal = ritem[1];
     for (i = p->nshifts - 1; i >= 0; --i)
     {
         final_state = to_state[i];
         if (accessing_symbol[final_state] == goal) break;
     }
 }

Here is the caller graph for this function:

free_action_row ( action * p )

Definition at line 335 of file mkpar.c.

References FREE, and action::next.

Referenced by free_parser().

 {
     register action *q;
 
     while (p)
     {
         q = p->next;
         FREE(p);
         p = q;
     }
 }

Here is the caller graph for this function:

free_parser ( )

Definition at line 348 of file mkpar.c.

References FREE, free_action_row(), and nstates.

Referenced by output().

 {
     register int i;
 
     for (i = 0; i < nstates; i++)
         free_action_row(parser[i]);
 
     FREE(parser);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

action* get_shifts ( )

Referenced by parse_actions().

Here is the caller graph for this function:

action* get_shifts ( int stateno )

Definition at line 52 of file mkpar.c.

References accessing_symbol, action::action_code, action::assoc, ISTOKEN, NEW, action::next, shifts::nshifts, action::number, action::prec, SHIFT, shifts::shift, shift_table, action::symbol, symbol_assoc, symbol_prec, and to_state.

 {
     register action *actions, *temp;
     register shifts *sp;
     register short *to_state;
     register int i, k;
     register int symbol;
 
     actions = 0;
     sp = shift_table[stateno];
     if (sp)
     {
         to_state = sp->shift;
         for (i = sp->nshifts - 1; i >= 0; i--)
         {
             k = to_state[i];
             symbol = accessing_symbol[k];
             if (ISTOKEN(symbol))
             {
                 temp = NEW(action);
                 temp->next = actions;
                 temp->symbol = symbol;
                 temp->number = k;
                 temp->prec = symbol_prec[symbol];
                 temp->action_code = SHIFT;
                 temp->assoc = symbol_assoc[symbol];
                 actions = temp;
             }
         }
     }
     return (actions);
 }

make_parser ( )

Definition at line 23 of file mkpar.c.

References defreds(), find_final_state(), NEW2, nstates, parse_actions(), remove_conflicts(), RRtotal, SRtotal, total_conflicts(), and unused_rules().

Referenced by main().

 {
     register int i;
 
     parser = NEW2(nstates, action *);
     for (i = 0; i < nstates; i++)
         parser[i] = parse_actions(i);
 
     find_final_state();
     remove_conflicts();
     unused_rules();
     if (SRtotal + RRtotal > 0) total_conflicts();
     defreds();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

action* parse_actions ( )

Referenced by make_parser().

Here is the caller graph for this function:

action* parse_actions ( int stateno )

Definition at line 40 of file mkpar.c.

References add_reductions(), and get_shifts().

 {
     register action *actions;
 
     actions = get_shifts(stateno);
     actions = add_reductions(stateno, actions);
     return (actions);
 }

Here is the call graph for this function:

remove_conflicts ( )

Definition at line 202 of file mkpar.c.

References action::action_code, action::assoc, final_state, LEFT, NEW2, action::next, nstates, action::prec, RIGHT, RRconflicts, RRcount, RRtotal, SHIFT, SRconflicts, SRcount, SRtotal, action::suppressed, and action::symbol.

Referenced by make_parser().

 {
     register int i;
     register int symbol;
     register action *p, *pref;
 
     SRtotal = 0;
     RRtotal = 0;
     SRconflicts = NEW2(nstates, short);
     RRconflicts = NEW2(nstates, short);
     for (i = 0; i < nstates; i++)
     {
         SRcount = 0;
         RRcount = 0;
         symbol = -1;
         for (p = parser[i]; p; p = p->next)
         {
             if (p->symbol != symbol)
             {
                 pref = p;
                 symbol = p->symbol;
             }
             else if (i == final_state && symbol == 0)
             {
                 SRcount++;
                 p->suppressed = 1;
             }
             else if (pref->action_code == SHIFT)
             {
                 if (pref->prec > 0 && p->prec > 0)
                 {
                     if (pref->prec < p->prec)
                     {
                         pref->suppressed = 2;
                         pref = p;
                     }
                     else if (pref->prec > p->prec)
                     {
                         p->suppressed = 2;
                     }
                     else if (pref->assoc == LEFT)
                     {
                         pref->suppressed = 2;
                         pref = p;
                     }
                     else if (pref->assoc == RIGHT)
                     {
                         p->suppressed = 2;
                     }
                     else
                     {
                         pref->suppressed = 2;
                         p->suppressed = 2;
                     }
                 }
                 else
                 {
                     SRcount++;
                     p->suppressed = 1;
                 }
             }
             else
             {
                 RRcount++;
                 p->suppressed = 1;
             }
         }
         SRtotal += SRcount;
         RRtotal += RRcount;
         SRconflicts[i] = SRcount;
         RRconflicts[i] = RRcount;
     }
 }

Here is the caller graph for this function:

int sole_reduction ( int stateno )

Definition at line 298 of file mkpar.c.

References action::action_code, action::next, action::number, REDUCE, SHIFT, action::suppressed, and action::symbol.

Referenced by defreds().

 {
     register int count, ruleno;
     register action *p;
 
     count = 0;
     ruleno = 0; 
     for (p = parser[stateno]; p; p = p->next)
     {
         if (p->action_code == SHIFT && p->suppressed == 0)
             return (0);
         else if (p->action_code == REDUCE && p->suppressed == 0)
         {
             if (ruleno > 0 && p->number != ruleno)
                 return (0);
             if (p->symbol != 1)
                 ++count;
             ruleno = p->number;
         }
     }
 
     if (count == 0)
         return (0);
     return (ruleno);
 }

Here is the caller graph for this function:

total_conflicts ( )

Definition at line 277 of file mkpar.c.

References myname, RRtotal, and SRtotal.

Referenced by make_parser().

 {
     fprintf(stderr, "%s: ", myname);
     if (SRtotal == 1)
         fprintf(stderr, "1 shift/reduce conflict");
     else if (SRtotal > 1)
         fprintf(stderr, "%d shift/reduce conflicts", SRtotal);
 
     if (SRtotal && RRtotal)
         fprintf(stderr, ", ");
 
     if (RRtotal == 1)
         fprintf(stderr, "1 reduce/reduce conflict");
     else if (RRtotal > 1)
         fprintf(stderr, "%d reduce/reduce conflicts", RRtotal);
 
     fprintf(stderr, ".\n");
 }

Here is the caller graph for this function:

unused_rules ( )

Definition at line 170 of file mkpar.c.

References action::action_code, MALLOC, myname, action::next, no_space(), nrules, nstates, action::number, nunused, REDUCE, rules_used, and action::suppressed.

Referenced by make_parser().

 {
     register int i;
     register action *p;
 
     rules_used = (short *) MALLOC(nrules*sizeof(short));
     if (rules_used == 0) no_space();
 
     for (i = 0; i < nrules; ++i)
         rules_used[i] = 0;
 
     for (i = 0; i < nstates; ++i)
     {
         for (p = parser[i]; p; p = p->next)
         {
             if (p->action_code == REDUCE && p->suppressed == 0)
                 rules_used[p->number] = 1;
         }
     }
 
     nunused = 0;
     for (i = 3; i < nrules; ++i)
         if (!rules_used[i]) ++nunused;
 
     if (nunused)
         if (nunused == 1)
             fprintf(stderr, "%s: 1 rule never reduced\n", myname);
         else
             fprintf(stderr, "%s: %d rules never reduced\n", myname, nunused);
 }