be0c04c1123d2cca7217f97ad20093630d3d9602
[mmh] / 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 fmtdump 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 fmtdump.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
51 #ifdef HAVE_SYS_TIME_H
52 # include <sys/time.h>
53 #endif
54 #include <time.h>
55
56 /*
57  * hash table for deciding if a component is "interesting"
58  */
59 static struct comp *wantcomp[128];
60
61 static struct format *formatvec;        /* array to hold formats */
62 static struct format *next_fp;          /* next free format slot */
63 static struct format *fp;               /* current format slot   */
64 static struct comp *cm;                 /* most recent comp ref  */
65 static struct ftable *ftbl;             /* most recent func ref  */
66 static int ncomp;
67 static int infunction;                  /* function nesting cnt  */
68
69 extern struct mailname fmt_mnull;
70
71 /* ftable->type (argument type) */
72 #define TF_COMP    0        /* component expected                 */
73 #define TF_NUM     1        /* number expected                    */
74 #define TF_STR     2        /* string expected                    */
75 #define TF_EXPR    3        /* component or func. expected        */
76 #define TF_NONE    4        /* no argument                        */
77 #define TF_MYBOX   5        /* special - get current user's mbox  */
78 #define TF_NOW     6        /* special - get current unix time    */
79 #define TF_EXPR_SV 7        /* like expr but save current str reg */
80 #define TF_NOP     8        /* like expr but no result            */
81 #define TF_MYNAME  9        /* special - get current name of user */
82 #define TF_MYHOST  10       /* special - get "local" hostname     */
83 #define TF_LMBOX   11       /* special - get full local mailbox   */
84
85 /* ftable->flags */
86 /* NB that TFL_PUTS is also used to decide whether the test
87  * in a "%<(function)..." should be a string or numeric one.
88  */
89 #define TFL_PUTS   1        /* implicit putstr if top level */
90 #define TFL_PUTN   2        /* implicit putnum if top level */
91
92 /*
93  * The functable array maps between the text names of format functions and
94  * the format instructions interpreted by the engine in fmt_scan.c.
95  *
96  * The elements of this structure are as follows:
97  *
98  * name -   The name of the function as seen in the format string.  This is
99  *          what maps a particular function name into a format instruction.
100  * type -   The type of argument this function expects.  Those types are
101  *          listed above (with the TF_ prefix).  This affects what gets
102  *          placed in the format instruction (the f_un union).
103  * f_type - The instruction corresponding to this function (from the list
104  *          in fmt_compile.h).
105  * extra  - Used by some functions to provide extra data to the compiler.
106  *          Uses include:
107  *              - Providing an alternate instruction to combine a load
108  *                and test operation (see do_if()).
109  *              - Passed in f_value in the format instruction to provide
110  *                extra information for the engine (see FT_LV_DAT handling
111  *                in fmt_scan.c).
112  *              - Provide a hint as to preprocessing that is required for
113  *                this instruction (see do_name()).
114  * flags  - See the definitions for TFL_PUTS & TFL_PUTN above.
115  */
116
117 struct ftable {
118     char *name;         /* function name                  */
119     char type;          /* argument type                  */
120     char f_type;        /* fmt type                       */
121     char extra;         /* arg. type dependent extra info */
122     char flags;
123 };
124
125 static struct ftable functable[] = {
126      { "nonzero",    TF_EXPR,   FT_V_NE,        FT_IF_V_NE,     0 },
127      { "zero",       TF_EXPR,   FT_V_EQ,        FT_IF_V_EQ,     0 },
128      { "eq",         TF_NUM,    FT_V_EQ,        FT_IF_V_EQ,     0 },
129      { "ne",         TF_NUM,    FT_V_NE,        FT_IF_V_NE,     0 },
130      { "gt",         TF_NUM,    FT_V_GT,        FT_IF_V_GT,     0 },
131      { "null",       TF_EXPR,   FT_S_NULL,      FT_IF_S_NULL,   0 },
132      { "nonnull",    TF_EXPR,   FT_S_NONNULL,   FT_IF_S,        0 },
133      { "match",      TF_STR,    FT_V_MATCH,     FT_IF_MATCH,    0 },
134      { "amatch",     TF_STR,    FT_V_AMATCH,    FT_IF_AMATCH,   0 },
135
136      { "putstr",     TF_EXPR,   FT_STR,         0,              0 },
137      { "putstrf",    TF_EXPR,   FT_STRF,        0,              0 },
138      { "putnum",     TF_EXPR,   FT_NUM,         0,              0 },
139      { "putnumf",    TF_EXPR,   FT_NUMF,        0,              0 },
140      { "putaddr",    TF_STR,    FT_PUTADDR,     0,              0 },
141      { "putlit",     TF_EXPR,   FT_STRLIT,      0,              0 },
142      { "zputlit",    TF_EXPR,   FT_STRLITZ,     0,              0 },
143      { "void",       TF_NOP,    0,              0,              0 },
144
145      { "comp",       TF_COMP,   FT_LS_COMP,     0,              TFL_PUTS },
146      { "lit",        TF_STR,    FT_LS_LIT,      0,              TFL_PUTS },
147      { "getenv",     TF_STR,    FT_LS_GETENV,   0,              TFL_PUTS },
148      { "profile",    TF_STR,    FT_LS_CFIND,    0,              TFL_PUTS },
149      { "decodecomp", TF_COMP,   FT_LS_DECODECOMP, 0,            TFL_PUTS },
150      { "decode",     TF_EXPR,   FT_LS_DECODE,   0,              TFL_PUTS },
151      { "trim",       TF_EXPR,   FT_LS_TRIM,     0,              0 },
152      { "compval",    TF_COMP,   FT_LV_COMP,     0,              TFL_PUTN },
153      { "compflag",   TF_COMP,   FT_LV_COMPFLAG, 0,              TFL_PUTN },
154      { "num",        TF_NUM,    FT_LV_LIT,      0,              TFL_PUTN },
155      { "msg",        TF_NONE,   FT_LV_DAT,      0,              TFL_PUTN },
156      { "cur",        TF_NONE,   FT_LV_DAT,      1,              TFL_PUTN },
157      { "size",       TF_NONE,   FT_LV_DAT,      2,              TFL_PUTN },
158      { "width",      TF_NONE,   FT_LV_DAT,      3,              TFL_PUTN },
159      { "unseen",     TF_NONE,   FT_LV_DAT,      4,              TFL_PUTN },
160      { "dat",        TF_NUM,    FT_LV_DAT,      0,              TFL_PUTN },
161      { "strlen",     TF_NONE,   FT_LV_STRLEN,   0,              TFL_PUTN },
162      { "me",         TF_MYBOX,  FT_LS_LIT,      0,              TFL_PUTS },
163      { "myname",     TF_MYNAME, FT_LS_LIT,      0,              TFL_PUTS },
164      { "myhost",     TF_MYHOST, FT_LS_LIT,      0,              TFL_PUTS },
165      { "localmbox",  TF_LMBOX,  FT_LS_LIT,      0,              TFL_PUTS },
166      { "plus",       TF_NUM,    FT_LV_PLUS_L,   0,              TFL_PUTN },
167      { "minus",      TF_NUM,    FT_LV_MINUS_L,  0,              TFL_PUTN },
168      { "divide",     TF_NUM,    FT_LV_DIVIDE_L, 0,              TFL_PUTN },
169      { "modulo",     TF_NUM,    FT_LV_MODULO_L, 0,              TFL_PUTN },
170      { "charleft",   TF_NONE,   FT_LV_CHAR_LEFT, 0,             TFL_PUTN },
171      { "timenow",    TF_NOW,    FT_LV_LIT,      0,              TFL_PUTN },
172
173      { "month",      TF_COMP,   FT_LS_MONTH,    FT_PARSEDATE,   TFL_PUTS },
174      { "lmonth",     TF_COMP,   FT_LS_LMONTH,   FT_PARSEDATE,   TFL_PUTS },
175      { "tzone",      TF_COMP,   FT_LS_ZONE,     FT_PARSEDATE,   TFL_PUTS },
176      { "day",        TF_COMP,   FT_LS_DAY,      FT_PARSEDATE,   TFL_PUTS },
177      { "weekday",    TF_COMP,   FT_LS_WEEKDAY,  FT_PARSEDATE,   TFL_PUTS },
178      { "tws",        TF_COMP,   FT_LS_822DATE,  FT_PARSEDATE,   TFL_PUTS },
179      { "sec",        TF_COMP,   FT_LV_SEC,      FT_PARSEDATE,   TFL_PUTN },
180      { "min",        TF_COMP,   FT_LV_MIN,      FT_PARSEDATE,   TFL_PUTN },
181      { "hour",       TF_COMP,   FT_LV_HOUR,     FT_PARSEDATE,   TFL_PUTN },
182      { "mday",       TF_COMP,   FT_LV_MDAY,     FT_PARSEDATE,   TFL_PUTN },
183      { "mon",        TF_COMP,   FT_LV_MON,      FT_PARSEDATE,   TFL_PUTN },
184      { "year",       TF_COMP,   FT_LV_YEAR,     FT_PARSEDATE,   TFL_PUTN },
185      { "yday",       TF_COMP,   FT_LV_YDAY,     FT_PARSEDATE,   TFL_PUTN },
186      { "wday",       TF_COMP,   FT_LV_WDAY,     FT_PARSEDATE,   TFL_PUTN },
187      { "zone",       TF_COMP,   FT_LV_ZONE,     FT_PARSEDATE,   TFL_PUTN },
188      { "clock",      TF_COMP,   FT_LV_CLOCK,    FT_PARSEDATE,   TFL_PUTN },
189      { "rclock",     TF_COMP,   FT_LV_RCLOCK,   FT_PARSEDATE,   TFL_PUTN },
190      { "sday",       TF_COMP,   FT_LV_DAYF,     FT_PARSEDATE,   TFL_PUTN },
191      { "szone",      TF_COMP,   FT_LV_ZONEF,    FT_PARSEDATE,   TFL_PUTN },
192      { "dst",        TF_COMP,   FT_LV_DST,      FT_PARSEDATE,   TFL_PUTN },
193      { "pretty",     TF_COMP,   FT_LS_PRETTY,   FT_PARSEDATE,   TFL_PUTS },
194      { "nodate",     TF_COMP,   FT_LV_COMPFLAG, FT_PARSEDATE,   TFL_PUTN },
195      { "date2local", TF_COMP,   FT_LOCALDATE,   FT_PARSEDATE,   0 },
196      { "date2gmt",   TF_COMP,   FT_GMTDATE,     FT_PARSEDATE,   0 },
197
198      { "pers",       TF_COMP,   FT_LS_PERS,     FT_PARSEADDR,   TFL_PUTS },
199      { "mbox",       TF_COMP,   FT_LS_MBOX,     FT_PARSEADDR,   TFL_PUTS },
200      { "host",       TF_COMP,   FT_LS_HOST,     FT_PARSEADDR,   TFL_PUTS },
201      { "path",       TF_COMP,   FT_LS_PATH,     FT_PARSEADDR,   TFL_PUTS },
202      { "gname",      TF_COMP,   FT_LS_GNAME,    FT_PARSEADDR,   TFL_PUTS },
203      { "note",       TF_COMP,   FT_LS_NOTE,     FT_PARSEADDR,   TFL_PUTS },
204      { "addr",       TF_COMP,   FT_LS_ADDR,     FT_PARSEADDR,   TFL_PUTS },
205      { "proper",     TF_COMP,   FT_LS_822ADDR,  FT_PARSEADDR,   TFL_PUTS },
206      { "type",       TF_COMP,   FT_LV_HOSTTYPE, FT_PARSEADDR,   TFL_PUTN },
207      { "ingrp",      TF_COMP,   FT_LV_INGRPF,   FT_PARSEADDR,   TFL_PUTN },
208      { "nohost",     TF_COMP,   FT_LV_NOHOSTF,  FT_PARSEADDR,   TFL_PUTN },
209      { "formataddr", TF_EXPR_SV,FT_FORMATADDR,  FT_FORMATADDR,  0 },
210      { "concataddr", TF_EXPR_SV,FT_CONCATADDR,  FT_FORMATADDR,  0 },
211      { "friendly",   TF_COMP,   FT_LS_FRIENDLY, FT_PARSEADDR,   TFL_PUTS },
212
213      { "mymbox",     TF_COMP,   FT_LV_COMPFLAG, FT_MYMBOX,      TFL_PUTN },
214      { "addtoseq",   TF_STR,    FT_ADDTOSEQ,    0,              0 },
215
216      { "unquote",   TF_EXPR,    FT_LS_UNQUOTE,  0,              TFL_PUTS},
217
218      { NULL,         0,         0,              0,              0 }
219 };
220
221 /* 
222  * Hash function for component name.  The function should be
223  * case independent and probably shouldn't involve a routine
224  * call.  This function is pretty good but will not work on
225  * single character component names.  
226  */
227 #define CHASH(nm) (((((nm)[0]) - ((nm)[1])) & 0x1f) + (((nm)[2]) & 0x5f))
228
229 /*
230  * Find a component in the hash table.
231  */
232 #define FINDCOMP(comp,name) \
233                 for (comp = wantcomp[CHASH(name)]; \
234                      comp && strcmp(comp->c_name,name); \
235                      comp = comp->c_next) \
236                 ;
237
238 /* Add new component to the hash table */
239 #define NEWCOMP(cm,name) do { \
240         cm = ((struct comp *) calloc(1, sizeof (struct comp)));\
241         cm->c_name = getcpy(name);\
242         ncomp++;\
243         i = CHASH(name);\
244         cm->c_next = wantcomp[i];\
245         wantcomp[i] = cm; \
246         } while (0)
247
248 #define NEWFMT (next_fp++)
249 #define NEW(type,fill,wid) do {\
250         fp=NEWFMT; fp->f_type=(type); fp->f_fill=(fill); fp->f_width=(wid); \
251         } while (0)
252
253 /* Add (possibly new) component to the hash table */
254 #define ADDC(name) do { \
255         FINDCOMP(cm, name);\
256         if (!cm) {\
257             NEWCOMP(cm,name);\
258         }\
259         fp->f_comp = cm; \
260         fp->f_flags |= FF_COMPREF; \
261         cm->c_refcount++; \
262         } while (0)
263
264 #define LV(type, value)         do { NEW(type,0,0); fp->f_value = (value); } while (0)
265 #define LS(type, str)           do { NEW(type,0,0); fp->f_text = (str); fp->f_flags |= FF_STRALLOC; } while (0)
266
267 #define PUTCOMP(comp)           do { NEW(FT_COMP,0,0); ADDC(comp); } while (0)
268 #define PUTLIT(str)             do { NEW(FT_LIT,0,0); fp->f_text = getcpy(str); } while (0)
269 #define PUTC(c)                 do { NEW(FT_CHAR,0,0); fp->f_char = (c); } while (0)
270
271 static char *format_string;
272 static unsigned char *usr_fstring;      /* for CERROR */
273
274 #define CERROR(str) compile_error (str, cp)
275
276 /*
277  * static prototypes
278  */
279 static struct ftable *lookup(char *);
280 static void compile_error(char *, char *);
281 static char *compile (char *);
282 static char *do_spec(char *);
283 static char *do_name(char *, int);
284 static char *do_func(char *);
285 static char *do_expr (char *, int);
286 static char *do_loop(char *);
287 static char *do_if(char *);
288 static void free_component(struct comp *);
289 static void free_comptable(void);
290
291
292 /*
293  * Lookup a function name in the functable
294  */
295 static struct ftable *
296 lookup(char *name)
297 {
298     register struct ftable *t = functable;
299     register char *nm;
300     register char c = *name;
301
302     while ((nm = t->name)) {
303         if (*nm == c && strcmp (nm, name) == 0)
304             return (ftbl = t);
305
306         t++;
307     }
308     return (struct ftable *) 0;
309 }
310
311
312 static void
313 compile_error(char *str, char *cp)
314 {
315     int i, errpos, errctx;
316
317     errpos = cp - format_string;
318     errctx = errpos > 20 ? 20 : errpos;
319     usr_fstring[errpos] = '\0';
320
321     for (i = errpos-errctx; i < errpos; i++) {
322 #ifdef LOCALE
323         if (iscntrl(usr_fstring[i]))
324 #else
325         if (usr_fstring[i] < 32)
326 #endif
327             usr_fstring[i] = '_';
328     }
329
330     advise(NULL, "\"%s\": format compile error - %s",
331            &usr_fstring[errpos-errctx], str);
332     adios (NULL, "%*s", errctx+1, "^");
333 }
334
335 /*
336  * Compile format string "fstring" into format list "fmt".
337  * Return the number of header components found in the format
338  * string.
339  */
340
341 int
342 fmt_compile(char *fstring, struct format **fmt, int reset_comptable)
343 {
344     register char *cp;
345     size_t i;
346     static int comptable_initialized = 0;
347
348     format_string = getcpy (fstring);
349     usr_fstring = fstring;
350
351     if (reset_comptable || !comptable_initialized) {
352         free_comptable();
353         comptable_initialized = 1;
354     }
355
356     /* init the component hash table. */
357     for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++)
358         wantcomp[i] = 0;
359
360     memset((char *) &fmt_mnull, 0, sizeof(fmt_mnull));
361
362     /* it takes at least 4 char to generate one format so we
363      * allocate a worst-case format array using 1/4 the length
364      * of the format string.  We actually need twice this much
365      * to handle both pre-processing (e.g., address parsing) and
366      * normal processing.
367      */
368     i = strlen(fstring)/2 + 1;
369                 if (i==1) i++;
370     next_fp = formatvec = (struct format *)calloc ((size_t) i,
371                                                    sizeof(struct format));
372     if (next_fp == NULL)
373         adios (NULL, "unable to allocate format storage");
374
375     ncomp = 0;
376     infunction = 0;
377
378     cp = compile(format_string);
379     if (*cp) {
380         CERROR("extra '%>', '%|' or '%?'");
381     }
382     LV(FT_DONE, 0);             /* really done */
383     *fmt = formatvec;
384
385     free(format_string);
386     return (ncomp);
387 }
388
389 static char *
390 compile (char *sp)
391 {
392     register char *cp = sp;
393     register int  c;
394
395     for (;;) {
396         sp = cp;
397         while ((c = *cp) && c != '%')
398             cp++;
399         *cp = 0;
400         switch (cp-sp) {
401         case 0:
402             break;
403         case 1:
404             PUTC(*sp);
405             break;
406         default:
407             PUTLIT(sp);
408             break;
409         }
410         if (c == 0)
411             return (cp);
412
413         switch (c = *++cp) {
414         case '%':
415             PUTC (*cp);
416             cp++;
417             break;
418
419         case '|':
420         case '>':
421         case '?':
422         case ']':
423             return (cp);
424
425         case '<':
426             cp = do_if(++cp);
427             break;
428
429         case '[':       /* ] */
430             cp = do_loop(++cp);
431             break;
432
433         case ';':       /* comment line */
434             cp++;
435             while ((c = *cp++) && c != '\n')
436                 continue;
437             break;
438
439         default:
440             cp = do_spec(cp);
441             break;
442         }
443     }
444 }
445
446
447 /*
448  * Process functions & components (handle field width here as well
449  */
450 static char *
451 do_spec(char *sp)
452 {
453     register char *cp = sp;
454     register int c;
455 #ifndef lint
456     register int ljust = 0;
457 #endif  /* not lint */
458     register int wid = 0;
459     register char fill = ' ';
460
461     c = *cp++;
462     if (c == '-') {
463         ljust++;
464         c = *cp++;
465     }
466     if (c == '0') {
467         fill = c;
468         c = *cp++;
469     }
470     while (isdigit(c)) {
471         wid = wid*10 + (c - '0');
472         c = *cp++;
473     }
474     if (c == '{') {
475         cp = do_name(cp, 0);
476         if (! infunction)
477             fp->f_type = wid? FT_COMPF : FT_COMP;
478     }
479     else if (c == '(') {
480         cp = do_func(cp);
481         if (! infunction) {
482             if (ftbl->flags & TFL_PUTS) {
483                 LV( wid? FT_STRF : FT_STR, ftbl->extra);
484             }
485             else if (ftbl->flags & TFL_PUTN) {
486                 LV( wid? FT_NUMF : FT_NUM, ftbl->extra);
487             }
488         }
489     }
490     else {
491         CERROR("component or function name expected");
492     }
493     if (ljust)
494         wid = -wid;
495     fp->f_width = wid;
496     fp->f_fill = fill;
497
498     return (cp);
499 }
500
501 /*
502  * Process a component name.  Normally this involves generating an FT_COMP
503  * instruction for the specified component.  If preprocess is set, then we
504  * do some extra processing.
505  */
506 static char *
507 do_name(char *sp, int preprocess)
508 {
509     register char *cp = sp;
510     register int c;
511     register int i;
512     static int primed = 0;
513
514     while (isalnum(c = *cp++) || c == '-' || c == '_')
515         ;
516     if (c != '}') {
517         CERROR("'}' expected");
518     }
519     cp[-1] = '\0';
520     PUTCOMP(sp);
521     switch (preprocess) {
522
523     case FT_PARSEDATE:
524         if (cm->c_type & CT_ADDR) {
525             CERROR("component used as both date and address");
526         }
527         cm->c_tws = (struct tws *)
528             calloc((size_t) 1, sizeof(*cm->c_tws));
529         fp->f_type = preprocess;
530         PUTCOMP(sp);
531         cm->c_type |= CT_DATE;
532         break;
533
534     case FT_MYMBOX:
535         if (!primed) {
536             ismymbox ((struct mailname *) 0);
537             primed++;
538         }
539         /* fall through */
540     case FT_PARSEADDR:
541         if (cm->c_type & CT_DATE) {
542             CERROR("component used as both date and address");
543         }
544         cm->c_mn = &fmt_mnull;
545         fp->f_type = preprocess;
546         PUTCOMP(sp);
547         cm->c_type |= CT_ADDR;
548         break;
549
550     case FT_FORMATADDR:
551         if (cm->c_type & CT_DATE) {
552             CERROR("component used as both date and address");
553         }
554         cm->c_type |= CT_ADDR;
555         break;
556     }
557     return (cp);
558 }
559
560 /*
561  * Generate one or more instructions corresponding to the named function.
562  * The different type of function arguments are handled here.
563  */
564 static char *
565 do_func(char *sp)
566 {
567     register char *cp = sp;
568     register int c;
569     register struct ftable *t;
570     register int n;
571     int mflag;          /* minus sign in NUM */
572
573     infunction++;
574
575     while (isalnum(c = *cp++)) 
576         ;
577     if (c != '(' && c != '{' && c != ' ' && c != ')') {
578         CERROR("'(', '{', ' ' or ')' expected");
579     }
580     cp[-1] = '\0';
581     if ((t = lookup (sp)) == 0) {
582         CERROR("unknown function");
583     }
584     if (isspace(c))
585         c = *cp++;
586
587     switch (t->type) {
588
589     case TF_COMP:
590         if (c != '{') {
591             CERROR("component name expected");
592         }
593         cp = do_name(cp, t->extra);
594         fp->f_type = t->f_type;
595         c = *cp++;
596         break;
597
598     case TF_NUM:
599         if ((mflag = (c == '-')))
600             c = *cp++;
601         n = 0;
602         while (isdigit(c)) {
603             n = n*10 + (c - '0');
604             c = *cp++;
605         }
606         if (mflag)
607             n = (-n);
608         LV(t->f_type,n);
609         break;
610
611     case TF_STR:
612         sp = cp - 1;
613         while (c && c != ')')
614             c = *cp++;
615         cp[-1] = '\0';
616         LS(t->f_type,sp);
617         break;
618
619     case TF_NONE:
620         LV(t->f_type,t->extra);
621         break;
622
623     case TF_MYBOX:
624         LS(t->f_type, getusername());
625         break;
626
627     case TF_MYNAME:
628         LS(t->f_type, getfullname());
629         break;
630
631     case TF_MYHOST:
632         LS(t->f_type, LocalName(0));
633         break;
634
635     case TF_LMBOX:
636         LS(t->f_type, getlocalmbox());
637         break;
638
639     case TF_NOW:
640         LV(t->f_type, time((time_t *) 0));
641         break;
642
643     case TF_EXPR_SV:
644         LV(FT_SAVESTR, 0);
645         /* fall through */
646     case TF_EXPR:
647         *--cp = c;
648         cp = do_expr(cp, t->extra);
649         LV(t->f_type, 0);
650         c = *cp++;
651         ftbl = t;
652         break;
653
654     case TF_NOP:
655         *--cp = c;
656         cp = do_expr(cp, t->extra);
657         c = *cp++;
658         ftbl = t;
659         break;
660     }
661     if (c != ')') {
662         CERROR("')' expected");
663     }
664     --infunction;
665     return (cp);
666 }
667
668 /*
669  * Handle an expression as an argument.  Basically we call one of do_name(),
670  * do_func(), or do_if()
671  */
672 static char *
673 do_expr (char *sp, int preprocess)
674 {
675     register char *cp = sp;
676     register int  c;
677
678     if ((c = *cp++) == '{') {
679         cp = do_name (cp, preprocess);
680         fp->f_type = FT_LS_COMP;
681     } else if (c == '(') {
682         cp = do_func (cp);
683     } else if (c == ')') {
684         return (--cp);
685     } else if (c == '%' && *cp == '<') {
686         cp = do_if (cp+1);
687     } else {
688         CERROR ("'(', '{', '%<' or ')' expected");
689     }
690     return (cp);
691 }
692
693 /*
694  * I am guessing this was for some kind of loop statement, which would have
695  * looked like %[ .... %].  It looks like the way this would have worked
696  * is that the format engine would have seen that FT_DONE had a 1 in the
697  * f_un.f_un_value and then decided whether or not to continue the loop.
698  * There is no support for this in the format engine, so right now if
699  * you try using it you will reach the FT_DONE and simply stop.  I'm leaving
700  * this here in case someone wants to continue the work.
701  */
702 static char *
703 do_loop(char *sp)
704 {
705     register char *cp = sp;
706     struct format *floop;
707
708     floop = next_fp;
709     cp = compile (cp);
710     if (*cp++ != ']')
711         CERROR ("']' expected");
712
713     LV(FT_DONE, 1);             /* not yet done */
714     LV(FT_GOTO, 0);
715     fp->f_skip = floop - fp;    /* skip backwards */
716
717     return cp;
718 }
719
720 /*
721  * Handle an if-elsif-endif statement.  Note here that the branching
722  * is handled by the f_skip member of the struct format (which is really
723  * just f_width overloaded).  This number controls how far to move forward
724  * (or back) in the format instruction array.
725  */
726 static char *
727 do_if(char *sp)
728 {
729     register char *cp = sp;
730     register struct format *fexpr,
731                            *fif = (struct format *)NULL;
732     register int c = '<';
733
734     for (;;) {
735         if (c == '<') {                 /* doing an IF */
736             if ((c = *cp++) == '{') /*}*/{
737                 cp = do_name(cp, 0);
738                 fp->f_type = FT_LS_COMP;
739                 LV (FT_IF_S, 0);
740             }
741             else if (c == '(') {
742                 cp = do_func(cp);
743                 /* see if we can merge the load and the "if" */
744                 if (ftbl->f_type >= IF_FUNCS)
745                     fp->f_type = ftbl->extra;
746                 else {
747                     /* Put out a string test or a value test depending
748                      * on what this function's return type is.
749                      */
750                     if (ftbl->flags & TFL_PUTS) {
751                         LV (FT_IF_S, 0);
752                     } else {
753                         LV (FT_IF_V_NE, 0);
754                     }
755                 }
756             }
757             else {
758                 CERROR("'(' or '{' expected");  /*}*/
759             }
760         }
761
762         fexpr = fp;                     /* loc of [ELS]IF */
763         cp = compile (cp);              /* compile IF TRUE stmts */
764         if (fif)
765             fif->f_skip = next_fp - fif;
766
767         if ((c = *cp++) == '|') {       /* the last ELSE */
768             LV(FT_GOTO, 0);
769             fif = fp;                   /* loc of GOTO */
770             fexpr->f_skip = next_fp - fexpr;
771
772             fexpr = (struct format *)NULL;/* no extra ENDIF */
773
774             cp = compile (cp);          /* compile ELSE stmts */
775             fif->f_skip = next_fp - fif;
776             c = *cp++;
777         }
778         else if (c == '?') {            /* another ELSIF */
779             LV(FT_GOTO, 0);
780             fif = fp;                   /* loc of GOTO */
781             fexpr->f_skip = next_fp - fexpr;
782
783             c = '<';                    /* impersonate an IF */
784             continue;
785         }
786         break;
787     }
788
789     if (c != '>') {
790         CERROR("'>' expected.");
791     }
792
793     if (fexpr)                          /* IF ... [ELSIF ...] ENDIF */
794         fexpr->f_skip = next_fp - fexpr;
795
796     return (cp);
797 }
798
799 /*
800  * Free a set of format instructions.
801  *
802  * What we do here is:
803  *
804  * - Iterate through the list of format instructions, freeing any references
805  *   to allocated memory in each instruction.
806  * - Free component references.
807  * - If requested, reset the component hash table; that will also free any
808  *   references to components stored there.
809  *
810  */
811
812 void
813 fmt_free(struct format *fmt, int reset_comptable)
814 {
815     struct format *fp = fmt;
816
817     if (fp) {
818         while (! (fp->f_type == FT_DONE && fp->f_value == 0)) {
819             if (fp->f_flags & FF_STRALLOC)
820                 free(fp->f_text);
821             if (fp->f_flags & FF_COMPREF)
822                 free_component(fp->f_comp);
823         }
824         free(fmt);
825     }
826
827     if (reset_comptable)
828         free_comptable();
829 }
830
831 /*
832  * Find a component in our hash table.  This is just a public interface to
833  * the FINDCOMP macro, so we don't have to expose our hash table.
834  */
835
836 struct comp *
837 fmt_findcomp(char *component)
838 {
839     struct comp *cm;
840
841     FINDCOMP(cm, component);
842
843     return cm;
844 }
845
846 /*
847  * Free and reset our component hash table
848  */
849
850 static void
851 free_comptable(void)
852 {
853     int i;
854     struct comp *cm, *cm2;
855
856     for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++) {
857         cm = wantcomp[i];
858         while (cm != NULL) {
859             cm2 = cm->c_next;
860             free_component(cm);
861             cm = cm2;
862         }
863         wantcomp[i] = 0;
864     }
865 }
866
867 /*
868  * Decrement the reference count of a component structure.  If it reaches
869  * zero, free it
870  */
871
872 static void
873 free_component(struct comp *cm)
874 {
875     if (--cm->c_refcount <= 0) {
876         /* Shouldn't ever be NULL, but just in case ... */
877         if (cm->c_name)
878             free(cm->c_name);
879         if (cm->c_text)
880             free(cm->c_text);
881         if (cm->c_type & CT_DATE)
882             free(cm->c_tws);
883         if (cm->c_type & CT_ADDR && cm->c_mn && cm->c_mn != &fmt_mnull)
884             mnfree(cm->c_mn);
885         free(cm);
886     }
887 }