CP/M/CPM_CDROM.iso/cpm/cpm3/cpmmake.ark/MAKE.C

C/C++ Source or Header | 1986-08-31 | 4.6 KB | 234 lines

/*
 *    Do the actual making for make
 */

#include "c:stdio.h"        /* "c:" is my ramdisk */
#include "c:fcntl.h"
#include "h.h"

FILE *execfile;        /* Submit file to execute the "shell-exec's" */

extern long ftime();

/*
 *    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(command, args)
char *command;
char *args;
{
    if (!execfile) {
        execfile = fopen(MAKERUN, "w");
        if (!execfile) {
            errout("Make: can't create ");
            errout(MAKERUN);
            errout("\r\n");
            exit(-1);
        }
    }

    fprintf(execfile, "%s %s", command, args);
    return 0;
}


/*
 *    Do commands to make a target
 */
void
docmds(np)
struct name *        np;
{
    bool            ssilent;
    bool            signore;
    int            estat;
    register char *        q;
    register char *        p;
    char *            shell;
    register struct line *    lp;
    register struct cmd *    cp;
    ssilent = silent;

    /*
     * Under cp/m the "ignore or not to ignore" is sorta done in dosh()
     * where colons are inserted or not into the cp/m submit file.
     * The actual ignoring (or not) is done when cpm 3.0's submit
     * program executes the submit file.
     *
     *                    -mdk
     */

    signore = ignore;

    if (*(shell = getmacro("SHELL")) == '\0')
        shell = ":bin/esh";

    for (lp = np->n_line; lp; lp = lp->l_next)
        for (cp = lp->l_cmd; cp; cp = cp->c_next)
        {
            strcpy(str1, cp->c_cmd);
            expand(str1);
            q = str1;
            while ((*q == '@') || (*q == '-'))
            {
                if (*q == '@')       /*  Specific silent  */
                    ssilent = TRUE;
                else           /*  Specific ignore  */
                    signore = TRUE;
                q++;           /*  Not part of the command  */
            }

            if (!ssilent)
                fputs("   ", stdout);

            if ((!ssilent) && (!signore)) {    /* cp/m stuff */
                putchar(':');
                putchar(' ');
            }
            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  */
                /*
                 * Colon in front of line makes execution
                 * conditional on error code in cp/m 3.0 .
                 * (Sortof, with one "minor" problem)
                 */

                if (!signore)
                    dosh(":","");

                if ((estat = dosh(q,"\n")) != 0)
                {
                    if (estat == -1)
                        fatal("Couldn't execute %s", shell);
                    else
                    {
                        printf("%s: Error code %d", myname, estat);
                        if (signore)
                            fputs(" (Ignored)\n", stdout);
                        else
                        {
                            putchar('\n');
                            if (!(np->n_flag & N_PREC))
                                if (unlink(np->n_name) == 0)
                                    printf("%s: '%s' removed.\n", myname, np->n_name);
                            exit(estat);
                        }
                    }
                }
            }
        }
}



/*
 *    Update the mod time of a file to now.
 */
void
touch(np)
struct name *        np;
{
    char            c;
    int            fd;
    char fcb[36];            /* set area for CP/M fcb */
    char tempbuffer[128];        /* CPM record size */


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

    if (domake)  {
        if ((fd=open(np->n_name,O_RDONLY)) < 0 ) {
            printf("%s: '%s' not touched - non-existant\n",
                    myname, np->n_name);
        }
        else {
            close(fd);
            OpenRandomFile(np->n_name,fcb);   /* open file      */
            ReadRandomFile(tempbuffer,0,fcb); /* read record    */
            WriteRandomFile(tempbuffer,0,fcb); /* write it back */
        }
        CloseRandomFile(fcb);
    }
}


/*
 *    Recursive routine to make a target.
 */
int
make(np, level)
struct name *        np;
int            level;
{
    register struct depend *    dp;
    register struct line *        lp;
    time_t                dtime = 1l;


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

    if (!np->n_time) {
        np->n_time = ftime(np->n_name);/*  Gets modtime of this file*/
    }

    if (rules) {
        for (lp = np->n_line; lp; lp = lp->l_next)
            if (lp->l_cmd)
                break;
        if (!lp)
            dyndep(np);
    }

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

    for (lp = np->n_line; lp; lp = lp->l_next)
        for (dp = lp->l_dep; dp; dp = dp->d_next)
        {
            make(dp->d_name, level+1);
            dtime = max(dtime, dp->d_name->n_time);
        }

    np->n_flag |= N_DONE;

    if (quest)
    {
        time(&np->n_time);      /* used to be rtime() zzz */
        return np->n_time < dtime;
    }
    else if (np->n_time < dtime)
    {
        if (dotouch)
            touch(np);
        else
        {
            setmacro("@", np->n_name);
            docmds(np);
        }
        time(&np->n_time);     /* used to be rtime() zzz */
    }
    else if (level == 0)
        printf("%s: '%s' is up to date\n", myname, np->n_name);
    return 0;
}