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