Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/misc/volume27/dmake/part31

Text File | 1992-01-29 | 39.9 KB | 1,399 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Dennis Vadura)
Subject:  v27i132:  dmake - dmake Version 3.8, Part31/41
Message-ID: <[e-mail]>
X-Md4-Signature: 9073b9c38091d1bd459c7b08279c1d8c
Date: Wed, 29 Jan 1992 16:46:36 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (Dennis Vadura)
Posting-number: Volume 27, Issue 132
Archive-name: dmake/part31
Environment: Atari-ST, Coherent, Mac, MSDOS, OS/2, UNIX
Supersedes: dmake: Volume 19, Issue 22-58

---- Cut Here and feed the following to sh ----
# this is dmake.shar.31 (part 31 of a multipart archive)
# do not concatenate these parts, unpack them in order with /bin/sh
# file dmake/rulparse.c continued
#
if test ! -r _shar_seq_.tmp; then
    echo 'Please unpack part 1 first!'
    exit 1
fi
(read Scheck
 if test "$Scheck" != 31; then
    echo Please unpack part "$Scheck" next!
    exit 1
 else
    exit 0
 fi
) < _shar_seq_.tmp || exit 1
if test -f _shar_wnt_.tmp; then
sed 's/^X//' << 'SHAR_EOF' >> 'dmake/rulparse.c' &&
{
X   int res = (*_strspn(list,"@-%+ \t") == '[');
X   if( res ) _sv_attr |= Rcp_attribute(list);
X   return(res);
}
X
X
static void
_do_special( special, op, attr, set_dir, target, prereq, state )/*
==================================================================
X   Process a special target.  So far the only special targets we have
X   are those recognized by the _is_special function.
X
X   target is always only a single special target.
X
X   NOTE:  For the cases of .IMPORT, and .INCLUDE, the cells created by the
X         parser are never freed.  This is due to the fact that it is too much
X      trouble to get them out of the hash table once they are defined, and
X      if they are per chance used again it will be ok, anyway, since the
X      cell is not really used by the code below.  */
X
int    special;
int    op;
t_attr    attr;
char    *set_dir;
CELLPTR target;
CELLPTR prereq;
int     *state;
{
X   HASHPTR    hp;        /* pointer to macro def cell        */
X   CELLPTR    cp;        /* temporary pointer into cells list    */
X   CELLPTR     dp;        /* pointer to directory dir cell    */
X   LINKPTR     lp;        /* pointer at prerequisite list     */
X   char        *dir;        /* current dir to prepend        */
X   char        *path;        /* resulting path to try to read    */
X   char     *name;        /* File name for processing a .INCLUDE    */
X   char        *tmp;        /* temporary string pointer        */
X   FILE     *fil;        /* File descriptor returned by Openfile    */
X
X   DB_ENTER( "_do_special" );
X
X   target->ce_flag = F_SPECIAL;    /* mark the target as special */
X
X   switch( special ) {
X      case ST_EXPORT:
X     for( ; prereq != NIL(CELL); prereq = prereq->ce_link ) {
X        DB_PRINT( "par", ("Exporting [%s]", prereq->CE_NAME) );
X        hp = GET_MACRO( prereq->CE_NAME );
X
X        if( hp != NIL(HASH) ) {
X           char *tmpstr = hp->ht_value;
X
X           if( tmpstr == NIL(char) ) tmpstr = "";
X
X           if( Write_env_string( prereq->CE_NAME, tmpstr ) != 0 )
X          Warning( "Could not export %s", prereq->CE_NAME );
X        }
X     }
X     break;
X
X      case ST_IMPORT:
X     for( ; prereq != NIL(CELL); prereq = prereq->ce_link ) {
X        char *tmpstr;
X
X        DB_PRINT( "par", ("Importing [%s]", prereq->CE_NAME) );
X
X        if( strcmp(prereq->CE_NAME, ".EVERYTHING") == 0 ) {
X           t_attr sattr = Glob_attr;
X           Glob_attr |= A_SILENT;
X
X           ReadEnvironment();
X
X           Glob_attr = sattr;
X        }
X        else {
X           tmpstr = Read_env_string( prereq->CE_NAME );
X
X           if( tmpstr != NIL(char) )
X          Def_macro( prereq->CE_NAME,tmpstr,M_EXPANDED | M_LITERAL);
X           else
X          if( !((Glob_attr | attr) & A_IGNORE) )
X             Fatal("Imported macro `%s' not found",prereq->CE_NAME);
X        }
X     }
X
X     attr &= ~A_IGNORE;
X     break;
X
X      case ST_INCLUDE:
X      {
X     int ignore     = (((Glob_attr | attr) & A_IGNORE) != 0);
X     int pushed     = FALSE;
X     LINKPTR prqlnk = NIL(LINK);
X     LINKPTR prqlst = NIL(LINK);
X
X     if( prereq == NIL(CELL) )  Fatal( "No .INCLUDE file(s) specified" );
X
X     dp = Def_cell( ".INCLUDEDIRS" );
X
X     if( (attr & A_SETDIR) && *(dir = strchr(set_dir, '=')+1) )
X        pushed = Push_dir( dir, ".INCLUDE", ignore );
X
X     for( cp=prereq; cp != NIL(CELL); cp = cp->ce_link ) {
X        LINKPTR ltmp;
X        TALLOC(ltmp, 1, LINK);
X        ltmp->cl_prq = cp;
X
X        if( prqlnk == NIL(LINK) )
X           prqlst = ltmp;
X        else
X           prqlnk->cl_next = ltmp;
X
X        prqlnk = ltmp;
X     }
X
X     for( ; prqlst != NIL(LINK); FREE(prqlst), prqlst=prqlnk ) {
X        prqlnk = prqlst->cl_next;
X        cp     = prqlst->cl_prq;
X        name   = cp->CE_NAME;
X
X        if( *name == '<' ) {
X           /* We have a file name enclosed in <....>
X            * so get rid of the <> arround the file name */
X
X           name++;
X           if( (tmp = strrchr( name, '>' )) != NIL( char ) )
X          *tmp = 0;
X
X           if( If_root_path( name ) )
X              fil = Openfile( name, FALSE, FALSE );
X           else
X          fil = NIL(FILE);
X        }
X        else
X           fil = Openfile( name, FALSE, FALSE );
X
X        if( fil == NIL(FILE) ) {    /*if true ==> not found in current dir*/
X           /* Now we must scan the list of prerequisites for .INCLUDEDIRS
X            * looking for the file in each of the specified directories.
X        * if we don't find it then we issue an error.  The error
X        * message is suppressed if the .IGNORE attribute of attr is
X        * set.  If a file is found we call Parse on the file to
X        * perform the parse and then continue on from where we left
X        * off.  */
X
X           for(lp=dp->CE_PRQ; lp && fil == NIL(FILE); lp=lp->cl_next) {
X          dir  = lp->cl_prq->CE_NAME;
X          if( strchr(dir, '$') ) dir = Expand(dir);
X          path = Build_path( dir, name );
X
X          DB_PRINT( "par", ("Trying to include [%s]", path) );
X
X          fil = Openfile( path, FALSE, FALSE );
X          if( dir != lp->cl_prq->CE_NAME ) FREE(dir);
X           }
X        }
X
X        if( fil != NIL(FILE) )
X           Parse( fil );
X        else if( !((Glob_attr | attr) & A_IGNORE) )
X           Fatal( "Include file %s, not found", name );
X     }
X
X     if( pushed ) Pop_dir(FALSE);
X     attr &= ~(A_IGNORE|A_SETDIR);
X      }
X      break;
X
X      case ST_SOURCE:
X      /* case ST_SUFFIXES: */
X           if( prereq != NIL(CELL) )
X        _do_targets( op & (R_OP_CL | R_OP_MI | R_OP_UP), attr, set_dir,
X             target, prereq );
X     else {
X        /* The old semantics of .SOURCE were that an empty list of
X         * prerequisites clears the .SOURCE list.  So we must implement
X         * that here as a clearout prerequisite operation.  Since this is
X         * a standard operation with the :- opcode we can simply call the
X         * proper routine with the target cell and it should do the trick
X         */
X
X        if( op == R_OP_CL || (op & R_OP_MI) )
X           Clear_prerequisites( target );
X     }
X
X     op &= ~(R_OP_MI | R_OP_UP);
X     break;
X
X      case ST_KEEP:
X     if( Keep_state != NIL(char) ) break;
X     Def_macro( ".KEEP_STATE", "_state.mk", M_EXPANDED );
X     break;
X
X      case ST_REST:
X         /* The rest of the special targets can all take rules, as such they
X      * must be able to affect the state of the parser. */
X
X     {
X        int s_targ = Target;
X
X        Target     = TRUE;
X        _sp_target = TRUE;
X        *state     = _do_targets( op, attr, set_dir, target, prereq );
X        Target     = s_targ;
X
X        target->ce_flag |= F_TARGET;
X
X        attr    = A_DEFAULT;
X        op      = R_OP_CL;
X     }
X     break;
X
X      default:break;
X   }
X
X   if( op   != R_OP_CL   ) Warning( "Modifier(s) for operator ignored" );
X   if( attr != A_DEFAULT ) Warning( "Extra attributes ignored" );
X
X   DB_VOID_RETURN;
}
X
X
X
static int
_do_targets( op, attr, set_dir, targets, prereq )/*
================================================= */
int    op;
t_attr    attr;
char    *set_dir;
CELLPTR targets;
CELLPTR prereq;
{
X   CELLPTR    tg1;        /* temporary target pointer        */
X   CELLPTR    tp1;        /* temporary prerequisite pointer    */
X   char        *p;        /* temporary char pointer        */
X   CELLPTR      prev_cell;    /* pointer for .UPDATEALL processing    */
X   CELLPTR      first_cell;    /* pointer for .UPDATEALL processing    */
X   int        update;        /* A_UPDATEALL attribute flag        */
X   int        smagic = 0;    /* collective amount of magic :-)    */
X   int          tflag = FALSE;    /* set to TRUE if we add target to root */
X
X   DB_ENTER( "_do_targets" );
X
X   if( update = ((attr & A_UPDATEALL) != 0) )
X      if( targets == NIL(CELL) )
X     Fatal( ".UPDATEALL attribute requires non-empty list of targets" );
X
X   first_cell = prev_cell = NIL(CELL);
X   for( tg1 = targets; tg1 != NIL(CELL); tg1 = tg1->ce_link ) {
X      /* Check each target.  Check for inconsistencies between :: and : rule
X       * sets.  :: may follow either : or :: but not the reverse.
X       *
X       * Any targets that contain :: rules are represented by a prerequisite
X       * list hanging off the main target cell where each of the prerequisites
X       * is a copy of the target cell but is not entered into the hash table.
X       */
X      int magic  = (tg1->ce_flag & F_PERCENT) && !(tg1->ce_flag & F_MAGIC);
X      smagic |= magic;
X
X      if( !(op & R_OP_DCL ) && (tg1->ce_flag & F_MULTI) && !magic )
X     Fatal( "Inconsistency in inference rules for %s", tg1->CE_NAME );
X
X      if( magic )
X         do {
X        _build_graph( op, tg1, prereq );
X        if( prereq != NIL(CELL) ) prereq = prereq->ce_link;
X     } while( prereq != NIL(CELL) );
X      else if( !(tg1->ce_flag & F_SPECIAL) &&
X        (prereq == NIL(CELL)) &&
X        (p = _is_magic( tg1->CE_NAME )) != NIL(char))
X         smagic |= _do_magic( op, p, tg1, prereq, attr, set_dir );
X      else if( op & R_OP_DCL ) {
X     CELLPTR tmp_cell = _make_multi(tg1);
X     tflag |= _add_root(tg1);
X     targets = _replace_cell( targets, tg1, tmp_cell );
X     tg1 = tmp_cell;
X      }
X
X      if( !magic ) _set_attributes( attr, set_dir, tg1 );
X
X      if( update ) {
X     if( smagic ) Fatal( ".UPDATEALL attribute not legal in meta rule" );
X
X     /* Check this as it would break another circular .UPATEALL list if
X      * we blindly assign it and it is part of another list already. */
X     if( tg1->ce_all != NIL(CELL) )
X        Fatal( "Target [%s] appears on multiple .UPDATEALL lists" );
X
X     tg1->ce_all = prev_cell;
X     if( prev_cell == NIL(CELL) ) first_cell = tg1;
X     prev_cell = tg1;
X      }
X
X      /* Build the proper prerequisite list of the target.  If the `-',
X       * modifier was used clear the prerequisite list before adding any
X       * new prerequisites.  Else add them to the head/tail as appropriate.
X       *
X       * If the target has F_PERCENT set then no prerequisites are used. */
X
X      if( !(tg1->ce_flag & F_PERCENT) ) {
X     if( op & R_OP_MI ) Clear_prerequisites( tg1 );
X
X     if( (op & R_OP_UP) && (tg1->ce_prq != NIL(LINK)) )
X        _stick_at_head( tg1, prereq );
X     else for( tp1=prereq; tp1 != NIL(CELL); tp1 = tp1->ce_link )
X        Add_prerequisite( tg1, tp1, FALSE, FALSE );
X      }
X      else if( op & (R_OP_MI | R_OP_UP) )
X     Warning( "Modifier(s) `^!' for %-meta target ignored" );
X   }
X
X   if( tflag ) Target = TRUE;
X   if( first_cell != NIL(CELL) ) first_cell->ce_all = prev_cell;
X
X
X   /* Check to see if we have NO targets but some attributes.  IF so then
X    * apply all of the attributes to the complete list of prerequisites.
X    * Cannot happen for F_PERCENT targets. (ie. in that case targets is always
X    * not NIL) */
X
X   if( (targets == NIL(CELL)) && attr )
X      if( prereq != NIL(CELL) )
X     for( tp1=prereq; tp1 != NIL(CELL); tp1 = tp1->ce_link )
X        _set_attributes( attr, set_dir, tp1 );
X      else
X     _set_global_attr( attr );
X
X   /* Fix up the ce_link pointers so that when we go to attach a recipe in
X    * Bind_targets to rules we get the right thing if it's an .UPDATEALL ::
X    * recipe */
X   if( update ) {
X      for( tp1=NIL(CELL),tg1=prev_cell; tg1!=first_cell; tg1=tg1->ce_all ) {
X     tg1->ce_link = tp1;
X     tp1 = tg1;
X      }
X      tg1->ce_link = tp1;
X      targets = first_cell;
X   }
X
X   /* Now that we have built the lists of targets, the parser must parse the
X    * rules if there are any.  However we must start the rule list with the
X    * rule specified as via the ; kludge, if there is one */
X   _sv_targets = targets;
X   _sv_attr    = attr;
X   _sv_flag    = ((op & R_OP_BG) ? F_SINGLE : F_DEFAULT);
X
X   DB_RETURN( RULE_SCAN );
}
X
X
static int
_do_magic( op, dot, target, prereq, attr, set_dir )/*
=====================================================
X   This function takes a magic target of the form .<chars>.<chars> or
X   .<chars> and builds the appropriate % rules for that target.
X
X   The function builds the % rule, `%.o : %.c'  from .c.o, and
X   `%.a :' from .a */
X
int    op;
char    *dot;
CELLPTR target;
CELLPTR prereq;
t_attr  attr;
char    *set_dir;
{
X   CELLPTR tg;
X   CELLPTR prq;
X   char    *tmp, *tmp2;
X
X   DB_ENTER( "_do_magic" );
X
X   if( prereq != NIL(CELL) )
X      Warning( "Ignoring prerequisites of old style meta-target" );
X
X   if( dot == target->CE_NAME )    {        /* its of the form .a    */
X      tg  = Def_cell( "%" );            /* ==> no prerequisite  */
X      tmp = _build_meta( target->CE_NAME );
X      prq = Def_cell( tmp );
X      FREE( tmp );
X
X      _build_graph( op, tg, prq );
X   }
X   else {
X      tmp = _build_meta( dot );
X      tg  = Def_cell( tmp );
X      FREE( tmp );
X
X      tmp = _build_meta( tmp2 = _substr( target->CE_NAME, dot ) );
X      prq = Def_cell( tmp );
X      FREE( tmp  );
X      FREE( tmp2 );
X
X      _build_graph( op, tg, prq );
X   }
X
X   tg->ce_flag      |= F_PERCENT;
X   target->ce_flag  |= (F_MAGIC|F_PERCENT);
X
X   _set_attributes( attr, set_dir, tg );
X
X   DB_RETURN(1);
}
X
X
static CELLPTR
_replace_cell( lst, cell, rep )
CELLPTR lst;
CELLPTR cell;
CELLPTR rep;
{
X   register CELLPTR tp;
X
X   if( lst == cell ) {
X      rep->ce_link = lst->ce_link;
X      lst = rep;
X   }
X   else {
X      for( tp=lst; tp->ce_link != cell; tp=tp->ce_link );
X      rep->ce_link = tp->ce_link->ce_link;
X      tp->ce_link = rep;
X   }
X
X   return(lst);
}
X
X
static char *
_build_meta( name )/*
=====================
X   Check to see if the name is of the form .c~ if so and if Augmake
X   translation is enabled then return s.%.c, else return %.suff, where if the
X   suffix ends in '~' then leave it be.*/
char *name;
{
X   char *tmp;
X   int  test = Augmake ? name[strlen(name)-1] == '~' : 0;
X
X   tmp = _strjoin( test ? "s.%" : "%", name, -1, FALSE);
X   if( test ) tmp[ strlen(tmp)-1 ] = '\0';
X
X   return(tmp);
}
X
X
X
static void
_build_graph( op, target, prereq )/*
====================================
X   This function is called to build the graph for the % rule given by
X   target : prereq cell combination.  This function assumes that target
X   is a % target and that prereq is a single % prerequisite.  R_OP_CL
X   rules replace existing rules if any, only R_OP_CL works for meta-rules.
X   %.o :: %.c is meaningless.
X
X   It also assumes that target cell has F_PERCENT set already. */
int op;
CELLPTR target;
CELLPTR prereq;
{
X   LINKPTR edl;
X   CELLPTR edge;
X   int match;
X
X   DB_ENTER( "_build_graph" );
X   DB_PRINT( "%", ("Building graph for [%s : %s]", target->CE_NAME,
X            (prereq == NIL(CELL)) ? "" : prereq->CE_NAME) );
X
X   if( prereq != NIL(CELL) ) {
X      char *name = prereq->CE_NAME;
X      int   len  = strlen(name);
X
X      if( *name == '\'' && name[len-1]=='\'' ){
X     _add_global_prereq( prereq );
X     name[len-1] = '\0';
X     strcpy(name, name+1);
X     DB_VOID_RETURN;
X      }
X   }
X
X   /* Search the list of prerequisites for the current target and see if
X    * any of them match the current %-meta : prereq pair.  NOTE that %-metas
X    * are built as if they were F_MULTI targets. */
X
X   match = FALSE;
X   for( edl=target->ce_prq; edl != NIL(LINK); edl=edl->cl_next ) {
X      edge = edl->cl_prq;
X
X      DB_PRINT( "%", ("Trying to match [%s]", edge?edge->CE_NAME:"(nil)") );
X
X      if(    (!edge->ce_prq && !prereq)
X      || (   edge->ce_prq
X          && edge->ce_prq->cl_prq == prereq
X          && (   edge->ce_dir == _sv_setdir
X          || (   edge->ce_dir
X              && _sv_setdir
X              && !strcmp(edge->ce_dir,strchr(_sv_setdir,'=')+1)
X             )
X         )
X         )
X    ) {
X     match = TRUE;
X     break;
X      }
X   }
X
X   if( match ) {
X      /* match is TRUE hence, we found an edge joining the target and the
X       * prerequisite so reset the new edge's how values to reflect the new
X       * recipe etc. */
X      DB_PRINT( "%", ("It's an old edge") );
X
X      edge->ce_dir    = NIL(char);
X      edge->ce_flag  &= (F_PERCENT|F_MAGIC|F_DFA);
X      edge->ce_attr  &= A_NOINFER;
X   }
X   else {
X      DB_PRINT( "%", ("Adding a new edge") );
X
X      if( !(target->ce_flag & F_DFA) ) {
X     Add_nfa( target->CE_NAME );
X     target->ce_flag |= F_DFA;
X      }
X      edge = _make_multi(target);
X      if( prereq ) Add_prerequisite(edge, prereq, FALSE, TRUE);
X   }
X
X   if( op & R_OP_DCL )
X   Warning( "'::' operator for meta-target '%s' ignored, ':' operator assumed.",
X           target->CE_NAME );
X
X   edge->ce_link = _sv_edgel;
X   _sv_edgel = edge;
X   _sv_globprq_only = 0;
X
X   DB_VOID_RETURN;
}
X
X
static CELLPTR
_make_multi( tg )
CELLPTR tg;
{
X   CELLPTR cp;
X
X   /* This first handle the case when a : foo ; exists prior to seeing
X    * a :: fee; */
X   if( !(tg->ce_flag & F_MULTI) && (tg->ce_prq || tg->ce_recipe) ) {
X      TALLOC(cp, 1, CELL);
X      *cp = *tg;
X
X      tg->ce_prq    = NIL(LINK);
X      tg->ce_flag  |= F_RULES|F_MULTI|F_TARGET;
X      tg->ce_attr  |= A_SEQ;
X      tg->ce_recipe = NIL(STRING);
X      tg->ce_dir    = NIL(char);
X      cp->ce_count  = ++tg->ce_index;
X
X      Add_prerequisite(tg, cp, FALSE, TRUE);
X   }
X
X   TALLOC(cp, 1, CELL);
X   *cp = *tg;
X
X   if( !(tg->ce_flag & F_MULTI) ) {
X      tg->ce_prq    = NIL(LINK);
X      tg->ce_flag  |= F_RULES|F_MULTI|F_TARGET;
X      tg->ce_attr  |= A_SEQ;
X      tg->ce_recipe = NIL(STRING);
X      tg->ce_dir    = NIL(char);
X   }
X   else {
X      cp->ce_flag  &= ~(F_RULES|F_MULTI);
X      cp->ce_attr  &= ~A_SEQ;
X      cp->ce_prq    = NIL(LINK);
X      cp->ce_index  = 0;
X   }
X   cp->ce_count = ++tg->ce_index;
X   cp->ce_flag |= F_TARGET;
X
X   Add_prerequisite(tg, cp, FALSE, TRUE);
X   return(cp);
}
X
X
static void
_add_global_prereq( pq )/*
==========================
X    Prerequisite is a non-% prerequisite for a %-rule target, add it to
X    the target's list of global prerequsites to add on match */
CELLPTR pq;
{
X   register LINKPTR ln;
X
X   TALLOC( ln, 1, LINK );
X   ln->cl_next = _sv_glb_prq;
X   ln->cl_prq  = pq;
X   _sv_glb_prq = ln;
}
X
X
X
static void
_set_attributes( attr, set_dir, cp )/*
======================================
X    Set the appropriate attributes for a cell */
t_attr    attr;
char    *set_dir;
CELLPTR cp;
{
X   char   *dir;
X
X   DB_ENTER( "_set_attributes" );
X
X   /* If .SETDIR attribute is set then we have at least .SETDIR= in the
X    * set_dir string.  So go and fishout what is at the end of the =.
X    * If not set and not NULL then propagate it to the target cell. */
X
X   if( attr & A_SETDIR ) {
X      dir = strchr( set_dir, '=' ) + 1;
X
X      if( cp->ce_dir )
X     Warning( "Multiple .SETDIR for %s ignored", cp->CE_NAME );
X      else
X     if( *dir ) cp->ce_dir = _strdup(dir);
X   }
X   cp->ce_attr |= attr;        /* set rest of attributes for target */
X
X   DB_VOID_RETURN;
}
X
X
X
static void
_set_global_attr( attr )/*
==========================
X    Handle the setting of the global attribute functions based on
X    The attribute flags set in attr. */
t_attr attr;
{
X   t_attr flag;
X
X   /* Some compilers can't handle a switch on a long, and t_attr is now a long
X    * integer on some systems.  foey! */
X   for( flag = MAX_ATTR; flag; flag >>= 1 )
X      if( flag & attr )
X     if( flag == A_PRECIOUS)      Def_macro(".PRECIOUS",  "y", M_EXPANDED);
X     else if( flag == A_SILENT)   Def_macro(".SILENT",    "y", M_EXPANDED);
X     else if( flag == A_IGNORE )  Def_macro(".IGNORE",    "y", M_EXPANDED);
X     else if( flag == A_EPILOG )  Def_macro(".EPILOG",    "y", M_EXPANDED);
X     else if( flag == A_PROLOG )  Def_macro(".PROLOG",    "y", M_EXPANDED);
X     else if( flag == A_NOINFER ) Def_macro(".NOINFER",   "y", M_EXPANDED);
X     else if( flag == A_SEQ )     Def_macro(".SEQUENTIAL","y", M_EXPANDED);
X     else if( flag == A_SHELL )   Def_macro(".USESHELL",  "y", M_EXPANDED);
X     else if( flag == A_MKSARGS ) Def_macro(".MKSARGS",   "y", M_EXPANDED);
X     else if( flag == A_SWAP )    Def_macro(".SWAP",      "y", M_EXPANDED);
X
X   attr &= ~A_GLOB;
X   if( attr ) Warning( "Non global attribute(s) ignored" );
}
X
X
X
static void
_stick_at_head( cp, pq )/*
==========================
X    Add the prerequisite list to the head of the existing prerequisite
X    list */
X
CELLPTR cp;          /* cell for target node    */
CELLPTR pq;        /* list of prerequisites to add */
{
X   DB_ENTER( "_stick_at_head" );
X
X   if( pq->ce_link != NIL(CELL) ) _stick_at_head( cp, pq->ce_link );
X   Add_prerequisite( cp, pq, TRUE, FALSE );
X
X   DB_VOID_RETURN;
}
X
X
X
static t_attr
_is_attribute( name )/*
=======================
X   Check the passed name against the list of valid attributes and return the
X   attribute index if it is, else return 0, indicating the name is not a valid
X   attribute.  The present attributes are defined in dmake.h as A_xxx #defines,
X   with the corresponding makefile specification:  (note they must be named
X   exactly as defined below)
X
X   Valid attributes are:  .IGNORE, .SETDIR=, .SILENT, .PRECIOUS, .LIBRARY,
X                          .EPILOG, .PROLOG,  .LIBRARYM, .SYMBOL, .UPDATEALL,
X              .USESHELL, .NOINFER, .PHONY, .SWAP, .SEQUENTIAL
X              .NOSTATE,  .MKSARGS
X
X   NOTE:  The strcmp's are OK since at most three are ever executed for any
X          one attribute check, and that happens only when we can be fairly
X          certain we have an attribute.  */
char *name;
{
X   t_attr attr = 0;
X
X   DB_ENTER( "_is_attribute" );
X
X   if( *name++ == '.' )
X      switch( *name )
X      {
X         case 'E': attr = (strcmp(name, "EPILOG"))   ? 0 : A_EPILOG;  break;
X         case 'I': attr = (strcmp(name, "IGNORE"))   ? 0 : A_IGNORE;  break;
X         case 'L': attr = (strcmp(name, "LIBRARY"))  ? 0 : A_LIBRARY; break;
X         case 'M': attr = (strcmp(name, "MKSARGS"))  ? 0 : A_MKSARGS; break;
X
X         case 'N':
X        if( !strcmp(name, "NOINFER") )      attr = A_NOINFER;
X        else if( !strcmp(name, "NOSTATE"))  attr = A_NOSTATE;
X        else attr = 0;
X        break;
X
X         case 'U':
X        if( !strcmp(name, "UPDATEALL") )    attr = A_UPDATEALL;
X        else if( !strcmp(name, "USESHELL")) attr = A_SHELL;
X        else attr = 0;
X        break;
X
X         case 'P':
X            if( !strcmp(name, "PRECIOUS") )     attr = A_PRECIOUS;
X            else if( !strcmp(name, "PROLOG") )  attr = A_PROLOG;
X            else if( !strcmp(name, "PHONY") )   attr = A_PHONY;
X            else attr = 0;
X            break;
X
X         case 'S':
X            if( !strncmp(name, "SETDIR=", 7) )    attr = A_SETDIR;
X            else if( !strcmp(name, "SILENT") )    attr = A_SILENT;
X            else if( !strcmp(name, "SYMBOL") )    attr = A_SYMBOL;
X            else if( !strcmp(name, "SEQUENTIAL")) attr = A_SEQ;
X            else if( !strcmp(name, "SWAP"))       attr = A_SWAP;
X            else attr = 0;
X            break;
X      }
X
X   DB_RETURN( attr );
}
X
X
X
static int
_is_special( tg )/*
===================
X   This function returns TRUE if the name passed in represents a special
X   target, otherwise it returns false.  A special target is one that has
X   a special meaning to dmake, and may require processing at the time that
X   it is parsed.
X
X   Current Special targets are:
X    .GROUPPROLOG    .GROUPEPILOG    .INCLUDE    .IMPORT
X    .EXPORT        .SOURCE     .SUFFIXES    .ERROR
X    .INCLUDEDIRS    .MAKEFILES    .REMOVE        .KEEP_STATE
*/
char *tg;
{
X   DB_ENTER( "_is_special" );
X
X   if( *tg++ != '.' ) DB_RETURN( 0 );
X
X   switch( *tg )
X   {
X      case 'I':
X         if( !strcmp( tg, "IMPORT" ) )        DB_RETURN( ST_IMPORT   );
X         else if( !strcmp( tg, "INCLUDE" ) )    DB_RETURN( ST_INCLUDE  );
X     else if( !strcmp( tg, "INCLUDEDIRS" )) DB_RETURN( ST_REST     );
X     break;
X
X      case 'M':
X         if( !strcmp( tg, "MAKEFILES" ) )    DB_RETURN( ST_REST     );
X     break;
X
X      case 'E':
X         if( !strcmp( tg, "ERROR" ) )        DB_RETURN( ST_REST     );
X         else if( !strcmp( tg, "EXPORT" ) )    DB_RETURN( ST_EXPORT   );
X     break;
X
X      case 'G':
X     if( !strcmp( tg, "GROUPPROLOG" ))      DB_RETURN( ST_REST     );
X     else if( !strcmp( tg, "GROUPEPILOG" )) DB_RETURN( ST_REST     );
X     break;
X
X      case 'K':
X         if( !strcmp( tg, "KEEP_STATE" ) )    DB_RETURN( ST_KEEP     );
X     break;
X
X      case 'R':
X         if( !strcmp( tg, "REMOVE" ) )        DB_RETURN( ST_REST     );
X     break;
X
X      case 'S':
X         if( !strncmp( tg, "SOURCE", 6 ) )    DB_RETURN( ST_SOURCE   );
X         else if( !strncmp(tg, "SUFFIXES", 8 )) DB_RETURN( ST_SOURCE   );
X     break;
X   }
X
X   DB_RETURN( 0 );
}
X
X
X
static int
_is_percent( np )/*
===================
X    return TRUE if np points at a string containing a % sign */
char *np;
{
X   return( (strchr(np,'%') && (*np != '\'' && np[strlen(np)-1] != '\'')) ?
X       TRUE : FALSE );
}
X
X
static char *
_is_magic( np )/*
=================
X    return TRUE if np points at a string of the form
X          .<chars>.<chars>  or  .<chars>
X    where chars are only alpha characters.
X
X        NOTE:  reject target if it begins with ./ or ../ */
char *np;
{
X   register char *n;
X
X   n = np;
X   if( *n != '.' ) return( NIL(char) );
X   if (strchr(DirBrkStr, *(n+1))!=NULL || *(n+1) == '.' )
X      return (NIL(char));
X
X   for( n++; isgraph(*n) && (*n != '.'); n++ );
X
X   if( *n != '\0' ) {
X      if( *n != '.' )  return( NIL(char) );
X      for( np = n++; isgraph( *n ) && (*n != '.'); n++ );
X      if( *n != '\0' ) return( NIL(char) );
X   }
X   else if( !Augmake )
X      return( NIL(char) );
X
X   /* np points at the second . of .<chars>.<chars> string.
X    * if the special target is of the form .<chars> then np points at the
X    * first . in the token. */
X
X   return( np );
}
X
X
static int
_add_root(tg)
CELLPTR tg;
{
X   int res = FALSE;
X
X   if( !Target && !(tg->ce_flag & (F_SPECIAL|F_PERCENT)) ) {
X      Add_prerequisite( Root, tg, FALSE, TRUE );
X
X      tg->ce_flag |= F_TARGET;
X      tg->ce_attr |= A_FRINGE;
X      res          = TRUE;
X   }
X
X   return(res);
}
SHAR_EOF
chmod 0640 dmake/rulparse.c ||
echo 'restore of dmake/rulparse.c failed'
Wc_c="`wc -c < 'dmake/rulparse.c'`"
test 39571 -eq "$Wc_c" ||
    echo 'dmake/rulparse.c: original size 39571, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/stat.c ==============
if test -f 'dmake/stat.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/stat.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/stat.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/stat.c,v 1.1 1992/01/24 03:27:58 dvadura Exp $
-- SYNOPSIS -- bind a target name to a file.
--
-- DESCRIPTION
--    This file contains the code to go and stat a target.  The stat rules
--    follow a predefined order defined in the comment for Stat_target.
--
-- AUTHOR
--      Dennis Vadura, [e-mail]
--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
--
-- COPYRIGHT
--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
--
--      This program is free software; you can redistribute it and/or
--      modify it under the terms of the GNU General Public License
--      (version 1), as published by the Free Software Foundation, and
--      found in the file 'LICENSE' included with this distribution.
--
--      This program is distributed in the hope that it will be useful,
--      but WITHOUT ANY WARRANTY; without even the implied warrant 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 this program;  if not, write to the Free Software
--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
--
-- LOG
--     $Log: stat.c,v $
X * Revision 1.1  1992/01/24  03:27:58  dvadura
X * dmake Version 3.8, Initial revision
X *
*/
X
#include "extern.h"
X
X
static    int    _check_dir_list ANSI((CELLPTR, CELLPTR, int));
X
#ifdef DBUG
X   /* Just a little ditty for debugging this thing */
X   static time_t
X   _do_stat( name, lib, sym )
X   char *name;
X   char *lib;
X   char **sym;
X   {
X      time_t res;
X      DB_ENTER( "_do_stat" );
X
X      res = Do_stat(name, lib, sym);
X      DB_PRINT( "stat", ("Statted [%s,%s,%d,%ld]", name, lib, sym, res) );
X
X      DB_RETURN( res );
X   }
#define DO_STAT(A,B,C)  _do_stat(A,B,C)
#else
#define DO_STAT(A,B,C)  Do_stat(A,B,C)
#endif
X
static char *_first;    /* local storage of first attempted path */
X
PUBLIC void
Stat_target( cp, setfname )/*
=============================
X    Stat a target.  When doing so follow the following rules, suppose
X    that cp->CE_NAME points at a target called fred.o:
X
X        0.      If A_SYMBOL attribute set look into the library
X            then do the steps 1 thru 4 on the resulting name.
X        1.    Try path's obtained by prepending any dirs found as
X            prerequisites for .SOURCE.o.
X        2.    If not found, do same as 2 but use .SOURCE
X        3.    If not found and .LIBRARYM attribute for the target is
X            set then look for it in the corresponding library.
X            4.    If found in step 0 thru 3, then ce_fname points at
X            file name associate with target, else ce_fname points
X            at a file name built by the first .SOURCE* dir that
X            applied. */
X
CELLPTR cp;
int     setfname;
{
X   register HASHPTR hp;
X   static   HASHPTR srchp = NIL(HASH);
X   char            *name;
X   char            *tmp;
X   int            res = 0;
X
X   DB_ENTER( "Stat_target" );
X
X   name = cp->CE_NAME;
X   if( srchp == NIL(HASH) ) srchp = Get_name(".SOURCE",Defs,FALSE);
X
X   /* Look for a symbol of the form lib((symbol)) the name of the symbol
X    * as entered in the hash table is (symbol) so pull out symbol and try
X    * to find it's module.  If successful DO_STAT will return the module
X    * as well as the archive member name (pointed at by tmp).  We then
X    * replace the symbol name with the archive member name so that we
X    * have the proper name for any future refrences. */
X
X   if( cp->ce_attr & A_SYMBOL ) {
X      DB_PRINT( "stat", ("Binding lib symbol [%s]", name) );
X
X      cp->ce_time = DO_STAT( name, cp->ce_lib, &tmp );
X
X      if( cp->ce_time != (time_t) 0L ) {
X     /* stat the new member name below  note tmp must point at a string
X      * returned by MALLOC... ie. the Do_stat code should use _strdup */
X
X     if( Verbose & V_MAKE )
X        printf( "%s:  Mapped ((%s)) to %s(%s)\n", Pname,
X             name, cp->ce_lib, tmp );
X
X         FREE( name );
X     name = cp->CE_NAME = tmp;
X     cp->ce_attr &= ~(A_FFNAME | A_SYMBOL);
X      }
X      else
X         { DB_VOID_RETURN; }
X   }
X
X   _first = NIL(char);
X   tmp = _strjoin( ".SOURCE", Get_suffix( name ), -1, FALSE);
X
X   /* Check .SOURCE.xxx target */
X   if( (hp = Get_name(tmp, Defs, FALSE)) != NIL(HASH) )
X      res = _check_dir_list( cp, hp->CP_OWNR, setfname );
X
X   /* Check just .SOURCE */
X   if( !res && (srchp != NIL(HASH)) )
X      res = _check_dir_list( cp, srchp->CP_OWNR, setfname );
X
X   /* If libmember and we haven't found it check the library */
X   if( !res && (cp->ce_attr & A_LIBRARYM) ) {
X      cp->ce_time = DO_STAT(name, cp->ce_lib, NIL(char *));
X
X      if( !cp->ce_time && Tmd && *Tmd && cp->ce_lib ) {
X     cp->ce_lib=Build_path(Tmd,cp->ce_lib);
X     cp->ce_time = DO_STAT(name, cp->ce_lib, NIL(char *));
X      }
X
X      if( Verbose & V_MAKE )
X     printf( "%s:  Checking library '%s' for member [%s], time %ld\n",
X         Pname, cp->ce_lib, name, cp->ce_time );
X   }
X
X   FREE( tmp );
X
X   if( setfname == 1 || (setfname == -1 && cp->ce_time != (time_t)0L) ) {
X      if( (cp->ce_attr & A_FFNAME) && (cp->ce_fname != NIL(char)) )
X     FREE( cp->ce_fname );
X
X      if( _first != NIL(char) ) {
X     cp->ce_fname = _first;
X     cp->ce_attr |= A_FFNAME;
X      }
X      else {
X     cp->ce_fname = cp->CE_NAME;
X     cp->ce_attr &= ~A_FFNAME;
X      }
X   }
X   else if( _first )
X      FREE( _first );
X
X   /* set it as stated only if successful, this way, we shall try again
X    * later. */
X   if( cp->ce_time != (time_t)0L ) cp->ce_flag |= F_STAT;
X
X   DB_VOID_RETURN;
}
X
X
X
static int
_check_dir_list( cp, sp, setfname )/*
=====================================
X    Check the list of dir's given by the prerequisite list of sp, for a
X    file pointed at by cp.  Returns 0 if path not bound, else returns
X    1 and replaces old name for cell with new cell name. */
X
CELLPTR cp;
CELLPTR sp;
int     setfname;
{
X   register LINKPTR lp;
X   char *dir;
X   char *path;
X   char *name;
X   int  res  = 0;
X   int  fset = 0;
X
X   DB_ENTER( "_check_dir_list" );
X   DB_PRINT( "mem", ("%s:-> mem %ld", cp->CE_NAME, (long) coreleft()) );
X
X   if( sp->ce_prq != NIL(LINK) )    /* check prerequisites if any */
X   {
X      /* Use the real name instead of basename, this prevents silly
X       * loops in inference code, and is consistent with man page */
X      name = cp->CE_NAME;
X
X      /* Here we loop through each directory on the list, and try to stat
X       * the target.  We always save the first pathname we try and stat in
X       * _first.  If we subsequently get a match we then replace the value of
X       * _first by the matched path name.  */
X
X      for( lp=sp->CE_PRQ; lp != NIL(LINK) && !res; lp=lp->cl_next ) {
X     int  nodup = 0;
X     dir  = lp->cl_prq->CE_NAME;
X
X     if( strchr( dir, '$' ) ) dir = Expand(dir);
X     if( strcmp( dir, ".NULL" ) == 0 ) {
X        nodup = 1;
X        path = cp->CE_NAME;
X     }
X     else
X        path = Build_path( dir, name );
X
X     res = ((cp->ce_time = DO_STAT(path,NIL(char),NIL(char *))) != (time_t)0L);
#if 0
I think this will break a lot of things!
X     /* It didn't work and TMD macro has a value so try to stat it
X      * relative to the original MAKEDIR directory. */
X     if( Tmd && !*Tmd && !res ) {
X        char *p = _strdup(path);
X        path = Build_path(Tmd,p); FREE(p);
X        res = ((cp->ce_time = DO_STAT(path,NIL(char),NIL(char *))) != (time_t)0L);
X     }
#endif
X
X     /* Have to use _strdup to set _first since Build_path, builds it's
X      * path names inside a static buffer. */
X     if( setfname )
X        if( (_first == NIL(char) && !fset) || res ) {
X           if( _first != NIL(char) ) FREE( _first );
X           _first = nodup ? NIL(char) : _strdup(path);
X           fset = 1;
X        }
X
X     DB_PRINT( "stat", ("_first [%s], path [%s]", _first, path) );
X     if( dir != lp->cl_prq->CE_NAME )  FREE(dir);
X      }
X   }
X
X   DB_PRINT( "mem", ("%s:-< mem %ld", cp->CE_NAME, (long) coreleft()) );
X   DB_RETURN( res );
}
SHAR_EOF
chmod 0640 dmake/stat.c ||
echo 'restore of dmake/stat.c failed'
Wc_c="`wc -c < 'dmake/stat.c'`"
test 7774 -eq "$Wc_c" ||
    echo 'dmake/stat.c: original size 7774, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/state.c ==============
if test -f 'dmake/state.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/state.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/state.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/state.c,v 1.1 1992/01/24 03:27:05 dvadura Exp $
-- SYNOPSIS -- .KEEP_STATE state file management
--
-- DESCRIPTION
--     Three routines to interface to the .KEEP_STATE state file.
--
--        Read_state()    - reads the state file if any.
--        Write_state()    - writes the state file.
--
--        Check_state(cp,how) - checks an entry returns 0 or 1
--                      and updates the entry.
--
-- AUTHOR
--      Dennis Vadura, [e-mail]
--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
--
-- COPYRIGHT
--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
--
--      This program is free software; you can redistribute it and/or
--      modify it under the terms of the GNU General Public License
--      (version 1), as published by the Free Software Foundation, and
--      found in the file 'LICENSE' included with this distribution.
--
--      This program is distributed in the hope that it will be useful,
--      but WITHOUT ANY WARRANTY; without even the implied warrant 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 this program;  if not, write to the Free Software
--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
--
-- LOG
--     $Log: state.c,v $
X * Revision 1.1  1992/01/24  03:27:05  dvadura
X * dmake Version 3.8, Initial revision
X *
*/
X
#include "extern.h"
X
typedef struct se {
X   char        *st_name;        /* name of cell        */
X   uint32    st_nkey;        /* name hash key    */
X   int        st_count;        /* how count for how    */
X   uint32    st_dkey;        /* directory hash key    */
X   uint32    st_key;            /* hash key        */
X   struct se    *st_next;
} KSTATE, *KSTATEPTR;
X
static KSTATEPTR _st_head  = NIL(KSTATE);
static KSTATEPTR _st_tail  = NIL(KSTATE);
static int       _st_upd   = FALSE;
static char     *_st_file  = NIL(char);
X
static int  _my_fgets ANSI((char *, int, FILE *));
X
PUBLIC void
Read_state()
{
X   char *buf;
X   char sizeb[20];
X   int  size;
X   FILE *fp;
X   KSTATEPTR sp;
X
X   if( (fp = Search_file(".KEEP_STATE", &_st_file)) != NIL(FILE) ) {
X      if( _my_fgets( sizeb, 20, fp ) ) {
X     size = atol(sizeb);
X     buf = MALLOC(size+2, char);
X
X     while( _my_fgets(buf, size, fp) ) {
X        TALLOC(sp, 1, KSTATE);
X        sp->st_name = _strdup(buf);
X        (void) Hash(buf, &sp->st_nkey);
X
X        if( _my_fgets(buf, size, fp) ) sp->st_count = atoi(buf);
X        if( _my_fgets(buf, size, fp) ) sp->st_dkey   = (uint32) atol(buf);
X
X        if( _my_fgets(buf, size, fp) )
X           sp->st_key = (uint32) atol(buf);
X        else {
X           FREE(sp);
X           break;
X        }
X
X        if( _st_head == NIL(KSTATE) )
X           _st_head = sp;
X        else
X           _st_tail->st_next = sp;
X
X        _st_tail = sp;
X     }
X
X     FREE(buf);
X      }
X
X      Closefile(fp);
X   }
}
X
X
PUBLIC void
Write_state()
{
X   static int in_write = 0;
X   register KSTATEPTR sp;
X   FILE *fp;
X
X   if( !_st_upd || !_st_file || (_st_file && !*_st_file) ||
X       Trace || in_write ) return;
X
X   in_write++;
X   if( (fp = Openfile(_st_file, TRUE, TRUE)) != NIL(FILE) ) {
X      int maxlen = 0;
X      int tmplen;
X
X      for( sp = _st_head; sp; sp=sp->st_next )
X     if( (tmplen = strlen(sp->st_name)+2) > maxlen )
X        maxlen = tmplen;
X
X      /* A nice arbitrary minimum size */
X      if( maxlen < 20 ) maxlen = 20;
X      fprintf( fp, "%d\n", maxlen );
X
X      for( sp = _st_head; sp; sp=sp->st_next ) {
X     uint16 hv;
X     uint32 hk;
X
X     if( Search_table(Defs, sp->st_name, &hv, &hk) ) {
X        fprintf( fp, "%s\n",  sp->st_name   );
X        fprintf( fp, "%d\n",  sp->st_count );
X        fprintf( fp, "%lu\n", sp->st_dkey   );
X        fprintf( fp, "%lu\n", sp->st_key    );
X     }
X      }
X
X      Closefile();
X   }
X   else
X      Fatal("Cannot open STATE file %s", _st_file);
X
X   in_write = 0;
}
X
X
PUBLIC int
Check_state( cp, recipes, maxrcp )
CELLPTR cp;
STRINGPTR *recipes;
int  maxrcp;
{
X   KSTATEPTR  st;
X   STRINGPTR sp;
X   int    i;
X   uint32 thkey;
X   uint32 hkey;
X   uint32 nkey;
X   uint32 dkey;
X   int    update = FALSE;
X
X   if(    strcmp(cp->CE_NAME,".REMOVE") == 0
X       || (cp->ce_attr & (A_PHONY|A_NOSTATE)) )
X      return(FALSE);
X
X   (void) Hash( cp->CE_NAME, &nkey ); thkey = nkey + (uint32) cp->ce_count;
X   (void) Hash( Pwd,  &dkey ); thkey += dkey;
X
X   Suppress_temp_file = TRUE;
X   for( i=0 ; i<maxrcp; i++ )
X      for(sp=recipes[i]; sp != NIL(STRING); sp=sp->st_next ) {
X     char *cmnd = Expand(sp->st_string);
X
X     (void) Hash(cmnd, &hkey); thkey += hkey;
X     FREE(cmnd);
X      }
X   Suppress_temp_file = FALSE;
X
X   for( st=_st_head; st != NIL(KSTATE); st=st->st_next ) {
X      if(    st->st_nkey   == nkey
X      && st->st_dkey   == dkey
X      && st->st_count  == cp->ce_count
X      && !strcmp(cp->CE_NAME, st->st_name) )
X     break;
X   }
X
X   if( st == NIL(KSTATE) ) {
X      KSTATEPTR nst;
X
X      TALLOC(nst, 1, KSTATE);
X      nst->st_name = cp->CE_NAME;
X      nst->st_nkey = nkey;
X      nst->st_dkey = dkey;
X      nst->st_key  = thkey;
X      nst->st_count = cp->ce_count;
X
X      if( _st_head == NIL(KSTATE) )
X     _st_head = nst;
X      else
X     _st_tail->st_next = nst;
X
X      _st_tail = nst;
X      _st_upd  = TRUE;
X   }
X   else if( st->st_key != thkey ) {
X      st->st_key = thkey;
X      _st_upd = update = TRUE;
X   }
X
X   return(st != NIL(KSTATE) && update);
SHAR_EOF
true || echo 'restore of dmake/state.c failed'
fi
echo 'End of part 31, continue with part 32'
echo 32 > _shar_seq_.tmp
exit 0
exit 0 # Just in case...