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