debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-12-18 07:24:51 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/parse-time-string/parse-time-string.c
uncrustify 8a3f86f2f9 parse-time-string: run uncrustify 
This is the result of running

     $ uncrustify --replace --config ../devel/uncrustify.cfg *.c *.h

in the parse-time-string directory
2019-06-14 07:41:27 -03:00

1510 lines
40 KiB
C
Raw Blame History

/*
* parse time string - user friendly date and time parser
* Copyright © 2012 Jani Nikula
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* Author: Jani Nikula <jani@nikula.org>
*/
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include "compat.h"
#include "parse-time-string.h"
/*
* IMPLEMENTATION DETAILS
*
* At a high level, the parsing is done in two phases: 1) actual
* parsing of the input string and storing the parsed data into
* 'struct state', and 2) processing of the data in 'struct state'
* according to current time (or provided reference time) and
* rounding. This is evident in the main entry point function
* parse_time_string().
*
* 1) The parsing phase - parse_input()
*
* Parsing is greedy and happens from left to right. The parsing is as
* unambiguous as possible; only unambiguous date/time formats are
* accepted. Redundant or contradictory absolute date/time in the
* input (e.g. date specified multiple times/ways) is not
* accepted. Relative date/time on the other hand just accumulates if
* present multiple times (e.g. "5 days 5 days" just turns into 10
* days).
*
* Parsing decisions are made on the input format, not value. For
* example, "20/5/2005" fails because the recognized format here is
* MM/D/YYYY, even though the values would suggest DD/M/YYYY.
*
* Parsing is mostly stateless in the sense that parsing decisions are
* not made based on the values of previously parsed data, or whether
* certain data is present in the first place. (There are a few
* exceptions to the latter part, though, such as parsing of time zone
* that would otherwise look like plain time.)
*
* When the parser encounters a number that is not greedily parsed as
* part of a format, the interpretation is postponed until the next
* token is parsed. The parser for the next token may consume the
* previously postponed number. For example, when parsing "20 May" the
* meaning of "20" is not known until "May" is parsed. If the parser
* for the next token does not consume the postponed number, the
* number is handled as a "lone" number before parser for the next
* token finishes.
*
* 2) The processing phase - create_output()
*
* Once the parser in phase 1 has finished, 'struct state' contains
* all the information from the input string, and it's no longer
* needed. Since the parser does not even handle the concept of "now",
* the processing initializes the fields referring to the current
* date/time.
*
* If requested, the result is rounded towards past or future. The
* idea behind rounding is to support parsing date/time ranges in an
* obvious way. For example, for a range defined as two dates (without
* time), one would typically want to have an inclusive range from the
* beginning of start date to the end of the end date. The caller
* would use rounding towards past in the start date, and towards
* future in the end date.
*
* The absolute date and time is shifted by the relative date and
* time, and time zone adjustments are made. Daylight saving time
* (DST) is specifically *not* handled at all.
*
* Finally, the result is stored to time_t.
*/
#define unused(x) x __attribute__ ((unused))
/* XXX: Redefine these to add i18n support. The keyword table uses
* N_() to mark strings to be translated; they are accessed
* dynamically using _(). */
#define _(s) (s) /* i18n: define as gettext (s) */
#define N_(s) (s) /* i18n: define as gettext_noop (s) */
#define ARRAY_SIZE(a) (sizeof (a) / sizeof (a[0]))
/*
* Field indices in the tm and set arrays of struct state.
*
* NOTE: There's some code that depends on the ordering of this enum.
*/
enum field {
/* Keep SEC...YEAR in this order. */
TM_ABS_SEC, /* seconds */
TM_ABS_MIN, /* minutes */
TM_ABS_HOUR, /* hours */
TM_ABS_MDAY, /* day of the month */
TM_ABS_MON, /* month */
TM_ABS_YEAR, /* year */
TM_WDAY, /* day of the week. special: may be relative */
TM_ABS_ISDST, /* daylight saving time */
TM_AMPM, /* am vs. pm */
TM_TZ, /* timezone in minutes */
/* Keep SEC...YEAR in this order. */
TM_REL_SEC, /* seconds relative to absolute or reference time */
TM_REL_MIN, /* minutes ... */
TM_REL_HOUR, /* hours ... */
TM_REL_DAY, /* days ... */
TM_REL_MON, /* months ... */
TM_REL_YEAR, /* years ... */
TM_REL_WEEK, /* weeks ... */
TM_NONE, /* not a field */
TM_SIZE = TM_NONE,
TM_FIRST_ABS = TM_ABS_SEC,
TM_FIRST_REL = TM_REL_SEC,
};
/* Values for the set array of struct state. */
enum field_set {
FIELD_UNSET, /* The field has not been touched by parser. */
FIELD_SET, /* The field has been set by parser. */
FIELD_NOW, /* The field will be set to reference time. */
};
static enum field
next_abs_field (enum field field)
{
/* NOTE: Depends on the enum ordering. */
return field < TM_ABS_YEAR ? field + 1 : TM_NONE;
}
static enum field
abs_to_rel_field (enum field field)
{
assert (field <= TM_ABS_YEAR);
/* NOTE: Depends on the enum ordering. */
return field + (TM_FIRST_REL - TM_FIRST_ABS);
}
/* Get the smallest acceptable value for field. */
static int
get_field_epoch_value (enum field field)
{
if (field == TM_ABS_MDAY || field == TM_ABS_MON)
return 1;
else if (field == TM_ABS_YEAR)
return 1970;
else
return 0;
}
/* The parsing state. */
struct state {
int tm[TM_SIZE]; /* parsed date and time */
enum field_set set[TM_SIZE]; /* set status of tm */
enum field last_field; /* Previously set field. */
char delim;
int postponed_length; /* Number of digits in postponed value. */
int postponed_value;
char postponed_delim; /* The delimiter preceding postponed number. */
};
/*
* Helpers for postponed numbers.
*
* postponed_length is the number of digits in postponed value. 0
* means there is no postponed number. -1 means there is a postponed
* number, but it comes from a keyword, and it doesn't have digits.
*/
static int
get_postponed_length (struct state *state)
{
return state->postponed_length;
}
/*
* Consume a previously postponed number. Return true if a number was
* in fact postponed, false otherwise. Store the postponed number's
* value in *v, length in the input string in *n (or -1 if the number
* was written out and parsed as a keyword), and the preceding
* delimiter to *d. If a number was not postponed, *v, *n and *d are
* unchanged.
*/
static bool
consume_postponed_number (struct state *state, int *v, int *n, char *d)
{
if (! state->postponed_length)
return false;
if (n)
*n = state->postponed_length;
if (v)
*v = state->postponed_value;
if (d)
*d = state->postponed_delim;
state->postponed_length = 0;
state->postponed_value = 0;
state->postponed_delim = 0;
return true;
}
static int parse_postponed_number (struct state *state, enum field next_field);
/*
* Postpone a number to be handled later. If one exists already,
* handle it first. n may be -1 to indicate a keyword that has no
* number length.
*/
static int
set_postponed_number (struct state *state, int v, int n)
{
int r;
char d = state->delim;
/* Parse a previously postponed number, if any. */
r = parse_postponed_number (state, TM_NONE);
if (r)
return r;
state->postponed_length = n;
state->postponed_value = v;
state->postponed_delim = d;
return 0;
}
static void
set_delim (struct state *state, char delim)
{
state->delim = delim;
}
static void
unset_delim (struct state *state)
{
state->delim = 0;
}
/*
* Field set/get/mod helpers.
*/
/* Return true if field has been set. */
static bool
is_field_set (struct state *state, enum field field)
{
assert (field < ARRAY_SIZE (state->tm));
return state->set[field] != FIELD_UNSET;
}
static void
unset_field (struct state *state, enum field field)
{
assert (field < ARRAY_SIZE (state->tm));
state->set[field] = FIELD_UNSET;
state->tm[field] = 0;
}
/*
* Set field to value. A field can only be set once to ensure the
* input does not contain redundant and potentially conflicting data.
*/
static int
set_field (struct state *state, enum field field, int value)
{
int r;
/* Fields can only be set once. */
if (is_field_set (state, field))
return -PARSE_TIME_ERR_ALREADYSET;
state->set[field] = FIELD_SET;
/* Parse a previously postponed number, if any. */
r = parse_postponed_number (state, field);
if (r)
return r;
unset_delim (state);
state->tm[field] = value;
state->last_field = field;
return 0;
}
/*
* Mark n fields in fields to be set to the reference date/time in the
* specified time zone, or local timezone if not specified. The fields
* will be initialized after parsing is complete and timezone is
* known.
*/
static int
set_fields_to_now (struct state *state, enum field *fields, size_t n)
{
size_t i;
int r;
for (i = 0; i < n; i++) {
r = set_field (state, fields[i], 0);
if (r)
return r;
state->set[fields[i]] = FIELD_NOW;
}
return 0;
}
/* Modify field by adding value to it. To be used on relative fields,
* which can be modified multiple times (to accumulate). */
static int
add_to_field (struct state *state, enum field field, int value)
{
int r;
assert (field < ARRAY_SIZE (state->tm));
state->set[field] = FIELD_SET;
/* Parse a previously postponed number, if any. */
r = parse_postponed_number (state, field);
if (r)
return r;
unset_delim (state);
state->tm[field] += value;
state->last_field = field;
return 0;
}
/*
* Get field value. Make sure the field is set before query. It's most
* likely an error to call this while parsing (for example fields set
* as FIELD_NOW will only be set to some value after parsing).
*/
static int
get_field (struct state *state, enum field field)
{
assert (field < ARRAY_SIZE (state->tm));
return state->tm[field];
}
/*
* Validity checkers.
*/
static bool
is_valid_12hour (int h)
{
return h >= 1 && h <= 12;
}
static bool
is_valid_time (int h, int m, int s)
{
/* Allow 24:00:00 to denote end of day. */
if (h == 24 && m == 0 && s == 0)
return true;
return h >= 0 && h <= 23 && m >= 0 && m <= 59 && s >= 0 && s <= 59;
}
static bool
is_valid_mday (int mday)
{
return mday >= 1 && mday <= 31;
}
static bool
is_valid_mon (int mon)
{
return mon >= 1 && mon <= 12;
}
static bool
is_valid_year (int year)
{
return year >= 1970;
}
static bool
is_valid_date (int year, int mon, int mday)
{
return is_valid_year (year) && is_valid_mon (mon) && is_valid_mday (mday);
}
/* Unset indicator for time and date set helpers. */
#define UNSET -1
/* Time set helper. No input checking. Use UNSET (-1) to leave unset. */
static int
set_abs_time (struct state *state, int hour, int min, int sec)
{
int r;
if (hour != UNSET) {
if ((r = set_field (state, TM_ABS_HOUR, hour)))
return r;
}
if (min != UNSET) {
if ((r = set_field (state, TM_ABS_MIN, min)))
return r;
}
if (sec != UNSET) {
if ((r = set_field (state, TM_ABS_SEC, sec)))
return r;
}
return 0;
}
/* Date set helper. No input checking. Use UNSET (-1) to leave unset. */
static int
set_abs_date (struct state *state, int year, int mon, int mday)
{
int r;
if (year != UNSET) {
if ((r = set_field (state, TM_ABS_YEAR, year)))
return r;
}
if (mon != UNSET) {
if ((r = set_field (state, TM_ABS_MON, mon)))
return r;
}
if (mday != UNSET) {
if ((r = set_field (state, TM_ABS_MDAY, mday)))
return r;
}
return 0;
}
/*
* Keyword parsing and handling.
*/
struct keyword;
typedef int (*setter_t)(struct state *state, struct keyword *kw);
struct keyword {
const char *name; /* keyword */
enum field field; /* field to set, or FIELD_NONE if N/A */
int value; /* value to set, or 0 if N/A */
setter_t set; /* function to use for setting, if non-NULL */
};
/*
* Setter callback functions for keywords.
*/
static int
kw_set_rel (struct state *state, struct keyword *kw)
{
int multiplier = 1;
/* Get a previously set multiplier, if any. */
consume_postponed_number (state, &multiplier, NULL, NULL);
/* Accumulate relative field values. */
return add_to_field (state, kw->field, multiplier * kw->value);
}
static int
kw_set_number (struct state *state, struct keyword *kw)
{
/* -1 = no length, from keyword. */
return set_postponed_number (state, kw->value, -1);
}
static int
kw_set_month (struct state *state, struct keyword *kw)
{
int n = get_postponed_length (state);
/* Consume postponed number if it could be mday. This handles "20
* January". */
if (n == 1 || n == 2) {
int r, v;
consume_postponed_number (state, &v, NULL, NULL);
if (! is_valid_mday (v))
return -PARSE_TIME_ERR_INVALIDDATE;
r = set_field (state, TM_ABS_MDAY, v);
if (r)
return r;
}
return set_field (state, kw->field, kw->value);
}
static int
kw_set_ampm (struct state *state, struct keyword *kw)
{
int n = get_postponed_length (state);
/* Consume postponed number if it could be hour. This handles
* "5pm". */
if (n == 1 || n == 2) {
int r, v;
consume_postponed_number (state, &v, NULL, NULL);
if (! is_valid_12hour (v))
return -PARSE_TIME_ERR_INVALIDTIME;
r = set_abs_time (state, v, 0, 0);
if (r)
return r;
}
return set_field (state, kw->field, kw->value);
}
static int
kw_set_timeofday (struct state *state, struct keyword *kw)
{
return set_abs_time (state, kw->value, 0, 0);
}
static int
kw_set_today (struct state *state, unused (struct keyword *kw))
{
enum field fields[] = { TM_ABS_YEAR, TM_ABS_MON, TM_ABS_MDAY };
return set_fields_to_now (state, fields, ARRAY_SIZE (fields));
}
static int
kw_set_now (struct state *state, unused (struct keyword *kw))
{
enum field fields[] = { TM_ABS_HOUR, TM_ABS_MIN, TM_ABS_SEC };
return set_fields_to_now (state, fields, ARRAY_SIZE (fields));
}
static int
kw_set_ordinal (struct state *state, struct keyword *kw)
{
int n, v;
/* Require a postponed number. */
if (! consume_postponed_number (state, &v, &n, NULL))
return -PARSE_TIME_ERR_DATEFORMAT;
/* Ordinals are mday. */
if (n != 1 && n != 2)
return -PARSE_TIME_ERR_DATEFORMAT;
/* Be strict about st, nd, rd, and lax about th. */
if (strcasecmp (kw->name, "st") == 0 && v != 1 && v != 21 && v != 31)
return -PARSE_TIME_ERR_INVALIDDATE;
else if (strcasecmp (kw->name, "nd") == 0 && v != 2 && v != 22)
return -PARSE_TIME_ERR_INVALIDDATE;
else if (strcasecmp (kw->name, "rd") == 0 && v != 3 && v != 23)
return -PARSE_TIME_ERR_INVALIDDATE;
else if (strcasecmp (kw->name, "th") == 0 && ! is_valid_mday (v))
return -PARSE_TIME_ERR_INVALIDDATE;
return set_field (state, TM_ABS_MDAY, v);
}
static int
kw_ignore (unused (struct state *state), unused (struct keyword *kw))
{
return 0;
}
/*
* Accepted keywords.
*
* A keyword may optionally contain a '|' to indicate the minimum
* match length. Without one, full match is required. It's advisable
* to keep the minimum match parts unique across all keywords. If
* they're not, the first match wins.
*
* If keyword begins with '*', then the matching will be case
* sensitive. Otherwise the matching is case insensitive.
*
* If .set is NULL, the field specified by .field will be set to
* .value.
*
* Note: Observe how "m" and "mi" match minutes, "M" and "mo" and
* "mont" match months, but "mon" matches Monday.
*/
static struct keyword keywords[] = {
/* Weekdays. */
{ N_ ("sun|day"), TM_WDAY, 0, NULL },
{ N_ ("mon|day"), TM_WDAY, 1, NULL },
{ N_ ("tue|sday"), TM_WDAY, 2, NULL },
{ N_ ("wed|nesday"), TM_WDAY, 3, NULL },
{ N_ ("thu|rsday"), TM_WDAY, 4, NULL },
{ N_ ("fri|day"), TM_WDAY, 5, NULL },
{ N_ ("sat|urday"), TM_WDAY, 6, NULL },
/* Months. */
{ N_ ("jan|uary"), TM_ABS_MON, 1, kw_set_month },
{ N_ ("feb|ruary"), TM_ABS_MON, 2, kw_set_month },
{ N_ ("mar|ch"), TM_ABS_MON, 3, kw_set_month },
{ N_ ("apr|il"), TM_ABS_MON, 4, kw_set_month },
{ N_ ("may"), TM_ABS_MON, 5, kw_set_month },
{ N_ ("jun|e"), TM_ABS_MON, 6, kw_set_month },
{ N_ ("jul|y"), TM_ABS_MON, 7, kw_set_month },
{ N_ ("aug|ust"), TM_ABS_MON, 8, kw_set_month },
{ N_ ("sep|tember"), TM_ABS_MON, 9, kw_set_month },
{ N_ ("oct|ober"), TM_ABS_MON, 10, kw_set_month },
{ N_ ("nov|ember"), TM_ABS_MON, 11, kw_set_month },
{ N_ ("dec|ember"), TM_ABS_MON, 12, kw_set_month },
/* Durations. */
{ N_ ("y|ears"), TM_REL_YEAR, 1, kw_set_rel },
{ N_ ("mo|nths"), TM_REL_MON, 1, kw_set_rel },
{ N_ ("*M"), TM_REL_MON, 1, kw_set_rel },
{ N_ ("w|eeks"), TM_REL_WEEK, 1, kw_set_rel },
{ N_ ("d|ays"), TM_REL_DAY, 1, kw_set_rel },
{ N_ ("h|ours"), TM_REL_HOUR, 1, kw_set_rel },
{ N_ ("hr|s"), TM_REL_HOUR, 1, kw_set_rel },
{ N_ ("mi|nutes"), TM_REL_MIN, 1, kw_set_rel },
{ N_ ("mins"), TM_REL_MIN, 1, kw_set_rel },
{ N_ ("*m"), TM_REL_MIN, 1, kw_set_rel },
{ N_ ("s|econds"), TM_REL_SEC, 1, kw_set_rel },
{ N_ ("secs"), TM_REL_SEC, 1, kw_set_rel },
/* Numbers. */
{ N_ ("one"), TM_NONE, 1, kw_set_number },
{ N_ ("two"), TM_NONE, 2, kw_set_number },
{ N_ ("three"), TM_NONE, 3, kw_set_number },
{ N_ ("four"), TM_NONE, 4, kw_set_number },
{ N_ ("five"), TM_NONE, 5, kw_set_number },
{ N_ ("six"), TM_NONE, 6, kw_set_number },
{ N_ ("seven"), TM_NONE, 7, kw_set_number },
{ N_ ("eight"), TM_NONE, 8, kw_set_number },
{ N_ ("nine"), TM_NONE, 9, kw_set_number },
{ N_ ("ten"), TM_NONE, 10, kw_set_number },
{ N_ ("dozen"), TM_NONE, 12, kw_set_number },
{ N_ ("hundred"), TM_NONE, 100, kw_set_number },
/* Special number forms. */
{ N_ ("this"), TM_NONE, 0, kw_set_number },
{ N_ ("last"), TM_NONE, 1, kw_set_number },
/* Other special keywords. */
{ N_ ("yesterday"), TM_REL_DAY, 1, kw_set_rel },
{ N_ ("today"), TM_NONE, 0, kw_set_today },
{ N_ ("now"), TM_NONE, 0, kw_set_now },
{ N_ ("noon"), TM_NONE, 12, kw_set_timeofday },
{ N_ ("midnight"), TM_NONE, 0, kw_set_timeofday },
{ N_ ("am"), TM_AMPM, 0, kw_set_ampm },
{ N_ ("a.m."), TM_AMPM, 0, kw_set_ampm },
{ N_ ("pm"), TM_AMPM, 1, kw_set_ampm },
{ N_ ("p.m."), TM_AMPM, 1, kw_set_ampm },
{ N_ ("st"), TM_NONE, 0, kw_set_ordinal },
{ N_ ("nd"), TM_NONE, 0, kw_set_ordinal },
{ N_ ("rd"), TM_NONE, 0, kw_set_ordinal },
{ N_ ("th"), TM_NONE, 0, kw_set_ordinal },
{ N_ ("ago"), TM_NONE, 0, kw_ignore },
/* Timezone codes: offset in minutes. XXX: Add more codes. */
{ N_ ("pst"), TM_TZ, -8 * 60, NULL },
{ N_ ("mst"), TM_TZ, -7 * 60, NULL },
{ N_ ("cst"), TM_TZ, -6 * 60, NULL },
{ N_ ("est"), TM_TZ, -5 * 60, NULL },
{ N_ ("ast"), TM_TZ, -4 * 60, NULL },
{ N_ ("nst"), TM_TZ, -(3 * 60 + 30), NULL },
{ N_ ("gmt"), TM_TZ, 0, NULL },
{ N_ ("utc"), TM_TZ, 0, NULL },
{ N_ ("wet"), TM_TZ, 0, NULL },
{ N_ ("cet"), TM_TZ, 1 * 60, NULL },
{ N_ ("eet"), TM_TZ, 2 * 60, NULL },
{ N_ ("fet"), TM_TZ, 3 * 60, NULL },
{ N_ ("wat"), TM_TZ, 1 * 60, NULL },
{ N_ ("cat"), TM_TZ, 2 * 60, NULL },
{ N_ ("eat"), TM_TZ, 3 * 60, NULL },
};
/*
* Compare strings str and keyword. Return the number of matching
* chars on match, 0 for no match.
*
* All of the alphabetic characters (isalpha) in str up to the first
* non-alpha character (or end of string) must match the
* keyword. Consequently, the value returned on match is the number of
* consecutive alphabetic characters in str.
*
* Abbreviated match is accepted if the keyword contains a '|'
* character, and str matches keyword up to that character. Any alpha
* characters after that in str must still match the keyword following
* the '|' character. If no '|' is present, all of keyword must match.
*
* Excessive, consecutive, and misplaced (at the beginning or end) '|'
* characters in keyword are handled gracefully. Only the first one
* matters.
*
* If match_case is true, the matching is case sensitive.
*/
static size_t
match_keyword (const char *str, const char *keyword, bool match_case)
{
const char *s = str;
bool prefix_matched = false;
for (;;) {
while (*keyword == '|') {
prefix_matched = true;
keyword++;
}
if (! *s || ! isalpha ((unsigned char) *s) || ! *keyword)
break;
if (match_case) {
if (*s != *keyword)
return 0;
} else {
if (tolower ((unsigned char) *s) !=
tolower ((unsigned char) *keyword))
return 0;
}
s++;
keyword++;
}
/* did not match all of the keyword in input string */
if (*s && isalpha ((unsigned char) *s))
return 0;
/* did not match enough of keyword */
if (*keyword && ! prefix_matched)
return 0;
return s - str;
}
/*
* Parse a keyword. Return < 0 on error, number of parsed chars on
* success.
*/
static ssize_t
parse_keyword (struct state *state, const char *s)
{
unsigned int i;
size_t n = 0;
struct keyword *kw = NULL;
int r;
for (i = 0; i < ARRAY_SIZE (keywords); i++) {
const char *keyword = _ (keywords[i].name);
bool mcase = false;
/* Match case if keyword begins with '*'. */
if (*keyword == '*') {
mcase = true;
keyword++;
}
n = match_keyword (s, keyword, mcase);
if (n) {
kw = &keywords[i];
break;
}
}
if (! kw)
return -PARSE_TIME_ERR_KEYWORD;
if (kw->set)
r = kw->set (state, kw);
else
r = set_field (state, kw->field, kw->value);
if (r < 0)
return r;
return n;
}
/*
* Non-keyword parsers and their helpers.
*/
static int
set_user_tz (struct state *state, char sign, int hour, int min)
{
int tz = hour * 60 + min;
assert (sign == '+' || sign == '-');
if (hour < 0 || hour > 14 || min < 0 || min > 59 || min % 15)
return -PARSE_TIME_ERR_INVALIDTIME;
if (sign == '-')
tz = -tz;
return set_field (state, TM_TZ, tz);
}
/*
* Parse a previously postponed number if one exists. Independent
* parsing of a postponed number when it wasn't consumed during
* parsing of the following token.
*/
static int
parse_postponed_number (struct state *state, unused (enum field next_field))
{
int v, n;
char d;
/* Bail out if there's no postponed number. */
if (! consume_postponed_number (state, &v, &n, &d))
return 0;
if (n == 1 || n == 2) {
/* Notable exception: Previous field affects parsing. This
* handles "January 20". */
if (state->last_field == TM_ABS_MON) {
/* D[D] */
if (! is_valid_mday (v))
return -PARSE_TIME_ERR_INVALIDDATE;
return set_field (state, TM_ABS_MDAY, v);
} else if (n == 2) {
/* XXX: Only allow if last field is hour, min, or sec? */
if (d == '+' || d == '-') {
/* +/-HH */
return set_user_tz (state, d, v, 0);
}
}
} else if (n == 4) {
/* Notable exception: Value affects parsing. Time zones are
* always at most 1400 and we don't understand years before
* 1970. */
if (! is_valid_year (v)) {
if (d == '+' || d == '-') {
/* +/-HHMM */
return set_user_tz (state, d, v / 100, v % 100);
}
} else {
/* YYYY */
return set_field (state, TM_ABS_YEAR, v);
}
} else if (n == 6) {
/* HHMMSS */
int hour = v / 10000;
int min = (v / 100) % 100;
int sec = v % 100;
if (! is_valid_time (hour, min, sec))
return -PARSE_TIME_ERR_INVALIDTIME;
return set_abs_time (state, hour, min, sec);
} else if (n == 8) {
/* YYYYMMDD */
int year = v / 10000;
int mon = (v / 100) % 100;
int mday = v % 100;
if (! is_valid_date (year, mon, mday))
return -PARSE_TIME_ERR_INVALIDDATE;
return set_abs_date (state, year, mon, mday);
}
return -PARSE_TIME_ERR_FORMAT;
}
static int tm_get_field (const struct tm *tm, enum field field);
static int
set_timestamp (struct state *state, time_t t)
{
struct tm tm;
enum field f;
int r;
if (gmtime_r (&t, &tm) == NULL)
return -PARSE_TIME_ERR_LIB;
for (f = TM_ABS_SEC; f != TM_NONE; f = next_abs_field (f)) {
r = set_field (state, f, tm_get_field (&tm, f));
if (r)
return r;
}
r = set_field (state, TM_TZ, 0);
if (r)
return r;
/* XXX: Prevent TM_AMPM with timestamp, e.g. "@123456 pm" */
return 0;
}
/* Parse a single number. Typically postpone parsing until later. */
static int
parse_single_number (struct state *state, unsigned long v,
unsigned long n)
{
assert (n);
if (state->delim == '@')
return set_timestamp (state, (time_t) v);
if (v > INT_MAX)
return -PARSE_TIME_ERR_FORMAT;
return set_postponed_number (state, v, n);
}
static bool
is_time_sep (char c)
{
return c == ':';
}
static bool
is_date_sep (char c)
{
return c == '/' || c == '-' || c == '.';
}
static bool
is_sep (char c)
{
return is_time_sep (c) || is_date_sep (c);
}
/* Two-digit year: 00...69 is 2000s, 70...99 1900s, if n == 0 keep
* unset. */
static int
expand_year (unsigned long year, size_t n)
{
if (n == 2) {
return (year < 70 ? 2000 : 1900) + year;
} else if (n == 4) {
return year;
} else {
return UNSET;
}
}
/* Parse a date number triplet. */
static int
parse_date (struct state *state, char sep,
unsigned long v1, unsigned long v2, unsigned long v3,
size_t n1, size_t n2, size_t n3)
{
int year = UNSET, mon = UNSET, mday = UNSET;
assert (is_date_sep (sep));
switch (sep) {
case '/': /* Date: M[M]/D[D][/YY[YY]] or M[M]/YYYY */
if (n1 != 1 && n1 != 2)
return -PARSE_TIME_ERR_DATEFORMAT;
if ((n2 == 1 || n2 == 2) && (n3 == 0 || n3 == 2 || n3 == 4)) {
/* M[M]/D[D][/YY[YY]] */
year = expand_year (v3, n3);
mon = v1;
mday = v2;
} else if (n2 == 4 && n3 == 0) {
/* M[M]/YYYY */
year = v2;
mon = v1;
} else {
return -PARSE_TIME_ERR_DATEFORMAT;
}
break;
case '-': /* Date: YYYY-MM[-DD] or DD-MM[-YY[YY]] or MM-YYYY */
if (n1 == 4 && n2 == 2 && (n3 == 0 || n3 == 2)) {
/* YYYY-MM[-DD] */
year = v1;
mon = v2;
if (n3)
mday = v3;
} else if (n1 == 2 && n2 == 2 && (n3 == 0 || n3 == 2 || n3 == 4)) {
/* DD-MM[-YY[YY]] */
year = expand_year (v3, n3);
mon = v2;
mday = v1;
} else if (n1 == 2 && n2 == 4 && n3 == 0) {
/* MM-YYYY */
year = v2;
mon = v1;
} else {
return -PARSE_TIME_ERR_DATEFORMAT;
}
break;
case '.': /* Date: D[D].M[M][.[YY[YY]]] */
if ((n1 != 1 && n1 != 2) || (n2 != 1 && n2 != 2) ||
(n3 != 0 && n3 != 2 && n3 != 4))
return -PARSE_TIME_ERR_DATEFORMAT;
year = expand_year (v3, n3);
mon = v2;
mday = v1;
break;
}
if (year != UNSET && ! is_valid_year (year))
return -PARSE_TIME_ERR_INVALIDDATE;
if (mon != UNSET && ! is_valid_mon (mon))
return -PARSE_TIME_ERR_INVALIDDATE;
if (mday != UNSET && ! is_valid_mday (mday))
return -PARSE_TIME_ERR_INVALIDDATE;
return set_abs_date (state, year, mon, mday);
}
/* Parse a time number triplet. */
static int
parse_time (struct state *state, char sep,
unsigned long v1, unsigned long v2, unsigned long v3,
size_t n1, size_t n2, size_t n3)
{
assert (is_time_sep (sep));
if ((n1 != 1 && n1 != 2) || n2 != 2 || (n3 != 0 && n3 != 2))
return -PARSE_TIME_ERR_TIMEFORMAT;
/*
* Notable exception: Previously set fields affect
* parsing. Interpret (+|-)HH:MM as time zone only if hour and
* minute have been set.
*
* XXX: This could be fixed by restricting the delimiters
* preceding time. For '+' it would be justified, but for '-' it
* might be inconvenient. However prefer to allow '-' as an
* insignificant delimiter preceding time for convenience, and
* handle '+' the same way for consistency between positive and
* negative time zones.
*/
if (is_field_set (state, TM_ABS_HOUR) &&
is_field_set (state, TM_ABS_MIN) &&
n1 == 2 && n2 == 2 && n3 == 0 &&
(state->delim == '+' || state->delim == '-')) {
return set_user_tz (state, state->delim, v1, v2);
}
if (! is_valid_time (v1, v2, n3 ? v3 : 0))
return -PARSE_TIME_ERR_INVALIDTIME;
return set_abs_time (state, v1, v2, n3 ? (int) v3 : UNSET);
}
/* strtoul helper that assigns length. */
static unsigned long
strtoul_len (const char *s, const char **endp, size_t *len)
{
unsigned long val = strtoul (s, (char **) endp, 10);
*len = *endp - s;
return val;
}
/*
* Parse a (group of) number(s). Return < 0 on error, number of parsed
* chars on success.
*/
static ssize_t
parse_number (struct state *state, const char *s)
{
int r;
unsigned long v1, v2, v3 = 0;
size_t n1, n2, n3 = 0;
const char *p = s;
char sep;
v1 = strtoul_len (p, &p, &n1);
if (! is_sep (*p) || ! isdigit ((unsigned char) *(p + 1))) {
/* A single number. */
r = parse_single_number (state, v1, n1);
if (r)
return r;
return p - s;
}
sep = *p;
v2 = strtoul_len (p + 1, &p, &n2);
/* A group of two or three numbers? */
if (*p == sep && isdigit ((unsigned char) *(p + 1)))
v3 = strtoul_len (p + 1, &p, &n3);
if (is_time_sep (sep))
r = parse_time (state, sep, v1, v2, v3, n1, n2, n3);
else
r = parse_date (state, sep, v1, v2, v3, n1, n2, n3);
if (r)
return r;
return p - s;
}
/*
* Parse delimiter(s). Throw away all except the last one, which is
* stored for parsing the next non-delimiter. Return < 0 on error,
* number of parsed chars on success.
*
* XXX: We might want to be more strict here.
*/
static ssize_t
parse_delim (struct state *state, const char *s)
{
const char *p = s;
/*
* Skip non-alpha and non-digit, and store the last for further
* processing.
*/
while (*p && ! isalnum ((unsigned char) *p)) {
set_delim (state, *p);
p++;
}
return p - s;
}
/*
* Parse a date/time string. Return < 0 on error, number of parsed
* chars on success.
*/
static ssize_t
parse_input (struct state *state, const char *s)
{
const char *p = s;
ssize_t n;
int r;
while (*p) {
if (isalpha ((unsigned char) *p)) {
n = parse_keyword (state, p);
} else if (isdigit ((unsigned char) *p)) {
n = parse_number (state, p);
} else {
n = parse_delim (state, p);
}
if (n <= 0) {
if (n == 0)
n = -PARSE_TIME_ERR;
return n;
}
p += n;
}
/* Parse a previously postponed number, if any. */
r = parse_postponed_number (state, TM_NONE);
if (r < 0)
return r;
return p - s;
}
/*
* Processing the parsed input.
*/
/*
* Initialize reference time to tm. Use time zone in state if
* specified, otherwise local time. Use now for reference time if
* non-NULL, otherwise current time.
*/
static int
initialize_now (struct state *state, const time_t *ref, struct tm *tm)
{
time_t t;
if (ref) {
t = *ref;
} else {
if (time (&t) == (time_t) -1)
return -PARSE_TIME_ERR_LIB;
}
if (is_field_set (state, TM_TZ)) {
/* Some other time zone. */
/* Adjust now according to the TZ. */
t += get_field (state, TM_TZ) * 60;
/* It's not gm, but this doesn't mess with the TZ. */
if (gmtime_r (&t, tm) == NULL)
return -PARSE_TIME_ERR_LIB;
} else {
/* Local time. */
if (localtime_r (&t, tm) == NULL)
return -PARSE_TIME_ERR_LIB;
}
return 0;
}
/*
* Normalize tm according to mktime(3); if structure members are
* outside their valid interval, they will be normalized (so that, for
* example, 40 October is changed into 9 November), and tm_wday and
* tm_yday are set to values determined from the contents of the other
* fields.
*
* Both mktime(3) and localtime_r(3) use local time, but they cancel
* each other out here, making this function agnostic to time zone.
*/
static int
normalize_tm (struct tm *tm)
{
time_t t = mktime (tm);
if (t == (time_t) -1)
return -PARSE_TIME_ERR_LIB;
if (! localtime_r (&t, tm))
return -PARSE_TIME_ERR_LIB;
return 0;
}
/* Get field out of a struct tm. */
static int
tm_get_field (const struct tm *tm, enum field field)
{
switch (field) {
case TM_ABS_SEC: return tm->tm_sec;
case TM_ABS_MIN: return tm->tm_min;
case TM_ABS_HOUR: return tm->tm_hour;
case TM_ABS_MDAY: return tm->tm_mday;
case TM_ABS_MON: return tm->tm_mon + 1; /* 0- to 1-based */
case TM_ABS_YEAR: return 1900 + tm->tm_year;
case TM_WDAY: return tm->tm_wday;
case TM_ABS_ISDST: return tm->tm_isdst;
default:
assert (false);
break;
}
return 0;
}
/* Modify hour according to am/pm setting. */
static int
fixup_ampm (struct state *state)
{
int hour, hdiff = 0;
if (! is_field_set (state, TM_AMPM))
return 0;
if (! is_field_set (state, TM_ABS_HOUR))
return -PARSE_TIME_ERR_TIMEFORMAT;
hour = get_field (state, TM_ABS_HOUR);
if (! is_valid_12hour (hour))
return -PARSE_TIME_ERR_INVALIDTIME;
if (get_field (state, TM_AMPM)) {
/* 12pm is noon. */
if (hour != 12)
hdiff = 12;
} else {
/* 12am is midnight, beginning of day. */
if (hour == 12)
hdiff = -12;
}
add_to_field (state, TM_REL_HOUR, -hdiff);
return 0;
}
/* Combine absolute and relative fields, and round. */
static int
create_output (struct state *state, time_t *t_out, const time_t *ref,
int round)
{
struct tm tm = { .tm_isdst = -1 };
struct tm now;
time_t t;
enum field f;
int r;
int week_round = PARSE_TIME_NO_ROUND;
r = initialize_now (state, ref, &now);
if (r)
return r;
/* Initialize fields flagged as "now" to reference time. */
for (f = TM_ABS_SEC; f != TM_NONE; f = next_abs_field (f)) {
if (state->set[f] == FIELD_NOW) {
state->tm[f] = tm_get_field (&now, f);
state->set[f] = FIELD_SET;
}
}
/*
* If WDAY is set but MDAY is not, we consider WDAY relative
*
* XXX: This fails on stuff like "two months monday" because two
* months ago wasn't the same day as today. Postpone until we know
* date?
*/
if (is_field_set (state, TM_WDAY) &&
! is_field_set (state, TM_ABS_MDAY)) {
int wday = get_field (state, TM_WDAY);
int today = tm_get_field (&now, TM_WDAY);
int rel_days;
if (today > wday)
rel_days = today - wday;
else
rel_days = today + 7 - wday;
/* This also prevents special week rounding from happening. */
add_to_field (state, TM_REL_DAY, rel_days);
unset_field (state, TM_WDAY);
}
r = fixup_ampm (state);
if (r)
return r;
/*
* Iterate fields from most accurate to least accurate, and set
* unset fields according to requested rounding.
*/
for (f = TM_ABS_SEC; f != TM_NONE; f = next_abs_field (f)) {
if (round != PARSE_TIME_NO_ROUND) {
enum field r = abs_to_rel_field (f);
if (is_field_set (state, f) || is_field_set (state, r)) {
if (round >= PARSE_TIME_ROUND_UP && f != TM_ABS_SEC) {
/*
* This is the most accurate field
* specified. Round up adjusting it towards
* future.
*/
add_to_field (state, r, -1);
/*
* Go back a second if the result is to be used
* for inclusive comparisons.
*/
if (round == PARSE_TIME_ROUND_UP_INCLUSIVE)
add_to_field (state, TM_REL_SEC, 1);
}
round = PARSE_TIME_NO_ROUND; /* No more rounding. */
} else {
if (f == TM_ABS_MDAY &&
is_field_set (state, TM_REL_WEEK)) {
/* Week is most accurate. */
week_round = round;
round = PARSE_TIME_NO_ROUND;
} else {
set_field (state, f, get_field_epoch_value (f));
}
}
}
if (! is_field_set (state, f))
set_field (state, f, tm_get_field (&now, f));
}
/* Special case: rounding with week accuracy. */
if (week_round != PARSE_TIME_NO_ROUND) {
/* Temporarily set more accurate fields to now. */
set_field (state, TM_ABS_SEC, tm_get_field (&now, TM_ABS_SEC));
set_field (state, TM_ABS_MIN, tm_get_field (&now, TM_ABS_MIN));
set_field (state, TM_ABS_HOUR, tm_get_field (&now, TM_ABS_HOUR));
set_field (state, TM_ABS_MDAY, tm_get_field (&now, TM_ABS_MDAY));
}
/*
* Set all fields. They may contain out of range values before
* normalization by mktime(3).
*/
tm.tm_sec = get_field (state, TM_ABS_SEC) - get_field (state, TM_REL_SEC);
tm.tm_min = get_field (state, TM_ABS_MIN) - get_field (state, TM_REL_MIN);
tm.tm_hour = get_field (state, TM_ABS_HOUR) - get_field (state, TM_REL_HOUR);
tm.tm_mday = get_field (state, TM_ABS_MDAY) -
get_field (state, TM_REL_DAY) - 7 * get_field (state, TM_REL_WEEK);
tm.tm_mon = get_field (state, TM_ABS_MON) - get_field (state, TM_REL_MON);
tm.tm_mon--; /* 1- to 0-based */
tm.tm_year = get_field (state, TM_ABS_YEAR) - get_field (state, TM_REL_YEAR) - 1900;
/*
* It's always normal time.
*
* XXX: This is probably not a solution that universally
* works. Just make sure DST is not taken into account. We don't
* want rounding to be affected by DST.
*/
tm.tm_isdst = -1;
/* Special case: rounding with week accuracy. */
if (week_round != PARSE_TIME_NO_ROUND) {
/* Normalize to get proper tm.wday. */
r = normalize_tm (&tm);
if (r < 0)
return r;
/* Set more accurate fields back to zero. */
tm.tm_sec = 0;
tm.tm_min = 0;
tm.tm_hour = 0;
tm.tm_isdst = -1;
/* Monday is the true 1st day of week, but this is easier. */
if (week_round >= PARSE_TIME_ROUND_UP) {
tm.tm_mday += 7 - tm.tm_wday;
if (week_round == PARSE_TIME_ROUND_UP_INCLUSIVE)
tm.tm_sec--;
} else {
tm.tm_mday -= tm.tm_wday;
}
}
if (is_field_set (state, TM_TZ)) {
/* tm is in specified TZ, convert to UTC for timegm(3). */
tm.tm_min -= get_field (state, TM_TZ);
t = timegm (&tm);
} else {
/* tm is in local time. */
t = mktime (&tm);
}
if (t == (time_t) -1)
return -PARSE_TIME_ERR_LIB;
*t_out = t;
return 0;
}
/* Internally, all errors are < 0. parse_time_string() returns errors > 0. */
#define EXTERNAL_ERR(r) (-r)
int
parse_time_string (const char *s, time_t *t, const time_t *ref, int round)
{
struct state state = { .last_field = TM_NONE };
int r;
if (! s || ! t)
return EXTERNAL_ERR (-PARSE_TIME_ERR);
r = parse_input (&state, s);
if (r < 0)
return EXTERNAL_ERR (r);
r = create_output (&state, t, ref, round);
if (r < 0)
return EXTERNAL_ERR (r);
return 0;
}
Reference in a new issue View git blame Copy permalink