2 ** fmt_compile.c -- "compile" format strings for fmt_scan
4 ** This code is Copyright (c) 2002, by the authors of nmh. See the
5 ** COPYRIGHT file in the root directory of the nmh distribution for
6 ** complete copyright information.
8 ** This code compiles the format strings (documented in mh-format(5)) into
9 ** an internal form to be later processed by fmt_scan.c.
11 ** What happens here is that the format strings are parsed and an array
12 ** of struct format structures are returned. Each format structure is
13 ** a single operation interpreted by the the routines in fmt_scan.c.
15 ** There is a NOT a one-to-one correspondence between format strings and
16 ** format instructions; some functions have side effects that can result
17 ** in multiple instructions being generated. The exact list of instructions
18 ** generated by a format string can be seem with the nmh fmtdump utility.
20 ** A list of format instructions can be found in fmt_compile.h.
22 ** If you wish to add a new function, you will need to do the following
25 ** - Add a new instruction to the list of instructions in fmt_compile.h.
26 ** Note that test instructions (starting with FT_IF_S_NULL) have special
27 ** handling, so if you are NOT writing a test function then you need
28 ** to insert it into the list before that _and_ bump all of the
29 ** following instruction numbers.
31 ** - Add the function name to the functable[] array below, and write any
32 ** special code that your function may require in terms of parsing
33 ** (it very well may not need anything).
35 ** - Add the code in fmt_scan.c to handle your new function.
37 ** - Document the new function in the mh-format(5) man page.
42 #include <h/addrsbr.h>
44 #include <h/fmt_scan.h>
45 #include <h/fmt_compile.h>
47 #ifdef HAVE_SYS_TIME_H
48 # include <sys/time.h>
53 ** hash table for deciding if a component is "interesting"
55 struct comp *wantcomp[128];
57 static struct format *formatvec; /* array to hold formats */
58 static struct format *next_fp; /* next free format slot */
59 static struct format *fp; /* current format slot */
60 static struct comp *cm; /* most recent comp ref */
61 static struct ftable *ftbl; /* most recent func ref */
63 static int infunction; /* function nesting cnt */
65 extern struct mailname fmt_mnull;
67 /* ftable->type (argument type) */
68 #define TF_COMP 0 /* component expected */
69 #define TF_NUM 1 /* number expected */
70 #define TF_STR 2 /* string expected */
71 #define TF_EXPR 3 /* component or func. expected */
72 #define TF_NONE 4 /* no argument */
73 #define TF_MYBOX 5 /* special - get current user's mbox */
74 #define TF_NOW 6 /* special - get current unix time */
75 #define TF_EXPR_SV 7 /* like expr but save current str reg */
76 #define TF_NOP 8 /* like expr but no result */
80 ** NB that TFL_PUTS is also used to decide whether the test
81 ** in a "%<(function)..." should be a string or numeric one.
83 #define TFL_PUTS 1 /* implicit putstr if top level */
84 #define TFL_PUTN 2 /* implicit putnum if top level */
87 ** The functable array maps between the text names of format functions and
88 ** the format instructions interpreted by the engine in fmt_scan.c.
90 ** The elements of this structure are as follows:
92 ** name: The name of the function as seen in the format string. This is
93 ** what maps a particular function name into a format instruction.
94 ** type: The type of argument this function expects. Those types are
95 ** listed above (with the TF_ prefix). This affects what gets
96 ** placed in the format instruction (the f_un union).
97 ** f_type: The instruction corresponding to this function (from the list
99 ** extra: Used by some functions to provide extra data to the compiler.
101 ** - Providing an alternate instruction to combine a load
102 ** and test operation (see do_if()).
103 ** - Passed in f_value in the format instruction to provide
104 ** extra information for the engine (see FT_LV_DAT handling
106 ** - Provide a hint as to preprocessing that is required for
107 ** this instruction (see do_name()).
108 ** flags: See the definitions for TFL_PUTS & TFL_PUTN above.
111 char *name; /* function name */
112 char type; /* argument type */
113 char f_type; /* fmt type */
114 char extra; /* arg. type dependent extra info */
118 static struct ftable functable[] = {
119 { "nonzero", TF_EXPR, FT_V_NE, FT_IF_V_NE, 0 },
120 { "zero", TF_EXPR, FT_V_EQ, FT_IF_V_EQ, 0 },
121 { "eq", TF_NUM, FT_V_EQ, FT_IF_V_EQ, 0 },
122 { "ne", TF_NUM, FT_V_NE, FT_IF_V_NE, 0 },
123 { "gt", TF_NUM, FT_V_GT, FT_IF_V_GT, 0 },
124 { "null", TF_EXPR, FT_S_NULL, FT_IF_S_NULL, 0 },
125 { "nonnull", TF_EXPR, FT_S_NONNULL, FT_IF_S, 0 },
126 { "match", TF_STR, FT_V_MATCH, FT_IF_MATCH, 0 },
127 { "amatch", TF_STR, FT_V_AMATCH, FT_IF_AMATCH, 0 },
129 { "putstr", TF_EXPR, FT_STR, 0, 0 },
130 { "putstrf", TF_EXPR, FT_STRF, 0, 0 },
131 { "putnum", TF_EXPR, FT_NUM, 0, 0 },
132 { "putnumf", TF_EXPR, FT_NUMF, 0, 0 },
133 { "putaddr", TF_STR, FT_PUTADDR, 0, 0 },
134 { "void", TF_NOP, 0, 0, 0 },
136 { "comp", TF_COMP, FT_LS_COMP, 0, TFL_PUTS },
137 { "lit", TF_STR, FT_LS_LIT, 0, TFL_PUTS },
138 { "getenv", TF_STR, FT_LS_GETENV, 0, TFL_PUTS },
139 { "profile", TF_STR, FT_LS_CFIND, 0, TFL_PUTS },
140 { "decodecomp", TF_COMP, FT_LS_DECODECOMP, 0, TFL_PUTS },
141 { "decode", TF_EXPR, FT_LS_DECODE, 0, TFL_PUTS },
142 { "trim", TF_EXPR, FT_LS_TRIM, 0, 0 },
143 { "compval", TF_COMP, FT_LV_COMP, 0, TFL_PUTN },
144 { "compflag", TF_COMP, FT_LV_COMPFLAG, 0, TFL_PUTN },
145 { "num", TF_NUM, FT_LV_LIT, 0, TFL_PUTN },
146 { "msg", TF_NONE, FT_LV_DAT, 0, TFL_PUTN },
147 { "cur", TF_NONE, FT_LV_DAT, 1, TFL_PUTN },
148 { "size", TF_NONE, FT_LV_DAT, 2, TFL_PUTN },
149 { "width", TF_NONE, FT_LV_DAT, 3, TFL_PUTN },
150 { "unseen", TF_NONE, FT_LV_DAT, 4, TFL_PUTN },
151 { "dat", TF_NUM, FT_LV_DAT, 0, TFL_PUTN },
152 { "strlen", TF_NONE, FT_LV_STRLEN, 0, TFL_PUTN },
153 { "me", TF_MYBOX, FT_LS_LIT, 0, TFL_PUTS },
154 { "plus", TF_NUM, FT_LV_PLUS_L, 0, TFL_PUTN },
155 { "minus", TF_NUM, FT_LV_MINUS_L, 0, TFL_PUTN },
156 { "divide", TF_NUM, FT_LV_DIVIDE_L, 0, TFL_PUTN },
157 { "modulo", TF_NUM, FT_LV_MODULO_L, 0, TFL_PUTN },
158 { "charleft", TF_NONE, FT_LV_CHAR_LEFT, 0, TFL_PUTN },
159 { "timenow", TF_NOW, FT_LV_LIT, 0, TFL_PUTN },
161 { "month", TF_COMP, FT_LS_MONTH, FT_PARSEDATE, TFL_PUTS },
162 { "lmonth", TF_COMP, FT_LS_LMONTH, FT_PARSEDATE, TFL_PUTS },
163 { "tzone", TF_COMP, FT_LS_ZONE, FT_PARSEDATE, TFL_PUTS },
164 { "day", TF_COMP, FT_LS_DAY, FT_PARSEDATE, TFL_PUTS },
165 { "weekday", TF_COMP, FT_LS_WEEKDAY, FT_PARSEDATE, TFL_PUTS },
166 { "tws", TF_COMP, FT_LS_822DATE, FT_PARSEDATE, TFL_PUTS },
167 { "sec", TF_COMP, FT_LV_SEC, FT_PARSEDATE, TFL_PUTN },
168 { "min", TF_COMP, FT_LV_MIN, FT_PARSEDATE, TFL_PUTN },
169 { "hour", TF_COMP, FT_LV_HOUR, FT_PARSEDATE, TFL_PUTN },
170 { "mday", TF_COMP, FT_LV_MDAY, FT_PARSEDATE, TFL_PUTN },
171 { "mon", TF_COMP, FT_LV_MON, FT_PARSEDATE, TFL_PUTN },
172 { "year", TF_COMP, FT_LV_YEAR, FT_PARSEDATE, TFL_PUTN },
173 { "yday", TF_COMP, FT_LV_YDAY, FT_PARSEDATE, TFL_PUTN },
174 { "wday", TF_COMP, FT_LV_WDAY, FT_PARSEDATE, TFL_PUTN },
175 { "zone", TF_COMP, FT_LV_ZONE, FT_PARSEDATE, TFL_PUTN },
176 { "clock", TF_COMP, FT_LV_CLOCK, FT_PARSEDATE, TFL_PUTN },
177 { "rclock", TF_COMP, FT_LV_RCLOCK, FT_PARSEDATE, TFL_PUTN },
178 { "sday", TF_COMP, FT_LV_DAYF, FT_PARSEDATE, TFL_PUTN },
179 { "szone", TF_COMP, FT_LV_ZONEF, FT_PARSEDATE, TFL_PUTN },
180 { "dst", TF_COMP, FT_LV_DST, FT_PARSEDATE, TFL_PUTN },
181 { "pretty", TF_COMP, FT_LS_PRETTY, FT_PARSEDATE, TFL_PUTS },
182 { "nodate", TF_COMP, FT_LV_COMPFLAG, FT_PARSEDATE, TFL_PUTN },
183 { "date2local", TF_COMP, FT_LOCALDATE, FT_PARSEDATE, 0 },
184 { "date2gmt", TF_COMP, FT_GMTDATE, FT_PARSEDATE, 0 },
186 { "pers", TF_COMP, FT_LS_PERS, FT_PARSEADDR, TFL_PUTS },
187 { "mbox", TF_COMP, FT_LS_MBOX, FT_PARSEADDR, TFL_PUTS },
188 { "host", TF_COMP, FT_LS_HOST, FT_PARSEADDR, TFL_PUTS },
189 { "path", TF_COMP, FT_LS_PATH, FT_PARSEADDR, TFL_PUTS },
190 { "gname", TF_COMP, FT_LS_GNAME, FT_PARSEADDR, TFL_PUTS },
191 { "note", TF_COMP, FT_LS_NOTE, FT_PARSEADDR, TFL_PUTS },
192 { "addr", TF_COMP, FT_LS_ADDR, FT_PARSEADDR, TFL_PUTS },
193 { "proper", TF_COMP, FT_LS_822ADDR, FT_PARSEADDR, TFL_PUTS },
194 { "type", TF_COMP, FT_LV_HOSTTYPE, FT_PARSEADDR, TFL_PUTN },
195 { "ingrp", TF_COMP, FT_LV_INGRPF, FT_PARSEADDR, TFL_PUTN },
196 { "nohost", TF_COMP, FT_LV_NOHOSTF, FT_PARSEADDR, TFL_PUTN },
197 { "formataddr", TF_EXPR_SV, FT_FORMATADDR, FT_FORMATADDR, 0 },
198 { "friendly", TF_COMP, FT_LS_FRIENDLY, FT_PARSEADDR, TFL_PUTS },
200 { "mymbox", TF_COMP, FT_LV_COMPFLAG, FT_MYMBOX, TFL_PUTN },
202 { "unquote", TF_EXPR, FT_LS_UNQUOTE, 0, TFL_PUTS},
207 /* Add new component to the hash table */
208 #define NEWCOMP(cm,name) do { \
209 cm = ((struct comp *) calloc(1, sizeof (struct comp)));\
213 cm->c_next = wantcomp[i];\
217 #define NEWFMT (next_fp++)
218 #define NEW(type,fill,wid) do {\
219 fp=NEWFMT; fp->f_type=(type); fp->f_fill=(fill); fp->f_width=(wid); \
222 /* Add (possibly new) component to the hash table */
223 #define ADDC(name) do { \
231 #define LV(type, value) do { NEW(type,0,0); fp->f_value = (value); } while (0)
232 #define LS(type, str) do { NEW(type,0,0); fp->f_text = (str); } while (0)
234 #define PUTCOMP(comp) do { NEW(FT_COMP,0,0); ADDC(comp); } while (0)
235 #define PUTLIT(str) do { NEW(FT_LIT,0,0); fp->f_text = (str); } while (0)
236 #define PUTC(c) do { NEW(FT_CHAR,0,0); fp->f_char = (c); } while (0)
238 static char *format_string;
239 static unsigned char *usr_fstring; /* for CERROR */
241 #define CERROR(str) compile_error(str, cp)
246 static struct ftable *lookup(char *);
247 static void compile_error(char *, char *);
248 static char *compile(char *);
249 static char *do_spec(char *);
250 static char *do_name(char *, int);
251 static char *do_func(char *);
252 static char *do_expr(char *, int);
253 static char *do_loop(char *);
254 static char *do_if(char *);
258 ** Lookup a function name in the functable
260 static struct ftable *
263 register struct ftable *t = functable;
265 register char c = *name;
267 while ((nm = t->name)) {
268 if (*nm == c && strcmp(nm, name) == 0)
273 return (struct ftable *) 0;
278 compile_error(char *str, char *cp)
280 int i, errpos, errctx;
282 errpos = cp - format_string;
283 errctx = errpos > 20 ? 20 : errpos;
284 usr_fstring[errpos] = '\0';
286 for (i = errpos-errctx; i < errpos; i++) {
287 if (iscntrl(usr_fstring[i]))
288 usr_fstring[i] = '_';
291 advise(NULL, "\"%s\": format compile error - %s",
292 &usr_fstring[errpos-errctx], str);
293 adios(NULL, "%*s", errctx+1, "^");
297 ** Compile format string "fstring" into format list "fmt".
298 ** Return the number of header components found in the format
302 fmt_compile(char *fstring, struct format **fmt)
309 format_string = getcpy(fstring);
310 usr_fstring = fstring;
312 /* init the component hash table. */
313 for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++)
316 memset((char *) &fmt_mnull, 0, sizeof(fmt_mnull));
319 ** it takes at least 4 char to generate one format so we
320 ** allocate a worst-case format array using 1/4 the length
321 ** of the format string. We actually need twice this much
322 ** to handle both pre-processing (e.g., address parsing) and
323 ** normal processing.
325 i = strlen(fstring)/2 + 1;
328 next_fp = formatvec = (struct format *)calloc((size_t) i,
329 sizeof(struct format));
331 adios(NULL, "unable to allocate format storage");
336 cp = compile(format_string);
338 CERROR("extra '%>', '%|' or '%?'");
340 LV(FT_DONE, 0); /* really done */
349 register char *cp = sp;
354 while ((c = *cp) && c != '%')
390 case ';': /* comment line */
392 while ((c = *cp++) && c != '\n')
405 ** Process functions & components (handle field width here as well
410 register char *cp = sp;
413 register int ljust = 0;
414 #endif /* not lint */
415 register int wid = 0;
416 register char fill = ' ';
428 wid = wid*10 + (c - '0');
434 fp->f_type = wid? FT_COMPF : FT_COMP;
435 } else if (c == '(') {
438 if (ftbl->flags & TFL_PUTS) {
439 LV( wid? FT_STRF : FT_STR, ftbl->extra);
440 } else if (ftbl->flags & TFL_PUTN) {
441 LV( wid? FT_NUMF : FT_NUM, ftbl->extra);
445 CERROR("component or function name expected");
457 ** Process a component name. Normally this involves generating an FT_COMP
458 ** instruction for the specified component. If preprocess is set, then we
459 ** do some extra processing.
462 do_name(char *sp, int preprocess)
464 register char *cp = sp;
467 static int primed = 0;
469 while (isalnum(c = *cp++) || c == '-' || c == '_')
472 CERROR("'}' expected");
476 switch (preprocess) {
479 if (cm->c_type & CT_ADDR) {
480 CERROR("component used as both date and address");
482 cm->c_tws = (struct tws *)
483 calloc((size_t) 1, sizeof(*cm->c_tws));
484 fp->f_type = preprocess;
486 cm->c_type |= CT_DATE;
491 ismymbox((struct mailname *) 0);
496 if (cm->c_type & CT_DATE) {
497 CERROR("component used as both date and address");
499 cm->c_mn = &fmt_mnull;
500 fp->f_type = preprocess;
502 cm->c_type |= CT_ADDR;
506 if (cm->c_type & CT_DATE) {
507 CERROR("component used as both date and address");
509 cm->c_type |= CT_ADDR;
517 ** Generate one or more instructions corresponding to the named function.
518 ** The different type of function arguments are handled here.
523 register char *cp = sp;
525 register struct ftable *t;
527 int mflag; /* minus sign in NUM */
531 while (isalnum(c = *cp++))
533 if (c != '(' && c != '{' && c != ' ' && c != ')') {
534 CERROR("'(', '{', ' ' or ')' expected");
537 if ((t = lookup(sp)) == 0) {
538 CERROR("unknown function");
547 CERROR("component name expected");
549 cp = do_name(cp, t->extra);
550 fp->f_type = t->f_type;
555 if ((mflag = (c == '-')))
559 n = n*10 + (c - '0');
569 while (c && c != ')')
576 LV(t->f_type,t->extra);
580 LS(t->f_type, getusername());
584 LV(t->f_type, time((time_t *) 0));
592 cp = do_expr(cp, t->extra);
600 cp = do_expr(cp, t->extra);
606 CERROR("')' expected");
614 ** Handle an expression as an argument. Basically we call one of do_name(),
615 ** do_func(), or do_if()
618 do_expr(char *sp, int preprocess)
620 register char *cp = sp;
623 if ((c = *cp++) == '{') {
624 cp = do_name(cp, preprocess);
625 fp->f_type = FT_LS_COMP;
626 } else if (c == '(') {
628 } else if (c == ')') {
630 } else if (c == '%' && *cp == '<') {
633 CERROR("'(', '{', '%<' or ')' expected");
640 ** I am guessing this was for some kind of loop statement, which would have
641 ** looked like %[ .... %]. It looks like the way this would have worked
642 ** is that the format engine would have seen that FT_DONE had a 1 in the
643 ** f_un.f_un_value and then decided whether or not to continue the loop.
644 ** There is no support for this in the format engine, so right now if
645 ** you try using it you will reach the FT_DONE and simply stop. I'm leaving
646 ** this here in case someone wants to continue the work.
651 register char *cp = sp;
652 struct format *floop;
657 CERROR("']' expected");
659 LV(FT_DONE, 1); /* not yet done */
661 fp->f_skip = floop - fp; /* skip backwards */
668 ** Handle an if-elsif-endif statement. Note here that the branching
669 ** is handled by the f_skip member of the struct format (which is really
670 ** just f_width overloaded). This number controls how far to move forward
671 ** (or back) in the format instruction array.
676 register char *cp = sp;
677 register struct format *fexpr, *fif = (struct format *)NULL;
678 register int c = '<';
681 if (c == '<') { /* doing an IF */
682 if ((c = *cp++) == '{') /*}*/{
684 fp->f_type = FT_LS_COMP;
686 } else if (c == '(') {
688 /* see if we can merge the load and the "if" */
689 if (ftbl->f_type >= IF_FUNCS)
690 fp->f_type = ftbl->extra;
693 ** Put out a string test or a value
694 ** test depending on what this
695 ** function 's return type is.
697 if (ftbl->flags & TFL_PUTS) {
704 CERROR("'(' or '{' expected"); /*}*/
708 fexpr = fp; /* loc of [ELS]IF */
709 cp = compile(cp); /* compile IF TRUE stmts */
711 fif->f_skip = next_fp - fif;
713 if ((c = *cp++) == '|') { /* the last ELSE */
715 fif = fp; /* loc of GOTO */
716 fexpr->f_skip = next_fp - fexpr;
718 fexpr = (struct format *)NULL;/* no extra ENDIF */
720 cp = compile(cp); /* compile ELSE stmts */
721 fif->f_skip = next_fp - fif;
723 } else if (c == '?') { /* another ELSIF */
725 fif = fp; /* loc of GOTO */
726 fexpr->f_skip = next_fp - fexpr;
728 c = '<'; /* impersonate an IF */
735 CERROR("'>' expected.");
738 if (fexpr) /* IF ... [ELSIF ...] ENDIF */
739 fexpr->f_skip = next_fp - fexpr;