diplodocus.org Git - nmh/blob - uip/picksbr.c

   1
   2 /*
   3  * picksbr.c -- routines to help pick along...
   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/tws.h>
  12 #include <h/picksbr.h>
  13 #include <h/utils.h>
  14
  15 #ifdef HAVE_SYS_TIME_H
  16 # include <sys/time.h>
  17 #endif
  18 #include <time.h>
  19
  20 static struct swit parswit[] = {
  21 #define PRAND                   0
  22     { "and", 0 },
  23 #define PROR                    1
  24     { "or", 0 },
  25 #define PRNOT                   2
  26     { "not", 0 },
  27 #define PRLBR                   3
  28     { "lbrace", 0 },
  29 #define PRRBR                   4
  30     { "rbrace", 0 },
  31 #define PRCC                    5
  32     { "cc  pattern", 0 },
  33 #define PRDATE                  6
  34     { "date  pattern", 0 },
  35 #define PRFROM                  7
  36     { "from  pattern", 0 },
  37 #define PRSRCH                  8
  38     { "search  pattern", 0 },
  39 #define PRSUBJ                  9
  40     { "subject  pattern", 0 },
  41 #define PRTO                   10
  42     { "to  pattern", 0 },
  43 #define PROTHR                 11
  44     { "-othercomponent  pattern", 15 },
  45 #define PRAFTR                 12
  46     { "after date", 0 },
  47 #define PRBEFR                 13
  48     { "before date", 0 },
  49 #define PRDATF                 14
  50     { "datefield field", 5 },
  51     { NULL, 0 }
  52 };
  53
  54 /* DEFINITIONS FOR PATTERN MATCHING */
  55
  56 /*
  57  * We really should be using re_comp() and re_exec() here.  Unfortunately,
  58  * pick advertises that lowercase characters matches characters of both
  59  * cases.  Since re_exec() doesn't exhibit this behavior, we are stuck
  60  * with this version.  Furthermore, we need to be able to save and restore
  61  * the state of the pattern matcher in order to do things "efficiently".
  62  *
  63  * The matching power of this algorithm isn't as powerful as the re_xxx()
  64  * routines (no \(xxx\) and \n constructs).  Such is life.
  65  */
  66
  67 #define CCHR    2
  68 #define CDOT    4
  69 #define CCL     6
  70 #define NCCL    8
  71 #define CDOL    10
  72 #define CEOF    11
  73
  74 #define STAR    01
  75
  76 #define LBSIZE  1024
  77 #define ESIZE   1024
  78
  79
  80 static char linebuf[LBSIZE + 1];
  81
  82 /* the magic array for case-independence */
  83 static char cc[] = {
  84         0000,0001,0002,0003,0004,0005,0006,0007,
  85         0010,0011,0012,0013,0014,0015,0016,0017,
  86         0020,0021,0022,0023,0024,0025,0026,0027,
  87         0030,0031,0032,0033,0034,0035,0036,0037,
  88         0040,0041,0042,0043,0044,0045,0046,0047,
  89         0050,0051,0052,0053,0054,0055,0056,0057,
  90         0060,0061,0062,0063,0064,0065,0066,0067,
  91         0070,0071,0072,0073,0074,0075,0076,0077,
  92         0100,0141,0142,0143,0144,0145,0146,0147,
  93         0150,0151,0152,0153,0154,0155,0156,0157,
  94         0160,0161,0162,0163,0164,0165,0166,0167,
  95         0170,0171,0172,0133,0134,0135,0136,0137,
  96         0140,0141,0142,0143,0144,0145,0146,0147,
  97         0150,0151,0152,0153,0154,0155,0156,0157,
  98         0160,0161,0162,0163,0164,0165,0166,0167,
  99         0170,0171,0172,0173,0174,0175,0176,0177,
 100
 101         0200,0201,0202,0203,0204,0205,0206,0207,
 102         0210,0211,0212,0213,0214,0215,0216,0217,
 103         0220,0221,0222,0223,0224,0225,0226,0227,
 104         0230,0231,0232,0233,0234,0235,0236,0237,
 105         0240,0241,0242,0243,0244,0245,0246,0247,
 106         0250,0251,0252,0253,0254,0255,0256,0257,
 107         0260,0261,0262,0263,0264,0265,0266,0267,
 108         0270,0271,0272,0273,0274,0275,0276,0277,
 109         0300,0301,0302,0303,0304,0305,0306,0307,
 110         0310,0311,0312,0313,0314,0315,0316,0317,
 111         0320,0321,0322,0323,0324,0325,0326,0327,
 112         0330,0331,0332,0333,0334,0335,0336,0337,
 113         0340,0341,0342,0343,0344,0345,0346,0347,
 114         0350,0351,0352,0353,0354,0355,0356,0357,
 115         0360,0361,0362,0363,0364,0365,0366,0367,
 116         0370,0371,0372,0373,0374,0375,0376,0377,
 117 };
 118
 119 /*
 120  * DEFINITIONS FOR NEXUS
 121  */
 122
 123 #define nxtarg()        (*argp ? *argp++ : NULL)
 124 #define prvarg()        argp--
 125
 126 #define padvise         if (!talked++) advise
 127
 128 struct nexus {
 129     int (*n_action)();
 130
 131     union {
 132         /* for {OR,AND,NOT}action */
 133         struct {
 134             struct nexus *un_L_child;
 135             struct nexus *un_R_child;
 136         } st1;
 137
 138         /* for GREPaction */
 139         struct {
 140             int   un_header;
 141             int   un_circf;
 142             char  un_expbuf[ESIZE];
 143             char *un_patbuf;
 144         } st2;
 145
 146         /* for TWSaction */
 147         struct {
 148             char *un_datef;
 149             int   un_after;
 150             struct tws un_tws;
 151         } st3;
 152     } un;
 153 };
 154
 155 #define n_L_child un.st1.un_L_child
 156 #define n_R_child un.st1.un_R_child
 157
 158 #define n_header un.st2.un_header
 159 #define n_circf  un.st2.un_circf
 160 #define n_expbuf un.st2.un_expbuf
 161 #define n_patbuf un.st2.un_patbuf
 162
 163 #define n_datef  un.st3.un_datef
 164 #define n_after  un.st3.un_after
 165 #define n_tws    un.st3.un_tws
 166
 167 static int talked;
 168 static int pdebug = 0;
 169
 170 static char *datesw;
 171 static char **argp;
 172
 173 static struct nexus *head;
 174
 175 /*
 176  * prototypes for date routines
 177  */
 178 static struct tws *tws_parse(char *, int);
 179 static struct tws *tws_special(char *);
 180
 181 /*
 182  * static prototypes
 183  */
 184 static void PRaction(struct nexus *, int);
 185 static int gcompile(struct nexus *, char *);
 186 static int advance(char *, char *);
 187 static int cclass(unsigned char *, int, int);
 188 static int tcompile(char *, struct tws *, int);
 189
 190 static struct nexus *parse(void);
 191 static struct nexus *nexp1(void);
 192 static struct nexus *nexp2(void);
 193 static struct nexus *nexp3(void);
 194 static struct nexus *newnexus(int (*)());
 195
 196 static int ORaction();
 197 static int ANDaction();
 198 static int NOTaction();
 199 static int GREPaction();
 200 static int TWSaction();
 201
 202
 203 int
 204 pcompile (char **vec, char *date)
 205 {
 206     register char *cp;
 207
 208     if ((cp = getenv ("MHPDEBUG")) && *cp)
 209         pdebug++;
 210
 211     argp = vec;
 212     if ((datesw = date) == NULL)
 213         datesw = "date";
 214     talked = 0;
 215
 216     if ((head = parse ()) == NULL)
 217         return (talked ? 0 : 1);
 218
 219     if (*argp) {
 220         padvise (NULL, "%s unexpected", *argp);
 221         return 0;
 222     }
 223
 224     return 1;
 225 }
 226
 227
 228 static struct nexus *
 229 parse (void)
 230 {
 231     register char  *cp;
 232     register struct nexus *n, *o;
 233
 234     if ((n = nexp1 ()) == NULL || (cp = nxtarg ()) == NULL)
 235         return n;
 236
 237     if (*cp != '-') {
 238         padvise (NULL, "%s unexpected", cp);
 239         return NULL;
 240     }
 241
 242     if (*++cp == '-')
 243         goto header;
 244     switch (smatch (cp, parswit)) {
 245         case AMBIGSW:
 246             ambigsw (cp, parswit);
 247             talked++;
 248             return NULL;
 249         case UNKWNSW:
 250             fprintf (stderr, "-%s unknown\n", cp);
 251             talked++;
 252             return NULL;
 253
 254         case PROR:
 255             o = newnexus (ORaction);
 256             o->n_L_child = n;
 257             if ((o->n_R_child = parse ()))
 258                 return o;
 259             padvise (NULL, "missing disjunctive");
 260             return NULL;
 261
 262 header: ;
 263         default:
 264             prvarg ();
 265             return n;
 266     }
 267 }
 268
 269 static struct nexus *
 270 nexp1 (void)
 271 {
 272     register char *cp;
 273     register struct nexus *n, *o;
 274
 275     if ((n = nexp2 ()) == NULL || (cp = nxtarg ()) == NULL)
 276         return n;
 277
 278     if (*cp != '-') {
 279         padvise (NULL, "%s unexpected", cp);
 280         return NULL;
 281     }
 282
 283     if (*++cp == '-')
 284         goto header;
 285     switch (smatch (cp, parswit)) {
 286         case AMBIGSW:
 287             ambigsw (cp, parswit);
 288             talked++;
 289             return NULL;
 290         case UNKWNSW:
 291             fprintf (stderr, "-%s unknown\n", cp);
 292             talked++;
 293             return NULL;
 294
 295         case PRAND:
 296             o = newnexus (ANDaction);
 297             o->n_L_child = n;
 298             if ((o->n_R_child = nexp1 ()))
 299                 return o;
 300             padvise (NULL, "missing conjunctive");
 301             return NULL;
 302
 303 header: ;
 304         default:
 305             prvarg ();
 306             return n;
 307     }
 308 }
 309
 310
 311 static struct nexus *
 312 nexp2 (void)
 313 {
 314     register char *cp;
 315     register struct nexus *n;
 316
 317     if ((cp = nxtarg ()) == NULL)
 318         return NULL;
 319
 320     if (*cp != '-') {
 321         prvarg ();
 322         return nexp3 ();
 323     }
 324
 325     if (*++cp == '-')
 326         goto header;
 327     switch (smatch (cp, parswit)) {
 328         case AMBIGSW:
 329             ambigsw (cp, parswit);
 330             talked++;
 331             return NULL;
 332         case UNKWNSW:
 333             fprintf (stderr, "-%s unknown\n", cp);
 334             talked++;
 335             return NULL;
 336
 337         case PRNOT:
 338             n = newnexus (NOTaction);
 339             if ((n->n_L_child = nexp3 ()))
 340                 return n;
 341             padvise (NULL, "missing negation");
 342             return NULL;
 343
 344 header: ;
 345         default:
 346             prvarg ();
 347             return nexp3 ();
 348     }
 349 }
 350
 351 static struct nexus *
 352 nexp3 (void)
 353 {
 354     int i;
 355     register char *cp, *dp;
 356     char buffer[BUFSIZ], temp[64];
 357     register struct nexus *n;
 358
 359     if ((cp = nxtarg ()) == NULL)
 360         return NULL;
 361
 362     if (*cp != '-') {
 363         padvise (NULL, "%s unexpected", cp);
 364         return NULL;
 365     }
 366
 367     if (*++cp == '-') {
 368         dp = ++cp;
 369         goto header;
 370     }
 371     switch (i = smatch (cp, parswit)) {
 372         case AMBIGSW:
 373             ambigsw (cp, parswit);
 374             talked++;
 375             return NULL;
 376         case UNKWNSW:
 377             fprintf (stderr, "-%s unknown\n", cp);
 378             talked++;
 379             return NULL;
 380
 381         case PRLBR:
 382             if ((n = parse ()) == NULL) {
 383                 padvise (NULL, "missing group");
 384                 return NULL;
 385             }
 386             if ((cp = nxtarg ()) == NULL) {
 387                 padvise (NULL, "missing -rbrace");
 388                 return NULL;
 389             }
 390             if (*cp++ == '-' && smatch (cp, parswit) == PRRBR)
 391                 return n;
 392             padvise (NULL, "%s unexpected", --cp);
 393             return NULL;
 394
 395         default:
 396             prvarg ();
 397             return NULL;
 398
 399         case PRCC:
 400         case PRDATE:
 401         case PRFROM:
 402         case PRTO:
 403         case PRSUBJ:
 404             strncpy(temp, parswit[i].sw, sizeof(temp));
 405             temp[sizeof(temp) - 1] = '\0';
 406             dp = *brkstring (temp, " ", NULL);
 407     header: ;
 408             if (!(cp = nxtarg ())) {/* allow -xyz arguments */
 409                 padvise (NULL, "missing argument to %s", argp[-2]);
 410                 return NULL;
 411             }
 412             n = newnexus (GREPaction);
 413             n->n_header = 1;
 414             snprintf (buffer, sizeof(buffer), "^%s[ \t]*:.*%s", dp, cp);
 415             dp = buffer;
 416             goto pattern;
 417
 418         case PRSRCH:
 419             n = newnexus (GREPaction);
 420             n->n_header = 0;
 421             if (!(cp = nxtarg ())) {/* allow -xyz arguments */
 422                 padvise (NULL, "missing argument to %s", argp[-2]);
 423                 return NULL;
 424             }
 425             dp = cp;
 426     pattern: ;
 427             if (!gcompile (n, dp)) {
 428                 padvise (NULL, "pattern error in %s %s", argp[-2], cp);
 429                 return NULL;
 430             }
 431             n->n_patbuf = getcpy (dp);
 432             return n;
 433
 434         case PROTHR:
 435             padvise (NULL, "internal error!");
 436             return NULL;
 437
 438         case PRDATF:
 439             if (!(datesw = nxtarg ()) || *datesw == '-') {
 440                 padvise (NULL, "missing argument to %s", argp[-2]);
 441                 return NULL;
 442             }
 443             return nexp3 ();
 444
 445         case PRAFTR:
 446         case PRBEFR:
 447             if (!(cp = nxtarg ())) {/* allow -xyz arguments */
 448                 padvise (NULL, "missing argument to %s", argp[-2]);
 449                 return NULL;
 450             }
 451             n = newnexus (TWSaction);
 452             n->n_datef = datesw;
 453             if (!tcompile (cp, &n->n_tws, n->n_after = i == PRAFTR)) {
 454                 padvise (NULL, "unable to parse %s %s", argp[-2], cp);
 455                 return NULL;
 456             }
 457             return n;
 458     }
 459 }
 460
 461
 462 static struct nexus *
 463 newnexus (int (*action)())
 464 {
 465     register struct nexus *p;
 466
 467     if ((p = (struct nexus *) calloc ((size_t) 1, sizeof *p)) == NULL)
 468         adios (NULL, "unable to allocate component storage");
 469
 470     p->n_action = action;
 471     return p;
 472 }
 473
 474
 475 #define args(a) a, fp, msgnum, start, stop
 476 #define params  args (n)
 477 #define plist   \
 478             register struct nexus  *n; \
 479             register FILE *fp; \
 480             int msgnum; \
 481             long    start, \
 482                     stop;
 483
 484 int
 485 pmatches (FILE *fp, int msgnum, long start, long stop)
 486 {
 487     if (!head)
 488         return 1;
 489
 490     if (!talked++ && pdebug)
 491         PRaction (head, 0);
 492
 493     return (*head->n_action) (args (head));
 494 }
 495
 496
 497 static void
 498 PRaction (struct nexus *n, int level)
 499 {
 500     register int i;
 501
 502     for (i = 0; i < level; i++)
 503         fprintf (stderr, "| ");
 504
 505     if (n->n_action == ORaction) {
 506         fprintf (stderr, "OR\n");
 507         PRaction (n->n_L_child, level + 1);
 508         PRaction (n->n_R_child, level + 1);
 509         return;
 510     }
 511     if (n->n_action == ANDaction) {
 512         fprintf (stderr, "AND\n");
 513         PRaction (n->n_L_child, level + 1);
 514         PRaction (n->n_R_child, level + 1);
 515         return;
 516     }
 517     if (n->n_action == NOTaction) {
 518         fprintf (stderr, "NOT\n");
 519         PRaction (n->n_L_child, level + 1);
 520         return;
 521     }
 522     if (n->n_action == GREPaction) {
 523         fprintf (stderr, "PATTERN(%s) %s\n",
 524                 n->n_header ? "header" : "body", n->n_patbuf);
 525         return;
 526     }
 527     if (n->n_action == TWSaction) {
 528         fprintf (stderr, "TEMPORAL(%s) %s: %s\n",
 529                 n->n_after ? "after" : "before", n->n_datef,
 530                 dasctime (&n->n_tws, TW_NULL));
 531         return;
 532     }
 533     fprintf (stderr, "UNKNOWN(0x%x)\n",
 534              (unsigned int)(unsigned long) (*n->n_action));
 535 }
 536
 537
 538 static int
 539 ORaction (params)
 540 plist
 541 {
 542     if ((*n->n_L_child->n_action) (args (n->n_L_child)))
 543         return 1;
 544     return (*n->n_R_child->n_action) (args (n->n_R_child));
 545 }
 546
 547
 548 static int
 549 ANDaction (params)
 550 plist
 551 {
 552     if (!(*n->n_L_child->n_action) (args (n->n_L_child)))
 553         return 0;
 554     return (*n->n_R_child->n_action) (args (n->n_R_child));
 555 }
 556
 557
 558 static int
 559 NOTaction (params)
 560 plist
 561 {
 562     return (!(*n->n_L_child->n_action) (args (n->n_L_child)));
 563 }
 564
 565
 566 static int
 567 gcompile (struct nexus *n, char *astr)
 568 {
 569     register int c;
 570     int cclcnt;
 571     register unsigned char *ep, *dp, *sp, *lastep = 0;
 572
 573     dp = (ep = n->n_expbuf) + sizeof n->n_expbuf;
 574     sp = astr;
 575     if (*sp == '^') {
 576         n->n_circf = 1;
 577         sp++;
 578     }
 579     else
 580         n->n_circf = 0;
 581     for (;;) {
 582         if (ep >= dp)
 583             goto cerror;
 584         if ((c = *sp++) != '*')
 585             lastep = ep;
 586         switch (c) {
 587             case '\0':
 588                 *ep++ = CEOF;
 589                 return 1;
 590
 591             case '.':
 592                 *ep++ = CDOT;
 593                 continue;
 594
 595             case '*':
 596                 if (lastep == 0)
 597                     goto defchar;
 598                 *lastep |= STAR;
 599                 continue;
 600
 601             case '$':
 602                 if (*sp != '\0')
 603                     goto defchar;
 604                 *ep++ = CDOL;
 605                 continue;
 606
 607             case '[':
 608                 *ep++ = CCL;
 609                 *ep++ = 0;
 610                 cclcnt = 0;
 611                 if ((c = *sp++) == '^') {
 612                     c = *sp++;
 613                     ep[-2] = NCCL;
 614                 }
 615                 if (c == '-') {
 616                     *ep++ = c;
 617                     cclcnt++;
 618                     c = *sp++;
 619                 }
 620                 do {
 621                     if (c == '-' && *sp != '\0' && *sp != ']') {
 622                         for (c = ep[-1]+1; c < *sp; c++) {
 623                             *ep++ = c;
 624                             cclcnt++;
 625                             if (c == '\0' || ep >= dp)
 626                                 goto cerror;
 627                         }
 628                     } else {
 629                         *ep++ = c;
 630                         cclcnt++;
 631                         if (c == '\0' || ep >= dp)
 632                             goto cerror;
 633                     }
 634                 } while ((c = *sp++) != ']');
 635                 if (cclcnt > 255)
 636                     goto cerror;
 637                 lastep[1] = cclcnt;
 638                 continue;
 639
 640             case '\\':
 641                 if ((c = *sp++) == '\0')
 642                     goto cerror;
 643         defchar:
 644             default:
 645                 *ep++ = CCHR;
 646                 *ep++ = c;
 647         }
 648     }
 649
 650 cerror: ;
 651     return 0;
 652 }
 653
 654
 655 static int
 656 GREPaction (params)
 657 plist
 658 {
 659     NMH_UNUSED (msgnum);
 660
 661     int c, body, lf;
 662     long pos = start;
 663     register char *p1, *p2, *ebp, *cbp;
 664     char ibuf[BUFSIZ];
 665
 666     fseek (fp, start, SEEK_SET);
 667     body = 0;
 668     ebp = cbp = ibuf;
 669     for (;;) {
 670         if (body && n->n_header)
 671             return 0;
 672         p1 = linebuf;
 673         p2 = cbp;
 674         lf = 0;
 675         for (;;) {
 676             if (p2 >= ebp) {
 677                 if (fgets (ibuf, sizeof ibuf, fp) == NULL
 678                         || (stop && pos >= stop)) {
 679                     if (lf)
 680                         break;
 681                     return 0;
 682                 }
 683                 pos += (long) strlen (ibuf);
 684                 p2 = ibuf;
 685                 ebp = ibuf + strlen (ibuf);
 686             }
 687             c = *p2++;
 688             if (lf && c != '\n') {
 689                 if (c != ' ' && c != '\t') {
 690                     --p2;
 691                     break;
 692                 }
 693                 else
 694                     lf = 0;
 695             }
 696             if (c == '\n') {
 697                 if (body)
 698                     break;
 699                 else {
 700                     if (lf) {
 701                         body++;
 702                         break;
 703                     }
 704                     lf++;
 705                     c = ' ';
 706                 }
 707             }
 708             if (c && p1 < &linebuf[LBSIZE - 1])
 709                 *p1++ = c;
 710         }
 711
 712         *p1++ = 0;
 713         cbp = p2;
 714         p1 = linebuf;
 715         p2 = n->n_expbuf;
 716
 717         if (n->n_circf) {
 718             if (advance (p1, p2))
 719                 return 1;
 720             continue;
 721         }
 722
 723         if (*p2 == CCHR) {
 724             c = p2[1];
 725             do {
 726                 if (*p1 == c || cc[(unsigned char)*p1] == c)
 727                     if (advance (p1, p2))
 728                         return 1;
 729             } while (*p1++);
 730             continue;
 731         }
 732
 733         do {
 734             if (advance (p1, p2))
 735                 return 1;
 736         } while (*p1++);
 737     }
 738 }
 739
 740
 741 static int
 742 advance (char *alp, char *aep)
 743 {
 744     register unsigned char *lp, *ep, *curlp;
 745
 746     lp = (unsigned char *)alp;
 747     ep = (unsigned char *)aep;
 748     for (;;)
 749         switch (*ep++) {
 750             case CCHR:
 751                 if (*ep++ == *lp++ || ep[-1] == cc[lp[-1]])
 752                     continue;
 753                 return 0;
 754
 755             case CDOT:
 756                 if (*lp++)
 757                     continue;
 758                 return 0;
 759
 760             case CDOL:
 761                 if (*lp == 0)
 762                     continue;
 763                 return 0;
 764
 765             case CEOF:
 766                 return 1;
 767
 768             case CCL:
 769                 if (cclass (ep, *lp++, 1)) {
 770                     ep += *ep + 1;
 771                     continue;
 772                 }
 773                 return 0;
 774
 775             case NCCL:
 776                 if (cclass (ep, *lp++, 0)) {
 777                     ep += *ep + 1;
 778                     continue;
 779                 }
 780                 return 0;
 781
 782             case CDOT | STAR:
 783                 curlp = lp;
 784                 while (*lp++)
 785                     continue;
 786                 goto star;
 787
 788             case CCHR | STAR:
 789                 curlp = lp;
 790                 while (*lp++ == *ep || cc[lp[-1]] == *ep)
 791                     continue;
 792                 ep++;
 793                 goto star;
 794
 795             case CCL | STAR:
 796             case NCCL | STAR:
 797                 curlp = lp;
 798                 while (cclass (ep, *lp++, ep[-1] == (CCL | STAR)))
 799                     continue;
 800                 ep += *ep + 1;
 801                 goto star;
 802
 803         star:
 804                 do {
 805                     lp--;
 806                     if (advance (lp, ep))
 807                         return (1);
 808                 } while (lp > curlp);
 809                 return 0;
 810
 811             default:
 812                 admonish (NULL, "advance() botch -- you lose big");
 813                 return 0;
 814         }
 815 }
 816
 817
 818 static int
 819 cclass (unsigned char *aset, int ac, int af)
 820 {
 821     register unsigned int    n;
 822     register unsigned char   c, *set;
 823
 824     set = aset;
 825     if ((c = ac) == 0)
 826         return (0);
 827
 828     n = *set++;
 829     while (n--)
 830         if (*set++ == c || set[-1] == cc[c])
 831             return (af);
 832
 833     return (!af);
 834 }
 835
 836
 837 static int
 838 tcompile (char *ap, struct tws *tb, int isafter)
 839 {
 840     register struct tws *tw;
 841
 842     if ((tw = tws_parse (ap, isafter)) == NULL)
 843         return 0;
 844
 845     twscopy (tb, tw);
 846     return 1;
 847 }
 848
 849
 850 static struct tws *
 851 tws_parse (char *ap, int isafter)
 852 {
 853     char buffer[BUFSIZ];
 854     register struct tws *tw, *ts;
 855
 856     if ((tw = tws_special (ap)) != NULL) {
 857         tw->tw_sec = tw->tw_min = isafter ? 59 : 0;
 858         tw->tw_hour = isafter ? 23 : 0;
 859         return tw;
 860     }
 861     if ((tw = dparsetime (ap)) != NULL)
 862         return tw;
 863
 864     if ((ts = dlocaltimenow ()) == NULL)
 865         return NULL;
 866
 867     snprintf (buffer, sizeof(buffer), "%s %s", ap, dtwszone (ts));
 868     if ((tw = dparsetime (buffer)) != NULL)
 869         return tw;
 870
 871     snprintf (buffer, sizeof(buffer), "%s %02d:%02d:%02d %s", ap,
 872             ts->tw_hour, ts->tw_min, ts->tw_sec, dtwszone (ts));
 873     if ((tw = dparsetime (buffer)) != NULL)
 874         return tw;
 875
 876     snprintf (buffer, sizeof(buffer), "%02d %s %04d %s",
 877             ts->tw_mday, tw_moty[ts->tw_mon], ts->tw_year, ap);
 878     if ((tw = dparsetime (buffer)) != NULL)
 879         return tw;
 880
 881     snprintf (buffer, sizeof(buffer), "%02d %s %04d %s %s",
 882             ts->tw_mday, tw_moty[ts->tw_mon], ts->tw_year,
 883             ap, dtwszone (ts));
 884     if ((tw = dparsetime (buffer)) != NULL)
 885         return tw;
 886
 887     return NULL;
 888 }
 889
 890
 891 static struct tws *
 892 tws_special (char *ap)
 893 {
 894     int i;
 895     time_t clock;
 896     register struct tws *tw;
 897
 898     time (&clock);
 899     if (!mh_strcasecmp (ap, "today"))
 900         return dlocaltime (&clock);
 901     if (!mh_strcasecmp (ap, "yesterday")) {
 902         clock -= (long) (60 * 60 * 24);
 903         return dlocaltime (&clock);
 904     }
 905     if (!mh_strcasecmp (ap, "tomorrow")) {
 906         clock += (long) (60 * 60 * 24);
 907         return dlocaltime (&clock);
 908     }
 909
 910     for (i = 0; tw_ldotw[i]; i++)
 911         if (!mh_strcasecmp (ap, tw_ldotw[i]))
 912             break;
 913     if (tw_ldotw[i]) {
 914         if ((tw = dlocaltime (&clock)) == NULL)
 915             return NULL;
 916         if ((i -= tw->tw_wday) > 0)
 917             i -= 7;
 918     }
 919     else
 920         if (*ap != '-')
 921             return NULL;
 922         else                    /* -ddd days ago */
 923             i = atoi (ap);      /* we should error check this */
 924
 925     clock += (long) ((60 * 60 * 24) * i);
 926     return dlocaltime (&clock);
 927 }
 928
 929
 930 static int
 931 TWSaction (params)
 932 plist
 933 {
 934     NMH_UNUSED (stop);
 935
 936     int state;
 937     register char *bp;
 938     char buf[BUFSIZ], name[NAMESZ];
 939     register struct tws *tw;
 940
 941     fseek (fp, start, SEEK_SET);
 942     for (state = FLD, bp = NULL;;) {
 943         switch (state = m_getfld (state, name, buf, sizeof buf, fp)) {
 944             case FLD:
 945             case FLDEOF:
 946             case FLDPLUS:
 947                 if (bp != NULL)
 948                     free (bp), bp = NULL;
 949                 bp = add (buf, NULL);
 950                 while (state == FLDPLUS) {
 951                     state = m_getfld (state, name, buf, sizeof buf, fp);
 952                     bp = add (buf, bp);
 953                 }
 954                 if (!mh_strcasecmp (name, n->n_datef))
 955                     break;
 956                 if (state != FLDEOF)
 957                     continue;
 958
 959             case BODY:
 960             case BODYEOF:
 961             case FILEEOF:
 962             case LENERR:
 963             case FMTERR:
 964                 if (state == LENERR || state == FMTERR)
 965                     advise (NULL, "format error in message %d", msgnum);
 966                 if (bp != NULL)
 967                     free (bp);
 968                 return 0;
 969
 970             default:
 971                 adios (NULL, "internal error -- you lose");
 972         }
 973         break;
 974     }
 975
 976     if ((tw = dparsetime (bp)) == NULL)
 977         advise (NULL, "unable to parse %s field in message %d, matching...",
 978                 n->n_datef, msgnum), state = 1;
 979     else
 980         state = n->n_after ? (twsort (tw, &n->n_tws) > 0)
 981             : (twsort (tw, &n->n_tws) < 0);
 982
 983     if (bp != NULL)
 984         free (bp);
 985     return state;
 986 }