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