cmd/nmake/scan.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1984-2011 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 language dependent scan support
 */

#include "make.h"

#include <tm.h>

#define SCAN_define     (1<<0)  /* enable D actions     */
#define SCAN_macro      (1<<1)  /* macro (default line) style   */
#define SCAN_nopropagate    (1<<2)  /* don't propagate scan index   */
#define SCAN_state      (1<<3)  /* scan for state vars      */
#define SCAN_override       (1<<4)  /* no scan override warning */

#define QUOTE_blank     (1<<0)  /* blank out quote      */
#define QUOTE_comment       (1<<1)  /* comment quote type       */
#define QUOTE_nested        (1<<2)  /* nesting quote        */
#define QUOTE_newline       (1<<3)  /* newline terminates quote */
#define QUOTE_quote     (1<<4)  /* normal quote         */
#define QUOTE_single        (1<<5)  /* quote next char      */
#define QUOTE_space     (1<<6)  /* quote preceded by space  */

#define ANY         '\t'    /* 0 or more internal code  */
#define ARG         '\n'    /* grab arg internal code   */
#define DIG         '\b'    /* 0 or more digit internal code*/
#define NAM         '\v'    /* 0 or more var internal code  */
#define REP         '\r'    /* repeat group internal code   */
#define SPC         ' ' /* 0 or more space internal code*/
#define TOK         '\f'    /* 0 or more token chars    */

#define SCANARGS        2   /* max number % arg matches */
#define SCANBUFFER      4096    /* scan buffer size     */

typedef unsigned short Scanstate_t;

struct Quote_s; typedef struct Quote_s Quote_t;

typedef struct Action_s         /* state action         */
{
    short       type;       /* action type id       */
    short       flags;      /* SCAN_* flags         */
    char*       pattern;    /* match expression     */
    char*       map;        /* path name map        */
    char*       script;     /* script           */
    struct
    {
    unsigned long   clear;      /* clear these          */
    unsigned long   set;        /* set these            */
    }       attribute;  /* attributes           */
    struct
    {
    unsigned long   clear;      /* clear these          */
    unsigned long   set;        /* set these            */
    }       property;   /* properties           */
    int     attrprop;   /* attribute|property mods  */
    int     scan;       /* scan index           */
} Action_t;

struct Quote_s              /* quote/comment match info */
{
    Quote_t*    next;       /* next in list         */
    char*       begin;      /* begin pattern        */
    char*       end;        /* end pattern          */
    int     escape;     /* end escape char      */
    int     flags;      /* QUOTE_* flags        */
};

typedef struct Scan_s           /* scan info            */
{
    unsigned char   type[UCHAR_MAX];/* SCAN_* types indexed by char */
    int     flags;      /* SCAN_* flags         */
    char*       external;   /* external scan        */
    Action_t*   before;     /* do this before scanexec  */
    Action_t*   after;      /* do this after scanexec   */
    Quote_t*    quote;      /* quote patterns       */
    Action_t*   action;     /* action table         */
    Action_t*   classid;    /* classid action       */
    Scanstate_t*    state;      /* state transition table   */
    void*       data;       /* private data         */
} Scan_t;

/*
 * default scan strategies
 */

static Namval_t     scantab[] =
{
    ".IGNORE",  SCAN_IGNORE,
    ".NULL",    SCAN_NULL,
    ".STATE",   SCAN_STATE,
};

static Scan_t*      strategy[SCAN_MAX+1];

/*
 * initialize the scan atoms
 */

void
initscan(int repeat)
{
    register int        i;
    register Rule_t*    r;

    if (!repeat)
        for (i = 0; i < elementsof(scantab); i++)
        {
            r = catrule(internal.scan->name, scantab[i].name, NiL, 1);
            r->property |= P_attribute;
            r->scan = scantab[i].value;
            addprereq(internal.scan, r, PREREQ_APPEND);
        }
}

/*
 * scan pattern sort -- strcmp(3) convention
 */

static int
scansort(register const char* a, register const char* b)
{
    register const char*    s;

    while (*++a == *++b)
        if (!*a)
            return 0;
    for (s = "* %@"; *s; s++)
        if (*a == *s)
            return 1;
        else if (*b == *s)
            return -1;
    return *a - *b;
}

/*
 * compile a branch of the expression tree
 * next state pointer returned
 */

static Scanstate_t*
scanbranch(Scanstate_t* u, Action_t* action, Action_t* first, Action_t* last, register int i)
{
    register Action_t*  a;
    Action_t*       b;
    Action_t*       m;
    Scanstate_t*        v;

    for (a = first; a <= last; a++)
    {
        if (a->pattern)
        {
            while (a->pattern[i])
            {
                v = u + 1;
                m = a;
                for (b = a + 1; b <= last; b++)
                {
                    if (b->pattern && b->pattern[i] && b->pattern[i] != m->pattern[i])
                    {
                        *u++ = m->pattern[i];
                        *u++ = 0;
                        m = b;
                    }
                }
                if (m != a)
                {
                    *u++ = m->pattern[i];
                    *u++ = 0;
                    *u++ = 0;
                    *u++ = 0;
                    m = a;
                    for (b = a + 1; b <= last; b++)
                    {
                        if (b->pattern && b->pattern[i] != m->pattern[i])
                        {
                            if ((*v = (u - v)) != (u - v))
                                error(3, "pattern transition offset %d too large", (u - v));
                            v += 2;
                            u = scanbranch(u, action, m, b - 1, i + 1);
                            m = b;
                        }
                    }
                    if ((*v = (u - v)) != (u - v))
                        error(3, "pattern transition offset %d too large", (u - v));
                    return scanbranch(u, action, m, last, i + 1);
                }
                switch (*u++ = a->pattern[i++])
                {
                case DIG:
                case NAM:
                case REP:
                case SPC:
                case TOK:
                    *u++ = 1;
                    break;
                default:
                    *u++ = 3;
                    *u++ = 0;
                    *u++ = 0;
                    break;
                }
            }
            *u++ = 0;
            *u++ = a - action;
            a->pattern = 0;
        }
    }
    return u;
}

/*
 * parse scan action for a in s
 * s points to the first delimiter
 */

static void
scanaction(Action_t* a, register char* s)
{
    register int    c;
    register int    t;
    register char*  v;
    register char*  n;
    Rule_t*     u;
    unsigned long   m;

    if (c = *s++)
        do
        {
            v = n = s;
            while (t = *s++)
            {
                if (t == c)
                    break;
                if (t == '\\' && !(t = *s++))
                    break;
                *n++ = t;
            }
            *n = 0;
            if (!*v)
                break;
            switch (*v++)
            {
            case 'A':
                n = tokopen(v, 1);
                while (v = tokread(n))
                {
                    if (((t = *v) == ATTRSET || t == ATTRCLEAR) && *(v + 1))
                    {
                        *v = ATTRNAME;
                        u = getrule(v);
                        *v = t;
                        if (!u)
                            u = getrule(v + 1);
                    }
                    else
                        u = getrule(v);
                    if (!u || !(u->property & P_attribute))
                        error(3, "%s: must be an attribute", v);
                    if (u->scan)
                    {
                        if (!a->scan)
                            a->scan = u->scan;
                    }
                    else if (u->attribute && !(u->property & P_ignore))
                    {
                        a->attrprop = 1;
                        if (t == '-')
                            a->attribute.clear |= u->attribute;
                        else
                            a->attribute.set |= u->attribute;
                    }
                    else if (m = u->property & (P_accept|P_after|P_always|P_archive|P_before|P_command|P_dontcare|P_force|P_foreground|P_functional|P_ignore|P_implicit|P_local|P_make|P_multiple|P_parameter|P_repeat|P_terminal|P_virtual))
                    {
                        a->attrprop = 1;
                        if (t == '-')
                            a->property.clear |= m;
                        else
                            a->property.set |= m;
                    }
                }
                tokclose(n);
                break;
            case 'M':
                if (a->map)
                {
                    error(1, "%c: multiply defined", *(v - 1));
                    free(a->map);
                }
                a->map = strdup(v);
                break;
            case 'O':
                for (;;)
                {
                    switch (*v++)
                    {
                    case 0:
                        break;
                    case 'X':
                        a->flags |= SCAN_nopropagate;
                        continue;
                    default:
                        error(1, "%c: invalid match option", *(v - 1));
                        continue;
                    }
                    break;
                }
                break;
            case 'R':
                if (a->script)
                {
                    error(1, "%c: multiply defined", *(v - 1));
                    free(a->script);
                }
                a->script = strdup(v);
                break;
            default:
                error(1, "%c: invalid match operation", *(v - 1));
                break;
            }
        } while (t);
}

/*
 * compile scan description in r and return scan pointer
 */

static Scan_t*
scancompile(Rule_t* r, int flags)
{
    register char*      s;
    register Scan_t*    ss;
    register Quote_t*   q;
    register int        c;
    int         i;
    int         t;
    int         z;
    int         line;
    char*           file;
    char*           n;
    char*           v;
    char*           y;
    char*           x[128];
    char**          p;
    Action_t*       a;
    Sfio_t*         tmp;

    z = 0;
    p = x;
    ss = newof(0, Scan_t, 1, 0);
    ss->flags = flags;
    tmp = sfstropen();
    expand(tmp, r->action);
    s = sfstruse(tmp);
    file = error_info.file;
    error_info.file = r->name;
    line = error_info.line;
    error_info.line = 0;
    do
    {
        error_info.line++;
        if (n = strchr(s, '\n'))
            *n++ = 0;
        switch (*s++)
        {
        case 0:
            break;
        case 'C':
            ss->classid = newof(0, Action_t, 1, 0);
            scanaction(ss->classid, s);
            ss->data = hashalloc(NiL, HASH_set, HASH_ALLOCATE, HASH_name, r->name, 0);
            break;
        case 'D':
            if (!(ss->flags & SCAN_define))
                break;
            /*FALLTHROUGH*/
        case 'A':
        case 'B':
        case 'E':
        case 'I':
        case 'T':
            if (*s)
            {
                if (p >= &x[elementsof(x) - 1])
                    error(3, "too many patterns");
                *p++ = s - 1;
                z += n ? (n - s) : strlen(s);
            }
            break;
        case 'F':
            ss->after = newof(0, Action_t, 1, 0);
            scanaction(ss->after, s);
            break;
        case 'O':
            c = isalnum(*s) ? 0 : *s++;
            for (;;)
            {
                switch (*s++)
                {
                case 0:
                    break;
                case 'M':
                    ss->flags |= SCAN_macro;
                    continue;
                case 'O':
                    ss->flags |= SCAN_override;
                    continue;
                case 'S':
                    ss->flags |= SCAN_state;
                    continue;
                default:
                    if (*(s - 1) == c)
                        break;
                    error(1, "%c: invalid scan option", *(s - 1));
                    continue;
                }
                break;
            }
            break;
        case 'Q':
            if (c = *s++)
            {
                q = newof(0, Quote_t, 1, 0);
                q->next = ss->quote;
                ss->quote = q;
                q->end = null;
                z = 0;
                do
                {
                    v = y = s;
                    while (t = *s++)
                    {
                        if (t == c || t == '\\' && !(t = *s++))
                            break;
                        *y++ = t;
                    }
                    *y = 0;
                    switch (z++)
                    {
                    case 0:
                        q->begin = strdup(v);
                        break;
                    case 1:
                        if (!*(q->end = strdup(v)))
                            q->flags |= QUOTE_newline;
                        break;
                    case 2:
                        q->escape = *v;
                        break;
                    case 3:
                        for (;;)
                        {
                            switch (*v++)
                            {
                            case 0:
                                break;
                            case 'C':
                                q->flags |= QUOTE_comment;
                                continue;
                            case 'L':
                                q->flags |= QUOTE_newline;
                                continue;
                            case 'N':
                                q->flags |= QUOTE_nested;
                                continue;
                            case 'Q':
                                q->flags |= QUOTE_quote;
                                continue;
                            case 'S':
                                q->flags |= QUOTE_single;
                                continue;
                            case 'W':
                                q->flags |= QUOTE_space;
                                continue;
                            default:
                                error(1, "%c: invalid quote option", *(v - 1));
                                continue;
                            }
                            break;
                        }
                        break;
                    case 4:
                        break;
                    default:
                        error(1, "%s: too many quote fields", v - 1);
                        break;
                    }
                } while (t);
                ss->type[*q->begin] |= q->flags;
            }
            break;
        case 'S':
            ss->before = newof(0, Action_t, 1, 0);
            scanaction(ss->before, s);
            break;
        case 'X':
            if (*s)
                s++;
            if (ss->external)
            {
                error(1, "%s: external scan multiply defined", s - 1);
                free(ss->external);
            }
            ss->external = strdup(s);
            break;
        default:
            error(1, "%c: invalid scan directive", *(s - 1));
            break;
        }
    } while (s = n);
    if (p > x)
    {
        ss->action = a = newof(0, Action_t, p - x + 1, 0);
        ss->state = newof(0, Scanstate_t, z * 4, 0);
        z = p - x;
        strsort(x, z, scansort);
        *p = 0;
        p = x;
        while (s = *p++)
        {
            a++;
            a->type = *s++;
            c = *s++;
            i = 0;
            a->pattern = n = s;
            while (t = *s++)
            {
                if (t == c)
                    break;
                if (t == '\\')
                {
                    if (!(t = *s++))
                        break;
                    switch (t)
                    {
                    case 'D':
                        t = DIG;
                        break;
                    case 'T':
                        t = TOK;
                        break;
                    case 'V':
                        t = NAM;
                        break;
                    }
                    if (n > a->pattern && *(n - 1) == t)
                        continue;
                }
                else if (isspace(t))
                {
                    t = SPC;
                    if (n > a->pattern && *(n - 1) == t)
                        continue;
                }
                else if (t == '%')
                {
                    i++;
                    t = ARG;
                }
                else if (t == '*')
                    t = ANY;
                else if (t == '@')
                    t = REP;
                *n++ = t;
            }
            scanaction(a, s - 1);
            *n = 0;
            switch (a->type)
            {
            case 'A':
            case 'I':
                if (!i)
                    error(3, "%% arg match missing from pattern [%s]", a->pattern);
                if (i > SCANARGS)
                    error(3, "too many %% arg matches in pattern [%s]", a->pattern);
                break;
            }
        }
        scanbranch(ss->state, ss->action, ss->action + 1, ss->action + z, 0);
    }
    sfstrclose(tmp);
    error_info.file = file;
    error_info.line = line;
    maketop(r, P_virtual, NiL);
    if (r->dynamic & D_triggered)
    {
        message((-2, "%s forces re-scan", r->name));
        hashwalk(table.rule, 0, forcescan, &r->scan);
    }
    return ss;
}

/*
 * skip quotes in q
 */

static unsigned char*
scanquote(int fd, unsigned char* buf, unsigned char** p, register unsigned char* g, Quote_t* q, int flags)
{
    register int        c;
    register unsigned char* t;
    unsigned char*      x;
    unsigned char*      y;
    unsigned char*      z;
    int         e;

    for (x = g; q; q = q->next)
        if ((flags & q->flags) && (t = (unsigned char*)q->begin) && *(g - 1) == *t++ && (!(q->flags & QUOTE_space) || (g - 1) == *p || *(g - 2) == ' ' || *(g - 2) == '\t'))
        {
            for (;;)
            {
                while (!(c = *g++))
                {
                    if (*p >= buf + SCANBUFFER)
                    {
                        c = g - *p - 1;
                        memcpy(buf + SCANBUFFER - c, *p, c);
                        *p = buf + SCANBUFFER - c;
                    }
                    x = (buf + SCANBUFFER) - (g - x - 1);
                    if ((c = read(fd, g = buf + SCANBUFFER, SCANBUFFER)) <= 0)
                    {
                        g[0] = 0;
                        return g;
                    }
                    g[c] = 0;
                }
                if (!*t)
                {
                    if (q->flags & QUOTE_single)
                        goto accept;
                    e = *q->end;
                    y = g;
                    for (;;)
                    {
                        if (c == '\n' && (q->flags & QUOTE_newline) && *(g - 2) != q->escape)
                        {
                            g--;
                            goto accept;
                        }
                        if (c == e && *(g - 2) != q->escape)
                        {
                            z = g;
                            t = (unsigned char*)q->end + 1;
                            /*UNDENT*/
    for (;;)
    {
        if (!*t)
        {
            if (c == '\n')
                g--;
            goto accept;
        }
        while (!(c = *g++))
        {
            if (q->flags & QUOTE_comment)
            {
                c = g - z;
                memcpy(buf + SCANBUFFER - c, z - 1, c);
                z = buf + SCANBUFFER - c;
                y = (buf + SCANBUFFER) - (g - y - 1);
                x = (buf + SCANBUFFER) - (g - x - 1);
            }
            else
            {
                c = g - *p - 1;
                memcpy(buf + SCANBUFFER - c, *p, c);
            }
            *p = buf + SCANBUFFER - c;
            if ((c = read(fd, g = buf + SCANBUFFER, SCANBUFFER)) <= 0)
            {
                g[0] = 0;
                return g;
            }
            g[c] = 0;
        }
        if (c != *t++)
        {
            g = z;
            break;
        }
    }
                            /*INDENT*/
                        }
                        while (!(c = *g++))
                        {
                            if (*p >= buf + SCANBUFFER)
                            {
                                c = g - *p - 1;
                                memcpy(buf + SCANBUFFER - c, *p, c);
                                *p = buf + SCANBUFFER - c;
                            }
                            x = (buf + SCANBUFFER) - (g - x - 1);
                            y = (buf + SCANBUFFER) - (g - y - 1);
                            if ((c = read(fd, g = buf + SCANBUFFER, SCANBUFFER)) <= 0)
                            {
                                g[0] = 0;
                                return g;
                            }
                            g[c] = 0;
                        }
                    }
                }
                if (c != *t++)
                {
                    g = x;
                    break;
                }
            }
        }
    return g;
 accept:
    if ((flags & (QUOTE_blank|q->flags)) == (QUOTE_blank|QUOTE_comment))
        for (x--; x < g; *x++ = ' ');
    return g;
}

/*
 * parameter definition
 */

static List_t*
scandefine(register char* s, List_t* p)
{
    register char*  t;
    char*       b;
    char*       z;
    int     c;
    Rule_t*     u;
    Var_t*      v;
    Sfio_t*     tmp;

    while (isspace(*s))
        s++;
    t = s;
    while (*s && istype(*s, C_ID1|C_ID2))
        s++;
    if (s > t)
    {
        c = *s;
        *s = 0;
        u = staterule(VAR, NiL, t, 1);
        if (!(v = getvar(t)))
            v = setvar(t, null, 0);
        *s = c;
        b = t = s;
        for (;;)
        {
            while (isspace(*s))
                s++;
            while (*s && !isspace(*s))
                *t++ = *s++;
            if (!*s)
                break;
            *t++ = ' ';
        }
        for (z = t; z < s; *z++ = ' ');
        *t = 0;
        if (*v->value)
        {
            tmp = sfstropen();
            sfprintf(tmp, "%s#%s", v->value, b);
            setvar(v->name, sfstruse(tmp), 0);
            sfstrclose(tmp);
        }
        else
            setvar(v->name, b, 0);
        if (!(u->mark & M_scan))
        {
            u->mark |= M_scan;
            u->property |= P_parameter;
            v->property |= V_scan;
            p = cons(u, p);
        }
        if (t < s)
            *t = ' ';
    }
    return p;
}

/*
 * macro scan -- only partial parameterization
 *
 *  include(<SP>*<FILE><SP>*)
 *  sinclude(<SP>*<FILE><SP>*)
 *  INCLUDE(<SP>*<FILE>[,<FILE>]*<SP>*)
 *  define(<SP>*<VARIABLE><SP>*,<DEFINITION><SP>*)
 *  ifelse(c,t,f)
 *  # comment
 *
 * attribute and property from first I pattern propagated to prereq files
 */

/*ARGSUSED*/
static List_t*
scanmacro(int fd, Rule_t* r, Scan_t* ss, register List_t* p)
{
    register int        c;
    register int        inquote;
    register char*      w;
    int         n;
    int         dontcare;
    int         ifparen;
    int         paren;
    int         h;
    int         t;
    Sfio_t*         fp;
    Sfio_t*         tmp;
    Rule_t*         u;
    Var_t*          v;

    if (!(fp = sfnew(NiL, NiL, SF_UNBOUND, fd, SF_READ)))
    {
        error(2, "%s: cannot fdopen", r->name);
        return p;
    }
    tmp = sfstropen();
    ifparen = inquote = paren = 0;
    while ((c = sfgetc(fp)) != EOF)
        switch (c)
        {
        case ')':
            if (!inquote)
            {
                sfstrseek(tmp, 0, SEEK_SET);
                if (paren-- == ifparen)
                    ifparen = 0;
            }
            break;

        case '"':
        case '#':
        case '\n':
            if (inquote == c)
            {
                inquote = 0;
                sfstrseek(tmp, 0, SEEK_SET);
            }
            else if (!inquote && c != '\n')
                inquote = c == '#' ? '\n' : c;
            break;

        case '\\':
            sfstrseek(tmp, 0, SEEK_SET);
            sfgetc(fp);
            break;

        default:
            if (!inquote)
            {
                if (!sfstrtell(tmp))
                {
                    if (c == '(')
                        paren++;
                    else if (istype(c, C_VARPOS1) && state.fullscan)
                    {
                        h = 1;
                        t = C_VARPOS1;
                        sfputc(tmp, c);
                    }
                    else if (istype(c, C_ID1|C_ID2))
                    {
                        h = 0;
                        t = C_ID1|C_ID2;
                        sfputc(tmp, c);
                    }
                }
                else
                {
                    if (t != (C_ID1|C_ID2))
                    {
                        if (t == C_VARPOS8)
                            t = C_ID1|C_ID2;
                        else
                            t <<= 1;
                    }
                    if (istype(c, t))
                        sfputc(tmp, c);
                    else if (t == (C_ID1|C_ID2) || !istype(c, C_ID1|C_ID2))
                    {
                        w = sfstruse(tmp);
                        if (h && (v = getvar(w)) && (v->property & V_scan))
                        {
                            u = staterule(VAR, NiL, w, 1);
                            if (!(u->mark & M_scan))
                            {
                                u->mark |= M_scan;
                                p = cons(u, p);
                            }
                        }
                        if (c == '(')
                        {
                            paren++;
                            /*UNDENT*/
        if (*w == 's')
        {
            dontcare = 1;
            w++;
        }
        else
            dontcare = ifparen != 0;
        if (*w == 'i')
        {
            if (!strcmp(w, "include"))
            {
                sfstrseek(tmp, 0, SEEK_SET);
                while ((c = sfgetc(fp)) != EOF && c != ')')
                    if (!isspace(c))
                        sfputc(tmp, c);
                sfungetc(fp, c);
                u = makerule(sfstruse(tmp));
                if (!(u->mark & M_scan))
                {
                    u->mark |= M_scan;
                    if (dontcare)
                        u->property |= P_dontcare;
                    else if (!(u->property & P_target))
                        u->property &= ~P_dontcare;
                    if (ss->action && ss->action[1].attrprop && ss->action[1].type == 'I')
                    {
                        u->attribute &= ~ss->action[1].attribute.clear;
                        u->attribute |= ss->action[1].attribute.set;
                        u->property &= ~ss->action[1].property.clear;
                        u->property |= ss->action[1].property.set;
                    }
                    u->scan = r->scan;
                    staterule(RULE, u, NiL, 1)->scan = r->scan;
                    p = cons(u, p);
                }
            }
            else if (!ifparen && (!strcmp(w, "ifdef") || !strcmp(w, "ifelse")))
                ifparen = paren;
        }
        else if (*w == 'I' && !strcmp(w, "INCLUDE"))
        {
            do
            {
                sfstrseek(tmp, 0, SEEK_SET);
                while ((c = sfgetc(fp)) != EOF && c != ')' && c != ',')
                    if (!isspace(c))
                        sfputc(tmp, c);
                u = makerule(sfstruse(tmp));
                if (!(u->mark & M_scan))
                {
                    u->mark |= M_scan;
                    if (dontcare)
                        u->property |= P_dontcare;
                    else if (!(u->property & P_target))
                        u->property &= ~P_dontcare;
                    if (ss->action && ss->action[1].attrprop && ss->action[1].type == 'I')
                    {
                        u->attribute &= ~ss->action[1].attribute.clear;
                        u->attribute |= ss->action[1].attribute.set;
                        u->property &= ~ss->action[1].property.clear;
                        u->property |= ss->action[1].property.set;
                    }
                    u->scan = r->scan;
                    staterule(RULE, u, NiL, 1)->scan = r->scan;
                    p = cons(u, p);
                }
            } while (c == ',');
            sfungetc(fp, c);
        }
        else if ((r->property & P_parameter) && *w == 'd' && !strcmp(w, "define"))
        {
            sfstrseek(tmp, 0, SEEK_SET);
            while ((c = sfgetc(fp)) != EOF && c != ',')
                if (!isspace(c))
                    sfputc(tmp, c);
            sfputc(tmp, ' ');
            while (isspace(c = sfgetc(fp)));
            if (c == '`')
                inquote = '\'';
            else
                sfungetc(fp, c);
            n = 1;
            while ((c = sfgetc(fp)) != EOF && c != inquote)
            {
                if (!inquote)
                {
                    if (c == '(')
                        n++;
                    else if (c == ')' && !n--)
                        break;
                }
                else if (c == '#')
                {
                    while ((c = sfgetc(fp)) != EOF && c != '\n');
                    continue;
                }
                sfputc(tmp, c);
            }
            inquote = 0;
            p = scandefine(sfstruse(tmp), p);
        }
                            /*INDENT*/
                        }
                    }
                    else
                    {
                        h = 0;
                        t = C_ID1|C_ID2;
                        sfputc(tmp, c);
                    }
                }
            }
            break;
        }
    sfstrclose(tmp);
    sfsetfd(fp, -1);
    sfclose(fp);
    return p;
}

/*
 * do scan match action a on r with matched string s
 * b is beginning of the original line
 */

static List_t*
scanmatch(List_t* p, register Action_t* a, Rule_t* r, char* b, char* s, int iflev, int split)
{
    int     n;
    char*       t;
    char*       o;
    Rule_t*     u;
    Rule_t*     x;
    Sfio_t*     tmp = 0;

    static char label[] = "X-scan-action";

    if (strchr(s, ' '))
        return p;
    if (state.test & 0x00100000)
        error(2, "scanmatch: %s %c", s, a->type);
    if (a->script || a->map)
    {
        o = state.frame->original;
        state.frame->original = b;
        t = state.frame->stem;
        state.frame->stem = s;
        if (a->script)
        {
            if (state.test & 0x00100000)
                error(2, "scanmatch: %s %c script `%s'", s, a->type, a->script);
            label[0] = a->type;
            parse(NiL, a->script, label, NiL);
        }
        if (a->map)
        {
            if (state.test & 0x00100000)
                error(2, "scanmatch: %s %c map `%s'", s, a->type, a->map);
            tmp = sfstropen();
            expand(tmp, a->map);
            s = sfstruse(tmp);
        }
        state.frame->original = o;
        state.frame->stem = t;
    }
    if (*s)
    {
        if (split)
            t = tokopen(s, 1);
        do
        {
            if (split && !(s = tokread(t)))
                break;
            if (o = strchr(s, ' '))
            {
                do
                {
                    *o++ = (state.test & 0x00080000) ? '?' : FILE_SPACE;
                } while (o = strchr(o, ' '));
                o = s;
            }
            if (!*s || *s == '-' && !*(s + 1))
                break;
#if _WINIX
            if (isalpha(*s) && *(s + 1) == ':' && (*(s + 2) == '/' || *(s + 2) == '\\'))
            {
                *(s + 1) = *s;
                *s = '/';
                for (o = s; o = strchr(s, '\\'); *o++ = '/');
            }
#endif
            u = makerule(s);
            if (u->status == UPDATE)
            {
                if (u->uname && streq(s, u->name))
                {
                    message((-2, "%s split from %s", u->name, u->uname));
                    oldname(u);
                    u = makerule(s);
                }
                else
                {
                    parentage(internal.tmp, r, " : ");
                    error(1, "%s : %s: implicit reference before action completed", sfstruse(internal.tmp), unbound(u));
                }
            }
            if (!(u->mark & M_scan))
            {
                u->mark |= M_scan;
                p = cons(u, p);
                if (iflev || o)
                    u->property |= P_dontcare;
                else if (!(u->property & P_target))
                    u->property &= ~P_dontcare;
                x = (u->dynamic & D_alias) ? getrule(u->name) : (Rule_t*)0;
                if (a->attrprop)
                {
                    u->attribute &= ~a->attribute.clear;
                    u->attribute |= a->attribute.set;
                    u->property &= ~a->property.clear;
                    u->property |= a->property.set;
                    if (x)
                    {
                        x->attribute &= ~a->attribute.clear;
                        x->attribute |= a->attribute.set;
                        x->property &= ~a->property.clear;
                        x->property |= a->property.set;
                    }
                }
                if (!(a->flags & SCAN_nopropagate) && (!(u->dynamic & D_scanned) || !u->scan))
                {
                    if (!(n = a->scan))
                        n = r->scan;
                    else if (n == SCAN_NULL)
                        n = 0;
                    if (n && u->scan != n && !(u->property & P_state))
                    {
                        if (u->scan)
                        {
                            char*       os;
                            char*       ns;
                            List_t*     q;

                            os = ns = internal.scan->name;
                            for (q = internal.scan->prereqs; q; q = q->next)
                                if (q->rule->scan == u->scan)
                                    os = q->rule->name;
                                else if (q->rule->scan == n)
                                    ns = q->rule->name;
                            if (!(strategy[n]->flags & SCAN_override))
                                error(1, "%s: scan strategy %s overrides %s", u->name, ns, os);
                        }
                        u->scan = n;
                        staterule(RULE, u, NiL, 1)->scan = n;
                        if (x)
                            x->scan = n;
                    }
                }
            }
        } while (split);
        if (split)
            tokclose(t);
    }
    else
    {
        x = (r->dynamic & D_alias) ? getrule(r->name) : (Rule_t*)0;
        if (a->attrprop)
        {
            r->attribute &= ~a->attribute.clear;
            r->attribute |= a->attribute.set;
            r->property &= ~a->property.clear;
            r->property |= a->property.set;
            if (x)
            {
                x->attribute &= ~a->attribute.clear;
                x->attribute |= a->attribute.set;
                x->property &= ~a->property.clear;
                x->property |= a->property.set;
            }
        }
    }
    if (tmp)
        sfstrclose(tmp);
    return p;
}

#if DEBUG
static char*
opname(Scanstate_t* s)
{
    int     i;

    static char buf[8];

    switch (*s)
    {
    case ANY:
        return "ANY";
    case ARG:
        return "ARG";
    case DIG:
        return "DIG";
    case NAM:
        return "NAM";
    case REP:
        return "REP";
    case SPC:
        return "SPC";
    case TOK:
        return "TOK";
    case 0:
        return "END";
    }
    i = 0;
    buf[i++] = '\'';
    while (i < (sizeof(buf) - 3) && isprint(*s))
        buf[i++] = *s++;
    buf[i++] = '\'';
    buf[i] = 0;
    return buf;
}
#endif

/*
 * scan fd on file r for patterns compiled in ss
 * cons prereqs on p
 */

static List_t*
scanexec(int fd, Rule_t* r, Scan_t* ss, List_t* p)
{
    register int        c;
    register unsigned char* g;
    register Scanstate_t*   s;
    Scanstate_t*        m;
    unsigned char*      pb;
    unsigned char*      x;
    unsigned char*      b;
    Scanstate_t*        rep;
    Scanstate_t*        per;
    char*           a;
    Hash_table_t*       tab;
    Hash_position_t*    pos;
    int         d;
    int         e;
    int         hit;
    int         n;
    int         collect;
    int         iflev;
    int         h;
    int         t;
    int         typ;
    Frame_t         frame;
    Rule_t*         u;
    Var_t*          v;
    struct
    {
    int         arg;
    Scanstate_t*        state;
    unsigned char*      buffer;
    }           any[8], *pop, *pp;
    unsigned char       buf[2 * SCANBUFFER + 1];
    struct
    {
        int     begin;
        int     end;
        int     replace;
    }           arg[SCANARGS];

    if (ss->flags & SCAN_macro)
        return scanmacro(fd, r, ss, p);
    if (ss->external)
    {
        Sfio_t* sp;

        if (!(sp = fapply(r, null, r->name, ss->external, CO_ALWAYS|CO_LOCAL|CO_URGENT)))
            error(3, "%s: external scan error", r->name);
        parse(sp, NiL, "external-scan", NiL);
        sfclose(sp);
        p = internal.implicit->prereqs;
        internal.implicit->prereqs = 0;
        return p;
    }
    zero(frame);
    frame.parent = state.frame;
    if (!(frame.previous = r->active))
    {
        frame.target = r;
        state.frame = r->active = &frame;
    }
    else if (state.frame != r->active)
        state.frame = r->active;
    tab = ss->classid ? (Hash_table_t*)ss->data : (Hash_table_t*)0;
    iflev = (r->property & P_dontcare) ? 1 : 0;
    g = buf + 2 * SCANBUFFER;
    g[0] = 0;
    m = 0;
    collect = 0;
    for (;;)
    {
        n = 0;
        pop = any;
        rep = per = 0;
        pb = 0;
        hit = 0;
        b = g;
        if (state.test & 0x00000080)
        {
            for (x = g; *x && *x != '\n'; x++);
            if (x > g)
                error(2, "scanexec: NXT \"%-.*s\"", x - g, g);
        }
        if (s = ss->state)
        {
        next:
            while (!(c = *g++))
            {
                c = g - b - 1;
                g = buf + SCANBUFFER;
                if (c && b >= g)
                {
                    memcpy(g - c, b, c);
                    c += b - g;
                    b -= c;
                    if (pb)
                        pb -= c;
                    for (pp = any; pp < pop; pp++)
                        pp->buffer -= c;
                }
                else
                    b = g;
                if ((c = read(fd, g, SCANBUFFER)) <= 0)
                    goto done;
                g[c] = 0;
                if (state.test & 0x00000080)
                {
                    for (x = g; *x && *x != '\n'; x++);
                    error(2, "scanexec: BUF \"%-.*s\"", x - g, g);
                }
            }
            for (;;)
            {
#if DEBUG
                if (state.test & 0x00000080)
                {
                    for (x = g - 1; *x && *x != '\n'; x++);
                    error(2, "scanexec: %s \"%-.*s\"", opname(s), x - (g - 1), g - 1);
                }
#endif
                /*UNDENT*/
    if ((typ = *s) == DIG || typ == SPC || typ == NAM || typ == TOK)
    {
        h = g == (b + 1);
        if (typ == DIG || typ == SPC || typ == NAM && istype(c, C_VARIABLE1) || typ == TOK && istype(c, C_VARIABLE1|C_VARIABLE2))
            for (;;)
            {
                if (typ == SPC ? isspace(c) : typ == DIG ? isdigit(c) : istype(c, C_VARIABLE1|C_VARIABLE2))
                {
                    if (m)
                    {
                        m = 0;
                        if (collect)
                        {
                            collect = 0;
                            arg[n++].end = g - b - 1;
                        }
                    }
#if DEBUG
                    if (!(state.questionable & 0x00000020))
                        h = 1;
#endif
                    if (c == '\n')
                        break;
                    h = 1;
                }
                else if (!c)
                {
                    if (b >= buf + SCANBUFFER)
                    {
                        c = g - b - 1;
                        memcpy(buf + SCANBUFFER - c, b, c);
                        b = buf + SCANBUFFER - c;
                    }
                    if ((c = read(fd, g = buf + SCANBUFFER, SCANBUFFER)) <= 0)
                        goto done;
                    g[c] = 0;
                }
                else if (!m)
                    break;
                c = *g++;
            }
        s += *(s + 1) + 1;
        if (!h && !rep && (*s == ANY || *s == ARG || *s == 0))
        {
#if DEBUG
            if ((state.test & 0x00000080) && *s == 0)
                error(2, "scanexec: HIT *s==0");
#endif
            m = 0;
            collect = 0;
            break;
        }
    }
    else if (typ == ANY)
    {
        if (pop < &any[elementsof(any)])
        {
            pop->arg = n;
            pop->state = s;
            pop->buffer = g;
            pop++;
        }
        s += *(s + 1) + 1;
    }
    else if (typ == ARG)
    {
        m = s += *(s + 1) + 1;
        if (n < elementsof(arg))
        {
            collect = 1;
            arg[n].begin = g - b - 1;
        }
    }
    else if (typ == REP)
    {
        if (rep)
        {
            per = s + *(s + 1) + 1;
            if (n && arg[0].end > arg[0].begin)
            {
                x = b + arg[0].begin;
                while (x < g)
                {
                    if (*per == SPC)
                        while (x < g && isspace(*x))
                            x++;
                    else
                    {
                        if (*x != *per)
                            break;
                        x++;
                    }
                    per += *(per + 1) + 1;
                }
                if (x >= g)
                    break;
            }
            for (s = per; *s; s += *(s + 1) + 1);
            goto rephit;
        }
        else
            rep = s += *(s + 1) + 1;
    }
    else if (typ == 0)
    {
 rephit:
        if (m)
        {
            if (c != '\n')
            {
                s = m;
                goto next;
            }
            m = 0;
            if (collect)
            {
                collect = 0;
                arg[n++].end = g - b - 1;
            }
        }
        if (c == '\n')
        {
            if (per || rep && *rep != ARG && (*rep != SPC || *(rep + *(rep + 1) + 1) != ARG) && (!hit || n))
                g++;
            else
                rep = 0;
        }
        if (*++s && (!n || arg[0].begin < arg[0].end))
        {
            if (rep)
                hit += n;
            if (n < elementsof(arg))
            {
                arg[n].begin = arg[n].end = g - b - 1;
                n++;
            }
            for (c = 0; c < n; c++)
                arg[c].replace = *(b + arg[c].end);
            for (c = 0; c < n; c++)
                *(b + arg[c].end) = 0;
            while (c < elementsof(arg))
                arg[c++].begin = arg[n - 1].begin;
#if DEBUG
            if (state.test & 0x00000080)
                error(2, "scanexec: HIT %s: %c n=%d \"%s\" \"%s\"", r->name, ss->action[*s].type, n - 1, b + arg[0].begin, b + arg[1].begin);
#endif
            a = null;
            switch (c = ss->action[*s].type)
            {
            case 'A':
                if (state.archive)
                {
                    Time_t  date;

                    if (date = strtol((char*)b + arg[1].begin, NiL, 10))
                        date = tmxsns(date, 0);
                    else
                        date = tmxdate((char*)b + arg[1].begin, NiL, TMX_NOW);
                    addfile(state.archive, (char*)b + arg[0].begin, date);
                }
                else
                    error(2, "%s: `A' scan pattern for non-%s", r->name, internal.archive->name);
                a = (char*)b + arg[0].begin;
                break;
            case 'B':
                iflev++;
                break;
            case 'D':
                if (r->property & P_parameter)
                    p = scandefine((char*)b + arg[0].begin, p);
                break;
            case 'E':
                iflev--;
                break;
            case 'I':
            case 'T':
                a = (char*)b + arg[0].begin;
                break;
            }
            p = scanmatch(p, &ss->action[*s], r, (char*)b, a, iflev, c == 'T' ? -1 : a != null && a > (char*)b && (c = *(a - 1)) != '"' && c != '\'' && (c != '<' || arg[0].replace != '>'));
            for (c = 0; c < n; c++)
                *(b + arg[c].end) = arg[c].replace;
            if (pop > any)
                pop--;
        }
        else
        {
#if DEBUG
            if (state.test & 0x00000080)
                error(2, "scanexec: XXX");
#endif
            if (hit)
                rep = 0;
            if (pop > any)
            {
                pop--;
                if (c != '\n')
                {
#if DEBUG
                    if (state.test & 0x00000080)
                        error(2, "scanexec: POP");
#endif
                    m = s = pop->state;
                    g = pop->buffer;
                    n = pop->arg;
                    goto next;
                }
            }
        }
        if (rep)
        {
            s = rep;
            if ((b = --g) == pb)
                goto done;
            pb = b;
            n = 0;
            goto next;
        }
        break;
    }
    else if (c == *s++)
    {
        if (m)
        {
            m = 0;
            if (collect)
            {
                collect = 0;
                arg[n++].end = g - b - 1;
            }
        }
        s += *s;
        goto next;
    }
    else
        s++;
                /*INDENT*/
            }
            g = b;
        }
        n = (ss->flags & SCAN_state) && state.fullscan;
        x = ss->type;
        while ((c = *g++) != '\n')
        {
            if (!c)
            {
                if ((c = read(fd, b = g = buf + SCANBUFFER, SCANBUFFER)) <= 0)
                    goto done;
                g[c] = 0;
            }
            else if (x[c] & (QUOTE_comment|QUOTE_quote))
            {
                if (g - 2 >= b)
                    b = g - 2;
                g = scanquote(fd, buf, &b, g, ss->quote, QUOTE_comment|QUOTE_quote);
            }
            else if (n && istype(c, C_ID1))
            {
                if (istype(c, C_VARPOS1))
                {
                    h = 1;
                    t = C_VARPOS1;
                }
                else
                {
                    h = 0;
                    t = C_ID1|C_ID2;
                }
                b = g - 1;
                for (;;)
                {
                    while (!(c = *g++))
                    {
                        if (b >= buf + SCANBUFFER)
                        {
                            c = g - b - 1;
                            memcpy(buf + SCANBUFFER - c, b, c);
                            b = buf + SCANBUFFER - c;
                        }
                        if ((c = read(fd, g = buf + SCANBUFFER, SCANBUFFER)) <= 0)
                            goto done;
                        g[c] = 0;
                    }
                    if (t != (C_ID1|C_ID2))
                    {
                        if (t == C_VARPOS8)
                            t = C_ID1|C_ID2;
                        else
                            t <<= 1;
                    }
                    if (!istype(c, t))
                    {
                        if (t == (C_ID1|C_ID2) || !istype(c, C_ID1|C_ID2))
                            break;
                        t = C_ID1|C_ID2;
                        h = 0;
                    }
                }
                g--;
                if (h)
                {
                    *g = 0;
                    if ((v = getvar(b)) && (v->property & V_scan))
                    {
                        u = staterule(VAR, NiL, (char*)b, 1);
                        if (!(u->mark & M_scan))
                        {
                            u->mark |= M_scan;
                            p = cons(u, p);
                        }
                    }
                    *g = c;
                }
            }
            else if (tab && istype(c, C_ID1))
            {
                d = e = 0;
                h = 0;
                b = g - 1;
                for (;;)
                {
                    while (!(c = *g++))
                    {
                        if (b >= buf + SCANBUFFER)
                        {
                            c = g - b - 1;
                            memcpy(buf + SCANBUFFER - c, b, c);
                            b = buf + SCANBUFFER - c;
                        }
                        if ((c = read(fd, g = buf + SCANBUFFER, SCANBUFFER)) <= 0)
                            goto done;
                        g[c] = 0;
                    }
                    if (!istype(c, C_ID1|C_VARIABLE2))
                    {
                        if (e && d > 1)
                        {
                            h = e;
                            break;
                        }
                        if (!isspace(c))
                        {
                            h = 0;
                            break;
                        }
                        if (!h)
                            h = g - b - 1;
                    }
                    else if (c == '.')
                    {
                        d++;
                        e = g - b - 1;
                    }
                    else if (h)
                        break;
                }
                g--;
                if (h)
                {
                    c = b[h];
                    b[h] = 0;
                    hashput(tab, b, 1);
                    b[h] = c;
                }
                break;
            }
        }
    }
 done:
    if (tab && (pos = hashscan(tab, 0)))
    {
        while (hashnext(pos))
            if (pos->bucket->value)
            {
                pos->bucket->value = 0;
                p = scanmatch(p, ss->classid, r, pos->bucket->name, pos->bucket->name, 0, 0);
            }
        hashdone(pos);
    }
    r->active = frame.previous;
    state.frame = frame.parent;
    return p;
}

/*
 * return list of r's implicit prerequisites
 * r must be bound to a file which is then scanned
 */

List_t*
scan(register Rule_t* r, Time_t* tm)
{
    register Rule_t*    s;
    register List_t*    oprereqs;
    Rule_t*         alt;
    List_t*         p;
    Scan_t*         ss;
    int         fd;

    if (tm)
        *tm = 0;
    if ((r->property & (P_attribute|P_state|P_virtual)) || !(r->dynamic & D_regular))
        return 0;
    s = staterule(RULE, r, NiL, 1);
    if ((r->property & P_joint) || (s->dynamic & D_built))
    {
        alt = s;
        s = staterule(PREREQS, r, NiL, 1);
        s->property |= P_implicit;
        r->preview = r->view;
    }
    else if (alt = staterule(PREREQS, r, NiL, 0))
    {
        alt->property &= ~P_implicit;
        alt = 0;
    }
    if (r->scan < SCAN_USER)
    {
        ss = 0;
        if (alt)
            s->prereqs = 0;
    }
    else
    {
        if (!strategy[r->scan])
        {
            for (p = internal.scan->prereqs; p; p = p->next)
                if (p->rule->scan == r->scan)
                {
                    strategy[r->scan] = scancompile(p->rule, (r->property & P_parameter) ? SCAN_define : 0);
                    break;
                }
            if (!p)
                error(3, "%s: invalid scan index %d", r->name, r->scan);
        }
        ss = strategy[r->scan];
    }
    r->dynamic |= D_scanned;
    if (s->dynamic & D_scanned)
        return s->prereqs;
    oprereqs = s->prereqs;
    if (ss)
    {
        if (!(r->property & P_accept) && !state.accept && !((s->property | (alt ? alt->property : 0L)) & P_force) && r->scan == s->scan)
            ss = 0;
        else if ((fd = ropen(r->name, O_RDONLY)) < 0)
        {
            if (state.exec && !(r->property & P_dontcare))
                error(1, "cannot read %s", r->name);
            return 0;
        }
        else
        {
            message((-2, "scanning %s for prerequisites", r->name));
            state.savestate = 1;
            s->prereqs = scanexec(fd, r, ss, ss->before ? scanmatch(NiL, ss->before, r, null, null, 0, 1) : (List_t*)0);
            close(fd);
        }
    }
    s->property &= ~P_force;
    s->dynamic |= D_scanned;
    s->scan = r->scan;
    if (alt)
    {
        s->event = alt->event;
        alt->attribute = r->attribute;
        alt->property &= ~P_force;
        alt->scan = s->scan;
        if (alt->prereqs != r->prereqs)
        {
            if ((r->property & (P_joint|P_target)) != (P_joint|P_target))
                freelist(alt->prereqs);
            alt->prereqs = r->prereqs;
        }
    }
    else
        s->attribute = r->attribute;
    if (ss)
    {
        if (ss->after)
        {
            for (p = s->prereqs; p; p = p->next)
                if (p->rule->mark & M_scan)
                {
                    p->rule->mark &= ~M_scan;
                    debug((-5, "%s: implicit prerequisite %s", r->name, p->rule->name));
                }
            s->prereqs = scanmatch(s->prereqs, ss->after, r, null, null, 0, 1);
        }
        for (p = s->prereqs; p; p = p->next)
            if (p->rule->mark & M_scan)
            {
                p->rule->mark &= ~M_scan;
                debug((-5, "%s: implicit prerequisite %s", r->name, p->rule->name));
            }
    }
    if (tm && prereqchange(r, s->prereqs, r, oprereqs))
        *tm = CURTIME;
    if (oprereqs != s->prereqs && (r->property & (P_joint|P_target)) != (P_joint|P_target))
        freelist(oprereqs);
    return s->prereqs;
}