sort switch cases

There are no code changes here.
The 'case' statements have been sorted where:
- There's a clear order, e.g. alphabetical
- Where they all have break/return statements

diff --git a/browser.c b/browser.c
index 9f26995494568d87fa954af33898014c6a4e8864..e02a0ccd3fa3711c6b7984ed2e4f94eac1a9b084 100644 (file)
--- a/browser.c
+++ b/browser.c
@@ -211,14 +211,14 @@ static int browser_compare(const void *a, const void *b)
 
   switch (SortBrowser & SORT_MASK)
   {
+    case SORT_COUNT:
+      return browser_compare_count(a, b);
     case SORT_DATE:
       return browser_compare_date(a, b);
-    case SORT_SIZE:
-      return browser_compare_size(a, b);
     case SORT_DESC:
       return browser_compare_desc(a, b);
-    case SORT_COUNT:
-      return browser_compare_count(a, b);
+    case SORT_SIZE:
+      return browser_compare_size(a, b);
     case SORT_UNREAD:
       return browser_compare_count_new(a, b);
     case SORT_SUBJECT:
@@ -606,20 +606,17 @@ static const char *group_index_format_str(char *buf, size_t buflen, size_t col,
         snprintf(buf, buflen, fmt, folder->ff->new ? 'N' : 'u');
       break;
 
-    case 's':
-      if (flags & MUTT_FORMAT_OPTIONAL)
+    case 'n':
+      if (Context && Context->data == folder->ff->nd)
       {
-        if (folder->ff->nd->unread != 0)
-          mutt_expando_format(buf, buflen, col, cols, if_str,
-                              group_index_format_str, data, flags);
-        else
-          mutt_expando_format(buf, buflen, col, cols, else_str,
-                              group_index_format_str, data, flags);
+        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+        snprintf(buf, buflen, fmt, Context->new);
       }
-      else if (Context && Context->data == folder->ff->nd)
+      else if (MarkOld && folder->ff->nd->last_cached >= folder->ff->nd->first_message &&
+               folder->ff->nd->last_cached <= folder->ff->nd->last_message)
       {
         snprintf(fmt, sizeof(fmt), "%%%sd", prec);
-        snprintf(buf, buflen, fmt, Context->unread);
+        snprintf(buf, buflen, fmt, folder->ff->nd->last_message - folder->ff->nd->last_cached);
       }
       else
       {
@@ -628,17 +625,20 @@ static const char *group_index_format_str(char *buf, size_t buflen, size_t col,
       }
       break;
 
-    case 'n':
-      if (Context && Context->data == folder->ff->nd)
+    case 's':
+      if (flags & MUTT_FORMAT_OPTIONAL)
       {
-        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
-        snprintf(buf, buflen, fmt, Context->new);
+        if (folder->ff->nd->unread != 0)
+          mutt_expando_format(buf, buflen, col, cols, if_str,
+                              group_index_format_str, data, flags);
+        else
+          mutt_expando_format(buf, buflen, col, cols, else_str,
+                              group_index_format_str, data, flags);
       }
-      else if (MarkOld && folder->ff->nd->last_cached >= folder->ff->nd->first_message &&
-               folder->ff->nd->last_cached <= folder->ff->nd->last_message)
+      else if (Context && Context->data == folder->ff->nd)
       {
         snprintf(fmt, sizeof(fmt), "%%%sd", prec);
-        snprintf(buf, buflen, fmt, folder->ff->nd->last_message - folder->ff->nd->last_cached);
+        snprintf(buf, buflen, fmt, Context->unread);
       }
       else
       {
@@ -1298,11 +1298,11 @@ void mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfi
            */
           switch (mx_get_magic(CurrentFolder))
           {
+            case MUTT_IMAP:
+            case MUTT_MAILDIR:
             case MUTT_MBOX:
-            case MUTT_MMDF:
             case MUTT_MH:
-            case MUTT_MAILDIR:
-            case MUTT_IMAP:
+            case MUTT_MMDF:
               if (Folder)
                 mutt_str_strfcpy(LastDir, NONULL(Folder), sizeof(LastDir));
               else if (SpoolFile)

diff --git a/conn/ssl.c b/conn/ssl.c
index a74ea41adb2c2ced4d6409b02ae165c974a57f30..6ceb4f9707547c3c337e73b226a95c4a3410930a 100644 (file)
--- a/conn/ssl.c
+++ b/conn/ssl.c
@@ -261,8 +261,14 @@ static void ssl_err(struct SslSockData *data, int err)
 
   switch (e)
   {
-    case SSL_ERROR_ZERO_RETURN:
-      errmsg = "SSL connection closed";
+    case SSL_ERROR_SYSCALL:
+      errmsg = "I/O error";
+      break;
+    case SSL_ERROR_WANT_ACCEPT:
+      errmsg = "retry accept";
+      break;
+    case SSL_ERROR_WANT_CONNECT:
+      errmsg = "retry connect";
       break;
     case SSL_ERROR_WANT_READ:
       errmsg = "retry read";
@@ -270,17 +276,11 @@ static void ssl_err(struct SslSockData *data, int err)
     case SSL_ERROR_WANT_WRITE:
       errmsg = "retry write";
       break;
-    case SSL_ERROR_WANT_CONNECT:
-      errmsg = "retry connect";
-      break;
-    case SSL_ERROR_WANT_ACCEPT:
-      errmsg = "retry accept";
-      break;
     case SSL_ERROR_WANT_X509_LOOKUP:
       errmsg = "retry x509 lookup";
       break;
-    case SSL_ERROR_SYSCALL:
-      errmsg = "I/O error";
+    case SSL_ERROR_ZERO_RETURN:
+      errmsg = "SSL connection closed";
       break;
     case SSL_ERROR_SSL:
       sslerr = ERR_get_error();

diff --git a/copy.c b/copy.c
index 7df337705cfc0c321df86dc39325e5417da91be1..d1b8cb604542013f6bc81759e8c466fbbbc45223 100644 (file)
--- a/copy.c
+++ b/copy.c
@@ -957,26 +957,11 @@ static int address_header_decode(char **h)
 
   switch (tolower((unsigned char) *s))
   {
-    case 'r':
-    {
-      if (mutt_str_strncasecmp(s, "return-path:", 12) == 0)
-      {
-        l = 12;
-        rp = true;
-        break;
-      }
-      else if (mutt_str_strncasecmp(s, "reply-to:", 9) == 0)
-      {
-        l = 9;
-        break;
-      }
-      return 0;
-    }
-    case 'f':
+    case 'b':
     {
-      if (mutt_str_strncasecmp(s, "from:", 5) != 0)
+      if (mutt_str_strncasecmp(s, "bcc:", 4) != 0)
         return 0;
-      l = 5;
+      l = 4;
       break;
     }
     case 'c':
@@ -986,13 +971,35 @@ static int address_header_decode(char **h)
       l = 3;
       break;
     }
-    case 'b':
+    case 'f':
     {
-      if (mutt_str_strncasecmp(s, "bcc:", 4) != 0)
+      if (mutt_str_strncasecmp(s, "from:", 5) != 0)
         return 0;
-      l = 4;
+      l = 5;
+      break;
+    }
+    case 'm':
+    {
+      if (mutt_str_strncasecmp(s, "mail-followup-to:", 17) != 0)
+        return 0;
+      l = 17;
       break;
     }
+    case 'r':
+    {
+      if (mutt_str_strncasecmp(s, "return-path:", 12) == 0)
+      {
+        l = 12;
+        rp = true;
+        break;
+      }
+      else if (mutt_str_strncasecmp(s, "reply-to:", 9) == 0)
+      {
+        l = 9;
+        break;
+      }
+      return 0;
+    }
     case 's':
     {
       if (mutt_str_strncasecmp(s, "sender:", 7) != 0)
@@ -1007,13 +1014,6 @@ static int address_header_decode(char **h)
       l = 3;
       break;
     }
-    case 'm':
-    {
-      if (mutt_str_strncasecmp(s, "mail-followup-to:", 17) != 0)
-        return 0;
-      l = 17;
-      break;
-    }
     default:
       return 0;
   }

diff --git a/curs_main.c b/curs_main.c
index 1ebf1ef5e65c33dabe0aea29bd3d6c7ec2fffca2..58e6fa69ac6ceaca2caa2827aa48f05280c81b41 100644 (file)
--- a/curs_main.c
+++ b/curs_main.c
@@ -1188,45 +1188,45 @@ int mutt_index_menu(void)
       case OP_BOTTOM_PAGE:
         menu_bottom_page(menu);
         break;
+      case OP_CURRENT_BOTTOM:
+        menu_current_bottom(menu);
+        break;
+      case OP_CURRENT_MIDDLE:
+        menu_current_middle(menu);
+        break;
+      case OP_CURRENT_TOP:
+        menu_current_top(menu);
+        break;
       case OP_FIRST_ENTRY:
         menu_first_entry(menu);
         break;
-      case OP_MIDDLE_PAGE:
-        menu_middle_page(menu);
+      case OP_HALF_DOWN:
+        menu_half_down(menu);
         break;
       case OP_HALF_UP:
         menu_half_up(menu);
         break;
-      case OP_HALF_DOWN:
-        menu_half_down(menu);
+      case OP_LAST_ENTRY:
+        menu_last_entry(menu);
+        break;
+      case OP_MIDDLE_PAGE:
+        menu_middle_page(menu);
         break;
       case OP_NEXT_LINE:
         menu_next_line(menu);
         break;
-      case OP_PREV_LINE:
-        menu_prev_line(menu);
-        break;
       case OP_NEXT_PAGE:
         menu_next_page(menu);
         break;
+      case OP_PREV_LINE:
+        menu_prev_line(menu);
+        break;
       case OP_PREV_PAGE:
         menu_prev_page(menu);
         break;
-      case OP_LAST_ENTRY:
-        menu_last_entry(menu);
-        break;
       case OP_TOP_PAGE:
         menu_top_page(menu);
         break;
-      case OP_CURRENT_TOP:
-        menu_current_top(menu);
-        break;
-      case OP_CURRENT_MIDDLE:
-        menu_current_middle(menu);
-        break;
-      case OP_CURRENT_BOTTOM:
-        menu_current_bottom(menu);
-        break;
 
 #ifdef USE_NNTP
       case OP_GET_PARENT:

diff --git a/imap/command.c b/imap/command.c
index 3778ec0b2b0e57cf47105c9cac213320fc8e2399..3885ac8d54811213b2d957e400398c4ee9bbb6e9 100644 (file)
--- a/imap/command.c
+++ b/imap/command.c
@@ -536,39 +536,39 @@ static void cmd_parse_myrights(struct ImapData *idata, const char *s)
   {
     switch (*s)
     {
+      case 'a':
+        mutt_bit_set(idata->ctx->rights, MUTT_ACL_ADMIN);
+        break;
+      case 'e':
+        mutt_bit_set(idata->ctx->rights, MUTT_ACL_EXPUNGE);
+        break;
+      case 'i':
+        mutt_bit_set(idata->ctx->rights, MUTT_ACL_INSERT);
+        break;
+      case 'k':
+        mutt_bit_set(idata->ctx->rights, MUTT_ACL_CREATE);
+        break;
       case 'l':
         mutt_bit_set(idata->ctx->rights, MUTT_ACL_LOOKUP);
         break;
+      case 'p':
+        mutt_bit_set(idata->ctx->rights, MUTT_ACL_POST);
+        break;
       case 'r':
         mutt_bit_set(idata->ctx->rights, MUTT_ACL_READ);
         break;
       case 's':
         mutt_bit_set(idata->ctx->rights, MUTT_ACL_SEEN);
         break;
+      case 't':
+        mutt_bit_set(idata->ctx->rights, MUTT_ACL_DELETE);
+        break;
       case 'w':
         mutt_bit_set(idata->ctx->rights, MUTT_ACL_WRITE);
         break;
-      case 'i':
-        mutt_bit_set(idata->ctx->rights, MUTT_ACL_INSERT);
-        break;
-      case 'p':
-        mutt_bit_set(idata->ctx->rights, MUTT_ACL_POST);
-        break;
-      case 'a':
-        mutt_bit_set(idata->ctx->rights, MUTT_ACL_ADMIN);
-        break;
-      case 'k':
-        mutt_bit_set(idata->ctx->rights, MUTT_ACL_CREATE);
-        break;
       case 'x':
         mutt_bit_set(idata->ctx->rights, MUTT_ACL_DELMX);
         break;
-      case 't':
-        mutt_bit_set(idata->ctx->rights, MUTT_ACL_DELETE);
-        break;
-      case 'e':
-        mutt_bit_set(idata->ctx->rights, MUTT_ACL_EXPUNGE);
-        break;
 
       /* obsolete rights */
       case 'c':

diff --git a/imap/imap.c b/imap/imap.c
index 311b3628b4acb0c43d566bb2d2912e9673e4016d..1a29c58dad65ab1fa53e00fb180fd584d0c756c0 100644 (file)
--- a/imap/imap.c
+++ b/imap/imap.c
@@ -217,7 +217,6 @@ static int make_msg_set(struct ImapData *idata, struct Buffer *buf, int flag,
           if (hdrs[n]->replied != HEADER_DATA(hdrs[n])->replied)
             match = invert ^ hdrs[n]->replied;
           break;
-
         case MUTT_TAG:
           if (hdrs[n]->tagged)
             match = true;

diff --git a/init.c b/init.c
index 39f1e3438420317992704d76cce9078505642e16..dc835e6929173d4349c51bb514fc188468e8e5fb 100644 (file)
--- a/init.c
+++ b/init.c
@@ -531,21 +531,21 @@ int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, int flags)
           mutt_buffer_addch(dest, (toupper((unsigned char) *tok->dptr) - '@') & 0x7f);
           tok->dptr++;
           break;
-        case 'r':
-          mutt_buffer_addch(dest, '\r');
+        case 'e':
+          mutt_buffer_addch(dest, '\033');
+          break;
+        case 'f':
+          mutt_buffer_addch(dest, '\f');
           break;
         case 'n':
           mutt_buffer_addch(dest, '\n');
           break;
+        case 'r':
+          mutt_buffer_addch(dest, '\r');
+          break;
         case 't':
           mutt_buffer_addch(dest, '\t');
           break;
-        case 'f':
-          mutt_buffer_addch(dest, '\f');
-          break;
-        case 'e':
-          mutt_buffer_addch(dest, '\033');
-          break;
         default:
           if (isdigit((unsigned char) ch) && isdigit((unsigned char) *tok->dptr) &&
               isdigit((unsigned char) *(tok->dptr + 1)))
@@ -2688,6 +2688,9 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
         case DT_SORT_ALIAS:
           map = SortAliasMethods;
           break;
+        case DT_SORT_AUX:
+          map = SortAuxMethods;
+          break;
         case DT_SORT_BROWSER:
           map = SortBrowserMethods;
           break;
@@ -2695,9 +2698,6 @@ static int parse_set(struct Buffer *tmp, struct Buffer *s, unsigned long data,
           if (WithCrypto & APPLICATION_PGP)
             map = SortKeyMethods;
           break;
-        case DT_SORT_AUX:
-          map = SortAuxMethods;
-          break;
         case DT_SORT_SIDEBAR:
           map = SortSidebarMethods;
           break;

diff --git a/keymap.c b/keymap.c
index 398fc99546a5c742ece22a1b24f5bbeb110ca96c..fef10d21e7b71e3bba413fc63b3d4ca1accc3555 100644 (file)
--- a/keymap.c
+++ b/keymap.c
@@ -1051,41 +1051,38 @@ const struct Binding *km_get_table(int menu)
 {
   switch (menu)
   {
-    case MENU_MAIN:
-      return OpMain;
-    case MENU_GENERIC:
-      return OpGeneric;
-    case MENU_COMPOSE:
-      return OpCompose;
-    case MENU_PAGER:
-      return OpPager;
-    case MENU_POST:
-      return OpPost;
-    case MENU_FOLDER:
-      return OpBrowser;
     case MENU_ALIAS:
       return OpAlias;
     case MENU_ATTACH:
       return OpAttach;
+    case MENU_COMPOSE:
+      return OpCompose;
     case MENU_EDITOR:
       return OpEditor;
-    case MENU_QUERY:
-      return OpQuery;
-
-    case MENU_PGP:
-      return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
-
+    case MENU_FOLDER:
+      return OpBrowser;
+    case MENU_GENERIC:
+      return OpGeneric;
 #ifdef CRYPT_BACKEND_GPGME
     case MENU_KEY_SELECT_PGP:
       return OpPgp;
     case MENU_KEY_SELECT_SMIME:
       return OpSmime;
 #endif
-
+    case MENU_MAIN:
+      return OpMain;
 #ifdef MIXMASTER
     case MENU_MIX:
       return OpMix;
 #endif
+    case MENU_PAGER:
+      return OpPager;
+    case MENU_PGP:
+      return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
+    case MENU_POST:
+      return OpPost;
+    case MENU_QUERY:
+      return OpQuery;
   }
   return NULL;
 }

diff --git a/mh.c b/mh.c
index 42c53b59caa7273171c2993cfd71e6caf3ee1720..1b98bdab5cb5d4c8bcceee5a2567ec5116c5ab9f 100644 (file)
--- a/mh.c
+++ b/mh.c
@@ -712,20 +712,17 @@ void maildir_parse_flags(struct Header *h, const char *path)
       switch (*p)
       {
         case 'F':
-
           h->flagged = true;
           break;
 
-        case 'S': /* seen */
-
-          h->read = true;
-          break;
-
         case 'R': /* replied */
-
           h->replied = true;
           break;
 
+        case 'S': /* seen */
+          h->read = true;
+          break;
+
         case 'T': /* trashed */
           if (!h->flagged || !FlagSafe)
           {

diff --git a/muttlib.c b/muttlib.c
index ba3514210d8b3efd9c0817cc5f121e762c5ea6d6..05a7b7f61c26d705f3a51a325599bf3fb60ee563 100644 (file)
--- a/muttlib.c
+++ b/muttlib.c
@@ -1192,17 +1192,17 @@ void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const c
         break;
       switch (*src)
       {
+        case 'f':
+          *wptr = '\f';
+          break;
         case 'n':
           *wptr = '\n';
           break;
-        case 't':
-          *wptr = '\t';
-          break;
         case 'r':
           *wptr = '\r';
           break;
-        case 'f':
-          *wptr = '\f';
+        case 't':
+          *wptr = '\t';
           break;
         case 'v':
           *wptr = '\v';

diff --git a/ncrypt/crypt_gpgme.c b/ncrypt/crypt_gpgme.c
index f2df76c3ef02e31f0b8596aac382bcc4a84a9e15..87e805b78d4b75ae3754bbaecbb21c99e8a40648 100644 (file)
--- a/ncrypt/crypt_gpgme.c
+++ b/ncrypt/crypt_gpgme.c
@@ -386,10 +386,10 @@ static int crypt_id_is_strong(struct CryptKeyInfo *key)
 
   switch (key->validity)
   {
-    case GPGME_VALIDITY_UNKNOWN:
-    case GPGME_VALIDITY_UNDEFINED:
-    case GPGME_VALIDITY_NEVER:
     case GPGME_VALIDITY_MARGINAL:
+    case GPGME_VALIDITY_NEVER:
+    case GPGME_VALIDITY_UNDEFINED:
+    case GPGME_VALIDITY_UNKNOWN:
       is_strong = 0;
       break;
 
@@ -3007,21 +3007,21 @@ static const char *crypt_format_str(char *buf, size_t buflen, size_t col, int co
       {
         switch (key->validity)
         {
-          case GPGME_VALIDITY_UNDEFINED:
-            s = "q";
-            break;
-          case GPGME_VALIDITY_NEVER:
-            s = "n";
+          case GPGME_VALIDITY_FULL:
+            s = "f";
             break;
           case GPGME_VALIDITY_MARGINAL:
             s = "m";
             break;
-          case GPGME_VALIDITY_FULL:
-            s = "f";
+          case GPGME_VALIDITY_NEVER:
+            s = "n";
             break;
           case GPGME_VALIDITY_ULTIMATE:
             s = "u";
             break;
+          case GPGME_VALIDITY_UNDEFINED:
+            s = "q";
+            break;
           case GPGME_VALIDITY_UNKNOWN:
           default:
             s = "?";
@@ -4202,15 +4202,15 @@ static struct CryptKeyInfo *crypt_select_key(struct CryptKeyInfo *keys,
 
   switch (PgpSortKeys & SORT_MASK)
   {
+    case SORT_ADDRESS:
+      f = crypt_compare_address;
+      break;
     case SORT_DATE:
       f = crypt_compare_date;
       break;
     case SORT_KEYID:
       f = crypt_compare_keyid;
       break;
-    case SORT_ADDRESS:
-      f = crypt_compare_address;
-      break;
     case SORT_TRUST:
     default:
       f = crypt_compare_trust;
@@ -4307,10 +4307,6 @@ static struct CryptKeyInfo *crypt_select_key(struct CryptKeyInfo *keys,
             warn_s = "??";
             switch (key_table[menu->current]->validity)
             {
-              case GPGME_VALIDITY_UNKNOWN:
-              case GPGME_VALIDITY_UNDEFINED:
-                warn_s = N_("ID has undefined validity.");
-                break;
               case GPGME_VALIDITY_NEVER:
                 warn_s = N_("ID is not valid.");
                 break;
@@ -4320,6 +4316,10 @@ static struct CryptKeyInfo *crypt_select_key(struct CryptKeyInfo *keys,
               case GPGME_VALIDITY_FULL:
               case GPGME_VALIDITY_ULTIMATE:
                 break;
+              case GPGME_VALIDITY_UNKNOWN:
+              case GPGME_VALIDITY_UNDEFINED:
+                warn_s = N_("ID has undefined validity.");
+                break;
             }
           }
 
@@ -4951,20 +4951,6 @@ static int gpgme_send_menu(struct Header *msg, int is_smime)
   {
     switch (choices[choice - 1])
     {
-      case 'e': /* (e)ncrypt */
-        msg->security |= ENCRYPT;
-        msg->security &= ~SIGN;
-        break;
-
-      case 's': /* (s)ign */
-        msg->security &= ~ENCRYPT;
-        msg->security |= SIGN;
-        break;
-
-      case 'S': /* (s)ign in oppenc mode */
-        msg->security |= SIGN;
-        break;
-
       case 'a': /* sign (a)s */
         p = crypt_ask_for_key(_("Sign as: "), NULL, KEYFLAG_CANSIGN,
                               is_smime ? APPLICATION_SMIME : APPLICATION_PGP, NULL);
@@ -4983,8 +4969,21 @@ static int gpgme_send_menu(struct Header *msg, int is_smime)
         msg->security |= (ENCRYPT | SIGN);
         break;
 
-      case 'p': /* (p)gp or s/(m)ime */
-      case 'm':
+      case 'C':
+        msg->security &= ~SIGN;
+        break;
+
+      case 'c': /* (c)lear */
+        msg->security &= ~(ENCRYPT | SIGN);
+        break;
+
+      case 'e': /* (e)ncrypt */
+        msg->security |= ENCRYPT;
+        msg->security &= ~SIGN;
+        break;
+
+      case 'm': /* (p)gp or s/(m)ime */
+      case 'p':
         is_smime = !is_smime;
         if (is_smime)
         {
@@ -4999,14 +4998,6 @@ static int gpgme_send_menu(struct Header *msg, int is_smime)
         crypt_opportunistic_encrypt(msg);
         break;
 
-      case 'c': /* (c)lear */
-        msg->security &= ~(ENCRYPT | SIGN);
-        break;
-
-      case 'C':
-        msg->security &= ~SIGN;
-        break;
-
       case 'O': /* oppenc mode on */
         msg->security |= OPPENCRYPT;
         crypt_opportunistic_encrypt(msg);
@@ -5015,6 +5006,15 @@ static int gpgme_send_menu(struct Header *msg, int is_smime)
       case 'o': /* oppenc mode off */
         msg->security &= ~OPPENCRYPT;
         break;
+
+      case 'S': /* (s)ign in oppenc mode */
+        msg->security |= SIGN;
+        break;
+
+      case 's': /* (s)ign */
+        msg->security &= ~ENCRYPT;
+        msg->security |= SIGN;
+        break;
     }
   }
 

diff --git a/ncrypt/gnupgparse.c b/ncrypt/gnupgparse.c
index 88e208870046b6419a98068aabfc97db381cf0f4..b73a5983f3a04de940b018be9699bd5292a1f7f7 100644 (file)
--- a/ncrypt/gnupgparse.c
+++ b/ncrypt/gnupgparse.c
@@ -185,23 +185,23 @@ static struct PgpKeyInfo *parse_pub_line(char *buf, int *is_subkey, struct PgpKe
 
         switch (*p)
         { /* look only at the first letter */
+          case 'd':
+            flags |= KEYFLAG_DISABLED;
+            break;
           case 'e':
             flags |= KEYFLAG_EXPIRED;
             break;
-          case 'r':
-            flags |= KEYFLAG_REVOKED;
+          case 'f':
+            trust = 3;
             break;
-          case 'd':
-            flags |= KEYFLAG_DISABLED;
+          case 'm':
+            trust = 2;
             break;
           case 'n':
             trust = 1;
             break;
-          case 'm':
-            trust = 2;
-            break;
-          case 'f':
-            trust = 3;
+          case 'r':
+            flags |= KEYFLAG_REVOKED;
             break;
           case 'u':
             trust = 3;

diff --git a/ncrypt/pgp.c b/ncrypt/pgp.c
index 7caddcf351dfbe3ba73efce8ef37cd1e58d95a39..c1e0e5c4ca2e1dbd956b3b481b71714b8d4278ba 100644 (file)
--- a/ncrypt/pgp.c
+++ b/ncrypt/pgp.c
@@ -1778,20 +1778,6 @@ int pgp_send_menu(struct Header *msg)
   {
     switch (choices[choice - 1])
     {
-      case 'e': /* (e)ncrypt */
-        msg->security |= ENCRYPT;
-        msg->security &= ~SIGN;
-        break;
-
-      case 's': /* (s)ign */
-        msg->security &= ~ENCRYPT;
-        msg->security |= SIGN;
-        break;
-
-      case 'S': /* (s)ign in oppenc mode */
-        msg->security |= SIGN;
-        break;
-
       case 'a': /* sign (a)s */
         OPT_PGP_CHECK_TRUST = false;
 
@@ -1813,14 +1799,23 @@ int pgp_send_menu(struct Header *msg)
         msg->security |= (ENCRYPT | SIGN);
         break;
 
+      case 'C':
+        msg->security &= ~SIGN;
+        break;
+
       case 'c': /* (c)lear     */
         msg->security &= ~(ENCRYPT | SIGN);
         break;
 
-      case 'C':
+      case 'e': /* (e)ncrypt */
+        msg->security |= ENCRYPT;
         msg->security &= ~SIGN;
         break;
 
+      case 'i': /* toggle (i)nline */
+        msg->security ^= INLINE;
+        break;
+
       case 'O': /* oppenc mode on */
         msg->security |= OPPENCRYPT;
         crypt_opportunistic_encrypt(msg);
@@ -1830,8 +1825,13 @@ int pgp_send_menu(struct Header *msg)
         msg->security &= ~OPPENCRYPT;
         break;
 
-      case 'i': /* toggle (i)nline */
-        msg->security ^= INLINE;
+      case 'S': /* (s)ign in oppenc mode */
+        msg->security |= SIGN;
+        break;
+
+      case 's': /* (s)ign */
+        msg->security &= ~ENCRYPT;
+        msg->security |= SIGN;
         break;
     }
   }

diff --git a/ncrypt/pgpinvoke.c b/ncrypt/pgpinvoke.c
index 07e33c3a4b2905ed85f2adbee106f1ce89d11929..6b4ebd02a8a5fde4d39ef665bd638ad5fd8dfa6f 100644 (file)
--- a/ncrypt/pgpinvoke.c
+++ b/ncrypt/pgpinvoke.c
@@ -65,62 +65,58 @@ static const char *fmt_pgp_command(char *buf, size_t buflen, size_t col, int col
 
   switch (op)
   {
-    case 'r':
+    case 'a':
     {
       if (!optional)
       {
         snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, NONULL(cctx->ids));
+        snprintf(buf, buflen, fmt, NONULL(cctx->signas));
       }
-      else if (!cctx->ids)
+      else if (!cctx->signas)
         optional = 0;
       break;
     }
-
-    case 'a':
+    case 'f':
     {
       if (!optional)
       {
         snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, NONULL(cctx->signas));
+        snprintf(buf, buflen, fmt, NONULL(cctx->fname));
       }
-      else if (!cctx->signas)
+      else if (!cctx->fname)
         optional = 0;
       break;
     }
-
-    case 's':
+    case 'p':
     {
       if (!optional)
       {
         snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, NONULL(cctx->sig_fname));
+        snprintf(buf, buflen, fmt, cctx->need_passphrase ? "PGPPASSFD=0" : "");
       }
-      else if (!cctx->sig_fname)
+      else if (!cctx->need_passphrase || pgp_use_gpg_agent())
         optional = 0;
       break;
     }
-
-    case 'f':
+    case 'r':
     {
       if (!optional)
       {
         snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, NONULL(cctx->fname));
+        snprintf(buf, buflen, fmt, NONULL(cctx->ids));
       }
-      else if (!cctx->fname)
+      else if (!cctx->ids)
         optional = 0;
       break;
     }
-
-    case 'p':
+    case 's':
     {
       if (!optional)
       {
         snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, cctx->need_passphrase ? "PGPPASSFD=0" : "");
+        snprintf(buf, buflen, fmt, NONULL(cctx->sig_fname));
       }
-      else if (!cctx->need_passphrase || pgp_use_gpg_agent())
+      else if (!cctx->sig_fname)
         optional = 0;
       break;
     }

diff --git a/ncrypt/pgpkey.c b/ncrypt/pgpkey.c
index 60e7c0acbb097485b8545e93593e2ed8a2f972ae..3024e229b4105cd788acc96b6b545d116b16dafb 100644 (file)
--- a/ncrypt/pgpkey.c
+++ b/ncrypt/pgpkey.c
@@ -160,6 +160,71 @@ static const char *pgp_entry_fmt(char *buf, size_t buflen, size_t col, int cols,
 
   switch (tolower(op))
   {
+    case 'a':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+        snprintf(buf, buflen, fmt, key->algorithm);
+      }
+      break;
+    case 'c':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+        snprintf(buf, buflen, fmt, pgp_key_abilities(kflags));
+      }
+      else if (!(kflags & (KEYFLAG_ABILITIES)))
+        optional = 0;
+      break;
+    case 'f':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+        snprintf(buf, buflen, fmt, pgp_flags(kflags));
+      }
+      else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
+        optional = 0;
+      break;
+    case 'k':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+        snprintf(buf, buflen, fmt, pgp_this_keyid(key));
+      }
+      break;
+    case 'l':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+        snprintf(buf, buflen, fmt, key->keylen);
+      }
+      break;
+    case 'n':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
+        snprintf(buf, buflen, fmt, entry->num);
+      }
+      break;
+    case 't':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
+        snprintf(buf, buflen, fmt, trust_flags[uid->trust & 0x03]);
+      }
+      else if (!(uid->trust & 0x03))
+      {
+        /* undefined trust */
+        optional = 0;
+      }
+      break;
+    case 'u':
+      if (!optional)
+      {
+        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
+        snprintf(buf, buflen, fmt, NONULL(uid->addr));
+      }
+      break;
     case '[':
 
     {
@@ -218,71 +283,6 @@ static const char *pgp_entry_fmt(char *buf, size_t buflen, size_t col, int cols,
         src = cp + 1;
     }
     break;
-    case 'n':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
-        snprintf(buf, buflen, fmt, entry->num);
-      }
-      break;
-    case 'k':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, pgp_this_keyid(key));
-      }
-      break;
-    case 'u':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, NONULL(uid->addr));
-      }
-      break;
-    case 'a':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, key->algorithm);
-      }
-      break;
-    case 'l':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
-        snprintf(buf, buflen, fmt, key->keylen);
-      }
-      break;
-    case 'f':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
-        snprintf(buf, buflen, fmt, pgp_flags(kflags));
-      }
-      else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
-        optional = 0;
-      break;
-    case 'c':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
-        snprintf(buf, buflen, fmt, pgp_key_abilities(kflags));
-      }
-      else if (!(kflags & (KEYFLAG_ABILITIES)))
-        optional = 0;
-      break;
-    case 't':
-      if (!optional)
-      {
-        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
-        snprintf(buf, buflen, fmt, trust_flags[uid->trust & 0x03]);
-      }
-      else if (!(uid->trust & 0x03))
-      {
-        /* undefined trust */
-        optional = 0;
-      }
-      break;
     default:
       *buf = '\0';
   }
@@ -518,15 +518,15 @@ static struct PgpKeyInfo *pgp_select_key(struct PgpKeyInfo *keys,
 
   switch (PgpSortKeys & SORT_MASK)
   {
+    case SORT_ADDRESS:
+      f = pgp_compare_address;
+      break;
     case SORT_DATE:
       f = pgp_compare_date;
       break;
     case SORT_KEYID:
       f = pgp_compare_keyid;
       break;
-    case SORT_ADDRESS:
-      f = pgp_compare_address;
-      break;
     case SORT_TRUST:
     default:
       f = pgp_compare_trust;

diff --git a/ncrypt/smime.c b/ncrypt/smime.c
index 6008b6a3392a3e9a290629168db8ebc88a77d65f..b3df88783e637031cb304d01705bb9812a94408e 100644 (file)
--- a/ncrypt/smime.c
+++ b/ncrypt/smime.c
@@ -360,23 +360,23 @@ static void smime_entry(char *buf, size_t buflen, struct Menu *menu, int num)
   char *truststate = NULL;
   switch (this->trust)
   {
-    case 't':
-      truststate = N_("Trusted   ");
-      break;
-    case 'v':
-      truststate = N_("Verified  ");
-      break;
-    case 'u':
-      truststate = N_("Unverified");
-      break;
     case 'e':
       truststate = N_("Expired   ");
       break;
+    case 'i':
+      truststate = N_("Invalid   ");
+      break;
     case 'r':
       truststate = N_("Revoked   ");
       break;
-    case 'i':
-      truststate = N_("Invalid   ");
+    case 't':
+      truststate = N_("Trusted   ");
+      break;
+    case 'u':
+      truststate = N_("Unverified");
+      break;
+    case 'v':
+      truststate = N_("Verified  ");
       break;
     default:
       truststate = N_("Unknown   ");
@@ -443,9 +443,9 @@ static struct SmimeKey *smime_select_key(struct SmimeKey *keys, char *query)
         {
           switch (table[menu->current]->trust)
           {
+            case 'e':
             case 'i':
             case 'r':
-            case 'e':
               s = N_("ID is expired/disabled/revoked.");
               break;
             case 'u':
@@ -2082,11 +2082,56 @@ int smime_send_menu(struct Header *msg)
   {
     switch (choices[choice - 1])
     {
+      case 'a': /* sign (a)s */
+        key = smime_ask_for_key(_("Sign as: "), KEYFLAG_CANSIGN, 0);
+        if (key)
+        {
+          mutt_str_replace(&SmimeSignAs, key->hash);
+          smime_free_key(&key);
+
+          msg->security |= SIGN;
+
+          /* probably need a different passphrase */
+          crypt_smime_void_passphrase();
+        }
+
+        break;
+
+      case 'b': /* (b)oth */
+        msg->security |= (ENCRYPT | SIGN);
+        break;
+
+      case 'c': /* (c)lear */
+        msg->security &= ~(ENCRYPT | SIGN);
+        break;
+
+      case 'C':
+        msg->security &= ~SIGN;
+        break;
+
       case 'e': /* (e)ncrypt */
         msg->security |= ENCRYPT;
         msg->security &= ~SIGN;
         break;
 
+      case 'O': /* oppenc mode on */
+        msg->security |= OPPENCRYPT;
+        crypt_opportunistic_encrypt(msg);
+        break;
+
+      case 'o': /* oppenc mode off */
+        msg->security &= ~OPPENCRYPT;
+        break;
+
+      case 'S': /* (s)ign in oppenc mode */
+        msg->security |= SIGN;
+        break;
+
+      case 's': /* (s)ign */
+        msg->security &= ~ENCRYPT;
+        msg->security |= SIGN;
+        break;
+
       case 'w': /* encrypt (w)ith */
       {
         msg->security |= ENCRYPT;
@@ -2153,51 +2198,6 @@ int smime_send_menu(struct Header *msg)
         } while (choice == -1);
       }
       break;
-
-      case 's': /* (s)ign */
-        msg->security &= ~ENCRYPT;
-        msg->security |= SIGN;
-        break;
-
-      case 'S': /* (s)ign in oppenc mode */
-        msg->security |= SIGN;
-        break;
-
-      case 'a': /* sign (a)s */
-        key = smime_ask_for_key(_("Sign as: "), KEYFLAG_CANSIGN, 0);
-        if (key)
-        {
-          mutt_str_replace(&SmimeSignAs, key->hash);
-          smime_free_key(&key);
-
-          msg->security |= SIGN;
-
-          /* probably need a different passphrase */
-          crypt_smime_void_passphrase();
-        }
-
-        break;
-
-      case 'b': /* (b)oth */
-        msg->security |= (ENCRYPT | SIGN);
-        break;
-
-      case 'c': /* (c)lear */
-        msg->security &= ~(ENCRYPT | SIGN);
-        break;
-
-      case 'C':
-        msg->security &= ~SIGN;
-        break;
-
-      case 'O': /* oppenc mode on */
-        msg->security |= OPPENCRYPT;
-        crypt_opportunistic_encrypt(msg);
-        break;
-
-      case 'o': /* oppenc mode off */
-        msg->security &= ~OPPENCRYPT;
-        break;
     }
   }
 

diff --git a/parse.c b/parse.c
index 09534dad586f5d12c1797b3d00565a6d881fc88a..f9e295740bd954abf8d4608689dc39575ba96f50 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -1029,15 +1029,15 @@ int mutt_parse_rfc822_line(struct Envelope *e, struct Header *hdr, char *line,
           {
             switch (*p)
             {
-              case 'r':
-                hdr->replied = true;
-                break;
               case 'O':
                 hdr->old = MarkOld ? true : false;
                 break;
               case 'R':
                 hdr->read = true;
                 break;
+              case 'r':
+                hdr->replied = true;
+                break;
             }
             p++;
           }

diff --git a/postpone.c b/postpone.c
index 1c21065c35ea20ee10e1a5c0313197354c32662b..01e658f689cb1b5cab3dd3de4744cb07e64fabf2 100644 (file)
--- a/postpone.c
+++ b/postpone.c
@@ -417,29 +417,19 @@ int mutt_parse_crypt_hdr(const char *p, int set_empty_signas, int crypt_app)
   {
     switch (*p)
     {
-      case 'e':
-      case 'E':
-        flags |= ENCRYPT;
-        break;
-
-      case 'o':
-      case 'O':
-        flags |= OPPENCRYPT;
-        break;
-
-      case 's':
-      case 'S':
-        flags |= SIGN;
-        q = sign_as;
+      case 'c':
+      case 'C':
+        q = smime_cryptalg;
 
         if (*(p + 1) == '<')
         {
-          for (p += 2; *p && *p != '>' && q < sign_as + sizeof(sign_as) - 1; *q++ = *p++)
+          for (p += 2; *p && *p != '>' && q < smime_cryptalg + sizeof(smime_cryptalg) - 1;
+               *q++ = *p++)
             ;
 
           if (*p != '>')
           {
-            mutt_error(_("Illegal crypto header"));
+            mutt_error(_("Illegal S/MIME header"));
             return 0;
           }
         }
@@ -447,6 +437,16 @@ int mutt_parse_crypt_hdr(const char *p, int set_empty_signas, int crypt_app)
         *q = '\0';
         break;
 
+      case 'e':
+      case 'E':
+        flags |= ENCRYPT;
+        break;
+
+      case 'i':
+      case 'I':
+        flags |= INLINE;
+        break;
+
       /* This used to be the micalg parameter.
        *
        * It's no longer needed, so we just skip the parameter in order
@@ -467,19 +467,24 @@ int mutt_parse_crypt_hdr(const char *p, int set_empty_signas, int crypt_app)
 
         break;
 
-      case 'c':
-      case 'C':
-        q = smime_cryptalg;
+      case 'o':
+      case 'O':
+        flags |= OPPENCRYPT;
+        break;
+
+      case 's':
+      case 'S':
+        flags |= SIGN;
+        q = sign_as;
 
         if (*(p + 1) == '<')
         {
-          for (p += 2; *p && *p != '>' && q < smime_cryptalg + sizeof(smime_cryptalg) - 1;
-               *q++ = *p++)
+          for (p += 2; *p && *p != '>' && q < sign_as + sizeof(sign_as) - 1; *q++ = *p++)
             ;
 
           if (*p != '>')
           {
-            mutt_error(_("Illegal S/MIME header"));
+            mutt_error(_("Illegal crypto header"));
             return 0;
           }
         }
@@ -487,11 +492,6 @@ int mutt_parse_crypt_hdr(const char *p, int set_empty_signas, int crypt_app)
         *q = '\0';
         break;
 
-      case 'i':
-      case 'I':
-        flags |= INLINE;
-        break;
-
       default:
         mutt_error(_("Illegal crypto header"));
         return 0;

diff --git a/sort.c b/sort.c
index 753fcdc65b23b266306618bf001e69b1250ddd7b..008d0ea107d24c684bb335b92c16755e00e4676e 100644 (file)
--- a/sort.c
+++ b/sort.c
@@ -275,26 +275,26 @@ sort_t *mutt_get_sort_func(int method)
 {
   switch (method & SORT_MASK)
   {
-    case SORT_RECEIVED:
-      return compare_date_received;
-    case SORT_ORDER:
-      return compare_order;
     case SORT_DATE:
       return compare_date_sent;
-    case SORT_SUBJECT:
-      return compare_subject;
     case SORT_FROM:
       return compare_from;
-    case SORT_SIZE:
-      return compare_size;
-    case SORT_TO:
-      return compare_to;
+    case SORT_LABEL:
+      return compare_label;
+    case SORT_ORDER:
+      return compare_order;
+    case SORT_RECEIVED:
+      return compare_date_received;
     case SORT_SCORE:
       return compare_score;
+    case SORT_SIZE:
+      return compare_size;
     case SORT_SPAM:
       return compare_spam;
-    case SORT_LABEL:
-      return compare_label;
+    case SORT_SUBJECT:
+      return compare_subject;
+    case SORT_TO:
+      return compare_to;
     default:
       return NULL;
   }