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

   1 head    1.17;
   2 access;
   3 symbols;
   4 locks
   5         shettich:1.17; strict;
   6 comment @ * @;
   7
   8
   9 1.17
  10 date    93.08.19.21.05.42;      author jromine; state Exp;
  11 branches;
  12 next    1.16;
  13
  14 1.16
  15 date    93.06.12.06.46.16;      author jromine; state Exp;
  16 branches;
  17 next    1.15;
  18
  19 1.15
  20 date    92.12.15.00.20.22;      author jromine; state Exp;
  21 branches;
  22 next    1.14;
  23
  24 1.14
  25 date    92.10.26.22.45.35;      author jromine; state Exp;
  26 branches;
  27 next    1.13;
  28
  29 1.13
  30 date    92.02.09.21.42.12;      author jromine; state Exp;
  31 branches;
  32 next    1.12;
  33
  34 1.12
  35 date    92.02.09.07.09.49;      author jromine; state Exp;
  36 branches;
  37 next    1.11;
  38
  39 1.11
  40 date    92.02.05.04.57.21;      author jromine; state Exp;
  41 branches;
  42 next    1.10;
  43
  44 1.10
  45 date    92.01.23.23.10.58;      author jromine; state Exp;
  46 branches;
  47 next    1.9;
  48
  49 1.9
  50 date    91.01.10.08.35.40;      author mh;      state Exp;
  51 branches;
  52 next    1.8;
  53
  54 1.8
  55 date    91.01.09.22.33.06;      author mh;      state Exp;
  56 branches;
  57 next    1.7;
  58
  59 1.7
  60 date    91.01.09.22.19.43;      author mh;      state Exp;
  61 branches;
  62 next    1.6;
  63
  64 1.6
  65 date    91.01.09.16.31.16;      author mh;      state Exp;
  66 branches;
  67 next    1.5;
  68
  69 1.5
  70 date    90.12.27.17.19.13;      author mh;      state Exp;
  71 branches;
  72 next    1.4;
  73
  74 1.4
  75 date    90.04.05.15.32.23;      author sources; state Exp;
  76 branches;
  77 next    1.3;
  78
  79 1.3
  80 date    90.04.05.14.49.56;      author sources; state Exp;
  81 branches;
  82 next    1.2;
  83
  84 1.2
  85 date    90.02.21.15.51.02;      author sources; state Exp;
  86 branches;
  87 next    1.1;
  88
  89 1.1
  90 date    90.02.21.15.46.42;      author sources; state Exp;
  91 branches;
  92 next    ;
  93
  94
  95 desc
  96 @@
  97
  98
  99 1.17
 100 log
 101 @allow "_" in header field names
 102 @
 103 text
 104 @/* fmtcompile.c - "compile" format strings for fmtscan */
 105 #ifndef lint
 106 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.16 1993/06/12 06:46:16 jromine Exp jromine $";
 107 #endif  /* lint */
 108
 109 #include "../h/mh.h"
 110 #include "../h/addrsbr.h"
 111 #include "../h/formatsbr.h"
 112 #include "../zotnet/tws.h"
 113 #include "../h/fmtcompile.h"
 114 #include <ctype.h>
 115 #include <stdio.h>
 116 #include <sys/types.h>
 117 #include <sys/stat.h>
 118
 119 static struct format *formatvec;        /* array to hold formats */
 120 static struct format *next_fp;          /* next free format slot */
 121 static struct format *fp;               /* current format slot */
 122 static struct comp *cm;                 /* most recent comp ref */
 123 static struct ftable *ftbl;             /* most recent func ref */
 124 static int ncomp;
 125 static int infunction;                  /* function nesting cnt */
 126
 127 extern char *getusr();
 128 extern struct mailname fmt_mnull;
 129
 130 struct ftable {
 131     char        *name;          /* function name */
 132     char        type;           /* argument type */
 133 #define         TF_COMP 0           /* component expected */
 134 #define         TF_NUM  1           /* number expected */
 135 #define         TF_STR  2           /* string expected */
 136 #define         TF_EXPR 3           /* component or func. expected */
 137 #define         TF_NONE 4           /* no argument */
 138 #define         TF_MYBOX 5          /* special - get current user's mbox */
 139 #define         TF_NOW  6           /* special - get current unix time */
 140 #define         TF_EXPR_SV 7        /* like expr but save current str reg */
 141 #define         TF_NOP  8           /* like expr but no result */
 142     char        f_type;         /* fmt type */
 143     char        extra;          /* arg. type dependent extra info */
 144     char        flags;
 145 #define         TFL_PUTS  1         /* implicit putstr if top level */
 146 #define         TFL_PUTN  2         /* implicit putnum if top level */
 147 };
 148
 149 static struct ftable functable[] = {
 150     "nonzero",  TF_EXPR,        FT_V_NE,        FT_IF_V_NE,     0,
 151     "zero",     TF_EXPR,        FT_V_EQ,        FT_IF_V_EQ,     0,
 152     "eq",       TF_NUM,         FT_V_EQ,        FT_IF_V_EQ,     0,
 153     "ne",       TF_NUM,         FT_V_NE,        FT_IF_V_NE,     0,
 154     "gt",       TF_NUM,         FT_V_GT,        FT_IF_V_GT,     0,
 155     "null",     TF_EXPR,        FT_S_NULL,      FT_IF_S_NULL,   0,
 156     "nonnull",  TF_EXPR,        FT_S_NONNULL,   FT_IF_S,        0,
 157     "match",    TF_STR,         FT_V_MATCH,     FT_IF_MATCH,    0,
 158     "amatch",   TF_STR,         FT_V_AMATCH,    FT_IF_AMATCH,   0,
 159
 160     "putstr",   TF_EXPR,        FT_STR,         0,              0,
 161     "putstrf",  TF_EXPR,        FT_STRF,        0,              0,
 162     "putnum",   TF_EXPR,        FT_NUM,         0,              0,
 163     "putnumf",  TF_EXPR,        FT_NUMF,        0,              0,
 164     "putaddr",  TF_STR,         FT_PUTADDR,     0,              0,
 165     "void",     TF_NOP,         0,              0,              0,
 166
 167     "comp",     TF_COMP,        FT_LS_COMP,     0,              TFL_PUTS,
 168     "lit",      TF_STR,         FT_LS_LIT,      0,              TFL_PUTS,
 169     "getenv",   TF_STR,         FT_LS_GETENV,   0,              TFL_PUTS,
 170     "profile",  TF_STR,         FT_LS_MFIND,    0,              TFL_PUTS,
 171     "trim",     TF_EXPR,        FT_LS_TRIM,     0,              0,
 172     "compval",  TF_COMP,        FT_LV_COMP,     0,              TFL_PUTN,
 173     "compflag", TF_COMP,        FT_LV_COMPFLAG, 0,              TFL_PUTN,
 174     "num",      TF_NUM,         FT_LV_LIT,      0,              TFL_PUTN,
 175     "msg",      TF_NONE,        FT_LV_DAT,      0,              TFL_PUTN,
 176     "cur",      TF_NONE,        FT_LV_DAT,      1,              TFL_PUTN,
 177     "size",     TF_NONE,        FT_LV_DAT,      2,              TFL_PUTN,
 178     "width",    TF_NONE,        FT_LV_DAT,      3,              TFL_PUTN,
 179     "unseen",   TF_NONE,        FT_LV_DAT,      4,              TFL_PUTN,
 180     "dat",      TF_NUM,         FT_LV_DAT,      0,              TFL_PUTN,
 181     "strlen",   TF_NONE,        FT_LV_STRLEN,   0,              TFL_PUTN,
 182     "me",       TF_MYBOX,       FT_LS_LIT,      0,              TFL_PUTS,
 183     "plus",     TF_NUM,         FT_LV_PLUS_L,   0,              TFL_PUTN,
 184     "minus",    TF_NUM,         FT_LV_MINUS_L,  0,              TFL_PUTN,
 185     "divide",   TF_NUM,         FT_LV_DIVIDE_L, 0,              TFL_PUTN,
 186     "modulo",   TF_NUM,         FT_LV_MODULO_L, 0,              TFL_PUTN,
 187     "charleft", TF_NONE,        FT_LV_CHAR_LEFT, 0,             TFL_PUTN,
 188     "timenow",  TF_NOW,         FT_LV_LIT,      0,              TFL_PUTN,
 189
 190     "month",    TF_COMP,        FT_LS_MONTH,    FT_PARSEDATE,   TFL_PUTS,
 191     "lmonth",   TF_COMP,        FT_LS_LMONTH,   FT_PARSEDATE,   TFL_PUTS,
 192     "tzone",    TF_COMP,        FT_LS_ZONE,     FT_PARSEDATE,   TFL_PUTS,
 193     "day",      TF_COMP,        FT_LS_DAY,      FT_PARSEDATE,   TFL_PUTS,
 194     "weekday",  TF_COMP,        FT_LS_WEEKDAY,  FT_PARSEDATE,   TFL_PUTS,
 195     "tws",      TF_COMP,        FT_LS_822DATE,  FT_PARSEDATE,   TFL_PUTS,
 196     "sec",      TF_COMP,        FT_LV_SEC,      FT_PARSEDATE,   TFL_PUTN,
 197     "min",      TF_COMP,        FT_LV_MIN,      FT_PARSEDATE,   TFL_PUTN,
 198     "hour",     TF_COMP,        FT_LV_HOUR,     FT_PARSEDATE,   TFL_PUTN,
 199     "mday",     TF_COMP,        FT_LV_MDAY,     FT_PARSEDATE,   TFL_PUTN,
 200     "mon",      TF_COMP,        FT_LV_MON,      FT_PARSEDATE,   TFL_PUTN,
 201     "year",     TF_COMP,        FT_LV_YEAR,     FT_PARSEDATE,   TFL_PUTN,
 202     "yday",     TF_COMP,        FT_LV_YDAY,     FT_PARSEDATE,   TFL_PUTN,
 203     "wday",     TF_COMP,        FT_LV_WDAY,     FT_PARSEDATE,   TFL_PUTN,
 204     "zone",     TF_COMP,        FT_LV_ZONE,     FT_PARSEDATE,   TFL_PUTN,
 205     "clock",    TF_COMP,        FT_LV_CLOCK,    FT_PARSEDATE,   TFL_PUTN,
 206     "rclock",   TF_COMP,        FT_LV_RCLOCK,   FT_PARSEDATE,   TFL_PUTN,
 207     "sday",     TF_COMP,        FT_LV_DAYF,     FT_PARSEDATE,   TFL_PUTN,
 208     "szone",    TF_COMP,        FT_LV_ZONEF,    FT_PARSEDATE,   TFL_PUTN,
 209     "dst",      TF_COMP,        FT_LV_DST,      FT_PARSEDATE,   TFL_PUTN,
 210     "pretty",   TF_COMP,        FT_LS_PRETTY,   FT_PARSEDATE,   TFL_PUTS,
 211     "nodate",   TF_COMP,        FT_LV_COMPFLAG, FT_PARSEDATE,   TFL_PUTN,
 212     "date2local", TF_COMP,      FT_LOCALDATE,   FT_PARSEDATE,   0,
 213     "date2gmt", TF_COMP,        FT_GMTDATE,     FT_PARSEDATE,   0,
 214
 215     "pers",     TF_COMP,        FT_LS_PERS,     FT_PARSEADDR,   TFL_PUTS,
 216     "mbox",     TF_COMP,        FT_LS_MBOX,     FT_PARSEADDR,   TFL_PUTS,
 217     "host",     TF_COMP,        FT_LS_HOST,     FT_PARSEADDR,   TFL_PUTS,
 218     "path",     TF_COMP,        FT_LS_PATH,     FT_PARSEADDR,   TFL_PUTS,
 219     "gname",    TF_COMP,        FT_LS_GNAME,    FT_PARSEADDR,   TFL_PUTS,
 220     "note",     TF_COMP,        FT_LS_NOTE,     FT_PARSEADDR,   TFL_PUTS,
 221     "addr",     TF_COMP,        FT_LS_ADDR,     FT_PARSEADDR,   TFL_PUTS,
 222     "proper",   TF_COMP,        FT_LS_822ADDR,  FT_PARSEADDR,   TFL_PUTS,
 223     "type",     TF_COMP,        FT_LV_HOSTTYPE, FT_PARSEADDR,   TFL_PUTN,
 224     "ingrp",    TF_COMP,        FT_LV_INGRPF,   FT_PARSEADDR,   TFL_PUTN,
 225     "nohost",   TF_COMP,        FT_LV_NOHOSTF,  FT_PARSEADDR,   TFL_PUTN,
 226     "formataddr", TF_EXPR_SV,   FT_FORMATADDR,  FT_FORMATADDR,  0,
 227     "friendly", TF_COMP,        FT_LS_FRIENDLY, FT_PARSEADDR,   TFL_PUTS,
 228
 229     "mymbox",   TF_COMP,        FT_LV_COMPFLAG, FT_MYMBOX,      TFL_PUTN,
 230     "addtoseq", TF_STR,         FT_ADDTOSEQ,    0,              0,
 231
 232     (char *)0,  0,              0,              0,              0
 233 };
 234
 235
 236 long time ();
 237
 238 static struct ftable *lookup(name)
 239     register char *name;
 240 {
 241     register struct ftable *t = functable;
 242     register char *nm;
 243     register char c = *name;
 244
 245     while (nm = t->name) {
 246         if (*nm == c && strcmp (nm, name) == 0)
 247             return (ftbl = t);
 248
 249         t++;
 250     }
 251     return (struct ftable *)0;
 252 }
 253
 254
 255 #define NEWCOMP(cm,name)\
 256         cm = ((struct comp *)calloc(1, sizeof (struct comp)));\
 257         cm->c_name = name; ncomp++;\
 258         i = CHASH(name); cm->c_next = wantcomp[i]; wantcomp[i] = cm;
 259
 260 #define NEWFMT (next_fp++)
 261 #define NEW(type,fill,wid)\
 262         fp=NEWFMT; fp->f_type=(type); fp->f_fill=(fill); fp->f_width=(wid);
 263
 264 #define ADDC(name)\
 265         FINDCOMP( cm, name );\
 266         if ( ! cm ) {\
 267             NEWCOMP(cm,name);\
 268         }\
 269         fp->f_comp = cm;
 270
 271 #define LV( type, value )       NEW(type,0,0); fp->f_value = (value);
 272 #define LS( type, str )         NEW(type,0,0); fp->f_text = (str);
 273 #define PUTCOMP( comp )         NEW(FT_COMP,0,0); ADDC(comp);
 274 #define PUTLIT( str )           NEW(FT_LIT,0,0); fp->f_text = (str);
 275 #define PUTC( c )               NEW(FT_CHAR,0,0); fp->f_char = (c);
 276
 277 static char *compile();
 278 static char *do_spec();
 279 static char *do_name();
 280 static char *do_func();
 281 static char *do_expr();
 282 static char *do_if();
 283 static char *do_loop();
 284
 285 static char *format_string;
 286 static char *usr_fstring;       /* for CERROR */
 287
 288 #define CERROR(str) compile_error (str, cp)
 289
 290 static void
 291 compile_error(str, cp)
 292     char *str;
 293     char *cp;
 294 {
 295     int errpos = cp - format_string;
 296     int errctx = errpos > 20 ? 20 : errpos;
 297     int i;
 298
 299     usr_fstring[errpos] = '\0';
 300     for (i = errpos-errctx; i < errpos; i++)
 301 #ifdef LOCALE
 302         if (iscntrl(usr_fstring[i]))
 303 #else
 304         if (usr_fstring[i] < 32)
 305 #endif
 306             usr_fstring[i] = '_';
 307     advise(NULLCP, "\"%s\": format compile error - %s",
 308            &usr_fstring[errpos-errctx], str);
 309     adios (NULLCP, "%*s", errctx+1, "^");
 310 }
 311
 312 /*
 313  * Compile format string "fstring" into format list "fmt".
 314  * Return the number of header components found in the format
 315  * string.
 316  */
 317 fmt_compile( fstring, fmt )
 318     register char *fstring;
 319     struct format **fmt;
 320 {
 321     register char *cp;
 322     int i;
 323
 324     if (format_string)
 325         (void) free (format_string);
 326     format_string = getcpy (fstring);
 327     usr_fstring = fstring;
 328
 329     /* init the component hash table. */
 330     for (i = 0; i < sizeof(wantcomp)/sizeof(wantcomp[0]); i++)
 331         wantcomp[i] = 0;
 332
 333     bzero ((char *) &fmt_mnull, sizeof fmt_mnull);
 334
 335     /* it takes at least 4 char to generate one format so we
 336      * allocate a worst-case format array using 1/4 the length
 337      * of the format string.  We actually need twice this much
 338      * to handle both pre-processing (e.g., address parsing) and
 339      * normal processing.
 340      */
 341     i = strlen(fstring)/2 + 1;
 342     next_fp = formatvec = (struct format *)calloc ((unsigned) i,
 343                                                    sizeof(struct format));
 344     if (next_fp == NULL)
 345         adios (NULLCP, "unable to allocate format storage");
 346
 347     ncomp = 0;
 348     infunction = 0;
 349
 350     cp = compile(format_string);
 351     if (*cp) {
 352         CERROR("extra '%>', '%|' or '%?'");
 353     }
 354     LV(FT_DONE,0);              /* really done */
 355     *fmt = formatvec;
 356
 357     return (ncomp);
 358 }
 359
 360 static char *compile (sp)
 361     register char *sp;
 362 {
 363     register char *cp = sp;
 364     register int  c;
 365
 366     for (;;) {
 367         sp = cp;
 368         while ((c = *cp) && c != '%')
 369             cp++;
 370         *cp = 0;
 371         switch (cp-sp) {
 372         case 0:
 373             break;
 374         case 1:
 375             PUTC(*sp);
 376             break;
 377         default:
 378             PUTLIT(sp);
 379             break;
 380         }
 381         if (c == 0)
 382             return (cp);
 383
 384         switch (c = *++cp) {
 385         case '%':
 386             PUTC (*cp);
 387             cp++;
 388             break;
 389
 390         case '|':
 391         case '>':
 392         case '?':
 393         case ']':
 394             return (cp);
 395
 396         case '<':
 397             cp = do_if(++cp);
 398             break;
 399
 400         case '[':       /* ] */
 401             cp = do_loop(++cp);
 402             break;
 403
 404         case ';':       /* comment line */
 405             cp++;
 406             while ((c = *cp++) && c != '\n')
 407                 continue;
 408             break;
 409
 410         default:
 411             cp = do_spec(cp);
 412             break;
 413         }
 414     }
 415 }
 416
 417
 418 static char *do_spec(sp)
 419     register char *sp;
 420 {
 421     register char *cp = sp;
 422     register int c;
 423 #ifndef lint
 424     register int ljust = 0;
 425 #endif  /* not lint */
 426     register int wid = 0;
 427     register char fill = ' ';
 428
 429     c = *cp++;
 430     if (c == '-') {
 431         ljust++;
 432         c = *cp++;
 433     }
 434     if (c == '0') {
 435         fill = c;
 436         c = *cp++;
 437     }
 438     while (isdigit(c)) {
 439         wid = wid*10 + (c - '0');
 440         c = *cp++;
 441     }
 442     if (c == '{') {
 443         cp = do_name(cp, 0);
 444         if (! infunction)
 445             fp->f_type = wid? FT_COMPF : FT_COMP;
 446     }
 447     else if (c == '(') {
 448         cp = do_func(cp);
 449         if (! infunction) {
 450             if (ftbl->flags & TFL_PUTS) {
 451                 LV( wid? FT_STRF : FT_STR, ftbl->extra);
 452             }
 453             else if (ftbl->flags & TFL_PUTN) {
 454                 LV( wid? FT_NUMF : FT_NUM, ftbl->extra);
 455             }
 456         }
 457     }
 458     else {
 459         CERROR("component or function name expected");
 460     }
 461     if (ljust)
 462         wid = -wid;
 463     fp->f_width = wid;
 464     fp->f_fill = fill;
 465
 466     return (cp);
 467 }
 468
 469 static char *do_name(sp, preprocess)
 470     char *sp;
 471     int  preprocess;
 472 {
 473     register char *cp = sp;
 474     register int c;
 475     register int i;
 476     static int primed = 0;
 477
 478     while (isalnum(c = *cp++) || c == '-' || c == '_')
 479         ;
 480     if (c != '}') {
 481         CERROR("'}' expected");
 482     }
 483     cp[-1] = '\0';
 484     PUTCOMP(sp);
 485     switch (preprocess) {
 486
 487     case FT_PARSEDATE:
 488         if (cm->c_type & CT_ADDR) {
 489             CERROR("component used as both date and address");
 490         }
 491         if (! (cm->c_type & CT_DATE)) {
 492             cm->c_tws = (struct tws *)
 493                                 calloc((unsigned) 1, sizeof *cm -> c_tws);
 494             fp->f_type = preprocess;
 495             PUTCOMP(sp);
 496             cm->c_type |= CT_DATE;
 497         }
 498         break;
 499
 500     case FT_MYMBOX:
 501         if (!primed) {
 502             (void) ismymbox ((struct mailname *) 0);
 503             primed++;
 504         }
 505         cm->c_type |= CT_MYMBOX;
 506         /* fall through */
 507     case FT_PARSEADDR:
 508         if (cm->c_type & CT_DATE) {
 509             CERROR("component used as both date and address");
 510         }
 511         if (! (cm->c_type & CT_ADDRPARSE)) {
 512             cm->c_mn = &fmt_mnull;
 513             fp->f_type = preprocess;
 514             PUTCOMP(sp);
 515             cm->c_type |= (CT_ADDR | CT_ADDRPARSE);
 516         }
 517         break;
 518
 519     case FT_FORMATADDR:
 520         if (cm->c_type & CT_DATE) {
 521             CERROR("component used as both date and address");
 522         }
 523         cm->c_type |= CT_ADDR;
 524         break;
 525     }
 526     return (cp);
 527 }
 528
 529 static char *do_func(sp)
 530     char *sp;
 531 {
 532     register char *cp = sp;
 533     register int c;
 534     register struct ftable *t;
 535     register int n;
 536     int mflag;          /* minus sign in NUM */
 537
 538     infunction++;
 539
 540     while (isalnum(c = *cp++))
 541         ;
 542     if (c != '(' && c != '{' && c != ' ' && c != ')') {
 543         CERROR("'(', '{', ' ' or ')' expected");
 544     }
 545     cp[-1] = '\0';
 546     if ((t = lookup (sp)) == 0) {
 547         CERROR("unknown function");
 548     }
 549     if (isspace(c))
 550         c = *cp++;
 551
 552     switch (t->type) {
 553
 554     case TF_COMP:
 555         if (c != '{') {
 556             CERROR("component name expected");
 557         }
 558         cp = do_name(cp, t->extra);
 559         fp->f_type = t->f_type;
 560         c = *cp++;
 561         break;
 562
 563     case TF_NUM:
 564         if (mflag = (c == '-'))
 565             c = *cp++;
 566         n = 0;
 567         while (isdigit(c)) {
 568             n = n*10 + (c - '0');
 569             c = *cp++;
 570         }
 571         if (mflag)
 572             n = (-n);
 573         LV(t->f_type,n);
 574         break;
 575
 576     case TF_STR:
 577         sp = cp - 1;
 578         while (c && c != ')')
 579             c = *cp++;
 580         cp[-1] = '\0';
 581         LS(t->f_type,sp);
 582         break;
 583
 584     case TF_NONE:
 585         LV(t->f_type,t->extra);
 586         break;
 587
 588     case TF_MYBOX:
 589         LS(t->f_type, getusr());
 590         break;
 591
 592     case TF_NOW:
 593         LV(t->f_type, time((long *) 0));
 594         break;
 595
 596     case TF_EXPR_SV:
 597         LV(FT_SAVESTR, 0);
 598         /* fall through */
 599     case TF_EXPR:
 600         *--cp = c;
 601         cp = do_expr(cp, t->extra);
 602         LV(t->f_type, 0);
 603         c = *cp++;
 604         ftbl = t;
 605         break;
 606
 607     case TF_NOP:
 608         *--cp = c;
 609         cp = do_expr(cp, t->extra);
 610         c = *cp++;
 611         ftbl = t;
 612         break;
 613     }
 614     if (c != ')') {
 615         CERROR("')' expected");
 616     }
 617     --infunction;
 618     return (cp);
 619 }
 620
 621 static char *do_expr (sp, preprocess)
 622     char *sp;
 623 {
 624     register char *cp = sp;
 625     register int  c;
 626
 627     if ((c = *cp++) == '{') {
 628         cp = do_name (cp, preprocess);
 629         fp->f_type = FT_LS_COMP;
 630     } else if (c == '(') {
 631         cp = do_func (cp);
 632     } else if (c == ')') {
 633         return (--cp);
 634     } else if (c == '%' && *cp == '<') {
 635         cp = do_if (cp+1);
 636     } else {
 637         CERROR ("'(', '{', '%<' or ')' expected");
 638     }
 639     return (cp);
 640 }
 641
 642 static char *do_loop(sp)
 643     register char *sp;
 644 {
 645     register char *cp = sp;
 646     struct format *floop;
 647
 648     floop = next_fp;
 649     cp = compile (cp);
 650     if (*cp++ != ']')
 651         CERROR ("']' expected");
 652
 653     LV(FT_DONE, 1);             /* not yet done */
 654     LV(FT_GOTO, 0);
 655     fp->f_skip = floop - fp;    /* skip backwards */
 656
 657     return cp;
 658 }
 659
 660 static char *do_if(sp)
 661     register char *sp;
 662 {
 663     register char *cp = sp;
 664     register struct format *fexpr,
 665                            *fif = (struct format *)NULL;
 666     register int c = '<';
 667
 668     for (;;) {
 669         if (c == '<') {                 /* doing an IF */
 670             if ((c = *cp++) == '{') /*}*/{
 671                 cp = do_name(cp, 0);
 672                 fp->f_type = FT_LS_COMP;
 673                 LV (FT_IF_S, 0);
 674             }
 675             else if (c == '(') {
 676                 cp = do_func(cp);
 677                 /* see if we can merge the load and the "if" */
 678                 if (ftbl->f_type >= IF_FUNCS)
 679                     fp->f_type = ftbl->extra;
 680                 else {
 681                     LV (FT_IF_V_NE, 0);
 682                 }
 683             }
 684             else {
 685                 CERROR("'(' or '{' expected");  /*}*/
 686             }
 687         }
 688
 689         fexpr = fp;                     /* loc of [ELS]IF */
 690         cp = compile (cp);              /* compile IF TRUE stmts */
 691         if (fif)
 692             fif->f_skip = next_fp - fif;
 693
 694         if ((c = *cp++) == '|') {       /* the last ELSE */
 695             LV(FT_GOTO, 0);
 696             fif = fp;                   /* loc of GOTO */
 697             fexpr->f_skip = next_fp - fexpr;
 698
 699             fexpr = (struct format *)NULL;/* no extra ENDIF */
 700
 701             cp = compile (cp);          /* compile ELSE stmts */
 702             fif->f_skip = next_fp - fif;
 703             c = *cp++;
 704         }
 705         else if (c == '?') {            /* another ELSIF */
 706             LV(FT_GOTO, 0);
 707             fif = fp;                   /* loc of GOTO */
 708             fexpr->f_skip = next_fp - fexpr;
 709
 710             c = '<';                    /* impersonate an IF */
 711             continue;
 712         }
 713         break;
 714     }
 715
 716     if (c != '>') {
 717         CERROR("'>' expected.");
 718     }
 719
 720     if (fexpr)                          /* IF ... [ELSIF ...] ENDIF */
 721         fexpr->f_skip = next_fp - fexpr;
 722
 723     return (cp);
 724 }
 725 @
 726
 727
 728 1.16
 729 log
 730 @add %(profile xxx) to return m_find(xxx)
 731 @
 732 text
 733 @d3 1
 734 a3 1
 735 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.15 1992/12/15 00:20:22 jromine Exp jromine $";
 736 d375 1
 737 a375 1
 738     while (isalnum(c = *cp++) || c == '-')
 739 @
 740
 741
 742 1.15
 743 log
 744 @endif sugar
 745 @
 746 text
 747 @d3 1
 748 a3 1
 749 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.14 1992/10/26 22:45:35 jromine Exp jromine $";
 750 d67 1
 751 @
 752
 753
 754 1.14
 755 log
 756 @LOCALE
 757 @
 758 text
 759 @d3 2
 760 a4 2
 761 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.13 1992/02/09 21:42:12 jromine Exp jromine $";
 762 #endif  lint
 763 d321 1
 764 a321 1
 765 #endif  not lint
 766 @
 767
 768
 769 1.13
 770 log
 771 @allow comment lines with '%; ... \n'
 772 @
 773 text
 774 @d3 1
 775 a3 1
 776 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.12 1992/02/09 07:09:49 jromine Exp jromine $";
 777 d197 3
 778 d201 1
 779 @
 780
 781
 782 1.12
 783 log
 784 @fix bug in %(zero)/%(nonzero) (actually, all TF_EXPR
 785 formats which include a IF_V_... test
 786 add %(modulo n)
 787 put Van Jacobson changes under "options LBL"
 788 @
 789 text
 790 @d3 1
 791 a3 1
 792 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.11 1992/02/05 04:57:21 jromine Exp $";
 793 d294 6
 794 @
 795
 796
 797 1.11
 798 log
 799 @add unseen - uses dat[5]
 800 @
 801 text
 802 @d3 1
 803 a3 1
 804 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.10 1992/01/23 23:10:58 jromine Exp jromine $";
 805 d82 1
 806 a125 1
 807 #ifdef  VAN
 808 a126 1
 809 #endif
 810 d422 1
 811 d450 2
 812 d457 2
 813 d488 1
 814 a488 1
 815         LV(t->f_type, t->extra);
 816 @
 817
 818
 819 1.10
 820 log
 821 @new formatsbr changes under JLR
 822 @
 823 text
 824 @d3 1
 825 a3 1
 826 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.9 1991/01/10 08:35:40 mh Exp jromine $";
 827 d75 1
 828 @
 829
 830
 831 1.9
 832 log
 833 @cleanup
 834 jlr
 835 @
 836 text
 837 @d3 1
 838 a3 1
 839 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.8 91/01/09 22:33:06 mh Exp Locker: mh $";
 840 d66 1
 841 d179 1
 842 d246 1
 843 a246 1
 844     NEW(FT_DONE,0,0);
 845 d285 1
 846 d292 4
 847 d521 18
 848 @
 849
 850
 851 1.8
 852 log
 853 @use '%?' as ELSIF
 854 jlr
 855 @
 856 text
 857 @d3 1
 858 a3 1
 859 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.7 91/01/09 22:19:43 mh Exp Locker: mh $";
 860 d520 2
 861 a521 1
 862     register struct format *fexpr, *fif = (struct format *)NULL;
 863 d525 1
 864 a525 1
 865         if (c == '<') {
 866 d550 1
 867 a550 1
 868         if ((c = *cp++) == '|') {       /* another ELSE/ELSIF */
 869 d553 1
 870 a553 1
 871             fexpr->f_skip = next_fp - fexpr;    /* next stmt */
 872 d555 1
 873 a555 1
 874             fexpr = (struct format *)NULL;
 875 d557 1
 876 a557 1
 877             cp = compile (cp);  /* compile ELSE stmts */
 878 d564 1
 879 a564 1
 880             fexpr->f_skip = next_fp - fexpr;    /* next stmt */
 881 d566 1
 882 a566 1
 883             c = '<';                    /* impresonate an IF */
 884 d576 1
 885 a576 1
 886     if (fexpr)
 887 @
 888
 889
 890 1.7
 891 log
 892 @jlr
 893 @
 894 text
 895 @d3 1
 896 a3 1
 897 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.6 91/01/09 16:31:16 mh Exp Locker: mh $";
 898 d242 1
 899 a242 1
 900         CERROR("extra '%>' or '%|'");
 901 d282 1
 902 a553 6
 903             if ((c = *cp) == '<') {
 904                 cp++;
 905                 continue;
 906             }
 907             else if (c == '\\')         /* allow quoted '<' chars */
 908                 cp++;
 909 d559 8
 910 @
 911
 912
 913 1.6
 914 log
 915 @allow "ELSEIF" with "%|<"
 916 jlr
 917 @
 918 text
 919 @d3 1
 920 a3 1
 921 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.5 90/12/27 17:19:13 mh Exp Locker: mh $";
 922 d557 2
 923 @
 924
 925
 926 1.5
 927 log
 928 @add "addr" address format.
 929 jlr
 930 @
 931 text
 932 @d3 1
 933 a3 1
 934 static char ident[] = "@@(#)$Id: fmtcompile.c,v 1.4 90/04/05 15:32:23 sources Exp Locker: mh $";
 935 d519 2
 936 a520 2
 937     register struct format *fexpr, *fif, *felse;
 938     register int c;
 939 d522 19
 940 a540 12
 941     if ((c = *cp++) == '{') {
 942         cp = do_name(cp, 0);
 943         fp->f_type = FT_LS_COMP;
 944         LV (FT_IF_S, 0);
 945     }
 946     else if (c == '(') {
 947         cp = do_func(cp);
 948         /* see if we can merge the load and the "if" */
 949         if (ftbl->f_type >= IF_FUNCS)
 950             fp->f_type = ftbl->extra;
 951         else {
 952             LV (FT_IF_V_NE, 0);
 953 d542 22
 954 a564 15
 955     else  {
 956         CERROR("'(' or '{' expected");
 957     }
 958     fexpr = fp;
 959     cp = compile (cp);
 960     if ((c = *cp++) == '|') {
 961         LV(FT_GOTO, 0);
 962         fif = fp;
 963         felse = next_fp;
 964         cp = compile(cp);
 965         fif->f_skip = next_fp - fif;
 966         c = *cp++;
 967     }
 968     else
 969         felse = next_fp;
 970 d569 3
 971 a571 1
 972     fexpr->f_skip = felse - fexpr;
 973 @
 974
 975
 976 1.4
 977 log
 978 @add ID
 979 @
 980 text
 981 @d3 1
 982 a3 1
 983 static char ident[] = "@@(#)$Id:$";
 984 d114 1
 985 @
 986
 987
 988 1.3
 989 log
 990 @add ID
 991 @
 992 text
 993 @d3 1
 994 a3 1
 995 static char ident[] = "$Id:";
 996 @
 997
 998
 999 1.2
1000 log
1001 @Fixes from Van Jacobson
1002 @
1003 text
1004 @d2 3
1005 @
1006
1007
1008 1.1
1009 log
1010 @Initial revision
1011 @
1012 text
1013 @d63 1
1014 d76 1
1015 d98 2
1016 a99 1
1017     "dst",      TF_COMP,        FT_LV_TZONEF,   FT_PARSEDATE,   TFL_PUTN,
1018 d102 2
1019 d119 3
1020 d180 2
1021 a181 1
1022 static compile_error (str, cp)
1023 d305 1
1024 a305 3
1025 #ifndef lint
1026         ljust++;                /* should do something with this */
1027 #endif  not lint
1028 d335 2
1029 @