Convert inc and scan from m_getfld() to m_getfld2()

The main conversion was done in uip/scansbr.c.

Mbox handling is now completely outside of m_getfld2(), which does not
even know about From_ lines.

No more need to call thisisanmbox() (formerly m_unknown(), ``the magic
invocation'') before calling scan().

The newly introduced gotos should be eliminated ...

diff --git a/uip/inc.c b/uip/inc.c
index f08fb4f..5f08df4 100644 (file)
--- a/uip/inc.c
+++ b/uip/inc.c
@@ -358,10 +358,25 @@ main(int argc, char **argv)
                fflush(stdout);
        }
 
                fflush(stdout);
        }
 

+       /* check if readable and nonempty */
+       if (!fgets(buf, sizeof(buf), in)) {
+               if (ferror(in)) {
+                       advise("read", "unable to");
+                       incerr = SCNFAT;
+               } else {
+                       incerr = SCNEOF;
+               }
+               goto giveup;
+       }
+       if (strncmp("From ", buf, 5)!=0) {
+               advise(NULL, "not in mbox format");
+               incerr = SCNFAT;
+               goto giveup;
+       }
+

        /*
        ** Get the mail from file (usually mail spool)
        */
        /*
        ** Get the mail from file (usually mail spool)
        */

-       thisisanmbox(in);

        hghnum = msgnum = mp->hghmsg;
        for (;;) {
                /*
        hghnum = msgnum = mp->hghmsg;
        for (;;) {
                /*

@@ -429,6 +444,7 @@ main(int argc, char **argv)
                */
                break;
        }
                */
                break;
        }

+giveup:;

        free(maildir_copy);
 
        if (incerr < 0) {  /* error */
        free(maildir_copy);
 
        if (incerr < 0) {  /* error */

diff --git a/uip/scan.c b/uip/scan.c
index d6a4372..3a83420 100644 (file)
--- a/uip/scan.c
+++ b/uip/scan.c
@@ -126,7 +126,6 @@ main(int argc, char **argv)
                        adios(EX_IOERR, file, "unable to open");
                }
 
                        adios(EX_IOERR, file, "unable to open");
                }
 

-               thisisanmbox(in);

                for (msgnum = 1; ; ++msgnum) {
                        state = scan(in, msgnum, SCN_MBOX, fmtstr, width, 0, 0);
                        if (state != SCNMSG)
                for (msgnum = 1; ; ++msgnum) {
                        state = scan(in, msgnum, SCN_MBOX, fmtstr, width, 0, 0);
                        if (state != SCNMSG)

diff --git a/uip/scansbr.c b/uip/scansbr.c
index d985a5c..50b250e 100644 (file)
--- a/uip/scansbr.c
+++ b/uip/scansbr.c
@@ -16,26 +16,12 @@
 #include <sys/stat.h>
 #include <sysexits.h>
 
 #include <sys/stat.h>
 #include <sysexits.h>
 

-#ifdef _FSTDIO
-# define _ptr _p  /* Gag */
-# define _cnt _w  /* Wretch */
-#endif
-

 #define MAXSCANL 256  /* longest possible scan line */
 
 #define MAXSCANL 256  /* longest possible scan line */
 

-/*
-** Buffer size for content part of header fields.  We want this
-** to be large enough so that we don't do a lot of extra FLDPLUS
-** calls on m_getfld.
-*/
-#define SBUFSIZ 512
-

 static struct format *fmt;
 
 static struct comp *datecomp;  /* pntr to "date" comp */
 static int ncomps = 0;  /* # of interesting components */
 static struct format *fmt;
 
 static struct comp *datecomp;  /* pntr to "date" comp */
 static int ncomps = 0;  /* # of interesting components */

-static char **compbuffers = NULL;  /* buffers for component text */
-static struct comp **used_buf = NULL;  /* stack for comp that use buffers */

 
 static int dat[5];  /* aux. data for format routine */
 
 
 static int dat[5];  /* aux. data for format routine */
 

@@ -62,18 +48,18 @@ scan(FILE *inb, int innum, int outnum, char *fmtstr, int width, int curflg,
        int unseen)
 {
        static int slwidth;
        int unseen)
 {
        static int slwidth;

-       int i, compnum, state;
-       unsigned char *cp, *tmpbuf;
-       char **nxtbuf;
+       int compnum, i;
+       enum state state;
+       struct field f = {{0}};
+       char *cp;

        struct comp *cptr;
        struct comp *cptr;

-       struct comp **savecomp;

        char *scnmsg = NULL;
        FILE *scnout = NULL;
        char *scnmsg = NULL;
        FILE *scnout = NULL;

-       char name[NAMESZ];

        int incing = (outnum != SCN_MBOX && outnum != SCN_FOLD);
        int scanfolder = (outnum == SCN_FOLD);
        long fpos;
        struct stat st;
        int incing = (outnum != SCN_MBOX && outnum != SCN_FOLD);
        int scanfolder = (outnum == SCN_FOLD);
        long fpos;
        struct stat st;

+       int blankline;

 
        /* first-time only initialization */
        if (!scanl) {
 
        /* first-time only initialization */
        if (!scanl) {

@@ -97,43 +83,20 @@ scan(FILE *inb, int innum, int outnum, char *fmtstr, int width, int curflg,
                        ncomps = 1;
                        datecomp = NULL;
                }
                        ncomps = 1;
                        datecomp = NULL;
                }

+       }

 
 

-               nxtbuf = compbuffers = (char **) mh_xcalloc((size_t) ncomps,
-                               sizeof(char *));
-               used_buf = (struct comp **) mh_xcalloc((size_t) (ncomps+1),
-                               sizeof(struct comp *));
-               /* NULL-terminate array */
-               used_buf += ncomps;
-               *used_buf = NULL;
-               /* allocate space for the items */
-               for (i = ncomps; i--; )
-                       *nxtbuf++ = mh_xmalloc(SBUFSIZ);
+       if (feof(inb)) {
+               return SCNEOF;

        }
 
        /*
        ** each-message initialization
        */
        }
 
        /*
        ** each-message initialization
        */

-       nxtbuf = compbuffers;
-       savecomp = used_buf;
-       tmpbuf = *nxtbuf++;

        dat[0] = innum ? innum : outnum;
        dat[1] = curflg;
        dat[4] = unseen;
        fpos = ftell(inb);
 
        dat[0] = innum ? innum : outnum;
        dat[1] = curflg;
        dat[4] = unseen;
        fpos = ftell(inb);
 

-       /*
-       ** Get the first field.  If the message is non-empty
-       ** and we're doing an "inc", open the output file.
-       */
-       if ((state = m_getfld(FLD, name, tmpbuf, SBUFSIZ, inb)) == FILEEOF) {
-               if (ferror(inb)) {
-                       advise("read", "unable to"); /* "read error" */
-                       return SCNFAT;
-               } else {
-                       return SCNEOF;
-               }
-       }
-

        if (incing) {
                scnmsg = m_name(outnum);
                if (*scnmsg == '?')  /* msg num out of range */
        if (incing) {
                scnmsg = m_name(outnum);
                if (*scnmsg == '?')  /* msg num out of range */

@@ -141,92 +104,123 @@ scan(FILE *inb, int innum, int outnum, char *fmtstr, int width, int curflg,
                if (!(scnout = fopen(scnmsg, "w")))
                        adios(EX_IOERR, scnmsg, "unable to write");
        }
                if (!(scnout = fopen(scnmsg, "w")))
                        adios(EX_IOERR, scnmsg, "unable to write");
        }

-

        /* scan - main loop */
        /* scan - main loop */

-       for (compnum = 1; ;
-                       state = m_getfld(state, name, tmpbuf, SBUFSIZ, inb)) {
+       for (compnum = 1, state = FLD2; ; ) {
+               state = m_getfld2(state, &f, inb);

                switch (state) {
                switch (state) {

-               case FLD:
-               case FLDPLUS:
+               case FLD2:

                        compnum++;
                        if (incing) {
                        compnum++;
                        if (incing) {

-                               FPUTS(name);
+                               FPUTS(f.name);

                                FPUTS(":");
                                FPUTS(":");

-                               FPUTS(tmpbuf);
+                               FPUTS(f.value);

                        }
                        }

-                       /*
-                       ** if we're interested in this component, save
-                       ** a pointer to the component text, then start
-                       ** using our next free buffer as the component
-                       ** temp buffer (buffer switching saves an extra
-                       ** copy of the component text).
-                       */
-                       if (fmtstr && (cptr = wantcomp[CHASH(name)])) {
+                       if (fmtstr && (cptr = wantcomp[CHASH(f.name)])) {
+                               /*
+                               ** we're interested in this component,
+                               ** but find the right one in the hash
+                               ** collision chain ...
+                               */

                                do {
                                do {

-                                       if (mh_strcasecmp(name, cptr->c_name)!=0) {
+                                       if (mh_strcasecmp(f.name, cptr->c_name)!=0) {

                                                continue;
                                        }
                                                continue;
                                        }

-                                       if (!cptr->c_text) {
-                                               cptr->c_text = tmpbuf;
-                                               cp = tmpbuf+strlen(tmpbuf)-1;
-                                               for (; cp >= tmpbuf; cp--) {
-                                                       if (isspace(*cp))
-                                                               *cp = '\0';
-                                                       else
-                                                               break;
+                                       if (cptr->c_text) {
+                                               free(cptr->c_text);
+                                               cptr->c_text = NULL;
+                                       }
+                                       cptr->c_text = getcpy(f.value);
+                                       cp = cptr->c_text + strlen(cptr->c_text) - 1;
+                                       for (; cp >= cptr->c_text; cp--) {
+                                               if (isspace(*cp)) {
+                                                       *cp = '\0';
+                                               } else {
+                                                       break;

                                                }
                                                }

-                                               *--savecomp = cptr;
-                                               tmpbuf = *nxtbuf++;

                                        }
                                        break;
                                } while ((cptr = cptr->c_next));
                        }
                                        }
                                        break;
                                } while ((cptr = cptr->c_next));
                        }

-
-                       while (state == FLDPLUS) {
-                               state = m_getfld(state, name, tmpbuf, SBUFSIZ,
-                                               inb);
-                               if (incing)
-                                       FPUTS(tmpbuf);
-                       }

                        break;
 
                        break;
 

-               case BODY:
+               case BODY2:

                        compnum = -1;
                        if (scanfolder) {
                                /* stop here if we scan a msg in a folder */
                        compnum = -1;
                        if (scanfolder) {
                                /* stop here if we scan a msg in a folder */

-                               state = FILEEOF;
+                               state = FILEEOF2;

                                goto finished;
                        }
                        /* otherwise (mbox): snarf the body */
                                goto finished;
                        }
                        /* otherwise (mbox): snarf the body */

+                       if (strncmp("From ", f.value, 5)==0) {
+                               state = FILEEOF2;
+                               goto finished;
+                       }

                        if (incing) {
                                FPUTS("\n");
                        if (incing) {
                                FPUTS("\n");

-                               FPUTS(tmpbuf);
+                               FPUTS(f.value);

                        }
 body:;
                        }
 body:;

-                       while (state == BODY) {
-                               state = m_getfld(state, name, tmpbuf, SBUFSIZ,
-                                               inb);
+                       blankline = 0;
+                       while ((state = m_getfld2(state, &f, inb)) == BODY2) {
+                               /*
+                               ** recognize From lines without blank lines
+                               ** before them as well.
+                               */
+                               if (strncmp("From ", f.value, 5)==0) {
+                                       state = FILEEOF2;
+                                       goto finished;
+                               }
+                               /*
+                               ** delay the printing of blank lines
+                               ** because if it's the end of the message,
+                               ** then we must omit the blank line,
+                               ** as it is not part of the message but
+                               ** part of the mbox format
+                               */
+                               if (blankline) {
+                                       /* print the delayed blank line */
+                                       FPUTS("\n");
+                                       blankline = 0;
+                               }
+                               if (strcmp(f.value, "\n")==0) {
+                                       blankline = 1;
+                                       continue;
+                               }

                                if (incing) {
                                if (incing) {

-                                       FPUTS(tmpbuf);
+                                       FPUTS(f.value);

                                }
                        }
                        goto finished;
 
                                }
                        }
                        goto finished;
 

-               case LENERR:
-               case FMTERR:
-                       fprintf(stderr, innum ? "??Format error (message %d) in " : "??Format error in ", outnum ? outnum : innum);
+               case LENERR2:
+                       advise(NULL, "line \"%s\" too long", trim(f.value));
+                       goto handleerror;
+
+               case FMTERR2:
+                       if (strncmp("From ", f.value, 5)==0) {
+                               state = FILEEOF2;
+                               goto finished;
+                       }
+                       /* FALL */
+
+               case IOERR2:
+handleerror:;
+                       fprintf(stderr, innum ?
+                                       "??Format error (message %d) in " :
+                                       "??Format error in ",
+                                       outnum ? outnum : innum);

                        fprintf(stderr, "component %d\n", compnum);
 
                        if (incing) {
                                FPUTS("\n\nBAD MSG:\n");
                        fprintf(stderr, "component %d\n", compnum);
 
                        if (incing) {
                                FPUTS("\n\nBAD MSG:\n");

-                               FPUTS(name);
+                               FPUTS(f.name);  /* XXX use f.field? */

                                FPUTS("\n");
                                FPUTS("\n");

-                               state = BODY;
+                               state = BODY2;

                                goto body;
                        }
                        /* fall through if we scan only */
 
                                goto body;
                        }
                        /* fall through if we scan only */
 

-               case FILEEOF:
+               case FILEEOF2:

                        goto finished;
 
                default:
                        goto finished;
 
                default:

@@ -235,7 +229,6 @@ body:;
        }
 
 finished:
        }
 
 finished:

-

        /* Format and output the scan line. */
        if (ferror(inb)) {
                advise("read", "unable to");
        /* Format and output the scan line. */
        if (ferror(inb)) {
                advise("read", "unable to");

@@ -274,15 +267,18 @@ finished:
                fputs(scanl, stdout);
        }
 
                fputs(scanl, stdout);
        }
 

-       /* return dynamically allocated buffers to pool */
-       while ((cptr = *savecomp++)) {
-               *--nxtbuf = cptr->c_text;
-               cptr->c_text = NULL;
+       /* clean up old values */
+        for (i=0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++) {
+               for (cptr=wantcomp[i]; cptr; cptr=cptr->c_next) {
+                       if (cptr->c_text) {
+                               free(cptr->c_text);
+                               cptr->c_text = NULL;
+                       }
+               }

        }
        }

-       *--nxtbuf = tmpbuf;

 
        if (incing && (ferror(scnout) || fclose(scnout) == EOF))
                adios(EX_IOERR, scnmsg, "write error on");
 
 
        if (incing && (ferror(scnout) || fclose(scnout) == EOF))
                adios(EX_IOERR, scnmsg, "write error on");
 

-       return (state != FILEEOF ? SCNERR : SCNMSG);
+       return (state == FILEEOF2 ? SCNMSG : SCNERR);

 }
 }