timelib.h

Go to the documentation of this file.

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015-2024 Derick Rethans
 * Copyright (c) 2018,2021 MongoDB, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#ifndef __TIMELIB_H__
#define __TIMELIB_H__
 
#ifdef HAVE_TIMELIB_CONFIG_H
# include "timelib_config.h"
#endif
 
#define TIMELIB_VERSION 202212
#define TIMELIB_EXTENDED_VERSION 20221201
#define TIMELIB_ASCII_VERSION "2022.12"
 
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h>
#include <inttypes.h>
 
# ifndef HAVE_INT32_T
#  if SIZEOF_INT == 4
typedef int int32_t;
#  elif SIZEOF_LONG == 4
typedef long int int32_t;
#  endif
# endif
 
# ifndef HAVE_UINT32_T
#  if SIZEOF_INT == 4
typedef unsigned int uint32_t;
#  elif SIZEOF_LONG == 4
typedef unsigned long int uint32_t;
#  endif
# endif
 
#ifdef _WIN32
# if _MSC_VER >= 1600
# include <stdint.h>
# endif
# ifndef SIZEOF_INT
#  define SIZEOF_INT 4
# endif
# ifndef SIZEOF_LONG
#  define SIZEOF_LONG 4
# endif
# ifndef int32_t
typedef __int32           int32_t;
# endif
# ifndef uint32_t
typedef unsigned __int32  uint32_t;
# endif
# ifndef int64_t
typedef __int64           int64_t;
# endif
# ifndef uint64_t
typedef unsigned __int64  uint64_t;
# endif
# ifndef PRId32
#  define PRId32       "I32d"
# endif
# ifndef PRIu32
#  define PRIu32       "I32u"
# endif
# ifndef PRId64
#  define PRId64       "I64d"
# endif
# ifndef PRIu64
#  define PRIu64       "I64u"
# endif
# ifndef INT32_MAX
#define INT32_MAX    _I32_MAX
# endif
# ifndef INT32_MIN
#define INT32_MIN    ((int32_t)_I32_MIN)
# endif
# ifndef UINT32_MAX
#define UINT32_MAX   _UI32_MAX
# endif
# ifndef INT64_MIN
#define INT64_MIN    ((int64_t)_I64_MIN)
# endif
# ifndef INT64_MAX
#define INT64_MAX    _I64_MAX
# endif
# ifndef UINT64_MAX
#define UINT64_MAX   _UI64_MAX
# endif
#endif
 
#if (defined(__x86_64__) || defined(__LP64__) || defined(_LP64) || defined(_WIN64)) && !defined(TIMELIB_FORCE_LONG32)
typedef int64_t timelib_long;
typedef uint64_t timelib_ulong;
# define TIMELIB_LONG_MAX INT64_MAX
# define TIMELIB_LONG_MIN INT64_MIN
# define TIMELIB_ULONG_MAX UINT64_MAX
# define TIMELIB_LONG_FMT "%" PRId64
# define TIMELIB_ULONG_FMT "%" PRIu64
#else
typedef int32_t timelib_long;
typedef uint32_t timelib_ulong;
# define TIMELIB_LONG_MAX INT32_MAX
# define TIMELIB_LONG_MIN INT32_MIN
# define TIMELIB_ULONG_MAX UINT32_MAX
# define TIMELIB_LONG_FMT "%" PRId32
# define TIMELIB_ULONG_FMT "%" PRIu32
#endif
 
#if defined(_MSC_VER)
typedef uint64_t timelib_ull;
typedef int64_t timelib_sll;
# define TIMELIB_LL_CONST(n) n ## i64
#else
typedef unsigned long long timelib_ull;
typedef signed long long timelib_sll;
# define TIMELIB_LL_CONST(n) n ## ll
#endif
 
typedef struct _ttinfo ttinfo;
typedef struct _tlinfo tlinfo;
 
typedef struct _tlocinfo
{
    char country_code[3];
    double latitude;
    double longitude;
    char *comments;
} tlocinfo;
 
#define TIMELIB_POSIX_TRANS_TYPE_JULIAN_NO_FEB29   1
#define TIMELIB_POSIX_TRANS_TYPE_JULIAN_FEB29      2
#define TIMELIB_POSIX_TRANS_TYPE_MWD               3
 
typedef struct _timelib_posix_trans_info
{
    int type; // 1=Jn, 2=n, 3=Mm.w.d
    union {
        int days;
        struct {
            int month;
            int week;
            int dow;
        } mwd;
    };
    int hour;
} timelib_posix_trans_info;
 
typedef struct _timelib_posix_str
{
    char        *std;
    timelib_sll  std_offset;
    char        *dst;
    timelib_sll  dst_offset;
 
    timelib_posix_trans_info *dst_begin;
    timelib_posix_trans_info *dst_end;
 
    int type_index_std_type;  // index into tz->type
    int type_index_dst_type;  // index into tz->type
} timelib_posix_str;
 
typedef struct _timelib_posix_transitions {
    size_t      count;
    timelib_sll times[6];
    timelib_sll types[6];
} timelib_posix_transitions;
 
typedef struct _timelib_tzinfo
{
    char    *name;
    struct {
        uint32_t ttisgmtcnt;
        uint32_t ttisstdcnt;
        uint32_t leapcnt;
        uint32_t timecnt;
        uint32_t typecnt;
        uint32_t charcnt;
    } _bit32;
    struct {
        uint64_t ttisgmtcnt;
        uint64_t ttisstdcnt;
        uint64_t leapcnt;
        uint64_t timecnt;
        uint64_t typecnt;
        uint64_t charcnt;
    } bit64;
 
    int64_t *trans;
    unsigned char *trans_idx;
 
    ttinfo  *type;
    char    *timezone_abbr;
 
    tlinfo  *leap_times;
    unsigned char bc;
    tlocinfo location;
 
    char              *posix_string;
    timelib_posix_str *posix_info;
} timelib_tzinfo;
 
typedef struct _timelib_rel_time {
    timelib_sll y, m, d; /* Years, Months and Days */
    timelib_sll h, i, s; /* Hours, mInutes and Seconds */
    timelib_sll us;      /* Microseconds */
 
    int weekday; /* Stores the day in 'next monday' */
    int weekday_behavior; /* 0: the current day should *not* be counted when advancing forwards; 1: the current day *should* be counted */
 
    int first_last_day_of;
    int invert; /* Whether the difference should be inverted */
    timelib_sll days; /* Contains the number of *days*, instead of Y-M-D differences */
 
    struct {
        unsigned int type;
        timelib_sll amount;
    } special;
 
    unsigned int   have_weekday_relative, have_special_relative;
} timelib_rel_time;
 
typedef struct _timelib_time_offset {
    int32_t      offset;
    unsigned int leap_secs;
    unsigned int is_dst;
    char        *abbr;
    timelib_sll  transition_time;
} timelib_time_offset;
 
typedef struct _timelib_time {
    timelib_sll      y, m, d;     /* Year, Month, Day */
    timelib_sll      h, i, s;     /* Hour, mInute, Second */
    timelib_sll      us;          /* Microseconds */
    int              z;           /* UTC offset in seconds */
    char            *tz_abbr;     /* Timezone abbreviation (display only) */
    timelib_tzinfo  *tz_info;     /* Timezone structure */
    signed int       dst;         /* Flag if we were parsing a DST zone */
    timelib_rel_time relative;
 
    timelib_sll      sse;         /* Seconds since epoch */
 
    unsigned int   have_time, have_date, have_zone, have_relative, have_weeknr_day;
 
    unsigned int   sse_uptodate; /* !0 if the sse member is up to date with the date/time members */
    unsigned int   tim_uptodate; /* !0 if the date/time members are up to date with the sse member */
    unsigned int   is_localtime; /*  1 if the current struct represents localtime, 0 if it is in GMT */
    unsigned int   zone_type;    /*  1 time offset,
                                  *  3 TimeZone identifier,
                                  *  2 TimeZone abbreviation */
} timelib_time;
 
typedef struct _timelib_abbr_info {
    timelib_sll  utc_offset;
    char        *abbr;
    int          dst;
} timelib_abbr_info;
 
#define TIMELIB_WARN_MASK                      0x1ff
#define TIMELIB_ERR_MASK                       0x2ff
 
#define TIMELIB_WARN_DOUBLE_TZ                 0x101
#define TIMELIB_WARN_INVALID_TIME              0x102
#define TIMELIB_WARN_INVALID_DATE              0x103
#define TIMELIB_WARN_TRAILING_DATA             0x11a
 
#define TIMELIB_ERR_DOUBLE_TZ                  0x201
#define TIMELIB_ERR_TZID_NOT_FOUND             0x202
#define TIMELIB_ERR_DOUBLE_TIME                0x203
#define TIMELIB_ERR_DOUBLE_DATE                0x204
#define TIMELIB_ERR_UNEXPECTED_CHARACTER       0x205
#define TIMELIB_ERR_EMPTY_STRING               0x206
#define TIMELIB_ERR_UNEXPECTED_DATA            0x207
#define TIMELIB_ERR_NO_TEXTUAL_DAY             0x208
#define TIMELIB_ERR_NO_TWO_DIGIT_DAY           0x209
#define TIMELIB_ERR_NO_THREE_DIGIT_DAY_OF_YEAR 0x20a
#define TIMELIB_ERR_NO_TWO_DIGIT_MONTH         0x20b
#define TIMELIB_ERR_NO_TEXTUAL_MONTH           0x20c
#define TIMELIB_ERR_NO_TWO_DIGIT_YEAR          0x20d
#define TIMELIB_ERR_NO_FOUR_DIGIT_YEAR         0x20e
#define TIMELIB_ERR_NO_TWO_DIGIT_HOUR          0x20f
#define TIMELIB_ERR_HOUR_LARGER_THAN_12        0x210
#define TIMELIB_ERR_MERIDIAN_BEFORE_HOUR       0x211
#define TIMELIB_ERR_NO_MERIDIAN                0x212
#define TIMELIB_ERR_NO_TWO_DIGIT_MINUTE        0x213
#define TIMELIB_ERR_NO_TWO_DIGIT_SECOND        0x214
#define TIMELIB_ERR_NO_SIX_DIGIT_MICROSECOND   0x215
#define TIMELIB_ERR_NO_SEP_SYMBOL              0x216
#define TIMELIB_ERR_EXPECTED_ESCAPE_CHAR       0x217
#define TIMELIB_ERR_NO_ESCAPED_CHAR            0x218
#define TIMELIB_ERR_WRONG_FORMAT_SEP           0x219
#define TIMELIB_ERR_TRAILING_DATA              0x21a
#define TIMELIB_ERR_DATA_MISSING               0x21b
#define TIMELIB_ERR_NO_THREE_DIGIT_MILLISECOND 0x21c
#define TIMELIB_ERR_NO_FOUR_DIGIT_YEAR_ISO     0x21d
#define TIMELIB_ERR_NO_TWO_DIGIT_WEEK          0x21e
#define TIMELIB_ERR_INVALID_WEEK               0x21f
#define TIMELIB_ERR_NO_DAY_OF_WEEK             0x220
#define TIMELIB_ERR_INVALID_DAY_OF_WEEK        0x221
#define TIMELIB_ERR_INVALID_SPECIFIER          0x222
#define TIMELIB_ERR_INVALID_TZ_OFFSET          0x223
#define TIMELIB_ERR_FORMAT_LITERAL_MISMATCH    0x224
#define TIMELIB_ERR_MIX_ISO_WITH_NATURAL       0x225
#define TIMELIB_ERR_NUMBER_OUT_OF_RANGE        0x226
 
#define TIMELIB_ZONETYPE_NONE   0
#define TIMELIB_ZONETYPE_OFFSET 1
#define TIMELIB_ZONETYPE_ABBR   2
#define TIMELIB_ZONETYPE_ID     3
 
typedef struct _timelib_error_message {
    int         error_code;
    int         position;
    char        character;
    char       *message;
} timelib_error_message;
 
typedef struct _timelib_error_container {
    timelib_error_message *error_messages;
    timelib_error_message *warning_messages;
    int                    error_count;
    int                    warning_count;
} timelib_error_container;
 
typedef struct _timelib_tz_lookup_table {
    const char *name;
    int         type;
    float       gmtoffset;
    const char *full_tz_name;
} timelib_tz_lookup_table;
 
typedef struct _timelib_tzdb_index_entry {
    char *id;
    unsigned int pos;
} timelib_tzdb_index_entry;
 
typedef struct _timelib_tzdb {
    const char                     *version;
    int                             index_size;
    const timelib_tzdb_index_entry *index;
    const unsigned char            *data;
} timelib_tzdb;
 
#ifndef timelib_malloc
# define timelib_malloc  malloc
# define timelib_realloc realloc
# define timelib_calloc  calloc
# define timelib_strdup  strdup
# define timelib_free    free
# if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
#  define TIMELIB_USE_BUILTIN_STRNDUP 1
# else
#  define TIMELIB_USE_BUILTIN_STRNDUP 0
#  define timelib_strndup strndup
# endif
#endif
 
#define TIMELIB_NONE             0x00
#define TIMELIB_OVERRIDE_TIME    0x01
#define TIMELIB_NO_CLONE         0x02
 
#define TIMELIB_UNSET   -9999999
 
/* An entry for each of these error codes is also in the
 * timelib_error_messages array in timelib.c.
 * Codes 0x00, 0x07, and 0x09 are warnings only. */
#define TIMELIB_ERROR_NO_ERROR                            0x00
#define TIMELIB_ERROR_CANNOT_ALLOCATE                     0x01
#define TIMELIB_ERROR_CORRUPT_TRANSITIONS_DONT_INCREASE   0x02
#define TIMELIB_ERROR_CORRUPT_NO_64BIT_PREAMBLE           0x03
#define TIMELIB_ERROR_CORRUPT_NO_ABBREVIATION             0x04
#define TIMELIB_ERROR_UNSUPPORTED_VERSION                 0x05
#define TIMELIB_ERROR_NO_SUCH_TIMEZONE                    0x06
#define TIMELIB_ERROR_SLIM_FILE                           0x07 /* Warns if the file is SLIM, but we can't read it */
#define TIMELIB_ERROR_CORRUPT_POSIX_STRING                0x08
#define TIMELIB_ERROR_EMPTY_POSIX_STRING                  0x09 /* Warns if the POSIX string is empty, but still produces results */
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum _timelib_format_specifier_code {
    TIMELIB_FORMAT_ALLOW_EXTRA_CHARACTERS = 0,
    TIMELIB_FORMAT_ANY_SEPARATOR,
    TIMELIB_FORMAT_DAY_TWO_DIGIT,
    TIMELIB_FORMAT_DAY_TWO_DIGIT_PADDED,
    TIMELIB_FORMAT_DAY_OF_WEEK_ISO,
    TIMELIB_FORMAT_DAY_OF_WEEK,
    TIMELIB_FORMAT_DAY_OF_YEAR,
    TIMELIB_FORMAT_DAY_SUFFIX,
    TIMELIB_FORMAT_END,
    TIMELIB_FORMAT_EPOCH_SECONDS,
    TIMELIB_FORMAT_ESCAPE,
    TIMELIB_FORMAT_HOUR_TWO_DIGIT_12_MAX,
    TIMELIB_FORMAT_HOUR_TWO_DIGIT_12_MAX_PADDED,
    TIMELIB_FORMAT_HOUR_TWO_DIGIT_24_MAX,
    TIMELIB_FORMAT_HOUR_TWO_DIGIT_24_MAX_PADDED,
    TIMELIB_FORMAT_LITERAL,
    TIMELIB_FORMAT_MERIDIAN,
    TIMELIB_FORMAT_MICROSECOND_SIX_DIGIT,
    TIMELIB_FORMAT_MILLISECOND_THREE_DIGIT,
    TIMELIB_FORMAT_MINUTE_TWO_DIGIT,
    TIMELIB_FORMAT_MONTH_TWO_DIGIT,
    TIMELIB_FORMAT_MONTH_TWO_DIGIT_PADDED,
    TIMELIB_FORMAT_RANDOM_CHAR,
    TIMELIB_FORMAT_RESET_ALL,
    TIMELIB_FORMAT_RESET_ALL_WHEN_NOT_SET,
    TIMELIB_FORMAT_SECOND_TWO_DIGIT,
    TIMELIB_FORMAT_SEPARATOR,
    TIMELIB_FORMAT_SKIP_TO_SEPARATOR,
    TIMELIB_FORMAT_TEXTUAL_DAY_3_LETTER,
    TIMELIB_FORMAT_TEXTUAL_DAY_FULL,
    TIMELIB_FORMAT_TEXTUAL_MONTH_3_LETTER,
    TIMELIB_FORMAT_TEXTUAL_MONTH_FULL,
    TIMELIB_FORMAT_TIMEZONE_OFFSET,
    TIMELIB_FORMAT_TIMEZONE_OFFSET_MINUTES,
    TIMELIB_FORMAT_WEEK_OF_YEAR_ISO,
    TIMELIB_FORMAT_WEEK_OF_YEAR,
    TIMELIB_FORMAT_WHITESPACE,
    TIMELIB_FORMAT_YEAR_TWO_DIGIT,
    TIMELIB_FORMAT_YEAR_FOUR_DIGIT,
    TIMELIB_FORMAT_YEAR_EXPANDED,
    TIMELIB_FORMAT_YEAR_ISO
} timelib_format_specifier_code;
 
typedef struct _timelib_format_specifier {
    char                          specifier;
    timelib_format_specifier_code code;
} timelib_format_specifier;
 
typedef struct _timelib_format_config {
    const timelib_format_specifier *format_map;
    /* Format speciifiers must be preceded by 'prefix_char' if not '\0'. */
    char                            prefix_char;
} timelib_format_config;
 
/* Function pointers */
typedef timelib_tzinfo* (*timelib_tz_get_wrapper)(const char *tzname, const timelib_tzdb *tzdb, int *error_code);
 
/* From dow.c */
/* Calculates the day of the week from y, m, and d. 0=Sunday..6=Saturday */
timelib_sll timelib_day_of_week(timelib_sll y, timelib_sll m, timelib_sll d);
 
/* Calculates the day of the ISO week from y, m, and d. 1=Monday, 7=Sunday */
timelib_sll timelib_iso_day_of_week(timelib_sll y, timelib_sll m, timelib_sll d);
 
/* Calculates the day of the year according to y-m-d. 0=Jan 1st..364/365=Dec
 * 31st */
timelib_sll timelib_day_of_year(timelib_sll y, timelib_sll m, timelib_sll d);
 
/* Calculates the day of the year according to y-w-dow. 0..364/365 */
timelib_sll timelib_daynr_from_weeknr(timelib_sll iy, timelib_sll iw, timelib_sll id);
 
/* Calculates the number of days in month m for year y. 28..31 */
timelib_sll timelib_days_in_month(timelib_sll y, timelib_sll m);
 
/* Calculates the ISO year and week from y, m, and d, into iw and iy */
void timelib_isoweek_from_date(timelib_sll y, timelib_sll m, timelib_sll d, timelib_sll *iw, timelib_sll *iy);
 
/* Calculates the ISO year, week, and day of week from y, m, and d, into iy,
 * iw, and id */
void timelib_isodate_from_date(timelib_sll y, timelib_sll m, timelib_sll d, timelib_sll *iy, timelib_sll *iw, timelib_sll *id);
 
/* Calculates the year, month, and day from iy, iw, and iw, into y, m, and d */
void timelib_date_from_isodate(timelib_sll iy, timelib_sll iw, timelib_sll id, timelib_sll *y, timelib_sll *m, timelib_sll *d);
 
/* Returns true if h, i and s fit in the range 00:00:00..23:59:59, false
 * otherwise */
int timelib_valid_time(timelib_sll h, timelib_sll i, timelib_sll s);
 
/* Returns true if m fits in the range 1..12, and d fits in the range
 * 1..<days-in-month> for year y */
int timelib_valid_date(timelib_sll y, timelib_sll m, timelib_sll d);
 
/* From parse_date.re */
 
/* Parses the date/time string in 's' with length 'len' into the constituent
 * parts of timelib_time*.
 *
 * Depending on the contents of the string 's', not all elements might be
 * filled. You can check whether a specific element has been parsed by
 * comparing with the TIMELIB_UNSET define.
 *
 * If errors occur, this function keeps already parsed elements in the
 * returned timelib_time* value.
 *
 * If the **errors points to a timelib_error_container variable, warnings
 * and errors will be recorded. You are responsible for freeing the stored
 * information with timelib_error_container_dtor(). To see whether errors have
 * occurred, inspect errors->errors_count. To see whether warnings have occurred,
 * inspect errors->warnings_count.
 *
 * The returned timelib_time* value is dynamically allocated and should be
 * freed with timelib_time_dtor().
 */
timelib_time *timelib_strtotime(const char *s, size_t len, timelib_error_container **errors, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_get_wrapper);
 
/* Parses the date/time string in 's' with length 'len' into the constituent
 * parts of timelib_time* according to the format in 'format'.
 *
 * Depending on the contents of the string 's', not all elements might be
 * filled. You can check whether a specific element has been parsed by
 * comparing with the TIMELIB_UNSET define.
 *
 * If errors occur, this function keeps already parsed elements in the
 * returned timelib_time* value.
 *
 * If the **errors points to a timelib_error_container variable, warnings
 * and errors will be recorded. You are responsible for freeing the stored
 * information with timelib_error_container_dtor(). To see whether errors have
 * occurred, inspect errors->errors_count. To see whether warnings have occurred,
 * inspect errors->warnings_count.
 *
 * The returned timelib_time* value is dynamically allocated and should be
 * freed with timelib_time_dtor().
 */
timelib_time *timelib_parse_from_format(const char *format, const char *s, size_t len, timelib_error_container **errors, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_get_wrapper);
 
/* Parses the date/time string in 's' with length 'len' into the constituent
 * parts of timelib_time* according to the format in 'format' with format
 * specifier configuration 'format_config'.
 *
 * 'format_map' is an array of pairs, with the first element being the format
 * specifier as a character and the second element corresponds to the
 * representation of the specifier from the enum list
 * 'timelib_format_specifier_code'.
 *
 * Note: 'format_map' must be terminated with specifier '\0' to indicate to the
 * parser that there are no more format specifiers in the list.
 */
timelib_time *timelib_parse_from_format_with_map(const char *format, const char *s, size_t len, timelib_error_container **errors, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_get_wrapper, const timelib_format_config* format_config);
 
/* Fills the gaps in the parsed timelib_time with information from the reference date/time in 'now'
 *
 * If any of the 'parsed' y, m, d, h, i or s parameters is unset (TIMELIB_UNSET):
 * - if microtime (us) is unset, then the us of the parsed time is set to 0.
 * - else if microtime (us) is unset and 'now'->'us' is set, use it, otherwise use 0.
 *
 * For either of the 'parsed' y, m, d, h, i, s, z (utc offset in seconds) or
 * dst is unset, set it to the corresponding value in 'now' if set, otherwise
 * set it to 0.
 *
 * It duplicates tz_abbr if unset in 'parsed' but set in 'now'.
 *
 * It duplicates tz_info if unset in 'parsed', but set in 'now' unless
 * TIMELIB_NO_CLONE is passed, in which case only the pointer in 'parsed' is
 * set to 'now'.
 *
 * If the option TIMELIB_OVERRIDE_TIME is passed and the parsed date/time has
 * no time portion, the function will ignore the time aspect in 'now' and
 * instead fill it with zeros.
 */
void timelib_fill_holes(timelib_time *parsed, timelib_time *now, int options);
 
/* Tries to convert a time zone abbreviation, gmtoffset and/or isdst flag
 * combination to a time zone identifier.
 *
 * If 'abbr' is either 'utc' or 'gmt' (case insensitve) then "UTC" is
 * returned.
 *
 * It first uses the data in the timezonemap.h file to find a matching
 * abbreviation/GMT offset combination. If not found, it uses the data in
 * fallbackmap.h to match only the GMT offset/isdst flag to try to find a
 * match. If nothing is found, NULL is returned.
 *
 * The returned char* is not duplicated, and should not be freed.
 */
const char *timelib_timezone_id_from_abbr(const char *abbr, timelib_long gmtoffset, int isdst);
 
/* Returns an array of known time zone abbreviations
 *
 * This file is generated from the time zone database through the
 * gettzmapping.php scripts, which requires that an up-to-date time zone
 * database is used with the PHP binary that runs the script.
 *
 * Each item in the returned list contains the abbreviation, a flag whether
 * it's an abbreviation used with DST, the UTC offset in seconds, and the name
 * of the time zone identifier that this abbreviation belongs to.
 *
 * The order for each specific abbreviation is controlled through the
 * preference list in the gettzmapping.php script. Time zones that match the
 * pattern ±\d{2,4} are excluded
 */
const timelib_tz_lookup_table *timelib_timezone_abbreviations_list(void);

timelib_long timelib_parse_zone(const char **ptr, int *dst, timelib_time *t, int *tz_not_found, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_wrapper);
 
/* From parse_iso_intervals.re */

void timelib_strtointerval(const char *s, size_t len,
                           timelib_time **begin, timelib_time **end,
                           timelib_rel_time **period, int *recurrences,
                           timelib_error_container **errors);
 
 
/* From tm2unixtime.c */

void timelib_update_ts(timelib_time* time, timelib_tzinfo* tzi);

timelib_sll timelib_epoch_days_from_time(timelib_time *time);

void timelib_do_normalize(timelib_time *base);

void timelib_do_rel_normalize(timelib_time *base, timelib_rel_time *rt);
 
/* From unixtime2tm.c */

void timelib_unixtime2date(timelib_sll ts, timelib_sll *y, timelib_sll *m, timelib_sll *d);

void timelib_unixtime2gmt(timelib_time* tm, timelib_sll ts);

void timelib_unixtime2local(timelib_time *tm, timelib_sll ts);

void timelib_update_from_sse(timelib_time *tm);

void timelib_set_timezone_from_offset(timelib_time *t, timelib_sll utc_offset);

void timelib_set_timezone_from_abbr(timelib_time *t, timelib_abbr_info abbr_info);

void timelib_set_timezone(timelib_time *t, timelib_tzinfo *tz);
 
/* From parse_tz.c */

int timelib_timezone_id_is_valid(const char *timezone, const timelib_tzdb *tzdb);

timelib_tzinfo *timelib_parse_tzfile(const char *timezone, const timelib_tzdb *tzdb, int *error_code);

void timelib_tzinfo_dtor(timelib_tzinfo *tz);

timelib_tzinfo* timelib_tzinfo_clone(timelib_tzinfo *tz);

int timelib_timestamp_is_in_dst(timelib_sll ts, timelib_tzinfo *tz);

timelib_time_offset *timelib_get_time_zone_info(timelib_sll ts, timelib_tzinfo *tz);

int timelib_get_time_zone_offset_info(timelib_sll ts, timelib_tzinfo *tz, int32_t* offset, timelib_sll* transition_time, unsigned int* is_dst);

timelib_sll timelib_get_current_offset(timelib_time *t);

int timelib_same_timezone(timelib_time *one, timelib_time *two);

void timelib_dump_tzinfo(timelib_tzinfo *tz);

const timelib_tzdb *timelib_builtin_db(void);

const timelib_tzdb_index_entry *timelib_timezone_identifiers_list(const timelib_tzdb *tzdb, int *count);
 
/* From parse_zoneinfo.c */

timelib_tzdb *timelib_zoneinfo(const char *directory);

void timelib_zoneinfo_dtor(timelib_tzdb *tzdb);
 
/* From timelib.c */

const char *timelib_get_error_message(int error_code);

timelib_rel_time* timelib_rel_time_ctor(void);

void timelib_rel_time_dtor(timelib_rel_time* t);

timelib_rel_time* timelib_rel_time_clone(timelib_rel_time *tz);

timelib_time* timelib_time_ctor(void);

void timelib_time_dtor(timelib_time* t);

timelib_time* timelib_time_clone(timelib_time* orig);

int timelib_time_compare(timelib_time *t1, timelib_time *t2);

timelib_time_offset* timelib_time_offset_ctor(void);

void timelib_time_offset_dtor(timelib_time_offset* t);

void timelib_error_container_dtor(timelib_error_container *errors);

timelib_long timelib_date_to_int(timelib_time *d, int *error);

void timelib_dump_date(timelib_time *d, int options);

void timelib_dump_rel_time(timelib_rel_time *d);

void timelib_decimal_hour_to_hms(double h, int *hour, int *min, int *sec);

void timelib_hms_to_decimal_hour(int hour, int min, int sec, double *h);

void timelib_hmsf_to_decimal_hour(int hour, int min, int sec, int us, double *h);

timelib_sll timelib_hms_to_seconds(timelib_sll h, timelib_sll m, timelib_sll s);
 
 
/* from astro.c */

double timelib_ts_to_julianday(timelib_sll ts);

double timelib_ts_to_j2000(timelib_sll ts);

int timelib_astro_rise_set_altitude(timelib_time *time, double lon, double lat, double altit, int upper_limb, double *h_rise, double *h_set, timelib_sll *ts_rise, timelib_sll *ts_set, timelib_sll *ts_transit);
 
/* from interval.c */

timelib_rel_time *timelib_diff(timelib_time *one, timelib_time *two);

int timelib_diff_days(timelib_time *one, timelib_time *two);

timelib_time *timelib_add(timelib_time *t, timelib_rel_time *interval);
timelib_time *timelib_add_wall(timelib_time *t, timelib_rel_time *interval);

timelib_time *timelib_sub(timelib_time *t, timelib_rel_time *interval);
timelib_time *timelib_sub_wall(timelib_time *t, timelib_rel_time *interval);
 
/* from parse_posix.c */
 
void timelib_posix_str_dtor(timelib_posix_str *ps);
 
timelib_posix_str* timelib_parse_posix_str(const char *posix);

void timelib_get_transitions_for_year(timelib_tzinfo *tz, timelib_sll year, timelib_posix_transitions *transitions);
 
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif