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