Garbo/Garbo.cdr/mac/progrmng/flextc.sit/dfa.c

C/C++ Source or Header | 1990-01-03 | 22.0 KB | 978 lines | [TEXT/KAHL]

/* dfa - DFA construction routines */

/*
 * Copyright (c) 1989 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Vern Paxson.
 *
 * The United States Government has rights in this work pursuant to
 * contract no. DE-AC03-76SF00098 between the United States Department of
 * Energy and the University of California.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef lint

static char copyright[] =
"@(#) Copyright (c) 1989 The Regents of the University of California.\n";
static char CR_continuation[] = "@(#) All rights reserved.\n";

static char rcsid[] =
"@(#) $Header: dfa.c,v 2.0 89/06/20 15:49:30 vern Locked $ (LBL)";

#endif

#include "flexdef.h"
#ifdef THINK_C
#include <stdlib.h>
#endif


/* check_for_backtracking - check a DFA state for backtracking
 *
 * synopsis
 *       int ds, state[numecs];
 *       check_for_backtracking( ds, state );
 *
 * ds is the number of the state to check and state[] is its out-transitions,
 * indexed by equivalence class, and state_rules[] is the set of rules
 * associated with this state
 */

check_for_backtracking( ds, state )
int ds;
int state[];

{
    if ( (reject && ! dfaacc[ds].dfaacc_set) || ! dfaacc[ds].dfaacc_state )
    { /* state is non-accepting */
        ++num_backtracking;

        if ( backtrack_report )
        {
            fprintf( backtrack_file, "State #%d is non-accepting -\n", ds );

            /* identify the state */
            dump_associated_rules( backtrack_file, ds );

            /* now identify it further using the out- and jam-transitions */
            dump_transitions( backtrack_file, state );

            putc( '\n', backtrack_file );
        }
    }
}


/* check_trailing_context - check to see if NFA state set constitutes
 *                            "dangerous" trailing context
 *
 * synopsis
 *      int nfa_states[num_states+1], num_states;
 *      int accset[nacc+1], nacc;
 *      int check_trailing_context();
 *      true/false = check_trailing_context( nfa_states, num_states,
 *                                           accset, nacc );
 *
 * NOTES
 *      Trailing context is "dangerous" if both the head and the trailing
 *    part are of variable size \and/ there's a DFA state which contains
 *    both an accepting state for the head part of the rule and NFA states
 *    which occur after the beginning of the trailing context.
 *    When such a rule is matched, it's impossible to tell if having been
 *    in the DFA state indicates the beginning of the trailing context
 *    or further-along scanning of the pattern.  In these cases, a warning
 *    message is issued.
 *
 *      nfa_states[1 .. num_states] is the list of NFA states in the DFA.
 *      accset[1 .. nacc] is the list of accepting numbers for the DFA state.
 */

int check_trailing_context( nfa_states, num_states, accset, nacc )
int *nfa_states, num_states;
int *accset;
register int nacc;

{
    register int i, j;

    for ( i = 1; i <= num_states; ++i )
    {
        int ns = nfa_states[i];
        register int type = state_type[ns];
        register int ar = assoc_rule[ns];

        if ( type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE )
        { /* do nothing */
        }

        else
            if ( type == STATE_TRAILING_CONTEXT )
            {
                /* potential trouble.  Scan set of accepting numbers for
                 * the one marking the end of the "head".  We assume that
                 * this looping will be fairly cheap since it's rare that
                 * an accepting number set is large.
                 */
                for ( j = 1; j <= nacc; ++j )
                    if ( accset[j] & YY_TRAILING_HEAD_MASK )
                    {
                        fprintf( stderr,
                        "flex: Dangerous trailing context in rule at line %d\n",
                        rule_linenum[ar] );
                        return;
                    }
            }
    }
}


/* dump_associated_rules - list the rules associated with a DFA state
 *
 * synopisis
 *       int ds;
 *       FILE *file;
 *       dump_associated_rules( file, ds );
 *
 * goes through the set of NFA states associated with the DFA and
 * extracts the first MAX_ASSOC_RULES unique rules, sorts them,
 * and writes a report to the given file
 */

dump_associated_rules( file, ds )
FILE *file;
int ds;

{
    register int i, j;
    register int num_associated_rules = 0;
    int rule_set[MAX_ASSOC_RULES + 1];
    int *dset = dss[ds];
    int size = dfasiz[ds];

    for ( i = 1; i <= size; ++i )
    {
        register rule_num = rule_linenum[assoc_rule[dset[i]]];

        for ( j = 1; j <= num_associated_rules; ++j )
            if ( rule_num == rule_set[j] )
                break;

        if ( j > num_associated_rules )
        { /* new rule */
            if ( num_associated_rules < MAX_ASSOC_RULES )
                rule_set[++num_associated_rules] = rule_num;
        }
    }

    bubble( rule_set, num_associated_rules );

    fprintf( file, " associated rules:" );

    for ( i = 1; i <= num_associated_rules; ++i )
    {
        if ( i % 8 == 1 )
            putc( '\n', file );

        fprintf( file, "\t%d", rule_set[i] );
    }

    putc( '\n', file );
}


/* dump_transitions - list the transitions associated with a DFA state
 *
 * synopisis
 *       int state[numecs];
 *       FILE *file;
 *       dump_transitions( file, state );
 *
 * goes through the set of out-transitions and lists them in human-readable
 * form (i.e., not as equivalence classes); also lists jam transitions
 * (i.e., all those which are not out-transitions, plus EOF).  The dump
 * is done to the given file.
 */

dump_transitions( file, state )
FILE *file;
int state[];

{
    register int i, ec;
    int out_char_set[CSIZE + 1];

    for ( i = 1; i <= CSIZE; ++i )
    {
        ec = ecgroup[i];

        if ( ec < 0 )
            ec = -ec;

        out_char_set[i] = state[ec];
    }

    fprintf( file, " out-transitions: " );

    list_character_set( file, out_char_set );

    /* now invert the members of the set to get the jam transitions */
    for ( i = 1; i <= CSIZE; ++i )
        out_char_set[i] = ! out_char_set[i];

    fprintf( file, "\n jam-transitions: EOF " );

    list_character_set( file, out_char_set );

    putc( '\n', file );
}


/* epsclosure - construct the epsilon closure of a set of ndfa states
 *
 * synopsis
 *      int t[current_max_dfa_size], numstates, accset[num_rules + 1], nacc;
 *      int hashval;
 *      int *epsclosure();
 *      t = epsclosure( t, &numstates, accset, &nacc, &hashval );
 *
 * NOTES
 *      the epsilon closure is the set of all states reachable by an arbitrary
 *    number of epsilon transitions which themselves do not have epsilon
 *    transitions going out, unioned with the set of states which have non-null
 *    accepting numbers.    t is an array of size numstates of nfa state numbers.
 *    Upon return, t holds the epsilon closure and numstates is updated.    accset
 *    holds a list of the accepting numbers, and the size of accset is given
 *    by nacc.  t may be subjected to reallocation if it is not large enough
 *    to hold the epsilon closure.
 *
 *      hashval is the hash value for the dfa corresponding to the state set
 */

int *epsclosure( t, ns_addr, accset, nacc_addr, hv_addr )
int *t, *ns_addr, accset[], *nacc_addr, *hv_addr;

{
    register int stkpos, ns, tsp;
    int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
    int stkend, nstate;
    static int did_stk_init = false, *stk;

#define MARK_STATE(state) \
    trans1[state] = trans1[state] - MARKER_DIFFERENCE;

#define IS_MARKED(state) (trans1[state] < 0)

#define UNMARK_STATE(state) \
    trans1[state] = trans1[state] + MARKER_DIFFERENCE;

#define CHECK_ACCEPT(state) \
    {    \
    nfaccnum = accptnum[state];    \
    if ( nfaccnum != NIL ) \
        accset[++nacc] = nfaccnum;    \
        }

#define DO_REALLOCATION \
    {    \
    current_max_dfa_size += MAX_DFA_SIZE_INCREMENT;    \
    ++num_reallocs;    \
    t = reallocate_integer_array( t, current_max_dfa_size );    \
    stk = reallocate_integer_array( stk, current_max_dfa_size );    \
        }

#define PUT_ON_STACK(state) \
    {    \
    if ( ++stkend >= current_max_dfa_size ) \
        DO_REALLOCATION \
    stk[stkend] = state;    \
    MARK_STATE(state) \
        }

#define ADD_STATE(state) \
    {    \
    if ( ++numstates >= current_max_dfa_size ) \
        DO_REALLOCATION \
    t[numstates] = state;    \
    hashval = hashval + state;    \
        }

#define STACK_STATE(state) \
    {    \
    PUT_ON_STACK(state) \
    CHECK_ACCEPT(state) \
    if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \
        ADD_STATE(state) \
        }

    if ( ! did_stk_init )
    {
        stk = allocate_integer_array( current_max_dfa_size );
        did_stk_init = true;
    }

    nacc = stkend = hashval = 0;

    for ( nstate = 1; nstate <= numstates; ++nstate )
    {
        ns = t[nstate];

        /* the state could be marked if we've already pushed it onto
         * the stack
         */
        if ( ! IS_MARKED(ns) )
            PUT_ON_STACK(ns)
                CHECK_ACCEPT(ns)
                    hashval = hashval + ns;
            }

            for ( stkpos = 1; stkpos <= stkend; ++stkpos )
            {
                ns = stk[stkpos];
                transsym = transchar[ns];

                if ( transsym == SYM_EPSILON )
                {
                    tsp = trans1[ns] + MARKER_DIFFERENCE;

                    if ( tsp != NO_TRANSITION )
                    {
                        if ( ! IS_MARKED(tsp) )
                            STACK_STATE(tsp)
                                tsp = trans2[ns];

                            if ( tsp != NO_TRANSITION )
                                if ( ! IS_MARKED(tsp) )
                                    STACK_STATE(tsp)
                                    }
                                }
                            }

                            /* clear out "visit" markers */

                            for ( stkpos = 1; stkpos <= stkend; ++stkpos )
                            {
                                if ( IS_MARKED(stk[stkpos]) )
                                {
                                    UNMARK_STATE(stk[stkpos])
                                    }
                                    else
                                        flexfatal( "consistency check failed in epsclosure()" );
                            }

                            *ns_addr = numstates;
                            *hv_addr = hashval;
                            *nacc_addr = nacc;

                            return ( t );
                        }


/* increase_max_dfas - increase the maximum number of DFAs */

increase_max_dfas()

{
    current_max_dfas += MAX_DFAS_INCREMENT;

    ++num_reallocs;

    base = reallocate_integer_array( base, current_max_dfas );
    def = reallocate_integer_array( def, current_max_dfas );
    dfasiz = reallocate_integer_array( dfasiz, current_max_dfas );
    accsiz = reallocate_integer_array( accsiz, current_max_dfas );
    dhash = reallocate_integer_array( dhash, current_max_dfas );
    dss = reallocate_int_ptr_array( dss, current_max_dfas );
    dfaacc = reallocate_dfaacc_union( dfaacc, current_max_dfas );
}


/* ntod - convert an ndfa to a dfa
 *
 * synopsis
 *      ntod();
 *
 *    creates the dfa corresponding to the ndfa we've constructed.  the
 *    dfa starts out in state #1.
 */
ntod()

{
    int *accset, ds, nacc, newds;
    int duplist[CSIZE + 1], sym, hashval, numstates, dsize;
    int targfreq[CSIZE + 1], targstate[CSIZE + 1], state[CSIZE + 1];
    int *nset, *dset;
    int targptr, totaltrans, i, comstate, comfreq, targ;
    int *epsclosure(), snstods(), symlist[CSIZE + 1];
    int num_start_states;
    int todo_head, todo_next;

    /* this is so find_table_space(...) will know where to start looking in
     * chk/nxt for unused records for space to put in the state
     */
    if ( fullspd )
        firstfree = 0;

    accset = allocate_integer_array( num_rules + 1 );
    nset = allocate_integer_array( current_max_dfa_size );

    /* the "todo" queue is represented by the head, which is the DFA
     * state currently being processed, and the "next", which is the
     * next DFA state number available (not in use).  We depend on the
     * fact that snstods() returns DFA's \in increasing order/, and thus
     * need only know the bounds of the dfas to be processed.
     */
    todo_head = todo_next = 0;

    for ( i = 0; i <= CSIZE; ++i )
    {
        duplist[i] = NIL;
        symlist[i] = false;
    }

    for ( i = 0; i <= num_rules; ++i )
        accset[i] = NIL;

    if ( trace )
    {
        dumpnfa( scset[1] );
        fputs( "\n\nDFA Dump:\n\n", stderr );
    }

    inittbl();

    if ( fullspd )
    {
        for ( i = 0; i <= numecs; ++i )
            state[i] = 0;
        place_state( state, 0, 0 );
    }

    if ( fulltbl )
    {
        /* declare it "short" because it's a real long-shot that that
         * won't be large enough
         */
        printf( "static short int %s[][%d] =\n    {\n", NEXTARRAY,
        numecs + 1 ); /* '}' so vi doesn't get too confused */

        /* generate 0 entries for state #0 */
        for ( i = 0; i <= numecs; ++i )
            mk2data( 0 );

        /* force ',' and dataflush() next call to mk2data */
        datapos = NUMDATAITEMS;

        /* force extra blank line next dataflush() */
        dataline = NUMDATALINES;
    }

    /* create the first states */

    num_start_states = lastsc * 2;

    for ( i = 1; i <= num_start_states; ++i )
    {
        numstates = 1;

        /* for each start condition, make one state for the case when
         * we're at the beginning of the line (the '%' operator) and
         * one for the case when we're not
         */
        if ( i % 2 == 1 )
            nset[numstates] = scset[(i / 2) + 1];
        else
            nset[numstates] = mkbranch( scbol[i / 2], scset[i / 2] );

        nset = epsclosure( nset, &numstates, accset, &nacc, &hashval );

        if ( snstods( nset, numstates, accset, nacc, hashval, &ds ) )
        {
            numas += nacc;
            totnst += numstates;
            ++todo_next;

            if ( variable_trailing_context_rules && nacc > 0 )
                check_trailing_context( nset, numstates, accset, nacc );
        }
    }

    if ( ! fullspd )
    {
        if ( ! snstods( nset, 0, accset, 0, 0, &end_of_buffer_state ) )
            flexfatal( "could not create unique end-of-buffer state" );

        ++numas;
        ++num_start_states;
        ++todo_next;
    }

    while ( todo_head < todo_next )
    {
        targptr = 0;
        totaltrans = 0;

        for ( i = 1; i <= numecs; ++i )
            state[i] = 0;

        ds = ++todo_head;

        dset = dss[ds];
        dsize = dfasiz[ds];

        if ( trace )
            fprintf( stderr, "state # %d:\n", ds );

        sympartition( dset, dsize, symlist, duplist );

        for ( sym = 1; sym <= numecs; ++sym )
        {
            if ( symlist[sym] )
            {
                symlist[sym] = 0;

                if ( duplist[sym] == NIL )
                { /* symbol has unique out-transitions */
                    numstates = symfollowset( dset, dsize, sym, nset );
                    nset = epsclosure( nset, &numstates, accset,
                    &nacc, &hashval );

                    if ( snstods( nset, numstates, accset,
                    nacc, hashval, &newds ) )
                    {
                        totnst = totnst + numstates;
                        ++todo_next;
                        numas += nacc;

                        if ( variable_trailing_context_rules && nacc > 0 )
                            check_trailing_context( nset, numstates,
                            accset, nacc );
                    }

                    state[sym] = newds;

                    if ( trace )
                        fprintf( stderr, "\t%d\t%d\n", sym, newds );

                    targfreq[++targptr] = 1;
                    targstate[targptr] = newds;
                    ++numuniq;
                }

                else
                {
                    /* sym's equivalence class has the same transitions
                     * as duplist(sym)'s equivalence class
                     */
                    targ = state[duplist[sym]];
                    state[sym] = targ;

                    if ( trace )
                        fprintf( stderr, "\t%d\t%d\n", sym, targ );

                    /* update frequency count for destination state */

                    i = 0;
                    while ( targstate[++i] != targ );

                    ++targfreq[i];
                    ++numdup;
                }

                ++totaltrans;
                duplist[sym] = NIL;
            }
        }

        numsnpairs = numsnpairs + totaltrans;

        if ( caseins && ! useecs )
        {
            register int j;

            for ( i = 'A', j = 'a'; i <= 'Z'; ++i, ++j )
                state[i] = state[j];
        }

        if ( ds > num_start_states )
            check_for_backtracking( ds, state );

        if ( fulltbl )
        {
            /* supply array's 0-element */
            if ( ds == end_of_buffer_state )
                mk2data( -end_of_buffer_state );
            else
                mk2data( end_of_buffer_state );

            for ( i = 1; i <= numecs; ++i )        /* jams are marked by negative of state number */
                mk2data( state[i] ? state[i] : -ds );

            /* force ',' and dataflush() next call to mk2data */
            datapos = NUMDATAITEMS;

            /* force extra blank line next dataflush() */
            dataline = NUMDATALINES;
        }

        else
            if ( fullspd )
                place_state( state, ds, totaltrans );

        else
            if ( ds == end_of_buffer_state )        /* special case this state to make sure it does what it's
             * supposed to, i.e., jam on end-of-buffer
             */
                stack1( ds, 0, 0, JAMSTATE );

        else /* normal, compressed state */
        {
            /* determine which destination state is the most common, and
             * how many transitions to it there are
             */

            comfreq = 0;
            comstate = 0;

            for ( i = 1; i <= targptr; ++i )
                if ( targfreq[i] > comfreq )
                {
                    comfreq = targfreq[i];
                    comstate = targstate[i];
                }

            bldtbl( state, ds, totaltrans, comstate, comfreq );
        }
    }

    if ( fulltbl )
        dataend();

    else
        if ( ! fullspd )
        {
            cmptmps();    /* create compressed template entries */

            /* create tables for all the states with only one out-transition */
            while ( onesp > 0 )
            {
                mk1tbl( onestate[onesp], onesym[onesp], onenext[onesp],
                onedef[onesp] );
                --onesp;
            }

            mkdeftbl();
        }
}


/* snstods - converts a set of ndfa states into a dfa state
 *
 * synopsis
 *      int sns[numstates], numstates, newds, accset[num_rules + 1], nacc, hashval;
 *      int snstods();
 *      is_new_state = snstods( sns, numstates, accset, nacc, hashval, &newds );
 *
 * on return, the dfa state number is in newds.
 */

int snstods( sns, numstates, accset, nacc, hashval, newds_addr )
int sns[], numstates, accset[], nacc, hashval, *newds_addr;

{
    int didsort = 0;
    register int i, j;
    int newds, *oldsns;
#ifndef THINK_C
    char *malloc();
#endif

    for ( i = 1; i <= lastdfa; ++i )
        if ( hashval == dhash[i] )
        {
            if ( numstates == dfasiz[i] )
            {
                oldsns = dss[i];

                if ( ! didsort )
                {
                    /* we sort the states in sns so we can compare it to
                     * oldsns quickly.    we use bubble because there probably
                     * aren't very many states
                     */
                    bubble( sns, numstates );
                    didsort = 1;
                }

                for ( j = 1; j <= numstates; ++j )
                    if ( sns[j] != oldsns[j] )
                        break;

                if ( j > numstates )
                {
                    ++dfaeql;
                    *newds_addr = i;
                    return ( 0 );
                }

                ++hshcol;
            }

            else
                ++hshsave;
        }

    /* make a new dfa */

    if ( ++lastdfa >= current_max_dfas )
        increase_max_dfas();

    newds = lastdfa;

    dss[newds] = (int *) malloc( (unsigned) ((numstates + 1) * sizeof( int )) );

    if ( ! dss[newds] )
        flexfatal( "dynamic memory failure in snstods()" );

    /* if we haven't already sorted the states in sns, we do so now, so that
     * future comparisons with it can be made quickly
     */

    if ( ! didsort )
        bubble( sns, numstates );

    for ( i = 1; i <= numstates; ++i )
        dss[newds][i] = sns[i];

    dfasiz[newds] = numstates;
    dhash[newds] = hashval;

    if ( nacc == 0 )
    {
        if ( reject )
            dfaacc[newds].dfaacc_set = (int *) 0;
        else
            dfaacc[newds].dfaacc_state = 0;

        accsiz[newds] = 0;
    }

    else
        if ( reject )
        {
            /* we sort the accepting set in increasing order so the disambiguating
             * rule that the first rule listed is considered match in the event of
             * ties will work.    We use a bubble sort since the list is probably
             * quite small.
             */

            bubble( accset, nacc );

            dfaacc[newds].dfaacc_set =
                (int *) malloc( (unsigned) ((nacc + 1) * sizeof( int )) );

            if ( ! dfaacc[newds].dfaacc_set )
                flexfatal( "dynamic memory failure in snstods()" );

            /* save the accepting set for later */
            for ( i = 1; i <= nacc; ++i )
                dfaacc[newds].dfaacc_set[i] = accset[i];

            accsiz[newds] = nacc;
        }

    else
    { /* find lowest numbered rule so the disambiguating rule will work */
        j = num_rules + 1;

        for ( i = 1; i <= nacc; ++i )
            if ( accset[i] < j )
                j = accset[i];

        dfaacc[newds].dfaacc_state = j;
    }

    *newds_addr = newds;

    return ( 1 );
}


/* symfollowset - follow the symbol transitions one step
 *
 * synopsis
 *      int ds[current_max_dfa_size], dsize, transsym;
 *      int nset[current_max_dfa_size], numstates;
 *      numstates = symfollowset( ds, dsize, transsym, nset );
 */

int symfollowset( ds, dsize, transsym, nset )
int ds[], dsize, transsym, nset[];

{
    int ns, tsp, sym, i, j, lenccl, ch, numstates;
    int ccllist;

    numstates = 0;

    for ( i = 1; i <= dsize; ++i )
    { /* for each nfa state ns in the state set of ds */
        ns = ds[i];
        sym = transchar[ns];
        tsp = trans1[ns];

        if ( sym < 0 )
        { /* it's a character class */
            sym = -sym;
            ccllist = cclmap[sym];
            lenccl = ccllen[sym];

            if ( cclng[sym] )
            {
                for ( j = 0; j < lenccl; ++j )
                { /* loop through negated character class */
                    ch = ccltbl[ccllist + j];

                    if ( ch > transsym )
                        break;    /* transsym isn't in negated ccl */

                    else
                        if ( ch == transsym )             /* next 2 */
                            goto bottom;
                }

                /* didn't find transsym in ccl */
                nset[++numstates] = tsp;
            }

            else
                for ( j = 0; j < lenccl; ++j )
                {
                    ch = ccltbl[ccllist + j];

                    if ( ch > transsym )
                        break;

                    else
                        if ( ch == transsym )
                        {
                            nset[++numstates] = tsp;
                            break;
                        }
                }
        }

        else
            if ( sym >= 'A' && sym <= 'Z' && caseins )
                flexfatal( "consistency check failed in symfollowset" );

        else
            if ( sym == SYM_EPSILON )
            { /* do nothing */
            }

        else
            if ( ecgroup[sym] == transsym )
                nset[++numstates] = tsp;

bottom:;
    }

    return ( numstates );
}


/* sympartition - partition characters with same out-transitions
 *
 * synopsis
 *      integer ds[current_max_dfa_size], numstates, duplist[numecs];
 *      symlist[numecs];
 *      sympartition( ds, numstates, symlist, duplist );
 */

sympartition( ds, numstates, symlist, duplist )
int ds[], numstates, duplist[];
int symlist[];

{
    int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;

    /* partitioning is done by creating equivalence classes for those
     * characters which have out-transitions from the given state.    Thus
     * we are really creating equivalence classes of equivalence classes.
     */

    for ( i = 1; i <= numecs; ++i )
    { /* initialize equivalence class list */
        duplist[i] = i - 1;
        dupfwd[i] = i + 1;
    }

    duplist[1] = NIL;
    dupfwd[numecs] = NIL;

    for ( i = 1; i <= numstates; ++i )
    {
        ns = ds[i];
        tch = transchar[ns];

        if ( tch != SYM_EPSILON )
        {
            if ( tch < -lastccl || tch > CSIZE )
                flexfatal( "bad transition character detected in sympartition()" );

            if ( tch > 0 )
            { /* character transition */
                mkechar( ecgroup[tch], dupfwd, duplist );
                symlist[ecgroup[tch]] = 1;
            }

            else
            { /* character class */
                tch = -tch;

                lenccl = ccllen[tch];
                cclp = cclmap[tch];
                mkeccl( ccltbl + cclp, lenccl, dupfwd, duplist, numecs );

                if ( cclng[tch] )
                {
                    j = 0;

                    for ( k = 0; k < lenccl; ++k )
                    {
                        ich = ccltbl[cclp + k];

                        for ( ++j; j < ich; ++j )
                            symlist[j] = 1;
                    }

                    for ( ++j; j <= numecs; ++j )
                        symlist[j] = 1;
                }

                else
                    for ( k = 0; k < lenccl; ++k )
                    {
                        ich = ccltbl[cclp + k];
                        symlist[ich] = 1;
                    }
            }
        }
    }
}