diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/sbr/fmtcompile.c

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