3 * fmt_compile.c -- "compile" format strings for fmt_scan
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.
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.
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.
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.
21 * A list of format instructions can be found in fmt_compile.h.
23 * If you wish to add a new function, you will need to do the following
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.
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).
36 * - Add the code in fmt_scan.c to handle your new function.
38 * - Add code to fmtdump.c to display your new function.
40 * - Document the new function in the mh-format(5) man page.
45 #include <h/addrsbr.h>
47 #include <h/fmt_scan.h>
48 #include <h/fmt_compile.h>
51 #ifdef HAVE_SYS_TIME_H
52 # include <sys/time.h>
57 * hash table for deciding if a component is "interesting"
59 static struct comp *wantcomp[128];
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 */
67 static int infunction; /* function nesting cnt */
69 extern struct mailname fmt_mnull;
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 */
86 /* NB that TFL_PUTS is also used to decide whether the test
87 * in a "%<(function)..." should be a string or numeric one.
89 #define TFL_PUTS 1 /* implicit putstr if top level */
90 #define TFL_PUTN 2 /* implicit putnum if top level */
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.
96 * The elements of this structure are as follows:
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
105 * extra - Used by some functions to provide extra data to the compiler.
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
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.
118 char *name; /* function name */
119 char type; /* argument type */
120 char f_type; /* fmt type */
121 char extra; /* arg. type dependent extra info */
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 },
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 },
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 },
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 },
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 },
213 { "mymbox", TF_COMP, FT_LV_COMPFLAG, FT_MYMBOX, TFL_PUTN },
214 { "addtoseq", TF_STR, FT_ADDTOSEQ, 0, 0 },
216 { "unquote", TF_EXPR, FT_LS_UNQUOTE, 0, TFL_PUTS},
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.
227 #define CHASH(nm) (((((nm)[0]) - ((nm)[1])) & 0x1f) + (((nm)[2]) & 0x5f))
230 * Find a component in the hash table.
232 #define FINDCOMP(comp,name) \
233 for (comp = wantcomp[CHASH(name)]; \
234 comp && strcmp(comp->c_name,name); \
235 comp = comp->c_next) \
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);\
245 cm->c_next = wantcomp[i];\
249 #define NEWFMT (next_fp++)
250 #define NEW(type,fill,wid) do {\
251 fp=NEWFMT; fp->f_type=(type); fp->f_fill=(fill); fp->f_width=(wid); \
254 /* Add (possibly new) component to the hash table */
255 #define ADDC(name) do { \
261 fp->f_flags |= FF_COMPREF; \
265 #define LV(type, value) do { NEW(type,0,0); fp->f_value = (value); } while (0)
266 #define LS(type, str) do { NEW(type,0,0); fp->f_text = (str); fp->f_flags |= FF_STRALLOC; } while (0)
268 #define PUTCOMP(comp) do { NEW(FT_COMP,0,0); ADDC(comp); } while (0)
269 #define PUTLIT(str) do { NEW(FT_LIT,0,0); fp->f_text = getcpy(str); fp->f_flags |= FF_STRALLOC; } while (0)
270 #define PUTC(c) do { NEW(FT_CHAR,0,0); fp->f_char = (c); } while (0)
272 static char *format_string;
273 static unsigned char *usr_fstring; /* for CERROR */
275 #define CERROR(str) compile_error (str, cp)
280 static struct ftable *lookup(char *);
281 static void compile_error(char *, char *);
282 static char *compile (char *);
283 static char *do_spec(char *);
284 static char *do_name(char *, int);
285 static char *do_func(char *);
286 static char *do_expr (char *, int);
287 static char *do_loop(char *);
288 static char *do_if(char *);
289 static void free_component(struct comp *);
290 static void free_comptable(void);
294 * Lookup a function name in the functable
296 static struct ftable *
299 register struct ftable *t = functable;
301 register char c = *name;
303 while ((nm = t->name)) {
304 if (*nm == c && strcmp (nm, name) == 0)
309 return (struct ftable *) 0;
314 compile_error(char *str, char *cp)
316 int i, errpos, errctx;
318 errpos = cp - format_string;
319 errctx = errpos > 20 ? 20 : errpos;
320 usr_fstring[errpos] = '\0';
322 for (i = errpos-errctx; i < errpos; i++) {
324 if (iscntrl(usr_fstring[i]))
326 if (usr_fstring[i] < 32)
328 usr_fstring[i] = '_';
331 advise(NULL, "\"%s\": format compile error - %s",
332 &usr_fstring[errpos-errctx], str);
333 adios (NULL, "%*s", errctx+1, "^");
337 * Compile format string "fstring" into format list "fmt".
338 * Return the number of header components found in the format
343 fmt_compile(char *fstring, struct format **fmt, int reset_comptable)
347 static int comptable_initialized = 0;
349 format_string = getcpy (fstring);
350 usr_fstring = fstring;
352 if (reset_comptable || !comptable_initialized) {
354 comptable_initialized = 1;
357 /* init the component hash table. */
358 for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++)
361 memset((char *) &fmt_mnull, 0, sizeof(fmt_mnull));
363 /* it takes at least 4 char to generate one format so we
364 * allocate a worst-case format array using 1/4 the length
365 * of the format string. We actually need twice this much
366 * to handle both pre-processing (e.g., address parsing) and
369 i = strlen(fstring)/2 + 1;
371 next_fp = formatvec = (struct format *)calloc ((size_t) i,
372 sizeof(struct format));
374 adios (NULL, "unable to allocate format storage");
378 cp = compile(format_string);
380 CERROR("extra '%>', '%|' or '%?'");
382 LV(FT_DONE, 0); /* really done */
392 register char *cp = sp;
397 while ((c = *cp) && c != '%')
433 case ';': /* comment line */
435 while ((c = *cp++) && c != '\n')
448 * Process functions & components (handle field width here as well
453 register char *cp = sp;
456 register int ljust = 0;
457 #endif /* not lint */
458 register int wid = 0;
459 register char fill = ' ';
471 wid = wid*10 + (c - '0');
477 fp->f_type = wid? FT_COMPF : FT_COMP;
482 if (ftbl->flags & TFL_PUTS) {
483 LV( wid? FT_STRF : FT_STR, ftbl->extra);
485 else if (ftbl->flags & TFL_PUTN) {
486 LV( wid? FT_NUMF : FT_NUM, ftbl->extra);
491 CERROR("component or function name expected");
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.
507 do_name(char *sp, int preprocess)
509 register char *cp = sp;
512 static int primed = 0;
514 while (isalnum(c = *cp++) || c == '-' || c == '_')
517 CERROR("'}' expected");
521 switch (preprocess) {
524 if (cm->c_type & CT_ADDR) {
525 CERROR("component used as both date and address");
527 cm->c_tws = (struct tws *)
528 calloc((size_t) 1, sizeof(*cm->c_tws));
529 fp->f_type = preprocess;
531 cm->c_type |= CT_DATE;
536 ismymbox ((struct mailname *) 0);
541 if (cm->c_type & CT_DATE) {
542 CERROR("component used as both date and address");
544 cm->c_mn = &fmt_mnull;
545 fp->f_type = preprocess;
547 cm->c_type |= CT_ADDR;
551 if (cm->c_type & CT_DATE) {
552 CERROR("component used as both date and address");
554 cm->c_type |= CT_ADDR;
561 * Generate one or more instructions corresponding to the named function.
562 * The different type of function arguments are handled here.
567 register char *cp = sp;
569 register struct ftable *t;
571 int mflag; /* minus sign in NUM */
575 while (isalnum(c = *cp++))
577 if (c != '(' && c != '{' && c != ' ' && c != ')') {
578 CERROR("'(', '{', ' ' or ')' expected");
581 if ((t = lookup (sp)) == 0) {
582 CERROR("unknown function");
591 CERROR("component name expected");
593 cp = do_name(cp, t->extra);
594 fp->f_type = t->f_type;
599 if ((mflag = (c == '-')))
603 n = n*10 + (c - '0');
613 while (c && c != ')')
620 LV(t->f_type,t->extra);
624 LS(t->f_type, getusername());
628 LS(t->f_type, getfullname());
632 LS(t->f_type, LocalName(0));
636 LS(t->f_type, getlocalmbox());
640 LV(t->f_type, time((time_t *) 0));
648 cp = do_expr(cp, t->extra);
656 cp = do_expr(cp, t->extra);
662 CERROR("')' expected");
669 * Handle an expression as an argument. Basically we call one of do_name(),
670 * do_func(), or do_if()
673 do_expr (char *sp, int preprocess)
675 register char *cp = sp;
678 if ((c = *cp++) == '{') {
679 cp = do_name (cp, preprocess);
680 fp->f_type = FT_LS_COMP;
681 } else if (c == '(') {
683 } else if (c == ')') {
685 } else if (c == '%' && *cp == '<') {
688 CERROR ("'(', '{', '%<' or ')' expected");
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.
702 * Okay, got some more information on this from John L. Romine! From an
703 * email he sent to the nmh-workers mailing list on December 2, 2010, he
704 * explains it thusly:
706 * In this case (scan, formatsbr) it has to do with an extension to
707 * the mh-format syntax to allow for looping.
709 * The scan format is processed once for each message. Those #ifdef
710 * JLR changes allowed for the top part of the format file to be
711 * processed once, then a second, looping part to be processed
712 * once per message. As I recall, there were new mh-format escape
713 * sequences to delimit the loop. This would have allowed for things
714 * like per-format column headings in the scan output.
716 * Since existing format files didn't include the scan listing
717 * header (it was hard-coded in scan.c) it would not have been
718 * backward-compatible. All existing format files (including any
719 * local ones) would have needed to be changed to include the format
720 * codes for a header. The practice at the time was not to introduce
721 * incompatible changes in a minor release, and I never managed to
722 * put out a newer major release.
724 * I can see how this would work, and I suspect part of the motivation was
725 * because the format compiler routines (at the time) couldn't really be
726 * called multiple times on the same message because the memory management
727 * was so lousy. That's been reworked and things are now a lot cleaner,
728 * so I suspect if we're going to allow a format string to be used for the
729 * scan header it might be simpler to have a separate format string just
730 * for the header. But I'll leave this code in for now just in case we
731 * decide that we want some kind of looping support.
736 register char *cp = sp;
737 struct format *floop;
742 CERROR ("']' expected");
744 LV(FT_DONE, 1); /* not yet done */
746 fp->f_skip = floop - fp; /* skip backwards */
752 * Handle an if-elsif-endif statement. Note here that the branching
753 * is handled by the f_skip member of the struct format (which is really
754 * just f_width overloaded). This number controls how far to move forward
755 * (or back) in the format instruction array.
760 register char *cp = sp;
761 register struct format *fexpr,
762 *fif = (struct format *)NULL;
763 register int c = '<';
766 if (c == '<') { /* doing an IF */
767 if ((c = *cp++) == '{') /*}*/{
769 fp->f_type = FT_LS_COMP;
774 /* see if we can merge the load and the "if" */
775 if (ftbl->f_type >= IF_FUNCS)
776 fp->f_type = ftbl->extra;
778 /* Put out a string test or a value test depending
779 * on what this function's return type is.
781 if (ftbl->flags & TFL_PUTS) {
789 CERROR("'(' or '{' expected"); /*}*/
793 fexpr = fp; /* loc of [ELS]IF */
794 cp = compile (cp); /* compile IF TRUE stmts */
796 fif->f_skip = next_fp - fif;
798 if ((c = *cp++) == '|') { /* the last ELSE */
800 fif = fp; /* loc of GOTO */
801 fexpr->f_skip = next_fp - fexpr;
803 fexpr = (struct format *)NULL;/* no extra ENDIF */
805 cp = compile (cp); /* compile ELSE stmts */
806 fif->f_skip = next_fp - fif;
809 else if (c == '?') { /* another ELSIF */
811 fif = fp; /* loc of GOTO */
812 fexpr->f_skip = next_fp - fexpr;
814 c = '<'; /* impersonate an IF */
821 CERROR("'>' expected.");
824 if (fexpr) /* IF ... [ELSIF ...] ENDIF */
825 fexpr->f_skip = next_fp - fexpr;
831 * Free a set of format instructions.
833 * What we do here is:
835 * - Iterate through the list of format instructions, freeing any references
836 * to allocated memory in each instruction.
837 * - Free component references.
838 * - If requested, reset the component hash table; that will also free any
839 * references to components stored there.
844 fmt_free(struct format *fmt, int reset_comptable)
846 struct format *fp = fmt;
849 while (! (fp->f_type == FT_DONE && fp->f_value == 0)) {
850 if (fp->f_flags & FF_STRALLOC)
852 if (fp->f_flags & FF_COMPREF)
853 free_component(fp->f_comp);
864 * Find a component in our hash table. This is just a public interface to
865 * the FINDCOMP macro, so we don't have to expose our hash table.
869 fmt_findcomp(char *component)
873 FINDCOMP(cm, component);
879 * Free and reset our component hash table
886 struct comp *cm, *cm2;
888 for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++) {
902 * Decrement the reference count of a component structure. If it reaches
907 free_component(struct comp *cm)
909 if (--cm->c_refcount <= 0) {
910 /* Shouldn't ever be NULL, but just in case ... */
915 if (cm->c_type & CT_DATE)
917 if (cm->c_type & CT_ADDR && cm->c_mn && cm->c_mn != &fmt_mnull)