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