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