git.marmaro.de Git - mmh/blob - uip/mshcmds.c

   1
   2 /*
   3  * mshcmds.c -- command handlers in msh
   4  *
   5  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   6  * COPYRIGHT file in the root directory of the nmh distribution for
   7  * complete copyright information.
   8  */
   9
  10 #include <h/mh.h>
  11 #include <h/signals.h>
  12 #include <h/dropsbr.h>
  13 #include <h/fmt_scan.h>
  14 #include <h/scansbr.h>
  15 #include <h/tws.h>
  16 #include <h/mts.h>
  17 #include <errno.h>
  18 #include <setjmp.h>
  19 #include <signal.h>
  20 #include <h/msh.h>
  21 #include <h/picksbr.h>
  22 #include <h/utils.h>
  23
  24
  25 static char delim3[] = "-------";       /* from burst.c */
  26
  27 static int mhlnum;
  28 static FILE *mhlfp;
  29
  30 /*
  31  * Type for a compare function for qsort.  This keeps
  32  * the compiler happy.
  33  */
  34 typedef int (*qsort_comp) (const void *, const void *);
  35
  36 /*
  37  * prototypes
  38  */
  39 void clear_screen (void);   /* from termsbr.c */
  40 int SOprintf (char *, ...); /* from termsbr.c */
  41 int sc_width (void);        /* from termsbr.c */
  42
  43 /*
  44  * static prototypes
  45  */
  46 static int burst (struct Msg *, int, int, int, int);
  47 static void forw (char *, char *, int, char **);
  48 static void rmm (void);
  49 static void show (int);
  50 static int eom_action (int);
  51 static FILE *mhl_action (char *);
  52 static int ask (int);
  53 static int is_nontext (int);
  54 static int get_fields (char *, char *, int, struct Msg *);
  55 static int msgsort (struct Msg *, struct Msg *);
  56 static int subsort (struct Msg *, struct Msg *);
  57 static char *sosmash (char *, char *);
  58 static int process (int, char *, int, char **);
  59 static void copy_message (int, FILE *);
  60 static void copy_digest (int, FILE *);
  61
  62 /* from mhlsbr.c */
  63 int mhlsbr (int, char **, FILE *(*)());
  64
  65 void
  66 forkcmd (char **args, char *pgm)
  67 {
  68     int child_id;
  69     char *vec[MAXARGS];
  70
  71     vec[0] = r1bindex (pgm, '/');
  72     copyip (args, vec + 1, MAXARGS - 1);
  73
  74     if (fmsh) {
  75         context_del (pfolder);
  76         context_replace (pfolder, fmsh);/* update current folder   */
  77         seq_save (mp);
  78         context_save ();                /* save the context file   */
  79     }
  80     fflush (stdout);
  81     switch (child_id = fork ()) {
  82         case NOTOK:
  83             advise ("fork", "unable to");
  84             return;
  85
  86         case OK:
  87             closefds (3);
  88             SIGNAL (SIGINT, istat);
  89             SIGNAL (SIGQUIT, qstat);
  90
  91             execvp (pgm, vec);
  92             fprintf (stderr, "unable to exec ");
  93             perror (cmd_name);
  94             _exit (1);
  95
  96         default:
  97             pidXwait (child_id, NULL);
  98             break;
  99     }
 100     if (fmsh) {                 /* assume the worst case */
 101         mp->msgflags |= MODIFIED;
 102         modified++;
 103     }
 104 }
 105
 106
 107 static struct swit distswit[] = {
 108 #define DIANSW                    0
 109     { "annotate", 0 },
 110 #define DINANSW                   1
 111     { "noannotate", 0 },
 112 #define DIDFSW                    2
 113     { "draftfolder +folder", 0 },
 114 #define DIDMSW                    3
 115     { "draftmessage msg", 0 },
 116 #define DINDFSW                   4
 117     { "nodraftfolder", 0 },
 118 #define DIEDTSW                   5
 119     { "editor editor", 0 },
 120 #define DINEDSW                   6
 121     { "noedit", 0 },
 122 #define DIFRMSW                   7
 123     { "form formfile", 0 },
 124 #define DIINSW                    8
 125     { "inplace", 0 },
 126 #define DININSW                   9
 127     { "noinplace", 0 },
 128 #define DIWHTSW                  10
 129     { "whatnowproc program", 0 },
 130 #define DINWTSW                  11
 131     { "nowhatnowproc", 0 },
 132 #define DIHELP                   12
 133     { "help", 0 },
 134     { NULL, 0 }
 135 };
 136
 137
 138 void
 139 distcmd (char **args)
 140 {
 141     int vecp = 1;
 142     char *cp, *msg = NULL;
 143     char buf[BUFSIZ], *vec[MAXARGS];
 144
 145     if (fmsh) {
 146         forkcmd (args, cmd_name);
 147         return;
 148     }
 149
 150     while ((cp = *args++)) {
 151         if (*cp == '-')
 152             switch (smatch (++cp, distswit)) {
 153                 case AMBIGSW:
 154                     ambigsw (cp, distswit);
 155                     return;
 156                 case UNKWNSW:
 157                     fprintf (stderr, "-%s unknown\n", cp);
 158                     return;
 159                 case DIHELP:
 160                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
 161                     print_help (buf, distswit, 1);
 162                     return;
 163
 164                 case DIANSW:    /* not implemented */
 165                 case DINANSW:
 166                 case DIINSW:
 167                 case DININSW:
 168                     continue;
 169
 170                 case DINDFSW:
 171                 case DINEDSW:
 172                 case DINWTSW:
 173                     vec[vecp++] = --cp;
 174                     continue;
 175
 176                 case DIEDTSW:
 177                 case DIFRMSW:
 178                 case DIDFSW:
 179                 case DIDMSW:
 180                 case DIWHTSW:
 181                     vec[vecp++] = --cp;
 182                     if (!(cp = *args++) || *cp == '-') {
 183                         advise (NULL, "missing argument to %s", args[-2]);
 184                         return;
 185                     }
 186                     vec[vecp++] = cp;
 187                     continue;
 188             }
 189         if (*cp == '+' || *cp == '@') {
 190             advise (NULL, "sorry, no folders allowed!");
 191             return;
 192         }
 193         else
 194             if (msg) {
 195                 advise (NULL, "only one message at a time!");
 196                 return;
 197             }
 198             else
 199                 msg = cp;
 200     }
 201
 202     vec[0] = cmd_name;
 203     vec[vecp++] = "-file";
 204     vec[vecp] = NULL;
 205     if (!msg)
 206         msg = "cur";
 207     if (!m_convert (mp, msg))
 208         return;
 209     seq_setprev (mp);
 210
 211     if (mp->numsel > 1) {
 212         advise (NULL, "only one message at a time!");
 213         return;
 214     }
 215     process (mp->hghsel, cmd_name, vecp, vec);
 216     seq_setcur (mp, mp->hghsel);
 217 }
 218
 219
 220 static struct swit explswit[] = {
 221 #define EXINSW         0
 222     { "inplace", 0 },
 223 #define EXNINSW        1
 224     { "noinplace", 0 },
 225 #define EXQISW         2
 226     { "quiet", 0 },
 227 #define EXNQISW        3
 228     { "noquiet", 0 },
 229 #define EXVBSW         4
 230     { "verbose", 0 },
 231 #define EXNVBSW        5
 232     { "noverbose", 0 },
 233 #define EXHELP         6
 234     { "help", 0 },
 235     { NULL, 0 }
 236 };
 237
 238
 239 void
 240 explcmd (char **args)
 241 {
 242     int inplace = 0, quietsw = 0, verbosw = 0;
 243     int msgp = 0, hi, msgnum;
 244     char *cp, buf[BUFSIZ], *msgs[MAXARGS];
 245     struct Msg *smsgs;
 246
 247     if (fmsh) {
 248         forkcmd (args, cmd_name);
 249         return;
 250     }
 251
 252     while ((cp = *args++)) {
 253         if (*cp == '-')
 254             switch (smatch (++cp, explswit)) {
 255                 case AMBIGSW:
 256                     ambigsw (cp, explswit);
 257                     return;
 258                 case UNKWNSW:
 259                     fprintf (stderr, "-%s unknown\n", cp);
 260                     return;
 261                 case EXHELP:
 262                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
 263                     print_help (buf, explswit, 1);
 264                     return;
 265
 266                 case EXINSW:
 267                     inplace++;
 268                     continue;
 269                 case EXNINSW:
 270                     inplace = 0;
 271                     continue;
 272                 case EXQISW:
 273                     quietsw++;
 274                     continue;
 275                 case EXNQISW:
 276                     quietsw = 0;
 277                     continue;
 278                 case EXVBSW:
 279                     verbosw++;
 280                     continue;
 281                 case EXNVBSW:
 282                     verbosw = 0;
 283                     continue;
 284             }
 285         if (*cp == '+' || *cp == '@') {
 286             advise (NULL, "sorry, no folders allowed!");
 287             return;
 288         }
 289         else
 290             msgs[msgp++] = cp;
 291     }
 292
 293     if (!msgp)
 294         msgs[msgp++] = "cur";
 295     for (msgnum = 0; msgnum < msgp; msgnum++)
 296         if (!m_convert (mp, msgs[msgnum]))
 297             return;
 298     seq_setprev (mp);
 299
 300     smsgs = (struct Msg *)
 301                 calloc ((size_t) (MAXFOLDER + 2), sizeof *smsgs);
 302     if (smsgs == NULL)
 303         adios (NULL, "unable to allocate folder storage");
 304
 305     hi = mp->hghmsg + 1;
 306     interrupted = 0;
 307     for (msgnum = mp->lowsel;
 308             msgnum <= mp->hghsel && !interrupted;
 309             msgnum++)
 310         if (is_selected (mp, msgnum))
 311             if (burst (smsgs, msgnum, inplace, quietsw, verbosw) != OK)
 312                 break;
 313
 314     free ((char *) smsgs);
 315
 316     if (inplace)
 317         seq_setcur (mp, mp->lowsel);
 318     else
 319         if (hi <= mp->hghmsg)
 320             seq_setcur (mp, hi);
 321
 322     mp->msgflags |= MODIFIED;
 323     modified++;
 324 }
 325
 326
 327 static int
 328 burst (struct Msg *smsgs, int msgnum, int inplace, int quietsw, int verbosw)
 329 {
 330     int i, j, ld3, wasdlm, msgp;
 331     long pos;
 332     char c, buffer[BUFSIZ];
 333     register FILE *zp;
 334
 335     ld3 = strlen (delim3);
 336
 337     if (Msgs[msgnum].m_scanl) {
 338         free (Msgs[msgnum].m_scanl);
 339         Msgs[msgnum].m_scanl = NULL;
 340     }
 341
 342     pos = ftell (zp = msh_ready (msgnum, 1));
 343     for (msgp = 0; msgp <= MAXFOLDER;) {
 344         while (fgets (buffer, sizeof buffer, zp) != NULL
 345                 && buffer[0] == '\n'
 346                 && pos < Msgs[msgnum].m_stop)
 347             pos += (long) strlen (buffer);
 348         if (feof (zp) || pos >= Msgs[msgnum].m_stop)
 349             break;
 350         fseek (zp, pos, SEEK_SET);
 351         smsgs[msgp].m_start = pos;
 352
 353         for (c = 0;
 354                 pos < Msgs[msgnum].m_stop
 355                 && fgets (buffer, sizeof buffer, zp) != NULL;
 356                 c = buffer[0])
 357             if (strncmp (buffer, delim3, ld3) == 0
 358                     && (msgp == 1 || c == '\n')
 359                     && peekc (zp) == '\n')
 360                 break;
 361             else
 362                 pos += (long) strlen (buffer);
 363
 364         wasdlm = strncmp (buffer, delim3, ld3) == 0;
 365         if (smsgs[msgp].m_start != pos)
 366             smsgs[msgp++].m_stop = (c == '\n' && wasdlm) ? pos - 1 : pos;
 367         if (feof (zp) || pos >= Msgs[msgnum].m_stop) {
 368             if (wasdlm)
 369                 smsgs[msgp - 1].m_stop -= ((long) strlen (buffer) + 1);
 370             break;
 371         }
 372         pos += (long) strlen (buffer);
 373     }
 374
 375     switch (msgp--) {           /* toss "End of XXX Digest" */
 376         case 0:
 377             adios (NULL, "burst() botch -- you lose big");
 378
 379         case 1:
 380             if (!quietsw)
 381                 printf ("message %d not in digest format\n", msgnum);
 382             return OK;
 383
 384         default:
 385             if (verbosw)
 386                 printf ("%d message%s exploded from digest %d\n",
 387                         msgp, msgp != 1 ? "s" : "", msgnum);
 388             break;
 389     }
 390
 391     if ((i = msgp + mp->hghmsg) > MAXFOLDER) {
 392         advise (NULL, "more than %d messages", MAXFOLDER);
 393         return NOTOK;
 394     }
 395     if (!(mp = folder_realloc (mp, mp->lowoff, i)))
 396         adios (NULL, "unable to allocate folder storage");
 397
 398     j = mp->hghmsg;
 399     mp->hghmsg += msgp;
 400     mp->nummsg += msgp;
 401     if (mp->hghsel > msgnum)
 402         mp->hghsel += msgp;
 403
 404     if (inplace)
 405         for (i = mp->hghmsg; j > msgnum; i--, j--) {
 406             if (verbosw)
 407                 printf ("message %d becomes message %d\n", j, i);
 408
 409             Msgs[i].m_bboard_id = Msgs[j].m_bboard_id;
 410             Msgs[i].m_top = Msgs[j].m_top;
 411             Msgs[i].m_start = Msgs[j].m_start;
 412             Msgs[i].m_stop = Msgs[j].m_stop;
 413             Msgs[i].m_scanl = NULL;
 414             if (Msgs[j].m_scanl) {
 415                 free (Msgs[j].m_scanl);
 416                 Msgs[j].m_scanl = NULL;
 417             }
 418             copy_msg_flags (mp, i, j);
 419         }
 420
 421     if (Msgs[msgnum].m_bboard_id == 0)
 422         readid (msgnum);
 423
 424     unset_selected (mp, msgnum);
 425     i = inplace ? msgnum + msgp : mp->hghmsg;
 426     for (j = msgp; j >= (inplace ? 0 : 1); i--, j--) {
 427         if (verbosw && i != msgnum)
 428             printf ("message %d of digest %d becomes message %d\n",
 429                     j, msgnum, i);
 430
 431         Msgs[i].m_bboard_id = Msgs[msgnum].m_bboard_id;
 432         Msgs[i].m_top = Msgs[j].m_top;
 433         Msgs[i].m_start = smsgs[j].m_start;
 434         Msgs[i].m_stop = smsgs[j].m_stop;
 435         Msgs[i].m_scanl = NULL;
 436         copy_msg_flags (mp, i, msgnum);
 437     }
 438
 439     return OK;
 440 }
 441
 442
 443 static struct swit fileswit[] = {
 444 #define FIDRFT               0
 445     { "draft", 0 },
 446 #define FILINK               1
 447     { "link", 0 },
 448 #define FINLINK              2
 449     { "nolink", 0 },
 450 #define FIPRES               3
 451     { "preserve", 0 },
 452 #define FINPRES              4
 453     { "nopreserve", 0 },
 454 #define FISRC                5
 455     { "src +folder", 0 },
 456 #define FIFILE               6
 457     { "file file", 0 },
 458 #define FIPROC               7
 459     { "rmmproc program", 0 },
 460 #define FINPRC               8
 461     { "normmproc", 0 },
 462 #define FIHELP               9
 463     { "help", 0 },
 464     { NULL, 0 }
 465 };
 466
 467
 468 void
 469 filecmd (char **args)
 470 {
 471     int linksw = 0, msgp = 0;
 472     int vecp = 1, i, msgnum;
 473     char *cp, buf[BUFSIZ];
 474     char *msgs[MAXARGS], *vec[MAXARGS];
 475
 476     if (fmsh) {
 477         forkcmd (args, cmd_name);
 478         return;
 479     }
 480
 481     while ((cp = *args++)) {
 482         if (*cp == '-')
 483             switch (i = smatch (++cp, fileswit)) {
 484                 case AMBIGSW:
 485                     ambigsw (cp, fileswit);
 486                     return;
 487                 case UNKWNSW:
 488                     fprintf (stderr, "-%s unknown\n", cp);
 489                     return;
 490                 case FIHELP:
 491                     snprintf (buf, sizeof(buf), "%s +folder... [msgs] [switches]", cmd_name);
 492                     print_help (buf, fileswit, 1);
 493                     return;
 494
 495                 case FILINK:
 496                     linksw++;
 497                     continue;
 498                 case FINLINK:
 499                     linksw = 0;
 500                     continue;
 501
 502                 case FIPRES:
 503                 case FINPRES:
 504                     continue;
 505
 506                 case FISRC:
 507                 case FIDRFT:
 508                 case FIFILE:
 509                 case FIPROC:
 510                 case FINPRC:
 511                     advise (NULL, "sorry, -%s not allowed!", fileswit[i].sw);
 512                     return;
 513             }
 514         if (*cp == '+' || *cp == '@')
 515             vec[vecp++] = cp;
 516         else
 517             msgs[msgp++] = cp;
 518     }
 519
 520     vec[0] = cmd_name;
 521     vec[vecp++] = "-file";
 522     vec[vecp] = NULL;
 523     if (!msgp)
 524         msgs[msgp++] = "cur";
 525     for (msgnum = 0; msgnum < msgp; msgnum++)
 526         if (!m_convert (mp, msgs[msgnum]))
 527             return;
 528     seq_setprev (mp);
 529
 530     interrupted = 0;
 531     for (msgnum = mp->lowsel;
 532             msgnum <= mp->hghsel && !interrupted;
 533             msgnum++)
 534         if (is_selected (mp, msgnum))
 535             if (process (msgnum, fileproc, vecp, vec)) {
 536                 unset_selected (mp, msgnum);
 537                 mp->numsel--;
 538             }
 539
 540     if (mp->numsel != mp->nummsg || linksw)
 541         seq_setcur (mp, mp->hghsel);
 542     if (!linksw)
 543         rmm ();
 544 }
 545
 546
 547 int
 548 filehak (char **args)
 549 {
 550     int result, vecp = 0;
 551     char *cp, *cwd, *vec[MAXARGS];
 552
 553     while ((cp = *args++)) {
 554         if (*cp == '-')
 555             switch (smatch (++cp, fileswit)) {
 556                 case AMBIGSW:
 557                 case UNKWNSW:
 558                 case FIHELP:
 559                     return NOTOK;
 560
 561                 case FILINK:
 562                 case FINLINK:
 563                 case FIPRES:
 564                 case FINPRES:
 565                     continue;
 566
 567                 case FISRC:
 568                 case FIDRFT:
 569                 case FIFILE:
 570                     return NOTOK;
 571             }
 572         if (*cp == '+' || *cp == '@')
 573             vec[vecp++] = cp;
 574     }
 575     vec[vecp] = NULL;
 576
 577     result = NOTOK;
 578     cwd = NULL;
 579     for (vecp = 0; (cp = vec[vecp]) && result == NOTOK; vecp++) {
 580         if (cwd == NULL)
 581             cwd = getcpy (pwd ());
 582         chdir (m_maildir (""));
 583         cp = pluspath (cp);
 584         if (access (m_maildir (cp), F_OK) == NOTOK)
 585             result = OK;
 586         free (cp);
 587     }
 588     if (cwd)
 589         chdir (cwd);
 590
 591     return result;
 592 }
 593
 594
 595 static struct swit foldswit[] = {
 596 #define FLALSW         0
 597     { "all", 0 },
 598 #define FLFASW         1
 599     { "fast", 0 },
 600 #define FLNFASW        2
 601     { "nofast", 0 },
 602 #define FLHDSW         3
 603     { "header", 0 },
 604 #define FLNHDSW        4
 605     { "noheader", 0 },
 606 #define FLPKSW         5
 607     { "pack", 0 },
 608 #define FLNPKSW        6
 609     { "nopack", 0 },
 610 #define FLRCSW         7
 611     { "recurse", 0 },
 612 #define FLNRCSW        8
 613     { "norecurse", 0 },
 614 #define FLTLSW         9
 615     { "total", 0 },
 616 #define FLNTLSW       10
 617     { "nototal", 0 },
 618 #define FLPRSW        11
 619     { "print", 0 },
 620 #define FLPUSW        12
 621     { "push", 0 },
 622 #define FLPOSW        13
 623     { "pop", 0 },
 624 #define FLLISW        14
 625     { "list", 0 },
 626 #define FLHELP        15
 627     { "help", 0 },
 628     { NULL, 0 }
 629 };
 630
 631
 632 void
 633 foldcmd (char **args)
 634 {
 635     int fastsw = 0, headersw = 0, packsw = 0;
 636     int hole, msgnum;
 637     char *cp, *folder = NULL, *msg = NULL;
 638     char buf[BUFSIZ], **vec = args;
 639
 640     if (args == NULL)
 641         goto fast;
 642
 643     while ((cp = *args++)) {
 644         if (*cp == '-')
 645             switch (smatch (++cp, foldswit)) {
 646                 case AMBIGSW:
 647                     ambigsw (cp, foldswit);
 648                     return;
 649                 case UNKWNSW:
 650                     fprintf (stderr, "-%s unknown\n", cp);
 651                     return;
 652                 case FLHELP:
 653                     snprintf (buf, sizeof(buf), "%s [+folder] [msg] [switches]", cmd_name);
 654                     print_help (buf, foldswit, 1);
 655                     return;
 656
 657                 case FLALSW:    /* not implemented */
 658                 case FLRCSW:
 659                 case FLNRCSW:
 660                 case FLTLSW:
 661                 case FLNTLSW:
 662                 case FLPRSW:
 663                 case FLPUSW:
 664                 case FLPOSW:
 665                 case FLLISW:
 666                     continue;
 667
 668                 case FLFASW:
 669                     fastsw++;
 670                     continue;
 671                 case FLNFASW:
 672                     fastsw = 0;
 673                     continue;
 674                 case FLHDSW:
 675                     headersw++;
 676                     continue;
 677                 case FLNHDSW:
 678                     headersw = 0;
 679                     continue;
 680                 case FLPKSW:
 681                     packsw++;
 682                     continue;
 683                 case FLNPKSW:
 684                     packsw = 0;
 685                     continue;
 686             }
 687         if (*cp == '+' || *cp == '@') {
 688             if (folder) {
 689                 advise (NULL, "only one folder at a time!\n");
 690                 return;
 691             }
 692             else
 693                 folder = fmsh ? pluspath (cp)
 694                             : cp + 1;
 695         }
 696         else
 697             if (msg) {
 698                 advise (NULL, "only one message at a time!\n");
 699                 return;
 700             }
 701             else
 702                 msg = cp;
 703     }
 704
 705     if (folder) {
 706         if (*folder == 0) {
 707             advise (NULL, "null folder names are not permitted");
 708             return;
 709         }
 710         if (fmsh) {
 711             if (access (m_maildir (folder), R_OK) == NOTOK) {
 712                 advise (folder, "unable to read");
 713                 return;
 714             }
 715         }
 716         else {
 717             strncpy (buf, folder, sizeof(buf));
 718             if (expand (buf) == NOTOK)
 719                 return;
 720             folder = buf;
 721             if (access (folder, R_OK) == NOTOK) {
 722                 advise (folder, "unable to read");
 723                 return;
 724             }
 725         }
 726         m_reset ();
 727
 728         if (fmsh)
 729             fsetup (folder);
 730         else
 731             setup (folder);
 732         readids (0);
 733         display_info (0);
 734     }
 735
 736     if (msg) {
 737         if (!m_convert (mp, msg))
 738             return;
 739         seq_setprev (mp);
 740
 741         if (mp->numsel > 1) {
 742             advise (NULL, "only one message at a time!");
 743             return;
 744         }
 745         seq_setcur (mp, mp->hghsel);
 746     }
 747
 748     if (packsw) {
 749         if (fmsh) {
 750             forkcmd (vec, cmd_name);
 751             return;
 752         }
 753
 754         if (mp->lowoff > 1 && !(mp = folder_realloc (mp, 1, mp->hghmsg)))
 755             adios (NULL, "unable to allocate folder storage");
 756
 757         for (msgnum = mp->lowmsg, hole = 1; msgnum <= mp->hghmsg; msgnum++)
 758             if (does_exist (mp, msgnum)) {
 759                 if (msgnum != hole) {
 760                     Msgs[hole].m_bboard_id = Msgs[msgnum].m_bboard_id;
 761                     Msgs[hole].m_top = Msgs[msgnum].m_top;
 762                     Msgs[hole].m_start = Msgs[msgnum].m_start;
 763                     Msgs[hole].m_stop = Msgs[msgnum].m_stop;
 764                     Msgs[hole].m_scanl = NULL;
 765                     if (Msgs[msgnum].m_scanl) {
 766                         free (Msgs[msgnum].m_scanl);
 767                         Msgs[msgnum].m_scanl = NULL;
 768                     }
 769                     copy_msg_flags (mp, hole, msgnum);
 770                     if (mp->curmsg == msgnum)
 771                         seq_setcur (mp, hole);
 772                 }
 773                 hole++;
 774             }
 775         if (mp->nummsg > 0) {
 776             mp->lowmsg = 1;
 777             mp->hghmsg = hole - 1;
 778         }
 779         mp->msgflags |= MODIFIED;
 780         modified++;
 781     }
 782
 783 fast: ;
 784     if (fastsw)
 785         printf ("%s\n", fmsh ? fmsh : mp->foldpath);
 786     else {
 787         if (headersw)
 788             printf ("\t\tFolder  %*s# of messages (%*srange%*s); cur%*smsg\n",
 789                 DMAXFOLDER, "", DMAXFOLDER - 2, "", DMAXFOLDER - 2, "",
 790                 DMAXFOLDER - 2, "");
 791         printf (args ? "%22s  " : "%s ", fmsh ? fmsh : mp->foldpath);
 792
 793         /* check for empty folder */
 794         if (mp->nummsg == 0) {
 795             printf ("has   no messages%*s",
 796                     mp->msgflags & OTHERS ? DMAXFOLDER * 2 + 4 : 0, "");
 797         } else {
 798             printf ("has %*d message%s (%*d-%*d)",
 799                     DMAXFOLDER, mp->nummsg, mp->nummsg != 1 ? "s" : "",
 800                     DMAXFOLDER, mp->lowmsg, DMAXFOLDER, mp->hghmsg);
 801             if (mp->curmsg >= mp->lowmsg
 802                     && mp->curmsg <= mp->hghmsg)
 803                 printf ("; cur=%*d", DMAXFOLDER, mp->curmsg);
 804         }
 805         printf (".\n");
 806     }
 807 }
 808
 809
 810 static struct swit forwswit[] = {
 811 #define FOANSW                   0
 812     { "annotate", 0 },
 813 #define FONANSW                  1
 814     { "noannotate", 0 },
 815 #define FODFSW                   2
 816     { "draftfolder +folder", 0 },
 817 #define FODMSW                   3
 818     { "draftmessage msg", 0 },
 819 #define FONDFSW                  4
 820     { "nodraftfolder", 0 },
 821 #define FOEDTSW                  5
 822     { "editor editor", 0 },
 823 #define FONEDSW                  6
 824     { "noedit", 0 },
 825 #define FOFTRSW                  7
 826     { "filter filterfile", 0 },
 827 #define FOFRMSW                  8
 828     { "form formfile", 0 },
 829 #define FOFTSW                   9
 830     { "format", 5 },
 831 #define FONFTSW                 10
 832     { "noformat", 7 },
 833 #define FOINSW                  11
 834     { "inplace", 0 },
 835 #define FONINSW                 12
 836     { "noinplace", 0 },
 837 #define FOMISW                  13
 838     { "mime", 0 },
 839 #define FONMISW                 14
 840     { "nomime", 0 },
 841 #define FOWHTSW                 15
 842     { "whatnowproc program", 0 },
 843 #define FONWTSW                 16
 844     { "nowhatnow", 0 },
 845 #define FOHELP                  17
 846     { "help", 0 },
 847     { NULL, 0 }
 848 };
 849
 850
 851 void
 852 forwcmd (char **args)
 853 {
 854     int msgp = 0, vecp = 1, msgnum;
 855     char *cp, *filter = NULL, buf[BUFSIZ];
 856     char *msgs[MAXARGS], *vec[MAXARGS];
 857     char *tfile = NULL;
 858     char tmpfil[BUFSIZ];
 859
 860     if (fmsh) {
 861         forkcmd (args, cmd_name);
 862         return;
 863     }
 864
 865     while ((cp = *args++)) {
 866         if (*cp == '-')
 867             switch (smatch (++cp, forwswit)) {
 868                 case AMBIGSW:
 869                     ambigsw (cp, forwswit);
 870                     return;
 871                 case UNKWNSW:
 872                     fprintf (stderr, "-%s unknown\n", cp);
 873                     return;
 874                 case FOHELP:
 875                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
 876                     print_help (buf, forwswit, 1);
 877                     return;
 878
 879                 case FOANSW:    /* not implemented */
 880                 case FONANSW:
 881                 case FOINSW:
 882                 case FONINSW:
 883                 case FOMISW:
 884                 case FONMISW:
 885                     continue;
 886
 887                 case FONDFSW:
 888                 case FONEDSW:
 889                 case FONWTSW:
 890                     vec[vecp++] = --cp;
 891                     continue;
 892
 893                 case FOEDTSW:
 894                 case FOFRMSW:
 895                 case FODFSW:
 896                 case FODMSW:
 897                 case FOWHTSW:
 898                     vec[vecp++] = --cp;
 899                     if (!(cp = *args++) || *cp == '-') {
 900                         advise (NULL, "missing argument to %s", args[-2]);
 901                         return;
 902                     }
 903                     vec[vecp++] = cp;
 904                     continue;
 905                 case FOFTRSW:
 906                     if (!(filter = *args++) || *filter == '-') {
 907                         advise (NULL, "missing argument to %s", args[-2]);
 908                         return;
 909                     }
 910                     continue;
 911                 case FOFTSW:
 912                     if (access (filter = myfilter, R_OK) == NOTOK) {
 913                         advise (filter, "unable to read default filter file");
 914                         return;
 915                     }
 916                     continue;
 917                 case FONFTSW:
 918                     filter = NULL;
 919                     continue;
 920             }
 921         if (*cp == '+' || *cp == '@') {
 922             advise (NULL, "sorry, no folders allowed!");
 923             return;
 924         }
 925         else
 926             msgs[msgp++] = cp;
 927     }
 928
 929                                         /* foil search of .mh_profile */
 930     snprintf (buf, sizeof(buf), "%sXXXXXX", invo_name);
 931
 932     tfile = m_mktemp(buf, NULL, NULL);
 933     if (tfile == NULL) adios("forwcmd", "unable to create temporary file");
 934     strncpy (tmpfil, tfile, sizeof(tmpfil));
 935     vec[0] = tmpfil;
 936
 937     vec[vecp++] = "-file";
 938     vec[vecp] = NULL;
 939     if (!msgp)
 940         msgs[msgp++] = "cur";
 941     for (msgnum = 0; msgnum < msgp; msgnum++)
 942         if (!m_convert (mp, msgs[msgnum]))
 943             return;
 944     seq_setprev (mp);
 945
 946     if (filter) {
 947         strncpy (buf, filter, sizeof(buf));
 948         if (expand (buf) == NOTOK)
 949             return;
 950         if (access (filter = getcpy (etcpath (buf)), R_OK) == NOTOK) {
 951             advise (filter, "unable to read");
 952             free (filter);
 953             return;
 954         }
 955     }
 956     forw (cmd_name, filter, vecp, vec);
 957     seq_setcur (mp, mp->hghsel);
 958     if (filter)
 959         free (filter);
 960 }
 961
 962
 963 static void
 964 forw (char *proc, char *filter, int vecp, char **vec)
 965 {
 966     int i, child_id, msgnum, msgcnt;
 967     char tmpfil[BUFSIZ], *args[MAXARGS];
 968     FILE *out;
 969     char *tfile = NULL;
 970
 971     tfile = m_mktemp2(NULL, invo_name, NULL, NULL);
 972     if (tfile == NULL) adios("forw", "unable to create temporary file");
 973     strncpy (tmpfil, tfile, sizeof(tmpfil));
 974
 975     interrupted = 0;
 976     if (filter)
 977         switch (child_id = fork ()) {
 978             case NOTOK:
 979                 advise ("fork", "unable to");
 980                 return;
 981
 982             case OK:            /* "trust me" */
 983                 if (freopen (tmpfil, "w", stdout) == NULL) {
 984                     fprintf (stderr, "unable to create ");
 985                     perror (tmpfil);
 986                     _exit (1);
 987                 }
 988                 args[0] = r1bindex (mhlproc, '/');
 989                 i = 1;
 990                 args[i++] = "-forwall";
 991                 args[i++] = "-form";
 992                 args[i++] = filter;
 993                 for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
 994                     if (is_selected (mp, msgnum))
 995                         args[i++] = getcpy (m_name (msgnum));
 996                 args[i] = NULL;
 997                 mhlsbr (i, args, mhl_action);
 998                 m_eomsbr ((int (*) ()) 0);
 999                 fclose (stdout);
1000                 _exit (0);
1001
1002             default:
1003                 if (pidXwait (child_id, NULL))
1004                     interrupted++;
1005                 break;
1006         }
1007     else {
1008         if ((out = fopen (tmpfil, "w")) == NULL) {
1009             advise (tmpfil, "unable to create temporary file");
1010             return;
1011         }
1012
1013         msgcnt = 1;
1014         for (msgnum = mp->lowsel;
1015                 msgnum <= mp->hghsel && !interrupted;
1016                 msgnum++)
1017             if (is_selected (mp, msgnum)) {
1018                 fprintf (out, "\n\n-------");
1019                 if (msgnum == mp->lowsel)
1020                     fprintf (out, " Forwarded Message%s",
1021                             mp->numsel > 1 ? "s" : "");
1022                 else
1023                     fprintf (out, " Message %d", msgcnt);
1024                 fprintf (out, "\n\n");
1025                 copy_digest (msgnum, out);
1026                 msgcnt++;
1027             }
1028
1029         fprintf (out, "\n\n------- End of Forwarded Message%s\n",
1030                 mp->numsel > 1 ? "s" : "");
1031         fclose (out);
1032     }
1033
1034     fflush (stdout);
1035     if (!interrupted)
1036         switch (child_id = fork ()) {
1037             case NOTOK:
1038                 advise ("fork", "unable to");
1039                 break;
1040
1041             case OK:
1042                 closefds (3);
1043                 SIGNAL (SIGINT, istat);
1044                 SIGNAL (SIGQUIT, qstat);
1045
1046                 vec[vecp++] = tmpfil;
1047                 vec[vecp] = NULL;
1048
1049                 execvp (proc, vec);
1050                 fprintf (stderr, "unable to exec ");
1051                 perror (proc);
1052                 _exit (1);
1053
1054             default:
1055                 pidXwait (child_id, NULL);
1056                 break;
1057         }
1058
1059     unlink (tmpfil);
1060 }
1061
1062
1063 static char *hlpmsg[] = {
1064     "The %s program emulates many of the commands found in the nmh",
1065     "system.  Instead of operating on nmh folders, commands to %s concern",
1066     "a single file.",
1067     "",
1068     "To see the list of commands available, just type a ``?'' followed by",
1069     "the RETURN key.  To find out what switches each command takes, type",
1070     "the name of the command followed by ``-help''.  To leave %s, use the",
1071     "``quit'' command.",
1072     "",
1073     "Although a lot of nmh commands are found in %s, not all are fully",
1074     "implemented.  %s will always recognize all legal switches for a",
1075     "given command though, and will let you know when you ask for an",
1076     "option that it is unable to perform.",
1077     "",
1078     "Running %s is fun, but using nmh from your shell is far superior.",
1079     "After you have familiarized yourself with the nmh style by using %s,",
1080     "you should try using nmh from the shell.  You can still use %s for",
1081     "message files that aren't in nmh format, such as BBoard files.",
1082     NULL
1083 };
1084
1085
1086 void
1087 helpcmd (char **args)
1088 {
1089     int i;
1090
1091     for (i = 0; hlpmsg[i]; i++) {
1092         printf (hlpmsg[i], invo_name);
1093         putchar ('\n');
1094     }
1095 }
1096
1097
1098 static struct swit markswit[] = {
1099 #define MADDSW             0
1100     { "add", 0 },
1101 #define MDELSW             1
1102     { "delete", 0 },
1103 #define MLSTSW             2
1104     { "list", 0 },
1105 #define MSEQSW             3
1106     { "sequence name", 0 },
1107 #define MPUBSW             4
1108     { "public", 0 },
1109 #define MNPUBSW            5
1110     { "nopublic", 0 },
1111 #define MZERSW             6
1112     { "zero", 0 },
1113 #define MNZERSW            7
1114     { "nozero", 0 },
1115 #define MHELP              8
1116     { "help", 0 },
1117 #define MDBUGSW            9
1118     { "debug", -5 },
1119     { NULL, 0 }
1120 };
1121
1122
1123 void
1124 markcmd (char **args)
1125 {
1126     int addsw = 0, deletesw = 0, debugsw = 0;
1127     int listsw = 0, zerosw = 0, seqp = 0;
1128     int msgp = 0, msgnum;
1129     char *cp, buf[BUFSIZ];
1130     char *seqs[NUMATTRS + 1], *msgs[MAXARGS];
1131
1132     while ((cp = *args++)) {
1133         if (*cp == '-') {
1134             switch (smatch (++cp, markswit)) {
1135                 case AMBIGSW:
1136                     ambigsw (cp, markswit);
1137                     return;
1138                 case UNKWNSW:
1139                     fprintf (stderr, "-%s unknown\n", cp);
1140                     return;
1141                 case MHELP:
1142                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1143                     print_help (buf, markswit, 1);
1144                     return;
1145
1146                 case MADDSW:
1147                     addsw++;
1148                     deletesw = listsw = 0;
1149                     continue;
1150                 case MDELSW:
1151                     deletesw++;
1152                     addsw = listsw = 0;
1153                     continue;
1154                 case MLSTSW:
1155                     listsw++;
1156                     addsw = deletesw = 0;
1157                     continue;
1158
1159                 case MSEQSW:
1160                     if (!(cp = *args++) || *cp == '-') {
1161                         advise (NULL, "missing argument to %s", args[-2]);
1162                         return;
1163                     }
1164                     if (seqp < NUMATTRS)
1165                         seqs[seqp++] = cp;
1166                     else {
1167                         advise (NULL, "only %d sequences allowed!", NUMATTRS);
1168                         return;
1169                     }
1170                     continue;
1171
1172                 case MPUBSW:    /* not implemented */
1173                 case MNPUBSW:
1174                     continue;
1175
1176                 case MDBUGSW:
1177                     debugsw++;
1178                     continue;
1179
1180                 case MZERSW:
1181                     zerosw++;
1182                     continue;
1183                 case MNZERSW:
1184                     zerosw = 0;
1185                     continue;
1186             }
1187         }
1188         if (*cp == '+' || *cp == '@') {
1189             advise (NULL, "sorry, no folders allowed!");
1190             return;
1191         } else {
1192             msgs[msgp++] = cp;
1193         }
1194     }
1195
1196     if (!addsw && !deletesw && !listsw) {
1197         if (seqp)
1198             addsw++;
1199         else
1200             if (debugsw)
1201                 listsw++;
1202             else {
1203                 seqs[seqp++] = "unseen";
1204                 deletesw++;
1205                 zerosw = 0;
1206                 if (!msgp)
1207                     msgs[msgp++] = "all";
1208             }
1209     }
1210
1211     if (!msgp)
1212         msgs[msgp++] = listsw ? "all" :"cur";
1213     for (msgnum = 0; msgnum < msgp; msgnum++)
1214         if (!m_convert (mp, msgs[msgnum]))
1215             return;
1216
1217     if (debugsw) {
1218         printf ("invo_name=%s mypath=%s defpath=%s\n",
1219                 invo_name, mypath, defpath);
1220         printf ("ctxpath=%s context flags=%s\n",
1221                 ctxpath, snprintb (buf, sizeof(buf), (unsigned) ctxflags, DBITS));
1222         printf ("foldpath=%s flags=%s\n",
1223                 mp->foldpath,
1224                 snprintb (buf, sizeof(buf), (unsigned) mp->msgflags, FBITS));
1225         printf ("hghmsg=%d lowmsg=%d nummsg=%d curmsg=%d\n",
1226                 mp->hghmsg, mp->lowmsg, mp->nummsg, mp->curmsg);
1227         printf ("lowsel=%d hghsel=%d numsel=%d\n",
1228                 mp->lowsel, mp->hghsel, mp->numsel);
1229         printf ("lowoff=%d hghoff=%d\n", mp->lowoff, mp->hghoff);
1230     }
1231
1232     if (seqp == 0 && (addsw || deletesw)) {
1233         advise (NULL, "-%s requires at least one -sequence argument",
1234                 addsw ? "add" : "delete");
1235         return;
1236     }
1237     seqs[seqp] = NULL;
1238
1239     if (addsw) {
1240         for (seqp = 0; seqs[seqp]; seqp++)
1241             if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1242                 return;
1243     }
1244
1245     if (deletesw) {
1246         for (seqp = 0; seqs[seqp]; seqp++)
1247             if (!seq_delsel (mp, seqs[seqp], 0, zerosw))
1248                 return;
1249     }
1250
1251     /* Listing messages in sequences */
1252     if (listsw) {
1253         if (seqp) {
1254             /* list the given sequences */
1255             for (seqp = 0; seqs[seqp]; seqp++)
1256                 seq_print (mp, seqs[seqp]);
1257         } else {
1258             /* else list them all */
1259             seq_printall (mp);
1260         }
1261
1262         interrupted = 0;
1263         if (debugsw)
1264             for (msgnum = mp->lowsel;
1265                     msgnum <= mp->hghsel && !interrupted;
1266                     msgnum++)
1267                 if (is_selected (mp, msgnum)) {
1268                     printf ("%*d: id=%d top=%d start=%ld stop=%ld %s\n",
1269                         DMAXFOLDER,
1270                         msgnum,
1271                         Msgs[msgnum].m_bboard_id,
1272                         Msgs[msgnum].m_top,
1273                         (long) Msgs[msgnum].m_start,
1274                         (long) Msgs[msgnum].m_stop,
1275                         snprintb (buf, sizeof(buf),
1276                                 (unsigned) mp->msgstats[msgnum - mp->lowoff],
1277                                 seq_bits (mp)));
1278                     if (Msgs[msgnum].m_scanl)
1279                         printf ("%s", Msgs[msgnum].m_scanl);
1280                 }
1281     }
1282 }
1283
1284
1285 static struct swit mhnswit[] = {
1286 #define MHNAUTOSW           0
1287     { "auto", 0 },
1288 #define MHNNAUTOSW          1
1289     { "noauto", 0 },
1290 #define MHNDEBUGSW          2
1291     { "debug", -5 },
1292 #define MHNEBCDICSW         3
1293     { "ebcdicsafe", 0 },
1294 #define MHNNEBCDICSW        4
1295     { "noebcdicsafe", 0 },
1296 #define MHNFORMSW           5
1297     { "form formfile", 4 },
1298 #define MHNHEADSW           6
1299     { "headers", 0 },
1300 #define MHNNHEADSW          7
1301     { "noheaders", 0 },
1302 #define MHNLISTSW           8
1303     { "list", 0 },
1304 #define MHNNLISTSW          9
1305     { "nolist", 0 },
1306 #define MHNPARTSW          10
1307     { "part number", 0 },
1308 #define MHNSIZESW          11
1309     { "realsize", 0 },
1310 #define MHNNSIZESW         12
1311     { "norealsize", 0 },
1312 #define MHNRFC934SW        13
1313     { "rfc934mode", 0 },
1314 #define MHNNRFC934SW       14
1315     { "norfc934mode", 0 },
1316 #define MHNSERIALSW        15
1317     { "serialonly", 0 },
1318 #define MHNNSERIALSW       16
1319     { "noserialonly", 0 },
1320 #define MHNSHOWSW          17
1321     { "show", 0 },
1322 #define MHNNSHOWSW         18
1323     { "noshow", 0 },
1324 #define MHNSTORESW         19
1325     { "store", 0 },
1326 #define MHNNSTORESW        20
1327     { "nostore", 0 },
1328 #define MHNTYPESW          21
1329     { "type content", 0 },
1330 #define MHNVERBSW          22
1331     { "verbose", 0 },
1332 #define MHNNVERBSW         23
1333     { "noverbose", 0 },
1334 #define MHNHELPSW          24
1335     { "help", 0 },
1336 #define MHNPROGSW          25
1337     { "moreproc program", -4 },
1338 #define MHNNPROGSW         26
1339     { "nomoreproc", -3 },
1340 #define MHNLENSW           27
1341     { "length lines", -4 },
1342 #define MHNWIDSW           28
1343     { "width columns", -4 },
1344     { NULL, 0 }
1345 };
1346
1347
1348 void
1349 mhncmd (char **args)
1350 {
1351     int msgp = 0, vecp = 1;
1352     int msgnum;
1353     char *cp, buf[BUFSIZ];
1354     char *msgs[MAXARGS], *vec[MAXARGS];
1355
1356     if (fmsh) {
1357         forkcmd (args, cmd_name);
1358         return;
1359     }
1360     while ((cp = *args++)) {
1361         if (*cp == '-') {
1362             switch (smatch (++cp, mhnswit)) {
1363                 case AMBIGSW:
1364                     ambigsw (cp, mhnswit);
1365                     return;
1366                 case UNKWNSW:
1367                     fprintf (stderr, "-%s unknown\n", cp);
1368                     return;
1369                 case MHNHELPSW:
1370                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1371                     print_help (buf, mhnswit, 1);
1372                     return;
1373
1374                 case MHNAUTOSW:
1375                 case MHNNAUTOSW:
1376                 case MHNDEBUGSW:
1377                 case MHNEBCDICSW:
1378                 case MHNNEBCDICSW:
1379                 case MHNHEADSW:
1380                 case MHNNHEADSW:
1381                 case MHNLISTSW:
1382                 case MHNNLISTSW:
1383                 case MHNSIZESW:
1384                 case MHNNSIZESW:
1385                 case MHNRFC934SW:
1386                 case MHNNRFC934SW:
1387                 case MHNSERIALSW:
1388                 case MHNNSERIALSW:
1389                 case MHNSHOWSW:
1390                 case MHNNSHOWSW:
1391                 case MHNSTORESW:
1392                 case MHNNSTORESW:
1393                 case MHNVERBSW:
1394                 case MHNNVERBSW:
1395                 case MHNNPROGSW:
1396                     vec[vecp++] = --cp;
1397                     continue;
1398
1399                 case MHNFORMSW:
1400                 case MHNPARTSW:
1401                 case MHNTYPESW:
1402                 case MHNPROGSW:
1403                 case MHNLENSW:
1404                 case MHNWIDSW:
1405                     vec[vecp++] = --cp;
1406                     if (!(cp = *args++) || *cp == '-') {
1407                         advise (NULL, "missing argument to %s", args[-2]);
1408                         return;
1409                     }
1410                     vec[vecp++] = cp;
1411                     continue;
1412             }
1413         }
1414         if (*cp == '+' || *cp == '@') {
1415             advise (NULL, "sorry, no folders allowed!");
1416             return;
1417         } else {
1418             msgs[msgp++] = cp;
1419         }
1420     }
1421
1422     vec[0] = cmd_name;
1423     vec[vecp++] = "-file";
1424     vec[vecp] = NULL;
1425     if (!msgp)
1426         msgs[msgp++] = "cur";
1427     for (msgnum = 0; msgnum < msgp; msgnum++)
1428         if (!m_convert (mp, msgs[msgnum]))
1429             return;
1430     seq_setprev (mp);
1431
1432     interrupted = 0;
1433     for (msgnum = mp->lowsel;
1434             msgnum <= mp->hghsel && !interrupted;
1435             msgnum++)
1436         if (is_selected (mp, msgnum))
1437             if (process (msgnum, cmd_name, vecp, vec)) {
1438                 unset_selected (mp, msgnum);
1439                 mp->numsel--;
1440             }
1441
1442     seq_setcur (mp, mp->hghsel);
1443 }
1444
1445
1446 static struct swit packswit[] = {
1447 #define PAFISW         0
1448     { "file name", 0 },
1449 #define PAHELP         1
1450     { "help", 0 },
1451     { NULL, 0 }
1452 };
1453
1454 static int mbx_style = MMDF_FORMAT;
1455
1456 void
1457 packcmd (char **args)
1458 {
1459     int msgp = 0, md, msgnum;
1460     char *cp, *file = NULL;
1461     char buf[BUFSIZ], *msgs[MAXARGS];
1462     struct stat st;
1463
1464     if (fmsh) {
1465         forkcmd (args, cmd_name);
1466         return;
1467     }
1468
1469     while ((cp = *args++)) {
1470         if (*cp == '-')
1471             switch (smatch (++cp, packswit)) {
1472                 case AMBIGSW:
1473                     ambigsw (cp, packswit);
1474                     return;
1475                 case UNKWNSW:
1476                     fprintf (stderr, "-%s unknown\n", cp);
1477                     return;
1478                 case PAHELP:
1479                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1480                     print_help (buf, packswit, 1);
1481                     return;
1482
1483                 case PAFISW:
1484                     if (!(file = *args++) || *file == '-') {
1485                         advise (NULL, "missing argument to %s", args[-2]);
1486                         return;
1487                     }
1488                     continue;
1489             }
1490         if (*cp == '+' || *cp == '@') {
1491             advise (NULL, "sorry, no folders allowed!");
1492             return;
1493         }
1494         else
1495             msgs[msgp++] = cp;
1496     }
1497
1498     if (!file)
1499         file = "./msgbox";
1500     file = path (file, TFILE);
1501     if (stat (file, &st) == NOTOK) {
1502         if (errno != ENOENT) {
1503             advise (file, "error on file");
1504             goto done_pack;
1505         }
1506         md = getanswer (cp = concat ("Create file \"", file, "\"? ", NULL));
1507         free (cp);
1508         if (!md)
1509             goto done_pack;
1510     }
1511
1512     if (!msgp)
1513         msgs[msgp++] = "all";
1514     for (msgnum = 0; msgnum < msgp; msgnum++)
1515         if (!m_convert (mp, msgs[msgnum]))
1516             goto done_pack;
1517     seq_setprev (mp);
1518
1519     if ((md = mbx_open (file, mbx_style, getuid (), getgid (), m_gmprot ())) == NOTOK) {
1520         advise (file, "unable to open");
1521         goto done_pack;
1522     }
1523     for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1524         if (is_selected (mp, msgnum))
1525             if (pack (file, md, msgnum) == NOTOK)
1526                 break;
1527     mbx_close (file, md);
1528
1529     if (mp->hghsel != mp->curmsg)
1530         seq_setcur (mp, mp->lowsel);
1531
1532 done_pack: ;
1533     free (file);
1534 }
1535
1536
1537 int
1538 pack (char *mailbox, int md, int msgnum)
1539 {
1540     register FILE *zp;
1541
1542     if (Msgs[msgnum].m_bboard_id == 0)
1543         readid (msgnum);
1544
1545     zp = msh_ready (msgnum, 1);
1546     return mbx_write (mailbox, md, zp, Msgs[msgnum].m_bboard_id,
1547             0L, ftell (zp), Msgs[msgnum].m_stop, 1, 1);
1548 }
1549
1550
1551 int
1552 packhak (char **args)
1553 {
1554     int result;
1555     char *cp, *file = NULL;
1556
1557     while ((cp = *args++)) {
1558         if (*cp == '-')
1559             switch (smatch (++cp, packswit)) {
1560                 case AMBIGSW:
1561                 case UNKWNSW:
1562                 case PAHELP:
1563                     return NOTOK;
1564
1565                 case PAFISW:
1566                     if (!(file = *args++) || *file == '-')
1567                         return NOTOK;
1568                     continue;
1569             }
1570         if (*cp == '+' || *cp == '@')
1571             return NOTOK;
1572     }
1573
1574     file = path (file ? file : "./msgbox", TFILE);
1575     result = access (file, F_OK) == NOTOK ? OK : NOTOK;
1576     free (file);
1577
1578     return result;
1579 }
1580
1581
1582 static struct swit pickswit[] = {
1583 #define PIANSW                0
1584     { "and", 0 },
1585 #define PIORSW                1
1586     { "or", 0 },
1587 #define PINTSW                2
1588     { "not", 0 },
1589 #define PILBSW                3
1590     { "lbrace", 0 },
1591 #define PIRBSW                4
1592     { "rbrace", 0 },
1593 #define PICCSW                5
1594     { "cc  pattern", 0 },
1595 #define PIDASW                6
1596     { "date  pattern", 0 },
1597 #define PIFRSW                7
1598     { "from  pattern", 0 },
1599 #define PISESW                8
1600     { "search  pattern", 0 },
1601 #define PISUSW                9
1602     { "subject  pattern", 0 },
1603 #define PITOSW               10
1604     { "to  pattern", 0 },
1605 #define PIOTSW               11
1606     { "-othercomponent  pattern", 15 },
1607 #define PIAFSW               12
1608     { "after date", 0 },
1609 #define PIBFSW               13
1610     { "before date", 0 },
1611 #define PIDFSW               14
1612     { "datefield field", 5 },
1613 #define PISQSW               15
1614     { "sequence name", 0 },
1615 #define PIPUSW               16
1616     { "public", 0 },
1617 #define PINPUSW              17
1618     { "nopublic", 0 },
1619 #define PIZRSW               18
1620     { "zero", 0 },
1621 #define PINZRSW              19
1622     { "nozero", 0 },
1623 #define PILISW               20
1624     { "list", 0 },
1625 #define PINLISW              21
1626     { "nolist", 0 },
1627 #define PIHELP               22
1628     { "help", 0 },
1629     { NULL, 0 }
1630 };
1631
1632
1633 void
1634 pickcmd (char **args)
1635 {
1636     int zerosw = 1, msgp = 0, seqp = 0;
1637     int vecp = 0, hi, lo, msgnum;
1638     char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1639     char *seqs[NUMATTRS], *vec[MAXARGS];
1640     register FILE *zp;
1641
1642     while ((cp = *args++)) {
1643         if (*cp == '-') {
1644             if (*++cp == '-') {
1645                 vec[vecp++] = --cp;
1646                 goto pattern;
1647             }
1648             switch (smatch (cp, pickswit)) {
1649                 case AMBIGSW:
1650                     ambigsw (cp, pickswit);
1651                     return;
1652                 case UNKWNSW:
1653                     fprintf (stderr, "-%s unknown\n", cp);
1654                     return;
1655                 case PIHELP:
1656                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1657                     print_help (buf, pickswit, 1);
1658                     return;
1659
1660                 case PICCSW:
1661                 case PIDASW:
1662                 case PIFRSW:
1663                 case PISUSW:
1664                 case PITOSW:
1665                 case PIDFSW:
1666                 case PIAFSW:
1667                 case PIBFSW:
1668                 case PISESW:
1669                     vec[vecp++] = --cp;
1670 pattern: ;
1671                     if (!(cp = *args++)) {/* allow -xyz arguments */
1672                         advise (NULL, "missing argument to %s", args[-2]);
1673                         return;
1674                     }
1675                     vec[vecp++] = cp;
1676                     continue;
1677                 case PIOTSW:
1678                     advise (NULL, "internal error!");
1679                     return;
1680                 case PIANSW:
1681                 case PIORSW:
1682                 case PINTSW:
1683                 case PILBSW:
1684                 case PIRBSW:
1685                     vec[vecp++] = --cp;
1686                     continue;
1687
1688                 case PISQSW:
1689                     if (!(cp = *args++) || *cp == '-') {
1690                         advise (NULL, "missing argument to %s", args[-2]);
1691                         return;
1692                     }
1693                     if (seqp < NUMATTRS)
1694                         seqs[seqp++] = cp;
1695                     else {
1696                         advise (NULL, "only %d sequences allowed!", NUMATTRS);
1697                         return;
1698                     }
1699                     continue;
1700                 case PIZRSW:
1701                     zerosw++;
1702                     continue;
1703                 case PINZRSW:
1704                     zerosw = 0;
1705                     continue;
1706
1707                 case PIPUSW:    /* not implemented */
1708                 case PINPUSW:
1709                 case PILISW:
1710                 case PINLISW:
1711                     continue;
1712             }
1713         }
1714         if (*cp == '+' || *cp == '@') {
1715             advise (NULL, "sorry, no folders allowed!");
1716             return;
1717         }
1718         else
1719             msgs[msgp++] = cp;
1720     }
1721     vec[vecp] = NULL;
1722
1723     if (!msgp)
1724         msgs[msgp++] = "all";
1725     for (msgnum = 0; msgnum < msgp; msgnum++)
1726         if (!m_convert (mp, msgs[msgnum]))
1727             return;
1728     seq_setprev (mp);
1729
1730     interrupted = 0;
1731     if (!pcompile (vec, NULL))
1732         return;
1733
1734     lo = mp->lowsel;
1735     hi = mp->hghsel;
1736
1737     for (msgnum = mp->lowsel;
1738             msgnum <= mp->hghsel && !interrupted;
1739             msgnum++)
1740         if (is_selected (mp, msgnum)) {
1741             zp = msh_ready (msgnum, 1);
1742             if (pmatches (zp, msgnum, fmsh ? 0L : Msgs[msgnum].m_start,
1743                         fmsh ? 0L : Msgs[msgnum].m_stop)) {
1744                 if (msgnum < lo)
1745                     lo = msgnum;
1746                 if (msgnum > hi)
1747                     hi = msgnum;
1748             }
1749             else {
1750                 unset_selected (mp, msgnum);
1751                 mp->numsel--;
1752             }
1753         }
1754
1755     if (interrupted)
1756         return;
1757
1758     mp->lowsel = lo;
1759     mp->hghsel = hi;
1760
1761     if (mp->numsel <= 0) {
1762         advise (NULL, "no messages match specification");
1763         return;
1764     }
1765
1766     seqs[seqp] = NULL;
1767     for (seqp = 0; seqs[seqp]; seqp++)
1768         if (!seq_addsel (mp, seqs[seqp], 0, zerosw))
1769             return;
1770
1771     printf ("%d hit%s\n", mp->numsel, mp->numsel == 1 ? "" : "s");
1772 }
1773
1774
1775 static struct swit replswit[] = {
1776 #define REANSW                  0
1777     { "annotate", 0 },
1778 #define RENANSW                 1
1779     { "noannotate", 0 },
1780 #define RECCSW                  2
1781     { "cc type", 0 },
1782 #define RENCCSW                 3
1783     { "nocc type", 0 },
1784 #define REDFSW                  4
1785     { "draftfolder +folder", 0 },
1786 #define REDMSW                  5
1787     { "draftmessage msg", 0 },
1788 #define RENDFSW                 6
1789     { "nodraftfolder", 0 },
1790 #define REEDTSW                 7
1791     { "editor editor", 0 },
1792 #define RENEDSW                 8
1793     { "noedit", 0 },
1794 #define REFCCSW                 9
1795     { "fcc +folder", 0 },
1796 #define REFLTSW                10
1797     { "filter filterfile", 0 },
1798 #define REFRMSW                11
1799     { "form formfile", 0 },
1800 #define REINSW                 12
1801     { "inplace", 0 },
1802 #define RENINSW                13
1803     { "noinplace", 0 },
1804 #define REQUSW                 14
1805     { "query", 0 },
1806 #define RENQUSW                15
1807     { "noquery", 0 },
1808 #define REWHTSW                16
1809     { "whatnowproc program", 0 },
1810 #define RENWTSW                17
1811     { "nowhatnow", 0 },
1812 #define REWIDSW                19
1813     { "width columns", 0 },
1814 #define REHELP                 20
1815     { "help", 0 },
1816     { NULL, 0 }
1817 };
1818
1819
1820 void
1821 replcmd (char **args)
1822 {
1823     int vecp = 1;
1824     char *cp, *msg = NULL;
1825     char buf[BUFSIZ], *vec[MAXARGS];
1826
1827     if (fmsh) {
1828         forkcmd (args, cmd_name);
1829         return;
1830     }
1831
1832     while ((cp = *args++)) {
1833         if (*cp == '-')
1834             switch (smatch (++cp, replswit)) {
1835                 case AMBIGSW:
1836                     ambigsw (cp, replswit);
1837                     return;
1838                 case UNKWNSW:
1839                     fprintf (stderr, "-%s unknown\n", cp);
1840                     return;
1841                 case REHELP:
1842                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1843                     print_help (buf, replswit, 1);
1844                     return;
1845
1846                 case REANSW:    /* not implemented */
1847                 case RENANSW:
1848                 case REINSW:
1849                 case RENINSW:
1850                     continue;
1851
1852                 case REQUSW:
1853                 case RENQUSW:
1854                 case RENDFSW:
1855                 case RENEDSW:
1856                 case RENWTSW:
1857                     vec[vecp++] = --cp;
1858                     continue;
1859
1860                 case RECCSW:
1861                 case RENCCSW:
1862                 case REEDTSW:
1863                 case REFCCSW:
1864                 case REFLTSW:
1865                 case REFRMSW:
1866                 case REWIDSW:
1867                 case REDFSW:
1868                 case REDMSW:
1869                 case REWHTSW:
1870                     vec[vecp++] = --cp;
1871                     if (!(cp = *args++) || *cp == '-') {
1872                         advise (NULL, "missing argument to %s", args[-2]);
1873                         return;
1874                     }
1875                     vec[vecp++] = cp;
1876                     continue;
1877             }
1878         if (*cp == '+' || *cp == '@') {
1879             advise (NULL, "sorry, no folders allowed!");
1880             return;
1881         }
1882         else
1883             if (msg) {
1884                 advise (NULL, "only one message at a time!");
1885                 return;
1886             }
1887             else
1888                 msg = cp;
1889     }
1890
1891     vec[0] = cmd_name;
1892     vec[vecp++] = "-file";
1893     vec[vecp] = NULL;
1894     if (!msg)
1895         msg = "cur";
1896     if (!m_convert (mp, msg))
1897         return;
1898     seq_setprev (mp);
1899
1900     if (mp->numsel > 1) {
1901         advise (NULL, "only one message at a time!");
1902         return;
1903     }
1904     process (mp->hghsel, cmd_name, vecp, vec);
1905     seq_setcur (mp, mp->hghsel);
1906 }
1907
1908
1909 static struct swit rmmswit[] = {
1910 #define RMHELP    0
1911     { "help", 0 },
1912     { NULL, 0 }
1913 };
1914
1915
1916 void
1917 rmmcmd (char **args)
1918 {
1919     int msgp = 0, msgnum;
1920     char *cp, buf[BUFSIZ], *msgs[MAXARGS];
1921
1922     while ((cp = *args++)) {
1923         if (*cp == '-')
1924             switch (smatch (++cp, rmmswit)) {
1925                 case AMBIGSW:
1926                     ambigsw (cp, rmmswit);
1927                     return;
1928                 case UNKWNSW:
1929                     fprintf (stderr, "-%s unknown\n", cp);
1930                     return;
1931                 case RMHELP:
1932                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
1933                     print_help (buf, rmmswit, 1);
1934                     return;
1935             }
1936         if (*cp == '+' || *cp == '@') {
1937             advise (NULL, "sorry, no folders allowed!");
1938             return;
1939         }
1940         else
1941             msgs[msgp++] = cp;
1942     }
1943
1944     if (!msgp)
1945         msgs[msgp++] = "cur";
1946     for (msgnum = 0; msgnum < msgp; msgnum++)
1947         if (!m_convert (mp, msgs[msgnum]))
1948             return;
1949     seq_setprev (mp);
1950
1951     rmm ();
1952 }
1953
1954
1955 static void
1956 rmm (void)
1957 {
1958     register int msgnum, vecp;
1959     register char *cp;
1960     char buffer[BUFSIZ], *vec[MAXARGS];
1961
1962     if (fmsh) {
1963         if (rmmproc) {
1964             if (mp->numsel > MAXARGS - 1) {
1965                 advise (NULL, "more than %d messages for %s exec",
1966                         MAXARGS - 1, rmmproc);
1967                 return;
1968             }
1969             vecp = 0;
1970             for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1971                 if (is_selected (mp, msgnum))
1972                     vec[vecp++] = getcpy (m_name (msgnum));
1973             vec[vecp] = NULL;
1974             forkcmd (vec, rmmproc);
1975             for (vecp = 0; vec[vecp]; vecp++)
1976                 free (vec[vecp]);
1977         }
1978         else
1979             for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1980                 if (is_selected (mp, msgnum)) {
1981                     strncpy (buffer, m_backup (cp = m_name (msgnum)), sizeof(buffer));
1982                     if (rename (cp, buffer) == NOTOK)
1983                         admonish (buffer, "unable to rename %s to", cp);
1984                 }
1985     }
1986
1987     for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
1988         if (is_selected (mp, msgnum)) {
1989             set_deleted (mp, msgnum);
1990             unset_exists (mp, msgnum);
1991         }
1992
1993     if ((mp->nummsg -= mp->numsel) <= 0) {
1994         if (fmsh)
1995             admonish (NULL, "no messages remaining in +%s", fmsh);
1996         else
1997             admonish (NULL, "no messages remaining in %s", mp->foldpath);
1998         mp->lowmsg = mp->hghmsg = mp->nummsg = 0;
1999     }
2000     if (mp->lowsel == mp->lowmsg) {
2001         for (msgnum = mp->lowmsg + 1; msgnum <= mp->hghmsg; msgnum++)
2002             if (does_exist (mp, msgnum))
2003                 break;
2004         mp->lowmsg = msgnum;
2005     }
2006     if (mp->hghsel == mp->hghmsg) {
2007         for (msgnum = mp->hghmsg - 1; msgnum >= mp->lowmsg; msgnum--)
2008             if (does_exist (mp, msgnum))
2009                 break;
2010         mp->hghmsg = msgnum;
2011     }
2012
2013     mp->msgflags |= MODIFIED;
2014     modified++;
2015 }
2016
2017
2018 static struct swit scanswit[] = {
2019 #define SCCLR              0
2020     { "clear", 0 },
2021 #define SCNCLR             1
2022     { "noclear", 0 },
2023 #define SCFORM             2
2024     { "form formatfile", 0 },
2025 #define SCFMT              3
2026     { "format string", 5 },
2027 #define SCHEAD             4
2028     { "header", 0 },
2029 #define SCNHEAD            5
2030     { "noheader", 0 },
2031 #define SCWID              6
2032     { "width columns", 0 },
2033 #define SCHELP             7
2034     { "help", 0 },
2035     { NULL, 0 }
2036 };
2037
2038
2039 void
2040 scancmd (char **args)
2041 {
2042 #define equiv(a,b)      (a ? b && !strcmp (a, b) : !b)
2043
2044     int clearsw = 0, headersw = 0, width = 0, msgp = 0;
2045     int msgnum, optim, state;
2046     char *cp, *form = NULL, *format = NULL;
2047     char buf[BUFSIZ], *nfs, *msgs[MAXARGS];
2048     register FILE *zp;
2049     static int s_optim = 0;
2050     static char *s_form = NULL, *s_format = NULL;
2051
2052     while ((cp = *args++)) {
2053         if (*cp == '-')
2054             switch (smatch (++cp, scanswit)) {
2055                 case AMBIGSW:
2056                     ambigsw (cp, scanswit);
2057                     return;
2058                 case UNKWNSW:
2059                     fprintf (stderr, "-%s unknown\n", cp);
2060                     return;
2061                 case SCHELP:
2062                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
2063                     print_help (buf, scanswit, 1);
2064                     return;
2065
2066                 case SCCLR:
2067                     clearsw++;
2068                     continue;
2069                 case SCNCLR:
2070                     clearsw = 0;
2071                     continue;
2072                 case SCHEAD:
2073                     headersw++;
2074                     continue;
2075                 case SCNHEAD:
2076                     headersw = 0;
2077                     continue;
2078                 case SCFORM:
2079                     if (!(form = *args++) || *form == '-') {
2080                         advise (NULL, "missing argument to %s", args[-2]);
2081                         return;
2082                     }
2083                     format = NULL;
2084                     continue;
2085                 case SCFMT:
2086                     if (!(format = *args++) || *format == '-') {
2087                         advise (NULL, "missing argument to %s", args[-2]);
2088                         return;
2089                     }
2090                     form = NULL;
2091                     continue;
2092                 case SCWID:
2093                     if (!(cp = *args++) || *cp == '-') {
2094                         advise (NULL, "missing argument to %s", args[-2]);
2095                         return;
2096                     }
2097                     width = atoi (cp);
2098                     continue;
2099             }
2100         if (*cp == '+' || *cp == '@') {
2101             advise (NULL, "sorry, no folders allowed!");
2102             return;
2103         }
2104         else
2105             msgs[msgp++] = cp;
2106     }
2107
2108     if (!msgp)
2109         msgs[msgp++] = "all";
2110     for (msgnum = 0; msgnum < msgp; msgnum++)
2111         if (!m_convert (mp, msgs[msgnum]))
2112             return;
2113     seq_setprev (mp);
2114
2115     /* Get new format string */
2116     nfs = new_fs (form, format, FORMAT);
2117
2118     /* force scansbr to (re)compile format */
2119     if (scanl) {
2120         free (scanl);
2121         scanl = NULL;
2122     }
2123
2124     if (s_optim == 0) {
2125         s_optim = optim = 1;
2126         s_form = form ? getcpy (form) : NULL;
2127         s_format = format ? getcpy (format) : NULL;
2128
2129     }
2130     else
2131         optim = equiv (s_form, form) && equiv (s_format, format);
2132
2133     interrupted = 0;
2134     for (msgnum = mp->lowsel;
2135             msgnum <= mp->hghsel && !interrupted;
2136             msgnum++)
2137         if (is_selected (mp, msgnum)) {
2138             if (optim && Msgs[msgnum].m_scanl)
2139                 printf ("%s", Msgs[msgnum].m_scanl);
2140             else {
2141
2142                 zp = msh_ready (msgnum, 0);
2143                 switch (state = scan (zp, msgnum, 0, nfs, width,
2144                         msgnum == mp->curmsg,
2145                         is_unseen (mp, msgnum),
2146                         headersw ? (fmsh ? fmsh : mp->foldpath) : NULL,
2147                         fmsh ? 0L : (long) (Msgs[msgnum].m_stop - Msgs[msgnum].m_start),
2148                         1)) {
2149                     case SCNMSG:
2150                     case SCNENC:
2151                     case SCNERR:
2152                         if (optim)
2153                             Msgs[msgnum].m_scanl = getcpy (scanl);
2154                         break;
2155
2156                     default:
2157                         advise (NULL, "scan() botch (%d)", state);
2158                         return;
2159
2160                     case SCNEOF:
2161                         printf ("%*d  empty\n", DMAXFOLDER, msgnum);
2162                         break;
2163                     }
2164             }
2165             headersw = 0;
2166         }
2167
2168     if (clearsw)
2169         clear_screen ();
2170 }
2171
2172
2173 static struct swit showswit[] = {
2174 #define SHDRAFT               0
2175     { "draft", 5 },
2176 #define SHFORM                1
2177     { "form formfile", 4 },
2178 #define SHPROG                2
2179     { "moreproc program", 4 },
2180 #define SHNPROG               3
2181     { "nomoreproc", 3 },
2182 #define SHLEN                 4
2183     { "length lines", 4 },
2184 #define SHWID                 5
2185     { "width columns", 4 },
2186 #define SHSHOW                6
2187     { "showproc program", 4 },
2188 #define SHNSHOW               7
2189     { "noshowproc", 3 },
2190 #define SHHEAD                8
2191     { "header", 4 },
2192 #define SHNHEAD               9
2193     { "noheader", 3 },
2194 #define SHHELP               10
2195     { "help", 0 },
2196     { NULL, 0 }
2197 };
2198
2199
2200 void
2201 showcmd (char **args)
2202 {
2203     int headersw = 1, nshow = 0, msgp = 0, vecp = 1;
2204     int mhl = 0, seqnum = -1, mode = 0, i, msgnum;
2205     char *cp, *proc = showproc, buf[BUFSIZ];
2206     char *msgs[MAXARGS], *vec[MAXARGS];
2207
2208     if (!mh_strcasecmp (cmd_name, "next"))
2209         mode = 1;
2210     else
2211         if (!mh_strcasecmp (cmd_name, "prev"))
2212             mode = -1;
2213     while ((cp = *args++)) {
2214         if (*cp == '-')
2215             switch (i = smatch (++cp, showswit)) {
2216                 case AMBIGSW:
2217                     ambigsw (cp, showswit);
2218                     return;
2219                 case UNKWNSW:
2220                 case SHNPROG:
2221                     vec[vecp++] = --cp;
2222                     continue;
2223                 case SHHELP:
2224                     snprintf (buf, sizeof(buf), "%s %s[switches] [switches for showproc]",
2225                             cmd_name, mode ? NULL : "[msgs] ");
2226                     print_help (buf, showswit, 1);
2227                     return;
2228
2229                 case SHFORM:
2230                 case SHPROG:
2231                 case SHLEN:
2232                 case SHWID:
2233                     vec[vecp++] = --cp;
2234                     if (!(cp = *args++) || *cp == '-') {
2235                         advise (NULL, "missing argument to %s", args[-2]);
2236                         return;
2237                     }
2238                     vec[vecp++] = cp;
2239                     continue;
2240                 case SHHEAD:
2241                     headersw++;
2242                     continue;
2243                 case SHNHEAD:
2244                     headersw = 0;
2245                     continue;
2246                 case SHSHOW:
2247                     if (!(proc = *args++) || *proc == '-') {
2248                         advise (NULL, "missing argument to %s", args[-2]);
2249                         return;
2250                     }
2251                     nshow = 0;
2252                     continue;
2253                 case SHNSHOW:
2254                     nshow++;
2255                     continue;
2256
2257                 case SHDRAFT:
2258                     advise (NULL, "sorry, -%s not allowed!", showswit[i].sw);
2259                     return;
2260             }
2261         if (*cp == '+' || *cp == '@') {
2262             advise (NULL, "sorry, no folders allowed!");
2263             return;
2264         }
2265         else
2266             if (mode) {
2267                 fprintf (stderr,
2268                         "usage: %s [switches] [switches for showproc]\n",
2269                         cmd_name);
2270                 return;
2271             }
2272             else
2273                 msgs[msgp++] = cp;
2274     }
2275     vec[vecp] = NULL;
2276
2277     if (!msgp)
2278         msgs[msgp++] = mode > 0 ? "next" : mode < 0 ? "prev" : "cur";
2279     for (msgnum = 0; msgnum < msgp; msgnum++)
2280         if (!m_convert (mp, msgs[msgnum]))
2281             return;
2282     seq_setprev (mp);
2283
2284     if (!nshow && !getenv ("NOMHNPROC"))
2285         for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
2286             if (is_selected (mp, msgnum) && is_nontext (msgnum)) {
2287                 proc = showmimeproc;
2288                 vec[vecp++] = "-file";
2289                 vec[vecp] = NULL;
2290                 goto finish;
2291             }
2292
2293     if (nshow)
2294         proc = catproc;
2295     else
2296         if (strcmp (showproc, "mhl") == 0) {
2297             proc = mhlproc;
2298             mhl++;
2299         }
2300
2301 finish: ;
2302     seqnum = seq_getnum (mp, "unseen");
2303     vec[0] = r1bindex (proc, '/');
2304     if (mhl) {
2305         msgp = vecp;
2306         for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
2307             if (is_selected (mp, msgnum)) {
2308                 vec[vecp++] = getcpy (m_name (msgnum));
2309                 if (seqnum != -1)
2310                     seq_delmsg (mp, "unseen", msgnum);
2311             }
2312         vec[vecp] = NULL;
2313         if (mp->numsel == 1 && headersw)
2314             show (mp->lowsel);
2315         mhlsbr (vecp, vec, mhl_action);
2316         m_eomsbr ((int (*)()) 0);
2317         while (msgp < vecp)
2318             free (vec[msgp++]);
2319     } else {
2320         interrupted = 0;
2321         for (msgnum = mp->lowsel;
2322                 msgnum <= mp->hghsel && !interrupted;
2323                 msgnum++)
2324             if (is_selected (mp, msgnum)) {
2325                 switch (ask (msgnum)) {
2326                     case NOTOK: /* QUIT */
2327                         break;
2328
2329                     case OK:    /* INTR */
2330                         continue;
2331
2332                     default:
2333                         if (mp->numsel == 1 && headersw)
2334                             show (msgnum);
2335                         if (nshow)
2336                             copy_message (msgnum, stdout);
2337                         else
2338                             process (msgnum, proc, vecp, vec);
2339
2340                         if (seqnum != -1)
2341                             seq_delmsg (mp, "unseen", msgnum);
2342                         continue;
2343                 }
2344                 break;
2345             }
2346     }
2347
2348     seq_setcur (mp, mp->hghsel);
2349 }
2350
2351
2352 static void
2353 show (int msgnum)
2354 {
2355     if (Msgs[msgnum].m_bboard_id == 0)
2356         readid (msgnum);
2357
2358     printf ("(Message %d", msgnum);
2359     if (Msgs[msgnum].m_bboard_id > 0)
2360         printf (", %s: %d", BBoard_ID, Msgs[msgnum].m_bboard_id);
2361     printf (")\n");
2362 }
2363
2364
2365
2366 static int
2367 eom_action (int c)
2368 {
2369     return (ftell (mhlfp) >= Msgs[mhlnum].m_stop);
2370 }
2371
2372
2373 static FILE *
2374 mhl_action (char *name)
2375 {
2376     int msgnum;
2377
2378     if ((msgnum = m_atoi (name)) < mp->lowmsg
2379             || msgnum > mp->hghmsg
2380             || !does_exist (mp, msgnum))
2381         return NULL;
2382     mhlnum = msgnum;
2383
2384     mhlfp = msh_ready (msgnum, 1);
2385     if (!fmsh)
2386         m_eomsbr (eom_action);
2387
2388     return mhlfp;
2389 }
2390
2391
2392
2393 static int
2394 ask (int msgnum)
2395 {
2396     char buf[BUFSIZ];
2397
2398     if (mp->numsel == 1 || !interactive || redirected)
2399         return DONE;
2400
2401     if (SOprintf ("Press <return> to list \"%d\"...", msgnum)) {
2402         if (mp->lowsel != msgnum)
2403             printf ("\n\n\n");
2404         printf ("Press <return> to list \"%d\"...", msgnum);
2405     }
2406     fflush (stdout);
2407     buf[0] = 0;
2408
2409 #ifndef BSD42
2410     read (fileno (stdout), buf, sizeof buf);
2411 #else /* BSD42 */
2412     switch (setjmp (sigenv)) {
2413         case OK:
2414             should_intr = 1;
2415             read (fileno (stdout), buf, sizeof buf);/* fall... */
2416
2417         default:
2418             should_intr = 0;
2419             break;
2420     }
2421 #endif /* BSD42 */
2422
2423     if (strchr(buf, '\n') == NULL)
2424         putchar ('\n');
2425
2426     if (told_to_quit) {
2427         told_to_quit = interrupted = 0;
2428         return NOTOK;
2429     }
2430     if (interrupted) {
2431         interrupted = 0;
2432         return OK;
2433     }
2434
2435     return DONE;
2436 }
2437
2438
2439 #include <h/mime.h>
2440
2441 static int
2442 is_nontext (int msgnum)
2443 {
2444     int result, state;
2445     unsigned char *bp, *dp;
2446     char *cp;
2447     char buf[BUFSIZ], name[NAMESZ];
2448     FILE *fp;
2449
2450     if (Msgs[msgnum].m_flags & MHNCHK)
2451         return (Msgs[msgnum].m_flags & MHNYES);
2452     Msgs[msgnum].m_flags |= MHNCHK;
2453
2454     fp = msh_ready (msgnum, 1);
2455
2456     for (state = FLD;;)
2457         switch (state = m_getfld (state, name, buf, sizeof buf, fp)) {
2458         case FLD:
2459         case FLDPLUS:
2460         case FLDEOF:
2461             /*
2462              * Check Content-Type field
2463              */
2464             if (!mh_strcasecmp (name, TYPE_FIELD)) {
2465                 int passno;
2466                 char c;
2467
2468                 cp = add (buf, NULL);
2469                 while (state == FLDPLUS) {
2470                     state = m_getfld (state, name, buf, sizeof buf, fp);
2471                     cp = add (buf, cp);
2472                 }
2473                 bp = cp;
2474                 passno = 1;
2475
2476 again:
2477                 for (; isspace (*bp); bp++)
2478                     continue;
2479                 if (*bp == '(') {
2480                     int i;
2481
2482                     for (bp++, i = 0;;) {
2483                         switch (*bp++) {
2484                         case '\0':
2485 invalid:
2486                             result = 0;
2487                             goto out;
2488                         case '\\':
2489                             if (*bp++ == '\0')
2490                                 goto invalid;
2491                             continue;
2492                         case '(':
2493                             i++;
2494                             /* and fall... */
2495                         default:
2496                             continue;
2497                         case ')':
2498                             if (--i < 0)
2499                                 break;
2500                             continue;
2501                         }
2502                         break;
2503                     }
2504                 }
2505                 if (passno == 2) {
2506                     if (*bp != '/')
2507                         goto invalid;
2508                     bp++;
2509                     passno = 3;
2510                     goto again;
2511                 }
2512                 for (dp = bp; istoken (*dp); dp++)
2513                     continue;
2514                 c = *dp;
2515                 *dp = '\0';
2516                 if (!*bp)
2517                     goto invalid;
2518                 if (passno > 1) {
2519                     if ((result = (mh_strcasecmp (bp, "plain") != 0)))
2520                         goto out;
2521                     *dp = c;
2522                     for (dp++; isspace (*dp); dp++)
2523                         continue;
2524                     if (*dp) {
2525                         if ((result = !uprf (dp, "charset")))
2526                             goto out;
2527                         dp += sizeof "charset" - 1;
2528                         while (isspace (*dp))
2529                             dp++;
2530                         if (*dp++ != '=')
2531                             goto invalid;
2532                         while (isspace (*dp))
2533                             dp++;
2534                         if (*dp == '"') {
2535                             if ((bp = strchr(++dp, '"')))
2536                                 *bp = '\0';
2537                         } else {
2538                             for (bp = dp; *bp; bp++)
2539                                 if (isspace (*bp)) {
2540                                     *bp = '\0';
2541                                     break;
2542                                 }
2543                         }
2544                     } else {
2545                         /* Default character set */
2546                         dp = "US-ASCII";
2547                     }
2548                     /* Check the character set */
2549                     result = !check_charset (dp, strlen (dp));
2550                 } else {
2551                     if (!(result = (mh_strcasecmp (bp, "text") != 0))) {
2552                         *dp = c;
2553                         bp = dp;
2554                         passno = 2;
2555                         goto again;
2556                     }
2557                 }
2558 out:
2559                 free (cp);
2560                 if (result) {
2561                     Msgs[msgnum].m_flags |= MHNYES;
2562                     return result;
2563                 }
2564                 break;
2565             }
2566
2567             /*
2568              * Check Content-Transfer-Encoding field
2569              */
2570             if (!mh_strcasecmp (name, ENCODING_FIELD)) {
2571                 cp = add (buf, NULL);
2572                 while (state == FLDPLUS) {
2573                     state = m_getfld (state, name, buf, sizeof buf, fp);
2574                     cp = add (buf, cp);
2575                 }
2576                 for (bp = cp; isspace (*bp); bp++)
2577                     continue;
2578                 for (dp = bp; istoken (*dp); dp++)
2579                     continue;
2580                 *dp = '\0';
2581                 result = (mh_strcasecmp (bp, "7bit")
2582                        && mh_strcasecmp (bp, "8bit")
2583                        && mh_strcasecmp (bp, "binary"));
2584
2585                 free (cp);
2586                 if (result) {
2587                     Msgs[msgnum].m_flags |= MHNYES;
2588                     return result;
2589                 }
2590                 break;
2591             }
2592
2593             /*
2594              * Just skip the rest of this header
2595              * field and go to next one.
2596              */
2597             while (state == FLDPLUS)
2598                 state = m_getfld (state, name, buf, sizeof(buf), fp);
2599             break;
2600
2601             /*
2602              * We've passed the message header,
2603              * so message is just text.
2604              */
2605         default:
2606             return 0;
2607         }
2608 }
2609
2610
2611 static struct swit sortswit[] = {
2612 #define SODATE               0
2613     { "datefield field", 0 },
2614 #define SOSUBJ               1
2615     { "textfield field", 0 },
2616 #define SONSUBJ              2
2617     { "notextfield", 0 },
2618 #define SOLIMT               3
2619     { "limit days", 0 },
2620 #define SONLIMT              4
2621     { "nolimit", 0 },
2622 #define SOVERB               5
2623     { "verbose", 0 },
2624 #define SONVERB              6
2625     { "noverbose", 0 },
2626 #define SOHELP               7
2627     { "help", 0 },
2628     { NULL, 0 }
2629 };
2630
2631
2632 void
2633 sortcmd (char **args)
2634 {
2635     int msgp = 0, msgnum;
2636     char *cp, *datesw = NULL, *subjsw = NULL;
2637     char buf[BUFSIZ], *msgs[MAXARGS];
2638     struct tws tb;
2639
2640     if (fmsh) {
2641         forkcmd (args, cmd_name);
2642         return;
2643     }
2644
2645     while ((cp = *args++)) {
2646         if (*cp == '-')
2647             switch (smatch (++cp, sortswit)) {
2648                 case AMBIGSW:
2649                     ambigsw (cp, sortswit);
2650                     return;
2651                 case UNKWNSW:
2652                     fprintf (stderr, "-%s unknown\n", cp);
2653                     return;
2654                 case SOHELP:
2655                     snprintf (buf, sizeof(buf), "%s [msgs] [switches]", cmd_name);
2656                     print_help (buf, sortswit, 1);
2657                     return;
2658
2659                 case SODATE:
2660                     if (datesw) {
2661                         advise (NULL, "only one date field at a time!");
2662                         return;
2663                     }
2664                     if (!(datesw = *args++) || *datesw == '-') {
2665                         advise (NULL, "missing argument to %s", args[-2]);
2666                         return;
2667                     }
2668                     continue;
2669
2670                 case SOSUBJ:
2671                     if (subjsw) {
2672                         advise (NULL, "only one text field at a time!");
2673                         return;
2674                     }
2675                     if (!(subjsw = *args++) || *subjsw == '-') {
2676                         advise (NULL, "missing argument to %s", args[-2]);
2677                         return;
2678                     }
2679                     continue;
2680                 case SONSUBJ:
2681                     subjsw = (char *)0;
2682                     continue;
2683
2684                 case SOLIMT:            /* too hard */
2685                     if (!(cp = *args++) || *cp == '-') {
2686                         advise (NULL, "missing argument to %s", args[-2]);
2687                         return;
2688                     }
2689                 case SONLIMT:
2690                 case SOVERB:            /* not implemented */
2691                 case SONVERB:
2692                     continue;
2693             }
2694         if (*cp == '+' || *cp == '@') {
2695             advise (NULL, "sorry, no folders allowed!");
2696             return;
2697         }
2698         else
2699             msgs[msgp++] = cp;
2700     }
2701
2702     if (!msgp)
2703         msgs[msgp++] = "all";
2704     if (!datesw)
2705         datesw = "Date";
2706     for (msgnum = 0; msgnum < msgp; msgnum++)
2707         if (!m_convert (mp, msgs[msgnum]))
2708             return;
2709     seq_setprev (mp);
2710
2711     twscopy (&tb, dlocaltimenow ());
2712
2713     for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
2714         if (Msgs[msgnum].m_scanl) {
2715             free (Msgs[msgnum].m_scanl);
2716             Msgs[msgnum].m_scanl = NULL;
2717         }
2718         if (is_selected (mp, msgnum)) {
2719             if (get_fields (datesw, subjsw, msgnum, &Msgs[msgnum]))
2720                 twscopy (&Msgs[msgnum].m_tb,
2721                         msgnum != mp->lowsel ? &Msgs[msgnum - 1].m_tb : &tb);
2722         }
2723         else                    /* m_scaln is already NULL */
2724             twscopy (&Msgs[msgnum].m_tb, &tb);
2725         Msgs[msgnum].m_stats = mp->msgstats[msgnum - mp->lowoff];
2726         if (mp->curmsg == msgnum)
2727             Msgs[msgnum].m_stats |= CUR;
2728     }
2729
2730     qsort ((char *) &Msgs[mp->lowsel], mp->hghsel - mp->lowsel + 1,
2731            sizeof(struct Msg), (qsort_comp) (subjsw ? subsort : msgsort));
2732
2733     for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
2734         if (subjsw && Msgs[msgnum].m_scanl) {
2735             free (Msgs[msgnum].m_scanl);        /* from subjsort */
2736             Msgs[msgnum].m_scanl = NULL;
2737         }
2738         mp->msgstats[msgnum - mp->lowoff] = Msgs[msgnum].m_stats & ~CUR;
2739         if (Msgs[msgnum].m_stats & CUR)
2740             seq_setcur (mp, msgnum);
2741     }
2742
2743     mp->msgflags |= MODIFIED;
2744     modified++;
2745 }
2746
2747
2748 /*
2749  * get_fields - parse message, and get date and subject if needed.
2750  * We'll use the msgp->m_tb tws struct for the date, and overload
2751  * the msgp->m_scanl field with our subject string.
2752  */
2753 static int
2754 get_fields (char *datesw, char *subjsw, int msgnum, struct Msg *msgp)
2755 {
2756     int state, gotdate = 0;
2757     char *bp, buf[BUFSIZ], name[NAMESZ];
2758     struct tws *tw = (struct tws *) 0;
2759     register FILE *zp;
2760
2761     zp = msh_ready (msgnum, 0);
2762     for (state = FLD;;) {
2763         switch (state = m_getfld (state, name, buf, sizeof buf, zp)) {
2764             case FLD:
2765             case FLDEOF:
2766             case FLDPLUS:
2767                 if (!mh_strcasecmp (name, datesw)) {
2768                     bp = getcpy (buf);
2769                     while (state == FLDPLUS) {
2770                         state = m_getfld (state, name, buf, sizeof buf, zp);
2771                         bp = add (buf, bp);
2772                     }
2773                     if ((tw = dparsetime (bp)) == NULL)
2774                         admonish (NULL,
2775                                 "unable to parse %s field in message %d",
2776                                 datesw, msgnum);
2777                     else
2778                         twscopy (&(msgp->m_tb), tw);
2779                     free (bp);
2780                     if (!subjsw)        /* not using this, or already done */
2781                         break;          /* all done! */
2782                     gotdate++;
2783                 }
2784                 else if (subjsw && !mh_strcasecmp(name, subjsw)) {
2785                     bp = getcpy (buf);
2786                     while (state == FLDPLUS) {
2787                         state = m_getfld (state, name, buf, sizeof buf, zp);
2788                         bp = add (buf, bp);
2789                     }
2790                     msgp->m_scanl = sosmash(subjsw, bp);
2791                     if (gotdate)
2792                         break;          /* date done so we're done */
2793                     else
2794                         subjsw = (char *)0;/* subject done, need date */
2795                 } else {
2796                     while (state == FLDPLUS)    /* flush this one */
2797                         state = m_getfld (state, name, buf, sizeof buf, zp);
2798                 }
2799                 continue;
2800
2801             case BODY:
2802             case BODYEOF:
2803             case FILEEOF:
2804                 break;
2805
2806             case LENERR:
2807             case FMTERR:
2808                 admonish (NULL, "format error in message %d", msgnum);
2809                 if (msgp->m_scanl) {    /* this might need free'd */
2810                     free (msgp->m_scanl); /* probably can't use subj anyway */
2811                     msgp->m_scanl = NULL;
2812                 }
2813                 return NOTOK;
2814
2815             default:
2816                 adios (NULL, "internal error -- you lose");
2817         }
2818         break;
2819     }
2820     if (tw)
2821         return OK;      /* not an error if subj not found */
2822
2823     admonish (NULL, "no %s field in message %d", datesw, msgnum);
2824     return NOTOK;       /* NOTOK means use some other date */
2825 }
2826
2827
2828 /*
2829  * sort routines
2830  */
2831
2832 static int
2833 msgsort (struct Msg *a, struct Msg *b)
2834 {
2835     return twsort (&a->m_tb, &b->m_tb);
2836 }
2837
2838
2839 static int
2840 subsort (struct Msg *a, struct Msg *b)
2841 {
2842         register int i;
2843
2844         if (a->m_scanl && b->m_scanl)
2845             if ((i = strcmp (a->m_scanl, b->m_scanl)))
2846                 return (i);
2847
2848         return twsort (&a->m_tb, &b->m_tb);
2849 }
2850
2851
2852 /*
2853  * try to make the subject "canonical": delete leading "re:", everything
2854  * but letters & smash letters to lower case.
2855  */
2856 static char *
2857 sosmash (char *subj, char *s)
2858 {
2859     register char *cp, *dp;
2860     register unsigned char c;
2861
2862     if (s) {
2863         cp = s;
2864         dp = s; /* dst pointer */
2865         if (!mh_strcasecmp (subj, "subject"))
2866             while ((c = *cp)) {
2867                 if (! isspace(c)) {
2868                     if(uprf(cp, "re:"))
2869                         cp += 2;
2870                     else {
2871                         if (isalnum(c))
2872                             *dp++ = isupper(c) ? tolower(c) : c;
2873                         break;
2874                     }
2875                 }
2876                 cp++;
2877             }
2878         while ((c = *cp++)) {
2879             if (isalnum(c))
2880                 *dp++ = isupper(c) ? tolower(c) : c;
2881
2882         }
2883         *dp = '\0';
2884     }
2885     return s;
2886 }
2887
2888
2889 static int
2890 process (int msgnum, char *proc, int vecp, char **vec)
2891 {
2892     int child_id, status;
2893     char tmpfil[BUFSIZ];
2894     FILE *out;
2895     char *cp;
2896
2897     if (fmsh) {
2898         strncpy (tmpfil, m_name (msgnum), sizeof(tmpfil));
2899         context_del (pfolder);
2900         context_replace (pfolder, fmsh);/* update current folder   */
2901         seq_save (mp);
2902         context_save ();                /* save the context file   */
2903         goto ready;
2904     }
2905
2906     cp = m_mktemp(invo_name, NULL, &out);
2907     if (cp == NULL) {
2908         /* Try again, but try to create under /tmp */
2909         int olderr = errno;
2910         cp = m_mktemp2(NULL, invo_name, NULL, &out);
2911         if (cp == NULL) {
2912             errno = olderr;
2913             advise (NULL, "unable to create temporary file");
2914             return NOTOK;
2915         }
2916     }
2917     copy_message (msgnum, out);
2918     fclose (out);
2919     strncpy(tmpfil, cp, sizeof(tmpfil));
2920
2921 ready: ;
2922     fflush (stdout);
2923     switch (child_id = fork ()) {
2924         case NOTOK:
2925             advise ("fork", "unable to");
2926             status = NOTOK;
2927             break;
2928
2929         case OK:
2930             closefds (3);
2931             SIGNAL (SIGINT, istat);
2932             SIGNAL (SIGQUIT, qstat);
2933
2934             vec[vecp++] = tmpfil;
2935             vec[vecp] = NULL;
2936
2937             execvp (proc, vec);
2938             fprintf (stderr, "unable to exec ");
2939             perror (proc);
2940             _exit (1);
2941
2942         default:
2943             status = pidXwait (child_id, NULL);
2944             break;
2945     }
2946
2947     if (!fmsh)
2948         unlink (tmpfil);
2949     return status;
2950 }
2951
2952
2953 static void
2954 copy_message (int msgnum, FILE *out)
2955 {
2956     long pos;
2957     static char buffer[BUFSIZ];
2958     register FILE *zp;
2959
2960     zp = msh_ready (msgnum, 1);
2961     if (fmsh) {
2962         while (fgets (buffer, sizeof buffer, zp) != NULL) {
2963             fputs (buffer, out);
2964             if (interrupted && out == stdout)
2965                 break;
2966         }
2967     }
2968     else {
2969         pos = ftell (zp);
2970         while (fgets (buffer, sizeof buffer, zp) != NULL
2971                 && pos < Msgs[msgnum].m_stop) {
2972             fputs (buffer, out);
2973             pos += (long) strlen (buffer);
2974             if (interrupted && out == stdout)
2975                 break;
2976         }
2977     }
2978 }
2979
2980
2981 static void
2982 copy_digest (int msgnum, FILE *out)
2983 {
2984     char c;
2985     long pos = 0L;
2986     static char buffer[BUFSIZ];
2987     register FILE *zp;
2988
2989     c = '\n';
2990     zp = msh_ready (msgnum, 1);
2991     if (!fmsh)
2992         pos = ftell (zp);
2993     while (fgets (buffer, sizeof buffer, zp) != NULL
2994             && !fmsh && pos < Msgs[msgnum].m_stop) {
2995         if (c == '\n' && *buffer == '-')
2996             fputc (' ', out);
2997         fputs (buffer, out);
2998         c = buffer[strlen (buffer) - 1];
2999         if (!fmsh)
3000             pos += (long) strlen (buffer);
3001         if (interrupted && out == stdout)
3002             break;
3003     }
3004 }