picksbr.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

/* picksbr.c - routines to help pick along... */
#ifndef	lint
static char ident[] = "@(#)$Id: picksbr.c,v 1.2 90/11/25 19:05:21 sharpe Exp $";
#endif	lint

#include "../h/mh.h"
#include "../zotnet/tws.h"
#include <stdio.h>

/*  */

static struct swit parswit[] = {
#define	PRAND	0
    "and", 0,
#define	PROR	1
    "or", 0,
#define	PRNOT	2
    "not", 0,
#define	PRLBR	3
    "lbrace", 0,
#define	PRRBR	4
    "rbrace", 0,

#define	PRCC	5
    "cc  pattern", 0,
#define	PRDATE	6
    "date  pattern", 0,
#define	PRFROM	7
    "from  pattern", 0,
#define	PRSRCH	8
    "search  pattern", 0,
#define	PRSUBJ	9
    "subject  pattern", 0,
#define	PRTO	10
    "to  pattern", 0,
#define	PROTHR	11
    "-othercomponent  pattern", 15,

#define	PRAFTR	12
    "after date", 0,
#define	PRBEFR	13
    "before date", 0,
#define	PRDATF	14
    "datefield field", 5,

    NULL, NULL
};

/*    DEFINITIONS FOR PATTERN MATCHING */

/* We really should be using re_comp() and re_exec() here.  Unfortunately,
   pick advertises that lowercase characters matches characters of both
   cases.  Since re_exec() doesn't exhibit this behavior, we are stuck
   with this version.  Furthermore, we need to be able to save and restore
   the state of the pattern matcher in order to do things "efficiently".

   The matching power of this algorithm isn't as powerful as the re_xxx()
   routines (no \(xxx\) and \n constructs).  Such is life.
 */


#define	CCHR	2
#define	CDOT	4
#define	CCL	6
#define	NCCL	8
#define	CDOL	10
#define	CEOF	11

#define	STAR	01

#define LBSIZE  1024
#define	ESIZE	256


static char	linebuf[LBSIZE + 1];

static char cc[] = {		/* the magic array for case-independence */
	0000,0001,0002,0003,0004,0005,0006,0007,
	0010,0011,0012,0013,0014,0015,0016,0017,
	0020,0021,0022,0023,0024,0025,0026,0027,
	0030,0031,0032,0033,0034,0035,0036,0037,
	0040,0041,0042,0043,0044,0045,0046,0047,
	0050,0051,0052,0053,0054,0055,0056,0057,
	0060,0061,0062,0063,0064,0065,0066,0067,
	0070,0071,0072,0073,0074,0075,0076,0077,
	0100,0141,0142,0143,0144,0145,0146,0147,
	0150,0151,0152,0153,0154,0155,0156,0157,
	0160,0161,0162,0163,0164,0165,0166,0167,
	0170,0171,0172,0133,0134,0135,0136,0137,
	0140,0141,0142,0143,0144,0145,0146,0147,
	0150,0151,0152,0153,0154,0155,0156,0157,
	0160,0161,0162,0163,0164,0165,0166,0167,
	0170,0171,0172,0173,0174,0175,0176,0177,
};

/*    DEFINITIONS FOR DATE MATCHING */

static struct tws *tws_parse (), *tws_special ();


long   time ();

/*    DEFINITIONS FOR NEXUS */

#define	nxtarg()	(*argp ? *argp++ : NULL)
#define	prvarg()	argp--


#define	padvise		if (!talked++) advise


struct nexus {
    int     (*n_action) ();

    union {
	struct {		/* for {OR,AND,NOT}action */
	    struct nexus   *un_L_child;
	    struct nexus   *un_R_child;
	}       st1;
#define	n_L_child	un.st1.un_L_child
#define	n_R_child	un.st1.un_R_child

	struct {		/* for GREPaction */
	    int     un_header;
	    int     un_circf;
	    char    un_expbuf[ESIZE];
	    char   *un_patbuf;
	}       st2;
#define	n_header	un.st2.un_header
#define	n_circf		un.st2.un_circf
#define	n_expbuf	un.st2.un_expbuf
#define	n_patbuf	un.st2.un_patbuf

	struct {		/* for TWSaction */
	    char   *un_datef;
	    int     un_after;
	    struct tws un_tws;
	}	st3;
#define	n_datef		un.st3.un_datef
#define	n_after		un.st3.un_after
#define	n_tws		un.st3.un_tws

    }	un;
};

static	int   talked;
static	int   pdebug = 0;

static  char *datesw;
static  char **argp;

static  struct nexus *head;

static void	PRaction();
static int	gcompile(), advance(), cclass(), tcompile();

static struct	nexus *parse (), *exp1 (), *exp2 (), *exp3 (), *newnexus ();

static int	ORaction (), ANDaction (), NOTaction (), GREPaction (),
		TWSaction ();

/*  */

int	pcompile (vec, date)
register char  **vec,
	        *date;
{
    register char  *cp;

    if ((cp = getenv ("MHPDEBUG")) && *cp)
	pdebug++;

    argp = vec;
    if ((datesw = date) == NULL)
	datesw = "date";
    talked = 0;

    if ((head = parse ()) == NULL)
	return (talked ? 0 : 1);

    if (*argp) {
	padvise (NULLCP, "%s unexpected", *argp);
	return 0;
    }

    return 1;
}

/*  */

static struct nexus *parse () {
    register char  *cp;
    register struct nexus  *n,
                           *o;

    if ((n = exp1 ()) == NULL || (cp = nxtarg ()) == NULL)
	return n;

    if (*cp != '-') {
	padvise (NULLCP, "%s unexpected", cp);
	return NULL;
    }

    if (*++cp == '-')
	goto header;
    switch (smatch (cp, parswit)) {
	case AMBIGSW: 
	    ambigsw (cp, parswit);
	    talked++;
	    return NULL;
	case UNKWNSW: 
	    fprintf (stderr, "-%s unknown\n", cp);
	    talked++;
	    return NULL;

	case PROR: 
	    o = newnexus (ORaction);
	    o -> n_L_child = n;
	    if (o -> n_R_child = parse ())
		return o;
	    padvise (NULLCP, "missing disjunctive");
	    return NULL;

header: ;
	default: 
	    prvarg ();
	    return n;
    }
}

/*  */

static struct nexus *exp1 () {
    register char  *cp;
    register struct nexus  *n,
                           *o;

    if ((n = exp2 ()) == NULL || (cp = nxtarg ()) == NULL)
	return n;

    if (*cp != '-') {
	padvise (NULLCP, "%s unexpected", cp);
	return NULL;
    }

    if (*++cp == '-')
	goto header;
    switch (smatch (cp, parswit)) {
	case AMBIGSW: 
	    ambigsw (cp, parswit);
	    talked++;
	    return NULL;
	case UNKWNSW: 
	    fprintf (stderr, "-%s unknown\n", cp);
	    talked++;
	    return NULL;

	case PRAND: 
	    o = newnexus (ANDaction);
	    o -> n_L_child = n;
	    if (o -> n_R_child = exp1 ())
		return o;
	    padvise (NULLCP, "missing conjunctive");
	    return NULL;

header: ;
	default: 
	    prvarg ();
	    return n;
    }
}

/*  */

static struct nexus *exp2 () {
    register char  *cp;
    register struct nexus  *n;

    if ((cp = nxtarg ()) == NULL)
	return NULL;

    if (*cp != '-') {
	prvarg ();
	return exp3 ();
    }

    if (*++cp == '-')
	goto header;
    switch (smatch (cp, parswit)) {
	case AMBIGSW: 
	    ambigsw (cp, parswit);
	    talked++;
	    return NULL;
	case UNKWNSW: 
	    fprintf (stderr, "-%s unknown\n", cp);
	    talked++;
	    return NULL;

	case PRNOT: 
	    n = newnexus (NOTaction);
	    if (n -> n_L_child = exp3 ())
		return n;
	    padvise (NULLCP, "missing negation");
	    return NULL;

header: ;
	default: 
	    prvarg ();
	    return exp3 ();
    }
}

/*  */

static struct nexus *exp3 () {
    int     i;
    register char  *cp,
                   *dp;
    char    buffer[BUFSIZ], temp[64];
    register struct nexus  *n;

    if ((cp = nxtarg ()) == NULL)
	return NULL;

    if (*cp != '-') {
	padvise (NULLCP, "%s unexpected", cp);
	return NULL;
    }

    if (*++cp == '-') {
	dp = ++cp;
	goto header;
    }
    switch (i = smatch (cp, parswit)) {
	case AMBIGSW: 
	    ambigsw (cp, parswit);
	    talked++;
	    return NULL;
	case UNKWNSW: 
	    fprintf (stderr, "-%s unknown\n", cp);
	    talked++;
	    return NULL;

	case PRLBR: 
	    if ((n = parse ()) == NULL) {
		padvise (NULLCP, "missing group");
		return NULL;
	    }
	    if ((cp = nxtarg ()) == NULL) {
		padvise (NULLCP, "missing -rbrace");
		return NULL;
	    }
	    if (*cp++ == '-' && smatch (cp, parswit) == PRRBR)
		return n;
	    padvise (NULLCP, "%s unexpected", --cp);
	    return NULL;

	default: 
	    prvarg ();
	    return NULL;

	case PRCC: 
	case PRDATE: 
	case PRFROM: 
	case PRTO: 
	case PRSUBJ: 
	    strncpy(temp, parswit[i].sw, sizeof(temp));
	    temp[sizeof(temp) - 1] = '\0';
	    dp = *brkstring (temp, " ", NULLCP);
    header: ;
	    if (!(cp = nxtarg ())) {/* allow -xyz arguments */
		padvise (NULLCP, "missing argument to %s", argp[-2]);
		return NULL;
	    }
	    n = newnexus (GREPaction);
	    n -> n_header = 1;
	    (void) sprintf (buffer, "^%s[ \t]*:.*%s", dp, cp);
	    dp = buffer;
	    goto pattern;

	case PRSRCH: 
	    n = newnexus (GREPaction);
	    n -> n_header = 0;
	    if (!(cp = nxtarg ())) {/* allow -xyz arguments */
		padvise (NULLCP, "missing argument to %s", argp[-2]);
		return NULL;
	    }
	    dp = cp;
    pattern: ;
	    if (!gcompile (n, dp)) {
		padvise (NULLCP, "pattern error in %s %s", argp[-2], cp);
		return NULL;
	    }
	    n -> n_patbuf = getcpy (dp);
	    return n;

	case PROTHR: 
	    padvise (NULLCP, "internal error!");
	    return NULL;

	case PRDATF: 
	    if (!(datesw = nxtarg ()) || *datesw == '-') {
		padvise (NULLCP, "missing argument to %s", argp[-2]);
		return NULL;
	    }
	    return exp3 ();

	case PRAFTR: 
	case PRBEFR: 
	    if (!(cp = nxtarg ())) {/* allow -xyz arguments */
		padvise (NULLCP, "missing argument to %s", argp[-2]);
		return NULL;
	    }
	    n = newnexus (TWSaction);
	    n -> n_datef = datesw;
	    if (!tcompile (cp, &n -> n_tws, n -> n_after = i == PRAFTR)) {
		padvise (NULLCP, "unable to parse %s %s", argp[-2], cp);
		return NULL;
	    }
	    return n;
    }
}

/*  */

static struct nexus *newnexus (action)
register int	(*action) ();
{
    register struct nexus   *p;

    if ((p = (struct nexus *) calloc ((unsigned) 1, sizeof *p)) == NULL)
	adios (NULLCP, "unable to allocate component storage");

    p -> n_action = action;
    return p;
}

/*  */

#define	args(a)	a, fp, msgnum, start, stop
#define	params	args (n)
#define	plist	\
	    register struct nexus  *n; \
	    register FILE *fp; \
	    int	msgnum; \
	    long    start, \
		    stop;

int	pmatches (fp, msgnum, start, stop)
register FILE *fp;
int	msgnum;
long	start,
	stop;
{
    if (!head)
	return 1;

    if (!talked++ && pdebug)
	PRaction (head, 0);

    return (*head -> n_action) (args (head));
}

/*  */

static	void PRaction (n, level)
register struct nexus *n;
register int	level;
{
    register int    i;

    for (i = 0; i < level; i++)
	fprintf (stderr, "| ");

    if (n -> n_action == ORaction) {
	fprintf (stderr, "OR\n");
	PRaction (n -> n_L_child, level + 1);
	PRaction (n -> n_R_child, level + 1);
	return;
    }
    if (n -> n_action == ANDaction) {