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

Text File | 1992-01-29 | 40.0 KB | 1,324 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Dennis Vadura)
Subject:  v27i111:  dmake - dmake Version 3.8, Part10/41
Message-ID: <[e-mail]>
X-Md4-Signature: 259e2101312464f2ed97ace9a0409c45
Date: Tue, 28 Jan 1992 03:15:01 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (Dennis Vadura)
Posting-number: Volume 27, Issue 111
Archive-name: dmake/part10
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.10 (part 10 of a multipart archive)
# do not concatenate these parts, unpack them in order with /bin/sh
# file dmake/infer.c continued
#
if test ! -r _shar_seq_.tmp; then
    echo 'Please unpack part 1 first!'
    exit 1
fi
(read Scheck
 if test "$Scheck" != 10; 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/infer.c' &&
X                     CELLPTR,int,int,char *,char *, int));
static ICELLPTR   _derive_prerequisites ANSI((ICELLPTR, ICELLPTR *));
static char *      _dump_inf_chain ANSI((ICELLPTR, int, int));
X
static int _prep = -1;    /* Integer value of Prep variable */
X
X
PUBLIC void
Infer_recipe( cp, setdirroot )/*
================================
X   Perform a breadth-first search of the inference graph and return if
X   possible an inferred set of prerequisites for making the current target.
*/
CELLPTR cp;
CELLPTR setdirroot;
{
X   ICELLPTR nomatch, match;
X
X   DB_ENTER("Infer_recipe");
X
X   if( cp->ce_attr & A_NOINFER ) {DB_VOID_RETURN;}
X   if( _prep == -1 ) _prep = atoi(Prep);  /* _dfa_subset needs _prep */
X
X   match = NIL(ICELL);
X   nomatch = _add_iset( NIL(ICELL), NIL(ICELL), NIL(CELL), NIL(DFALINK),
X            setdirroot, _prep+_count_dots(cp->CE_NAME), 0,
X            _strdup(cp->CE_NAME), NIL(char),
X            cp->ce_time != (time_t)0L);
X
X   /* Make sure we try whole heartedly to infer at least one suffix */
X   if( nomatch->ic_dmax == 0 ) ++nomatch->ic_dmax;
X
X   DB_EXECUTE( "inf", _dump_iset("nomatch",nomatch); );
X
X   while( nomatch != NIL(ICELL) ) {
X      ICELLPTR new_nomatch = NIL(ICELL);
X      ICELLPTR ic, pmatch, mmatch;
X      CELLPTR  prereq;
X      int      first;
X
X      for( ic=nomatch; ic != NIL(ICELL); ic=ic->ic_next ) {
X     int ipush = FALSE;
X
X     if( ic->ic_dir ) ipush = Push_dir(ic->ic_dir, ic->ic_name, FALSE);
X     match = _union_iset(match, _derive_prerequisites(ic, &new_nomatch));
X     if( ipush ) Pop_dir(FALSE);
X      }
X
X      DB_EXECUTE( "inf", _dump_iset("match",match); );
X      DB_EXECUTE( "inf", _dump_iset("nomatch",new_nomatch); );
X
X      /* We have now deduced the two sets MATCH and NOMATCH.  MATCH holds the
X       * set of edges that we encountered that matched.  If this set is empty
X       * then we can apply transitive closure (if enabled) to the elements of
X       * NOMATCH to see if we can find some other method to make the target.
X       *
X       * If MATCH is non-empty, we have found a method for making the target.
X       * It is the shortest method for doing so (ie. uses fewest number of
X       * steps).  If MATCH contains more than one element then we have a
X       * possible ambiguity.
X       */
X      if( match == NIL(ICELL) ) {
X     nomatch = new_nomatch;
X     if( Transitive ) continue;
X     goto all_done;
X      }
X
X      /* Ok, we have a set of possible matches in MATCH, we should check the
X       * set for ambiguity.  If more than one inference path exists of the
X       * same depth, then we may issue an ambigous inference error message.
X       *
X       * The message is suppressed if MATCH contains two elements and one of
X       * them is the empty-prerequisite-rule.  In this case we ignore the
X       * ambiguity and take the rule that infers the prerequisite.
X       *
X       * Also if there are any chains that rely on a non-existant prerequisite
X       * that may get made because it has a recipe then we prefer any that
X       * rely on existing final prerequisites over those that we have to make.
X       *
X       * NOTE:  May turn this around at some point.
X       */
X
X      /* Split out those that have to be made from those that end in
X       * prerequisites that already exist. */
X      pmatch = mmatch = NIL(ICELL);
X      for(; match; match = ic ) {
X     ic = match->ic_next;
X     match->ic_next = NIL(ICELL);
X
X     if( match->ic_exists )
X        pmatch = _union_iset(pmatch, match);
X     else
X        mmatch = _union_iset(mmatch, match);
X      }
X
X      if( pmatch )
X     match = pmatch;
X      else
X     match = mmatch;
X
X      /* Make sure it is unique */
X      if( match->ic_next != NIL(ICELL) ) {
X     int dump = (match->ic_next->ic_next != NIL(ICELL));
X
X     /* Check for definite ambiguity */
X     if( !dump )
X        if( (match->ic_meta->ce_prq && match->ic_next->ic_meta->ce_prq) ||
X            (!match->ic_meta->ce_prq && !match->ic_next->ic_meta->ce_prq)  )
X           dump = TRUE;
X        else if(!match->ic_meta->ce_prq && match->ic_next->ic_meta->ce_prq )
X           match = match->ic_next;
X
X     if( dump ) {
X        int count = 1;
X
X        Continue = TRUE;
X        Error( "Ambiguous inference chains for target '%s'", cp->CE_NAME );
X        for( ic=match; ic; ic=ic->ic_next )
X           (void) _dump_inf_chain(ic, TRUE, count++);
X        Fatal( "resolve ambiguity before proceeding.");
X        /*NOTREACHED*/
X     }
X      }
X
X      /* MATCH now points at the derived recipe.  We must now take cp, and
X       * construct the correct graph so that the make may proceed. */
X
X      if( Verbose & V_INFER ) {
X     char *tmp = _dump_inf_chain(match, TRUE, FALSE);
X     printf("%s:  Inferring prerequistes and recipes using:\n%s:  ... %s\n",
X         Pname, Pname, tmp );
X     FREE(tmp);
X      }
X
X      pmatch = NIL(ICELL);
X      prereq = NIL(CELL);
X      first  = TRUE;
X
X      while( match ) {
X         CELLPTR infcell=NIL(CELL);
X
X     /* Compute the inferred prerequisite first. */
X     if( match->ic_name ) {
X        if( match->ic_meta )
X           infcell = Def_cell( match->ic_name );
X        else
X           infcell = cp;
X
X        infcell->ce_flag |= F_TARGET;
X
X        if( infcell != cp ) {
X           infcell->ce_flag |= F_INFER;
X           if( !first ) infcell->ce_flag |= F_REMOVE;
X        }
X
X        if( !match->ic_flag )
X           infcell->ce_attr |= A_NOINFER;
X
X        first = FALSE;
X     }
X
X     /* Add global prerequisites from previous rule if there are any and
X      * the recipe. */
X     if( pmatch ) {
X        CELLPTR imeta = pmatch->ic_meta;
X        LINKPTR lp;
X
X        infcell->ce_per   = pmatch->ic_dfa->dl_per;
X        infcell->ce_attr |= (imeta->ce_attr & A_TRANSFER);
X
X        if( !(infcell->ce_flag & F_RULES) ) {
X           infcell->ce_flag |= (imeta->ce_flag&(F_SINGLE|F_GROUP))|F_RULES;
X           infcell->ce_recipe = imeta->ce_recipe;
X        }
X
X        pmatch->ic_dfa->dl_per = NIL(char);
X
X        /* If infcell already had a directory set then modify it based on
X         * whether it was the original cell or some intermediary. */
X        if( imeta->ce_dir )
X           if( infcell->ce_dir && infcell == cp ) {
X          /* cp->ce_dir was set and we have pushed the directory prior
X           * to calling this routine.  We should therefore pop it and
X           * push the new concatenated directory required by the
X           * inference. */
X          infcell->ce_dir=_strdup(Build_path(infcell->ce_dir,
X                             imeta->ce_dir));
X           }
X           else
X          infcell->ce_dir = imeta->ce_dir;
X
X        for( lp=imeta->ce_indprq; lp != NIL(LINK); lp=lp->cl_next ) {
X           char    *name = lp->cl_prq->CE_NAME;
X           CELLPTR tcp;
X
X           name = _build_name( cp->CE_NAME, name, infcell->ce_per );
X           tcp  = Def_cell( name );
X           tcp->ce_flag |= F_REMOVE;
X           Add_prerequisite( infcell, tcp, FALSE, FALSE );
X
X           if( Verbose & V_INFER )
X          printf( "%s:  Inferred indirect prerequisite [%s]\n",
X              Pname, name );
X           FREE(name);
X        }
X     }
X
X     /* Add the previous cell as the prerequisite */
X     if( prereq )
X        (Add_prerequisite(infcell,prereq,FALSE,FALSE))->cl_flag |= F_TARGET;
X
X     pmatch = match;
X     prereq = infcell;
X     match  = match->ic_parent;
X      }
X
X      DB_PRINT("inf", ("Terminated due to a match"));
X      break;
X   }
X
all_done:
X   _free_icells();
X
X   DB_VOID_RETURN;
}
X
X
static ICELLPTR
_derive_prerequisites( ic, nnmp )/*
===================================
X   Take a cell and derive a set of prerequisites from the cell.  Categorize
X   them into those that MATCH (ie. those that we found in the file system),
X   and those that do not match NOMATCH that we may possibly have a look at
X   later.  When we process the next level of the breadth-first search.
X
X   Once MATCH is non-empty we will stop inserting elements into NOMATCH
X   since we know that either MATCH is successful and unique or it will
X   issue an ambiguity error.  We will never go on to look at elements
X   in NOMATCH after wards. */
ICELLPTR ic;
ICELLPTR *nnmp;
{
X   ICELLPTR   match = NIL(ICELL);
X   DFALINKPTR pdfa;
X   DFALINKPTR dfas;
X
X   DB_ENTER("_derive_prerequisites");
X
X   /* If none of the inference nodes match then forget about the inference.
X    * The user did not tell us how to make such a target.  We also stop the
X    * Inference if the new set of DFA's is a proper subset of a previous
X    * subset and it's PREP counts exceed the value of Prep.
X    */
X   dfas = _dfa_subset( Match_dfa(ic->ic_name), &ic->ic_dfastack );
X
X   DB_EXECUTE("inf", _dump_dfa_stack(dfas, &ic->ic_dfastack); );
X
X   /* Ok, we have nothing here to work with so return an empty cell. */
X   if( dfas == NIL(DFALINK) ) {
X      DB_PRINT( "mem", ("%s:<- mem %ld",ic->ic_name, (long)coreleft()));
X      DB_PRINT( "inf", ("<<< Exit, no dfas, cp = %04x", NIL(CELL)) );
X      DB_RETURN( NIL(ICELL) );
X   }
X
X   /* Save the dfas, we are going to use on the stack for this cell. */
X   ic->ic_dfastack.df_set = dfas;
X
X   /* Run through the %-meta cells, build the prerequisite cells.  For each
X    * %-meta go through it's list of edges and try to use each in turn to
X    * decuce a likely prerequisite.  We perform a breadth-first search
X    * matching the first path that results in a unique method for making the
X    * target. */
X   for( pdfa = dfas; pdfa != NIL(DFALINK); pdfa = pdfa->dl_next ) {
X      LINK tl;
X      LINKPTR edge;
X      CELLPTR pmeta;
X
X      pmeta = pdfa->dl_meta;
X      DB_PRINT( "inf", ("Using dfa:  [%s]", pmeta->CE_NAME) );
X
X      /* If the %-meta is a singleton meta then deal with it differently from
X       * the case when it is a bunch of %-meta's found on the original entries
X       * prerequisite list. */
X      if( pmeta->ce_flag & F_MULTI )
X     edge = pmeta->ce_prq;
X      else {
X     tl.cl_prq = pmeta;
X     tl.cl_next = NIL(LINK);
X     edge = &tl;
X      }
X
X      /* Now run through the list of prerequisite edge's for the %-meta. */
X      for( ; edge != NIL(LINK); edge = edge->cl_next ) {
X     HASHPTR  thp;        /* temporary hash table pointer        */
X     HASH     iprqh;    /* hash cell for new prerequisite    */
X     CELL     iprq;        /* inferred prerequisite to look for    */
X     CELLPTR  idirroot;    /* Inferred prerequisite root        */
X     CELLPTR  nidirroot;    /* Inferred prerequisite root        */
X     STRINGPTR ircp;    /* Inferred prerequisites recipe    */
X     char     *idir;    /* directory to CD to.            */
X     int      ipush = 0;    /* flag for push on inferred prereq     */
X     char     *name = NIL(char);         /* prerequisite name    */
X     CELLPTR  meta = edge->cl_prq;
X     int      dmax_fix;
X     int      trans;
X     int      noinf;
X     int      exists;
X
X     if( meta->ce_prq ) name = meta->ce_prq->cl_prq->CE_NAME;
X
X     DB_PRINT( "inf", ("Trying edge from [%s] to [%s] for [%s]",
X           meta->CE_NAME, name?name:"(nil)", ic->ic_name) );
X
X     /* Set the temp CELL used for building prerequisite candidates to
X      * all zero so that we don't have to keep initializing all the
X      * fields. */
X     {
X        register char *s = (char *) &iprq;
X        register int   n = sizeof(CELL);
X        while( n ) { *s++ = '\0'; n--; }
X     }
X
X     nidirroot = idirroot = ic->ic_setdirroot;
X     iprq.ce_name = &iprqh;
X
X     if( name ) {
X        /* Build the prerequisite name from the %-meta prerequisite given
X         * for the %-meta rule. */
X        iprqh.ht_name = _build_name( ic->ic_name, name, pdfa->dl_per );
X        if((dmax_fix = (_count_dots(name)-_count_dots(meta->CE_NAME))) < 0)
X           dmax_fix = 0;
X
X        if( !strcmp(ic->ic_name, iprqh.ht_name) ||
X        (_count_dots(iprqh.ht_name) > ic->ic_dmax + dmax_fix) ) {
X           FREE( iprqh.ht_name );
X           continue;
X        }
X
X        DB_PRINT( "inf", ("Checking prerequisite [%s]", iprqh.ht_name) );
X
X        /* See if the prerequisite CELL has been previously defined.  If
X         * it has, then make a copy of it into iprq, and use it to try
X         * the inference.  We make the copy so that we don't modify the
X         * stat of the inferred cell if the inference fails.
X         */
X        thp = Get_name( iprqh.ht_name, Defs, FALSE );
X        if(thp != NIL(HASH)) {
X           iprq = *thp->CP_OWNR;
X           ircp = iprq.ce_recipe;
X        }
X        else
X           ircp = NIL(STRING);
X     }
X     else
X        iprqh.ht_name = NIL(char);
X
X
X     /* If the %-meta has a .SETDIR set then we change to the new
X      * directory prior to performing the stat of the new prerequisite.
X      * If the change of directory fails then the rule is droped from
X      * further consideration.
X      */
X     if( iprq.ce_dir ) {
X        if( ipush = Push_dir(iprq.ce_dir, iprqh.ht_name, TRUE) ) {
X           nidirroot = thp->CP_OWNR;
X           idir      = Pwd;
X        }
X        else {
X           if( iprqh.ht_name ) FREE( iprqh.ht_name );
X           continue;
X        }
X     }
X     else
X        idir = NIL(char);
X
X
X     /* Stat the inferred prerequisite.
X      */
X     if( name ) {
X        if( Verbose & V_INFER )
X           printf( "%s:  Trying prerequisite [%s] for [%s]\n", Pname,
X               iprqh.ht_name, ic->ic_name );
X
X        if( !(iprq.ce_flag & F_STAT) ) Stat_target(&iprq, FALSE);
X     }
X
X
X     /* If the STAT succeeded or if the prerequisite has a recipe for
X      * making it then it's a match and a candidate for getting infered.
X      * Otherwise it is not a match, and we cannot yet tell if it is
X      * going to be a successful path to follow, so we save it for
X      * later consideration.
X      */
X     noinf = ((Glob_attr)&A_NOINFER);
X     if( meta->ce_prq )
X        noinf |= ((meta->ce_prq->cl_prq->ce_attr)&A_NOINFER);
X     trans = Transitive || !noinf;
X     exists = (iprq.ce_time != (time_t)0L);
X
X     if( exists || (ircp != NIL(STRING)) || !name ) {
X        match = _add_iset( match, ic, meta, pdfa, idirroot, ic->ic_dmax,
X                   trans, iprq.ce_name->ht_name, idir, exists );
X        DB_PRINT("inf",("Added to MATCH %s",iprq.ce_name->ht_name));
X     }
X     else if( !noinf && match == NIL(ICELL) ) {
X        *nnmp = _add_iset( *nnmp, ic, meta, pdfa, nidirroot, ic->ic_dmax,
X                   trans, iprq.ce_name->ht_name, idir, exists );
X        DB_PRINT("inf",("Added to NOMATCH %s",iprq.ce_name->ht_name));
X     }
X
X     /* If we pushed a directory for the inferred prerequisite then
X      * pop it.
X      */
X     if( ipush ) Pop_dir(FALSE);
X     if( iprqh.ht_name ) FREE(iprqh.ht_name);
X      }
X   }
X
X   DB_RETURN(match);
}
X
X
static char *
_build_name( tg, meta, per )
char *tg;
char *meta;
char *per;
{
X   char    *name;
X
X   name = Apply_edit( meta, "%", per, FALSE, FALSE );
X   if( strchr(name, '$') ) {
X      HASHPTR m_at;
X      char *tmp;
X
X      m_at = Def_macro( "@", tg, M_MULTI );
X      tmp = Expand( name );
X
X      if( m_at->ht_value != NIL(char) ) {
X     FREE( m_at->ht_value );
X     m_at->ht_value = NIL(char);
X      }
X
X      if( name != meta ) FREE( name );
X      name = tmp;
X   }
X   else if( name == meta )
X      name = _strdup( name );
X
X   return(name);
}
X
X
static DFALINKPTR
_dfa_subset( pdfa, stack )/*
============================
X   This is the valid DFA subset computation.  Whenever a CELL has a Match_dfa
X   subset computed this algorithm is run to see if any of the previously
X   computed sets on the DFA stack are proper subsets of the new set.  If they
X   are, then any elements of the matching subset whose Prep counts exceed
X   the allowed maximum given by Prep are removed from the computed DFA set,
X   and hence from consideration, thereby cutting off the cycle in the
X   inference graph. */
DFALINKPTR       pdfa;
register DFASETPTR stack;
{
X   register DFALINKPTR element;
X   DFALINKPTR          nelement;
X
X   DB_ENTER( "_dfa_subset" );
X
X   for(; pdfa != NIL(DFALINK) && stack != NIL(DFASET); stack = stack->df_next) {
X      int subset = TRUE;
X
X      for( element=stack->df_set; subset && element != NIL(DFALINK);
X           element=element->dl_next ) {
X         register DFALINKPTR subel;
X
X     for( subel = pdfa;
X          subel != NIL(DFALINK) && (subel->dl_meta != element->dl_meta);
X          subel = subel->dl_next );
X
X     if( subset = (subel != NIL(DFALINK)) ) element->dl_member = subel;
X      }
X
X      if( subset )
X     for( element=stack->df_set; element != NIL(DFALINK);
X          element=element->dl_next ) {
X        DFALINKPTR mem = element->dl_member;
X        int        npr = element->dl_prep + 1;
X
X        if( npr > _prep )
X           mem->dl_delete++;
X        else
X           mem->dl_prep = npr;
X     }
X   }
X
X   for( element = pdfa; element != NIL(DFALINK); element = nelement ) {
X      nelement = element->dl_next;
X
X      if( element->dl_delete ) {
X     /* A member of the subset has a PREP count equal to PREP, so
X      * it should not be considered further in the inference, hence
X      * we remove it from the doubly linked set list */
X     if( element == pdfa )
X        pdfa = element->dl_next;
X     else
X        element->dl_prev->dl_next = element->dl_next;
X
X     if( element->dl_next != NIL(DFALINK) )
X        element->dl_next->dl_prev = element->dl_prev;
X
X     DB_PRINT("inf", ("deleting dfa [%s]", element->dl_meta->CE_NAME));
X     FREE( element->dl_per );
X     FREE( element );
X      }
X   }
X
X   DB_RETURN( pdfa );
}
X
X
X
static void
_free_dfas( chain )/*
=====================
X   Free the list of DFA's constructed by Match_dfa, and linked together by
X   LINK cells.  FREE the % value as well, as long as it isn't NIL. */
DFALINKPTR chain;
{
X   register DFALINKPTR tl;
X
X   DB_ENTER( "_free_dfas" );
X
X   for( tl=chain; tl != NIL(DFALINK); chain = tl ) {
X      tl = tl->dl_next;
X
X      DB_PRINT( "inf", ("Freeing DFA [%s], %% = [%s]", chain->dl_meta->CE_NAME,
X                chain->dl_per) );
X
X      if( chain->dl_per != NIL(char) ) FREE( chain->dl_per );
X      FREE( chain );
X   }
X
X   DB_VOID_RETURN;
}
X
X
static int
_count_dots( name )/*
=====================*/
char *name;
{
X   register char *p;
X   register int  i = 0;
X
X   for( p = name; *p; p++ ) if(*p == '.') i++;
X
X   return( i );
}
X
X
static ICELLPTR _icells = NIL(ICELL);
#ifdef DBUG
static int _icell_cost = 0;
#endif
X
static ICELLPTR
_add_iset( iset, parent, meta, dfa, setdirroot, dmax, noinf, name, dir, exists)
ICELLPTR   iset;
ICELLPTR   parent;
CELLPTR    meta;
DFALINKPTR dfa;
CELLPTR    setdirroot;
int       dmax;
int       noinf;
char      *name;
char      *dir;
int       exists;
{
X   ICELLPTR icell;
X
X   DB_ENTER("_add_iset");
X   TALLOC(icell, 1, ICELL);
X
X   DB_EXECUTE("inf", _icell_cost+=(sizeof(ICELL)+strlen(dir?dir:"")+strlen(name?name:"")+2););
X
X   icell->ic_meta = meta;
X   icell->ic_dfa  = dfa;
X   icell->ic_setdirroot = setdirroot;
X
X   if( parent ) icell->ic_dfastack.df_next = &parent->ic_dfastack;
X
X   icell->ic_dmax = dmax;
X   icell->ic_dir = _strdup(dir);
X   icell->ic_name = _strdup(name);
X   icell->ic_parent = parent;
X   icell->ic_next = iset;
X   icell->ic_flag = noinf;
X   icell->ic_exists = exists;
X
X   icell->ic_link = _icells;
X   _icells = icell;
X
X   DB_RETURN(icell);
}
X
X
static void
_free_icells()
{
X   register ICELLPTR ic;
X
X   DB_ENTER("_free_icells");
X
X   for( ; _icells; _icells = ic ) {
X      ic = _icells->ic_link;
X
X      _free_dfas(_icells->ic_dfastack.df_set);
X      if( _icells->ic_dir ) FREE(_icells->ic_dir);
X      if( _icells->ic_name) FREE(_icells->ic_name);
X      FREE(_icells);
X   }
X
X   DB_PRINT("inf",("Used %d memory for icells",_icell_cost));
X   DB_EXECUTE("inf", _icell_cost=0; );
X
X   DB_VOID_RETURN;
}
X
X
static ICELLPTR
_union_iset( iset, uset )
ICELLPTR iset;
ICELLPTR uset;
{
X   register ICELLPTR ic;
X
X   if( iset == NIL(ICELL) ) return(uset);
X
X   for( ic=iset; ic->ic_next != NIL(ICELL); ic=ic->ic_next );
X   ic->ic_next = uset;
X
X   return(iset);
}
X
X
static char *
_dump_inf_chain( ip, flag, print )/*
====================================*/
ICELLPTR ip;
int      flag;
int     print;
{
X   char *tmp;
X
X   if( ip == NIL(ICELL) ) return(NIL(char));
X
X   tmp = _dump_inf_chain(ip->ic_parent, FALSE, FALSE);
X
X   if( ip->ic_meta ) {
X      tmp = _strjoin(tmp, "(", -1, TRUE);
X      tmp = _strjoin(tmp, ip->ic_meta->CE_NAME, -1, TRUE);
X
X      if( ip->ic_dir && !*ip->ic_dir ) {
X     tmp = _strjoin(tmp, "[", -1, TRUE);
X     if( strncmp(Makedir,ip->ic_dir, strlen(Makedir)) )
X        tmp = _strjoin(tmp, ip->ic_dir, -1, TRUE);
X     else
X        tmp = _strjoin(tmp, ip->ic_dir+strlen(Makedir)+1, -1, TRUE);
X     tmp = _strjoin(tmp, "]", -1, TRUE);
X      }
X      tmp = _strjoin(tmp, (ip->ic_name)?") -->":")", -1, TRUE);
X   }
X
X   if( ip->ic_name ) tmp = _strapp( tmp, ip->ic_name );
X
X   if( flag && ip->ic_meta->ce_prq) {
X      tmp = _strjoin(tmp, "(", -1, TRUE);
X      tmp = _strjoin(tmp, ip->ic_meta->ce_prq->cl_prq->CE_NAME, -1, TRUE);
X      tmp = _strjoin(tmp, ")", -1, TRUE);
X   }
X
X   if( print ) {
X      fprintf( stderr, "%s:  %2d. %s\n", Pname, print, tmp );
X      FREE(tmp);
X      tmp = NIL(char);
X   }
X
X   return(tmp);
}
X
X
#ifdef DBUG
_dump_dfa_stack(dfas, dfa_stack)
DFALINKPTR dfas;
DFASETPTR  dfa_stack;
{
X   register DFALINKPTR pdfa;
X   char      *tmp = NIL(char);
X   DFASETPTR ds;
X
X   for( pdfa = dfas; pdfa != NIL(DFALINK); pdfa = pdfa->dl_next )
X      tmp = _strapp( tmp, pdfa->dl_meta->CE_NAME );
X
X   tmp = _strapp( tmp, ":: {" );
X   for( ds = dfa_stack; ds != NIL(DFASET); ds = ds->df_next ) {
X      tmp = _strapp( tmp, "[" );
X      for( pdfa = ds->df_set; pdfa != NIL(DFALINK); pdfa = pdfa->dl_next )
X     tmp = _strapp( tmp, pdfa->dl_meta->CE_NAME );
X      tmp = _strapp( tmp, "]" );
X   }
X   tmp = _strapp( tmp, "}" );
X
X   printf( "DFA set and stack contents:\n%s\n", tmp );
X   FREE(tmp);
}
X
X
_dump_iset( name, iset )
char     *name;
ICELLPTR iset;
{
X   int cell = 0;
X
X   printf( "**** ISET for %s\n", name );
X   for( ; iset != NIL(ICELL); iset = iset->ic_next ){
X      printf( "cell %d\n", cell++ );
X      if( iset->ic_meta )
X     printf( "edge: %s --> %s\n", iset->ic_meta->CE_NAME,
X         iset->ic_meta->ce_prq ?
X         iset->ic_meta->ce_prq->cl_prq->CE_NAME :
X         "(nil)" );
X      else
X     printf( "edge: (nil)\n" );
X
X      if( iset->ic_dfa )
X     printf( "dfa: %s\n", iset->ic_dfa->dl_meta->CE_NAME );
X      else
X     printf( "dfa: (nil)\n" );
X
X      printf( "sdr: %04x\n", iset->ic_setdirroot );
X      _dump_dfa_stack(iset->ic_dfastack.df_set, &iset->ic_dfastack);
X
X      printf( "dmax: %d\n", iset->ic_dmax );
X      printf( "name: %s\n", iset->ic_name );
X      printf( "dir:  %s\n", iset->ic_dir?iset->ic_dir:"(nil)" );
X
X      printf( "parent: " );
X      if( iset->ic_parent )
X    if( iset->ic_parent->ic_meta )
X       printf( "%s --> %s\n",
X               iset->ic_parent->ic_meta->CE_NAME,
X           iset->ic_parent->ic_meta->ce_prq ?
X           iset->ic_parent->ic_meta->ce_prq->cl_prq->CE_NAME :
X           "(nil)" );
X    else
X       printf( "(nil)\n" );
X      else
X     printf( "(nil)\n" );
X   }
X   printf( "==================================\n" );
}
#endif
SHAR_EOF
chmod 0640 dmake/infer.c ||
echo 'restore of dmake/infer.c failed'
Wc_c="`wc -c < 'dmake/infer.c'`"
test 24141 -eq "$Wc_c" ||
    echo 'dmake/infer.c: original size 24141, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/itypes.h ==============
if test -f 'dmake/itypes.h' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/itypes.h (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/itypes.h' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/itypes.h,v 1.1 1992/01/24 03:29:40 dvadura Exp $
-- SYNOPSIS -- type declarations for common types
--
-- DESCRIPTION
--     portable type declarations.
--
-- 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: itypes.h,v $
X * Revision 1.1  1992/01/24  03:29:40  dvadura
X * dmake Version 3.8, Initial revision
X *
*/
X
X
#ifndef ITYPES_h
#define    ITYPES_h
X
#if defined(M_I86) || defined(MC68000)
typedef char  int8;               /* typedefs for right size ints */
typedef int   int16;
typedef long  int32;
typedef unsigned char  uint8;
typedef unsigned int   uint16;
typedef unsigned long  uint32;
#else
typedef char  int8;               /* typedefs for right size ints */
typedef short int16;
typedef long  int32;
typedef unsigned char  uint8;
typedef unsigned short uint16;
typedef unsigned long  uint32;
#endif
X
#endif
X
SHAR_EOF
chmod 0640 dmake/itypes.h ||
echo 'restore of dmake/itypes.h failed'
Wc_c="`wc -c < 'dmake/itypes.h'`"
test 1822 -eq "$Wc_c" ||
    echo 'dmake/itypes.h: original size 1822, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/mac/arlib.c ==============
if test ! -d 'dmake/mac'; then
    mkdir 'dmake/mac'
fi
if test -f 'dmake/mac/arlib.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/mac/arlib.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/mac/arlib.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/mac/arlib.c,v 1.1 1992/01/24 03:29:41 dvadura Exp $
-- SYNOPSIS -- Library access code.
--
-- DESCRIPTION
--  This implementation uses the library timestamp inplace of the
--  library member timestamp.
--
-- 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: arlib.c,v $
X * Revision 1.1  1992/01/24  03:29:41  dvadura
X * dmake Version 3.8, Initial revision
X *
*/
X
#include "extern.h"
X
PUBLIC time_t
seek_arch(char * /* name */, char *lib) {
X   static   int warned = FALSE;
X
X   if (!warned && !(Glob_attr&A_SILENT))
X    warned = TRUE,
X    Warning("Can't extract library member timestamp;\n\
X    using library timestamp instead.");
X   return (Do_stat(lib, NULL, NULL));
}
X
PUBLIC int
touch_arch(char * /* name */, char *lib) {
X   static   int warned = FALSE;
X
X   if (!warned && !(Glob_attr&A_SILENT))
X    warned = TRUE,
X    Warning("Can't update library member timestamp;\n\
X    touching library instead.");
X   return (Do_touch(lib, NULL, NULL));
}
SHAR_EOF
chmod 0640 dmake/mac/arlib.c ||
echo 'restore of dmake/mac/arlib.c failed'
Wc_c="`wc -c < 'dmake/mac/arlib.c'`"
test 1950 -eq "$Wc_c" ||
    echo 'dmake/mac/arlib.c: original size 1950, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/mac/bogus.c ==============
if test -f 'dmake/mac/bogus.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/mac/bogus.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/mac/bogus.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/mac/bogus.c,v 1.1 1992/01/24 03:29:42 dvadura Exp $
-- SYNOPSIS -- Write the shell of subroutines we can't or don't
--             need to implement
--
-- DESCRIPTION
--  dmake uses a couple of functions which I am either unable to figure out
--  how to implement or which are not needed.  The shells of these routines
--  are in this file.
--
-- 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: bogus.c,v $
X * Revision 1.1  1992/01/24  03:29:42  dvadura
X * dmake Version 3.8, Initial revision
X *
*/
X
#include "extern.h"
X
X
X
/*
X * tzset() is a Microsoft "extension" to ANSI C.  It sets global
X * variables telling if we are in dayling savings time, the time
X * zone, and difference between the current time and GMT.
X * None of these globals are used by dmake, so this routine is
X * not needed
X */
PUBLIC void tzset () {}
X
X
X
/*
X * Add an environmental variable that child processes can use.
X * Since MPW currently doesn't allow child processes, this isn't
X * needed.
X */
PUBLIC int putenv (char * /* pEnvString */) {return (0);}
X
X
X
/*
X * Execute a child process.  This may be able to be done with
X * the MPW system() call someday, but cannot be done currently.
X */
PUBLIC int runargv (CELLPTR /* target */, int /* ignore */, int /* group */,
X                    int /* last */, int /* shell */, char * /* pCmd */) {
X    static int warned = FALSE;
X
X    if (!warned && !(Glob_attr & A_SILENT)) {
X        warned = TRUE;
X        Fatal ("Can't execute any targets:  use '-n' option.");
X    } /* if */
X
X    return (0);
} /* int runargv () */
X
X
X
/*
X * Wait for the child process to complete.  Only needed to be implemented
X * if we could executing multiple processes at once.
X */
PUBLIC int Wait_for_child(int /* abort_flg */, int /* pid */) {return (1);}
X
X
X
/*
X * Do any cleanup for any processes when we quit.
X */
PUBLIC void Clean_up_processes() {}
SHAR_EOF
chmod 0640 dmake/mac/bogus.c ||
echo 'restore of dmake/mac/bogus.c failed'
Wc_c="`wc -c < 'dmake/mac/bogus.c'`"
test 2850 -eq "$Wc_c" ||
    echo 'dmake/mac/bogus.c: original size 2850, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/mac/config.h ==============
if test -f 'dmake/mac/config.h' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/mac/config.h (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/mac/config.h' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/mac/config.h,v 1.1 1992/01/24 03:29:43 dvadura Exp $
-- SYNOPSIS -- Configurarion include file for the Macintosh.
--
-- DESCRIPTION
--  There is one of these for each specific machine configuration.
--  It can be used to further tweek the machine specific sources
--  so that they compile.
--
-- 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: config.h,v $
X * Revision 1.1  1992/01/24  03:29:43  dvadura
X * dmake Version 3.8, Initial revision
X *
*/
X
/* Definitions left out of StdArg.h */
#define va_alist     ...
#define va_dcl
X
#define CONST const
X
#define FALSE 0
#define TRUE 1
X
/* signal extensions */
#define SIGQUIT SIGTERM
X
X
/* Mac doesn't have a stat function or structure so we have to add one in. */
typedef long off_t;
struct stat {
X    unsigned short st_mode;
X    off_t st_size;
X    time_t st_mtime;
X    time_t st_ctime;
X    /* struct stat has lots of other fields, but we don't need them for dmake */
}; /* struct stat */
#define S_IFDIR  0040000    /* directory */
#define S_IFREG  0100000    /* regular */
#define S_IFMT   (S_IFDIR | S_IFREG)    /* Format */
#define S_IREAD  0000400    /* read owner permission */
#define S_IWRITE 0000200    /* write owner permission */
#define S_IEXEC  0000100    /* execute owner permission */
X
X
/* Global for environmental variables */
extern char **environ;
X
X
/* We really want main to be in the mac directory
X   so that we get the envp argument */
#define main(argc, argv)    dmakemain(argc, argv)
X
/* Directory/file info. and directory moving */
int stat (char *pPath, struct stat *pStat);
char *getcwd (char *pPath, size_t pathSize);
int chdir (char *pPath);
int utime (char *pPath, time_t *pTimes);
X
/* Routines to handle conversion from Unix file names to Mac file names */
char *Unix2MacFName(char *pUnixName);
FILE *MacFOpen (char *pName, char *pMode);
#define fopen(pFName, pMode)    MacFOpen(pFName, pMode)
X
/* a small problem with pointer to voids on some unix machines needs this */
#define PVOID void *
SHAR_EOF
chmod 0640 dmake/mac/config.h ||
echo 'restore of dmake/mac/config.h failed'
Wc_c="`wc -c < 'dmake/mac/config.h'`"
test 2976 -eq "$Wc_c" ||
    echo 'dmake/mac/config.h: original size 2976, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/mac/config.mk ==============
if test -f 'dmake/mac/config.mk' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/mac/config.mk (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/mac/config.mk' &&
# This is an OS Mac specific configuration file
#   It assumes that OBJDIR, TARGET and DEBUG are previously defined.
#   It defines  CFLAGS, LDARGS, CPPFLAGS, STARTUPFILE, LDOBJS
#   It augments SRC, OBJDIR, TARGET, CFLAGS, LDLIBS
#
X
STARTUPFILE = :$(OS):startup.mk
X
CPPFLAGS    = $(CFLAGS)
LDOBJS      = $(CSTARTUP) :$(OBJDIR):{$(<:f)}
LDARGS      = $(LDFLAGS) -o $@ $(LDOBJS) $(LDLIBS)
X
# Debug flags
DB_CFLAGS   = -sym on
DB_LDFLAGS  = -sym on
DB_LDLIBS   =
X
# NO Debug flags
NDB_CFLAGS  = -sym off
NDB_LDFLAGS = -sym off
NDB_LDLIBS  =
X
# Local configuration modifications for CFLAGS.
CFLAGS     += -I :$(OS) -d _MPW -s $(<:b)
LDFLAGS    += -w -c 'MPS ' -t MPST
X
# Since we writing out what files we want to execute, we can't use .SETDIR
# to specify the files to compile in the Mac directory.
# Instead, we copy the files to the (top-level) current directory and compile
# them there.
%.c : ":$(OS):%.c"
X    duplicate -y $< $@
X
# Common Mac source files.
OS_SRC = arlib.c bogus.c dirbrk.c directry.c environ.c main.c rmprq.c \
X         ruletab.c tempnam.c tomacfil.c
.IF $(SHELL) != mwp
X   .SETDIR=$(OS) : $(OS_SRC)
.ENDIF
SRC += $(OS_SRC)
X
# Set source dirs so that we can find files named in this
# config file.
.SOURCE.h : $(OS)
SHAR_EOF
chmod 0640 dmake/mac/config.mk ||
echo 'restore of dmake/mac/config.mk failed'
Wc_c="`wc -c < 'dmake/mac/config.mk'`"
test 1234 -eq "$Wc_c" ||
    echo 'dmake/mac/config.mk: original size 1234, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/mac/dirbrk.c ==============
if test -f 'dmake/mac/dirbrk.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/mac/dirbrk.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/mac/dirbrk.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/mac/dirbrk.c,v 1.1 1992/01/24 03:29:44 dvadura Exp $
-- SYNOPSIS -- define the directory separator string.
--
-- DESCRIPTION
--  Define this string for any character that may appear in a path name
--  and can be used as a directory separator.
--
-- 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: dirbrk.c,v $
X * Revision 1.1  1992/01/24  03:29:44  dvadura
X * dmake Version 3.8, Initial revision
X *
*/
X
#include "extern.h"
X
/* mac only uses ':' */
char*   DirBrkStr = ":";
X
/*
** Return TRUE if the name is the full specification of a path name to a file
** starting at the root of the file system, otherwise return FALSE
*/
PUBLIC int
If_root_path(name)
char *name;
{
X   name = Unix2MacFName (name);
X   return( (strchr(name, ':') != NIL(char)) &&
X           (name[0] != ':') );
}
SHAR_EOF
chmod 0640 dmake/mac/dirbrk.c ||
echo 'restore of dmake/mac/dirbrk.c failed'
Wc_c="`wc -c < 'dmake/mac/dirbrk.c'`"
test 1787 -eq "$Wc_c" ||
    echo 'dmake/mac/dirbrk.c: original size 1787, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/mac/directry.c ==============
if test -f 'dmake/mac/directry.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/mac/directry.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/mac/directry.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/mac/directry.c,v 1.1 1992/01/24 03:29:45 dvadura Exp $
-- SYNOPSIS -- Fake directory and file functions for the Mac
--
-- DESCRIPTION
--  This file contains implementations for some ANSI standard routines dmake
--  uses which are not otherwise available for the mac.
--
--  Assume we are using at least 128K ROMS.
--
-- 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.
SHAR_EOF
true || echo 'restore of dmake/mac/directry.c failed'
fi
echo 'End of part 10, continue with part 11'
echo 11 > _shar_seq_.tmp
exit 0
exit 0 # Just in case...