ARM Club 3/TheARMClub_PDCD3.iso/hensa/programming/make_1/!make_c_Make

Text File | 1992-12-07 | 4.8 KB | 261 lines

/* > C.Make
 * Do the actual making for make
 */

#include "h.h"


/*
 * Exec a shell that returns exit status correctly (/bin/esh).
 * The standard EON shell returns the process number of the last
 * async command, used by the debugger (ugg).
 * [exec on eon is like a fork+exec on unix]
 * As this is a 'single tasking' OS , I put it into a file which
 * is EXEC'd MDJ
 * RISC OS specific on how to get the ignore  .... 07-11-90

 */
int
dosh(char *string,bool ignore)
{
  char ss[LZ];
  strcpy(ss,string);
  convertLine(ss);
  if (ignore)
    fprintf(outfile,"%s\n",ss);
  else
    fprintf(outfile,"IF Sys$ReturnCode=0 THEN %s\n",ss);
  return 0;
}



/*
 * Do commands to make a target
 */
void
docmds1(struct name *np, struct line *lp)

{
   bool     ssilent;
   bool     signore;
   register char *    q;
   register char *    p;
   register struct cmd *   cp;



   for (cp =(lp->l_cmd); cp!=NULL ; cp = (cp->c_next))
   {

      strcpy(str1, cp->c_cmd);
/*
      printf("To do: %s\n",cp->c_cmd);
*/
      expand(str1);
/*
      printf("Exp. : %s\n",str1);
*/
      q = str1;
      ssilent = silent;
      signore = ignore;
      while ((*q == '@') || (*q == '-'))
      {
    if (*q == '@')     /*  Specific silent  */
       ssilent = TRUE;
    else     /*  Specific ignore  */
       signore = TRUE;
    q++;     /*  Not part of the command  */
      }

      if (!domake)
    ssilent = 0;

      if (!ssilent)
    fputs("Need to do: ", stdout);

      for (p=q; *p; p++)
      {
    if (*p == '\n' && p[1] != '\0')
    {
       *p = ' ';
       if (!ssilent)
          fputs("\\\n", stdout);
    }
    else if (!ssilent)
       putchar(*p);
      }
      if (!ssilent)
    putchar('\n');

      if (domake)
      {        /*  Get the shell to execute it  */
      dosh(q,signore );
      }
   }
}

void
docmds(struct name *np)
{
   register struct line *  lp;


   for (lp = np->n_line; lp; lp = lp->l_next)
      docmds1(np, lp);
}



/*
 * Get the modification time of a file.  If the first
 * doesn't exist, it's modtime is set to 0.
 */
void
modtime(struct name * np)
{
   int      mtime,stat;
   mtime = getstamp(np->n_name,&stat);
   if (stat != IS_FILE)
     np->n_time = 0L;
   else
     np->n_time = mtime;
}


/*
 * Update the mod time of a file to now.
 */
void
touch(struct name *np)
{

   if (!domake || !silent)
      printf("    touch(%s)\n", np->n_name);

   if (domake)
   {
      stamp(np->n_name);
   }
}

void
make1(struct name *np, struct line * lp,struct depend * qdp);

/*
 * Recursive routine to make a target.
 */
int
make(struct name *np, int level)

{
   register struct depend *   dp;
   register struct line *     lp;
   register struct depend *   qdp;

   time_t      dtime;
   bool        didsomething;
   didsomething = 0;
   dtime = 1;

#ifdef debug
   printf ("Make : %s\n",np->n_name);
#endif

   if (np->n_flag & N_DONE)
      return 0;

   if (!np->n_time)
      /* finding out about  this file */
      {
      modtime(np);  /*  Gets modtime of this file  */
/*
      printf("when was %s  (%d)\n",np->n_name, np->n_time);
*/
      }
   if (rules)
   {
      for (lp = np->n_line; lp; lp = lp->l_next)
    if (lp->l_cmd)
       break;
      if (!lp)
    if (dyndep(np));
   }

   if (!(np->n_flag & N_TARG) && np->n_time == 0L)
      fatal("Don't know how to make %s", np->n_name);

   for (qdp = (struct depend *)0, lp = np->n_line; lp; lp = lp->l_next)
     {
     for (dp = lp->l_dep; dp; dp = dp->d_next)
       {
/*
       printf("Look at %s\n",dp->d_name->n_name);
*/
       make(dp->d_name, level+1);
       if (np->n_time < dp->d_name->n_time)
         qdp = newdep(dp->d_name, qdp);
       dtime = max(dtime, dp->d_name->n_time);
       }
       if (!quest && (np->n_flag & N_DOUBLE) && (np->n_time < dtime))
         {
         make1(np, lp, qdp);     /* free()'s qdp */
         dtime = 1;
         qdp = (struct depend *)0;
         didsomething++;
         }
       }

   np->n_flag |= N_DONE;

   if (quest)
     {
     long  t;

     t = np->n_time;
     time(&np->n_time);
     return t < dtime;
     }
   else if (np->n_time < dtime && !(np->n_flag & N_DOUBLE))
     {
     make1(np, (struct line *)0, qdp);  /* free()'s qdp */
     time(&np->n_time);
     }
   else if (level == 0 && !didsomething)
     printf("%s: '%s' is up to date\n", myname, np->n_name);
   return 0;
}

void
make1(struct name *np, struct line * lp,struct depend * qdp)
{
   register struct depend *   dp;


   if (dotouch)
      touch(np);
   else
     {
     strcpy(str1, "");
     for (dp = qdp; dp; dp = qdp)
       {
       if (strlen(str1))
         strcat(str1, " ");
       strcat(str1, dp->d_name->n_name);
       qdp = dp->d_next;
       free(dp);
       }
     setmacro("?", str1);
     setmacro("@", np->n_name);

/*
     printf("Set $(@) to %s\n",np->n_name);
*/
     if (lp)    /* lp set if doing a :: rule */
       docmds1(np, lp);
     else
       docmds(np);
     }
}