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

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