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