diplodocus.org Git - nmh/blob - uip/fmttest.c

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