diplodocus.org Git - nmh/blob - uip/fmttest.c

   1 /* fmttest.c -- A program to help test and debug format instructions
   2  *
   3  * This code is Copyright (c) 2012, by the authors of nmh.  See the
   4  * COPYRIGHT file in the root directory of the nmh distribution for
   5  * complete copyright information.
   6  */
   7
   8 #include "h/mh.h"
   9 #include "sbr/brkstring.h"
  10 #include "sbr/ambigsw.h"
  11 #include "sbr/path.h"
  12 #include "sbr/print_version.h"
  13 #include "sbr/print_help.h"
  14 #include "sbr/seq_getnum.h"
  15 #include "sbr/error.h"
  16 #include "h/fmt_scan.h"
  17 #include "h/fmt_compile.h"
  18 #include "h/utils.h"
  19 #include "h/scansbr.h"
  20 #include "h/addrsbr.h"
  21 #include "h/done.h"
  22 #include "sbr/m_maildir.h"
  23 #include "sbr/terminal.h"
  24
  25 #define FMTTEST_SWITCHES \
  26     X("form formatfile", 0, FORMSW) \
  27     X("format string", 5, FMTSW) \
  28     X("address", 0, ADDRSW) \
  29     X("raw", 0, RAWSW) \
  30     X("date", 0, DATESW) \
  31     X("message", 0, MESSAGESW) \
  32     X("file", 0, FILESW) \
  33     X("nofile", 0, NFILESW) \
  34     X("-component-name component-text", 0, OTHERSW) \
  35     X("dupaddrs", 0, DUPADDRSW) \
  36     X("nodupaddrs", 0, NDUPADDRSW) \
  37     X("ccme", 0, CCMESW) \
  38     X("noccme", 0, NCCMESW) \
  39     X("outsize size-in-characters", 0, OUTSIZESW) \
  40     X("width column-width", 0, WIDTHSW) \
  41     X("msgnum number", 0, MSGNUMSW) \
  42     X("msgcur flag", 0, MSGCURSW) \
  43     X("msgsize size", 0, MSGSIZESW) \
  44     X("unseen flag", 0, UNSEENSW) \
  45     X("dump", 0, DUMPSW) \
  46     X("nodump", 0, NDUMPSW) \
  47     X("trace", 0, TRACESW) \
  48     X("notrace", 0, NTRACESW) \
  49     X("version", 0, VERSIONSW) \
  50     X("help", 0, HELPSW) \
  51
  52 #define X(sw, minchars, id) id,
  53 DEFINE_SWITCH_ENUM(FMTTEST);
  54 #undef X
  55
  56 #define X(sw, minchars, id) { sw, minchars, id },
  57 DEFINE_SWITCH_ARRAY(FMTTEST, switches);
  58 #undef X
  59
  60 /*
  61  * An array containing labels used for branch instructions
  62  */
  63
  64 static struct format **lvec = NULL;
  65 static int lused = 0;
  66 static int lallocated = 0;
  67
  68 enum mode_t { MESSAGE, ADDRESS, DATE, RAW };
  69 #define DEFADDRFORMAT "%<{error}%{error}: %{text}%|%(putstr(proper{text}))%>"
  70 #define DEFDATEFORMAT "%<(nodate{text})error: %{text}%|%(putstr(pretty{text}))%>"
  71
  72 /*
  73  * Context structure used by the tracing routines
  74  */
  75
  76 struct trace_context {
  77     int num;
  78     char *str;
  79     char *outbuf;
  80 };
  81
  82 /*
  83  * static prototypes
  84  */
  85 static void fmt_dump (char *, struct format *);
  86 static void dumpone(struct format *);
  87 static void initlabels(struct format *);
  88 static int findlabel(struct format *);
  89 static void assignlabel(struct format *);
  90 static char *f_typestr(int);
  91 static char *c_typestr(int);
  92 static char *c_flagsstr(int);
  93 static void litputs(const char *);
  94 static void litputc(char);
  95 static void process_addresses(struct format *, struct msgs_array *,
  96                               charstring_t, int, int *,
  97                               struct fmt_callbacks *);
  98 static void process_raw(struct format *, struct msgs_array *, charstring_t,
  99                         int, int *, struct fmt_callbacks *);
 100 static void process_messages(struct format *, struct msgs_array *,
 101                              struct msgs_array *, charstring_t, char *, int,
 102                              int, int *, struct fmt_callbacks *);
 103 static void process_single_file(FILE *, struct msgs_array *, int *, int,
 104                                 struct format *, charstring_t, int,
 105                                 struct fmt_callbacks *);
 106 static void test_trace(void *, struct format *, int, char *, const char *);
 107 static char *test_formataddr(char *, char *);
 108 static char *test_concataddr(char *, char *);
 109 static int insert(struct mailname *);
 110 static void mlistfree(void);
 111
 112 static bool nodupcheck;         /* If set, no check for duplicates */
 113 static bool ccme;               /* Should I cc myself? */
 114 static struct mailname mq;      /* Mail addresses to check for duplicates */
 115 static char *dummy = "dummy";
 116
 117 int
 118 main (int argc, char **argv)
 119 {
 120     char *cp, *form = NULL, *format = NULL, *defformat = FORMAT, *folder = NULL;
 121     char buf[BUFSIZ], *nfs, **argp, **arguments;
 122     charstring_t buffer;
 123     struct format *fmt;
 124     struct comp *cptr;
 125     struct msgs_array msgs = { 0, 0, NULL }, compargs = { 0, 0, NULL};
 126     bool dump = false;
 127     int i;
 128     int outputsize = 0;
 129     bool dupaddrs = true;
 130     bool trace = false;
 131     int files = 0;
 132     int colwidth = -1, msgnum = -1, msgcur = -1, msgsize = -1, msgunseen = -1;
 133     enum mode_t mode = MESSAGE;
 134     int dat[5];
 135     struct fmt_callbacks cb, *cbp = NULL;
 136
 137     if (nmh_init(argv[0], true, true)) { return 1; }
 138
 139     arguments = getarguments (invo_name, argc, argv, 1);
 140     argp = arguments;
 141
 142     while ((cp = *argp++)) {
 143         if (*cp == '-') {
 144             /*
 145              * A -- means that we have a component name (like pick);
 146              * save the component name and the next argument for the text.
 147              */
 148             if (*++cp == '-') {
 149                 if (*++cp == '\0')
 150                     die("missing component name after --");
 151                 app_msgarg(&compargs, cp);
 152                 /* Grab next argument for component text */
 153                 if (!(cp = *argp++))
 154                     die("missing argument to %s", argp[-2]);
 155                 app_msgarg(&compargs, cp);
 156                 continue;
 157             }
 158             switch (smatch (cp, switches)) {
 159                 case AMBIGSW:
 160                     ambigsw (cp, switches);
 161                     done (1);
 162                 case UNKWNSW:
 163                     die("-%s unknown", cp);
 164
 165                 case HELPSW:
 166                     snprintf (buf, sizeof(buf), "%s [switches]", invo_name);
 167                     print_help (buf, switches, 1);
 168                     done (0);
 169                 case VERSIONSW:
 170                     print_version(invo_name);
 171                     done (0);
 172                 case OTHERSW:
 173                     die("internal argument error!");
 174                     continue;
 175
 176                 case OUTSIZESW:
 177                     if (!(cp = *argp++) || *cp == '-')
 178                         die("missing argument to %s", argp[-2]);
 179                     if (strcmp(cp, "max") == 0)
 180                         outputsize = INT_MAX;
 181                     else if (strcmp(cp, "width") == 0)
 182                         outputsize = sc_width();
 183                     else
 184                         outputsize = atoi(cp);
 185                     continue;
 186
 187                 case FORMSW:
 188                     if (!(form = *argp++) || *form == '-')
 189                         die("missing argument to %s", argp[-2]);
 190                     format = NULL;
 191                     continue;
 192                 case FMTSW:
 193                     if (!(format = *argp++) || *format == '-')
 194                         die("missing argument to %s", argp[-2]);
 195                     form = NULL;
 196                     continue;
 197
 198                 case TRACESW:
 199                     trace = true;
 200                     continue;
 201                 case NTRACESW:
 202                     trace = false;
 203                     continue;
 204
 205                 case ADDRSW:
 206                     mode = ADDRESS;
 207                     defformat = DEFADDRFORMAT;
 208                     continue;
 209                 case RAWSW:
 210                     mode = RAW;
 211                     continue;
 212                 case MESSAGESW:
 213                     mode = MESSAGE;
 214                     defformat = FORMAT;
 215                     dupaddrs = false;
 216                     continue;
 217                 case DATESW:
 218                     mode = DATE;
 219                     defformat = DEFDATEFORMAT;
 220                     continue;
 221
 222                 case FILESW:
 223                     files++;
 224                     continue;
 225                 case NFILESW:
 226                     files = 0;
 227                     continue;
 228
 229                 case DUPADDRSW:
 230                     dupaddrs = true;
 231                     continue;
 232                 case NDUPADDRSW:
 233                     dupaddrs = false;
 234                     continue;
 235
 236                 case CCMESW:
 237                     ccme = true;
 238                     continue;
 239                 case NCCMESW:
 240                     ccme = false;
 241                     continue;
 242
 243                 case WIDTHSW:
 244                     if (!(cp = *argp++) || *cp == '-')
 245                         die("missing argument to %s", argp[-2]);
 246                     colwidth = atoi(cp);
 247                     continue;
 248                 case MSGNUMSW:
 249                     if (!(cp = *argp++) || *cp == '-')
 250                         die("missing argument to %s", argp[-2]);
 251                     msgnum = atoi(cp);
 252                     continue;
 253                 case MSGCURSW:
 254                     if (!(cp = *argp++) || *cp == '-')
 255                         die("missing argument to %s", argp[-2]);
 256                     msgcur = atoi(cp);
 257                     continue;
 258                 case MSGSIZESW:
 259                     if (!(cp = *argp++) || *cp == '-')
 260                         die("missing argument to %s", argp[-2]);
 261                     msgsize = atoi(cp);
 262                     continue;
 263                 case UNSEENSW:
 264                     if (!(cp = *argp++) || *cp == '-')
 265                         die("missing argument to %s", argp[-2]);
 266                     msgunseen = atoi(cp);
 267                     continue;
 268
 269                 case DUMPSW:
 270                     dump = true;
 271                     continue;
 272                 case NDUMPSW:
 273                     dump = false;
 274                     continue;
 275
 276             }
 277         }
 278
 279         /*
 280          * Only interpret as a folder if we're in message mode
 281          */
 282
 283         if (mode == MESSAGE && !files && (*cp == '+' || *cp == '@')) {
 284             if (folder)
 285                 die("only one folder at a time!");
 286             folder = pluspath (cp);
 287         } else
 288             app_msgarg(&msgs, cp);
 289     }
 290
 291     /*
 292      * Here's our weird heuristic:
 293      *
 294      * - We allow -dump without any other arguments.
 295      * - If you've given any component arguments, we don't require any
 296      *   other arguments.
 297      * - The arguments are interpreted as folders/messages _if_ we're in
 298      *   message mode, otherwise pass as strings in the text component.
 299      */
 300
 301    if (!dump && compargs.size == 0 && msgs.size == 0) {
 302         die("usage: [switches] [+folder] msgs | strings...");
 303    }
 304
 305    /*
 306     * If you're picking "raw" as a mode, then you have to select
 307     * a format.
 308     */
 309
 310    if (mode == RAW && form == NULL && format == NULL) {
 311         die("You must specify a format with -form or -format when "
 312                "using -raw");
 313    }
 314
 315     /*
 316      * Get new format string.  Must be before chdir().
 317      */
 318     nfs = new_fs (form, format, defformat);
 319     (void) fmt_compile(nfs, &fmt, 1);
 320
 321     if (dump || trace) {
 322         initlabels(fmt);
 323         if (dump) {
 324             fmt_dump(nfs, fmt);
 325             if (compargs.size == 0 && msgs.size == 0)
 326                 done(0);
 327         }
 328     }
 329
 330     buffer = charstring_create(BUFSIZ);
 331
 332     if (outputsize == 0) {
 333         if (mode == MESSAGE)
 334             outputsize = sc_width();
 335         else
 336             outputsize = INT_MAX;
 337     }
 338
 339     dat[0] = msgnum;
 340     dat[1] = msgcur;
 341     dat[2] = msgsize;
 342     dat[3] = colwidth == -1 ? outputsize : colwidth;
 343     dat[4] = msgunseen;
 344
 345     /*
 346      * If we want to provide our own formataddr, concactaddr, or tracing
 347      * callback, do that now.  Also, prime ismymbox if we use it.
 348      */
 349
 350     if (!dupaddrs || trace) {
 351         ZERO(&cb);
 352         cbp = &cb;
 353
 354         if (!dupaddrs) {
 355             cb.formataddr = test_formataddr;
 356             cb.concataddr = test_concataddr;
 357             if (!ccme)
 358                 ismymbox(NULL);
 359         }
 360
 361         if (trace) {
 362             struct trace_context *ctx;
 363
 364             NEW(ctx);
 365             ctx->num = -1;
 366             ctx->str = dummy;
 367             ctx->outbuf = mh_xstrdup("");
 368
 369             cb.trace_func = test_trace;
 370             cb.trace_context = ctx;
 371         }
 372     }
 373
 374     if (mode == MESSAGE) {
 375         process_messages(fmt, &compargs, &msgs, buffer, folder, outputsize,
 376                          files, dat, cbp);
 377     } else {
 378         if (compargs.size) {
 379             for (i = 0; i < compargs.size; i += 2) {
 380                 cptr = fmt_findcomp(compargs.msgs[i]);
 381                 if (cptr)
 382                     cptr->c_text = getcpy(compargs.msgs[i + 1]);
 383             }
 384         }
 385
 386         if (mode == ADDRESS) {
 387             process_addresses(fmt, &msgs, buffer, outputsize, dat, cbp);
 388         } else /* Fall-through for RAW or DATE */
 389             process_raw(fmt, &msgs, buffer, outputsize, dat, cbp);
 390     }
 391
 392     charstring_free(buffer);
 393     fmt_free(fmt, 1);
 394
 395     done(0);
 396     return 1;
 397 }
 398
 399 /*
 400  * Process each address with fmt_scan().
 401  */
 402
 403 struct pqpair {
 404     char *pq_text;
 405     char *pq_error;
 406     struct pqpair *pq_next;
 407 };
 408
 409 static void
 410 process_addresses(struct format *fmt, struct msgs_array *addrs,
 411                   charstring_t buffer, int outwidth, int *dat,
 412                   struct fmt_callbacks *cb)
 413 {
 414     int i;
 415     char *cp, error[BUFSIZ];
 416     struct mailname *mp;
 417     struct pqpair *p, *q;
 418     struct pqpair pq;
 419     struct comp *c;
 420
 421     if (dat[0] == -1)
 422         dat[0] = 0;
 423     if (dat[1] == -1)
 424         dat[1] = 0;
 425     if (dat[2] == -1)
 426         dat[2] = 0;
 427     if (dat[4] == -1)
 428         dat[4] = 0;
 429
 430     for (i = 0; i < addrs->size; i++) {
 431         (q = &pq)->pq_next = NULL;
 432         while ((cp = getname(addrs->msgs[i]))) {
 433             NEW0(p);
 434             if ((mp = getm(cp, NULL, 0, error, sizeof(error))) == NULL) {
 435                 p->pq_text = mh_xstrdup(cp);
 436                 p->pq_error = mh_xstrdup(error);
 437             } else {
 438                 p->pq_text = getcpy(mp->m_text);
 439                 mnfree(mp);
 440             }
 441             q = (q->pq_next = p);
 442         }
 443
 444         for (p = pq.pq_next; p; p = q) {
 445             c = fmt_findcomp("text");
 446             if (c) {
 447                 free(c->c_text);
 448                 c->c_text = p->pq_text;
 449                 p->pq_text = NULL;
 450             }
 451             c = fmt_findcomp("error");
 452             if (c) {
 453                 free(c->c_text);
 454                 c->c_text = p->pq_error;
 455                 p->pq_error = NULL;
 456             }
 457
 458             fmt_scan(fmt, buffer, outwidth, dat, cb);
 459             fputs(charstring_buffer(buffer), stdout);
 460             mlistfree();
 461
 462             free(p->pq_text);
 463             free(p->pq_error);
 464             q = p->pq_next;
 465             free(p);
 466         }
 467     }
 468 }
 469
 470 /*
 471  * Process messages and run them through the format engine.  A lot taken
 472  * from scan.c.
 473  */
 474
 475 static void
 476 process_messages(struct format *fmt, struct msgs_array *comps,
 477                  struct msgs_array *msgs, charstring_t buffer, char *folder,
 478                  int outwidth, int files, int *dat,
 479                  struct fmt_callbacks *cb)
 480 {
 481     int i, msgnum, msgsize = dat[2], num = dat[0], cur = dat[1];
 482     int num_unseen_seq = 0;
 483     ivector_t seqnum = ivector_create (0);
 484     char *maildir, *cp;
 485     struct msgs *mp;
 486     FILE *in;
 487
 488     /*
 489      * If 'files' is set, short-circuit everything else and just process
 490      * everything now.
 491      */
 492
 493     if (files) {
 494         for (i = 0; i < msgs->size; i++) {
 495             if ((in = fopen(cp = msgs->msgs[i], "r")) == NULL) {
 496                 admonish(cp, "unable to open file");
 497                 continue;
 498             }
 499             process_single_file(in, comps, dat, msgsize, fmt, buffer,
 500                                 outwidth, cb);
 501         }
 502
 503         return;
 504     }
 505
 506     if (! folder)
 507         folder = getfolder(1);
 508
 509     maildir = m_maildir(folder);
 510
 511     if (chdir(maildir) < 0)
 512         adios(maildir, "unable to change directory to");
 513
 514     if (!(mp = folder_read(folder, 1)))
 515         die("unable to read folder %s", folder);
 516
 517     if (mp->nummsg == 0)
 518         die("no messages in %s", folder);
 519
 520     for (i = 0; i < msgs->size; i++)
 521         if (!m_convert(mp, msgs->msgs[i]))
 522             done(1);
 523     seq_setprev(mp);                    /* set the Previous-Sequence */
 524
 525     context_replace(pfolder, folder);   /* update current folder */
 526     seq_save(mp);                       /* synchronize message sequences */
 527     context_save();                     /* save the context file */
 528
 529     /*
 530      * We want to set the unseen flag if requested, so we have to check
 531      * the unseen sequence as well.
 532      */
 533
 534     if (dat[4] == -1) {
 535         if ((cp = context_find(usequence)) && *cp) {
 536             char **ap, *dp;
 537
 538             dp = mh_xstrdup(cp);
 539             ap = brkstring(dp, " ", "\n");
 540             for (i = 0; ap && *ap; i++, ap++)
 541                 ivector_push_back (seqnum, seq_getnum(mp, *ap));
 542
 543             num_unseen_seq = i;
 544             free(dp);
 545         }
 546     }
 547
 548     for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
 549         if (is_selected(mp, msgnum)) {
 550             if ((in = fopen(cp = m_name(msgnum), "r")) == NULL) {
 551                 admonish(cp, "unable to open message");
 552                 continue;
 553             }
 554
 555             fmt_freecomptext();
 556
 557             if (num == -1)
 558                 dat[0] = msgnum;
 559
 560             if (cur == -1)
 561                 dat[1] = msgnum == mp->curmsg;
 562
 563             /*
 564              * Check to see if this is in the unseen sequence
 565              */
 566
 567             dat[4] = 0;
 568             for (i = 0; i < num_unseen_seq; i++) {
 569                 if (in_sequence(mp, ivector_at (seqnum, i), msgnum)) {
 570                     dat[4] = 1;
 571                     break;
 572                 }
 573             }
 574
 575             /*
 576              * Read in the message and process the components
 577              */
 578
 579             process_single_file(in, comps, dat, msgsize, fmt, buffer,
 580                                 outwidth, cb);
 581         }
 582     }
 583
 584     ivector_free (seqnum);
 585     folder_free(mp);
 586 }
 587
 588 /*
 589  * Process a single file in message mode
 590  */
 591
 592 static void
 593 process_single_file(FILE *in, struct msgs_array *comps, int *dat, int msgsize,
 594                     struct format *fmt, charstring_t buffer, int outwidth,
 595                     struct fmt_callbacks *cb)
 596 {
 597     int i, state;
 598     char name[NAMESZ], rbuf[NMH_BUFSIZ];
 599     m_getfld_state_t gstate;
 600     struct comp *c;
 601     int bufsz;
 602
 603     /*
 604      * Get our size if we didn't include one
 605      */
 606
 607     if (msgsize == -1) {
 608         struct stat st;
 609
 610         if (fstat(fileno(in), &st) < 0)
 611             dat[2] = 0;
 612         else
 613             dat[2] = st.st_size;
 614     }
 615
 616     /*
 617      * Initialize everything else
 618      */
 619
 620     if (dat[0] == -1)
 621         dat[0] = 0;
 622     if (dat[1] == -1)
 623         dat[1] = 0;
 624     if (dat[4] == -1)
 625         dat[4] = 0;
 626
 627     /*
 628      * Read in the message and process the components
 629      */
 630
 631     gstate = m_getfld_state_init(in);
 632     for (;;) {
 633         bufsz = sizeof(rbuf);
 634         state = m_getfld2(&gstate, name, rbuf, &bufsz);
 635         switch (state) {
 636         case FLD:
 637         case FLDPLUS:
 638             i = fmt_addcomptext(name, rbuf);
 639             if (i != -1) {
 640                 while (state == FLDPLUS) {
 641                     bufsz = sizeof(rbuf);
 642                     state = m_getfld2(&gstate, name, rbuf, &bufsz);
 643                     fmt_appendcomp(i, name, rbuf);
 644                 }
 645             }
 646
 647             while (state == FLDPLUS) {
 648                 bufsz = sizeof(rbuf);
 649                 state = m_getfld2(&gstate, name, rbuf, &bufsz);
 650             }
 651             break;
 652
 653         case BODY:
 654             if (fmt_findcomp("body")) {
 655                 if ((i = strlen(rbuf)) < outwidth) {
 656                     bufsz = min (outwidth, (int) sizeof rbuf - i);
 657                     m_getfld2(&gstate, name, rbuf + i, &bufsz);
 658                 }
 659
 660                 fmt_addcomptext("body", rbuf);
 661             }
 662             goto finished;
 663
 664         default:
 665             goto finished;
 666         }
 667     }
 668 finished:
 669     fclose(in);
 670     m_getfld_state_destroy(&gstate);
 671
 672     /*
 673      * Do this now to override any components in the original message
 674      */
 675     if (comps->size) {
 676         for (i = 0; i < comps->size; i += 2) {
 677             c = fmt_findcomp(comps->msgs[i]);
 678             if (c) {
 679                 free(c->c_text);
 680                 c->c_text = getcpy(comps->msgs[i + 1]);
 681             }
 682         }
 683     }
 684     fmt_scan(fmt, buffer, outwidth, dat, cb);
 685     fputs(charstring_buffer (buffer), stdout);
 686     mlistfree();
 687 }
 688
 689 /*
 690  * Run text through the format engine with no special processing
 691  */
 692
 693 static void
 694 process_raw(struct format *fmt, struct msgs_array *text, charstring_t buffer,
 695             int outwidth, int *dat, struct fmt_callbacks *cb)
 696 {
 697     int i;
 698     struct comp *c;
 699
 700     if (dat[0] == -1)
 701         dat[0] = 0;
 702     if (dat[1] == -1)
 703         dat[1] = 0;
 704     if (dat[2] == -1)
 705         dat[2] = 0;
 706     if (dat[4] == -1)
 707         dat[4] = 0;
 708
 709     c = fmt_findcomp("text");
 710
 711     for (i = 0; i < text->size; i++) {
 712         if (c != NULL) {
 713             free(c->c_text);
 714             c->c_text = getcpy(text->msgs[i]);
 715         }
 716
 717         fmt_scan(fmt, buffer, outwidth, dat, cb);
 718         fputs(charstring_buffer (buffer), stdout);
 719         mlistfree();
 720     }
 721 }
 722
 723 /*
 724  * Our basic tracing support callback.
 725  *
 726  * Print out each instruction as it's executed, including the values of
 727  * the num and str registers if they've changed.
 728  */
 729
 730 static void
 731 test_trace(void *context, struct format *fmt, int num, char *str,
 732            const char *outbuf)
 733 {
 734     struct trace_context *ctx = (struct trace_context *) context;
 735     bool changed = false;
 736
 737     dumpone(fmt);
 738
 739     if (num != ctx->num) {
 740         printf("num=%d", num);
 741         ctx->num = num;
 742         changed = true;
 743     }
 744
 745     if (str != ctx->str) {
 746         if (changed)
 747             putchar(' ');
 748         changed = true;
 749         fputs("str=", stdout);
 750         litputs(str);
 751         ctx->str = str;
 752     }
 753
 754     if (changed)
 755         putchar('\n');
 756
 757     if (strcmp(outbuf, ctx->outbuf) != 0) {
 758         fputs("outbuf=", stdout);
 759         litputs(outbuf);
 760         putchar('\n');
 761         free(ctx->outbuf);
 762         ctx->outbuf = mh_xstrdup(outbuf);
 763     }
 764 }
 765
 766 static void
 767 fmt_dump (char *nfs, struct format *fmth)
 768 {
 769         struct format *fmt;
 770
 771         printf("Instruction dump of format string: \n%s\n", nfs);
 772
 773         /* Dump them out! */
 774         for (fmt = fmth; fmt; ++fmt) {
 775                 dumpone(fmt);
 776                 if (fmt->f_type == FT_DONE && fmt->f_value == 0)
 777                         break;
 778         }
 779 }
 780
 781 static void
 782 dumpone(struct format *fmt)
 783 {
 784         int i;
 785
 786         if ((i = findlabel(fmt)) >= 0)
 787                 printf("L%d:", i);
 788         putchar('\t');
 789
 790         fputs(f_typestr((int)fmt->f_type), stdout);
 791
 792         switch (fmt->f_type) {
 793
 794         case FT_COMP:
 795         case FT_LS_COMP:
 796         case FT_LV_COMPFLAG:
 797         case FT_LV_COMP:
 798                 fputs(", comp ", stdout);
 799                 litputs(fmt->f_comp->c_name);
 800                 if (fmt->f_comp->c_type)
 801                         printf(", c_type %s", c_typestr(fmt->f_comp->c_type));
 802                 if (fmt->f_comp->c_flags)
 803                         printf(", c_flags %s", c_flagsstr(fmt->f_comp->c_flags));
 804                 break;
 805
 806         case FT_LV_SEC:
 807         case FT_LV_MIN:
 808         case FT_LV_HOUR:
 809         case FT_LV_MDAY:
 810         case FT_LV_MON:
 811         case FT_LS_MONTH:
 812         case FT_LS_LMONTH:
 813         case FT_LS_ZONE:
 814         case FT_LV_YEAR:
 815         case FT_LV_WDAY:
 816         case FT_LS_DAY:
 817         case FT_LS_WEEKDAY:
 818         case FT_LV_YDAY:
 819         case FT_LV_ZONE:
 820         case FT_LV_CLOCK:
 821         case FT_LV_RCLOCK:
 822         case FT_LV_DAYF:
 823         case FT_LV_ZONEF:
 824         case FT_LV_DST:
 825         case FT_LS_822DATE:
 826         case FT_LS_PRETTY:
 827         case FT_LOCALDATE:
 828         case FT_GMTDATE:
 829         case FT_PARSEDATE:
 830                 fputs(", c_name ", stdout);
 831                 litputs(fmt->f_comp->c_name);
 832                 if (fmt->f_comp->c_type)
 833                         printf(", c_type %s", c_typestr(fmt->f_comp->c_type));
 834                 if (fmt->f_comp->c_flags)
 835                         printf(", c_flags %s", c_flagsstr(fmt->f_comp->c_flags));
 836                 break;
 837
 838         case FT_LS_ADDR:
 839         case FT_LS_PERS:
 840         case FT_LS_MBOX:
 841         case FT_LS_HOST:
 842         case FT_LS_PATH:
 843         case FT_LS_GNAME:
 844         case FT_LS_NOTE:
 845         case FT_LS_822ADDR:
 846         case FT_LV_HOSTTYPE:
 847         case FT_LV_INGRPF:
 848         case FT_LV_NOHOSTF:
 849         case FT_LS_FRIENDLY:
 850         case FT_PARSEADDR:
 851         case FT_MYMBOX:
 852         case FT_GETMYMBOX:
 853         case FT_GETMYADDR:
 854                 fputs(", c_name ", stdout);
 855                 litputs(fmt->f_comp->c_name);
 856                 if (fmt->f_comp->c_type)
 857                         printf(", c_type %s", c_typestr(fmt->f_comp->c_type));
 858                 if (fmt->f_comp->c_flags)
 859                         printf(", c_flags %s", c_flagsstr(fmt->f_comp->c_flags));
 860                 break;
 861
 862         case FT_COMPF:
 863                 printf(", width %d, fill '", fmt->f_width);
 864                 litputc(fmt->f_fill);
 865                 fputs("' name ", stdout);
 866                 litputs(fmt->f_comp->c_name);
 867                 if (fmt->f_comp->c_type)
 868                         printf(", c_type %s", c_typestr(fmt->f_comp->c_type));
 869                 if (fmt->f_comp->c_flags)
 870                         printf(", c_flags %s", c_flagsstr(fmt->f_comp->c_flags));
 871                 break;
 872
 873         case FT_STRF:
 874         case FT_NUMF:
 875                 printf(", width %d, fill '", fmt->f_width);
 876                 litputc(fmt->f_fill);
 877                 putchar('\'');
 878                 break;
 879
 880         case FT_LIT:
 881                 putchar(' ');
 882                 litputs(fmt->f_text);
 883                 break;
 884
 885         case FT_LITF:
 886                 printf(", width %d, fill '", fmt->f_width);
 887                 litputc(fmt->f_fill);
 888                 fputs("' ", stdout);
 889                 litputs(fmt->f_text);
 890                 break;
 891
 892         case FT_CHAR:
 893                 putchar(' ');
 894                 putchar('\'');
 895                 litputc(fmt->f_char);
 896                 putchar('\'');
 897                 break;
 898
 899
 900         case FT_IF_S:
 901         case FT_IF_S_NULL:
 902         case FT_IF_MATCH:
 903         case FT_IF_AMATCH:
 904                 fputs(" continue else goto", stdout);
 905                 /* FALLTHRU */
 906         case FT_GOTO:
 907                 i = findlabel(fmt + fmt->f_skip);
 908                 printf(" L%d", i);
 909                 break;
 910
 911         case FT_IF_V_EQ:
 912         case FT_IF_V_NE:
 913         case FT_IF_V_GT:
 914                 i = findlabel(fmt + fmt->f_skip);
 915                 printf(" %d continue else goto L%d", fmt->f_value, i);
 916                 break;
 917
 918         case FT_V_EQ:
 919         case FT_V_NE:
 920         case FT_V_GT:
 921         case FT_LV_LIT:
 922         case FT_LV_PLUS_L:
 923         case FT_LV_MINUS_L:
 924         case FT_LV_MULTIPLY_L:
 925         case FT_LV_DIVIDE_L:
 926         case FT_LV_MODULO_L:
 927                 printf(" value %d", fmt->f_value);
 928                 break;
 929
 930         case FT_LS_LIT:
 931                 fputs(" str ", stdout);
 932                 litputs(fmt->f_text);
 933                 break;
 934
 935         case FT_LS_GETENV:
 936                 fputs(" getenv ", stdout);
 937                 litputs(fmt->f_text);
 938                 break;
 939
 940         case FT_LS_DECODECOMP:
 941                 fputs(", comp ", stdout);
 942                 litputs(fmt->f_comp->c_name);
 943                 break;
 944
 945         case FT_LS_DECODE:
 946                 break;
 947
 948         case FT_LS_TRIM:
 949                 printf(", width %d", fmt->f_width);
 950                 break;
 951
 952         case FT_LV_DAT:
 953                 printf(", value dat[%d]", fmt->f_value);
 954                 break;
 955         }
 956         putchar('\n');
 957 }
 958
 959 /*
 960  * Iterate over all instructions and assign labels to the targets of
 961  * branch statements
 962  */
 963
 964 static void
 965 initlabels(struct format *fmth)
 966 {
 967         struct format *fmt, *addr;
 968         int i;
 969
 970         /* Assign labels */
 971         for (fmt = fmth; fmt; ++fmt) {
 972                 i = fmt->f_type;
 973                 if (i == FT_IF_S ||
 974                     i == FT_IF_S_NULL ||
 975                     i == FT_IF_V_EQ ||
 976                     i == FT_IF_V_NE ||
 977                     i == FT_IF_V_GT ||
 978                     i == FT_IF_MATCH ||
 979                     i == FT_IF_AMATCH ||
 980                     i == FT_GOTO) {
 981                         addr = fmt + fmt->f_skip;
 982                         if (findlabel(addr) < 0)
 983                                 assignlabel(addr);
 984                 }
 985                 if (fmt->f_type == FT_DONE && fmt->f_value == 0)
 986                         break;
 987         }
 988 }
 989
 990
 991 static int
 992 findlabel(struct format *addr)
 993 {
 994         int i;
 995
 996         for (i = 0; i < lused; ++i)
 997                 if (addr == lvec[i])
 998                         return i;
 999         return -1;
1000 }
1001
1002 static void
1003 assignlabel(struct format *addr)
1004 {
1005         if (lused >= lallocated) {
1006                 lallocated += 64;
1007                 lvec = (struct format **)
1008                         mh_xrealloc(lvec, sizeof(struct format *) * lallocated);
1009         }
1010
1011         lvec[lused++] = addr;
1012 }
1013
1014 static char *
1015 f_typestr(int t)
1016 {
1017         static char buf[32];
1018
1019         switch (t) {
1020         case FT_COMP: return "COMP";
1021         case FT_COMPF: return "COMPF";
1022         case FT_LIT: return "LIT";
1023         case FT_LITF: return "LITF";
1024         case FT_CHAR: return "CHAR";
1025         case FT_NUM: return "NUM";
1026         case FT_NUMF: return "NUMF";
1027         case FT_STR: return "STR";
1028         case FT_STRF: return "STRF";
1029         case FT_STRFW: return "STRFW";
1030         case FT_STRLIT: return "STRLIT";
1031         case FT_STRLITZ: return "STRLITZ";
1032         case FT_PUTADDR: return "PUTADDR";
1033         case FT_LS_COMP: return "LS_COMP";
1034         case FT_LS_LIT: return "LS_LIT";
1035         case FT_LS_GETENV: return "LS_GETENV";
1036         case FT_LS_CFIND: return "LS_CFIND";
1037         case FT_LS_DECODECOMP: return "LS_DECODECOMP";
1038         case FT_LS_DECODE: return "LS_DECODE";
1039         case FT_LS_TRIM: return "LS_TRIM";
1040         case FT_LV_COMP: return "LV_COMP";
1041         case FT_LV_COMPFLAG: return "LV_COMPFLAG";
1042         case FT_LV_LIT: return "LV_LIT";
1043         case FT_LV_DAT: return "LV_DAT";
1044         case FT_LV_STRLEN: return "LV_STRLEN";
1045         case FT_LV_PLUS_L: return "LV_PLUS_L";
1046         case FT_LV_MINUS_L: return "LV_MINUS_L";
1047         case FT_LV_MULTIPLY_L: return "LV_MULTIPLY_L";
1048         case FT_LV_DIVIDE_L: return "LV_DIVIDE_L";
1049         case FT_LV_MODULO_L: return "LV_MODULO_L";
1050         case FT_LV_CHAR_LEFT: return "LV_CHAR_LEFT";
1051         case FT_LS_MONTH: return "LS_MONTH";
1052         case FT_LS_LMONTH: return "LS_LMONTH";
1053         case FT_LS_ZONE: return "LS_ZONE";
1054         case FT_LS_DAY: return "LS_DAY";
1055         case FT_LS_WEEKDAY: return "LS_WEEKDAY";
1056         case FT_LS_822DATE: return "LS_822DATE";
1057         case FT_LS_PRETTY: return "LS_PRETTY";
1058         case FT_LS_KILO: return "LS_KILO";
1059         case FT_LS_KIBI: return "LS_KIBI";
1060         case FT_LV_SEC: return "LV_SEC";
1061         case FT_LV_MIN: return "LV_MIN";
1062         case FT_LV_HOUR: return "LV_HOUR";
1063         case FT_LV_MDAY: return "LV_MDAY";
1064         case FT_LV_MON: return "LV_MON";
1065         case FT_LV_YEAR: return "LV_YEAR";
1066         case FT_LV_YDAY: return "LV_YDAY";
1067         case FT_LV_WDAY: return "LV_WDAY";
1068         case FT_LV_ZONE: return "LV_ZONE";
1069         case FT_LV_CLOCK: return "LV_CLOCK";
1070         case FT_LV_RCLOCK: return "LV_RCLOCK";
1071         case FT_LV_DAYF: return "LV_DAYF";
1072         case FT_LV_DST: return "LV_DST";
1073         case FT_LV_ZONEF: return "LV_ZONEF";
1074         case FT_LS_PERS: return "LS_PERS";
1075         case FT_LS_MBOX: return "LS_MBOX";
1076         case FT_LS_HOST: return "LS_HOST";
1077         case FT_LS_PATH: return "LS_PATH";
1078         case FT_LS_GNAME: return "LS_GNAME";
1079         case FT_LS_NOTE: return "LS_NOTE";
1080         case FT_LS_ADDR: return "LS_ADDR";
1081         case FT_LS_822ADDR: return "LS_822ADDR";
1082         case FT_LS_FRIENDLY: return "LS_FRIENDLY";
1083         case FT_LV_HOSTTYPE: return "LV_HOSTTYPE";
1084         case FT_LV_INGRPF: return "LV_INGRPF";
1085         case FT_LS_UNQUOTE: return "LS_UNQUOTE";
1086         case FT_LV_NOHOSTF: return "LV_NOHOSTF";
1087         case FT_LOCALDATE: return "LOCALDATE";
1088         case FT_GMTDATE: return "GMTDATE";
1089         case FT_PARSEDATE: return "PARSEDATE";
1090         case FT_PARSEADDR: return "PARSEADDR";
1091         case FT_FORMATADDR: return "FORMATADDR";
1092         case FT_CONCATADDR: return "CONCATADDR";
1093         case FT_MYMBOX: return "MYMBOX";
1094         case FT_GETMYMBOX: return "GETMYMBOX";
1095         case FT_GETMYADDR: return "GETMYADDR";
1096         case FT_SAVESTR: return "SAVESTR";
1097         case FT_DONE: return "DONE";
1098         case FT_PAUSE: return "PAUSE";
1099         case FT_NOP: return "NOP";
1100         case FT_GOTO: return "GOTO";
1101         case FT_IF_S_NULL: return "IF_S_NULL";
1102         case FT_IF_S: return "IF_S";
1103         case FT_IF_V_EQ: return "IF_V_EQ";
1104         case FT_IF_V_NE: return "IF_V_NE";
1105         case FT_IF_V_GT: return "IF_V_GT";
1106         case FT_IF_MATCH: return "IF_MATCH";
1107         case FT_IF_AMATCH: return "IF_AMATCH";
1108         case FT_S_NULL: return "S_NULL";
1109         case FT_S_NONNULL: return "S_NONNULL";
1110         case FT_V_EQ: return "V_EQ";
1111         case FT_V_NE: return "V_NE";
1112         case FT_V_GT: return "V_GT";
1113         case FT_V_MATCH: return "V_MATCH";
1114         case FT_V_AMATCH: return "V_AMATCH";
1115         default:
1116                 snprintf(buf, sizeof(buf), "/* ??? #%d */", t);
1117                 return buf;
1118         }
1119 }
1120
1121 static char *
1122 c_typestr(int t)
1123 {
1124         static char buf[64];
1125
1126         snprintb(buf, sizeof(buf), t, CT_BITS);
1127         return buf;
1128 }
1129
1130 static char *
1131 c_flagsstr(int t)
1132 {
1133         static char buf[64];
1134
1135         snprintb(buf, sizeof(buf), t, CF_BITS);
1136         return buf;
1137 }
1138
1139 static void
1140 litputs(const char *s)
1141 {
1142         if (s) {
1143                 putchar('"');
1144                 while (*s)
1145                         litputc(*s++);
1146                 putchar('"');
1147         } else
1148                 fputs("<nil>", stdout);
1149 }
1150
1151 static void
1152 litputc(char c)
1153 {
1154         if (c & ~ 0177) {
1155                 printf("\\x%02x", (unsigned char) c);
1156         } else if (c < 0x20 || c == 0177) {
1157                 if (c == '\b') {
1158                         putchar('\\');
1159                         putchar('b');
1160                 } else if (c == '\f') {
1161                         putchar('\\');
1162                         putchar('f');
1163                 } else if (c == '\n') {
1164                         putchar('\\');
1165                         putchar('n');
1166                 } else if (c == '\r') {
1167                         putchar('\\');
1168                         putchar('r');
1169                 } else if (c == '\t') {
1170                         putchar('\\');
1171                         putchar('t');
1172                 } else {
1173                         putchar('^');
1174                         putchar(c ^ 0x40);      /* DEL to ?, others to alpha */
1175                 }
1176         } else
1177                 putchar(c);
1178 }
1179
1180 /*
1181  * Routines/code to support the duplicate address suppression code, adapted
1182  * from replsbr.c
1183  */
1184
1185 static char *buf;               /* our current working buffer */
1186 static char *bufend;            /* end of working buffer */
1187 static char *last_dst;          /* buf ptr at end of last call */
1188 static unsigned int bufsiz=0;   /* current size of buf */
1189
1190 #define BUFINCR 512             /* how much to expand buf when if fills */
1191
1192 #define CPY(s) { cp = (s); while ((*dst++ = *cp++)) ; --dst; }
1193
1194 /*
1195  * check if there's enough room in buf for str.
1196  * add more mem if needed
1197  */
1198 #define CHECKMEM(str) \
1199             if ((len = strlen (str)) >= bufend - dst) {\
1200                 int i = dst - buf;\
1201                 int n = last_dst - buf;\
1202                 bufsiz += ((dst + len - bufend) / BUFINCR + 1) * BUFINCR;\
1203                 buf = mh_xrealloc (buf, bufsiz);\
1204                 dst = buf + i;\
1205                 last_dst = buf + n;\
1206                 bufend = buf + bufsiz;\
1207             }
1208
1209
1210 /*
1211  * These are versions of similar routines from replsbr.c; the purpose is
1212  * to suppress duplicate addresses from being added to a list when building
1213  * up addresses for the %(formataddr) format function.  This is used by
1214  * repl to prevent duplicate addresses from being added to the "to" line.
1215  * See replsbr.c for more information.
1216  *
1217  * We can't use the functions in replsbr.c directly because they are slightly
1218  * different and depend on the rest of replsbr.c
1219  */
1220 static char *
1221 test_formataddr (char *orig, char *str)
1222 {
1223     int len;
1224     char error[BUFSIZ];
1225     bool isgroup;
1226     char *dst;
1227     char *cp;
1228     char *sp;
1229     struct mailname *mp = NULL;
1230
1231     /* if we don't have a buffer yet, get one */
1232     if (bufsiz == 0) {
1233         buf = mh_xmalloc (BUFINCR);
1234         last_dst = buf;         /* XXX */
1235         bufsiz = BUFINCR - 6;  /* leave some slop */
1236         bufend = buf + bufsiz;
1237     }
1238     /*
1239      * If "orig" points to our buffer we can just pick up where we
1240      * left off.  Otherwise we have to copy orig into our buffer.
1241      */
1242     if (orig == buf)
1243         dst = last_dst;
1244     else if (!orig || !*orig) {
1245         dst = buf;
1246         *dst = '\0';
1247     } else {
1248         dst = last_dst;         /* XXX */
1249         CHECKMEM (orig);
1250         CPY (orig);
1251     }
1252
1253     /* concatenate all the new addresses onto 'buf' */
1254     for (isgroup = false; (cp = getname (str)); ) {
1255         if ((mp = getm (cp, NULL, 0, error, sizeof(error))) == NULL) {
1256             fprintf(stderr, "bad address \"%s\" -- %s\n", cp, error);
1257             continue;
1258         }
1259         if (isgroup && (mp->m_gname || !mp->m_ingrp)) {
1260             *dst++ = ';';
1261             isgroup = false;
1262         }
1263         if (insert (mp)) {
1264             /* if we get here we're going to add an address */
1265             if (dst != buf) {
1266                 *dst++ = ',';
1267                 *dst++ = ' ';
1268             }
1269             if (mp->m_gname) {
1270                 CHECKMEM (mp->m_gname);
1271                 CPY (mp->m_gname);
1272                 isgroup = true;
1273             }
1274             sp = adrformat (mp);
1275             CHECKMEM (sp);
1276             CPY (sp);
1277         }
1278     }
1279
1280     if (isgroup)
1281         *dst++ = ';';
1282
1283     *dst = '\0';
1284     last_dst = dst;
1285     return buf;
1286 }
1287
1288
1289 /*
1290  * The companion to test_formataddr(); it behaves the same way, except doesn't
1291  * do duplicate address detection.
1292  */
1293 static char *
1294 test_concataddr(char *orig, char *str)
1295 {
1296     char *cp;
1297
1298     nodupcheck = true;
1299     cp = test_formataddr(orig, str);
1300     nodupcheck = false;
1301     return cp;
1302 }
1303
1304 static int
1305 insert (struct mailname *np)
1306 {
1307     struct mailname *mp;
1308
1309     if (nodupcheck)
1310         return 1;
1311
1312     if (np->m_mbox == NULL)
1313         return 0;
1314
1315     for (mp = &mq; mp->m_next; mp = mp->m_next) {
1316         if (!strcasecmp (FENDNULL(np->m_host),
1317                          FENDNULL(mp->m_next->m_host)) &&
1318             !strcasecmp (FENDNULL(np->m_mbox),
1319                          FENDNULL(mp->m_next->m_mbox)))
1320             return 0;
1321     }
1322     if (!ccme && ismymbox (np))
1323         return 0;
1324
1325     mp->m_next = np;
1326
1327     return 1;
1328 }
1329
1330 /*
1331  * Reset our duplicate address list
1332  */
1333
1334 void
1335 mlistfree(void)
1336 {
1337     struct mailname *mp, *mp2;
1338
1339     for (mp = mq.m_next; mp; mp = mp2) {
1340         mp2 = mp->m_next;
1341         mnfree(mp);
1342     }
1343 }