Convert inc and scan from m_getfld() to m_getfld2()
authormarkus schnalke <meillo@marmaro.de>
Thu, 12 Nov 2015 16:52:22 +0000 (17:52 +0100)
committermarkus schnalke <meillo@marmaro.de>
Thu, 12 Nov 2015 21:42:29 +0000 (22:42 +0100)
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 ...

uip/inc.c
uip/scan.c
uip/scansbr.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);
        }
 
+       /* 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)
        */
-       thisisanmbox(in);
        hghnum = msgnum = mp->hghmsg;
        for (;;) {
                /*
@@ -429,6 +444,7 @@ main(int argc, char **argv)
                */
                break;
        }
+giveup:;
        free(maildir_copy);
 
        if (incerr < 0) {  /* error */
index d6a4372..3a83420 100644 (file)
@@ -126,7 +126,6 @@ main(int argc, char **argv)
                        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)
index d985a5c..50b250e 100644 (file)
 #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 */
 
-/*
-** 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 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 */
 
@@ -62,18 +48,18 @@ scan(FILE *inb, int innum, int outnum, char *fmtstr, int width, int curflg,
        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 **savecomp;
        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 blankline;
 
        /* 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;
                }
+       }
 
-               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
        */
-       nxtbuf = compbuffers;
-       savecomp = used_buf;
-       tmpbuf = *nxtbuf++;
        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 */
@@ -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");
        }
-
        /* 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) {
-               case FLD:
-               case FLDPLUS:
+               case FLD2:
                        compnum++;
                        if (incing) {
-                               FPUTS(name);
+                               FPUTS(f.name);
                                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 {
-                                       if (mh_strcasecmp(name, cptr->c_name)!=0) {
+                                       if (mh_strcasecmp(f.name, cptr->c_name)!=0) {
                                                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));
                        }
-
-                       while (state == FLDPLUS) {
-                               state = m_getfld(state, name, tmpbuf, SBUFSIZ,
-                                               inb);
-                               if (incing)
-                                       FPUTS(tmpbuf);
-                       }
                        break;
 
-               case BODY:
+               case BODY2:
                        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 */
+                       if (strncmp("From ", f.value, 5)==0) {
+                               state = FILEEOF2;
+                               goto finished;
+                       }
                        if (incing) {
                                FPUTS("\n");
-                               FPUTS(tmpbuf);
+                               FPUTS(f.value);
                        }
 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) {
-                                       FPUTS(tmpbuf);
+                                       FPUTS(f.value);
                                }
                        }
                        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");
-                               FPUTS(name);
+                               FPUTS(f.name);  /* XXX use f.field? */
                                FPUTS("\n");
-                               state = BODY;
+                               state = BODY2;
                                goto body;
                        }
                        /* fall through if we scan only */
 
-               case FILEEOF:
+               case FILEEOF2:
                        goto finished;
 
                default:
@@ -235,7 +229,6 @@ body:;
        }
 
 finished:
-
        /* Format and output the scan line. */
        if (ferror(inb)) {
                advise("read", "unable to");
@@ -274,15 +267,18 @@ finished:
                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");
 
-       return (state != FILEEOF ? SCNERR : SCNMSG);
+       return (state == FILEEOF2 ? SCNMSG : SCNERR);
 }