mshcmds.c

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

	if (!md)
	    goto done_pack;
    }

    if (!msgp)
	msgs[msgp++] = "all";
    for (msgnum = 0; msgnum < msgp; msgnum++)
	if (!m_convert (mp, msgs[msgnum]))
	    goto done_pack;
    m_setseq (mp);

    if ((md = mbx_open (file, getuid (), getgid (), m_gmprot ())) == NOTOK) {
	advise (file, "unable to open");
	goto done_pack;
    }
    for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
	if (mp -> msgstats[msgnum] & SELECTED)
	    if (pack (file, md, msgnum) == NOTOK)
		break;
    (void) mbx_close (file, md);

    if (mp -> hghsel != mp -> curmsg)
	m_setcur (mp, mp -> lowsel);

done_pack: ;
    free (file);
}

/*  */

int	pack (mailbox, md, msgnum)
char   *mailbox;
int     md,
        msgnum;
{
    register FILE *zp;

    if (Msgs[msgnum].m_bboard_id == 0)
	(void) readid (msgnum);

    zp = msh_ready (msgnum, 1);
    return mbx_write (mailbox, md, zp, Msgs[msgnum].m_bboard_id,
	    0L, ftell (zp), Msgs[msgnum].m_stop, 1, 1);
}

/*  */

int	packhak (args)
char  **args;
{
    int	    result;
    char   *cp,
	   *file = NULL;

    while (cp = *args++) {
	if (*cp == '-')
	    switch (smatch (++cp, packswit)) {
		case AMBIGSW: 
		case UNKWNSW: 
		case PAHELP: 
		    return NOTOK;

		case PAFISW: 
		    if (!(file = *args++) || *file == '-') 
			return NOTOK;
		    continue;
	    }
	if (*cp == '+' || *cp == '@')
	    return NOTOK;
    }

    file = path (file ? file : "./msgbox", TFILE);
    result = access (file, 0) == NOTOK ? OK : NOTOK;
    free (file);

    return result;
}

/*  */

static struct swit pickswit[] = {
#define	PIANSW	0
    "and", 0,
#define	PIORSW	1
    "or", 0,
#define	PINTSW	2
    "not", 0,
#define	PILBSW	3
    "lbrace", 0,
#define	PIRBSW	4
    "rbrace", 0,

#define	PICCSW	5
    "cc  pattern", 0,
#define	PIDASW	6
    "date  pattern", 0,
#define	PIFRSW	7
    "from  pattern", 0,
#define	PISESW	8
    "search  pattern", 0,
#define	PISUSW	9
    "subject  pattern", 0,
#define	PITOSW	10
    "to  pattern", 0,
#define	PIOTSW	11
    "-othercomponent  pattern", 15,
#define	PIAFSW	12
    "after date", 0,
#define	PIBFSW	13
    "before date", 0,
#define	PIDFSW	14
    "datefield field", 5,
#define	PISQSW	15
    "sequence name", 0,
#define	PIPUSW	16
    "public", 0,
#define	PINPUSW	17
    "nopublic", 0,
#define	PIZRSW	18
    "zero", 0,
#define	PINZRSW	19
    "nozero", 0,
#define	PILISW	20
    "list", 0,
#define	PINLISW	21
    "nolist", 0,
#define	PIHELP	22
    "help", 4,

    NULL, NULL
};

/*  */

pickcmd (args)
char  **args;
{
    int     zerosw = 1,
            msgp = 0,
            seqp = 0,
            vecp = 0,
            hi,
            lo,
            msgnum;
    char   *cp,
            buf[BUFSIZ],
           *msgs[MAXARGS],
           *seqs[NATTRS],
           *vec[MAXARGS];
    register FILE *zp;

    while (cp = *args++) {
	if (*cp == '-') {
	    if (*++cp == '-') {
		vec[vecp++] = --cp;
		goto pattern;
	    }
	    switch (smatch (cp, pickswit)) {
		case AMBIGSW: 
		    ambigsw (cp, pickswit);
		    return;
		case UNKWNSW: 
		    fprintf (stderr, "-%s unknown\n", cp);
		    return;
		case PIHELP: 
		    (void) sprintf (buf, "%s [msgs] [switches]", cmd_name);
		    help (buf, pickswit);
		    return;

		case PICCSW: 
		case PIDASW: 
		case PIFRSW: 
		case PISUSW: 
		case PITOSW: 
		case PIDFSW: 
		case PIAFSW: 
		case PIBFSW: 
		case PISESW: 
		    vec[vecp++] = --cp;
pattern: ;
		    if (!(cp = *args++)) {/* allow -xyz arguments */
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    vec[vecp++] = cp;
		    continue;
		case PIOTSW: 
		    advise (NULLCP, "internal error!");
		    return;
		case PIANSW: 
		case PIORSW: 
		case PINTSW: 
		case PILBSW: 
		case PIRBSW: 
		    vec[vecp++] = --cp;
		    continue;

		case PISQSW: 
		    if (!(cp = *args++) || *cp == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    if (seqp < NATTRS)
			seqs[seqp++] = cp;
		    else {
			advise (NULLCP, "only %d sequences allowed!", NATTRS);
			return;
		    }
		    continue;
		case PIZRSW: 
		    zerosw++;
		    continue;
		case PINZRSW: 
		    zerosw = 0;
		    continue;

		case PIPUSW: 	/* not implemented */
		case PINPUSW: 
		case PILISW: 
		case PINLISW: 
		    continue;
	    }
	}
	if (*cp == '+' || *cp == '@') {
	    advise (NULLCP, "sorry, no folders allowed!");
	    return;
	}
	else
	    msgs[msgp++] = cp;
    }
    vec[vecp] = NULL;

    if (!msgp)
	msgs[msgp++] = "all";
    for (msgnum = 0; msgnum < msgp; msgnum++)
	if (!m_convert (mp, msgs[msgnum]))
	    return;
    m_setseq (mp);

    interrupted = 0;
    if (!pcompile (vec, NULLCP))
	return;

    lo = mp -> lowsel;
    hi = mp -> hghsel;

    for (msgnum = mp -> lowsel;
	    msgnum <= mp -> hghsel && !interrupted;
	    msgnum++)
	if (mp -> msgstats[msgnum] & SELECTED) {
	    zp = msh_ready (msgnum, 1);
	    if (pmatches (zp, msgnum, fmsh ? 0L : Msgs[msgnum].m_start,
			fmsh ? 0L : Msgs[msgnum].m_stop)) {
		if (msgnum < lo)
		    lo = msgnum;
		if (msgnum > hi)
		    hi = msgnum;
	    }
	    else {
		mp -> msgstats[msgnum] &= ~SELECTED;
		mp -> numsel--;
	    }
	}

    if (interrupted)
	return;

    mp -> lowsel = lo;
    mp -> hghsel = hi;

    if (mp -> numsel <= 0) {
	advise (NULLCP, "no messages match specification");
	return;
    }

    seqs[seqp] = NULL;
    for (seqp = 0; seqs[seqp]; seqp++) {
	if (zerosw && !m_seqnew (mp, seqs[seqp], 0))
	    return;
	for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
	    if (mp -> msgstats[msgnum] & SELECTED)
		if (!m_seqadd (mp, seqs[seqp], msgnum, 0))
		    return;
    }

    printf ("%d hit%s\n", mp -> numsel, mp -> numsel == 1 ? "" : "s");
}

/*  */

static struct swit replswit[] = {
#define	REANSW	0
    "annotate", 0,
#define	RENANSW	1
    "noannotate", 0,
#define	RECCSW	2
    "cc type", 0,
#define	RENCCSW	3
    "nocc type", 0,
#define	REDFSW	4
    "draftfolder +folder", 0,
#define	REDMSW	5
    "draftmessage msg", 0,
#define	RENDFSW	6
    "nodraftfolder", 0,
#define	REEDTSW	7
    "editor editor", 0,
#define	RENEDSW	8
    "noedit", 0,
#define	REFCCSW	9
    "fcc +folder", 0,
#define	REFLTSW	10
    "filter filterfile", 0,
#define	REFRMSW	11
    "form formfile", 0,
#define	REFRSW	12
    "format", 5,
#define	RENFRSW	13
    "noformat", 7,
#define	REINSW	14
    "inplace", 0,
#define	RENINSW	15
    "noinplace", 0,
#define	REQUSW	16
    "query", 0,
#define	RENQUSW	17
    "noquery", 0,
#define	REWHTSW	18
    "whatnowproc program", 0,
#define	RENWTSW	19
    "nowhatnow", 0,
#define	REWIDSW	20
    "width columns", 0,
#define	REHELP	21
    "help", 4,

    NULL, NULL
};

/*  */

replcmd (args)
char  **args;
{
    int     vecp = 1;
    char   *cp,
           *msg = NULL,
            buf[BUFSIZ],
           *vec[MAXARGS];

    if (fmsh) {
	forkcmd (args, cmd_name);
	return;
    }

    while (cp = *args++) {
	if (*cp == '-')
	    switch (smatch (++cp, replswit)) {
		case AMBIGSW: 
		    ambigsw (cp, replswit);
		    return;
		case UNKWNSW: 
		    fprintf (stderr, "-%s unknown\n", cp);
		    return;
		case REHELP: 
		    (void) sprintf (buf, "%s [msgs] [switches]", cmd_name);
		    help (buf, replswit);
		    return;

		case REANSW:	/* not implemented */
		case RENANSW: 
		case REINSW: 
		case RENINSW: 
		    continue;

		case REFRSW: 
		case RENFRSW: 
		case REQUSW:
		case RENQUSW:
		case RENDFSW:
		case RENEDSW:
		case RENWTSW:
		    vec[vecp++] = --cp;
		    continue;

		case RECCSW: 
		case RENCCSW: 
		case REEDTSW: 
		case REFCCSW: 
		case REFLTSW:
		case REFRMSW: 
		case REWIDSW: 
		case REDFSW:
		case REDMSW:
		case REWHTSW:
		    vec[vecp++] = --cp;
		    if (!(cp = *args++) || *cp == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    vec[vecp++] = cp;
		    continue;
	    }
	if (*cp == '+' || *cp == '@') {
	    advise (NULLCP, "sorry, no folders allowed!");
	    return;
	}
	else
	    if (msg) {
		advise (NULLCP, "only one message at a time!");
		return;
	    }
	    else
		msg = cp;
    }

    vec[0] = cmd_name;
    vec[vecp++] = "-file";
    vec[vecp] = NULL;
    if (!msg)
	msg = "cur";
    if (!m_convert (mp, msg))
	return;
    m_setseq (mp);

    if (mp -> numsel > 1) {
	advise (NULLCP, "only one message at a time!");
	return;
    }
    (void) process (mp -> hghsel, cmd_name, vecp, vec);
    m_setcur (mp, mp -> hghsel);
}

/*  */

static struct swit rmmswit[] = {
#define	RMHELP	0
    "help", 4,

    NULL, NULL
};

/*  */

rmmcmd (args)
char  **args;
{
    int	    msgp = 0,
            msgnum;
    char   *cp,
            buf[BUFSIZ],
           *msgs[MAXARGS];

    while (cp = *args++) {
	if (*cp == '-')
	    switch (smatch (++cp, rmmswit)) {
		case AMBIGSW: 
		    ambigsw (cp, rmmswit);
		    return;
		case UNKWNSW: 
		    fprintf (stderr, "-%s unknown\n", cp);
		    return;
		case RMHELP: 
		    (void) sprintf (buf, "%s [msgs] [switches]", cmd_name);
		    help (buf, rmmswit);
		    return;
	    }
	if (*cp == '+' || *cp == '@') {
	    advise (NULLCP, "sorry, no folders allowed!");
	    return;
	}
	else
	    msgs[msgp++] = cp;
    }

    if (!msgp)
	msgs[msgp++] = "cur";
    for (msgnum = 0; msgnum < msgp; msgnum++)
	if (!m_convert (mp, msgs[msgnum]))
	    return;
    m_setseq (mp);

    rmm ();
}

/*  */

static  rmm () {
    register int    msgnum,
                    vecp;
    register char  *cp;
    char    buffer[BUFSIZ],
	   *vec[MAXARGS];

    if (fmsh) {
	if (rmmproc) {
	    if (mp -> numsel > MAXARGS - 1) {
		advise (NULLCP, "more than %d messages for %s exec",
			MAXARGS - 1, rmmproc);
		return;
	    }
	    vecp = 0;
	    for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
		if (mp -> msgstats[msgnum] & SELECTED)
		    vec[vecp++] = getcpy (m_name (msgnum));
	    vec[vecp] = NULL;
	    forkcmd (vec, rmmproc);
	    for (vecp = 0; vec[vecp]; vecp++)
		free (vec[vecp]);
	}
	else
	    for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
		if (mp -> msgstats[msgnum] & SELECTED) {
		    (void) strcpy (buffer, m_backup (cp = m_name (msgnum)));
		    if (rename (cp, buffer) == NOTOK)
			admonish (buffer, "unable to rename %s to", cp);
		}
    }

    for (msgnum = mp -> lowsel; msgnum <= mp -> hghsel; msgnum++)
	if (mp -> msgstats[msgnum] & SELECTED) {
	    mp -> msgstats[msgnum] |= DELETED;
	    mp -> msgstats[msgnum] &= ~EXISTS;
	}

    if ((mp -> nummsg -= mp -> numsel) <= 0) {
	if (fmsh)
	    admonish (NULLCP, "no messages remaining in +%s", fmsh);
	else
	    admonish (NULLCP, "no messages remaining in %s", mp -> foldpath);
	mp -> lowmsg = mp -> hghmsg = mp -> nummsg = 0;
    }
    if (mp -> lowsel == mp -> lowmsg) {
	for (msgnum = mp -> lowmsg + 1; msgnum <= mp -> hghmsg; msgnum++)
	    if (mp -> msgstats[msgnum] & EXISTS)
		break;
	mp -> lowmsg = msgnum;
    }
    if (mp -> hghsel == mp -> hghmsg) {
	for (msgnum = mp -> hghmsg - 1; msgnum >= mp -> lowmsg; msgnum--)
	    if (mp -> msgstats[msgnum] & EXISTS)
		break;
	mp -> hghmsg = msgnum;
    }

    mp -> msgflags |= MODIFIED;
    modified++;
}

/*  */

static struct swit scanswit[] = {
#define	SCCLR	0
    "clear", 0,
#define	SCNCLR	1
    "noclear", 0,
#define	SCFORM	2
    "form formatfile", 0,
#define	SCFMT	3
    "format string", 5,
#define	SCHEAD	4
    "header", 0,
#define SCNHEAD	5
    "noheader", 0,
#define	SCWID	6
    "width columns", 0,
#define	SCHELP	7
    "help", 4,

    NULL, NULL
};

/*  */

scancmd (args)
char  **args;
{
#define	equiv(a,b)	(a ? b && !strcmp (a, b) : !b)

    int     clearsw = 0,
            headersw = 0,
	    width = 0,
            msgp = 0,
            msgnum,
	    optim,
	    state;
    char   *cp,
	   *form = NULL,
	   *format = NULL,
            buf[BUFSIZ],
	   *nfs,
           *msgs[MAXARGS];
    register FILE *zp;
    static int s_optim = 0;
    static char *s_form = NULL,
		*s_format = NULL;

    while (cp = *args++) {
	if (*cp == '-')
	    switch (smatch (++cp, scanswit)) {
		case AMBIGSW: 
		    ambigsw (cp, scanswit);
		    return;
		case UNKWNSW: 
		    fprintf (stderr, "-%s unknown\n", cp);
		    return;
		case SCHELP: 
		    (void) sprintf (buf, "%s [msgs] [switches]", cmd_name);
		    help (buf, scanswit);
		    return;

		case SCCLR: 
		    clearsw++;
		    continue;
		case SCNCLR: 
		    clearsw = 0;
		    continue;
		case SCHEAD: 
		    headersw++;
		    continue;
		case SCNHEAD: 
		    headersw = 0;
		    continue;
		case SCFORM: 
		    if (!(form = *args++) || *form == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    format = NULL;
		    continue;
		case SCFMT: 
		    if (!(format = *args++) || *format == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    form = NULL;
		    continue;
		case SCWID: 
		    if (!(cp = *args++) || *cp == '-') {
			advise (NULLCP, "missing argument to %s", args[-2]);
			return;
		    }
		    width = atoi (cp);
		    continue;
	    }
	if (*cp == '+' || *cp == '@') {
	    advise (NULLCP, "sorry, no folders allowed!");
	    return;
	}
	else
	    msgs[msgp++] = cp;
    }

    if (!msgp)
	msgs[msgp++] = "all";
    for (msgnum = 0; msgnum < msgp; msgnum++)
	if (!m_convert (mp, msgs[msgnum]))
	    return;
    m_setseq (mp);

    nfs = new_fs (form, format, FORMAT);
    if (scanl) {		/* force scansbr to (re)compile format */
	(void) free (scanl);
	scanl = NULL;
    }

    if (s_optim == 0) {
	s_optim = optim = 1;
	s_form = form ? getcpy (form) : NULL;
	s_format = format ? getcpy (format) : NULL;
    }
    else
	optim = equiv (s_form, form) && equiv (s_format, format);

    interrupted = 0;
    for (msgnum = mp -> lowsel;
	    msgnum <= mp -> hghsel && !interrupted;
	    msgnum++)
	if (mp -> msgstats[msgnum] & SELECTED) {
	    if (optim && Msgs[msgnum].m_scanl)
		printf ("%s", Msgs[msgnum].m_scanl);
	    else {
		zp = msh_ready (msgnum, 0);
		switch (state = scan (zp, msgnum, 0, nfs, width,
			msgnum == mp -> curmsg, headersw,
			fmsh ? 0L : (long) (Msgs[msgnum].m_stop - Msgs[msgnum].m_start),
			1)) {
		    case SCNMSG:
		    case SCNENC:
		    case SCNERR:
			if (optim)
			    Msgs[msgnum].m_scanl = getcpy (scanl);
			break;

		    default:
			advise (NULLCP, "scan() botch (%d)", state);
			return;

		    case SCNEOF:
			printf ("%*d  empty\n", DMAXFOLDER, msgnum);
			break;
		    }