/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 1992-2009 Edwin Groothuis <edwin@FreeBSD.org>.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <err.h>

#include "calendar.h"

#define SLEN    100     /* maximum length of date spec. part strings */

static char *showflags(int flags);
static int isonlydigits(char *s, int nostar);
static const char *getmonthname(int i);
static int checkmonth(char *s, size_t *len, size_t *offset, const char **month);
static const char *getdayofweekname(int i);
static int checkdayofweek(char *s, size_t *len, size_t *offset, const char **dow);
static int indextooffset(char *s);
static int parseoffset(char *s);
static char *floattoday(int year, double f);
static char *floattotime(double f);
static int wdayom (int day, int offset, int month, int year);

/*
 * Expected styles:
 *
 * Date                 ::=     Month . ' ' . DayOfMonth |
 *                              Month . ' ' . DayOfWeek . ModifierIndex |
 *                              Month . '/' . DayOfMonth |
 *                              Month . '/' . DayOfWeek . ModifierIndex |
 *                              DayOfMonth . ' ' . Month |
 *                              DayOfMonth . '/' . Month |
 *                              DayOfWeek . ModifierIndex . ' ' .Month |
 *                              DayOfWeek . ModifierIndex . '/' .Month |
 *                              DayOfWeek . ModifierIndex |
 *                              SpecialDay . ModifierOffset
 *
 * Month                ::=     MonthName | MonthNumber | '*'
 * MonthNumber          ::=     '0' ... '9' | '00' ... '09' | '10' ... '12'
 * MonthName            ::=     MonthNameShort | MonthNameLong
 * MonthNameLong        ::=     'January' ... 'December'
 * MonthNameShort       ::=     'Jan' ... 'Dec' | 'Jan.' ... 'Dec.'
 *
 * DayOfWeek            ::=     DayOfWeekShort | DayOfWeekLong
 * DayOfWeekShort       ::=     'Mon' .. 'Sun'
 * DayOfWeekLong        ::=     'Monday' .. 'Sunday'
 * DayOfMonth           ::=     '0' ... '9' | '00' ... '09' | '10' ... '29' |
 *                              '30' ... '31' | '*'
 *
 * ModifierOffset       ::=     '' | '+' . ModifierNumber | '-' . ModifierNumber
 * ModifierNumber       ::=     '0' ... '9' | '00' ... '99' | '000' ... '299' |
 *                              '300' ... '359' | '360' ... '365'
 * ModifierIndex        ::=     'Second' | 'Third' | 'Fourth' | 'Fifth' |
 *                              'First' | 'Last'
 *
 * SpecialDay           ::=     'Easter' | 'Paskha' | 'ChineseNewYear'
 *
 */
static int
determinestyle(char *date, int *flags,
    char *month, int *imonth, char *dayofmonth, int *idayofmonth,
    char *dayofweek, int *idayofweek, char *modifieroffset,
    char *modifierindex, char *specialday, char *year, int *iyear)
{
        char *p, *p1, *p2, *py;
        const char *dow, *pmonth;
        char pold;
        size_t len, offset;

        *flags = F_NONE;
        *month = '\0';
        *imonth = 0;
        *year = '\0';
        *iyear = 0;
        *dayofmonth = '\0';
        *idayofmonth = 0;
        *dayofweek = '\0';
        *idayofweek = 0;
        *modifieroffset = '\0';
        *modifierindex = '\0';
        *specialday = '\0';

#define CHECKSPECIAL(s1, s2, lens2, type)                               \
        if (s2 != NULL && strncmp(s1, s2, lens2) == 0) {                \
                *flags |= F_SPECIALDAY;                                 \
                *flags |= type;                                         \
                *flags |= F_VARIABLE;                                   \
                if (strlen(s1) == lens2) {                              \
                        strlcpy(specialday, s1, SLEN);                  \
                        return (1);                                     \
                }                                                       \
                strncpy(specialday, s1, lens2);                         \
                specialday[lens2] = '\0';                               \
                strlcpy(modifieroffset, s1 + lens2, SLEN);              \
                *flags |= F_MODIFIEROFFSET;                             \
                return (1);                                             \
        }

        if ((p = strchr(date, ' ')) == NULL) {
                if ((p = strchr(date, '/')) == NULL) {
                        CHECKSPECIAL(date, STRING_CNY, strlen(STRING_CNY),
                            F_CNY);
                        CHECKSPECIAL(date, ncny.name, ncny.len, F_CNY);
                        CHECKSPECIAL(date, STRING_NEWMOON,
                            strlen(STRING_NEWMOON), F_NEWMOON);
                        CHECKSPECIAL(date, nnewmoon.name, nnewmoon.len,
                            F_NEWMOON);
                        CHECKSPECIAL(date, STRING_FULLMOON,
                            strlen(STRING_FULLMOON), F_FULLMOON);
                        CHECKSPECIAL(date, nfullmoon.name, nfullmoon.len,
                            F_FULLMOON);
                        CHECKSPECIAL(date, STRING_PASKHA,
                            strlen(STRING_PASKHA), F_PASKHA);
                        CHECKSPECIAL(date, npaskha.name, npaskha.len, F_PASKHA);
                        CHECKSPECIAL(date, STRING_EASTER,
                            strlen(STRING_EASTER), F_EASTER);
                        CHECKSPECIAL(date, neaster.name, neaster.len, F_EASTER);
                        CHECKSPECIAL(date, STRING_MAREQUINOX,
                            strlen(STRING_MAREQUINOX), F_MAREQUINOX);
                        CHECKSPECIAL(date, nmarequinox.name, nmarequinox.len,
                            F_SEPEQUINOX);
                        CHECKSPECIAL(date, STRING_SEPEQUINOX,
                            strlen(STRING_SEPEQUINOX), F_SEPEQUINOX);
                        CHECKSPECIAL(date, nsepequinox.name, nsepequinox.len,
                            F_SEPEQUINOX);
                        CHECKSPECIAL(date, STRING_JUNSOLSTICE,
                            strlen(STRING_JUNSOLSTICE), F_JUNSOLSTICE);
                        CHECKSPECIAL(date, njunsolstice.name, njunsolstice.len,
                            F_JUNSOLSTICE);
                        CHECKSPECIAL(date, STRING_DECSOLSTICE,
                            strlen(STRING_DECSOLSTICE), F_DECSOLSTICE);
                        CHECKSPECIAL(date, ndecsolstice.name, ndecsolstice.len,
                            F_DECSOLSTICE);
                        if (checkdayofweek(date, &len, &offset, &dow) != 0) {
                                *flags |= F_DAYOFWEEK;
                                *flags |= F_VARIABLE;
                                *idayofweek = offset;
                                if (strlen(date) == len) {
                                        strlcpy(dayofweek, date, SLEN);
                                        return (1);
                                }
                                strncpy(dayofweek, date, len);
                                dayofweek[len] = '\0';
                                strlcpy(modifierindex, date + len, SLEN);
                                *flags |= F_MODIFIERINDEX;
                                return (1);
                        }
                        if (isonlydigits(date, 1)) {
                                /* Assume month number only */
                                *flags |= F_MONTH;
                                *imonth = (int)strtol(date, (char **)NULL, 10);
                                strlcpy(month, getmonthname(*imonth), SLEN);
                                return(1);
                        }
                        return (0);
                }
        }

        /*
         * After this, leave by goto-ing to "allfine" or "fail" to restore the
         * original data in `date'.
         */
        pold = *p;
        *p = 0;
        p1 = date;
        p2 = p + 1;
        /* Now p2 points to the next field and p1 to the first field */

        if ((py = strchr(p2, '/')) != NULL) {
                /* We have a year in the string. Now this is getting tricky */
                strlcpy(year, p1, SLEN);
                *iyear = (int)strtol(year, NULL, 10);
                p1 = p2;
                p2 = py + 1;
                *py = 0;
                *flags |= F_YEAR;
        }

        /* Check if there is a month-string in the date */
        if ((checkmonth(p1, &len, &offset, &pmonth) != 0)
            || (checkmonth(p2, &len, &offset, &pmonth) != 0 && (p2 = p1))) {
                /* p2 is the non-month part */
                *flags |= F_MONTH;
                *imonth = offset;

                strlcpy(month, getmonthname(offset), SLEN);
                if (isonlydigits(p2, 1)) {
                        strlcpy(dayofmonth, p2, SLEN);
                        *idayofmonth = (int)strtol(p2, (char **)NULL, 10);
                        *flags |= F_DAYOFMONTH;
                        goto allfine;
                }
                if (strcmp(p2, "*") == 0) {
                        *flags |= F_ALLDAY;
                        goto allfine;
                }

                if (checkdayofweek(p2, &len, &offset, &dow) != 0) {
                        *flags |= F_DAYOFWEEK;
                        *flags |= F_VARIABLE;
                        *idayofweek = offset;
                        strlcpy(dayofweek, getdayofweekname(offset), SLEN);
                        if (strlen(p2) == len)
                                goto allfine;
                        strlcpy(modifierindex, p2 + len, SLEN);
                        *flags |= F_MODIFIERINDEX;
                        goto allfine;
                }
                goto fail;
        }

        /* Check if there is an every-day or every-month in the string */
        if ((strcmp(p1, "*") == 0 && isonlydigits(p2, 1))
            || (strcmp(p2, "*") == 0 && isonlydigits(p1, 1) && (p2 = p1))) {
                int d;

                *flags |= F_ALLMONTH;
                *flags |= F_DAYOFMONTH;
                d = (int)strtol(p2, (char **)NULL, 10);
                *idayofmonth = d;
                snprintf(dayofmonth, SLEN, "%d", d);
                goto allfine;
        }

        /* Month as a number, then a weekday */
        if (isonlydigits(p1, 1)
            && checkdayofweek(p2, &len, &offset, &dow) != 0) {
                int d;

                *flags |= F_MONTH;
                *flags |= F_DAYOFWEEK;
                *flags |= F_VARIABLE;

                *idayofweek = offset;
                d = (int)strtol(p1, (char **)NULL, 10);
                *imonth = d;
                strlcpy(month, getmonthname(d), SLEN);

                strlcpy(dayofweek, getdayofweekname(offset), SLEN);
                if (strlen(p2) == len)
                        goto allfine;
                strlcpy(modifierindex, p2 + len, SLEN);
                *flags |= F_MODIFIERINDEX;
                goto allfine;
        }

        /* If both the month and date are specified as numbers */
        if (isonlydigits(p1, 1) && isonlydigits(p2, 0)) {
                /* Now who wants to be this ambiguous? :-( */
                int m, d;

                if (strchr(p2, '*') != NULL)
                        *flags |= F_VARIABLE;

                m = (int)strtol(p1, (char **)NULL, 10);
                d = (int)strtol(p2, (char **)NULL, 10);

                *flags |= F_MONTH;
                *flags |= F_DAYOFMONTH;

                if (m > 12) {
                        *imonth = d;
                        *idayofmonth = m;
                        strlcpy(month, getmonthname(d), SLEN);
                        snprintf(dayofmonth, SLEN, "%d", m);
                } else {
                        *imonth = m;
                        *idayofmonth = d;
                        strlcpy(month, getmonthname(m), SLEN);
                        snprintf(dayofmonth, SLEN, "%d", d);
                }
                goto allfine;
        }

        /* FALLTHROUGH */
fail:
        *p = pold;
        return (0);
allfine:
        *p = pold;
        return (1);

}

static void
remember(int *rememberindex, int *y, int *m, int *d, char **ed, int yy, int mm,
    int dd, char *extra)
{
        static int warned = 0;

        if (*rememberindex >= MAXCOUNT - 1) {
                if (warned == 0)
                        warnx("Index > %d, ignored", MAXCOUNT);
                warned++;
                return;
        }
        y[*rememberindex] = yy;
        m[*rememberindex] = mm;
        d[*rememberindex] = dd;
        if (extra != NULL)
                strlcpy(ed[*rememberindex], extra, SLEN);
        else
                ed[*rememberindex][0] = '\0';
        *rememberindex += 1;
}

static void
debug_determinestyle(int dateonly, char *date, int flags, char *month,
    int imonth, char *dayofmonth, int idayofmonth, char *dayofweek,
    int idayofweek, char *modifieroffset, char *modifierindex, char *specialday,
    char *year, int iyear)
{

        if (dateonly != 0) {
                printf("-------\ndate: |%s|\n", date);
                if (dateonly == 1)
                        return;
        }
        printf("flags: %x - %s\n", flags, showflags(flags));
        if (modifieroffset[0] != '\0')
                printf("modifieroffset: |%s|\n", modifieroffset);
        if (modifierindex[0] != '\0')
                printf("modifierindex: |%s|\n", modifierindex);
        if (year[0] != '\0')
                printf("year: |%s| (%d)\n", year, iyear);
        if (month[0] != '\0')
                printf("month: |%s| (%d)\n", month, imonth);
        if (dayofmonth[0] != '\0')
                printf("dayofmonth: |%s| (%d)\n", dayofmonth, idayofmonth);
        if (dayofweek[0] != '\0')
                printf("dayofweek: |%s| (%d)\n", dayofweek, idayofweek);
        if (specialday[0] != '\0')
                printf("specialday: |%s|\n", specialday);
}

static struct yearinfo {
        int year;
        int ieaster, ipaskha, firstcnyday;
        double ffullmoon[MAXMOONS], fnewmoon[MAXMOONS];
        double ffullmooncny[MAXMOONS], fnewmooncny[MAXMOONS];
        int ichinesemonths[MAXMOONS];
        double equinoxdays[2], solsticedays[2];
        int *monthdays;
        struct yearinfo *next;
} *years, *yearinfo;

/*
 * Calculate dates with offset from weekdays, like Thurs-3, Wed+2, etc.
 * day is the day of the week,
 * offset the ordinal number of the weekday in the month.
 */
static int
wdayom (int day, int offset, int month, int year)
{
/* Weekday of first day in month */
        int wday1;                                /* first day of month */
/* Weekday of last day in month */
        int wdayn;
        int d;

        wday1 = first_dayofweek_of_month(year, month);
        if (wday1 < 0)                          /* not set */
                return (wday1);
        /*
         * Date of zeroth or first of our weekday in month, depending on the
         * relationship with the first of the month.  The range is -6:6.
         */
        d = (day - wday1 + 1) % 7;
        /*
         * Which way are we counting?  Offset 0 is invalid, abs (offset) > 5 is
         * meaningless, but that's OK.  Offset 5 may or may not be meaningless,
         * so there's no point in complaining for complaining's sake.
         */
        if (offset < 0) {                       /* back from end of month */
                                                /* FIXME */
                wdayn = d;
                while (wdayn <= yearinfo->monthdays[month])
                        wdayn += 7;
                d = offset * 7 + wdayn;
        } else if (offset > 0){
                if (d > 0)
                        d += offset * 7 - 7;
                else
                        d += offset * 7;
        } else
                warnx ("Invalid offset 0");
        return (d);
}

/*
 * Possible date formats include any combination of:
 *      3-charmonth                     (January, Jan, Jan)
 *      3-charweekday                   (Friday, Monday, mon.)
 *      numeric month or day            (1, 2, 04)
 *
 * Any character may separate them, or they may not be separated.  Any line,
 * following a line that is matched, that starts with "whitespace", is shown
 * along with the matched line.
 */
int
parsedaymonth(char *date, int *yearp, int *monthp, int *dayp, int *flags,
    char **edp)
{
        char month[SLEN], dayofmonth[SLEN], dayofweek[SLEN], modifieroffset[SLEN];
        char syear[SLEN];
        char modifierindex[SLEN], specialday[SLEN];
        int idayofweek = -1, imonth = -1, idayofmonth = -1, iyear = -1;
        int year, remindex;
        int d, m, dow, rm, rd, offset;
        char *ed;
        int retvalsign = 1;

        /*
         * CONVENTION
         *
         * Month:     1-12
         * Monthname: Jan .. Dec
         * Day:       1-31
         * Weekday:   Mon .. Sun
         *
         */

        *flags = 0;

        if (debug)
                debug_determinestyle(1, date, *flags, month, imonth,
                    dayofmonth, idayofmonth, dayofweek, idayofweek,
                    modifieroffset, modifierindex, specialday, syear, iyear);
        if (determinestyle(date, flags, month, &imonth, dayofmonth,
                &idayofmonth, dayofweek, &idayofweek, modifieroffset,
                modifierindex, specialday, syear, &iyear) == 0) {
                if (debug)
                        printf("Failed!\n");
                return (0);
        }

        if (debug)
                debug_determinestyle(0, date, *flags, month, imonth,
                    dayofmonth, idayofmonth, dayofweek, idayofweek,
                    modifieroffset, modifierindex, specialday, syear, iyear);

        remindex = 0;
        for (year = year1; year <= year2; year++) {

                int lflags = *flags;
                /* If the year is specified, only do it if it is this year! */
                if ((lflags & F_YEAR) != 0)
                        if (iyear != year)
                                continue;
                lflags &= ~F_YEAR;

                /* Get important dates for this year */
                yearinfo = years;
                while (yearinfo != NULL) {
                        if (yearinfo->year == year)
                                break;
                        yearinfo = yearinfo -> next;
                }
                if (yearinfo == NULL) {
                        yearinfo = (struct yearinfo *)calloc(1,
                            sizeof(struct yearinfo));
                        if (yearinfo == NULL)
                                errx(1, "Unable to allocate more years");
                        yearinfo->year = year;
                        yearinfo->next = years;
                        years = yearinfo;

                        yearinfo->monthdays = monthdaytab[isleap(year)];
                        yearinfo->ieaster = easter(year);
                        yearinfo->ipaskha = paskha(year);
                        fpom(year, UTCOffset, yearinfo->ffullmoon,
                            yearinfo->fnewmoon);
                        fpom(year, UTCOFFSET_CNY, yearinfo->ffullmooncny,
                            yearinfo->fnewmooncny);
                        fequinoxsolstice(year, UTCOffset,
                            yearinfo->equinoxdays, yearinfo->solsticedays);

                        /*
                         * CNY: Match day with sun longitude at 330` with new
                         * moon
                         */
                        yearinfo->firstcnyday = calculatesunlongitude30(year,
                            UTCOFFSET_CNY, yearinfo->ichinesemonths);
                        for (m = 0; yearinfo->fnewmooncny[m] >= 0; m++) {
                                if (yearinfo->fnewmooncny[m] >
                                    yearinfo->firstcnyday) {
                                        yearinfo->firstcnyday =
                                            floor(yearinfo->fnewmooncny[m - 1]);
                                        break;
                                }
                        }
                }

                /* Same day every year */
                if (lflags == (F_MONTH | F_DAYOFMONTH)) {
                        if (!remember_ymd(year, imonth, idayofmonth))
                                continue;
                        remember(&remindex, yearp, monthp, dayp, edp,
                            year, imonth, idayofmonth, NULL);
                        continue;
                }

                /* XXX Same day every year, but variable */
                if (lflags == (F_MONTH | F_DAYOFMONTH | F_VARIABLE)) {
                        if (!remember_ymd(year, imonth, idayofmonth))
                                continue;
                        remember(&remindex, yearp, monthp, dayp, edp,
                            year, imonth, idayofmonth, NULL);
                        continue;
                }

                /* Same day every month */
                if (lflags == (F_ALLMONTH | F_DAYOFMONTH)) {
                        for (m = 1; m <= 12; m++) {
                                if (!remember_ymd(year, m, idayofmonth))
                                        continue;
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, m, idayofmonth, NULL);
                        }
                        continue;
                }

                /* Every day of a month */
                if (lflags == (F_ALLDAY | F_MONTH)) {
                        for (d = 1; d <= yearinfo->monthdays[imonth]; d++) {
                                if (!remember_ymd(year, imonth, d))
                                        continue;
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, imonth, d, NULL);
                        }
                        continue;
                }

                /* One day of every month */
                if (lflags == (F_ALLMONTH | F_DAYOFWEEK)) {
                        for (m = 1; m <= 12; m++) {
                                if (!remember_ymd(year, m, idayofmonth))
                                        continue;
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, m, idayofmonth, NULL);
                        }
                        continue;
                }

                /* Every dayofweek of the year */
                if (lflags == (F_DAYOFWEEK | F_VARIABLE)) {
                        dow = first_dayofweek_of_year(year);
                        if (dow < 0)
                                continue;
                        d = (idayofweek - dow + 7) % 7 + 1;
                        while (d <= 366) {
                                if (remember_yd(year, d, &rm, &rd))
                                        remember(&remindex,
                                            yearp, monthp, dayp, edp,
                                            year, rm, rd, NULL);
                                d += 7;
                        }
                        continue;
                }

                /*
                 * Every so-manied dayofweek of every month of the year:
                 * Thu-3
                 */
                if (lflags == (F_DAYOFWEEK | F_MODIFIERINDEX | F_VARIABLE)) {
                        offset = indextooffset(modifierindex);

                        for (m = 0; m <= 12; m++) {
                                d = wdayom (idayofweek, offset, m, year);
                                if (remember_ymd(year, m, d)) {
                                        remember(&remindex,
                                            yearp, monthp, dayp, edp,
                                            year, m, d, NULL);
                                        continue;
                                }
                        }
                        continue;
                }

                /*
                 * A certain dayofweek of a month
                 * Jan/Thu-3
                 */
                if (lflags ==
                    (F_MONTH | F_DAYOFWEEK | F_MODIFIERINDEX | F_VARIABLE)) {
                        offset = indextooffset(modifierindex);
                        dow = first_dayofweek_of_month(year, imonth);
                        if (dow < 0)
                                continue;
                        d = (idayofweek - dow + 7) % 7 + 1;

                        if (offset > 0) {
                                while (d <= yearinfo->monthdays[imonth]) {
                                        if (--offset == 0
                                            && remember_ymd(year, imonth, d)) {
                                                remember(&remindex,
                                                    yearp, monthp, dayp, edp,
                                                    year, imonth, d, NULL);
                                                continue;
                                        }
                                        d += 7;
                                }
                                continue;
                        }
                        if (offset < 0) {
                                while (d <= yearinfo->monthdays[imonth])
                                        d += 7;
                                while (offset != 0) {
                                        offset++;
                                        d -= 7;
                                }
                                if (remember_ymd(year, imonth, d))
                                        remember(&remindex,
                                            yearp, monthp, dayp, edp,
                                            year, imonth, d, NULL);
                                continue;
                        }
                        continue;
                }

                /* Every dayofweek of the month */
                if (lflags == (F_DAYOFWEEK | F_MONTH | F_VARIABLE)) {
                        dow = first_dayofweek_of_month(year, imonth);
                        if (dow < 0)
                                continue;
                        d = (idayofweek - dow + 7) % 7 + 1;
                        while (d <= yearinfo->monthdays[imonth]) {
                                if (remember_ymd(year, imonth, d))
                                        remember(&remindex,
                                            yearp, monthp, dayp, edp,
                                            year, imonth, d, NULL);
                                d += 7;
                        }
                        continue;
                }

                /* Easter */
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_EASTER)) {
                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        if (remember_yd(year, yearinfo->ieaster + offset,
                                &rm, &rd))
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, rm, rd, NULL);
                        continue;
                }

                /* Paskha */
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_PASKHA)) {
                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        if (remember_yd(year, yearinfo->ipaskha + offset,
                                &rm, &rd))
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, rm, rd, NULL);
                        continue;
                }

                /* Chinese New Year */
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_CNY)) {
                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        if (remember_yd(year, yearinfo->firstcnyday + offset,
                                &rm, &rd))
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, rm, rd, NULL);
                        continue;
                }

                /* FullMoon */
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_FULLMOON)) {
                        int i;

                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        for (i = 0; yearinfo->ffullmoon[i] > 0; i++) {
                                if (remember_yd(year,
                                        floor(yearinfo->ffullmoon[i]) + offset,
                                        &rm, &rd)) {
                                        ed = floattotime(
                                            yearinfo->ffullmoon[i]);
                                        remember(&remindex,
                                            yearp, monthp, dayp, edp,
                                            year, rm, rd, ed);
                                }
                        }
                        continue;
                }

                /* NewMoon */
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_NEWMOON)) {
                        int i;

                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        for (i = 0; yearinfo->ffullmoon[i] > 0; i++) {
                                if (remember_yd(year,
                                        floor(yearinfo->fnewmoon[i]) + offset,
                                        &rm, &rd)) {
                                        ed = floattotime(yearinfo->fnewmoon[i]);
                                        remember(&remindex,
                                            yearp, monthp, dayp, edp,
                                            year, rm, rd, ed);
                                }
                        }
                        continue;
                }

                /* (Mar|Sep)Equinox */
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_MAREQUINOX)) {
                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        if (remember_yd(year, yearinfo->equinoxdays[0] + offset,
                                &rm, &rd)) {
                                ed = floattotime(yearinfo->equinoxdays[0]);
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, rm, rd, ed);
                        }
                        continue;
                }
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_SEPEQUINOX)) {
                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        if (remember_yd(year, yearinfo->equinoxdays[1] + offset,
                            &rm, &rd)) {
                                ed = floattotime(yearinfo->equinoxdays[1]);
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, rm, rd, ed);
                        }
                        continue;
                }

                /* (Jun|Dec)Solstice */
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_JUNSOLSTICE)) {
                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        if (remember_yd(year,
                                yearinfo->solsticedays[0] + offset, &rm, &rd)) {
                                ed = floattotime(yearinfo->solsticedays[0]);
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, rm, rd, ed);
                        }
                        continue;
                }
                if ((lflags & ~F_MODIFIEROFFSET) ==
                    (F_SPECIALDAY | F_VARIABLE | F_DECSOLSTICE)) {
                        offset = 0;
                        if ((lflags & F_MODIFIEROFFSET) != 0)
                                offset = parseoffset(modifieroffset);
                        if (remember_yd(year,
                                yearinfo->solsticedays[1] + offset, &rm, &rd)) {
                                ed = floattotime(yearinfo->solsticedays[1]);
                                remember(&remindex, yearp, monthp, dayp, edp,
                                    year, rm, rd, ed);
                        }
                        continue;
                }

                if (debug) {
                        printf("Unprocessed:\n");
                        debug_determinestyle(2, date, lflags, month, imonth,
                            dayofmonth, idayofmonth, dayofweek, idayofweek,
                            modifieroffset, modifierindex, specialday, syear,
                            iyear);
                }
                retvalsign = -1;
        }

        if (retvalsign == -1)
                return (-remindex - 1);
        else
                return (remindex);
}

static char *
showflags(int flags)
{
        static char s[SLEN];
        s[0] = '\0';

        if ((flags & F_YEAR) != 0)
                strlcat(s, "year ", SLEN);
        if ((flags & F_MONTH) != 0)
                strlcat(s, "month ", SLEN);
        if ((flags & F_DAYOFWEEK) != 0)
                strlcat(s, "dayofweek ", SLEN);
        if ((flags & F_DAYOFMONTH) != 0)
                strlcat(s, "dayofmonth ", SLEN);
        if ((flags & F_MODIFIERINDEX) != 0)
                strlcat(s, "modifierindex ", SLEN);
        if ((flags & F_MODIFIEROFFSET) != 0)
                strlcat(s, "modifieroffset ", SLEN);
        if ((flags & F_SPECIALDAY) != 0)
                strlcat(s, "specialday ", SLEN);
        if ((flags & F_ALLMONTH) != 0)
                strlcat(s, "allmonth ", SLEN);
        if ((flags & F_ALLDAY) != 0)
                strlcat(s, "allday ", SLEN);
        if ((flags & F_VARIABLE) != 0)
                strlcat(s, "variable ", SLEN);
        if ((flags & F_CNY) != 0)
                strlcat(s, "chinesenewyear ", SLEN);
        if ((flags & F_PASKHA) != 0)
                strlcat(s, "paskha ", SLEN);
        if ((flags & F_EASTER) != 0)
                strlcat(s, "easter ", SLEN);
        if ((flags & F_FULLMOON) != 0)
                strlcat(s, "fullmoon ", SLEN);
        if ((flags & F_NEWMOON) != 0)
                strlcat(s, "newmoon ", SLEN);
        if ((flags & F_MAREQUINOX) != 0)
                strlcat(s, "marequinox ", SLEN);
        if ((flags & F_SEPEQUINOX) != 0)
                strlcat(s, "sepequinox ", SLEN);
        if ((flags & F_JUNSOLSTICE) != 0)
                strlcat(s, "junsolstice ", SLEN);
        if ((flags & F_DECSOLSTICE) != 0)
                strlcat(s, "decsolstice ", SLEN);

        return s;
}

static const char *
getmonthname(int i)
{
        if (i <= 0 || i > 12)
                return ("");
        if (nmonths[i - 1].len != 0 && nmonths[i - 1].name != NULL)
                return (nmonths[i - 1].name);
        return (months[i - 1]);
}

static int
checkmonth(char *s, size_t *len, size_t *offset, const char **month)
{
        struct fixs *n;
        int i;

        for (i = 0; fnmonths[i].name != NULL; i++) {
                n = fnmonths + i;
                if (strncasecmp(s, n->name, n->len) == 0) {
                        *len = n->len;
                        *month = n->name;
                        *offset = i + 1;
                        return (1);
                }
        }
        for (i = 0; nmonths[i].name != NULL; i++) {
                n = nmonths + i;
                if (strncasecmp(s, n->name, n->len) == 0) {
                        *len = n->len;
                        *month = n->name;
                        *offset = i + 1;
                        return (1);
                }
        }
        for (i = 0; fmonths[i] != NULL; i++) {
                *len = strlen(fmonths[i]);
                if (strncasecmp(s, fmonths[i], *len) == 0) {
                        *month = fmonths[i];
                        *offset = i + 1;
                        return (1);
                }
        }
        for (i = 0; months[i] != NULL; i++) {
                if (strncasecmp(s, months[i], 3) == 0) {
                        *len = 3;
                        *month = months[i];
                        *offset = i + 1;
                        return (1);
                }
        }
        return (0);
}

static const char *
getdayofweekname(int i)
{
        if (ndays[i].len != 0 && ndays[i].name != NULL)
                return (ndays[i].name);
        return (days[i]);
}

static int
checkdayofweek(char *s, size_t *len, size_t *offset, const char **dow)
{
        struct fixs *n;
        int i;

        for (i = 0; fndays[i].name != NULL; i++) {
                n = fndays + i;
                if (strncasecmp(s, n->name, n->len) == 0) {
                        *len = n->len;
                        *dow = n->name;
                        *offset = i;
                        return (1);
                }
        }
        for (i = 0; ndays[i].name != NULL; i++) {
                n = ndays + i;
                if (strncasecmp(s, n->name, n->len) == 0) {
                        *len = n->len;
                        *dow = n->name;
                        *offset = i;
                        return (1);
                }
        }
        for (i = 0; fdays[i] != NULL; i++) {
                *len = strlen(fdays[i]);
                if (strncasecmp(s, fdays[i], *len) == 0) {
                        *dow = fdays[i];
                        *offset = i;
                        return (1);
                }
        }
        for (i = 0; days[i] != NULL; i++) {
                if (strncasecmp(s, days[i], 3) == 0) {
                        *len = 3;
                        *dow = days[i];
                        *offset = i;
                        return (1);
                }
        }
        return (0);
}

static int
isonlydigits(char *s, int nostar)
{
        int i;
        for (i = 0; s[i] != '\0'; i++) {
                if (nostar == 0 && s[i] == '*' && s[i + 1] == '\0')
                        return 1;
                if (!isdigit((unsigned char)s[i]))
                        return (0);
        }
        return (1);
}

static int
indextooffset(char *s)
{
        int i;
        struct fixs *n;
        char *es;

        if (s[0] == '+' || s[0] == '-') {
                i = strtol (s, &es, 10);
                if (*es != '\0')                      /* trailing junk */
                        errx (1, "Invalid specifier format: %s\n", s);
                return (i);
        }

        for (i = 0; i < 6; i++) {
                if (strcasecmp(s, sequences[i]) == 0) {
                        if (i == 5)
                                return (-1);
                        return (i + 1);
                }
        }
        for (i = 0; i < 6; i++) {
                n = nsequences + i;
                if (n->len == 0)
                        continue;
                if (strncasecmp(s, n->name, n->len) == 0) {
                        if (i == 5)
                                return (-1);
                        return (i + 1);
                }
        }
        return (0);
}

static int
parseoffset(char *s)
{
        return strtol(s, NULL, 10);
}

static char *
floattotime(double f)
{
        static char buf[SLEN];
        int hh, mm, ss, i;

        f -= floor(f);
        i = f * SECSPERDAY;

        hh = i / SECSPERHOUR;
        i %= SECSPERHOUR;
        mm = i / SECSPERMINUTE;
        i %= SECSPERMINUTE;
        ss = i;

        snprintf(buf, SLEN, "%02d:%02d:%02d", hh, mm, ss);
        return (buf);
}

static char *
floattoday(int year, double f)
{
        static char buf[SLEN];
        int i, m, d, hh, mm, ss;
        int *cumdays = cumdaytab[isleap(year)];

        for (i = 0; 1 + cumdays[i] < f; i++)
                ;
        m = --i;
        d = floor(f - 1 - cumdays[i]);
        f -= floor(f);
        i = f * SECSPERDAY;

        hh = i / SECSPERHOUR;
        i %= SECSPERHOUR;
        mm = i / SECSPERMINUTE;
        i %= SECSPERMINUTE;
        ss = i;

        snprintf(buf, SLEN, "%02d-%02d %02d:%02d:%02d", m, d, hh, mm, ss);
        return (buf);
}

void
dodebug(char *what)
{
        int year;

        printf("UTCOffset: %g\n", UTCOffset);
        printf("eastlongitude: %d\n", EastLongitude);

        if (strcmp(what, "moon") == 0) {
                double ffullmoon[MAXMOONS], fnewmoon[MAXMOONS];
                int i;

                for (year = year1; year <= year2; year++) {
                        fpom(year, UTCOffset, ffullmoon, fnewmoon);
                        printf("Full moon %d:\t", year);
                        for (i = 0; ffullmoon[i] >= 0; i++) {
                                printf("%g (%s) ", ffullmoon[i],
                                    floattoday(year, ffullmoon[i]));
                        }
                        printf("\nNew moon %d:\t", year);
                        for (i = 0; fnewmoon[i] >= 0; i++) {
                                printf("%g (%s) ", fnewmoon[i],
                                    floattoday(year, fnewmoon[i]));
                        }
                        printf("\n");

                }

                return;
        }

        if (strcmp(what, "sun") == 0) {
                double equinoxdays[2], solsticedays[2];
                for (year = year1; year <= year2; year++) {
                        printf("Sun in %d:\n", year);
                        fequinoxsolstice(year, UTCOffset, equinoxdays,
                            solsticedays);
                        printf("e[0] - %g (%s)\n",
                            equinoxdays[0],
                            floattoday(year, equinoxdays[0]));
                        printf("e[1] - %g (%s)\n",
                            equinoxdays[1],
                            floattoday(year, equinoxdays[1]));
                        printf("s[0] - %g (%s)\n",
                            solsticedays[0],
                            floattoday(year, solsticedays[0]));
                        printf("s[1] - %g (%s)\n",
                            solsticedays[1],
                            floattoday(year, solsticedays[1]));
                }
                return;
        }
}