diplodocus.org Git - nmh/blob - sbr/fmt_compile.c

   1
   2 /*
   3  * fmt_compile.c -- "compile" format strings for fmt_scan
   4  *
   5  * This code is Copyright (c) 2002, 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  * This code compiles the format strings (documented in mh-format(5)) into
  10  * an internal form to be later processed by fmt_scan.c.
  11  *
  12  * What happens here is that the format strings are parsed and an array
  13  * of struct format structures are returned.  Each format structure is
  14  * a single operation interpreted by the the routines in fmt_scan.c.
  15  *
  16  * There is a NOT a one-to-one correspondence between format strings and
  17  * format instructions; some functions have side effects that can result
  18  * in multiple instructions being generated.  The exact list of instructions
  19  * generated by a format string can be seem with the nmh fmttest utility.
  20  *
  21  * A list of format instructions can be found in fmt_compile.h.
  22  *
  23  * If you wish to add a new function, you will need to do the following
  24  * things:
  25  *
  26  * - Add a new instruction to the list of instructions in fmt_compile.h.
  27  *   Note that test instructions (starting with FT_IF_S_NULL) have special
  28  *   handling, so if you are NOT writing a test function then you need
  29  *   to insert it into the list before that _and_ bump all of the
  30  *   following instruction numbers.
  31  *
  32  * - Add the function name to the functable[] array below, and write any
  33  *   special code that your function may require in terms of parsing
  34  *   (it very well may not need anything).
  35  *
  36  * - Add the code in fmt_scan.c to handle your new function.
  37  *
  38  * - Add code to fmttest.c to display your new function.
  39  *
  40  * - Document the new function in the mh-format(5) man page.
  41  *
  42  */
  43
  44 #include <h/mh.h>
  45 #include <h/addrsbr.h>
  46 #include <h/tws.h>
  47 #include <h/fmt_scan.h>
  48 #include <h/fmt_compile.h>
  49 #include <h/mts.h>
  50 #include <h/utils.h>
  51
  52 #ifdef HAVE_SYS_TIME_H
  53 # include <sys/time.h>
  54 #endif
  55 #include <time.h>
  56
  57 /*
  58  * hash table for deciding if a component is "interesting"
  59  */
  60 static struct comp *wantcomp[128];
  61
  62 static struct format *formatvec;        /* array to hold formats */
  63 static struct format *next_fp;          /* next free format slot */
  64 static struct format *fp;               /* current format slot   */
  65 static struct comp *cm;                 /* most recent comp ref  */
  66 static struct ftable *ftbl;             /* most recent func ref  */
  67 static int ncomp;
  68 static int infunction;                  /* function nesting cnt  */
  69
  70 extern struct mailname fmt_mnull;
  71
  72 /* ftable->type (argument type) */
  73 #define TF_COMP    0        /* component expected                 */
  74 #define TF_NUM     1        /* number expected                    */
  75 #define TF_STR     2        /* string expected                    */
  76 #define TF_EXPR    3        /* component or func. expected        */
  77 #define TF_NONE    4        /* no argument                        */
  78 #define TF_MYBOX   5        /* special - get current user's mbox  */
  79 #define TF_NOW     6        /* special - get current unix time    */
  80 #define TF_EXPR_SV 7        /* like expr but save current str reg */
  81 #define TF_NOP     8        /* like expr but no result            */
  82 #define TF_MYNAME  9        /* special - get current name of user */
  83 #define TF_MYHOST  10       /* special - get "local" hostname     */
  84 #define TF_LMBOX   11       /* special - get full local mailbox   */
  85 #define TF_BOLD    12       /* special - enter terminal bold mode */
  86 #define TF_UNDERLN 13       /* special - enter underline mode     */
  87 #define TF_STNDOUT 14       /* special - enter underline mode     */
  88 #define TF_RESET   15       /* special - reset terminal modes     */
  89 #define TF_HASCLR  16       /* special - terminal have color?     */
  90 #define TF_FGCOLR  17       /* special - foreground term color    */
  91 #define TF_BGCOLR  18       /* special - background term color    */
  92
  93 /* ftable->flags */
  94 /* NB that TFL_PUTS is also used to decide whether the test
  95  * in a "%<(function)..." should be a string or numeric one.
  96  */
  97 #define TFL_PUTS   1        /* implicit putstr if top level */
  98 #define TFL_PUTN   2        /* implicit putnum if top level */
  99
 100 /*
 101  * The functable array maps between the text names of format functions and
 102  * the format instructions interpreted by the engine in fmt_scan.c.
 103  *
 104  * The elements of this structure are as follows:
 105  *
 106  * name -   The name of the function as seen in the format string.  This is
 107  *          what maps a particular function name into a format instruction.
 108  * type -   The type of argument this function expects.  Those types are
 109  *          listed above (with the TF_ prefix).  This affects what gets
 110  *          placed in the format instruction (the f_un union).  Also,
 111  *          instructions that require special handling are distinguished
 112  *          here (TF_MYMBOX is one example).
 113  * f_type - The instruction corresponding to this function (from the list
 114  *          in fmt_compile.h).
 115  * extra  - Used by some functions to provide extra data to the compiler.
 116  *          Uses include:
 117  *              - Providing an alternate instruction to combine a load
 118  *                and test operation (see do_if()).
 119  *              - Passed in f_value in the format instruction to provide
 120  *                extra information for the engine (see FT_LV_DAT handling
 121  *                in fmt_scan.c).
 122  *              - Provide a hint as to preprocessing that is required for
 123  *                this instruction (see do_name()).
 124  * flags  - See the definitions for TFL_PUTS & TFL_PUTN above.
 125  */
 126
 127 struct ftable {
 128     char *name;         /* function name                  */
 129     char type;          /* argument type                  */
 130     char f_type;        /* fmt type                       */
 131     char extra;         /* arg. type dependent extra info */
 132     char flags;
 133 };
 134
 135 static struct ftable functable[] = {
 136      { "nonzero",    TF_EXPR,   FT_V_NE,        FT_IF_V_NE,     0 },
 137      { "zero",       TF_EXPR,   FT_V_EQ,        FT_IF_V_EQ,     0 },
 138      { "eq",         TF_NUM,    FT_V_EQ,        FT_IF_V_EQ,     0 },
 139      { "ne",         TF_NUM,    FT_V_NE,        FT_IF_V_NE,     0 },
 140      { "gt",         TF_NUM,    FT_V_GT,        FT_IF_V_GT,     0 },
 141      { "null",       TF_EXPR,   FT_S_NULL,      FT_IF_S_NULL,   0 },
 142      { "nonnull",    TF_EXPR,   FT_S_NONNULL,   FT_IF_S,        0 },
 143      { "match",      TF_STR,    FT_V_MATCH,     FT_IF_MATCH,    0 },
 144      { "amatch",     TF_STR,    FT_V_AMATCH,    FT_IF_AMATCH,   0 },
 145
 146      { "putstr",     TF_EXPR,   FT_STR,         0,              0 },
 147      { "putstrf",    TF_EXPR,   FT_STRF,        0,              0 },
 148      { "putnum",     TF_EXPR,   FT_NUM,         0,              0 },
 149      { "putnumf",    TF_EXPR,   FT_NUMF,        0,              0 },
 150      { "putaddr",    TF_STR,    FT_PUTADDR,     0,              0 },
 151      { "putlit",     TF_EXPR,   FT_STRLIT,      0,              0 },
 152      { "zputlit",    TF_EXPR,   FT_STRLITZ,     0,              0 },
 153      { "void",       TF_NOP,    0,              0,              0 },
 154
 155      { "comp",       TF_COMP,   FT_LS_COMP,     0,              TFL_PUTS },
 156      { "lit",        TF_STR,    FT_LS_LIT,      0,              TFL_PUTS },
 157      { "getenv",     TF_STR,    FT_LS_GETENV,   0,              TFL_PUTS },
 158      { "profile",    TF_STR,    FT_LS_CFIND,    0,              TFL_PUTS },
 159      { "decodecomp", TF_COMP,   FT_LS_DECODECOMP, 0,            TFL_PUTS },
 160      { "decode",     TF_EXPR,   FT_LS_DECODE,   0,              TFL_PUTS },
 161      { "trim",       TF_EXPR,   FT_LS_TRIM,     0,              0 },
 162      { "kilo",       TF_EXPR,   FT_LS_KILO,     0,              TFL_PUTS },
 163      { "kibi",       TF_EXPR,   FT_LS_KIBI,     0,              TFL_PUTS },
 164      { "compval",    TF_COMP,   FT_LV_COMP,     0,              TFL_PUTN },
 165      { "compflag",   TF_COMP,   FT_LV_COMPFLAG, 0,              TFL_PUTN },
 166      { "num",        TF_NUM,    FT_LV_LIT,      0,              TFL_PUTN },
 167      { "msg",        TF_NONE,   FT_LV_DAT,      0,              TFL_PUTN },
 168      { "cur",        TF_NONE,   FT_LV_DAT,      1,              TFL_PUTN },
 169      { "size",       TF_NONE,   FT_LV_DAT,      2,              TFL_PUTN },
 170      { "width",      TF_NONE,   FT_LV_DAT,      3,              TFL_PUTN },
 171      { "unseen",     TF_NONE,   FT_LV_DAT,      4,              TFL_PUTN },
 172      { "dat",        TF_NUM,    FT_LV_DAT,      0,              TFL_PUTN },
 173      { "strlen",     TF_NONE,   FT_LV_STRLEN,   0,              TFL_PUTN },
 174      { "me",         TF_MYBOX,  FT_LS_LIT,      0,              TFL_PUTS },
 175      { "myname",     TF_MYNAME, FT_LS_LIT,      0,              TFL_PUTS },
 176      { "myhost",     TF_MYHOST, FT_LS_LIT,      0,              TFL_PUTS },
 177      { "localmbox",  TF_LMBOX,  FT_LS_LIT,      0,              TFL_PUTS },
 178      { "plus",       TF_NUM,    FT_LV_PLUS_L,   0,              TFL_PUTN },
 179      { "minus",      TF_NUM,    FT_LV_MINUS_L,  0,              TFL_PUTN },
 180      { "multiply",   TF_NUM,    FT_LV_MULTIPLY_L, 0,            TFL_PUTN },
 181      { "divide",     TF_NUM,    FT_LV_DIVIDE_L, 0,              TFL_PUTN },
 182      { "modulo",     TF_NUM,    FT_LV_MODULO_L, 0,              TFL_PUTN },
 183      { "charleft",   TF_NONE,   FT_LV_CHAR_LEFT, 0,             TFL_PUTN },
 184      { "timenow",    TF_NOW,    FT_LV_LIT,      0,              TFL_PUTN },
 185
 186      { "month",      TF_COMP,   FT_LS_MONTH,    FT_PARSEDATE,   TFL_PUTS },
 187      { "lmonth",     TF_COMP,   FT_LS_LMONTH,   FT_PARSEDATE,   TFL_PUTS },
 188      { "tzone",      TF_COMP,   FT_LS_ZONE,     FT_PARSEDATE,   TFL_PUTS },
 189      { "day",        TF_COMP,   FT_LS_DAY,      FT_PARSEDATE,   TFL_PUTS },
 190      { "weekday",    TF_COMP,   FT_LS_WEEKDAY,  FT_PARSEDATE,   TFL_PUTS },
 191      { "tws",        TF_COMP,   FT_LS_822DATE,  FT_PARSEDATE,   TFL_PUTS },
 192      { "sec",        TF_COMP,   FT_LV_SEC,      FT_PARSEDATE,   TFL_PUTN },
 193      { "min",        TF_COMP,   FT_LV_MIN,      FT_PARSEDATE,   TFL_PUTN },
 194      { "hour",       TF_COMP,   FT_LV_HOUR,     FT_PARSEDATE,   TFL_PUTN },
 195      { "mday",       TF_COMP,   FT_LV_MDAY,     FT_PARSEDATE,   TFL_PUTN },
 196      { "mon",        TF_COMP,   FT_LV_MON,      FT_PARSEDATE,   TFL_PUTN },
 197      { "year",       TF_COMP,   FT_LV_YEAR,     FT_PARSEDATE,   TFL_PUTN },
 198      { "yday",       TF_COMP,   FT_LV_YDAY,     FT_PARSEDATE,   TFL_PUTN },
 199      { "wday",       TF_COMP,   FT_LV_WDAY,     FT_PARSEDATE,   TFL_PUTN },
 200      { "zone",       TF_COMP,   FT_LV_ZONE,     FT_PARSEDATE,   TFL_PUTN },
 201      { "clock",      TF_COMP,   FT_LV_CLOCK,    FT_PARSEDATE,   TFL_PUTN },
 202      { "rclock",     TF_COMP,   FT_LV_RCLOCK,   FT_PARSEDATE,   TFL_PUTN },
 203      { "sday",       TF_COMP,   FT_LV_DAYF,     FT_PARSEDATE,   TFL_PUTN },
 204      { "szone",      TF_COMP,   FT_LV_ZONEF,    FT_PARSEDATE,   TFL_PUTN },
 205      { "dst",        TF_COMP,   FT_LV_DST,      FT_PARSEDATE,   TFL_PUTN },
 206      { "pretty",     TF_COMP,   FT_LS_PRETTY,   FT_PARSEDATE,   TFL_PUTS },
 207      { "nodate",     TF_COMP,   FT_LV_COMPFLAG, FT_PARSEDATE,   TFL_PUTN },
 208      { "date2local", TF_COMP,   FT_LOCALDATE,   FT_PARSEDATE,   0 },
 209      { "date2gmt",   TF_COMP,   FT_GMTDATE,     FT_PARSEDATE,   0 },
 210
 211      { "pers",       TF_COMP,   FT_LS_PERS,     FT_PARSEADDR,   TFL_PUTS },
 212      { "mbox",       TF_COMP,   FT_LS_MBOX,     FT_PARSEADDR,   TFL_PUTS },
 213      { "host",       TF_COMP,   FT_LS_HOST,     FT_PARSEADDR,   TFL_PUTS },
 214      { "path",       TF_COMP,   FT_LS_PATH,     FT_PARSEADDR,   TFL_PUTS },
 215      { "gname",      TF_COMP,   FT_LS_GNAME,    FT_PARSEADDR,   TFL_PUTS },
 216      { "note",       TF_COMP,   FT_LS_NOTE,     FT_PARSEADDR,   TFL_PUTS },
 217      { "addr",       TF_COMP,   FT_LS_ADDR,     FT_PARSEADDR,   TFL_PUTS },
 218      { "proper",     TF_COMP,   FT_LS_822ADDR,  FT_PARSEADDR,   TFL_PUTS },
 219      { "type",       TF_COMP,   FT_LV_HOSTTYPE, FT_PARSEADDR,   TFL_PUTN },
 220      { "ingrp",      TF_COMP,   FT_LV_INGRPF,   FT_PARSEADDR,   TFL_PUTN },
 221      { "nohost",     TF_COMP,   FT_LV_NOHOSTF,  FT_PARSEADDR,   TFL_PUTN },
 222      { "formataddr", TF_EXPR_SV,FT_FORMATADDR,  FT_FORMATADDR,  0 },
 223      { "concataddr", TF_EXPR_SV,FT_CONCATADDR,  FT_FORMATADDR,  0 },
 224      { "friendly",   TF_COMP,   FT_LS_FRIENDLY, FT_PARSEADDR,   TFL_PUTS },
 225
 226      { "mymbox",     TF_COMP,   FT_LV_COMPFLAG, FT_MYMBOX,      TFL_PUTN },
 227      { "getmymbox",  TF_COMP,   FT_STR,         FT_GETMYMBOX,   0 },
 228      { "getmyaddr",  TF_COMP,   FT_LS_ADDR,     FT_GETMYADDR,   TFL_PUTS },
 229
 230      { "unquote",    TF_EXPR,   FT_LS_UNQUOTE,  0,              TFL_PUTS },
 231
 232      { "bold",       TF_BOLD,   FT_LS_LIT,      0,              TFL_PUTS },
 233      { "underline",  TF_UNDERLN,FT_LS_LIT,      0,              TFL_PUTS },
 234      { "standout",   TF_STNDOUT,FT_LS_LIT,      0,              TFL_PUTS },
 235      { "resetterm",  TF_RESET,  FT_LS_LIT,      0,              TFL_PUTS },
 236      { "hascolor",   TF_HASCLR, FT_LV_LIT,      0,              0 },
 237      { "fgcolor",    TF_FGCOLR, FT_LS_LIT,      0,              TFL_PUTS },
 238      { "bgcolor",    TF_BGCOLR, FT_LS_LIT,      0,              TFL_PUTS },
 239
 240      { NULL,         0,         0,              0,              0 }
 241 };
 242
 243 /*
 244  * A mapping of color names to terminfo color numbers.
 245  *
 246  * There are two sets of terminal-setting codes: 'setaf/setab' (ANSI) and
 247  * 'setf/setb'.  Different terminals support different capabilities, so
 248  * we provide a mapping for both.  I'm not crazy about putting numbers
 249  * directly in here, but it seems these are well defined by terminfo
 250  * so it should be okay.
 251  */
 252
 253 struct colormap {
 254     char *colorname;    /* Name of color */
 255     int ansinum;        /* The ANSI escape color number */
 256     int nonansinum;     /* The non-ANSI escape color number */
 257 };
 258
 259 static struct colormap colortable[] = {
 260     { "black",          0,      0 },
 261     { "red",            1,      4 },
 262     { "green",          2,      2 },
 263     { "yellow",         3,      6 },
 264     { "blue",           4,      1 },
 265     { "magenta",        5,      5 },
 266     { "cyan",           6,      3 },
 267     { "white",          7,      7 },
 268     { NULL,             0,      0 }
 269 };
 270
 271 /* Hash function for component name.  Deliberately avoids a function
 272  * call.  Is case independent.  Covers interval [0, 126] so never uses
 273  * the last element of wantcomp[]. This function is "pretty good". */
 274 #define CHASH(nm) ( \
 275         (( \
 276             ((nm)[0]) - ((nm)[0] ? ((nm)[1]) : 0) \
 277         ) & 0x1f) + \
 278         ((nm[1]) ? (((nm)[2]) & 0x5f) : 0) \
 279     )
 280
 281 /*
 282  * Find a component in the hash table.
 283  */
 284 #define FINDCOMP(comp,name) \
 285                 for (comp = wantcomp[CHASH(name)]; \
 286                      comp && strcmp(comp->c_name,name); \
 287                      comp = comp->c_next) \
 288                 ;
 289
 290 /* Add new component to the hash table */
 291 #define NEWCOMP(cm,name) do { \
 292         NEW0(cm);\
 293         cm->c_name = mh_xstrdup(name);\
 294         cm->c_refcount++;\
 295         ncomp++;\
 296         i = CHASH(name);\
 297         cm->c_next = wantcomp[i];\
 298         wantcomp[i] = cm; \
 299         } while (0)
 300
 301 #define NEWFMT (next_fp++)
 302 #define NEW_FP(type,fill,wid) do {\
 303         fp=NEWFMT; fp->f_type=(type); fp->f_fill=(fill); fp->f_width=(wid); \
 304         } while (0)
 305
 306 /* Add (possibly new) component to the hash table */
 307 #define ADDC(name) do { \
 308         FINDCOMP(cm, name);\
 309         if (!cm) {\
 310             NEWCOMP(cm,name);\
 311         }\
 312         fp->f_comp = cm; \
 313         fp->f_flags |= FF_COMPREF; \
 314         cm->c_refcount++; \
 315         } while (0)
 316
 317 #define LV(type, value)         do { NEW_FP(type,0,0); fp->f_value = (value); } while (0)
 318 #define LS(type, str)           do { NEW_FP(type,0,0); fp->f_text = getcpy(str); fp->f_flags |= FF_STRALLOC; } while (0)
 319
 320 #define PUTCOMP(comp)           do { NEW_FP(FT_COMP,0,0); ADDC(comp); } while (0)
 321 #define PUTLIT(str)             do { NEW_FP(FT_LIT,0,0); fp->f_text = getcpy(str); fp->f_flags |= FF_STRALLOC; } while (0)
 322 #define PUTC(c)                 do { NEW_FP(FT_CHAR,0,0); fp->f_char = (c); } while (0)
 323
 324 static char *format_string;
 325 static char *usr_fstring;       /* for CERROR */
 326
 327 #define CERROR(str) compile_error (str, cp)
 328
 329 /*
 330  * static prototypes
 331  */
 332 static struct ftable *lookup(char *);
 333 static void compile_error(char *, char *);
 334 static char *compile (char *);
 335 static char *do_spec(char *);
 336 static char *do_name(char *, int);
 337 static char *do_func(char *);
 338 static char *do_expr (char *, int);
 339 static char *do_loop(char *);
 340 static char *do_if(char *);
 341 static void free_component(struct comp *);
 342 static void free_comptable(void);
 343
 344 /*
 345  * Lookup a function name in the functable
 346  */
 347 static struct ftable *
 348 lookup(char *name)
 349 {
 350     struct ftable *t = functable;
 351     char *nm;
 352     char c = *name;
 353
 354     while ((nm = t->name)) {
 355         if (*nm == c && strcmp (nm, name) == 0)
 356             return (ftbl = t);
 357
 358         t++;
 359     }
 360     return (struct ftable *) 0;
 361 }
 362
 363
 364 static void
 365 compile_error(char *str, char *cp)
 366 {
 367     int i, errpos, errctx;
 368
 369     errpos = cp - format_string;
 370     errctx = errpos > 20 ? 20 : errpos;
 371     usr_fstring[errpos] = '\0';
 372
 373     for (i = errpos-errctx; i < errpos; i++) {
 374         if (iscntrl((unsigned char) usr_fstring[i]))
 375             usr_fstring[i] = '_';
 376     }
 377
 378     advise(NULL, "\"%s\": format compile error - %s",
 379            &usr_fstring[errpos-errctx], str);
 380     adios (NULL, "%*s", errctx+1, "^");
 381 }
 382
 383 /*
 384  * Compile format string "fstring" into format list "fmt".
 385  * Return the number of header components found in the format
 386  * string.
 387  */
 388
 389 int
 390 fmt_compile(char *fstring, struct format **fmt, int reset_comptable)
 391 {
 392     char *cp;
 393     size_t i;
 394     static int comptable_initialized = 0;
 395
 396     format_string = mh_xstrdup(fstring);
 397     usr_fstring = fstring;
 398
 399     if (reset_comptable || !comptable_initialized) {
 400         free_comptable();
 401         comptable_initialized = 1;
 402     }
 403
 404     /* it takes at least 4 char to generate one format so we
 405      * allocate a worst-case format array using 1/4 the length
 406      * of the format string.  We actually need twice this much
 407      * to handle both pre-processing (e.g., address parsing) and
 408      * normal processing.
 409      */
 410     i = strlen(fstring)/2 + 1;
 411                 if (i==1) i++;
 412     next_fp = formatvec = mh_xcalloc(i, sizeof *next_fp);
 413     infunction = 0;
 414
 415     cp = compile(format_string);
 416     if (*cp) {
 417         CERROR("extra '%>', '%|' or '%?'");
 418     }
 419     LV(FT_DONE, 0);             /* really done */
 420     *fmt = formatvec;
 421
 422     free(format_string);
 423     return (ncomp);
 424 }
 425
 426 static char *
 427 compile (char *sp)
 428 {
 429     char *cp = sp;
 430     int  c;
 431
 432     for (;;) {
 433         sp = cp;
 434         while ((c = *cp) && c != '%')
 435             cp++;
 436         *cp = 0;
 437         switch (cp-sp) {
 438         case 0:
 439             break;
 440         case 1:
 441             PUTC(*sp);
 442             break;
 443         default:
 444             PUTLIT(sp);
 445             break;
 446         }
 447         if (c == 0)
 448             return (cp);
 449
 450         switch (c = *++cp) {
 451         case '%':
 452             PUTC (*cp);
 453             cp++;
 454             break;
 455
 456         case '|':
 457         case '>':
 458         case '?':
 459         case ']':
 460             return (cp);
 461
 462         case '<':
 463             cp = do_if(++cp);
 464             break;
 465
 466         case '[':       /* ] */
 467             cp = do_loop(++cp);
 468             break;
 469
 470         case ';':       /* comment line */
 471             cp++;
 472             while ((c = *cp++) && c != '\n')
 473                 continue;
 474             break;
 475
 476         default:
 477             cp = do_spec(cp);
 478             break;
 479         }
 480     }
 481 }
 482
 483
 484 /*
 485  * Process functions & components (handle field width here as well
 486  */
 487 static char *
 488 do_spec(char *sp)
 489 {
 490     char *cp = sp;
 491     int c;
 492 #ifndef lint
 493     int ljust = 0;
 494 #endif  /* not lint */
 495     int wid = 0;
 496     char fill = ' ';
 497
 498     c = *cp++;
 499     if (c == '-') {
 500         ljust++;
 501         c = *cp++;
 502     }
 503     if (c == '0') {
 504         fill = c;
 505         c = *cp++;
 506     }
 507     while (isdigit(c)) {
 508         wid = wid*10 + (c - '0');
 509         c = *cp++;
 510     }
 511     if (c == '{') {
 512         cp = do_name(cp, 0);
 513         if (! infunction)
 514             fp->f_type = wid? FT_COMPF : FT_COMP;
 515     }
 516     else if (c == '(') {
 517         cp = do_func(cp);
 518         if (! infunction) {
 519             if (ftbl->flags & TFL_PUTS) {
 520                 LV( wid? FT_STRF : FT_STR, ftbl->extra);
 521             }
 522             else if (ftbl->flags & TFL_PUTN) {
 523                 LV( wid? FT_NUMF : FT_NUM, ftbl->extra);
 524             }
 525         }
 526     }
 527     else {
 528         CERROR("component or function name expected");
 529     }
 530     if (ljust)
 531         wid = -wid;
 532     fp->f_width = wid;
 533     fp->f_fill = fill;
 534
 535     return (cp);
 536 }
 537
 538 /*
 539  * Process a component name.  Normally this involves generating an FT_COMP
 540  * instruction for the specified component.  If preprocess is set, then we
 541  * do some extra processing.
 542  */
 543 static char *
 544 do_name(char *sp, int preprocess)
 545 {
 546     char *cp = sp;
 547     int c;
 548     int i;
 549     static int primed = 0;
 550
 551     while (isalnum(c = *cp++) || c == '-' || c == '_')
 552         ;
 553     if (c != '}') {
 554         CERROR("'}' expected");
 555     }
 556     cp[-1] = '\0';
 557     PUTCOMP(sp);
 558     switch (preprocess) {
 559
 560     case FT_PARSEDATE:
 561         if (cm->c_type & CT_ADDR) {
 562             CERROR("component used as both date and address");
 563         }
 564         if (cm->c_tws) {
 565             memset (cm->c_tws, 0, sizeof *cm->c_tws);
 566         } else {
 567             NEW0(cm->c_tws);
 568         }
 569         fp->f_type = preprocess;
 570         PUTCOMP(sp);
 571         cm->c_type |= CT_DATE;
 572         break;
 573
 574     case FT_MYMBOX:
 575     case FT_GETMYMBOX:
 576     case FT_GETMYADDR:
 577         if (!primed) {
 578             ismymbox ((struct mailname *) 0);
 579             primed++;
 580         }
 581         /* FALLTHRU */
 582     case FT_PARSEADDR:
 583         if (cm->c_type & CT_DATE) {
 584             CERROR("component used as both date and address");
 585         }
 586         cm->c_mn = &fmt_mnull;
 587         fp->f_type = preprocess;
 588         PUTCOMP(sp);
 589         cm->c_type |= CT_ADDR;
 590         break;
 591
 592     case FT_FORMATADDR:
 593         if (cm->c_type & CT_DATE) {
 594             CERROR("component used as both date and address");
 595         }
 596         cm->c_type |= CT_ADDR;
 597         break;
 598     }
 599     return (cp);
 600 }
 601
 602 /*
 603  * Generate one or more instructions corresponding to the named function.
 604  * The different type of function arguments are handled here.
 605  */
 606 static char *
 607 do_func(char *sp)
 608 {
 609     char *cp = sp;
 610     int c;
 611     struct ftable *t;
 612     int n;
 613     int mflag;          /* minus sign in NUM */
 614
 615     infunction++;
 616
 617     while (isalnum(c = *cp++))
 618         ;
 619     if (c != '(' && c != '{' && c != ' ' && c != ')') {
 620         CERROR("'(', '{', ' ' or ')' expected");
 621     }
 622     cp[-1] = '\0';
 623     if ((t = lookup (sp)) == 0) {
 624         CERROR("unknown function");
 625     }
 626     if (isspace(c))
 627         c = *cp++;
 628
 629     switch (t->type) {
 630
 631     case TF_COMP:
 632         if (c != '{') {
 633             CERROR("component name expected");
 634         }
 635         cp = do_name(cp, t->extra);
 636         fp->f_type = t->f_type;
 637         c = *cp++;
 638         break;
 639
 640     case TF_NUM:
 641         if ((mflag = (c == '-')))
 642             c = *cp++;
 643         n = 0;
 644         while (isdigit(c)) {
 645             n = n*10 + (c - '0');
 646             c = *cp++;
 647         }
 648         if (mflag)
 649             n = (-n);
 650         LV(t->f_type,n);
 651         break;
 652
 653     case TF_STR:
 654         sp = cp - 1;
 655         while (c && c != ')')
 656             c = *cp++;
 657         cp[-1] = '\0';
 658         LS(t->f_type,sp);
 659         break;
 660
 661     case TF_NONE:
 662         LV(t->f_type,t->extra);
 663         break;
 664
 665     case TF_MYBOX:
 666         LS(t->f_type, getusername());
 667         break;
 668
 669     case TF_MYNAME:
 670         LS(t->f_type, getfullname());
 671         break;
 672
 673     case TF_MYHOST:
 674         LS(t->f_type, LocalName(0));
 675         break;
 676
 677     case TF_LMBOX:
 678         LS(t->f_type, getlocalmbox());
 679         break;
 680
 681     case TF_BOLD:
 682         LS(t->f_type, get_term_stringcap("bold"));
 683         break;
 684
 685     case TF_UNDERLN:
 686         LS(t->f_type, get_term_stringcap("smul"));
 687         break;
 688
 689     case TF_STNDOUT:
 690         LS(t->f_type, get_term_stringcap("smso"));
 691         break;
 692
 693     case TF_RESET:
 694         LS(t->f_type, get_term_stringcap("sgr0"));
 695         break;
 696
 697     case TF_HASCLR:
 698         LV(t->f_type, get_term_numcap("colors") > 1);
 699         break;
 700
 701     case TF_FGCOLR:
 702     case TF_BGCOLR: {
 703         struct colormap *cmap = colortable;
 704         char *code;
 705
 706         sp = cp - 1;
 707         while (c && c != ')')
 708             c = *cp++;
 709         cp[-1] = '\0';
 710
 711         while (cmap->colorname != NULL) {
 712             if (strcasecmp(sp, cmap->colorname) == 0)
 713                 break;
 714             cmap++;
 715         }
 716
 717         if (cmap->colorname == NULL) {
 718             CERROR("Unknown color name");
 719             break;
 720         }
 721
 722         code = get_term_stringparm(t->type == TF_FGCOLR ? "setaf" : "setab",
 723                                    cmap->ansinum, 0);
 724
 725         /*
 726          * If this doesn't have anything, try falling back to setf/setb
 727          */
 728
 729         if (! code)
 730             code = get_term_stringparm(t->type == TF_FGCOLR ? "setf" : "setb",
 731                                        cmap->nonansinum, 0);
 732
 733         LS(t->f_type, code);
 734         break;
 735     }
 736
 737     case TF_NOW:
 738         LV(t->f_type, time((time_t *) 0));
 739         break;
 740
 741     case TF_EXPR_SV:
 742         LV(FT_SAVESTR, 0);
 743         /* FALLTHRU */
 744     case TF_EXPR:
 745         *--cp = c;
 746         cp = do_expr(cp, t->extra);
 747         LV(t->f_type, 0);
 748         c = *cp++;
 749         ftbl = t;
 750         break;
 751
 752     case TF_NOP:
 753         *--cp = c;
 754         cp = do_expr(cp, t->extra);
 755         c = *cp++;
 756         ftbl = t;
 757         break;
 758     }
 759     if (c != ')') {
 760         CERROR("')' expected");
 761     }
 762     --infunction;
 763     return (cp);
 764 }
 765
 766 /*
 767  * Handle an expression as an argument.  Basically we call one of do_name(),
 768  * do_func(), or do_if()
 769  */
 770 static char *
 771 do_expr (char *sp, int preprocess)
 772 {
 773     char *cp = sp;
 774     int  c;
 775
 776     if ((c = *cp++) == '{') {
 777         cp = do_name (cp, preprocess);
 778         fp->f_type = FT_LS_COMP;
 779     } else if (c == '(') {
 780         cp = do_func (cp);
 781     } else if (c == ')') {
 782         return (--cp);
 783     } else if (c == '%' && *cp == '<') {
 784         cp = do_if (cp+1);
 785     } else {
 786         CERROR ("'(', '{', '%<' or ')' expected");
 787     }
 788     return (cp);
 789 }
 790
 791 /*
 792  * I am guessing this was for some kind of loop statement, which would have
 793  * looked like %[ .... %].  It looks like the way this would have worked
 794  * is that the format engine would have seen that FT_DONE had a 1 in the
 795  * f_un.f_un_value and then decided whether or not to continue the loop.
 796  * There is no support for this in the format engine, so right now if
 797  * you try using it you will reach the FT_DONE and simply stop.  I'm leaving
 798  * this here in case someone wants to continue the work.
 799  *
 800  * Okay, got some more information on this from John L. Romine!  From an
 801  * email he sent to the nmh-workers mailing list on December 2, 2010, he
 802  * explains it thusly:
 803  *
 804  *    In this case (scan, formatsbr) it has to do with an extension to
 805  *    the mh-format syntax to allow for looping.
 806  *
 807  *    The scan format is processed once for each message.  Those #ifdef
 808  *    JLR changes allowed for the top part of the format file to be
 809  *    processed once, then a second, looping part to be processed
 810  *    once per message.  As I recall, there were new mh-format escape
 811  *    sequences to delimit the loop.  This would have allowed for things
 812  *    like per-format column headings in the scan output.
 813  *
 814  *    Since existing format files didn't include the scan listing
 815  *    header (it was hard-coded in scan.c) it would not have been
 816  *    backward-compatible.  All existing format files (including any
 817  *    local ones) would have needed to be changed to include the format
 818  *    codes for a header.  The practice at the time was not to introduce
 819  *    incompatible changes in a minor release, and I never managed to
 820  *    put out a newer major release.
 821  *
 822  * I can see how this would work, and I suspect part of the motivation was
 823  * because the format compiler routines (at the time) couldn't really be
 824  * called multiple times on the same message because the memory management
 825  * was so lousy.  That's been reworked and things are now a lot cleaner,
 826  * so I suspect if we're going to allow a format string to be used for the
 827  * scan header it might be simpler to have a separate format string just
 828  * for the header.  But I'll leave this code in for now just in case we
 829  * decide that we want some kind of looping support.
 830  */
 831 static char *
 832 do_loop(char *sp)
 833 {
 834     char *cp = sp;
 835     struct format *floop;
 836
 837     floop = next_fp;
 838     cp = compile (cp);
 839     if (*cp++ != ']')
 840         CERROR ("']' expected");
 841
 842     LV(FT_DONE, 1);             /* not yet done */
 843     LV(FT_GOTO, 0);
 844     fp->f_skip = floop - fp;    /* skip backwards */
 845
 846     return cp;
 847 }
 848
 849 /*
 850  * Handle an if-elsif-endif statement.  Note here that the branching
 851  * is handled by the f_skip member of the struct format (which is really
 852  * just f_width overloaded).  This number controls how far to move forward
 853  * (or back) in the format instruction array.
 854  */
 855 static char *
 856 do_if(char *sp)
 857 {
 858     char *cp = sp;
 859     struct format *fexpr,
 860                            *fif = (struct format *)NULL;
 861     int c = '<';
 862
 863     for (;;) {
 864         if (c == '<') {                 /* doing an IF */
 865             if ((c = *cp++) == '{') /*}*/{
 866                 cp = do_name(cp, 0);
 867                 fp->f_type = FT_LS_COMP;
 868                 LV (FT_IF_S, 0);
 869             }
 870             else if (c == '(') {
 871                 cp = do_func(cp);
 872                 /* see if we can merge the load and the "if" */
 873                 if (ftbl->f_type >= IF_FUNCS)
 874                     fp->f_type = ftbl->extra;
 875                 else {
 876                     /* Put out a string test or a value test depending
 877                      * on what this function's return type is.
 878                      */
 879                     if (ftbl->flags & TFL_PUTS) {
 880                         LV (FT_IF_S, 0);
 881                     } else {
 882                         LV (FT_IF_V_NE, 0);
 883                     }
 884                 }
 885             }
 886             else {
 887                 CERROR("'(' or '{' expected");  /*}*/
 888             }
 889         }
 890
 891         fexpr = fp;                     /* loc of [ELS]IF */
 892         cp = compile (cp);              /* compile IF TRUE stmts */
 893         if (fif)
 894             fif->f_skip = next_fp - fif;
 895
 896         if ((c = *cp++) == '|') {       /* the last ELSE */
 897             LV(FT_GOTO, 0);
 898             fif = fp;                   /* loc of GOTO */
 899             fexpr->f_skip = next_fp - fexpr;
 900
 901             fexpr = (struct format *)NULL;/* no extra ENDIF */
 902
 903             cp = compile (cp);          /* compile ELSE stmts */
 904             fif->f_skip = next_fp - fif;
 905             c = *cp++;
 906         }
 907         else if (c == '?') {            /* another ELSIF */
 908             LV(FT_GOTO, 0);
 909             fif = fp;                   /* loc of GOTO */
 910             fexpr->f_skip = next_fp - fexpr;
 911
 912             c = '<';                    /* impersonate an IF */
 913             continue;
 914         }
 915         break;
 916     }
 917
 918     if (c != '>') {
 919         CERROR("'>' expected.");
 920     }
 921
 922     if (fexpr)                          /* IF ... [ELSIF ...] ENDIF */
 923         fexpr->f_skip = next_fp - fexpr;
 924
 925     return (cp);
 926 }
 927
 928 /*
 929  * Free a set of format instructions.
 930  *
 931  * What we do here is:
 932  *
 933  * - Iterate through the list of format instructions, freeing any references
 934  *   to allocated memory in each instruction.
 935  * - Free component references.
 936  * - If requested, reset the component hash table; that will also free any
 937  *   references to components stored there.
 938  *
 939  */
 940
 941 void
 942 fmt_free(struct format *fmt, int reset_comptable)
 943 {
 944     struct format *fp = fmt;
 945
 946     if (fp) {
 947         while (! (fp->f_type == FT_DONE && fp->f_value == 0)) {
 948             if (fp->f_flags & FF_STRALLOC)
 949                 free(fp->f_text);
 950             if (fp->f_flags & FF_COMPREF)
 951                 free_component(fp->f_comp);
 952             fp++;
 953         }
 954         free(fmt);
 955     }
 956
 957     if (reset_comptable)
 958         free_comptable();
 959 }
 960
 961 /*
 962  * Free just the text strings from all of the component hash table entries
 963  */
 964
 965 void
 966 fmt_freecomptext(void)
 967 {
 968     unsigned int i;
 969     struct comp *cm;
 970
 971     for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++)
 972         for (cm = wantcomp[i]; cm; cm = cm->c_next) {
 973             mh_xfree(cm->c_text);
 974             cm->c_text = NULL;
 975         }
 976 }
 977
 978 /*
 979  * Find a component in our hash table.  This is just a public interface to
 980  * the FINDCOMP macro, so we don't have to expose our hash table.
 981  */
 982
 983 struct comp *
 984 fmt_findcomp(char *component)
 985 {
 986     struct comp *cm;
 987
 988     FINDCOMP(cm, component);
 989
 990     return cm;
 991 }
 992
 993 /*
 994  * Like fmt_findcomp, but case-insensitive.
 995  */
 996
 997 struct comp *
 998 fmt_findcasecomp(char *component)
 999 {
1000     struct comp *cm;
1001
1002     for (cm = wantcomp[CHASH(component)]; cm; cm = cm->c_next)
1003         if (strcasecmp(component, cm->c_name ? cm->c_name : "") == 0)
1004             break;
1005
1006     return cm;
1007 }
1008
1009 /*
1010  * Add an entry to the component hash table
1011  *
1012  * Returns true if the component was added, 0 if it already existed.
1013  *
1014  */
1015
1016 int
1017 fmt_addcompentry(char *component)
1018 {
1019     struct comp *cm;
1020     int i;
1021
1022     FINDCOMP(cm, component);
1023
1024     if (cm)
1025         return 0;
1026
1027     NEWCOMP(cm, component);
1028
1029     /*
1030      * ncomp is really meant for fmt_compile() and this function is
1031      * meant to be used outside of it.  So decrement it just to be safe
1032      * (internal callers should be using NEWCOMP()).
1033      */
1034
1035     ncomp--;
1036
1037     return 1;
1038 }
1039
1040 /*
1041  * Add a string to a component hash table entry.
1042  *
1043  * Note the special handling for components marked with CT_ADDR.  The comments
1044  * in fmt_scan.h explain this in more detail.
1045  */
1046
1047 int
1048 fmt_addcomptext(char *component, char *text)
1049 {
1050     int i, found = 0, bucket = CHASH(component);
1051     struct comp *cptr = wantcomp[bucket];
1052     char *cp;
1053
1054     while (cptr) {
1055         if (strcasecmp(component, cptr->c_name ? cptr->c_name : "") == 0) {
1056             found++;
1057             if (! cptr->c_text) {
1058                 cptr->c_text = getcpy(text);
1059             } else {
1060                 i = strlen(cp = cptr->c_text) - 1;
1061                 if (cp[i] == '\n') {
1062                     if (cptr->c_type & CT_ADDR) {
1063                         cp[i] = '\0';
1064                         cp = add(",\n\t", cp);
1065                     } else {
1066                         cp = add("\t", cp);
1067                     }
1068                 }
1069                 cptr->c_text = add(text, cp);
1070             }
1071         }
1072         cptr = cptr->c_next;
1073     }
1074
1075     return found ? bucket : -1;
1076 }
1077
1078 /*
1079  * Append text to a component we've already found.  See notes in fmt_scan.h
1080  * for more information.
1081  */
1082
1083 void
1084 fmt_appendcomp(int bucket, char *component, char *text)
1085 {
1086     struct comp *cptr;
1087
1088     if (bucket != -1) {
1089         for (cptr = wantcomp[bucket]; cptr; cptr = cptr->c_next)
1090             if (strcasecmp(component, cptr->c_name ? cptr->c_name : "") == 0)
1091                 cptr->c_text = add(text, cptr->c_text);
1092     }
1093 }
1094
1095 /*
1096  * Iterate over our component hash table
1097  */
1098
1099 struct comp *
1100 fmt_nextcomp(struct comp *comp, unsigned int *bucket)
1101 {
1102     if (comp == NULL)
1103         *bucket = 0;
1104     else
1105         comp = comp->c_next;
1106
1107     while (comp == NULL && *bucket < sizeof(wantcomp)/sizeof(wantcomp[0])) {
1108         comp = wantcomp[(*bucket)++];
1109     }
1110
1111     return comp;
1112 }
1113
1114 /*
1115  * Free and reset our component hash table
1116  */
1117
1118 static void
1119 free_comptable(void)
1120 {
1121     unsigned int i;
1122     struct comp *cm, *cm2;
1123
1124     for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++) {
1125         cm = wantcomp[i];
1126         while (cm != NULL) {
1127             cm2 = cm->c_next;
1128             free_component(cm);
1129             cm = cm2;
1130         }
1131         wantcomp[i] = 0;
1132     }
1133
1134     ncomp = 0;
1135 }
1136
1137 /*
1138  * Decrement the reference count of a component structure.  If it reaches
1139  * zero, free it
1140  */
1141
1142 static void
1143 free_component(struct comp *cm)
1144 {
1145     if (--cm->c_refcount <= 0) {
1146         /* Shouldn't ever be NULL, but just in case ... */
1147         mh_xfree(cm->c_name);
1148         mh_xfree(cm->c_text);
1149         if (cm->c_type & CT_DATE)
1150             free(cm->c_tws);
1151         if (cm->c_type & CT_ADDR && cm->c_mn && cm->c_mn != &fmt_mnull)
1152             mnfree(cm->c_mn);
1153         free(cm);
1154     }
1155 }