date.c File Reference

Time and date handling routines. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include "date.h"
#include "buffer.h"
#include "logging.h"
#include "memory.h"
#include "prex.h"
#include "regex3.h"
#include "string2.h"

Include dependency graph for date.c:

Go to the source code of this file.

Functions
static int	compute_tz (time_t g, struct tm *utc)
	Calculate the number of seconds east of UTC. More...
static time_t	add_tz_offset (time_t t, bool w, time_t h, time_t m)
	Compute and add a timezone offset to an UTC time. More...
static const struct Tz *	find_tz (const char *s, size_t len)
	Look up a timezone. More...
static int	is_leap_year_feb (struct tm *tm)
	Is a given February in a leap year. More...
int	mutt_date_local_tz (time_t t)
	Calculate the local timezone in seconds east of UTC. More...
time_t	mutt_date_make_time (struct tm *t, bool local)
	Convert struct tm to time_t More...
void	mutt_date_normalize_time (struct tm *tm)
	Fix the contents of a struct tm. More...
void	mutt_date_make_date (struct Buffer *buf, bool local)
	Write a date in RFC822 format to a buffer. More...
int	mutt_date_check_month (const char *s)
	Is the string a valid month name. More...
time_t	mutt_date_epoch (void)
	Return the number of seconds since the Unix epoch. More...
uint64_t	mutt_date_epoch_ms (void)
	Return the number of milliseconds since the Unix epoch. More...
time_t	mutt_date_parse_date (const char *s, struct Tz *tz_out)
	Parse a date string in RFC822 format. More...
int	mutt_date_make_imap (char *buf, size_t buflen, time_t timestamp)
	Format date in IMAP style: DD-MMM-YYYY HH:MM:SS +ZZzz. More...
int	mutt_date_make_tls (char *buf, size_t buflen, time_t timestamp)
	Format date in TLS certificate verification style. More...
time_t	mutt_date_parse_imap (const char *s)
	Parse date of the form: DD-MMM-YYYY HH:MM:SS +ZZzz. More...
time_t	mutt_date_add_timeout (time_t now, time_t timeout)
	Safely add a timeout to a given time_t value. More...
struct tm	mutt_date_localtime (time_t t)
	Converts calendar time to a broken-down time structure expressed in user timezone. More...
struct tm	mutt_date_gmtime (time_t t)
	Converts calendar time to a broken-down time structure expressed in UTC timezone. More...
size_t	mutt_date_localtime_format (char *buf, size_t buflen, const char *format, time_t t)
	Format localtime. More...
void	mutt_date_sleep_ms (size_t ms)
	Sleep for milliseconds. More...

Variables
static const char *const	Weekdays []
	Day of the week (abbreviated) More...
static const char *const	Months []
	Months of the year (abbreviated) More...
static const struct Tz	TimeZones []
	Lookup table of Time Zones. More...

Detailed Description

Time and date handling routines.

Authors

• Michael R. Elkins

Copyright

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 http://www.gnu.org/licenses/.

Definition in file date.c.

Function Documentation

compute_tz()

static int compute_tz ( time_t  g, struct tm *  utc  )

static

Calculate the number of seconds east of UTC.

Parameters

g	Local time
utc	UTC time

Return values

num	Seconds east of UTC

returns the seconds east of UTC given 'g' and its corresponding gmtime() representation

Definition at line 127 of file date.c.

{
  struct tm lt = mutt_date_localtime(g);
 
  int tz = (((lt.tm_hour - utc->tm_hour) * 60) + (lt.tm_min - utc->tm_min)) * 60;
 
  int yday = (lt.tm_yday - utc->tm_yday);
  if (yday != 0)
  {
    /* This code is optimized to negative timezones (West of Greenwich) */
    if ((yday == -1) || /* UTC passed midnight before localtime */
        (yday > 1))     /* UTC passed new year before localtime */
    {
      tz -= (24 * 60 * 60);
    }
    else
    {
      tz += (24 * 60 * 60);
    }
  }
 
  return tz;
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_tz_offset()

static time_t add_tz_offset ( time_t  t, bool  w, time_t  h, time_t  m  )

static

Compute and add a timezone offset to an UTC time.

Parameters

t	UTC time
w	True if west of UTC, false if east
h	Number of hours in the timezone
m	Number of minutes in the timezone

Return values

num	Timezone offset in seconds

Definition at line 159 of file date.c.

{
  if ((t != TIME_T_MAX) && (t != TIME_T_MIN))
    return t + (w ? 1 : -1) * (((time_t) h * 3600) + ((time_t) m * 60));
  else
    return t;
}

Here is the caller graph for this function:

find_tz()

static const struct Tz * find_tz ( const char *  s, size_t  len  )

static

Look up a timezone.

Parameters

s	Timezone to lookup
len	Length of the s string

Return values

ptr	Pointer to the Tz struct
NULL	Not found

Definition at line 174 of file date.c.

{
  for (size_t i = 0; i < mutt_array_size(TimeZones); i++)
  {
    if (mutt_istrn_equal(TimeZones[i].tzname, s, len))
      return &TimeZones[i];
  }
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_leap_year_feb()

static int is_leap_year_feb ( struct tm *  tm )

static

Is a given February in a leap year.

Parameters

tm	Date to be tested

Return values

true	It's a leap year

Definition at line 189 of file date.c.

{
  if (tm->tm_mon != 1)
    return 0;
 
  int y = tm->tm_year + 1900;
  return ((y & 3) == 0) && (((y % 100) != 0) || ((y % 400) == 0));
}

Here is the caller graph for this function:

mutt_date_local_tz()

int mutt_date_local_tz

(

time_t

t

)

Calculate the local timezone in seconds east of UTC.

Parameters

t	Time to examine

Return values

num	Seconds east of UTC

Returns the local timezone in seconds east of UTC for the time t, or for the current time if t is zero.

Definition at line 206 of file date.c.

{
  /* Check we haven't overflowed the time (on 32-bit arches) */
  if ((t == TIME_T_MAX) || (t == TIME_T_MIN))
    return 0;
 
  if (t == 0)
    t = mutt_date_epoch();
 
  struct tm tm = mutt_date_gmtime(t);
  return compute_tz(t, &tm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_make_time()

time_t mutt_date_make_time	(	struct tm *	t,
		bool	local
	)

Convert struct tm to time_t

Parameters

t	Time to convert
local	Should the local timezone be considered

Return values

num	Time in Unix format
TIME_T_MIN	Error

Convert a struct tm to time_t, but don't take the local timezone into account unless "local" is nonzero

Definition at line 229 of file date.c.

{
  if (!t)
    return TIME_T_MIN;
 
  static const int AccumDaysPerMonth[mutt_array_size(Months)] = {
    0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
  };
 
  /* Prevent an integer overflow, with some arbitrary limits. */
  if (t->tm_year > 10000)
    return TIME_T_MAX;
  if (t->tm_year < -10000)
    return TIME_T_MIN;
 
  if ((t->tm_mday < 1) || (t->tm_mday > 31))
    return TIME_T_MIN;
  if ((t->tm_hour < 0) || (t->tm_hour > 23) || (t->tm_min < 0) ||
      (t->tm_min > 59) || (t->tm_sec < 0) || (t->tm_sec > 60))
  {
    return TIME_T_MIN;
  }
  if (t->tm_year > 9999)
    return TIME_T_MAX;
 
  /* Compute the number of days since January 1 in the same year */
  int yday = AccumDaysPerMonth[t->tm_mon % mutt_array_size(Months)];
 
  /* The leap years are 1972 and every 4. year until 2096,
   * but this algorithm will fail after year 2099 */
  yday += t->tm_mday;
  if ((t->tm_year % 4) || (t->tm_mon < 2))
    yday--;
  t->tm_yday = yday;
 
  time_t g = yday;
 
  /* Compute the number of days since January 1, 1970 */
  g += (t->tm_year - 70) * (time_t) 365;
  g += (t->tm_year - 69) / 4;
 
  /* Compute the number of hours */
  g *= 24;
  g += t->tm_hour;
 
  /* Compute the number of minutes */
  g *= 60;
  g += t->tm_min;
 
  /* Compute the number of seconds */
  g *= 60;
  g += t->tm_sec;
 
  if (local)
    g -= compute_tz(g, t);
 
  return g;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_normalize_time()

void mutt_date_normalize_time

(

struct tm *

tm

)

Fix the contents of a struct tm.

Parameters

tm	Time to correct

If values have been added/subtracted from a struct tm, it can lead to invalid dates, e.g. Adding 10 days to the 25th of a month.

This function will correct any over/under-flow.

Definition at line 297 of file date.c.

{
  if (!tm)
    return;
 
  static const char DaysPerMonth[mutt_array_size(Months)] = {
    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
  };
  int leap;
 
  while (tm->tm_sec < 0)
  {
    tm->tm_sec += 60;
    tm->tm_min--;
  }
  while (tm->tm_sec >= 60)
  {
    tm->tm_sec -= 60;
    tm->tm_min++;
  }
  while (tm->tm_min < 0)
  {
    tm->tm_min += 60;
    tm->tm_hour--;
  }
  while (tm->tm_min >= 60)
  {
    tm->tm_min -= 60;
    tm->tm_hour++;
  }
  while (tm->tm_hour < 0)
  {
    tm->tm_hour += 24;
    tm->tm_mday--;
  }
  while (tm->tm_hour >= 24)
  {
    tm->tm_hour -= 24;
    tm->tm_mday++;
  }
  /* use loops on NNNdwmy user input values? */
  while (tm->tm_mon < 0)
  {
    tm->tm_mon += 12;
    tm->tm_year--;
  }
  while (tm->tm_mon >= 12)
  {
    tm->tm_mon -= 12;
    tm->tm_year++;
  }
  while (tm->tm_mday <= 0)
  {
    if (tm->tm_mon)
      tm->tm_mon--;
    else
    {
      tm->tm_mon = 11;
      tm->tm_year--;
    }
    tm->tm_mday += DaysPerMonth[tm->tm_mon] + is_leap_year_feb(tm);
  }
  while (tm->tm_mday > (DaysPerMonth[tm->tm_mon] + (leap = is_leap_year_feb(tm))))
  {
    tm->tm_mday -= DaysPerMonth[tm->tm_mon] + leap;
    if (tm->tm_mon < 11)
      tm->tm_mon++;
    else
    {
      tm->tm_mon = 0;
      tm->tm_year++;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_make_date()

void mutt_date_make_date	(	struct Buffer *	buf,
		bool	local
	)

Write a date in RFC822 format to a buffer.

Parameters

buf	Buffer for result
local	If true, use the local timezone. Otherwise use UTC.

Appends the date to the passed in buffer. The buffer is not cleared because some callers prepend quotes.

Definition at line 380 of file date.c.

{
  if (!buf)
    return;
 
  struct tm tm;
  int tz = 0;
 
  time_t t = mutt_date_epoch();
  if (local)
  {
    tm = mutt_date_localtime(t);
    tz = mutt_date_local_tz(t);
  }
  else
  {
    tm = mutt_date_gmtime(t);
  }
 
  tz /= 60;
 
  mutt_buffer_add_printf(buf, "%s, %d %s %d %02d:%02d:%02d %+03d%02d", Weekdays[tm.tm_wday],
                         tm.tm_mday, Months[tm.tm_mon], tm.tm_year + 1900,
                         tm.tm_hour, tm.tm_min, tm.tm_sec, tz / 60, abs(tz) % 60);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_check_month()

int mutt_date_check_month

(

const char *

s

)

Is the string a valid month name.

Parameters

s	String to check

Return values

num	Index into Months array (0-based)
-1	Error

Note

Only the first three characters are checked

The comparison is case insensitive

Definition at line 415 of file date.c.

{
  for (int i = 0; i < mutt_array_size(Months); i++)
    if (mutt_istr_startswith(s, Months[i]))
      return i;
 
  return -1; /* error */
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_epoch()

time_t mutt_date_epoch

(

void

)

Return the number of seconds since the Unix epoch.

Return values

num	Number of seconds since the Unix epoch, or 0 on failure

Definition at line 428 of file date.c.

{
  return mutt_date_epoch_ms() / 1000;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_epoch_ms()

uint64_t mutt_date_epoch_ms

(

void

)

Return the number of milliseconds since the Unix epoch.

Return values

ms	The number of ms since the Unix epoch, or 0 on failure

Definition at line 437 of file date.c.

{
  struct timeval tv = { 0, 0 };
  gettimeofday(&tv, NULL);
  /* We assume that gettimeofday doesn't modify its first argument on failure.
   * We also kind of assume that gettimeofday does not fail. */
  return (uint64_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

Here is the caller graph for this function:

mutt_date_parse_date()

time_t mutt_date_parse_date	(	const char *	s,
		struct Tz *	tz_out
	)

Parse a date string in RFC822 format.

Parameters

[in]	s	String to parse
[out]	tz_out	Pointer to timezone (optional)

Return values

num	Unix time in seconds

Parse a date of the form: [ weekday , ] day-of-month month year hour:minute:second [ timezone ]

The 'timezone' field is optional; it defaults to +0000 if missing.

Definition at line 457 of file date.c.

{
  if (!s)
    return -1;
 
  bool lax = false;
 
  const regmatch_t *match = mutt_prex_capture(PREX_RFC5322_DATE, s);
  if (!match)
  {
    match = mutt_prex_capture(PREX_RFC5322_DATE_LAX, s);
    if (!match)
    {
      mutt_debug(LL_DEBUG1, "Could not parse date: <%s>\n", s);
      return -1;
    }
    lax = true;
    mutt_debug(LL_DEBUG2, "Fallback regex for date: <%s>\n", s);
  }
 
  struct tm tm = { 0 };
 
  // clang-format off
  const regmatch_t *mday    = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_DAY    : PREX_RFC5322_DATE_MATCH_DAY];
  const regmatch_t *mmonth  = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_MONTH  : PREX_RFC5322_DATE_MATCH_MONTH];
  const regmatch_t *myear   = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_YEAR   : PREX_RFC5322_DATE_MATCH_YEAR];
  const regmatch_t *mhour   = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_HOUR   : PREX_RFC5322_DATE_MATCH_HOUR];
  const regmatch_t *mminute = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_MINUTE : PREX_RFC5322_DATE_MATCH_MINUTE];
  const regmatch_t *msecond = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_SECOND : PREX_RFC5322_DATE_MATCH_SECOND];
  const regmatch_t *mtz     = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_TZ     : PREX_RFC5322_DATE_MATCH_TZ];
  const regmatch_t *mtzobs  = &match[lax ? PREX_RFC5322_DATE_LAX_MATCH_TZ_OBS : PREX_RFC5322_DATE_MATCH_TZ_OBS];
  // clang-format on
 
  /* Day */
  sscanf(s + mutt_regmatch_start(mday), "%d", &tm.tm_mday);
  if (tm.tm_mday > 31)
    return -1;
 
  /* Month */
  tm.tm_mon = mutt_date_check_month(s + mutt_regmatch_start(mmonth));
 
  /* Year */
  sscanf(s + mutt_regmatch_start(myear), "%d", &tm.tm_year);
  if (tm.tm_year < 50)
    tm.tm_year += 100;
  else if (tm.tm_year >= 1900)
    tm.tm_year -= 1900;
 
  /* Time */
  int hour, min, sec = 0;
  sscanf(s + mutt_regmatch_start(mhour), "%d", &hour);
  sscanf(s + mutt_regmatch_start(mminute), "%d", &min);
  if (mutt_regmatch_start(msecond) != -1)
    sscanf(s + mutt_regmatch_start(msecond), "%d", &sec);
  if ((hour > 23) || (min > 59) || (sec > 60))
    return -1;
  tm.tm_hour = hour;
  tm.tm_min = min;
  tm.tm_sec = sec;
 
  /* Time zone */
  int zhours = 0;
  int zminutes = 0;
  bool zoccident = false;
  if (mutt_regmatch_start(mtz) != -1)
  {
    char direction;
    sscanf(s + mutt_regmatch_start(mtz), "%c%02d%02d", &direction, &zhours, &zminutes);
    zoccident = (direction == '-');
  }
  else if (mutt_regmatch_start(mtzobs) != -1)
  {
    const struct Tz *tz = find_tz(s + mutt_regmatch_start(mtzobs),
                                  mutt_regmatch_len(mtzobs));
    if (tz)
    {
      zhours = tz->zhours;
      zminutes = tz->zminutes;
      zoccident = tz->zoccident;
    }
  }
 
  if (tz_out)
  {
    tz_out->zhours = zhours;
    tz_out->zminutes = zminutes;
    tz_out->zoccident = zoccident;
  }
 
  return add_tz_offset(mutt_date_make_time(&tm, false), zoccident, zhours, zminutes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_make_imap()

int mutt_date_make_imap	(	char *	buf,
		size_t	buflen,
		time_t	timestamp
	)

Format date in IMAP style: DD-MMM-YYYY HH:MM:SS +ZZzz.

Parameters

buf	Buffer to store the results
buflen	Length of buffer
timestamp	Time to format

Return values

num	Characters written to buf

Caller should provide a buffer of at least 27 bytes.

Definition at line 558 of file date.c.

{
  if (!buf)
    return -1;
 
  struct tm tm = mutt_date_localtime(timestamp);
  int tz = mutt_date_local_tz(timestamp);
 
  tz /= 60;
 
  return snprintf(buf, buflen, "%02d-%s-%d %02d:%02d:%02d %+03d%02d",
                  tm.tm_mday, Months[tm.tm_mon], tm.tm_year + 1900, tm.tm_hour,
                  tm.tm_min, tm.tm_sec, tz / 60, abs(tz) % 60);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_make_tls()

int mutt_date_make_tls	(	char *	buf,
		size_t	buflen,
		time_t	timestamp
	)

Format date in TLS certificate verification style.

Parameters

buf	Buffer to store the results
buflen	Length of buffer
timestamp	Time to format

Return values

num	Characters written to buf

e.g., Mar 17 16:40:46 2016 UTC. The time is always in UTC.

Caller should provide a buffer of at least 27 bytes.

Definition at line 584 of file date.c.

{
  if (!buf)
    return -1;
 
  struct tm tm = mutt_date_gmtime(timestamp);
  return snprintf(buf, buflen, "%s, %d %s %d %02d:%02d:%02d UTC",
                  Weekdays[tm.tm_wday], tm.tm_mday, Months[tm.tm_mon],
                  tm.tm_year + 1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_parse_imap()

time_t mutt_date_parse_imap

(

const char *

s

)

Parse date of the form: DD-MMM-YYYY HH:MM:SS +ZZzz.

Parameters

s	Date in string form

Return values

num	Unix time
0	Error

Definition at line 601 of file date.c.

{
  const regmatch_t *match = mutt_prex_capture(PREX_IMAP_DATE, s);
  if (!match)
    return 0;
 
  const regmatch_t *mday = &match[PREX_IMAP_DATE_MATCH_DAY];
  const regmatch_t *mmonth = &match[PREX_IMAP_DATE_MATCH_MONTH];
  const regmatch_t *myear = &match[PREX_IMAP_DATE_MATCH_YEAR];
  const regmatch_t *mtime = &match[PREX_IMAP_DATE_MATCH_TIME];
  const regmatch_t *mtz = &match[PREX_IMAP_DATE_MATCH_TZ];
 
  struct tm tm;
 
  sscanf(s + mutt_regmatch_start(mday), " %d", &tm.tm_mday);
  tm.tm_mon = mutt_date_check_month(s + mutt_regmatch_start(mmonth));
  sscanf(s + mutt_regmatch_start(myear), "%d", &tm.tm_year);
  tm.tm_year -= 1900;
  sscanf(s + mutt_regmatch_start(mtime), "%d:%d:%d", &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
 
  char direction;
  int zhours, zminutes;
  sscanf(s + mutt_regmatch_start(mtz), "%c%02d%02d", &direction, &zhours, &zminutes);
  bool zoccident = (direction == '-');
 
  return add_tz_offset(mutt_date_make_time(&tm, false), zoccident, zhours, zminutes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_add_timeout()

time_t mutt_date_add_timeout	(	time_t	now,
		time_t	timeout
	)

Safely add a timeout to a given time_t value.

Parameters

now	Time now
timeout	Timeout in seconds

Return values

num	Unix time to timeout

This will truncate instead of overflowing.

Definition at line 637 of file date.c.

{
  if (timeout < 0)
    return now;
 
  if ((TIME_T_MAX - now) < timeout)
    return TIME_T_MAX;
 
  return now + timeout;
}

Here is the caller graph for this function:

mutt_date_localtime()

struct tm mutt_date_localtime

(

time_t

t

)

Converts calendar time to a broken-down time structure expressed in user timezone.

Parameters

t

Time

Return values

obj	Broken-down time representation

Uses current time if t is MUTT_DATE_NOW

Definition at line 655 of file date.c.

{
  struct tm tm = { 0 };
 
  if (t == MUTT_DATE_NOW)
    t = mutt_date_epoch();
 
  localtime_r(&t, &tm);
  return tm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_gmtime()

struct tm mutt_date_gmtime

(

time_t

t

)

Converts calendar time to a broken-down time structure expressed in UTC timezone.

Parameters

t

Time

Return values

obj	Broken-down time representation

Uses current time if t is MUTT_DATE_NOW

Definition at line 673 of file date.c.

{
  struct tm tm = { 0 };
 
  if (t == MUTT_DATE_NOW)
    t = mutt_date_epoch();
 
  gmtime_r(&t, &tm);
  return tm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_localtime_format()

size_t mutt_date_localtime_format	(	char *	buf,
		size_t	buflen,
		const char *	format,
		time_t	t
	)

Format localtime.

Parameters

buf	Buffer to store formatted time
buflen	Buffer size
format	Format to apply
t	Time to format

Return values

num	Number of Bytes added to buffer, excluding NUL byte

Definition at line 692 of file date.c.

{
  if (!buf || !format)
    return 0;
 
  struct tm tm = mutt_date_localtime(t);
  return strftime(buf, buflen, format, &tm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_date_sleep_ms()

void mutt_date_sleep_ms

(

size_t

ms

)

Sleep for milliseconds.

Parameters

ms	Number of milliseconds to sleep

Definition at line 705 of file date.c.

{
  const struct timespec sleep = {
    .tv_sec = ms / 1000,
    .tv_nsec = (ms % 1000) * 1000000UL,
  };
  nanosleep(&sleep, NULL);
}

Here is the caller graph for this function:

Variable Documentation

Weekdays

const char* const Weekdays[]

static

Initial value:

= {
  "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
}

Day of the week (abbreviated)

Definition at line 47 of file date.c.

Months

const char* const Months[]

static

Initial value:

= {
  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
}

Months of the year (abbreviated)

Definition at line 54 of file date.c.

TimeZones

const struct Tz TimeZones[]

static

Lookup table of Time Zones.

Note

Keep in alphabetical order

Definition at line 64 of file date.c.