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