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