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