lalr.c File Reference

#include "defs.h"

Include dependency graph for lalr.c:

Go to the source code of this file.

Data Structures
struct	shorts

Typedefs
typedef struct shorts	shorts

Functions
short **	transpose ()
	lalr ()
	set_state_table ()
	set_accessing_symbol ()
	set_shift_table ()
	set_reduction_table ()
	set_maxrhs ()
	initialize_LA ()
	set_goto_map ()
int	map_goto (int state, int symbol)
	initialize_F ()
	build_relations ()
	add_lookback_edge (int stateno, int ruleno, int gotono)
short **	transpose (short **R, int n)
	compute_FOLLOWS ()
	compute_lookaheads ()
	digraph (short **relation)
	traverse (int i)

Variables
int	tokensetsize
short *	lookaheads
short *	LAruleno
unsigned *	LA
short *	accessing_symbol
core **	state_table
shifts **	shift_table
reductions **	reduction_table
short *	goto_map
short *	from_state
short *	to_state
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

Typedef Documentation

typedef struct shorts shorts

Function Documentation

add_lookback_edge	(	int	stateno,
		int	ruleno,
		int	gotono
	)

Definition at line 432 of file lalr.c.

References LAruleno, lookaheads, NEW, shorts::next, and shorts::value.

Referenced by build_relations().

{
    register int i, 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;
    }
    assert(found);

    sp = NEW(shorts);
    sp->next = lookback[i];
    sp->value = gotono;
    lookback[i] = sp;
}

Here is the caller graph for this function:

build_relations

(

)

Definition at line 340 of file lalr.c.

References accessing_symbol, add_lookback_edge(), derives, done(), FREE, from_state, includes, ISVAR, map_goto(), maxrhs, NEW2, ngotos, shifts::nshifts, nullable, ritem, rrhs, shifts::shift, to_state, and transpose().

Referenced by lalr().

{
    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->shift[j];
                    if (accessing_symbol[stateno] == symbol2) break;
                }

                states[length++] = stateno;
            }

            add_lookback_edge(stateno, *rulep, i);

            length--;
            done = 0;
            while (!done)
            {
                done = 1;
                rp--;
                if (ISVAR(*rp))
                {
                    stateno = states[--length];
                    edge[nedges++] = map_goto(stateno, *rp);
                    if (nullable[*rp] && length > 0) 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

compute_FOLLOWS

(

)

Definition at line 517 of file lalr.c.

References digraph(), and includes.

Referenced by lalr().

{
    digraph(includes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

compute_lookaheads

(

)

Definition at line 523 of file lalr.c.

References F, FREE, LA, lookaheads, shorts::next, nstates, tokensetsize, and shorts::value.

Referenced by lalr().

{
    register int i, n;
    register unsigned *fp1, *fp2, *fp3;
    register shorts *sp, *next;
    register unsigned *rowp;

    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++)
        for (sp = lookback[i]; sp; sp = next)
        {
            next = sp->next;
            FREE(sp);
        }

    FREE(lookback);
    FREE(F);
}

Here is the caller graph for this function:

digraph

(

short **

relation

)

Definition at line 557 of file lalr.c.

References FREE, INDEX, infinity, NEW2, ngotos, R, top, traverse(), and VERTICES.

Referenced by compute_FOLLOWS(), and initialize_F().

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_F

(

)

Definition at line 263 of file lalr.c.

References accessing_symbol, digraph(), F, FREE, ISVAR, map_goto(), NEW2, ngotos, shifts::nshifts, nullable, SETBIT, shifts::shift, to_state, and tokensetsize.

Referenced by lalr().

{
    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->shift[j]];
                if (ISVAR(symbol))
                    break;
                SETBIT(rowp, symbol);
            }

            for (; j < k; j++)
            {
                symbol = accessing_symbol[sp->shift[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;
    }

    SETBIT(F, 0);
    digraph(reads);

    for (i = 0; i < ngotos; i++)
    {
        if (reads[i])
            FREE(reads[i]);
    }

    FREE(reads);
    FREE(edge);
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_LA

(

)

Definition at line 128 of file lalr.c.

References LA, LAruleno, lookaheads, NEW2, reductions::nreds, nstates, reductions::rules, and tokensetsize.

Referenced by lalr().

{
    register int i, j, k;
    register reductions *rp;

    lookaheads = NEW2(nstates + 1, short);

    k = 0;
    for (i = 0; i < nstates; i++)
    {
        lookaheads[i] = k;
        rp = reduction_table[i];
        if (rp)
            k += rp->nreds;
    }
    lookaheads[nstates] = k;

    LA = NEW2(k * tokensetsize, unsigned);
    LAruleno = NEW2(k, short);
    lookback = NEW2(k, shorts *);

    k = 0;
    for (i = 0; i < nstates; i++)
    {
        rp = reduction_table[i];
        if (rp)
        {
            for (j = 0; j < rp->nreds; j++)
            {
                LAruleno[k] = rp->rules[j];
                k++;
            }
        }
    }
}

Here is the caller graph for this function:

lalr

(

)

Definition at line 37 of file lalr.c.

References build_relations(), compute_FOLLOWS(), compute_lookaheads(), initialize_F(), initialize_LA(), ntokens, set_accessing_symbol(), set_goto_map(), set_maxrhs(), set_reduction_table(), set_shift_table(), set_state_table(), tokensetsize, and WORDSIZE.

Referenced by main().

{
    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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

int map_goto	(	int	state,
		int	symbol
	)

Definition at line 235 of file lalr.c.

References from_state, goto_map, and high.

Referenced by build_relations(), and initialize_F().

{
    register int high;
    register int low;
    register int middle;
    register int s;

    low = goto_map[symbol];
    high = goto_map[symbol + 1];

    for (;;)
    {
        assert(low <= high);
        middle = (low + high) >> 1;
        s = from_state[middle];
        if (s == state)
            return (middle);
        else if (s < state)
            low = middle + 1;
        else
            high = middle - 1;
    }
}

Here is the caller graph for this function:

set_accessing_symbol

(

)

Definition at line 67 of file lalr.c.

References accessing_symbol, core::accessing_symbol, first_state, NEW2, core::next, nstates, and core::number.

Referenced by lalr().

{
    register core *sp;

    accessing_symbol = NEW2(nstates, short);
    for (sp = first_state; sp; sp = sp->next)
        accessing_symbol[sp->number] = sp->accessing_symbol;
}

Here is the caller graph for this function:

set_goto_map

(

)

Definition at line 165 of file lalr.c.

References accessing_symbol, fatal(), first_shift, FREE, from_state, goto_map, ISTOKEN, MAXSHORT, NEW2, shifts::next, ngotos, shifts::nshifts, nsyms, ntokens, shifts::number, nvars, shifts::shift, and to_state.

Referenced by lalr().

{
    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->shift[i]];

            if (ISTOKEN(symbol)) break;

            if (ngotos == MAXSHORT)
            fatal("too many 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->shift[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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_maxrhs

(

)

Definition at line 100 of file lalr.c.

References maxrhs, nitems, and ritem.

Referenced by lalr().

{
    register short *itemp;
    register short *item_end;
    register int length;
    register int max;

    length = 0;
    max = 0;
    item_end = ritem + nitems;
    for (itemp = ritem; itemp < item_end; itemp++)
    {
        if (*itemp >= 0)
        {
            length++;
        }
        else
        {
            if (length > max) max = length;
            length = 0;
        }
    }

    maxrhs = max;
}

Here is the caller graph for this function:

set_reduction_table

(

)

Definition at line 89 of file lalr.c.

References first_reduction, NEW2, reductions::next, nstates, and reductions::number.

Referenced by lalr().

{
    register reductions *rp;

    reduction_table = NEW2(nstates, reductions *);
    for (rp = first_reduction; rp; rp = rp->next)
        reduction_table[rp->number] = rp;
}

Here is the caller graph for this function:

set_shift_table

(

)

Definition at line 78 of file lalr.c.

References first_shift, NEW2, shifts::next, nstates, and shifts::number.

Referenced by lalr().

{
    register shifts *sp;

    shift_table = NEW2(nstates, shifts *);
    for (sp = first_shift; sp; sp = sp->next)
        shift_table[sp->number] = sp;
}

Here is the caller graph for this function:

set_state_table

(

)

Definition at line 56 of file lalr.c.

References first_state, NEW2, core::next, nstates, and core::number.

Referenced by lalr().

{
    register core *sp;

    state_table = NEW2(nstates, core *);
    for (sp = first_state; sp; sp = sp->next)
        state_table[sp->number] = sp;
}

Here is the caller graph for this function:

short** transpose

(

)

Referenced by build_relations().

Here is the caller graph for this function:

short** transpose	(	short **	R,
		int	n
	)

Definition at line 460 of file lalr.c.

References FREE, and NEW2.

{
    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[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[i];
        if (sp)
        {
            while (*sp >= 0)
                *temp_R[*sp++]++ = i;
        }
    }

    FREE(temp_R);

    return (new_R);
}

traverse

(

int

i

)

Definition at line 584 of file lalr.c.

References base, F, INDEX, infinity, R, tokensetsize, top, and VERTICES.

Referenced by digraph().

{
    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++;
        }
    }
}

Here is the caller graph for this function:

Variable Documentation

short* accessing_symbol

Definition at line 15 of file lalr.c.

Referenced by build_relations(), find_final_state(), get_shifts(), initialize_F(), output_actions(), print_actions(), print_gotos(), set_accessing_symbol(), and set_goto_map().

unsigned* F

static

Definition at line 28 of file lalr.c.

Referenced by compute_lookaheads(), initialize_F(), and traverse().

short* from_state

Definition at line 20 of file lalr.c.

Referenced by build_relations(), map_goto(), output_actions(), save_column(), and set_goto_map().

short* goto_map

Definition at line 19 of file lalr.c.

Referenced by default_goto(), map_goto(), output_actions(), save_column(), and set_goto_map().

short** includes

static

Definition at line 29 of file lalr.c.

Referenced by build_relations(), and compute_FOLLOWS().

short* INDEX

static

Definition at line 32 of file lalr.c.

Referenced by digraph(), and traverse().

int infinity

static

Definition at line 25 of file lalr.c.

Referenced by digraph(), and traverse().

unsigned* LA

Definition at line 14 of file lalr.c.

Referenced by add_reductions(), compute_lookaheads(), initialize_LA(), and output_actions().

short* LAruleno

Definition at line 13 of file lalr.c.

Referenced by add_lookback_edge(), add_reductions(), initialize_LA(), and output_actions().

short* lookaheads

Definition at line 12 of file lalr.c.

Referenced by add_lookback_edge(), add_reductions(), compute_lookaheads(), initialize_LA(), and output_actions().

shorts** lookback

static

Definition at line 30 of file lalr.c.

int maxrhs

static

Definition at line 26 of file lalr.c.

Referenced by build_relations(), and set_maxrhs().

int ngotos

static

Definition at line 27 of file lalr.c.

Referenced by build_relations(), digraph(), initialize_F(), and set_goto_map().

short** R

static

Definition at line 31 of file lalr.c.

Referenced by digraph(), reflexive_transitive_closure(), transitive_closure(), and traverse().

reductions** reduction_table

Definition at line 18 of file lalr.c.

Referenced by free_reductions().

shifts** shift_table

Definition at line 17 of file lalr.c.

Referenced by find_final_state(), free_shifts(), get_shifts(), print_actions(), and print_gotos().

core** state_table

Definition at line 16 of file lalr.c.

Referenced by free_itemsets(), and print_core().

short* to_state

Definition at line 21 of file lalr.c.

Referenced by build_relations(), default_goto(), find_final_state(), get_shifts(), initialize_F(), output_actions(), print_gotos(), save_column(), and set_goto_map().

int tokensetsize

Definition at line 11 of file lalr.c.

Referenced by add_reductions(), compute_lookaheads(), initialize_F(), initialize_LA(), lalr(), and traverse().

int top

static

Definition at line 34 of file lalr.c.

Referenced by digraph(), and traverse().

short* VERTICES

static

Definition at line 33 of file lalr.c.

Referenced by digraph(), and traverse().