usr.bin/calendar/parsedata.c

   1 /*-
   2  * Copyright (c) 1992-2009 Edwin Groothuis <edwin@FreeBSD.org>.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <ctype.h>
  32 #include <math.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <err.h>
  37
  38 #include "calendar.h"
  39
  40 static char *showflags(int flags);
  41 static int isonlydigits(char *s, int nostar);
  42 static const char *getmonthname(int i);
  43 static int checkmonth(char *s, size_t *len, size_t *offset, const char **month);
  44 static const char *getdayofweekname(int i);
  45 static int checkdayofweek(char *s, size_t *len, size_t *offset, const char **dow);
  46 static int indextooffset(char *s);
  47 static int parseoffset(char *s);
  48 static char *floattoday(int year, double f);
  49 static char *floattotime(double f);
  50
  51 /*
  52  * Expected styles:
  53  *
  54  * Date                 ::=     Month . ' ' . DayOfMonth |
  55  *                              Month . ' ' . DayOfWeek . ModifierIndex |
  56  *                              Month . '/' . DayOfMonth |
  57  *                              Month . '/' . DayOfWeek . ModifierIndex |
  58  *                              DayOfMonth . ' ' . Month |
  59  *                              DayOfMonth . '/' . Month |
  60  *                              DayOfWeek . ModifierIndex . ' ' .Month |
  61  *                              DayOfWeek . ModifierIndex . '/' .Month |
  62  *                              DayOfWeek . ModifierIndex |
  63  *                              SpecialDay . ModifierOffset
  64  *
  65  * Month                ::=     MonthName | MonthNumber | '*'
  66  * MonthNumber          ::=     '0' ... '9' | '00' ... '09' | '10' ... '12'
  67  * MonthName            ::=     MonthNameShort | MonthNameLong
  68  * MonthNameLong        ::=     'January' ... 'December'
  69  * MonthNameShort       ::=     'Jan' ... 'Dec' | 'Jan.' ... 'Dec.'
  70  *
  71  * DayOfWeek            ::=     DayOfWeekShort | DayOfWeekLong
  72  * DayOfWeekShort       ::=     'Mon' .. 'Sun'
  73  * DayOfWeekLong        ::=     'Monday' .. 'Sunday'
  74  * DayOfMonth           ::=     '0' ... '9' | '00' ... '09' | '10' ... '29' |
  75  *                              '30' ... '31' | '*'
  76  *
  77  * ModifierOffset       ::=     '' | '+' . ModifierNumber | '-' . ModifierNumber
  78  * ModifierNumber       ::=     '0' ... '9' | '00' ... '99' | '000' ... '299' |
  79  *                              '300' ... '359' | '360' ... '365'
  80  * ModifierIndex        ::=     'Second' | 'Third' | 'Fourth' | 'Fifth' |
  81  *                              'First' | 'Last'
  82  *
  83  * SpecialDay           ::=     'Easter' | 'Paskha' | 'ChineseNewYear'
  84  *
  85  */
  86 static int
  87 determinestyle(char *date, int *flags,
  88     char *month, int *imonth, char *dayofmonth, int *idayofmonth,
  89     char *dayofweek, int *idayofweek, char *modifieroffset,
  90     char *modifierindex, char *specialday, char *year, int *iyear)
  91 {
  92         char *p, *p1, *p2, *py;
  93         const char *dow, *pmonth;
  94         char pold;
  95         size_t len, offset;
  96
  97         *flags = F_NONE;
  98         *month = '\0';
  99         *imonth = 0;
 100         *year = '\0';
 101         *iyear = 0;
 102         *dayofmonth = '\0';
 103         *idayofmonth = 0;
 104         *dayofweek = '\0';
 105         *idayofweek = 0;
 106         *modifieroffset = '\0';
 107         *modifierindex = '\0';
 108         *specialday = '\0';
 109
 110 #define CHECKSPECIAL(s1, s2, lens2, type)                               \
 111         if (s2 != NULL && strncmp(s1, s2, lens2) == 0) {                \
 112                 *flags |= F_SPECIALDAY;                                 \
 113                 *flags |= type;                                         \
 114                 *flags |= F_VARIABLE;                                   \
 115                 if (strlen(s1) == lens2) {                              \
 116                         strcpy(specialday, s1);                         \
 117                         return (1);                                     \
 118                 }                                                       \
 119                 strncpy(specialday, s1, lens2);                         \
 120                 specialday[lens2] = '\0';                               \
 121                 strcpy(modifieroffset, s1 + lens2);                     \
 122                 *flags |= F_MODIFIEROFFSET;                             \
 123                 return (1);                                             \
 124         }
 125
 126         if ((p = strchr(date, ' ')) == NULL) {
 127                 if ((p = strchr(date, '/')) == NULL) {
 128                         CHECKSPECIAL(date, STRING_CNY, strlen(STRING_CNY),
 129                             F_CNY);
 130                         CHECKSPECIAL(date, ncny.name, ncny.len, F_CNY);
 131                         CHECKSPECIAL(date, STRING_NEWMOON,
 132                             strlen(STRING_NEWMOON), F_NEWMOON);
 133                         CHECKSPECIAL(date, nnewmoon.name, nnewmoon.len,
 134                             F_NEWMOON);
 135                         CHECKSPECIAL(date, STRING_FULLMOON,
 136                             strlen(STRING_FULLMOON), F_FULLMOON);
 137                         CHECKSPECIAL(date, nfullmoon.name, nfullmoon.len,
 138                             F_FULLMOON);
 139                         CHECKSPECIAL(date, STRING_PASKHA,
 140                             strlen(STRING_PASKHA), F_PASKHA);
 141                         CHECKSPECIAL(date, npaskha.name, npaskha.len, F_PASKHA);
 142                         CHECKSPECIAL(date, STRING_EASTER,
 143                             strlen(STRING_EASTER), F_EASTER);
 144                         CHECKSPECIAL(date, neaster.name, neaster.len, F_EASTER);
 145                         CHECKSPECIAL(date, STRING_MAREQUINOX,
 146                             strlen(STRING_MAREQUINOX), F_MAREQUINOX);
 147                         CHECKSPECIAL(date, nmarequinox.name, nmarequinox.len,
 148                             F_SEPEQUINOX);
 149                         CHECKSPECIAL(date, STRING_SEPEQUINOX,
 150                             strlen(STRING_SEPEQUINOX), F_SEPEQUINOX);
 151                         CHECKSPECIAL(date, nsepequinox.name, nsepequinox.len,
 152                             F_SEPEQUINOX);
 153                         CHECKSPECIAL(date, STRING_JUNSOLSTICE,
 154                             strlen(STRING_JUNSOLSTICE), F_JUNSOLSTICE);
 155                         CHECKSPECIAL(date, njunsolstice.name, njunsolstice.len,
 156                             F_JUNSOLSTICE);
 157                         CHECKSPECIAL(date, STRING_DECSOLSTICE,
 158                             strlen(STRING_DECSOLSTICE), F_DECSOLSTICE);
 159                         CHECKSPECIAL(date, ndecsolstice.name, ndecsolstice.len,
 160                             F_DECSOLSTICE);
 161                         if (checkdayofweek(date, &len, &offset, &dow) != 0) {
 162                                 *flags |= F_DAYOFWEEK;
 163                                 *flags |= F_VARIABLE;
 164                                 *idayofweek = offset;
 165                                 if (strlen(date) == len) {
 166                                         strcpy(dayofweek, date);
 167                                         return (1);
 168                                 }
 169                                 strncpy(dayofweek, date, len);
 170                                 dayofweek[len] = '\0';
 171                                 strcpy(modifierindex, date + len);
 172                                 *flags |= F_MODIFIERINDEX;
 173                                 return (1);
 174                         }
 175                         if (isonlydigits(date, 1)) {
 176                                 /* Assume month number only */
 177                                 *flags |= F_MONTH;
 178                                 *imonth = (int)strtol(date, (char **)NULL, 10);
 179                                 strcpy(month, getmonthname(*imonth));
 180                                 return(1);
 181                         }
 182                         return (0);
 183                 }
 184         }
 185
 186         /*
 187          * AFTER this, leave by goto-ing to "allfine" or "fail" to restore the
 188          * original data in `date'.
 189          */
 190         pold = *p;
 191         *p = 0;
 192         p1 = date;
 193         p2 = p + 1;
 194         /* Now p2 points to the next field and p1 to the first field */
 195
 196         if ((py = strchr(p2, '/')) != NULL) {
 197                 /* We have a year in the string. Now this is getting tricky */
 198                 strcpy(year, p1);
 199                 *iyear = (int)strtol(year, NULL, 10);
 200                 p1 = p2;
 201                 p2 = py + 1;
 202                 *py = 0;
 203                 *flags |= F_YEAR;
 204         }
 205
 206         /*
 207         printf("p1: %s\n", p1);
 208         printf("p2: %s\n", p2);
 209         printf("year: %s\n", year);
 210         */
 211
 212         /* Check if there is a month-string in the date */
 213         if ((checkmonth(p1, &len, &offset, &pmonth) != 0)
 214          || (checkmonth(p2, &len, &offset, &pmonth) != 0 && (p2 = p1))) {
 215                 /* p2 is the non-month part */
 216                 *flags |= F_MONTH;
 217                 *imonth = offset;
 218
 219                 strcpy(month, getmonthname(offset));
 220                 if (isonlydigits(p2, 1)) {
 221                         strcpy(dayofmonth, p2);
 222                         *idayofmonth = (int)strtol(p2, (char **)NULL, 10);
 223                         *flags |= F_DAYOFMONTH;
 224                         goto allfine;
 225                 }
 226                 if (strcmp(p2, "*") == 0) {
 227                         *flags |= F_ALLDAY;
 228                         goto allfine;
 229                 }
 230
 231                 if (checkdayofweek(p2, &len, &offset, &dow) != 0) {
 232                         *flags |= F_DAYOFWEEK;
 233                         *flags |= F_VARIABLE;
 234                         *idayofweek = offset;
 235                         strcpy(dayofweek, getdayofweekname(offset));
 236                         if (strlen(p2) == len)
 237                                 goto allfine;
 238                         strcpy(modifierindex, p2 + len);
 239                         *flags |= F_MODIFIERINDEX;
 240                         goto allfine;
 241                 }
 242
 243                 goto fail;
 244         }
 245
 246         /* Check if there is an every-day or every-month in the string */
 247         if ((strcmp(p1, "*") == 0 && isonlydigits(p2, 1))
 248          || (strcmp(p2, "*") == 0 && isonlydigits(p1, 1) && (p2 = p1))) {
 249                 int d;
 250
 251                 *flags |= F_ALLMONTH;
 252                 *flags |= F_DAYOFMONTH;
 253                 d = (int)strtol(p2, (char **)NULL, 10);
 254                 *idayofmonth = d;
 255                 sprintf(dayofmonth, "%d", d);
 256                 goto allfine;
 257         }
 258
 259         /* Month as a number, then a weekday */
 260         if (isonlydigits(p1, 1)
 261          && checkdayofweek(p2, &len, &offset, &dow) != 0) {
 262                 int d;
 263
 264                 *flags |= F_MONTH;
 265                 *flags |= F_DAYOFWEEK;
 266                 *flags |= F_VARIABLE;
 267
 268                 *idayofweek = offset;
 269                 d = (int)strtol(p1, (char **)NULL, 10);
 270                 *imonth = d;
 271                 strcpy(month, getmonthname(d));
 272
 273                 strcpy(dayofweek, getdayofweekname(offset));
 274                 if (strlen(p2) == len)
 275                         goto allfine;
 276                 strcpy(modifierindex, p2 + len);
 277                 *flags |= F_MODIFIERINDEX;
 278                 goto allfine;
 279         }
 280
 281         /* If both the month and date are specified as numbers */
 282         if (isonlydigits(p1, 1) && isonlydigits(p2, 0)) {
 283                 /* Now who wants to be this ambigious? :-( */
 284                 int m, d;
 285
 286                 if (strchr(p2, '*') != NULL)
 287                         *flags |= F_VARIABLE;
 288
 289                 m = (int)strtol(p1, (char **)NULL, 10);
 290                 d = (int)strtol(p2, (char **)NULL, 10);
 291
 292                 *flags |= F_MONTH;
 293                 *flags |= F_DAYOFMONTH;
 294
 295                 if (m > 12) {
 296                         *imonth = d;
 297                         *idayofmonth = m;
 298                         strcpy(month, getmonthname(d));
 299                         sprintf(dayofmonth, "%d", m);
 300                 } else {
 301                         *imonth = m;
 302                         *idayofmonth = d;
 303                         strcpy(month, getmonthname(m));
 304                         sprintf(dayofmonth, "%d", d);
 305                 }
 306                 goto allfine;
 307         }
 308
 309         /* FALLTHROUGH */
 310 fail:
 311         *p = pold;
 312         return (0);
 313 allfine:
 314         *p = pold;
 315         return (1);
 316
 317 }
 318
 319 static void
 320 remember(int *rememberindex, int *y, int *m, int *d, char **ed, int yy, int mm,
 321     int dd, char *extra)
 322 {
 323         static int warned = 0;
 324
 325         if (*rememberindex >= MAXCOUNT - 1) {
 326                 if (warned == 0)
 327                         warnx("Index > %d, ignored", MAXCOUNT);
 328                 warned++;
 329                 return;
 330         }
 331         y[*rememberindex] = yy;
 332         m[*rememberindex] = mm;
 333         d[*rememberindex] = dd;
 334         if (extra != NULL)
 335                 strcpy(ed[*rememberindex], extra);
 336         else
 337                 ed[*rememberindex][0] = '\0';
 338         *rememberindex += 1;
 339 }
 340
 341 static void
 342 debug_determinestyle(int dateonly, char *date, int flags, char *month,
 343     int imonth, char *dayofmonth, int idayofmonth, char *dayofweek,
 344     int idayofweek, char *modifieroffset, char *modifierindex, char *specialday,
 345     char *year, int iyear)
 346 {
 347
 348         if (dateonly != 0) {
 349                 printf("-------\ndate: |%s|\n", date);
 350                 if (dateonly == 1)
 351                         return;
 352         }
 353         printf("flags: %x - %s\n", flags, showflags(flags));
 354         if (modifieroffset[0] != '\0')
 355                 printf("modifieroffset: |%s|\n", modifieroffset);
 356         if (modifierindex[0] != '\0')
 357                 printf("modifierindex: |%s|\n", modifierindex);
 358         if (year[0] != '\0')
 359                 printf("year: |%s| (%d)\n", year, iyear);
 360         if (month[0] != '\0')
 361                 printf("month: |%s| (%d)\n", month, imonth);
 362         if (dayofmonth[0] != '\0')
 363                 printf("dayofmonth: |%s| (%d)\n", dayofmonth, idayofmonth);
 364         if (dayofweek[0] != '\0')
 365                 printf("dayofweek: |%s| (%d)\n", dayofweek, idayofweek);
 366         if (specialday[0] != '\0')
 367                 printf("specialday: |%s|\n", specialday);
 368 }
 369
 370 struct yearinfo {
 371         int year;
 372         int ieaster, ipaskha, firstcnyday;
 373         double ffullmoon[MAXMOONS], fnewmoon[MAXMOONS];
 374         double ffullmooncny[MAXMOONS], fnewmooncny[MAXMOONS];
 375         int ichinesemonths[MAXMOONS];
 376         double equinoxdays[2], solsticedays[2];
 377         int *mondays;
 378         struct yearinfo *next;
 379 };
 380 /*
 381  * Possible date formats include any combination of:
 382  *      3-charmonth                     (January, Jan, Jan)
 383  *      3-charweekday                   (Friday, Monday, mon.)
 384  *      numeric month or day            (1, 2, 04)
 385  *
 386  * Any character may separate them, or they may not be separated.  Any line,
 387  * following a line that is matched, that starts with "whitespace", is shown
 388  * along with the matched line.
 389  */
 390 int
 391 parsedaymonth(char *date, int *yearp, int *monthp, int *dayp, int *flags,
 392     char **edp)
 393 {
 394         char month[100], dayofmonth[100], dayofweek[100], modifieroffset[100];
 395         char syear[100];
 396         char modifierindex[100], specialday[100];
 397         int idayofweek = -1, imonth = -1, idayofmonth = -1, iyear = -1;
 398         int year, remindex;
 399         int d, m, dow, rm, rd, offset;
 400         char *ed;
 401         int retvalsign = 1;
 402
 403         static struct yearinfo *years, *yearinfo;
 404
 405         /*
 406          * CONVENTION
 407          *
 408          * Month:     1-12
 409          * Monthname: Jan .. Dec
 410          * Day:       1-31
 411          * Weekday:   Mon .. Sun
 412          *
 413          */
 414
 415         *flags = 0;
 416
 417         if (debug)
 418                 debug_determinestyle(1, date, *flags, month, imonth,
 419                     dayofmonth, idayofmonth, dayofweek, idayofweek,
 420                     modifieroffset, modifierindex, specialday, syear, iyear);
 421         if (determinestyle(date, flags, month, &imonth, dayofmonth,
 422             &idayofmonth, dayofweek, &idayofweek, modifieroffset,
 423             modifierindex, specialday, syear, &iyear) == 0) {
 424                 if (debug)
 425                         printf("Failed!\n");
 426                 return (0);
 427         }
 428
 429         if (debug)
 430                 debug_determinestyle(0, date, *flags, month, imonth,
 431                     dayofmonth, idayofmonth, dayofweek, idayofweek,
 432                     modifieroffset, modifierindex, specialday, syear, iyear);
 433
 434         remindex = 0;
 435         for (year = year1; year <= year2; year++) {
 436
 437                 int lflags = *flags;
 438                 /* If the year is specified, only do it if it is this year! */
 439                 if ((lflags & F_YEAR) != 0)
 440                         if (iyear != year)
 441                                 continue;
 442                 lflags &= ~F_YEAR;
 443
 444                 /* Get important dates for this year */
 445                 yearinfo = years;
 446                 while (yearinfo != NULL) {
 447                         if (yearinfo->year == year)
 448                                 break;
 449                         yearinfo = yearinfo -> next;
 450                 }
 451                 if (yearinfo == NULL) {
 452                         yearinfo = (struct yearinfo *)calloc(1,
 453                             sizeof(struct yearinfo));
 454                         if (yearinfo == NULL)
 455                                 errx(1, "Unable to allocate more years");
 456                         yearinfo->year = year;
 457                         yearinfo->next = years;
 458                         years = yearinfo;
 459
 460                         yearinfo->mondays = mondaytab[isleap(year)];
 461                         yearinfo->ieaster = easter(year);
 462                         yearinfo->ipaskha = paskha(year);
 463                         fpom(year, UTCOffset, yearinfo->ffullmoon,
 464                             yearinfo->fnewmoon);
 465                         fpom(year, UTCOFFSET_CNY, yearinfo->ffullmooncny,
 466                             yearinfo->fnewmooncny);
 467                         fequinoxsolstice(year, UTCOffset,
 468                             yearinfo->equinoxdays, yearinfo->solsticedays);
 469
 470                         /*
 471                          * CNY: Match day with sun longitude at 330` with new
 472                          * moon
 473                          */
 474                         yearinfo->firstcnyday = calculatesunlongitude30(year,
 475                             UTCOFFSET_CNY, yearinfo->ichinesemonths);
 476                         for (m = 0; yearinfo->fnewmooncny[m] >= 0; m++) {
 477                                 if (yearinfo->fnewmooncny[m] >
 478                                     yearinfo->firstcnyday) {
 479                                         yearinfo->firstcnyday =
 480                                             floor(yearinfo->fnewmooncny[m - 1]);
 481                                         break;
 482                                 }
 483                         }
 484                 }
 485
 486                 /* Same day every year */
 487                 if (lflags == (F_MONTH | F_DAYOFMONTH)) {
 488                         if (!remember_ymd(year, imonth, idayofmonth))
 489                                 continue;
 490                         remember(&remindex, yearp, monthp, dayp, edp,
 491                             year, imonth, idayofmonth, NULL);
 492                         continue;
 493                 }
 494
 495                 /* XXX Same day every year, but variable */
 496                 if (lflags == (F_MONTH | F_DAYOFMONTH | F_VARIABLE)) {
 497                         if (!remember_ymd(year, imonth, idayofmonth))
 498                                 continue;
 499                         remember(&remindex, yearp, monthp, dayp, edp,
 500                             year, imonth, idayofmonth, NULL);
 501                         continue;
 502                 }
 503
 504                 /* Same day every month */
 505                 if (lflags == (F_ALLMONTH | F_DAYOFMONTH)) {
 506                         for (m = 1; m <= 12; m++) {
 507                                 if (!remember_ymd(year, m, idayofmonth))
 508                                         continue;
 509                                 remember(&remindex, yearp, monthp, dayp, edp,
 510                                     year, m, idayofmonth, NULL);
 511                         }
 512                         continue;
 513                 }
 514
 515                 /* Every day of a month */
 516                 if (lflags == (F_ALLDAY | F_MONTH)) {
 517                         for (d = 1; d <= yearinfo->mondays[imonth]; d++) {
 518                                 if (!remember_ymd(year, imonth, d))
 519                                         continue;
 520                                 remember(&remindex, yearp, monthp, dayp, edp,
 521                                     year, imonth, d, NULL);
 522                         }
 523                         continue;
 524                 }
 525
 526                 /* One day of every month */
 527                 if (lflags == (F_ALLMONTH | F_DAYOFWEEK)) {
 528                         for (m = 1; m <= 12; m++) {
 529                                 if (!remember_ymd(year, m, idayofmonth))
 530                                         continue;
 531                                 remember(&remindex, yearp, monthp, dayp, edp,
 532                                     year, m, idayofmonth, NULL);
 533                         }
 534                         continue;
 535                 }
 536
 537                 /* Every dayofweek of the year */
 538                 if (lflags == (F_DAYOFWEEK | F_VARIABLE)) {
 539                         dow = first_dayofweek_of_year(year);
 540                         d = (idayofweek - dow + 8) % 7;
 541                         while (d <= 366) {
 542                                 if (remember_yd(year, d, &rm, &rd))
 543                                         remember(&remindex,
 544                                             yearp, monthp, dayp, edp,
 545                                             year, rm, rd, NULL);
 546                                 d += 7;
 547                         }
 548                         continue;
 549                 }
 550
 551                 /* Every so-manied dayofweek of every month of the year */
 552                 if (lflags == (F_DAYOFWEEK | F_MODIFIERINDEX | F_VARIABLE)) {
 553                         offset = indextooffset(modifierindex);
 554
 555                         for (m = 0; m < 12; m++) {
 556                                 dow = first_dayofweek_of_month(year, m);
 557                                 d = (idayofweek - dow + 8) % 7;
 558                                 d += (offset - 1) * 7;
 559                                 if (remember_ymd(year, m, d)) {
 560                                         remember(&remindex,
 561                                             yearp, monthp, dayp, edp,
 562                                             year, m, d, NULL);
 563                                         continue;
 564                                 }
 565                         }
 566                         continue;
 567                 }
 568
 569                 /* A certain dayofweek of a month */
 570                 if (lflags ==
 571                     (F_MONTH | F_DAYOFWEEK | F_MODIFIERINDEX | F_VARIABLE)) {
 572                         offset = indextooffset(modifierindex);
 573                         dow = first_dayofweek_of_month(year, imonth);
 574                         d = (idayofweek - dow + 8) % 7;
 575
 576                         if (offset > 0) {
 577                                 while (d <= yearinfo->mondays[imonth]) {
 578                                         if (--offset == 0
 579                                          && remember_ymd(year, imonth, d)) {
 580                                                 remember(&remindex,
 581                                                     yearp, monthp, dayp, edp,
 582                                                     year, imonth, d, NULL);
 583                                                 continue;
 584                                         }
 585                                         d += 7;
 586                                 }
 587                                 continue;
 588                         }
 589                         if (offset < 0) {
 590                                 while (d <= yearinfo->mondays[imonth])
 591                                         d += 7;
 592                                 while (offset != 0) {
 593                                         offset++;
 594                                         d -= 7;
 595                                 }
 596                                 if (remember_ymd(year, imonth, d))
 597                                         remember(&remindex,
 598                                             yearp, monthp, dayp, edp,
 599                                             year, imonth, d, NULL);
 600                                 continue;
 601                         }
 602                         continue;
 603                 }
 604
 605                 /* Every dayofweek of the month */
 606                 if (lflags == (F_DAYOFWEEK | F_MONTH | F_VARIABLE)) {
 607                         dow = first_dayofweek_of_month(year, imonth);
 608                         d = (idayofweek - dow + 8) % 7;
 609                         while (d <= yearinfo->mondays[imonth]) {
 610                                 if (remember_ymd(year, imonth, d))
 611                                         remember(&remindex,
 612                                             yearp, monthp, dayp, edp,
 613                                             year, imonth, d, NULL);
 614                                 d += 7;
 615                         }
 616                         continue;
 617                 }
 618
 619                 /* Easter */
 620                 if ((lflags & ~F_MODIFIEROFFSET) ==
 621                     (F_SPECIALDAY | F_VARIABLE | F_EASTER)) {
 622                         offset = 0;
 623                         if ((lflags & F_MODIFIEROFFSET) != 0)
 624                                 offset = parseoffset(modifieroffset);
 625                         if (remember_yd(year, yearinfo->ieaster + offset,
 626                             &rm, &rd))
 627                                 remember(&remindex, yearp, monthp, dayp, edp,
 628                                     year, rm, rd, NULL);
 629                         continue;
 630                 }
 631
 632                 /* Paskha */
 633                 if ((lflags & ~F_MODIFIEROFFSET) ==
 634                     (F_SPECIALDAY | F_VARIABLE | F_PASKHA)) {
 635                         offset = 0;
 636                         if ((lflags & F_MODIFIEROFFSET) != 0)
 637                                 offset = parseoffset(modifieroffset);
 638                         if (remember_yd(year, yearinfo->ipaskha + offset,
 639                             &rm, &rd))
 640                                 remember(&remindex, yearp, monthp, dayp, edp,
 641                                     year, rm, rd, NULL);
 642                         continue;
 643                 }
 644
 645                 /* Chinese New Year */
 646                 if ((lflags & ~F_MODIFIEROFFSET) ==
 647                     (F_SPECIALDAY | F_VARIABLE | F_CNY)) {
 648                         offset = 0;
 649                         if ((lflags & F_MODIFIEROFFSET) != 0)
 650                                 offset = parseoffset(modifieroffset);
 651                         if (remember_yd(year, yearinfo->firstcnyday + offset,
 652                             &rm, &rd))
 653                                 remember(&remindex, yearp, monthp, dayp, edp,
 654                                     year, rm, rd, NULL);
 655                         continue;
 656                 }
 657
 658                 /* FullMoon */
 659                 if ((lflags & ~F_MODIFIEROFFSET) ==
 660                     (F_SPECIALDAY | F_VARIABLE | F_FULLMOON)) {
 661                         int i;
 662
 663                         offset = 0;
 664                         if ((lflags & F_MODIFIEROFFSET) != 0)
 665                                 offset = parseoffset(modifieroffset);
 666                         for (i = 0; yearinfo->ffullmoon[i] > 0; i++) {
 667                                 if (remember_yd(year,
 668                                     floor(yearinfo->ffullmoon[i]) + offset,
 669                                         &rm, &rd)) {
 670                                         ed = floattotime(
 671                                             yearinfo->ffullmoon[i]);
 672                                         remember(&remindex,
 673                                             yearp, monthp, dayp, edp,
 674                                             year, rm, rd, ed);
 675                                 }
 676                         }
 677                         continue;
 678                 }
 679
 680                 /* NewMoon */
 681                 if ((lflags & ~F_MODIFIEROFFSET) ==
 682                     (F_SPECIALDAY | F_VARIABLE | F_NEWMOON)) {
 683                         int i;
 684
 685                         offset = 0;
 686                         if ((lflags & F_MODIFIEROFFSET) != 0)
 687                                 offset = parseoffset(modifieroffset);
 688                         for (i = 0; yearinfo->ffullmoon[i] > 0; i++) {
 689                                 if (remember_yd(year,
 690                                     floor(yearinfo->fnewmoon[i]) + offset,
 691                                     &rm, &rd)) {
 692                                         ed = floattotime(yearinfo->fnewmoon[i]);
 693                                         remember(&remindex,
 694                                             yearp, monthp, dayp, edp,
 695                                             year, rm, rd, ed);
 696                                 }
 697                         }
 698                         continue;
 699                 }
 700
 701                 /* (Mar|Sep)Equinox */
 702                 if ((lflags & ~F_MODIFIEROFFSET) ==
 703                     (F_SPECIALDAY | F_VARIABLE | F_MAREQUINOX)) {
 704                         offset = 0;
 705                         if ((lflags & F_MODIFIEROFFSET) != 0)
 706                                 offset = parseoffset(modifieroffset);
 707                         if (remember_yd(year, yearinfo->equinoxdays[0] + offset,
 708                             &rm, &rd)) {
 709                                 ed = floattotime(yearinfo->equinoxdays[0]);
 710                                 remember(&remindex, yearp, monthp, dayp, edp,
 711                                     year, rm, rd, ed);
 712                         }
 713                         continue;
 714                 }
 715                 if ((lflags & ~F_MODIFIEROFFSET) ==
 716                     (F_SPECIALDAY | F_VARIABLE | F_SEPEQUINOX)) {
 717                         offset = 0;
 718                         if ((lflags & F_MODIFIEROFFSET) != 0)
 719                                 offset = parseoffset(modifieroffset);
 720                         if (remember_yd(year, yearinfo->equinoxdays[1] + offset,
 721                             &rm, &rd)) {
 722                                 ed = floattotime(yearinfo->equinoxdays[1]);
 723                                 remember(&remindex, yearp, monthp, dayp, edp,
 724                                     year, rm, rd, ed);
 725                         }
 726                         continue;
 727                 }
 728
 729                 /* (Jun|Dec)Solstice */
 730                 if ((lflags & ~F_MODIFIEROFFSET) ==
 731                     (F_SPECIALDAY | F_VARIABLE | F_JUNSOLSTICE)) {
 732                         offset = 0;
 733                         if ((lflags & F_MODIFIEROFFSET) != 0)
 734                                 offset = parseoffset(modifieroffset);
 735                         if (remember_yd(year,
 736                             yearinfo->solsticedays[0] + offset, &rm, &rd)) {
 737                                 ed = floattotime(yearinfo->solsticedays[0]);
 738                                 remember(&remindex, yearp, monthp, dayp, edp,
 739                                     year, rm, rd, ed);
 740                         }
 741                         continue;
 742                 }
 743                 if ((lflags & ~F_MODIFIEROFFSET) ==
 744                     (F_SPECIALDAY | F_VARIABLE | F_DECSOLSTICE)) {
 745                         offset = 0;
 746                         if ((lflags & F_MODIFIEROFFSET) != 0)
 747                                 offset = parseoffset(modifieroffset);
 748                         if (remember_yd(year,
 749                             yearinfo->solsticedays[1] + offset, &rm, &rd)) {
 750                                 ed = floattotime(yearinfo->solsticedays[1]);
 751                                 remember(&remindex, yearp, monthp, dayp, edp,
 752                                     year, rm, rd, ed);
 753                         }
 754                         continue;
 755                 }
 756
 757                 printf("Unprocessed:\n");
 758                 debug_determinestyle(2, date, lflags, month, imonth,
 759                     dayofmonth, idayofmonth, dayofweek, idayofweek,
 760                     modifieroffset, modifierindex, specialday, syear, iyear);
 761                 retvalsign = -1;
 762         }
 763
 764         if (retvalsign == -1)
 765                 return (-remindex - 1);
 766         else
 767                 return (remindex);
 768 }
 769
 770 static char *
 771 showflags(int flags)
 772 {
 773         static char s[1000];
 774         s[0] = '\0';
 775
 776         if ((flags & F_YEAR) != 0)
 777                 strcat(s, "year ");
 778         if ((flags & F_MONTH) != 0)
 779                 strcat(s, "month ");
 780         if ((flags & F_DAYOFWEEK) != 0)
 781                 strcat(s, "dayofweek ");
 782         if ((flags & F_DAYOFMONTH) != 0)
 783                 strcat(s, "dayofmonth ");
 784         if ((flags & F_MODIFIERINDEX) != 0)
 785                 strcat(s, "modifierindex ");
 786         if ((flags & F_MODIFIEROFFSET) != 0)
 787                 strcat(s, "modifieroffset ");
 788         if ((flags & F_SPECIALDAY) != 0)
 789                 strcat(s, "specialday ");
 790         if ((flags & F_ALLMONTH) != 0)
 791                 strcat(s, "allmonth ");
 792         if ((flags & F_ALLDAY) != 0)
 793                 strcat(s, "allday ");
 794         if ((flags & F_VARIABLE) != 0)
 795                 strcat(s, "variable ");
 796         if ((flags & F_CNY) != 0)
 797                 strcat(s, "chinesenewyear ");
 798         if ((flags & F_PASKHA) != 0)
 799                 strcat(s, "paskha ");
 800         if ((flags & F_EASTER) != 0)
 801                 strcat(s, "easter ");
 802         if ((flags & F_FULLMOON) != 0)
 803                 strcat(s, "fullmoon ");
 804         if ((flags & F_NEWMOON) != 0)
 805                 strcat(s, "newmoon ");
 806         if ((flags & F_MAREQUINOX) != 0)
 807                 strcat(s, "marequinox ");
 808         if ((flags & F_SEPEQUINOX) != 0)
 809                 strcat(s, "sepequinox ");
 810         if ((flags & F_JUNSOLSTICE) != 0)
 811                 strcat(s, "junsolstice ");
 812         if ((flags & F_DECSOLSTICE) != 0)
 813                 strcat(s, "decsolstice ");
 814
 815         return s;
 816 }
 817
 818 static const char *
 819 getmonthname(int i)
 820 {
 821         if (i <= 0 || i > 12)
 822                 return ("");
 823         if (nmonths[i - 1].len != 0 && nmonths[i - 1].name != NULL)
 824                 return (nmonths[i - 1].name);
 825         return (months[i - 1]);
 826 }
 827
 828 static int
 829 checkmonth(char *s, size_t *len, size_t *offset, const char **month)
 830 {
 831         struct fixs *n;
 832         int i;
 833
 834         for (i = 0; fnmonths[i].name != NULL; i++) {
 835                 n = fnmonths + i;
 836                 if (strncasecmp(s, n->name, n->len) == 0) {
 837                         *len = n->len;
 838                         *month = n->name;
 839                         *offset = i + 1;
 840                         return (1);
 841                 }
 842         }
 843         for (i = 0; nmonths[i].name != NULL; i++) {
 844                 n = nmonths + i;
 845                 if (strncasecmp(s, n->name, n->len) == 0) {
 846                         *len = n->len;
 847                         *month = n->name;
 848                         *offset = i + 1;
 849                         return (1);
 850                 }
 851         }
 852         for (i = 0; fmonths[i] != NULL; i++) {
 853                 *len = strlen(fmonths[i]);
 854                 if (strncasecmp(s, fmonths[i], *len) == 0) {
 855                         *month = fmonths[i];
 856                         *offset = i + 1;
 857                         return (1);
 858                 }
 859         }
 860         for (i = 0; months[i] != NULL; i++) {
 861                 if (strncasecmp(s, months[i], 3) == 0) {
 862                         *len = 3;
 863                         *month = months[i];
 864                         *offset = i + 1;
 865                         return (1);
 866                 }
 867         }
 868         return (0);
 869 }
 870
 871 static const char *
 872 getdayofweekname(int i)
 873 {
 874         if (ndays[i].len != 0 && ndays[i].name != NULL)
 875                 return (ndays[i].name);
 876         return (days[i]);
 877 }
 878
 879 static int
 880 checkdayofweek(char *s, size_t *len, size_t *offset, const char **dow)
 881 {
 882         struct fixs *n;
 883         int i;
 884
 885         for (i = 0; fndays[i].name != NULL; i++) {
 886                 n = fndays + i;
 887                 if (strncasecmp(s, n->name, n->len) == 0) {
 888                         *len = n->len;
 889                         *dow = n->name;
 890                         *offset = i;
 891                         return (1);
 892                 }
 893         }
 894         for (i = 0; ndays[i].name != NULL; i++) {
 895                 n = ndays + i;
 896                 if (strncasecmp(s, n->name, n->len) == 0) {
 897                         *len = n->len;
 898                         *dow = n->name;
 899                         *offset = i;
 900                         return (1);
 901                 }
 902         }
 903         for (i = 0; fdays[i] != NULL; i++) {
 904                 *len = strlen(fdays[i]);
 905                 if (strncasecmp(s, fdays[i], *len) == 0) {
 906                         *dow = fdays[i];
 907                         *offset = i;
 908                         return (1);
 909                 }
 910         }
 911         for (i = 0; days[i] != NULL; i++) {
 912                 if (strncasecmp(s, days[i], 3) == 0) {
 913                         *len = 3;
 914                         *dow = days[i];
 915                         *offset = i;
 916                         return (1);
 917                 }
 918         }
 919         return (0);
 920 }
 921
 922 static int
 923 isonlydigits(char *s, int nostar)
 924 {
 925         int i;
 926         for (i = 0; s[i] != '\0'; i++) {
 927                 if (nostar == 0 && s[i] == '*' && s[i + 1] == '\0')
 928                         return 1;
 929                 if (!isdigit((unsigned char)s[i]))
 930                         return (0);
 931         }
 932         return (1);
 933 }
 934
 935 static int
 936 indextooffset(char *s)
 937 {
 938         int i;
 939         struct fixs *n;
 940
 941         if (s[0] == '+' || s[0] == '-') {
 942                 char ss[9];
 943                 for (i = -100; i < 100; i++) {
 944                         sprintf(ss, "%s%d", (i > 0) ? "+" : "", i);
 945                         if (strcmp(ss, s) == 0)
 946                                 return (i);
 947                 }
 948                 return (0);
 949         }
 950
 951         for (i = 0; i < 6; i++) {
 952                 if (strcasecmp(s, sequences[i]) == 0) {
 953                         if (i == 5)
 954                                 return (-1);
 955                         return (i + 1);
 956                 }
 957         }
 958         for (i = 0; i < 6; i++) {
 959                 n = nsequences + i;
 960                 if (n->len == 0)
 961                         continue;
 962                 if (strncasecmp(s, n->name, n->len) == 0) {
 963                         if (i == 5)
 964                                 return (-1);
 965                         return (i + 1);
 966                 }
 967         }
 968         return (0);
 969 }
 970
 971 static int
 972 parseoffset(char *s)
 973 {
 974
 975         return strtol(s, NULL, 10);
 976 }
 977
 978 static char *
 979 floattotime(double f)
 980 {
 981         static char buf[100];
 982         int hh, mm, ss, i;
 983
 984         f -= floor(f);
 985         i = f * SECSPERDAY;
 986
 987         hh = i / SECSPERHOUR;
 988         i %= SECSPERHOUR;
 989         mm = i / SECSPERMINUTE;
 990         i %= SECSPERMINUTE;
 991         ss = i;
 992
 993         sprintf(buf, "%02d:%02d:%02d", hh, mm, ss);
 994         return (buf);
 995 }
 996
 997 static char *
 998 floattoday(int year, double f)
 999 {
1000         static char buf[100];
1001         int i, m, d, hh, mm, ss;
1002         int *cumdays = cumdaytab[isleap(year)];
1003
1004         for (i = 0; 1 + cumdays[i] < f; i++)
1005                 ;
1006         m = --i;
1007         d = floor(f - 1 - cumdays[i]);
1008         f -= floor(f);
1009         i = f * SECSPERDAY;
1010
1011         hh = i / SECSPERHOUR;
1012         i %= SECSPERHOUR;
1013         mm = i / SECSPERMINUTE;
1014         i %= SECSPERMINUTE;
1015         ss = i;
1016
1017         sprintf(buf, "%02d-%02d %02d:%02d:%02d", m, d, hh, mm, ss);
1018         return (buf);
1019 }
1020
1021 void
1022 dodebug(char *what)
1023 {
1024         int year;
1025
1026         printf("UTCOffset: %g\n", UTCOffset);
1027         printf("eastlongitude: %d\n", EastLongitude);
1028
1029         if (strcmp(what, "moon") == 0) {
1030                 double ffullmoon[MAXMOONS], fnewmoon[MAXMOONS];
1031                 int i;
1032
1033                 for (year = year1; year <= year2; year++) {
1034                         fpom(year, UTCOffset, ffullmoon, fnewmoon);
1035                         printf("Full moon %d:\t", year);
1036                         for (i = 0; ffullmoon[i] >= 0; i++) {
1037                                 printf("%g (%s) ", ffullmoon[i],
1038                                     floattoday(year, ffullmoon[i]));
1039                         }
1040                         printf("\nNew moon %d:\t", year);
1041                         for (i = 0; fnewmoon[i] >= 0; i++) {
1042                                 printf("%g (%s) ", fnewmoon[i],
1043                                     floattoday(year, fnewmoon[i]));
1044                         }
1045                         printf("\n");
1046
1047                 }
1048
1049                 return;
1050         }
1051
1052         if (strcmp(what, "sun") == 0) {
1053                 double equinoxdays[2], solsticedays[2];
1054                 for (year = year1; year <= year2; year++) {
1055                         printf("Sun in %d:\n", year);
1056                         fequinoxsolstice(year, UTCOffset, equinoxdays,
1057                             solsticedays);
1058                         printf("e[0] - %g (%s)\n",
1059                             equinoxdays[0],
1060                             floattoday(year, equinoxdays[0]));
1061                         printf("e[1] - %g (%s)\n",
1062                             equinoxdays[1],
1063                             floattoday(year, equinoxdays[1]));
1064                         printf("s[0] - %g (%s)\n",
1065                             solsticedays[0],
1066                             floattoday(year, solsticedays[0]));
1067                         printf("s[1] - %g (%s)\n",
1068                             solsticedays[1],
1069                             floattoday(year, solsticedays[1]));
1070                 }
1071                 return;
1072         }
1073 }