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
  10 #include <h/mh.h>
  11 #include <h/addrsbr.h>
  12 #include <h/tws.h>
  13 #include <h/fmt_scan.h>
  14 #include <h/fmt_compile.h>
  15
  16 #ifdef TIME_WITH_SYS_TIME
  17 # include <sys/time.h>
  18 # include <time.h>
  19 #else
  20 # ifdef TM_IN_SYS_TIME
  21 #  include <sys/time.h>
  22 # else
  23 #  include <time.h>
  24 # endif
  25 #endif
  26
  27 /*
  28  * hash table for deciding if a component is "interesting"
  29  */
  30 struct comp *wantcomp[128];
  31
  32 static struct format *formatvec;        /* array to hold formats */
  33 static struct format *next_fp;          /* next free format slot */
  34 static struct format *fp;               /* current format slot   */
  35 static struct comp *cm;                 /* most recent comp ref  */
  36 static struct ftable *ftbl;             /* most recent func ref  */
  37 static int ncomp;
  38 static int infunction;                  /* function nesting cnt  */
  39
  40 extern struct mailname fmt_mnull;
  41
  42 /* ftable->type (argument type) */
  43 #define TF_COMP    0        /* component expected                 */
  44 #define TF_NUM     1        /* number expected                    */
  45 #define TF_STR     2        /* string expected                    */
  46 #define TF_EXPR    3        /* component or func. expected        */
  47 #define TF_NONE    4        /* no argument                        */
  48 #define TF_MYBOX   5        /* special - get current user's mbox  */
  49 #define TF_NOW     6        /* special - get current unix time    */
  50 #define TF_EXPR_SV 7        /* like expr but save current str reg */
  51 #define TF_NOP     8        /* like expr but no result            */
  52
  53 /* ftable->flags */
  54 /* NB that TFL_PUTS is also used to decide whether the test
  55  * in a "%<(function)..." should be a string or numeric one.
  56  */
  57 #define TFL_PUTS   1        /* implicit putstr if top level */
  58 #define TFL_PUTN   2        /* implicit putnum if top level */
  59
  60 struct ftable {
  61     char *name;         /* function name                  */
  62     char type;          /* argument type                  */
  63     char f_type;        /* fmt type                       */
  64     char extra;         /* arg. type dependent extra info */
  65     char flags;
  66 };
  67
  68 static struct ftable functable[] = {
  69      { "nonzero",    TF_EXPR,   FT_V_NE,        FT_IF_V_NE,     0 },
  70      { "zero",       TF_EXPR,   FT_V_EQ,        FT_IF_V_EQ,     0 },
  71      { "eq",         TF_NUM,    FT_V_EQ,        FT_IF_V_EQ,     0 },
  72      { "ne",         TF_NUM,    FT_V_NE,        FT_IF_V_NE,     0 },
  73      { "gt",         TF_NUM,    FT_V_GT,        FT_IF_V_GT,     0 },
  74      { "null",       TF_EXPR,   FT_S_NULL,      FT_IF_S_NULL,   0 },
  75      { "nonnull",    TF_EXPR,   FT_S_NONNULL,   FT_IF_S,        0 },
  76      { "match",      TF_STR,    FT_V_MATCH,     FT_IF_MATCH,    0 },
  77      { "amatch",     TF_STR,    FT_V_AMATCH,    FT_IF_AMATCH,   0 },
  78
  79      { "putstr",     TF_EXPR,   FT_STR,         0,              0 },
  80      { "putstrf",    TF_EXPR,   FT_STRF,        0,              0 },
  81      { "putnum",     TF_EXPR,   FT_NUM,         0,              0 },
  82      { "putnumf",    TF_EXPR,   FT_NUMF,        0,              0 },
  83      { "putaddr",    TF_STR,    FT_PUTADDR,     0,              0 },
  84      { "void",       TF_NOP,    0,              0,              0 },
  85
  86      { "comp",       TF_COMP,   FT_LS_COMP,     0,              TFL_PUTS },
  87      { "lit",        TF_STR,    FT_LS_LIT,      0,              TFL_PUTS },
  88      { "getenv",     TF_STR,    FT_LS_GETENV,   0,              TFL_PUTS },
  89      { "profile",    TF_STR,    FT_LS_CFIND,    0,              TFL_PUTS },
  90      { "decodecomp", TF_COMP,   FT_LS_DECODECOMP, 0,            TFL_PUTS },
  91      { "decode",     TF_EXPR,   FT_LS_DECODE,   0,              TFL_PUTS },
  92      { "trim",       TF_EXPR,   FT_LS_TRIM,     0,              0 },
  93      { "compval",    TF_COMP,   FT_LV_COMP,     0,              TFL_PUTN },
  94      { "compflag",   TF_COMP,   FT_LV_COMPFLAG, 0,              TFL_PUTN },
  95      { "num",        TF_NUM,    FT_LV_LIT,      0,              TFL_PUTN },
  96      { "msg",        TF_NONE,   FT_LV_DAT,      0,              TFL_PUTN },
  97      { "cur",        TF_NONE,   FT_LV_DAT,      1,              TFL_PUTN },
  98      { "size",       TF_NONE,   FT_LV_DAT,      2,              TFL_PUTN },
  99      { "width",      TF_NONE,   FT_LV_DAT,      3,              TFL_PUTN },
 100      { "unseen",     TF_NONE,   FT_LV_DAT,      4,              TFL_PUTN },
 101      { "dat",        TF_NUM,    FT_LV_DAT,      0,              TFL_PUTN },
 102      { "strlen",     TF_NONE,   FT_LV_STRLEN,   0,              TFL_PUTN },
 103      { "me",         TF_MYBOX,  FT_LS_LIT,      0,              TFL_PUTS },
 104      { "plus",       TF_NUM,    FT_LV_PLUS_L,   0,              TFL_PUTN },
 105      { "minus",      TF_NUM,    FT_LV_MINUS_L,  0,              TFL_PUTN },
 106      { "divide",     TF_NUM,    FT_LV_DIVIDE_L, 0,              TFL_PUTN },
 107      { "modulo",     TF_NUM,    FT_LV_MODULO_L, 0,              TFL_PUTN },
 108      { "charleft",   TF_NONE,   FT_LV_CHAR_LEFT, 0,             TFL_PUTN },
 109      { "timenow",    TF_NOW,    FT_LV_LIT,      0,              TFL_PUTN },
 110
 111      { "month",      TF_COMP,   FT_LS_MONTH,    FT_PARSEDATE,   TFL_PUTS },
 112      { "lmonth",     TF_COMP,   FT_LS_LMONTH,   FT_PARSEDATE,   TFL_PUTS },
 113      { "tzone",      TF_COMP,   FT_LS_ZONE,     FT_PARSEDATE,   TFL_PUTS },
 114      { "day",        TF_COMP,   FT_LS_DAY,      FT_PARSEDATE,   TFL_PUTS },
 115      { "weekday",    TF_COMP,   FT_LS_WEEKDAY,  FT_PARSEDATE,   TFL_PUTS },
 116      { "tws",        TF_COMP,   FT_LS_822DATE,  FT_PARSEDATE,   TFL_PUTS },
 117      { "sec",        TF_COMP,   FT_LV_SEC,      FT_PARSEDATE,   TFL_PUTN },
 118      { "min",        TF_COMP,   FT_LV_MIN,      FT_PARSEDATE,   TFL_PUTN },
 119      { "hour",       TF_COMP,   FT_LV_HOUR,     FT_PARSEDATE,   TFL_PUTN },
 120      { "mday",       TF_COMP,   FT_LV_MDAY,     FT_PARSEDATE,   TFL_PUTN },
 121      { "mon",        TF_COMP,   FT_LV_MON,      FT_PARSEDATE,   TFL_PUTN },
 122      { "year",       TF_COMP,   FT_LV_YEAR,     FT_PARSEDATE,   TFL_PUTN },
 123      { "yday",       TF_COMP,   FT_LV_YDAY,     FT_PARSEDATE,   TFL_PUTN },
 124      { "wday",       TF_COMP,   FT_LV_WDAY,     FT_PARSEDATE,   TFL_PUTN },
 125      { "zone",       TF_COMP,   FT_LV_ZONE,     FT_PARSEDATE,   TFL_PUTN },
 126      { "clock",      TF_COMP,   FT_LV_CLOCK,    FT_PARSEDATE,   TFL_PUTN },
 127      { "rclock",     TF_COMP,   FT_LV_RCLOCK,   FT_PARSEDATE,   TFL_PUTN },
 128      { "sday",       TF_COMP,   FT_LV_DAYF,     FT_PARSEDATE,   TFL_PUTN },
 129      { "szone",      TF_COMP,   FT_LV_ZONEF,    FT_PARSEDATE,   TFL_PUTN },
 130      { "dst",        TF_COMP,   FT_LV_DST,      FT_PARSEDATE,   TFL_PUTN },
 131      { "pretty",     TF_COMP,   FT_LS_PRETTY,   FT_PARSEDATE,   TFL_PUTS },
 132      { "nodate",     TF_COMP,   FT_LV_COMPFLAG, FT_PARSEDATE,   TFL_PUTN },
 133      { "date2local", TF_COMP,   FT_LOCALDATE,   FT_PARSEDATE,   0 },
 134      { "date2gmt",   TF_COMP,   FT_GMTDATE,     FT_PARSEDATE,   0 },
 135
 136      { "pers",       TF_COMP,   FT_LS_PERS,     FT_PARSEADDR,   TFL_PUTS },
 137      { "mbox",       TF_COMP,   FT_LS_MBOX,     FT_PARSEADDR,   TFL_PUTS },
 138      { "host",       TF_COMP,   FT_LS_HOST,     FT_PARSEADDR,   TFL_PUTS },
 139      { "path",       TF_COMP,   FT_LS_PATH,     FT_PARSEADDR,   TFL_PUTS },
 140      { "gname",      TF_COMP,   FT_LS_GNAME,    FT_PARSEADDR,   TFL_PUTS },
 141      { "note",       TF_COMP,   FT_LS_NOTE,     FT_PARSEADDR,   TFL_PUTS },
 142      { "addr",       TF_COMP,   FT_LS_ADDR,     FT_PARSEADDR,   TFL_PUTS },
 143      { "proper",     TF_COMP,   FT_LS_822ADDR,  FT_PARSEADDR,   TFL_PUTS },
 144      { "type",       TF_COMP,   FT_LV_HOSTTYPE, FT_PARSEADDR,   TFL_PUTN },
 145      { "ingrp",      TF_COMP,   FT_LV_INGRPF,   FT_PARSEADDR,   TFL_PUTN },
 146      { "nohost",     TF_COMP,   FT_LV_NOHOSTF,  FT_PARSEADDR,   TFL_PUTN },
 147      { "formataddr", TF_EXPR_SV,FT_FORMATADDR,  FT_FORMATADDR,  0 },
 148      { "friendly",   TF_COMP,   FT_LS_FRIENDLY, FT_PARSEADDR,   TFL_PUTS },
 149
 150      { "mymbox",     TF_COMP,   FT_LV_COMPFLAG, FT_MYMBOX,      TFL_PUTN },
 151      { "addtoseq",   TF_STR,    FT_ADDTOSEQ,    0,              0 },
 152
 153      { "unquote",   TF_EXPR,    FT_LS_UNQUOTE,  0,              TFL_PUTS},
 154
 155      { NULL,         0,         0,              0,              0 }
 156 };
 157
 158 /* Add new component to the hash table */
 159 #define NEWCOMP(cm,name) do { \
 160         cm = ((struct comp *) calloc(1, sizeof (struct comp)));\
 161         cm->c_name = name;\
 162         ncomp++;\
 163         i = CHASH(name);\
 164         cm->c_next = wantcomp[i];\
 165         wantcomp[i] = cm; \
 166         } while (0)
 167
 168 #define NEWFMT (next_fp++)
 169 #define NEW(type,fill,wid) do {\
 170         fp=NEWFMT; fp->f_type=(type); fp->f_fill=(fill); fp->f_width=(wid); \
 171         } while (0)
 172
 173 /* Add (possibly new) component to the hash table */
 174 #define ADDC(name) do { \
 175         FINDCOMP(cm, name);\
 176         if (!cm) {\
 177             NEWCOMP(cm,name);\
 178         }\
 179         fp->f_comp = cm; \
 180         } while (0)
 181
 182 #define LV(type, value)         do { NEW(type,0,0); fp->f_value = (value); } while (0)
 183 #define LS(type, str)           do { NEW(type,0,0); fp->f_text = (str); } while (0)
 184
 185 #define PUTCOMP(comp)           do { NEW(FT_COMP,0,0); ADDC(comp); } while (0)
 186 #define PUTLIT(str)             do { NEW(FT_LIT,0,0); fp->f_text = (str); } while (0)
 187 #define PUTC(c)                 do { NEW(FT_CHAR,0,0); fp->f_char = (c); } while (0)
 188
 189 static char *format_string;
 190 static unsigned char *usr_fstring;      /* for CERROR */
 191
 192 #define CERROR(str) compile_error (str, cp)
 193
 194 /*
 195  * external prototypes
 196  */
 197 extern char *getusername(void);
 198
 199 /*
 200  * static prototypes
 201  */
 202 static struct ftable *lookup(char *);
 203 static void compile_error(char *, char *);
 204 static char *compile (char *);
 205 static char *do_spec(char *);
 206 static char *do_name(char *, int);
 207 static char *do_func(char *);
 208 static char *do_expr (char *, int);
 209 static char *do_loop(char *);
 210 static char *do_if(char *);
 211
 212
 213 static struct ftable *
 214 lookup(char *name)
 215 {
 216     register struct ftable *t = functable;
 217     register char *nm;
 218     register char c = *name;
 219
 220     while ((nm = t->name)) {
 221         if (*nm == c && strcmp (nm, name) == 0)
 222             return (ftbl = t);
 223
 224         t++;
 225     }
 226     return (struct ftable *) 0;
 227 }
 228
 229
 230 static void
 231 compile_error(char *str, char *cp)
 232 {
 233     int i, errpos, errctx;
 234
 235     errpos = cp - format_string;
 236     errctx = errpos > 20 ? 20 : errpos;
 237     usr_fstring[errpos] = '\0';
 238
 239     for (i = errpos-errctx; i < errpos; i++) {
 240 #ifdef LOCALE
 241         if (iscntrl(usr_fstring[i]))
 242 #else
 243         if (usr_fstring[i] < 32)
 244 #endif
 245             usr_fstring[i] = '_';
 246     }
 247
 248     advise(NULL, "\"%s\": format compile error - %s",
 249            &usr_fstring[errpos-errctx], str);
 250     adios (NULL, "%*s", errctx+1, "^");
 251 }
 252
 253 /*
 254  * Compile format string "fstring" into format list "fmt".
 255  * Return the number of header components found in the format
 256  * string.
 257  */
 258
 259 int
 260 fmt_compile(char *fstring, struct format **fmt)
 261 {
 262     register char *cp;
 263     int i;
 264
 265     if (format_string)
 266         free (format_string);
 267     format_string = getcpy (fstring);
 268     usr_fstring = fstring;
 269
 270     /* init the component hash table. */
 271     for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++)
 272         wantcomp[i] = 0;
 273
 274     memset((char *) &fmt_mnull, 0, sizeof(fmt_mnull));
 275
 276     /* it takes at least 4 char to generate one format so we
 277      * allocate a worst-case format array using 1/4 the length
 278      * of the format string.  We actually need twice this much
 279      * to handle both pre-processing (e.g., address parsing) and
 280      * normal processing.
 281      */
 282     i = strlen(fstring)/2 + 1;
 283                 if (i==1) i++;
 284     next_fp = formatvec = (struct format *)calloc ((size_t) i,
 285                                                    sizeof(struct format));
 286     if (next_fp == NULL)
 287         adios (NULL, "unable to allocate format storage");
 288
 289     ncomp = 0;
 290     infunction = 0;
 291
 292     cp = compile(format_string);
 293     if (*cp) {
 294         CERROR("extra '%>', '%|' or '%?'");
 295     }
 296     LV(FT_DONE, 0);             /* really done */
 297     *fmt = formatvec;
 298
 299     return (ncomp);
 300 }
 301
 302 static char *
 303 compile (char *sp)
 304 {
 305     register char *cp = sp;
 306     register int  c;
 307
 308     for (;;) {
 309         sp = cp;
 310         while ((c = *cp) && c != '%')
 311             cp++;
 312         *cp = 0;
 313         switch (cp-sp) {
 314         case 0:
 315             break;
 316         case 1:
 317             PUTC(*sp);
 318             break;
 319         default:
 320             PUTLIT(sp);
 321             break;
 322         }
 323         if (c == 0)
 324             return (cp);
 325
 326         switch (c = *++cp) {
 327         case '%':
 328             PUTC (*cp);
 329             cp++;
 330             break;
 331
 332         case '|':
 333         case '>':
 334         case '?':
 335         case ']':
 336             return (cp);
 337
 338         case '<':
 339             cp = do_if(++cp);
 340             break;
 341
 342         case '[':       /* ] */
 343             cp = do_loop(++cp);
 344             break;
 345
 346         case ';':       /* comment line */
 347             cp++;
 348             while ((c = *cp++) && c != '\n')
 349                 continue;
 350             break;
 351
 352         default:
 353             cp = do_spec(cp);
 354             break;
 355         }
 356     }
 357 }
 358
 359
 360 static char *
 361 do_spec(char *sp)
 362 {
 363     register char *cp = sp;
 364     register int c;
 365 #ifndef lint
 366     register int ljust = 0;
 367 #endif  /* not lint */
 368     register int wid = 0;
 369     register char fill = ' ';
 370
 371     c = *cp++;
 372     if (c == '-') {
 373         ljust++;
 374         c = *cp++;
 375     }
 376     if (c == '0') {
 377         fill = c;
 378         c = *cp++;
 379     }
 380     while (isdigit(c)) {
 381         wid = wid*10 + (c - '0');
 382         c = *cp++;
 383     }
 384     if (c == '{') {
 385         cp = do_name(cp, 0);
 386         if (! infunction)
 387             fp->f_type = wid? FT_COMPF : FT_COMP;
 388     }
 389     else if (c == '(') {
 390         cp = do_func(cp);
 391         if (! infunction) {
 392             if (ftbl->flags & TFL_PUTS) {
 393                 LV( wid? FT_STRF : FT_STR, ftbl->extra);
 394             }
 395             else if (ftbl->flags & TFL_PUTN) {
 396                 LV( wid? FT_NUMF : FT_NUM, ftbl->extra);
 397             }
 398         }
 399     }
 400     else {
 401         CERROR("component or function name expected");
 402     }
 403     if (ljust)
 404         wid = -wid;
 405     fp->f_width = wid;
 406     fp->f_fill = fill;
 407
 408     return (cp);
 409 }
 410
 411 static char *
 412 do_name(char *sp, int preprocess)
 413 {
 414     register char *cp = sp;
 415     register int c;
 416     register int i;
 417     static int primed = 0;
 418
 419     while (isalnum(c = *cp++) || c == '-' || c == '_')
 420         ;
 421     if (c != '}') {
 422         CERROR("'}' expected");
 423     }
 424     cp[-1] = '\0';
 425     PUTCOMP(sp);
 426     switch (preprocess) {
 427
 428     case FT_PARSEDATE:
 429         if (cm->c_type & CT_ADDR) {
 430             CERROR("component used as both date and address");
 431         }
 432         cm->c_tws = (struct tws *)
 433             calloc((size_t) 1, sizeof(*cm->c_tws));
 434         fp->f_type = preprocess;
 435         PUTCOMP(sp);
 436         cm->c_type |= CT_DATE;
 437         break;
 438
 439     case FT_MYMBOX:
 440         if (!primed) {
 441             ismymbox ((struct mailname *) 0);
 442             primed++;
 443         }
 444         /* fall through */
 445     case FT_PARSEADDR:
 446         if (cm->c_type & CT_DATE) {
 447             CERROR("component used as both date and address");
 448         }
 449         cm->c_mn = &fmt_mnull;
 450         fp->f_type = preprocess;
 451         PUTCOMP(sp);
 452         cm->c_type |= CT_ADDR;
 453         break;
 454
 455     case FT_FORMATADDR:
 456         if (cm->c_type & CT_DATE) {
 457             CERROR("component used as both date and address");
 458         }
 459         cm->c_type |= CT_ADDR;
 460         break;
 461     }
 462     return (cp);
 463 }
 464
 465 static char *
 466 do_func(char *sp)
 467 {
 468     register char *cp = sp;
 469     register int c;
 470     register struct ftable *t;
 471     register int n;
 472     int mflag;          /* minus sign in NUM */
 473
 474     infunction++;
 475
 476     while (isalnum(c = *cp++))
 477         ;
 478     if (c != '(' && c != '{' && c != ' ' && c != ')') {
 479         CERROR("'(', '{', ' ' or ')' expected");
 480     }
 481     cp[-1] = '\0';
 482     if ((t = lookup (sp)) == 0) {
 483         CERROR("unknown function");
 484     }
 485     if (isspace(c))
 486         c = *cp++;
 487
 488     switch (t->type) {
 489
 490     case TF_COMP:
 491         if (c != '{') {
 492             CERROR("component name expected");
 493         }
 494         cp = do_name(cp, t->extra);
 495         fp->f_type = t->f_type;
 496         c = *cp++;
 497         break;
 498
 499     case TF_NUM:
 500         if ((mflag = (c == '-')))
 501             c = *cp++;
 502         n = 0;
 503         while (isdigit(c)) {
 504             n = n*10 + (c - '0');
 505             c = *cp++;
 506         }
 507         if (mflag)
 508             n = (-n);
 509         LV(t->f_type,n);
 510         break;
 511
 512     case TF_STR:
 513         sp = cp - 1;
 514         while (c && c != ')')
 515             c = *cp++;
 516         cp[-1] = '\0';
 517         LS(t->f_type,sp);
 518         break;
 519
 520     case TF_NONE:
 521         LV(t->f_type,t->extra);
 522         break;
 523
 524     case TF_MYBOX:
 525         LS(t->f_type, getusername());
 526         break;
 527
 528     case TF_NOW:
 529         LV(t->f_type, time((time_t *) 0));
 530         break;
 531
 532     case TF_EXPR_SV:
 533         LV(FT_SAVESTR, 0);
 534         /* fall through */
 535     case TF_EXPR:
 536         *--cp = c;
 537         cp = do_expr(cp, t->extra);
 538         LV(t->f_type, 0);
 539         c = *cp++;
 540         ftbl = t;
 541         break;
 542
 543     case TF_NOP:
 544         *--cp = c;
 545         cp = do_expr(cp, t->extra);
 546         c = *cp++;
 547         ftbl = t;
 548         break;
 549     }
 550     if (c != ')') {
 551         CERROR("')' expected");
 552     }
 553     --infunction;
 554     return (cp);
 555 }
 556
 557 static char *
 558 do_expr (char *sp, int preprocess)
 559 {
 560     register char *cp = sp;
 561     register int  c;
 562
 563     if ((c = *cp++) == '{') {
 564         cp = do_name (cp, preprocess);
 565         fp->f_type = FT_LS_COMP;
 566     } else if (c == '(') {
 567         cp = do_func (cp);
 568     } else if (c == ')') {
 569         return (--cp);
 570     } else if (c == '%' && *cp == '<') {
 571         cp = do_if (cp+1);
 572     } else {
 573         CERROR ("'(', '{', '%<' or ')' expected");
 574     }
 575     return (cp);
 576 }
 577
 578 static char *
 579 do_loop(char *sp)
 580 {
 581     register char *cp = sp;
 582     struct format *floop;
 583
 584     floop = next_fp;
 585     cp = compile (cp);
 586     if (*cp++ != ']')
 587         CERROR ("']' expected");
 588
 589     LV(FT_DONE, 1);             /* not yet done */
 590     LV(FT_GOTO, 0);
 591     fp->f_skip = floop - fp;    /* skip backwards */
 592
 593     return cp;
 594 }
 595
 596 static char *
 597 do_if(char *sp)
 598 {
 599     register char *cp = sp;
 600     register struct format *fexpr,
 601                            *fif = (struct format *)NULL;
 602     register int c = '<';
 603
 604     for (;;) {
 605         if (c == '<') {                 /* doing an IF */
 606             if ((c = *cp++) == '{') /*}*/{
 607                 cp = do_name(cp, 0);
 608                 fp->f_type = FT_LS_COMP;
 609                 LV (FT_IF_S, 0);
 610             }
 611             else if (c == '(') {
 612                 cp = do_func(cp);
 613                 /* see if we can merge the load and the "if" */
 614                 if (ftbl->f_type >= IF_FUNCS)
 615                     fp->f_type = ftbl->extra;
 616                 else {
 617                     /* Put out a string test or a value test depending
 618                      * on what this function's return type is.
 619                      */
 620                     if (ftbl->flags & TFL_PUTS) {
 621                         LV (FT_IF_S, 0);
 622                     } else {
 623                         LV (FT_IF_V_NE, 0);
 624                     }
 625                 }
 626             }
 627             else {
 628                 CERROR("'(' or '{' expected");  /*}*/
 629             }
 630         }
 631
 632         fexpr = fp;                     /* loc of [ELS]IF */
 633         cp = compile (cp);              /* compile IF TRUE stmts */
 634         if (fif)
 635             fif->f_skip = next_fp - fif;
 636
 637         if ((c = *cp++) == '|') {       /* the last ELSE */
 638             LV(FT_GOTO, 0);
 639             fif = fp;                   /* loc of GOTO */
 640             fexpr->f_skip = next_fp - fexpr;
 641
 642             fexpr = (struct format *)NULL;/* no extra ENDIF */
 643
 644             cp = compile (cp);          /* compile ELSE stmts */
 645             fif->f_skip = next_fp - fif;
 646             c = *cp++;
 647         }
 648         else if (c == '?') {            /* another ELSIF */
 649             LV(FT_GOTO, 0);
 650             fif = fp;                   /* loc of GOTO */
 651             fexpr->f_skip = next_fp - fexpr;
 652
 653             c = '<';                    /* impersonate an IF */
 654             continue;
 655         }
 656         break;
 657     }
 658
 659     if (c != '>') {
 660         CERROR("'>' expected.");
 661     }
 662
 663     if (fexpr)                          /* IF ... [ELSIF ...] ENDIF */
 664         fexpr->f_skip = next_fp - fexpr;
 665
 666     return (cp);
 667 }