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