cmd/nmake/make.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1984-2012 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Glenn Fowler
 * AT&T Research
 *
 * make target proof algorithm
 */

#include "make.h"

#define PREVIEW(r,x)    do{if(r->preview>x->preview&&(r->scan&&r->scan==x->scan||!r->scan&&!((r->property|x->property)&P_virtual)))r->preview=x->preview;}while(0)

/*
 * make scan prereqs
 */

static int
makescan(register Rule_t* r, Time_t* tm)
{
    register Rule_t*    s;
    register Rule_t*    u;
    register List_t*    p;
    List_t*         q;
    int         errors = 0;
    Time_t          tevent;
    Time_t          t;

    message((-2, "check scan prerequisites"));
    q = scan(r, &tevent);
    for (p = q; p; p = p->next)
    {
        s = p->rule;
        if (!s->scan && (u = staterule(RULE, bind(s), NiL, 0)) && u->scan)
            s->scan = u->scan;
        make(s, &t, NiL, P_implicit);
    }
    errors += complete(r, q, &t, P_implicit);
    if (tevent < t)
        tevent = t;
    *tm = tevent;
    return errors;
}

/*
 * insert|append global g prereqs to r
 */

static void
globalprereqs(register Rule_t* r, Rule_t* g)
{
    register List_t*    p;
    register List_t*    q;
    register List_t*    t;
    register List_t*    u;
    Rule_t*         x;
    List_t*         pos = 0;

    while (x = associate(g, r, NiL, &pos))
        if (p = x->prereqs)
        {
            for (q = t = 0; p; p = p->next)
                if (p->rule != r)
                {
                    newlist(u);
                    if (t)
                        t->next = u;
                    else
                        q = u;
                    (t = u)->rule = p->rule;
                }
            if (q)
            {
                t->next = 0;
                r->prereqs = g == internal.insert_p ? append(q, r->prereqs) : append(r->prereqs, q);
                if (x->dynamic & D_dynamic)
                    dynamic(r);
                remdup(r->prereqs);
            }
        }
}

/*
 * undo alias of a -> r in preparation for update()
 * return unaliased a
 */

static Rule_t*
unalias(register Rule_t* r, register Rule_t* a, char* name)
{
    Frame_t*    oframe;

    message((-3, "unalias(%s) -> %s", a->name, name));
    if (a == r)
    {
        a->uname = name;
        a->dynamic |= D_alias;
    }
    else
    {
        oframe = a->active;
        a->active = r->active;
        r->active = r->active->previous;
        a->active->previous = oframe;
        a->status = r->status;
        r->status = NOTYET;
        a->action = r->action;
        if (r == state.frame->target)
            state.frame->target = a;
    }
    if (r->view && a->active && !state.mam.statix)
        a->active->original = a->name;
    oldname(a);
    return a;
}

/*
 * prepare for update and execute action
 * r is the target (possibly with explicit action)
 * a is the implicit action rule
 * arg for P_functional
 */

static int
update(register Rule_t* r, register Rule_t* a, char* arg)
{
    register List_t*    p;
    register Rule_t*    u;
    int         errors;
    char*           s;

    errors = 0;
    if (state.override)
    {
        /*
         * save explicit target generation for non-override runs
         */

        if (r == a && r->time && (!(r->property & P_target) || !(r->property & (P_archive|P_command|P_make))))
        {
            r->time = CURTIME;
            r->dynamic |= D_triggered;
            if (r->dynamic & D_member)
            {
                r->dynamic &= ~D_member;
                r->dynamic |= D_membertoo;
            }
            return errors;
        }
    }
    for (p = joint(r); p; p = p->next)
    {
        u = p->rule;
        if (u->dynamic & D_alias)
            u = makerule(u->name);
        if (u->dynamic & D_member)
        {
            u->dynamic &= ~D_member;
            u->dynamic |= D_membertoo;
        }
        if (!state.override && u->action)
            a = u;
        if (!(u->property & P_state))
        {
            if (u->uname)
            {
                if (u->view)
                {
                    u->view = 0;
                    if (u->active && !state.mam.statix)
                        u->active->original = u->name;
                }
                oldname(u);
            }
            else if (u->view)
            {
                if (r == a)
                    u->view = 0;
                else if (state.fsview)
                {
                    u->view = 0;
                    if (u->active && !state.mam.statix)
                    {
                        if (state.expandview)
                        {
                            mount(u->name, sfstrbase(internal.tmp), FS3D_GET|FS3D_VIEW|FS3D_SIZE(sfstrsize(internal.tmp)), NiL);
                            u->active->original = makerule(sfstrbase(internal.tmp))->name;
                        }
                        else
                            u->active->original = u->name;
                    }
                }
                else
                {
                    int n;

                    /*
                     * this condition is definitely a bug
                     * this fix will have to do until the
                     * place that set u->uname=0 is found
                     */

                    n = 0;
                    s = u->name;
                    while (s = strchr(s, '/'))
                    {
                        n++;
                        if (getrule(++s) == u)
                        {
                            message((-1, "local binding %s recovered from %s", s, u->name));
                            u->view = 0;
                            if (u->active && !state.mam.statix)
                                u->active->original = u->name;
                            u->name = maprule(s, u);
                            break;
                        }
                    }
                    if (!s)
                    {
                        if (!n)
                            u->view = 0;
                        else if (!(u->property & P_dontcare))
                            error(1, "%s: modifying lower view=%d file", u->name, u->view);
                    }
                }
            }
        }
    }
    if ((r->property & P_attribute) || (r->property & P_functional) && !(r->active->stem = arg))
    {
        if (!state.accept && !(r->property & P_accept))
            r->dynamic |= D_triggered;
        statetime(r, 1);
    }
    else
    {
        r->action = a->action;
        trigger(r, a, a->action, CO_LOCALSTACK);
    }
    return errors;
}

/*
 * top level make
 * p temporarily or'd into r->property
 * arg for P_functional
 *
 * r->status determines the status of each rule:
 *
 *  NOTYET  nothing done yet
 *  UPDATE  rule in process of being updated
 *  MAKING  rule action being executed
 *  TOUCH   archive member to be touched
 *  EXISTS  rule has already been made
 *  IGNORE  rule make failed but ignore errors
 *  FAILED  rule make failed
 */

void
maketop(register Rule_t* r, int p, char* arg)
{
    Time_t      t;
    Flags_t     o;

#if _HUH_2004_06_20
    if ((p & (P_force|P_repeat)) == (P_force|P_repeat) && (r->property & (P_functional|P_make)) == P_make)
    {
        register Rule_t*    a;

        a = catrule(internal.internal->name, ".%%", r->name, 1);
        a->property |= P_internal|P_virtual;
        if (a->prereqs)
            freelist(a->prereqs);
        a->prereqs = cons(r, NiL);
        r = a;
    }
#endif
    o = r->property & p;
    r->property |= p;
    if (p & P_ignore)
        state.keepgoing |= 2;
    make(r, &t, arg, 0);
    complete(r, r->prereqs, NiL, 0);
    state.keepgoing &= 1;
    r->property &= ~p;
    r->property |= o;
}

/*
 * intermediate level make
 */

int
make(register Rule_t* r, Time_t* ttarget, char* arg, Flags_t flags)
{
    register List_t*    p;
    register Rule_t*    r1;
    Time_t          t;
    Time_t          tevent;
    Time_t          otime;
    char*           s;
    char*           v;
    char*           r3name;
    int         errors;
    int         explicit;
    int         must;
    int         otargetview;
    int         pop;
    Rule_t*         r0;
    Rule_t*         r2;
    Rule_t*         r3;
    Rule_t*         r4;
    Rule_t*         parent;
    List_t*         q;
    Frame_t*        fp;
    Frame_t*        oframe;
    Frame_t         frame;
    Sfio_t*         mam;
    char            stem[MAXNAME];

    trap();
    errors = 0;
    *ttarget = 0;
    if (state.expandall)
        return errors;
    if (r == internal.query)
    {
        interpreter(NiL);
        return errors;
    }
    if (r->property & P_use)
    {
        /*
         * r->use rules modify the parent
         */

        r1 = state.frame->target;
        if (!(r->property & P_metarule) && r1->action && !state.override)
            return errors;
        if (r->status == NOTYET)
        {
            /*
             * check if the action changed
             */

            r0 = staterule(RULE, r, NiL, 1);
            if (r->action && (!r0->action || !streq(r->action, r0->action)) || !r->action && r0->action)
            {
                reason((1, "%s action changed [#1]", r->name));
                r0->action = r->action;
                r0->time = ((r1->property & P_accept) || state.accept) ? OLDTIME : CURTIME;
                state.savestate = 1;
            }
            else if ((r1->property & P_accept) || state.accept)
                r0->time = OLDTIME;
            r->time = r0->time;
            r->status = EXISTS;
        }
#if DEBUG
        else if (r->status != EXISTS)
            error(PANIC, "%s rule %s has invalid status=%d", internal.use->name, r->name, r->status);
#endif
        tevent = ((r->property & P_metarule) && (r1->property & P_implicit) && r1->action) ? 0 : r->time;

        /*
         * append the prerequisites
         */

        q = listcopy(r->prereqs);
        if (r->dynamic & D_dynamic)
        {
            fp = r->active;
            r->active = state.frame;
            dynamic(r);
            r->active = fp;
            r->dynamic |= D_dynamic;
        }
        p = r->prereqs;
        r->prereqs = q;
        r1->prereqs = append(r1->prereqs, p);
        if (r->property & P_metarule)
            for (; p; p = p->next)
            {
                r2 = p->rule;
                if (r2->dynamic & D_scope)
                    r1->dynamic |= D_hasscope;
                else if ((r2->property & (P_make|P_local|P_use)) == (P_make|P_local))
                {
                    r2->property |= P_virtual;
                    r1->dynamic |= D_hasscope;
                    errors += make(r2, &t, NiL, 0);
                    if (tevent < t)
                        tevent = t;
                }
                else if ((r2->property & (P_after|P_use)) == P_after)
                {
                    r1->dynamic |= D_hasafter;
                    if ((r2->property & (P_make|P_foreground)) == (P_make|P_foreground))
                        r1->dynamic |= D_hasmake;
                }
                else if ((r2->property & (P_before|P_use)) == P_before)
                    r1->dynamic |= D_hasbefore;
                else if (r2->semaphore)
                    r1->dynamic |= D_hassemaphore;
                else if ((r2->property & (P_joint|P_target)) != P_joint)
                {
                    errors += make(r2, &t, NiL, 0);
                    if (tevent < t)
                        tevent = t;
                }
            }

        /*
         * propagate the attributes
         */

        merge(r, r1, MERGE_ATTR);
        if (!(r->property & P_metarule))
            r1->action = r->action;
        if ((r->property & P_dontcare) && !state.unwind)
            state.unwind = error_info.indent;
        if (!(r->property & P_ignore))
        {
            *ttarget = tevent;
            PREVIEW(r1, r);
        }
        return errors;
    }
    else if (r->semaphore)
        return complete(r, NiL, ttarget, 0);

    /*
     * check if rule has been or is in the process of being made
     */

    message((-1, "make(%s%s%s)", r->name, arg ? " " : null, arg ? arg : null));
    error_info.indent++;
    r3 = r;
    r3name = unbound(r3);
    zero(frame);
    frame.flags = flags;
    frame.target = r;
    frame.parent = state.frame;
    parent = frame.parent->target;
    frame.previous = r->active;
    r->active = &frame;
    for (;;)
    {
        if (r->status != NOTYET)
        {
            if (!(r->property & P_repeat))
            {
                tevent = r->time;
                r0 = 0;
                if (!(r->property & P_state))
                {
                    if (mam = mamout(r))
                        pop = mampush(mam, r, flags);
                    if (r->scan && !(r->dynamic & D_scanned) && state.scan)
                    {
                        if (r->status == MAKING)
                            complete(r, NiL, NiL, 0);
                        if (r->status == EXISTS)
                        {
                            otime = r->time;
                            r0 = staterule(RULE, r, NiL, 1);
                            if (r0->time)
                                r->time = r0->time;
                            makescan(r, &t);
                            if (tevent < t)
                                r->time = r0->event = tevent = t;
                            else
                                r->time = otime;
                        }
                    }
                    if (mam && pop)
                    {
                        if (state.mam.statix)
                            r->dynamic |= D_built;
                        mampop(mam, r, P_virtual);
                    }
                }
                if (!(r->property & P_ignore))
                {
                    if (r->dynamic & D_aliaschanged)
                        tevent = CURTIME;
                    else if (!(r->dynamic & D_triggered) && parent->scan == SCAN_IGNORE && (r0 || (r0 = staterule(RULE, r, NiL, 0))) && tevent < r0->time)
                        tevent = r0->time;
                    *ttarget = tevent;
                    PREVIEW(parent, r);
                }
                message((-1, "time(%s) = %s", r->name, timestr(tevent)));
                r->active = frame.previous;
                if (state.unwind == error_info.indent)
                {
                    state.unwind = 0;
                    errors = 0;
                }
                error_info.indent--;
                return r->status == FAILED;
            }
            if (r->status == MAKING)
                complete(r, NiL, NiL, 0);
        }
        if ((r->property & P_dontcare) && !state.unwind)
            state.unwind = error_info.indent;
        otime = r->time;
        if ((r1 = bind(r)) == r)
            break;
        if ((r->property & P_target) && !(r1->property & P_target))
        {
            r->dynamic &= ~D_alias;
            break;
        }
        fp = r1->active;
        r1->active = r->active;
        r->active = r->active->previous;
        r = r1;
        r->active->target = r;
        r->active->previous = fp;
    }
    if ((r3 == r || (r->property & P_target) && !(r3->property & P_target)) && (!(r->dynamic & D_alias) || r3name == unbound(r)))
        r3 = 0;
    otargetview = state.targetview;
    if (state.maxview && !(r->property & P_state) && !r->scan && r->view <= state.maxview)
        state.targetview = r->view;
    frame.action = r->action;
    frame.prereqs = r->prereqs;
    if ((r->property & (P_joint|P_target)) == (P_joint|P_target))
        for (p = r->prereqs->rule->prereqs; p; p = p->next)
            if ((r1 = p->rule) != r)
            {
                fp = r1->active;
                r1->active = r->active;
                bind(r1);
                r1->active = fp;
                if (r1->status == NOTYET)
                {
                    r0 = staterule(RULE, r1, NiL, 1);
                    if (!statetimeq(r1, r0) || !r0->event)
                    {
                        if ((r1->property & P_dontcare) && !r1->time)
                            r1->event = r0->event;
                        else
                        {
                            reason((1, "%s joint sibling %s is out of date", r->name, r1->name));
                            staterule(RULE, r, NiL, 1)->time = 0;
                        }
                    }
                }
                fp = newof(0, Frame_t, 1, 0);
                fp->target = r1;
                fp->parent = state.frame;
                fp->previous = r1->active;
                fp->action = r1->action;
                fp->prereqs = r1->prereqs;
                r1->active = fp;
            }
    oframe = state.frame;
    state.frame = &frame;
    if (r->dynamic & D_dynamic)
        dynamic(r);
    if (r->property & P_state)
        while (r->active->prereqs && r->active->prereqs->next)
            r->active->prereqs = r->active->prereqs->next;
    r->dynamic &= ~(D_hasafter|D_hasbefore|D_hasmake|D_hasscope|D_hassemaphore|D_triggered);
    r->status = UPDATE;
    message((-1, "time(%s) = %s", r->name, timestr(r->time)));
    if (mam = mamout(r))
    {
        pop = mampush(mam, r, flags);
        if (state.mam.statix)
            r->dynamic |= D_built;
    }

    /*
     * check for file changes since the last make
     * the changes take a few forms:
     *
     *  o  the file modify time has changed since the
     *     last make
     *
     *  o  the file is from a different directory than
     *     the last make -- this is checked by using
     *     the modify time of the file which may fail
     *     (low probability) if the two source files
     *     in question have both the same (base) name
     *     and the same modify time -- this avoids
     *     saving the full bound names in the state file
     *
     * notice that this technique detects when an old source
     * file is reinstated and forces updating just as if
     * the file had been touched
     */

    must = 0;
    tevent = 0;
    if (r->property & P_state)
    {
        r0 = 0;
        if (r->time != otime)
        {
            otime = r->time;
            must = r->must = 1;
            tevent = CURTIME;
        }
    }
    else
    {
        otime = r->time;
        must = 0;
        r0 = staterule(RULE, r, NiL, 1);
        if (!(r->property & P_virtual))
        {
            if (!state.intermediate && !r->time && r0->time && r0->event && (r0->dynamic & D_built) && !(parent->property & P_state) && (r2 = staterule(RULE, parent, NiL, 0)) && (r2->dynamic & D_built))
            {
                message((-1, "pretending intermediate target %s exists", r->name));
                must = 1;
                otime = r->time = r0->time;
                r->dynamic |= D_intermediate;
                r->must++;
            }
            else if (!statetimeq(r, r0) || !r0->event || (r->dynamic & D_aliaschanged))
            {
                if (!(r->property & P_accept) && !state.accept)
                {
                    if (r->dynamic & D_aliaschanged)
                        reason((1, "%s [%s] binds to a different file", r->name, timestr(r->time)));
                    else
                    {
                        if (r->time && r->time < r0->time && (r->dynamic & D_regular))
                            error(1, "%s has been replaced by an older version", unbound(r));
                        if (r0->event && r0->time)
                            reason((1, "%s [%s] has changed [%s]", r->name, timestr(r->time), timestr(r0->time)));
                        else if (r0->event && r->view)
                            reason((1, "%s [%s] has changed in view %s", r->name, timestr(r->time), state.view[r->view].path));
                        else
                            reason((1, "%s [%s] has no previous state", r->name, timestr(r->time)));
                    }
                    must = 1;
                    r0->event = CURTIME;
                    r->must++;
                    state.savestate = 1;
                }
                if ((r->dynamic & (D_alias|D_bound)) == (D_alias|D_bound))
                {
                    s = r->uname;
                    r->uname = 0;
                    r1 = staterule(RULE, r, NiL, 0);
                    r->uname = s;
                    if (r1 && r1 != r0 && r1->time)
                    {
                        r0->time = r1->time;
                        r0->event = r1->event;
                    }
                    else
                    {
                        r0->time = r->time;
                        r0->property |= P_force;
                    }
                }
                else
                {
                    r0->time = r->time;
                    r0->property |= P_force;
                }
            }
            if ((r->property & P_accept) || state.accept)
            {
                if (r->time < r0->event && (r1 = staterule(PREREQS, r, NiL, 0)) && r1->time >= r0->event)
                    r->time = r1->time;
                else if (!r->time)
                    r0->event = OLDTIME;
                else if (r->time < r0->event)
                    r->time = r0->event;
                else
                    r0->event = r->time;
                state.savestate = 1;
            }
            else
                r->time = r0->event;
        }
    }

    /*
     * check global insert|append pattern prerequisites
     */

    globalprereqs(r, internal.insert_p);
    globalprereqs(r, internal.append_p);

    /*
     * check explicit prerequisites
     */

    message((-2, "check explicit prerequisites"));
    explicit = 0;
    p = r->prereqs;
    while (p)
    {
        r1 = p->rule;
        if (r1->mark & M_bind)
            r1->mark &= ~M_bind;
        else if (r1->dynamic & D_scope)
            r->dynamic |= D_hasscope;
        else if ((r1->property & (P_make|P_local|P_use)) == (P_make|P_local))
        {
            r1->property |= P_virtual;
            r->dynamic |= D_hasscope;
            errors += make(r1, &t, NiL, 0);
            if (tevent < t)
                tevent = t;
        }
        else if ((r1->property & (P_after|P_use)) == P_after)
        {
            r->dynamic |= D_hasafter;
            if ((r1->property & (P_make|P_foreground)) == (P_make|P_foreground))
                r->dynamic |= D_hasmake;
        }
        else if ((r1->property & (P_before|P_use)) == P_before)
            r->dynamic |= D_hasbefore;
        else if (r1->semaphore)
            r->dynamic |= D_hassemaphore;
        else if ((r1->property & (P_joint|P_target)) != P_joint)
        {
            explicit = 1;
            errors += make(r1, &t, NiL, 0);
            if (tevent < t)
                tevent = t;
            if (r->time < t || (r1->dynamic & D_same))
                r->must++;
            if ((r2 = associate(internal.require_p, r1, NiL, NiL)) && (v = call(r2, unbound(r1))))
            {
                if (r->prereqs == r->active->prereqs)
                    for (p = r->prereqs = listcopy(r->prereqs); p->rule != r1; p = p->next);
                q = 0;
                while (s = getarg(&v, NiL))
                {
                    if ((r2 = makerule(s)) == r1)
                        r1->mark |= M_bind;
                    if (streq(r2->name, "-"))
                        r1->property |= P_virtual;
                    else if (q)
                        q = q->next = cons(r2, q->next);
                    else
                        (q = p)->rule = r2;
                }
                if (q && !(state.questionable & 0x00020000))
                {
                    unsigned long   u = 0;
                    unsigned long   n = 0;

                    /*
                     * mutually dependent requirements can
                     * get us into a loop -- this limits
                     * the total number to half the square
                     * of the number of unique non-virtual
                     * prereqs
                     */

                    for (q = r->prereqs; q; q = q->next)
                        if (!(q->rule->property & P_virtual))
                        {
                            n++;
                            if (!(q->rule->mark & M_mark))
                            {
                                q->rule->mark |= M_mark;
                                u++;
                            }
                        }
                    if (u < 4)
                        u = 4;
                    if (n > (u * u) / 2)
                    {
                        for (q = r->prereqs; q; q = q->next)
                            if (!(q->rule->property & P_virtual) && (q->rule->mark & M_mark))
                                q->rule->mark &= ~(M_mark|M_generate);
                            else
                                q->rule->mark |= M_generate;
                        for (q = p; q; q = q->next)
                            if (!q->next || !(q->next->rule->mark & M_generate))
                            {
                                p = q;
                                message((-2, "require loop avoidance skips to %s [total=%lu uniqe=%lu]", q->next ? q->next->rule->name : "END", n, u));
                                break;
                            }
                    }
                    for (q = r->prereqs; q; q = q->next)
                        q->rule->mark &= ~(M_mark|M_generate);
                }
            }
        }
        p = p->next;
    }

    /*
     * check metarule prerequisites
     */

    if (!errors && !(r->property & (P_attribute|P_functional|P_operator|P_state|P_virtual)) && ((r->property & P_implicit) || !r->action && !explicit))
    {
        message((-2, "check metarule prerequisites"));
#if DEBUG
        if (!r->active)
        {
            dumprule(sfstderr, r);
            error(PANIC, "%s: active=0", r->name);
        }
#endif
        if (r0 && (flags & P_implicit))
            r0->property |= P_implicit;
        if ((r2 = metaget(r, r->active, stem, &r4)) && !(state.questionable & 0x00100000) && ((state.questionable & 0x00200000) || !(r->property & P_implicit)) && strchr(unbound(r), '/') && !strchr(r4->name, '/'))
            r2 = 0;
        if (r2)
        {
            r1 = r4;
            if (state.mam.out && !mam)
            {
                mam = state.mam.out;
                pop = mampush(mam, r, flags);
            }
            if (mam)
                sfprintf(mam, "%smeta %s %s %s %s\n", state.mam.label, mamname(r), r4->name, state.mam.statix ? localview(r2) : r2->name, stem);
            debug((-9, "metarule=%s source=%s stem=%s", r4->name, r2->name, stem));
            frame.stem = stem;

            /*
             * primary metarule match
             */

            if ((r1->property & P_accept) && r->must == 1 && r0 && r0->time)
            {
                tevent = 0;
                r->must = 0;
                must = 0;
            }
            else if (!r0 || !r0->time)
            {
                tevent = CURTIME;
                r->must++;
                must = 1;
            }

            /*
             * check the implicit source prerequisite
             */

            if (!(errors += make(r2, &t, NiL, 0)))
            {
                if (tevent < t)
                    tevent = t;
                if (r->time < t || (r2->dynamic & D_same))
                    r->must++;
                if (r1->property & P_after)
                {
                    r2->property |= P_after;
                    r->dynamic |= D_hasafter;
                }
                if (r1->property & P_before)
                {
                    r2->property |= P_before;
                    r->dynamic |= D_hasbefore;
                }

                /*
                 * check joint metarule targets
                 */

                if (r4 = metainfo('S', r1->name, NiL, 0))
                {
                    Rule_t*     joint;
                    Rule_t*     x;
                    Rule_t*     r5;
                    Sfio_t*     tmp;
                    int     i;

                    message((-2, "check joint metarule targets"));
                    tmp = sfstropen();
                    sfprintf(tmp, "%s.%s", internal.joint->name, unbound(r2));
                    joint = makerule(sfstruse(tmp));
                    joint->property |= P_joint|P_readonly|P_virtual;
                    for (p = r4->prereqs; p; p = p->next)
                    {
                        metaexpand(tmp, stem, p->rule->name);
                        s = sfstruse(tmp);
                        x = makerule(s);
                        if (x->property & P_joint)
                            x->prereqs->rule = joint;
                        else
                        {
                            x->property |= P_joint|P_target;
                            x->prereqs = cons(joint, x->prereqs);
                        }
                        joint->prereqs = append(joint->prereqs, cons(x, NiL));
                        if (x != r)
                        {
                            message((-1, "make(%s)", s));
                            error_info.indent++;

                            /*
                             * NOTE: some joint targets may not be generated
                             */

                            t = (r4 = bindfile(NiL, s, 0)) ? r4->time : (Time_t)0;
                            if (!(r5 = staterule(RULE, r4, s, 0)))
                                i = state.accept;
                            else if (t)
                            {
                                r5->dynamic |= D_built;
                                i = state.accept || statetimeq(r4, r5);
                            }
                            else
                                i = !r5->time;
                            if (!i)
                            {
                                tevent = CURTIME;
                                reason((1, "joint metarule target %s [%s] changed [%s]", s, timestr(r4 ? r4->time : (Time_t)0), timestr(r5 ? r5->time : (Time_t)0)));
                            }
                            x->status = r->status;
                            message((-1, "time(%s) = %s", s, timestr(t)));
                            if (state.unwind == error_info.indent)
                            {
                                state.unwind = 0;
                                errors = 0;
                            }
                            error_info.indent--;
                            if (!x->active || x->active->parent != oframe)
                            {
                                fp = newof(0, Frame_t, 1, 0);
                                fp->target = x;
                                fp->parent = oframe;
                                fp->previous = x->active;
                                fp->action = x->action;
                                fp->prereqs = x->prereqs;
                                x->active = fp;
                            }
                        }
                    }
                    sfstrclose(tmp);
                }

                /*
                 * check the metarule
                 */

                errors += make(r1, &t, NiL, 0);
                if (!errors)
                {
                    /*UNDENT*/
    if (tevent < t)
        tevent = t;
    if (r->time < t || (r1->dynamic & D_same))
        r->must++;

    /*
     * check the explicit action
     */

    if ((r->property & P_implicit) && r->action && r->action == r->active->action && (!r0->action || !streq(r0->action, r->action)))
    {
        reason((1, "%s action changed [#2]", r->name));
        r0->action = r->action;
        state.savestate = 1;
        if (!(r->property & P_accept) && !state.accept)
        {
            tevent = CURTIME;
            r->must++;
        }
    }
    if ((state.questionable & 0x00000010) && r->view > r->preview && !(r->property & P_accept) && (!(r4 = staterule(PREREQS, r, NiL, 0)) || !r4->time))
    {
        reason((1, "%s view %d must be in view %d", r->name, r->view, r->preview));
        tevent = CURTIME;
        r->must++;
    }

    /*
     * check for update
     */

    timefix(tevent);
    if (must || r->time < tevent && (!(r4 = staterule(PREREQS, r, NiL, 0)) || r4->time < tevent) || (r->property & P_force) || prereqchange(r, r->prereqs, r0, r0->prereqs) || state.force)
    {
        if (state.touch)
            r->time = CURTIME;

        /*
         * trigger the action
         */

        if (r3)
        {
            r = unalias(r, r3, r3name);
            if (r0)
                r0 = staterule(RULE, r, NiL, 1);
        }
        r->active->primary = r2->name;
        errors += update(r, r1, arg);
    }
                    /*INDENT*/
                }
            }
        }
        else if (!errors && (r->property & P_implicit) && !state.override)
        {
            errors++;
            r->status = FAILED;
            parentage(internal.tmp, r, " : ");
            error(state.keepgoing || state.unwind ? 1 : 3, "can't find source for %s", sfstruse(internal.tmp));
            state.errors++;
        }
    }
    else
        r2 = 0;

    /*
     * determine the update rule if no metarule applied
     */

    if (r2)
    {
        r1 = 0;
        r0->dynamic |= D_built;
    }
    else if (r->action)
    {
        r1 = r;
        if (r0)
        {
            if (r->action == r->active->action && (!r0->action || !streq(r0->action, r->action)))
            {
                reason((1, "%s action changed [#3]", r->name));
                r0->action = r->action;
                state.savestate = 1;
                if (!(r->property & P_accept) && !state.accept)
                {
                    tevent = CURTIME;
                    r->must++;
                }
            }
            r0->dynamic |= D_built;
        }
    }
    else
    {
        r1 = 0;
        if (r0)
        {
            if (r0->action)
            {
                reason((1, "%s action changed [#4]", r->name));
                r0->action = 0;
                state.savestate = 1;
            }

            /*
             * at this point we accept the target as terminal source
             */

            r0->dynamic &= ~D_built;

            /*
             * ... unless it doesn't exist
             */

            if (!r0->time)
                r->time = 0;
        }
    }
    if (r1)
    {
        if ((state.questionable & 0x00000010) && r->view > r->preview && !(r->property & P_accept) && (!(r4 = staterule(PREREQS, r, NiL, 0)) || !r4->time))
        {
            reason((1, "%s view %d must be in view %d", r->name, r->view, r->preview));
            must = 1;
            tevent = CURTIME;
            r->must++;
        }
        else if ((r->property & (P_attribute|P_functional|P_ignore|P_target)) == P_target && (state.force || r0 && !r0->time))
        {
            /*
             * this takes care of non-file targets
             */

            must = 1;
            tevent = CURTIME;
            r->must++;
        }
    }

    /*
     * do the explicit action
     */

    timefix(tevent);
    message((-2, "[%s] : [%s]%s%s%s", timestr(r->time), timestr(tevent), errors ? " ERRORS" : null, errors && state.unwind >= error_info.indent ? " ignored" : null, must ? " must" : null));
    if (errors && !(state.questionable & 0x00800000))
        r->status = FAILED;
    else
    {
        if (!errors && !(r->dynamic & D_triggered) && r->status == UPDATE && (r1 && must || r->time < tevent && (!(r4 = staterule(PREREQS, r, NiL, 0)) || r4->time < tevent) || !r->time || !r2 && ((r->property & P_force) || r0 && (r->prereqs || r->action) && prereqchange(r, r->prereqs, r0, r0->prereqs))))
        {
            if (r1)
            {
                if (r3)
                {
                    r = unalias(r, r3, r3name);
                    if (r0)
                        r0 = staterule(RULE, r, NiL, 1);
                }
                errors += update(r, r1, arg);
            }
            else if (r->property & P_dontcare)
            {
                statetime(r, 0);
                tevent = 0;
            }
            else if (!(r->property & (P_state|P_virtual)))
            {
                if (!(r->property & (P_target|P_terminal)) || r2 || (r->property & P_terminal) && !r->time)
                {
                    if (r->status == UPDATE)
                    {
                        /*
                         * the attribute test handles rules in
                         * make object files that have since
                         * become attributes, e.g., .READONLY
                         */

                        if ((r->property & P_attribute) || (r1 = associate(internal.dontcare_p, r, NiL, NiL)) && call(r1, r->name))
                        {
                            r->status = IGNORE;
                            statetime(r, 0);
                            tevent = 0;
                        }
                        else
                        {
                            errors++;
                            r->status = FAILED;
                            parentage(internal.tmp, r, " : ");
                            error(state.keepgoing || state.unwind ? 1 : 3, "don't know how to make %s", sfstruse(internal.tmp));
                            state.errors++;
                        }
                    }
                }
                else if (state.exec || state.mam.statix)
                {
                    statetime(r, 0);
                    if (!(r->property & P_terminal))
                        tevent = 0;
                }
            }
        }
        if (!(r->dynamic & D_triggered))
            trigger(r, NiL, NiL, 0);
    }
    if (r->property & P_statevar)
    {
        if (state.targetview >= 0)
        {
            if (!tstbit(r->checked[RULE], state.targetview))
                staterule(RULE, r, NiL, 1);
            if (!tstbit(r->checked[CONSISTENT], state.targetview))
            {
                reason((1, "%s inconsistent with view %s", r->name, state.view[state.targetview].path));
                tevent = CURTIME;
            }
        }
        if (!state.accept && !(r->property & P_accept) && r->time < tevent)
            r->time = tevent;
    }
    else if (!(r->property & P_state))
    {
        if (!(r->property & P_archive) && r->scan && state.scan)
        {
            if (r->status == MAKING)
                complete(r, NiL, NiL, 0);
            if (r->status == UPDATE || r->status == EXISTS)
            {
                tevent = r->time;
                errors += makescan(r, &t);
                if (tevent < t)
                    tevent = t;
            }
        }
        else
        {
            if (r->property & P_parameter)
                tevent = OLDTIME;
            if (r0 && ((r0->dynamic & D_built) || !r0->scan))
            {
                if (r0->prereqs != r->prereqs)
                {
#if _HUH_1992_09_30 /* this test is insufficient */
                    if ((r->property & (P_joint|P_target)) != (P_joint|P_target))
                        freelist(r0->prereqs);
#endif
                    r0->prereqs = r->prereqs;
                }
                r0->attribute = r->attribute;
                r0->scan = 0;
            }
        }
        if (r0 && (r->property & (P_joint|P_target)) == (P_joint|P_target))
            for (p = r->prereqs->rule->prereqs; p; p = p->next)
                if (p->rule != r)
                {
                    r1 = staterule(RULE, p->rule, NiL, 1);
                    r1->prereqs = r0->prereqs;
                    r1->attribute = r0->attribute;
                    r1->scan = r0->scan;
                    r1->action = r0->action;
                }
        if (r->time < tevent || (r->property & (P_attribute|P_parameter)))
        {
            r->time = tevent;
            if (!r0)
                r0 = staterule(RULE, r, NiL, 1);
            r0->event = tevent;
        }
    }
    if (r->status == FAILED)
        errors++;
    if (r->property & P_state)
    {
        if (r->time != otime)
            state.savestate = 1;
    }
    else if (state.force && (!(r->property & P_dontcare) || r->action || r2))
        r->time = CURTIME;
    if (r0 && (r->dynamic & D_triggered) && (r->property & P_make))
    {
        r0->time = r0->event = r->time;
        state.savestate = 1;
    }

    /*
     * restore and return
     */

    for (p = joint(r); p; p = p->next)
    {
        r1 = p->rule;
        if (fp = r1->active)
        {
            if ((r1->property & P_state) && fp->prereqs)
                fp->prereqs->next = 0;
            r1->action = fp->action;
            r1->active = fp->previous;
            if (fp != &frame)
                free(fp);
        }
        if (r1 != r)
        {
            r1->time = r->time;
            r1->status = r->status;
        }
    }
    state.targetview = otargetview;
    state.frame = oframe;
    if (state.unwind == error_info.indent)
    {
        state.unwind = 0;
        errors = 0;
    }
    error_info.indent--;
    if (!(r->property & P_ignore))
    {
        t = r->time;
        if (parent->scan == SCAN_IGNORE)
        {
            if (!(r->dynamic & D_triggered) && !r->must)
                t = r0 ? r0->time : otime;
        }
        else if ((parent->property & P_archive) && (r->dynamic & D_regular) && (parent->dynamic & D_entries) && !(r->dynamic & D_member) && !(r->property & (P_archive|P_command|P_dontcare|P_ignore|P_state|P_virtual)))
            t = CURTIME;
        *ttarget = t;
        PREVIEW(parent, r);
    }
    message((-1, "time(%s) = %s", r->name, timestr(*ttarget)));
    if (mam && pop)
        mampop(mam, r, P_virtual);
    return errors;
}

/*
 * make explicit before prerequisites if r's action will trigger
 */

int
makebefore(register Rule_t* r)
{
    register List_t*    p;
    register int        errors;
    Time_t          t;

    errors = 0;
    if ((r->dynamic & (D_hasbefore|D_triggered)) == (D_hasbefore|D_triggered))
    {
        r->dynamic &= ~D_hasbefore;
        message((-2, "check explicit before `prerequisites'"));
        for (p = r->prereqs; p; p = p->next)
            if ((p->rule->property & (P_after|P_before)) == P_before)
                errors += make(p->rule, &t, NiL, 0);
    }
    return errors;
}

/*
 * make explicit after prerequisites if r's action triggered
 */

int
makeafter(register Rule_t* r, Flags_t property)
{
    register List_t*    p;
    register int        errors;
    Time_t          t;

    errors = 0;
    if ((r->dynamic & (D_hasafter|D_triggered)) == (D_hasafter|D_triggered))
    {
        statetime(r, -1);
        r->dynamic &= ~(D_hasafter|D_hasmake);
        message((-2, "check explicit %safter `prerequisites'", (property & P_dontcare) ? "dontcare " : null));
        for (p = r->prereqs; p; p = p->next)
            if ((p->rule->property & P_failure) == property)
                errors += make(p->rule, &t, NiL, 0);
    }
    return errors;
}