Relayouted all switch statements: case aligns with switch.
[mmh] / sbr / mf.c
index d93ad26..45bbecd 100644 (file)
--- a/sbr/mf.c
+++ b/sbr/mf.c
@@ -206,39 +206,39 @@ getadrx(char *addrs)
        }
 
        switch (parse_address()) {
-               case DONE:
-                       free(dp);
-                       dp = cp = NULL;
-                       return NULL;
-
-               case OK:
-                       switch (last_lex) {
-                               case LX_COMA:
-                               case LX_END:
-                                       break;
+       case DONE:
+               free(dp);
+               dp = cp = NULL;
+               return NULL;
 
-                               default:  /* catch trailing comments */
-                                       bp = cp;
-                                       my_lex(adr);
-                                       cp = bp;
-                                       break;
-                       }
+       case OK:
+               switch (last_lex) {
+               case LX_COMA:
+               case LX_END:
                        break;
 
-               default:
+               default:  /* catch trailing comments */
+                       bp = cp;
+                       my_lex(adr);
+                       cp = bp;
                        break;
                }
+               break;
+
+       default:
+               break;
+       }
 
        if (err[0])
                for (;;) {
                        switch (last_lex) {
-                               case LX_COMA:
-                               case LX_END:
-                                       break;
+                       case LX_COMA:
+                       case LX_END:
+                               break;
 
-                               default:
-                                       my_lex(adr);
-                                       continue;
+                       default:
+                               my_lex(adr);
+                               continue;
                        }
                        break;
                }
@@ -274,144 +274,144 @@ parse_address(void)
 again: ;
        ap = cp;
        switch (my_lex(buffer)) {
-               case LX_ATOM:
-               case LX_QSTR:
-                       pers = getcpy(buffer);
-                       break;
+       case LX_ATOM:
+       case LX_QSTR:
+               pers = getcpy(buffer);
+               break;
+
+       case LX_SEMI:
+               if (glevel-- <= 0) {
+                       strcpy(err, "extraneous semi-colon");
+                       return NOTOK;
+               }
+       case LX_COMA:
+               if (note) {
+                       free(note);
+                       note = NULL;
+               }
+               goto again;
 
-               case LX_SEMI:
-                       if (glevel-- <= 0) {
-                               strcpy(err, "extraneous semi-colon");
-                               return NOTOK;
-                       }
-               case LX_COMA:
-                       if (note) {
-                               free(note);
-                               note = NULL;
-                       }
-                       goto again;
+       case LX_END:
+               return DONE;
 
-               case LX_END:
-                       return DONE;
+       case LX_LBRK:  /* sigh (2) */
+               goto get_addr;
 
-               case LX_LBRK:  /* sigh (2) */
-                       goto get_addr;
+       case LX_AT:  /* sigh (3) */
+               cp = ap;
+               if (route_addr(buffer) == NOTOK)
+                       return NOTOK;
+               return OK;  /* why be choosy? */
 
-               case LX_AT:  /* sigh (3) */
-                       cp = ap;
+       default:
+               sprintf(err, "illegal address construct (%s)", buffer);
+               return NOTOK;
+       }
+
+       switch (my_lex(buffer)) {
+       case LX_ATOM:
+       case LX_QSTR:
+               pers = add(buffer, add(" ", pers));
+more_phrase: ;  /* sigh (1) */
+               if (phrase(buffer) == NOTOK)
+                       return NOTOK;
+
+               switch (last_lex) {
+               case LX_LBRK:
+get_addr: ;
                        if (route_addr(buffer) == NOTOK)
                                return NOTOK;
-                       return OK;  /* why be choosy? */
-
-               default:
-                       sprintf(err, "illegal address construct (%s)", buffer);
+                       if (last_lex == LX_RBRK)
+                               return OK;
+                       sprintf(err, "missing right-bracket (%s)", buffer);
                        return NOTOK;
-       }
 
-       switch (my_lex(buffer)) {
-               case LX_ATOM:
-               case LX_QSTR:
-                       pers = add(buffer, add(" ", pers));
-       more_phrase: ;  /* sigh (1) */
-                       if (phrase(buffer) == NOTOK)
+               case LX_COLN:
+get_group: ;
+                       if (glevel++ > 0) {
+                               sprintf(err, "nested groups not allowed (%s)", pers);
                                return NOTOK;
+                       }
+                       grp = add(": ", pers);
+                       pers = NULL;
+                       {
+                               char   *pp = cp;
 
-                       switch (last_lex) {
-                               case LX_LBRK:
-                       get_addr: ;
-                                       if (route_addr(buffer) == NOTOK)
-                                               return NOTOK;
-                                       if (last_lex == LX_RBRK)
+                               for (;;)
+                                       switch (my_lex(buffer)) {
+                                       case LX_SEMI:
+                                       case LX_END: /* tsk, tsk */
+                                               glevel--;
                                                return OK;
-                                       sprintf(err, "missing right-bracket (%s)", buffer);
-                                       return NOTOK;
-
-                               case LX_COLN:
-                       get_group: ;
-                                       if (glevel++ > 0) {
-                                               sprintf(err, "nested groups not allowed (%s)", pers);
-                                               return NOTOK;
-                                       }
-                                       grp = add(": ", pers);
-                                       pers = NULL;
-                                       {
-                                               char   *pp = cp;
-
-                                               for (;;)
-                                                       switch (my_lex(buffer)) {
-                                                               case LX_SEMI:
-                                                               case LX_END: /* tsk, tsk */
-                                                                       glevel--;
-                                                                       return OK;
-
-                                                               case LX_COMA:
-                                                                       continue;
-
-                                                               default:
-                                                                       cp = pp;
-                                                                       return parse_address();
-                                                       }
-                                       }
 
-                               case LX_DOT:  /* sigh (1) */
-                                       pers = add(".", pers);
-                                       goto more_phrase;
+                                       case LX_COMA:
+                                               continue;
 
-                               default:
-                                       sprintf(err, "no mailbox in address, only a phrase (%s%s)", pers, buffer);
-                                       return NOTOK;
+                                       default:
+                                               cp = pp;
+                                               return parse_address();
+                                       }
                        }
 
-               case LX_LBRK:
-                       goto get_addr;
+               case LX_DOT:  /* sigh (1) */
+                       pers = add(".", pers);
+                       goto more_phrase;
 
-               case LX_COLN:
-                       goto get_group;
+               default:
+                       sprintf(err, "no mailbox in address, only a phrase (%s%s)", pers, buffer);
+                       return NOTOK;
+               }
 
-               case LX_DOT:
-                       mbox = add(buffer, pers);
-                       pers = NULL;
-                       if (route_addr(buffer) == NOTOK)
-                               return NOTOK;
-                       goto check_end;
+       case LX_LBRK:
+               goto get_addr;
 
-               case LX_AT:
-                       ingrp = glevel;
-                       mbox = pers;
-                       pers = NULL;
-                       if (domain(buffer) == NOTOK)
-                               return NOTOK;
-       check_end: ;
-                       switch (last_lex) {
-                               case LX_SEMI:
-                                       if (glevel-- <= 0) {
-                                               strcpy(err, "extraneous semi-colon");
-                                               return NOTOK;
-                                       }
-                               case LX_COMA:
-                               case LX_END:
-                                       return OK;
+       case LX_COLN:
+               goto get_group;
 
-                               default:
-                                       sprintf(err, "junk after local@domain (%s)", buffer);
-                                       return NOTOK;
-                       }
+       case LX_DOT:
+               mbox = add(buffer, pers);
+               pers = NULL;
+               if (route_addr(buffer) == NOTOK)
+                       return NOTOK;
+               goto check_end;
 
-               case LX_SEMI:  /* no host */
-               case LX_COMA:
-               case LX_END:
-                       ingrp = glevel;
-                       if (last_lex == LX_SEMI && glevel-- <= 0) {
+       case LX_AT:
+               ingrp = glevel;
+               mbox = pers;
+               pers = NULL;
+               if (domain(buffer) == NOTOK)
+                       return NOTOK;
+check_end: ;
+               switch (last_lex) {
+               case LX_SEMI:
+                       if (glevel-- <= 0) {
                                strcpy(err, "extraneous semi-colon");
                                return NOTOK;
                        }
-                       mbox = pers;
-                       pers = NULL;
+               case LX_COMA:
+               case LX_END:
                        return OK;
 
                default:
-                       sprintf(err, "missing mailbox (%s)", buffer);
+                       sprintf(err, "junk after local@domain (%s)", buffer);
+                       return NOTOK;
+               }
+
+       case LX_SEMI:  /* no host */
+       case LX_COMA:
+       case LX_END:
+               ingrp = glevel;
+               if (last_lex == LX_SEMI && glevel-- <= 0) {
+                       strcpy(err, "extraneous semi-colon");
                        return NOTOK;
+               }
+               mbox = pers;
+               pers = NULL;
+               return OK;
+
+       default:
+               sprintf(err, "missing mailbox (%s)", buffer);
+               return NOTOK;
        }
 }
 
@@ -421,13 +421,13 @@ phrase(char *buffer)
 {
        for (;;)
                switch (my_lex(buffer)) {
-                       case LX_ATOM:
-                       case LX_QSTR:
-                               pers = add(buffer, add(" ", pers));
-                               continue;
+               case LX_ATOM:
+               case LX_QSTR:
+                       pers = add(buffer, add(" ", pers));
+                       continue;
 
-                       default:
-                               return OK;
+               default:
+                       return OK;
                }
 }
 
@@ -448,18 +448,18 @@ route_addr(char *buffer)
                return NOTOK;
 
        switch (last_lex) {
-               case LX_AT:
-                       return domain(buffer);
+       case LX_AT:
+               return domain(buffer);
 
-               case LX_SEMI:  /* if in group */
-               case LX_RBRK:  /* no host */
-               case LX_COMA:
-               case LX_END:
-                       return OK;
+       case LX_SEMI:  /* if in group */
+       case LX_RBRK:  /* no host */
+       case LX_COMA:
+       case LX_END:
+               return OK;
 
-               default:
-                       sprintf(err, "no at-sign after local-part (%s)", buffer);
-                       return NOTOK;
+       default:
+               sprintf(err, "no at-sign after local-part (%s)", buffer);
+               return NOTOK;
        }
 }
 
@@ -471,24 +471,23 @@ local_part(char *buffer)
 
        for (;;) {
                switch (my_lex(buffer)) {
-                       case LX_ATOM:
-                       case LX_QSTR:
-                               mbox = add(buffer, mbox);
-                               break;
+               case LX_ATOM:
+               case LX_QSTR:
+                       mbox = add(buffer, mbox);
+                       break;
 
-                       default:
-                               sprintf(err, "no mailbox in local-part (%s)",
-                                               buffer);
-                               return NOTOK;
+               default:
+                       sprintf(err, "no mailbox in local-part (%s)", buffer);
+                       return NOTOK;
                }
 
                switch (my_lex(buffer)) {
-                       case LX_DOT:
-                               mbox = add(buffer, mbox);
-                               continue;
+               case LX_DOT:
+                       mbox = add(buffer, mbox);
+                       continue;
 
-                       default:
-                               return OK;
+               default:
+                       return OK;
                }
        }
 }
@@ -499,29 +498,29 @@ domain(char *buffer)
 {
        for (;;) {
                switch (my_lex(buffer)) {
-                       case LX_ATOM:
-                       case LX_DLIT:
-                               host = add(buffer, host);
-                               break;
+               case LX_ATOM:
+               case LX_DLIT:
+                       host = add(buffer, host);
+                       break;
 
-                       default:
-                               sprintf(err, "no sub-domain in domain-part of address (%s)", buffer);
-                               return NOTOK;
+               default:
+                       sprintf(err, "no sub-domain in domain-part of address (%s)", buffer);
+                       return NOTOK;
                }
 
                switch (my_lex(buffer)) {
-                       case LX_DOT:
-                               host = add(buffer, host);
-                               continue;
+               case LX_DOT:
+                       host = add(buffer, host);
+                       continue;
 
-                       case LX_AT:  /* sigh (0) */
-                               mbox = add(host, add("%", mbox));
-                               free(host);
-                               host = NULL;
-                               continue;
+               case LX_AT:  /* sigh (0) */
+                       mbox = add(host, add("%", mbox));
+                       free(host);
+                       host = NULL;
+                       continue;
 
-                       default:
-                               return OK;
+               default:
+                       return OK;
                }
        }
 }
@@ -534,47 +533,47 @@ route(char *buffer)
 
        for (;;) {
                switch (my_lex(buffer)) {
-                       case LX_ATOM:
-                       case LX_DLIT:
-                               path = add(buffer, path);
-                               break;
+               case LX_ATOM:
+               case LX_DLIT:
+                       path = add(buffer, path);
+                       break;
 
-                       default:
-                               sprintf(err, "no sub-domain in domain-part of address (%s)", buffer);
-                               return NOTOK;
+               default:
+                       sprintf(err, "no sub-domain in domain-part of address (%s)", buffer);
+                       return NOTOK;
                }
                switch (my_lex(buffer)) {
-                       case LX_COMA:
-                               path = add(buffer, path);
-                               for (;;) {
-                                       switch (my_lex(buffer)) {
-                                               case LX_COMA:
-                                                       continue;
-
-                                               case LX_AT:
-                                                       path = add(buffer, path);
-                                                       break;
+               case LX_COMA:
+                       path = add(buffer, path);
+                       for (;;) {
+                               switch (my_lex(buffer)) {
+                               case LX_COMA:
+                                       continue;
 
-                                               default:
-                                                       sprintf(err, "no at-sign found for next domain in route (%s)",
-                                                                        buffer);
-                                       }
+                               case LX_AT:
+                                       path = add(buffer, path);
                                        break;
+
+                               default:
+                                       sprintf(err, "no at-sign found for next domain in route (%s)",
+                                                        buffer);
                                }
-                               continue;
+                               break;
+                       }
+                       continue;
 
-                       case LX_AT:  /* XXX */
-                       case LX_DOT:
-                               path = add(buffer, path);
-                               continue;
+               case LX_AT:  /* XXX */
+               case LX_DOT:
+                       path = add(buffer, path);
+                       continue;
 
-                       case LX_COLN:
-                               path = add(buffer, path);
-                               return OK;
+               case LX_COLN:
+                       path = add(buffer, path);
+                       return OK;
 
-                       default:
-                               sprintf(err, "no colon found to terminate route (%s)", buffer);
-                               return NOTOK;
+               default:
+                       sprintf(err, "no colon found to terminate route (%s)", buffer);
+                       return NOTOK;
                }
        }
 }
@@ -617,29 +616,29 @@ my_lex(char *buffer)
                ADDCHR(c);
                for (i = 0;;)
                        switch (c = *cp++) {
-                               case 0:
+                       case 0:
+                               cp = NULL;
+                               return (last_lex = LX_ERR);
+                       case QUOTE:
+                               ADDCHR(c);
+                               if ((c = *cp++) == 0) {
                                        cp = NULL;
                                        return (last_lex = LX_ERR);
-                               case QUOTE:
-                                       ADDCHR(c);
-                                       if ((c = *cp++) == 0) {
-                                               cp = NULL;
-                                               return (last_lex = LX_ERR);
-                                       }
-                                       ADDCHR(c);
-                                       continue;
-                               case '(':
-                                       i++;
-                               default:
-                                       ADDCHR(c);
-                                       continue;
-                               case ')':
-                                       ADDCHR(c);
-                                       if (--i < 0) {
-                                               *bp = 0;
-                                               note = note ? add(buffer, add(" ", note)) : getcpy(buffer);
-                                               return my_lex(buffer);
-                                       }
+                               }
+                               ADDCHR(c);
+                               continue;
+                       case '(':
+                               i++;
+                       default:
+                               ADDCHR(c);
+                               continue;
+                       case ')':
+                               ADDCHR(c);
+                               if (--i < 0) {
+                                       *bp = 0;
+                                       note = note ? add(buffer, add(" ", note)) : getcpy(buffer);
+                                       return my_lex(buffer);
+                               }
                        }
        }
 
@@ -647,22 +646,22 @@ my_lex(char *buffer)
                ADDCHR(c);
                for (;;)
                        switch (c = *cp++) {
-                               case 0:
+                       case 0:
+                               cp = NULL;
+                               return (last_lex = LX_ERR);
+                       case QUOTE:
+                               ADDCHR(c);
+                               if ((c = *cp++) == 0) {
                                        cp = NULL;
                                        return (last_lex = LX_ERR);
-                               case QUOTE:
-                                       ADDCHR(c);
-                                       if ((c = *cp++) == 0) {
-                                               cp = NULL;
-                                               return (last_lex = LX_ERR);
-                                       }
-                               default:
-                                       ADDCHR(c);
-                                       continue;
-                               case '"':
-                                       ADDCHR(c);
-                                       *bp = 0;
-                                       return (last_lex = LX_QSTR);
+                               }
+                       default:
+                               ADDCHR(c);
+                               continue;
+                       case '"':
+                               ADDCHR(c);
+                               *bp = 0;
+                               return (last_lex = LX_QSTR);
                        }
        }
 
@@ -670,22 +669,22 @@ my_lex(char *buffer)
                ADDCHR(c);
                for (;;)
                        switch (c = *cp++) {
-                               case 0:
+                       case 0:
+                               cp = NULL;
+                               return (last_lex = LX_ERR);
+                       case QUOTE:
+                               ADDCHR(c);
+                               if ((c = *cp++) == 0) {
                                        cp = NULL;
                                        return (last_lex = LX_ERR);
-                               case QUOTE:
-                                       ADDCHR(c);
-                                       if ((c = *cp++) == 0) {
-                                               cp = NULL;
-                                               return (last_lex = LX_ERR);
-                                       }
-                               default:
-                                       ADDCHR(c);
-                                       continue;
-                               case ']':
-                                       ADDCHR(c);
-                                       *bp = 0;
-                                       return (last_lex = LX_DLIT);
+                               }
+                       default:
+                               ADDCHR(c);
+                               continue;
+                       case ']':
+                               ADDCHR(c);
+                               *bp = 0;
+                               return (last_lex = LX_DLIT);
                        }
        }