/*************************************************************************

*

* m a k e : m a k e . c

*

* Do the actual making for make plus system dependent stuff

*========================================================================

* Edition history

*

* # Date Comments By

* --- -------- ---------------------------------------------------- ---

* 1 ?? ??

* 2 01.07.89 $<,$* bugs fixed RAL

* 3 23.08.89 (time_t)time((time_t*)0) bug fixed, N_EXISTS added RAL

* 4 30.08.89 leading sp. in cmd. output eliminated, indention ch. PSH,RAL

* 5 03.09.89 :: time fixed, error output -> stderr, N_ERROR intr.

* fixed LZ elimintaed RAL

* 6 07.09.89 implmacro, DF macros,debug stuff added RAL

* 7 09.09.89 tos support added PHH,RAL

* 8 17.09.89 make1 arg. fixed, N_EXEC introduced RAL

* ------------ Version 2.0 released ------------------------------- RAL

* 18.05.90 fixed -n bug with silent rules. (Now echos them.) PAN

*

*************************************************************************/

#include "h.h"

#include <sys/wait.h>

#include <unistd.h>

_PROTOTYPE(static void tellstatus, (FILE *out, char *name, int status));

static bool execflag;

/*

* 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]

*/

int dosh(string, shell)

char *string;

char *shell;

{

int number;

#ifdef unix

return system(string);

#endif

#ifdef tos

return Tosexec(string);

#endif

#ifdef eon

return ((number = execl(shell, shell,"-c", string, 0)) == -1) ?

-1: /* couldn't start the shell */

wait(number); /* return its exit status */

#endif

#ifdef os9

int status, pid;

strcat(string, "\n");

if ((number = os9fork(shell, strlen(string), string, 0, 0, 0)) == -1)

return -1; /* Couldn't start a shell */

do {

if ((pid = wait(&status)) == -1)

return -1; /* child already died!?!? */

} while (pid != number);

return status;

#endif

}

#ifdef unix

/*

* Make a file look very outdated after an error trying to make it.

* Don't remove, this keeps hard links intact. (kjb)

*/

int makeold(name) char *name;

{

struct utimbuf a;

a.actime = a.modtime = 0; /* The epoch */

return utime(name, &a);

}

#endif

static void tellstatus(out, name, status)

FILE *out;

char *name;

int status;

{

char cwd[PATH_MAX];

fprintf(out, "%s in %s: ",

name, getcwd(cwd, sizeof(cwd)) == NULL ? "?" : cwd);

if (WIFEXITED(status)) {

fprintf(out, "Exit code %d", WEXITSTATUS(status));

} else {

fprintf(out, "Signal %d%s",

WTERMSIG(status), status & 0x80 ? " - core dumped" : "");

}

}

/*

* Do commands to make a target

*/

void docmds1(np, lp)

struct name *np;

struct line *lp;

{

register char *q;

register char *p;

register struct cmd *cp;

bool ssilent;

bool signore;

int estat;

char *shell;

if (*(shell = getmacro("SHELL")) == '\0')

#ifdef eon

shell = ":bin/esh";

#endif

#ifdef unix

shell = "/bin/sh";

#endif

#ifdef os9

shell = "shell";

#endif

#ifdef tos

shell = "DESKTOP"; /* TOS has no shell */

#endif

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

execflag = TRUE;

strcpy(str1, cp->c_cmd);

expmake = FALSE;

expand(&str1s);

q = str1;

ssilent = silent;

signore = ignore;

while ((*q == '@') || (*q == '-')) {

if (*q == '@') /* Specific silent */

ssilent = TRUE;

else /* Specific ignore */

signore = TRUE;

if (!domake) putchar(*q); /* Show all characters. */

q++; /* Not part of the command */

}

for (p=q; *p; p++) {

if (*p == '\n' && p[1] != '\0') {

*p = ' ';

if (!ssilent || !domake)

fputs("\\\n", stdout);

}

else if (!ssilent || !domake)

putchar(*p);

}

if (!ssilent || !domake)

putchar('\n');

if (domake || expmake) { /* Get the shell to execute it */

fflush(stdout);

if ((estat = dosh(q, shell)) != 0) {

if (estat == -1)

fatal("Couldn't execute %s", shell,0);

else if (signore) {

tellstatus(stdout, myname, estat);

printf(" (Ignored)\n");

} else {

tellstatus(stderr, myname, estat);

fprintf(stderr, "\n");

if (!(np->n_flag & N_PREC))

#ifdef unix

if (makeold(np->n_name) == 0)

fprintf(stderr,"%s: made '%s' look old.\n", myname, np->n_name);

#else

if (unlink(np->n_name) == 0)

fprintf(stderr,"%s: '%s' removed.\n", myname, np->n_name);

#endif

if (!conterr) exit(estat != 0);

np->n_flag |= N_ERROR;

return;

}

}

}

}

}

void docmds(np)

struct name *np;

{

register struct line *lp;

for (lp = np->n_line; lp; lp = lp->l_next)

docmds1(np, lp);

}

#ifdef tos

/*

* execute the command submitted by make,

* needed because TOS has no internal shell,

* so we use Pexec to do the job

* v 1.1 of 10/sep/89 by yeti

*/

#define DELM1 ';'

#define DELM2 ' '

#define DELM3 ','

int Tosexec(string)

char *string;

{

register char *help, *help2, c;

register unsigned char l=1;

char progname[80], command[255], plain[15];

static char **envp,*env;

register int error,i;

/* generate strange TOS environment (RAL) */

for ( i = 0, envp = environ; *envp; envp++) i += strlen(*envp) +1;

if ((env = malloc(i+1)) == (char *)0)

fatal("No memory for TOS environment",(char *)0,0);

for ( envp = environ, help = env; *envp; envp++) {

strcpy ( help, *envp);

while ( *(help++)) ;

}

*help = '\0';

help = progname;

while((*help++=*string++) != ' '); /* progname is command name */

*--help = '\0';

l = strlen(string); /* build option list */

command[0] = l; /* TOS likes it complicated */

strcpy(&command[1],string);

if ((error = (int) Pexec(0,progname,command,env)) != -33) {

free(env);

return(error);

}

/* could'nt find program, try to search the PATH */

if((help=strrchr(progname,'\\')) != (char *) 0) /* just the */

strcpy(plain,++help); /* name */

else if((help=strrchr(progname,'/')) != (char *) 0)

strcpy(plain,++help);

else if((help=strrchr(progname,':')) != (char *) 0)

strcpy(plain,++help);

else

strcpy(plain,progname);

if(*(help=getmacro("PATH")) == '\0') {

free(env);

return(-33);

}

c = 1;

while(c)

{ help2 = &progname[-1];

i = 0;

while((c=*help++) != '\0' && i<80 && c != DELM1

&& c != DELM2 && c != DELM3)

*++help2 = c, i++;

*++help2 = '\\';

strcpy(++help2,plain);

if((error=(int) Pexec(0,progname,command,env))!=-33) {

free(env);

return(error);

}

}

free(env);

return(-33);

}

/* (stolen from ZOO -- thanks to Rahul Dehsi)

Function mstonix() accepts an MSDOS format date and time and returns

a **IX format time. No adjustment is done for timezone.

*/

time_t mstonix (date, time)

unsigned int date, time;

{

int year, month, day, hour, min, sec, daycount;

time_t longtime;

/* no. of days to beginning of month for each month */

static int dsboy[12] = { 0, 31, 59, 90, 120, 151, 181, 212,

243, 273, 304, 334};

if (date == 0 && time == 0) /* special case! */

return (0L);

/* part of following code is common to zoolist.c */

year = (((unsigned int) date >> 9) & 0x7f) + 1980;

month = ((unsigned int) date >> 5) & 0x0f;

day = date & 0x1f;

hour = ((unsigned int) time >> 11)& 0x1f;

min = ((unsigned int) time >> 5) & 0x3f;

sec = ((unsigned int) time & 0x1f) * 2;

/* DEBUG and leap year fixes thanks to Mark Alexander <uunet!amdahl!drivax!alexande>*/

#ifdef DEBUG

printf ("mstonix: year=%d month=%d day=%d hour=%d min=%d sec=%d\n",

year, month, day, hour, min, sec);

#endif

/* Calculate days since 1970/01/01 */

daycount = 365 * (year - 1970) + /* days due to whole years */

(year - 1969) / 4 + /* days due to leap years */

dsboy[month-1] + /* days since beginning of this year */

day-1; /* days since beginning of month */

if (year % 4 == 0 &&

year % 400 != 0 && month >= 3) /* if this is a leap year and month */

daycount++; /* is March or later, add a day */

/* Knowing the days, we can find seconds */

longtime = daycount * 24L * 60L * 60L +

hour * 60L * 60L + min * 60 + sec;

return (longtime);

}

#endif /* tos */

#ifdef os9

/*

* Some stuffing around to get the modified time of a file

* in an os9 file system

*/

void getmdate(fd, tbp)

int fd;

struct sgtbuf *tbp;

{

struct registers regs;

static struct fildes fdbuf;

regs.rg_a = fd;

regs.rg_b = SS_FD;

regs.rg_x = &fdbuf;

regs.rg_y = sizeof (fdbuf);

if (_os9(I_GETSTT, &regs) == -1) {

errno = regs.rg_b & 0xff;

return -1;

}

if (tbp)

{

_strass(tbp, fdbuf.fd_date, sizeof (fdbuf.fd_date));

tbp->t_second = 0; /* Files are only acurate to mins */

}

return 0;

}

/*

* Kludge routine to return an aproximation of how many

* seconds since 1980. Dates will be in order, but will not

* be lineer

*/

time_t cnvtime(tbp)

struct sgtbuf *tbp;

{

long acc;

acc = tbp->t_year - 80; /* Baseyear is 1980 */

acc = acc * 12 + tbp->t_month;

acc = acc * 31 + tbp->t_day;

acc = acc * 24 + tbp->t_hour;

acc = acc * 60 + tbp->t_minute;

acc = acc * 60 + tbp->t_second;

return acc;

}

/*

* Get the current time in the internal format

*/

void time(tp)

time_t *tp;

{

struct sgtbuf tbuf;

if (getime(&tbuf) < 0)

return -1;

if (tp)

*tp = cnvtime(&tbuf);

return 0;

}

#endif

/*

* Get the modification time of a file. If the first

* doesn't exist, it's modtime is set to 0.

*/

void modtime(np)

struct name *np;

{

#ifdef unix

struct stat info;

int r;

if (is_archive_ref(np->n_name)) {

r = archive_stat(np->n_name, &info);

} else {

r = stat(np->n_name, &info);

}

if (r < 0) {

if (errno != ENOENT)

fatal("Can't open %s: %s", np->n_name, errno);

np->n_time = 0L;

np->n_flag &= ~N_EXISTS;

} else {

np->n_time = info.st_mtime;

np->n_flag |= N_EXISTS;

}

#endif

#ifdef tos

struct DOSTIME fm;

int fd;

if((fd=Fopen(np->n_name,0)) < 0) {

np->n_time = 0L;

np->n_flag &= ~N_EXISTS;

}

else {

Fdatime(&fm,fd,0);

Fclose(fd);

np->n_time = mstonix((unsigned int)fm.date,(unsigned int)fm.time);

np->n_flag |= N_EXISTS;

}

#endif

#ifdef eon

struct stat info;

int fd;

if ((fd = open(np->n_name, 0)) < 0) {

if (errno != ER_NOTF)

fatal("Can't open %s: %s", np->n_name, errno);

np->n_time = 0L;

np->n_flag &= ~N_EXISTS;

}

else if (getstat(fd, &info) < 0)

fatal("Can't getstat %s: %s", np->n_name, errno);

else {

np->n_time = info.st_mod;

np->n_flag |= N_EXISTS;

}

close(fd);

#endif

#ifdef os9

struct sgtbuf info;

int fd;

if ((fd = open(np->n_name, 0)) < 0) {

if (errno != E_PNNF)

fatal("Can't open %s: %s", np->n_name, errno);

np->n_time = 0L;

np->n_flag &= ~N_EXISTS;

}

else if (getmdate(fd, &info) < 0)

fatal("Can't getstat %s: %s", np->n_name, errno);

else {

np->n_time = cnvtime(&info);

np->n_flag |= N_EXISTS;

}

close(fd);

#endif

}

/*

* Update the mod time of a file to now.

*/

void touch(np)

struct name *np;

{

char c;

int fd;

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

if (domake) {

#ifdef unix

struct utimbuf a;

a.actime = a.modtime = time((time_t *)NULL);

if (utime(np->n_name, &a) < 0)

printf("%s: '%s' not touched - non-existant\n",

myname, np->n_name);

#endif

#ifdef tos

struct DOSTIME fm;

int fd;

if((fd=Fopen(np->n_name,0)) < 0) {

printf("%s: '%s' not touched - non-existant\n",

myname, np->n_name);

}

else {

fm.date = Tgetdate();

fm.time = Tgettime();

Fdatime(&fm,fd,1);

Fclose(fd);

}

#endif

#ifdef eon

if ((fd = open(np->n_name, 0)) < 0)

printf("%s: '%s' not touched - non-existant\n",

myname, np->n_name);

else

{

uread(fd, &c, 1, 0);

uwrite(fd, &c, 1);

}

close(fd);

#endif

#ifdef os9

/*

* Strange that something almost as totally useless

* as this is easy to do in os9!

*/

if ((fd = open(np->n_name, S_IWRITE)) < 0)

printf("%s: '%s' not touched - non-existant\n",

myname, np->n_name);

close(fd);

#endif

}

}

/*

* Recursive routine to make a target.

*/

int make(np, level)

struct name *np;

int level;

{

register struct depend *dp;

register struct line *lp;

register struct depend *qdp;

time_t now, t, dtime = 0;

bool dbgfirst = TRUE;

char *basename = (char *) 0;

char *inputname = (char *) 0;

if (np->n_flag & N_DONE) {

if(dbginfo) dbgprint(level,np,"already done");

return 0;

}

modtime(np); /* Gets modtime of this file */

while (time(&now) == np->n_time) {

/* Time of target is equal to the current time. This bothers us, because

* we can't tell if it needs to be updated if we update a file it depends

* on within a second. So wait until the second is over.

*/

usleep(10000);

}

if (rules) {

for (lp = np->n_line; lp; lp = lp->l_next)

if (lp->l_cmd)

break;

if (!lp)

dyndep(np,&basename,&inputname);

}

if (!(np->n_flag & (N_TARG | N_EXISTS))) {

fprintf(stderr,"%s: Don't know how to make %s\n", myname, np->n_name);

if (conterr) {

np->n_flag |= N_ERROR;

if (dbginfo) dbgprint(level,np,"don't know how to make");

return 0;

}

else exit(1);

}

for (qdp = (struct depend *)0, lp = np->n_line; lp; lp = lp->l_next) {

for (dp = lp->l_dep; dp; dp = dp->d_next) {

if(dbginfo && dbgfirst) {

dbgprint(level,np," {");

dbgfirst = FALSE;

}

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 (dp->d_name->n_flag & N_ERROR) np->n_flag |= N_ERROR;

if (dp->d_name->n_flag & N_EXEC ) np->n_flag |= N_EXEC;

}

if (!quest && (np->n_flag & N_DOUBLE) &&

(np->n_time < dtime || !( np->n_flag & N_EXISTS))) {

execflag = FALSE;

make1(np, lp, qdp, basename, inputname); /* free()'s qdp */

dtime = 0;

qdp = (struct depend *)0;

if(execflag) np->n_flag |= N_EXEC;

}

}

np->n_flag |= N_DONE;

if (quest) {

t = np->n_time;

np->n_time = now;

return (t < dtime);

}

else if ((np->n_time < dtime || !( np->n_flag & N_EXISTS))

&& !(np->n_flag & N_DOUBLE)) {

execflag = FALSE;

make1(np, (struct line *)0, qdp, basename, inputname); /* free()'s qdp */

np->n_time = now;

if ( execflag) np->n_flag |= N_EXEC;

}

else if ( np->n_flag & N_EXEC ) {

np->n_time = now;

}

if (dbginfo) {

if(dbgfirst) {

if(np->n_flag & N_ERROR)

dbgprint(level,np,"skipped because of error");

else if(np->n_flag & N_EXEC)

dbgprint(level,np,"successfully made");

else dbgprint(level,np,"is up to date");

}

else {

if(np->n_flag & N_ERROR)

dbgprint(level,(struct name *)0,"} skipped because of error");

else if(np->n_flag & N_EXEC)

dbgprint(level,(struct name *)0,"} successfully made");

else dbgprint(level,(struct name *)0,"} is up to date");

}

}

if (level == 0 && !(np->n_flag & N_EXEC))

printf("%s: '%s' is up to date\n", myname, np->n_name);

if(basename)

free(basename);

return 0;

}

void make1(np, lp, qdp, basename, inputname)

struct name *np;

struct line *lp;

register struct depend *qdp;

char *basename;

char *inputname;

{

register struct depend *dp;

size_t l1, l2;

if (dotouch)

touch(np);

else if (!(np->n_flag & N_ERROR)) {

strcpy(str1, "");

if(!inputname) {

inputname = str1; /* default */

if (ambigmac) implmacros(np,lp,&basename,&inputname);

}

setDFmacro("<",inputname);

if(!basename)

basename = str1;

setDFmacro("*",basename);

for (dp = qdp; dp; dp = qdp) {

l1= strlen(str1);

l2= strlen(dp->d_name->n_name);

while (l1 + 1 + l2 +1 > str1s.len)

strrealloc(&str1s);

if (strlen(str1))

strcat(str1, " ");

strcat(str1, dp->d_name->n_name);

qdp = dp->d_next;

free(dp);

}

setmacro("?", str1);

setDFmacro("@", np->n_name);

if (lp) /* lp set if doing a :: rule */

docmds1(np, lp);

else

docmds(np);

}

}

void implmacros(np,lp, pbasename,pinputname)

struct name *np;

struct line *lp;

char **pbasename; /* Name without suffix */

char **pinputname;

{

struct line *llp;

register char *p;

register char *q;

register char *suff; /* Old suffix */

int baselen;

struct depend *dp;

bool dpflag = FALSE;

/* get basename out of target name */

p = str2;

q = np->n_name;

suff = suffix(q);

while ( *q && (q < suff || !suff)) *p++ = *q++;

*p = '\0';

if ((*pbasename = (char *) malloc(strlen(str2)+1)) == (char *)0 )

fatal("No memory for basename",(char *)0,0);

strcpy(*pbasename,str2);

baselen = strlen(str2);

if ( lp)

llp = lp;

else

llp = np->n_line;

while (llp) {

for (dp = llp->l_dep; dp; dp = dp->d_next) {

if( strncmp(*pbasename,dp->d_name->n_name,baselen) == 0) {

*pinputname = dp->d_name->n_name;

return;

}

if( !dpflag) {

*pinputname = dp->d_name->n_name;

dpflag = TRUE;

}

}

if (lp) break;

llp = llp->l_next;

}

#if NO_WE_DO_WANT_THIS_BASENAME

free(*pbasename); /* basename ambiguous or no dependency file */

*pbasename = (char *)0;

#endif

return;

}

void dbgprint(level,np,comment)

int level;

struct name *np;

char *comment;

{

char *timep;

if(np) {

timep = ctime(&np->n_time);

timep[24] = '\0';

fputs(&timep[4],stdout);

}

else fputs(" ",stdout);

fputs(" ",stdout);

while(level--) fputs(" ",stdout);

if (np) {

fputs(np->n_name,stdout);

if (np->n_flag & N_DOUBLE) fputs(" :: ",stdout);

else fputs(" : ",stdout);

}

fputs(comment,stdout);

putchar((int)'\n');

fflush(stdout);

return;

}