/*

 *  R : A Computer Language for Statistical Data Analysis

 *  Copyright (C) 2000-2026  The R Core Team.

 *

 *  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, a copy is available at

 *  https://www.R-project.org/Licenses/

 *

 *

 *      Interfaces to POSIX date-time conversion functions.

 */

/*

    These use POSIX functions which are also part of C99 so are almost

    universally available, albeit with more room for implementation

    variations.

    A particular problem is the setting of the timezone TZ on

    Unix/Linux.  POSIX appears to require it, yet older Linux systems

    do not set it and do not give the correct results/crash strftime

    if it is not set (or even if it is: see the workaround below).  We

    use unsetenv() to work around this: that is a BSD (and POSIX 2001)

    construct but seems to be available on the affected platforms.

    The system date-time entry points we use (or substitute) are

    gmtime_r (or gmtime)

    localtime_r (or localtime)

    mktime

    strftime (in do_formatPOSIXlt)

    tzname

    tzset

    PATH 2) also uses R_timegm and R_tzsetwall (a version of tzset

    which ignores TZ and loads the current timezone).

    Via Rstrptime.h we use the system strftime or wcsftime to get the

    language-specific names.

*/

/*

  R class "POSIXlt" is a list of 9 components, with two optional ones

  (but always added as from R 4.3.0).

  Objects of this class are most often created from character inputs

  via strptime() (called by as.POSIXlt.character) or from "POSIXct"

  objects. In the first case they may or may not have an associated

  time zone: in the second they must.

  On a system with tm_gmtoff (all current platforms) the components

  zone and gmtoff are included, but gmtoff may be NA and usually will

  be unless the value was supplied by strptime(, "%z") or by

  conversion from "POSIXct" or "Date".

  There will usually be a "tzone" attribute, of length 1 if only the

  name is known or is "UTC', of length 3 including the abbreviations

  for all other timezones. (If the timezone does not use DST, the

  second abbreviation may be empty or may repeat the first, depending

  on the platform., but it will always be present.)  However, if the

  call to strptime() does not specify 'tz', this attribute is omitted.

  Names for the date-times are optional (and rarely supplied):

  they are attached to the 'year' element' and used by strptime().

*/

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

// to get tm_zone, tm_gmtoff defined in glibc.

// some other header, e.g. math.h, might define the macro so do this first

#if defined HAVE_FEATURES_H

# include <features.h>

# ifdef __GNUC_PREREQ

#  if __GNUC_PREREQ(2,20) && !defined(_DEFAULT_SOURCE_)

#   define _DEFAULT_SOURCE 1

#  endif

# endif

#endif

#if defined(HAVE_GLIBC2) && !defined(_DEFAULT_SOURCE_) && !defined(_BSD_SOURCE)

# define _BSD_SOURCE 1

#endif

/*

  glibc (with these macros), macOS and internal tzcode all have tm_zone

  and tm_gmtoff fields in struct tm.

  musl has __tm_zone and __tm_gmtoff, which it re-defines without __

  if _BSD_SOURCE or _GNU_SOURCE is defined.  But with no macro to

  detect musl.  However, they were redefined on the tested Alpine

  Linux system which did define _GNU_SOURCE.

*/

#include <time.h>

#include <errno.h> // mktime or substitute may set errno.

#include <Rmath.h> // for imin2()

/*

There are two implementation paths here.

Inspectable from R,  sessionInfo()$tzcode_type  is either

  1) "system (<libc>)"  (with '<libc>' = 'glibc' usually)  or

  2) "internal"

1) Use the system functions for mktime, gmtime[_r], localtime[_r], strftime.

   Use the system time_t, struct tm and time-zone tables.

   This can be use on glibc, macOS and Solaris (and probably FreeBSD),

   but all except 64-bit glibc have issues we can try to work around.

   It could in principle be used on Windows but the issues there are

   too severe (no support for before 1970) to work around.

   The system facilities are used for 1902-2037 and outside those

   limits where there is a 64-bit time_t and the conversions work

   (some OSes have only 32-bit time-zone tables and macOS 13 only

   works from 1900).  Otherwise there is code below to extrapolate

   from 1902-2037.

   Other known issues are with strftime (macOS only supports offsets

   in multiple of half-hours), not having tzdata tables (possible on

   Alpine and now fatal when configuring) and odd issues reading the

   time-zone tables, especially for 1939-1945.

2) USE_INTERNAL_MKTIME : Use substitutes from src/extra/tzone for

   mktime, gmtime_r, localtime_r, strftime with a R_ prefix.  The

   system strftime is used for locale-dependent names in R_strptime

   and R_strftime.  This uses the time-zone tables shipped with R and

   installed into R_HOME/share/zoneinfo , with facilities to switch to

   others using environment variable TZDIR.

   Our own versions of time_t (64-bit) and struct tm (including the

   BSD-style fields tm_zone and tm_gmtoff) are used.

   PATH 2) was added for R 3.1.0 (2014-04), is the only one

   supported on Windows and is the current default on macOS.

*/

// ---------------------------

#ifdef USE_INTERNAL_MKTIME

// PATH 2)

# include "datetime.h"

// configure might have checked the system versions, so we override.

# undef HAVE_LOCALTIME_R

# define HAVE_LOCALTIME_R 1

# undef HAVE_TM_ZONE

# define HAVE_TM_ZONE 1

# undef HAVE_TM_GMTOFF

# define HAVE_TM_GMTOFF 1

// latterly these are set by configure, but not on Windows

# undef MKTIME_SETS_ERRNO

# define MKTIME_SETS_ERRNO

// these should only be used in PATH 1), but we set them for completeness.

# undef HAVE_WORKING_MKTIME_AFTER_2037

# define HAVE_WORKING_MKTIME_AFTER_2037 1

# undef HAVE_WORKING_MKTIME_BEFORE_1902

# define HAVE_WORKING_MKTIME_BEFORE_1902 1

# undef HAVE_WORKING_MKTIME_BEFORE_1970

# define HAVE_WORKING_MKTIME_BEFORE_1970 1

#else // PATH 1)

typedef struct tm stm;

#define R_tzname tzname

extern char *tzname[2];

#endif

// ---------------------------

#include <stdlib.h> /* for setenv or putenv */

#define R_USE_SIGNALS 1

#include <Defn.h>

#include <Internal.h>

#ifndef USE_INTERNAL_MKTIME

/* PATH 1 */

static bool warn1902 = false;

#endif

/* Substitute based on glibc code. */

#include "Rstrptime.h"

/* --> Def.  R_strptime()  etc */

static const int month_days[12] =

  {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

// Careful : days_in_year is for base-0 years, days_in_month for base-1900.

#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)

#define days_in_year(year) (isleap(year) ? 366 : 365)

#define days_in_month(mon, yr) ((mon == 1 && isleap(1900+yr)) ? 29 : month_days[mon])

/*

  Adjust a struct tm to be a valid scalar date-time.

  Return 0 if valid, -1 if invalid and uncorrectable, or a positive

  integer approximating the number of corrections done.

  Used in both paths in mktime0, in localtime0 in PATH 1) and in

  do_formatPOSIXlt, do_strptime, do_POSIXlt2D, do_balancePOSIXlt.

*/

static int validate_tm (stm *tm)

{

    int tmp, res = 0;

    if (tm->tm_sec < 0 || tm->tm_sec > 60) { /* 61 POSIX, 60 draft ISO C */

  res++;

  int tmp = tm->tm_sec/60;

  tm->tm_sec -= 60 * tmp; tm->tm_min += tmp;

  if(tm->tm_sec < 0) {tm->tm_sec += 60; tm->tm_min--;}

    }

    if (tm->tm_min < 0 || tm->tm_min > 59) {

  res++;

  int tmp = tm->tm_min/60;

  tm->tm_min -= 60 * tmp; tm->tm_hour += tmp;

  if(tm->tm_min < 0) {tm->tm_min += 60; tm->tm_hour--;}

    }

    if(tm->tm_hour == 24 && tm->tm_min == 0 && tm->tm_sec == 0) { /* 24:00:00 */

  tm->tm_hour = 0; tm->tm_mday++;

  if(tm->tm_mon >= 0 && tm->tm_mon <= 11) {

      if(tm->tm_mday > days_in_month(tm->tm_mon, tm->tm_year)) {

    tm->tm_mon++; tm->tm_mday = 1;

    if(tm->tm_mon == 12) {

        tm->tm_year++; tm->tm_mon = 0;

    }

      }

  }

    }

    else if (tm->tm_hour < 0 || tm->tm_hour > 23) {

  res++;

  tmp = tm->tm_hour/24;

  tm->tm_hour -= 24 * tmp; tm->tm_mday += tmp;

  if(tm->tm_hour < 0) {tm->tm_hour += 24; tm->tm_mday--;}

    }

    /* defer fixing mday until we know the year */

    if (tm->tm_mon < 0 || tm->tm_mon > 11) {

  res++;

  tmp = tm->tm_mon/12;

  tm->tm_mon -= 12 * tmp; tm->tm_year += tmp;

  if(tm->tm_mon < 0) {tm->tm_mon += 12; tm->tm_year--;}

    }

    /* A limit on the loops of about 3000x round.

       We could spin backwards or forwards in multiples of 400 years.

     */

    if(tm->tm_mday < -1000000 || tm->tm_mday > 1000000) return -1;

    if(abs(tm->tm_mday) > 366) {

  res++;

  /* first spin back until January */

  while(tm->tm_mon > 0) {

      --tm->tm_mon;

      tm->tm_mday += days_in_month(tm->tm_mon, tm->tm_year);

  }

  /* then spin on/back by years */

  while(tm->tm_mday < 1) {

      --tm->tm_year;

      tm->tm_mday += 365 + (isleap(1900+tm->tm_year)? 1 : 0);

  }

  while(tm->tm_mday >

        (tmp = 365 + (isleap(1900+tm->tm_year)? 1 : 0))) {

      tm->tm_mday -= tmp; tm->tm_year++;

  }

    }

    while(tm->tm_mday < 1) {

  res++;

  if(--tm->tm_mon < 0) {tm->tm_mon += 12; tm->tm_year--;}

  tm->tm_mday += days_in_month(tm->tm_mon, tm->tm_year);

    }

    while(tm->tm_mday > (tmp = days_in_month(tm->tm_mon, tm->tm_year))) {

  res++;

  if(++tm->tm_mon > 11) {tm->tm_mon -= 12; tm->tm_year++;}

  tm->tm_mday -= tmp;

    }

    return res;

} // validate_tm

/*

  glibc and internal strftime are subject to integer overflow when

  tm->tm_year + 1900 does not fit into an integer

*/

static int likely_strftime_overflow (stm *tm)

{

  double year = 1900.0 + tm->tm_year;

#if SIZEOF_INT <= 4

  return (year > INT_MAX || year < INT_MIN);

#else

  /* err on the safe side to avoid surprise due to imprecise floating point

     representation of the limits */

  return !(year < INT_MAX && year > INT_MIN);

#endif

}

/*

   days_in_year is the same for year mod 400.

   We could avoid loops altogether by computing how many leap years

   there are between 1900 + tm->tm_year and 1900.

   This will fix up tm->tm_yday and tm->tm_wday.

   Used in timegm00 (possibly) and guess_offset in PATH 1),

   POSIXlt2D and do_balancePOSIXlt

*/

static double mkdate00 (stm *tm)

{

    if(tm->tm_mday == NA_INTEGER || tm->tm_year == NA_INTEGER

       || tm->tm_mon == NA_INTEGER) {

  tm->tm_yday = tm->tm_wday = NA_INTEGER;

  return NA_REAL;

    }

    int day = tm->tm_mday - 1, /* checked for NA above */

  year0 = tm->tm_year;

    double excess = 0.0;

    if (year0 >= 400) {

  excess = (int)(year0/400) - 1;

  year0 -= (int)(excess * 400);

    } else if (year0 < 0) {

  excess = -1 - (int)(-year0/400);

  year0 -= (int)(excess * 400);

    }

    year0 += 1900;

    for(int i = 0; i < tm->tm_mon; i++) day += month_days[i];

    if (tm->tm_mon > 1 && isleap(year0)) day++;

    tm->tm_yday = day;

    if (year0 > 1970) {

  for (int year = 1970; year < year0; year++)

      day += days_in_year(year);

    } else if (year0 < 1970) {

  for (int year = 1969; year >= year0; year--)

      day -= days_in_year(year);

    }

    /* weekday: Epoch day was a Thursday */

    if ((tm->tm_wday = ((day % 7) + 4) % 7) < 0) tm->tm_wday += 7;

    return (day + excess * 146097);

}

/* if d is negative and non-integer then t will be off by one second

   since we really need floor(). But floor() is slow, so we just

   fix t instead as needed. */

#define LOCALTIME_MK_(t_)     \

        time_t t_ = (time_t) d;     \

  if (d < 0. && d != (double) t_) t_--

#ifdef USE_INTERNAL_MKTIME

/*

   PATH 2), internal tzcode

   Interface to mktime or timegm, version in each PATH. This is PATH 2).

   Called from do_asPOSIXct and do_strptime.

*/

static double mktime0 (stm *tm, const int local)

{

    if(validate_tm(tm) < 0) {

#ifdef EOVERFLOW

  errno = EOVERFLOW;

#else

  errno = 79;

#endif

  return -1.;

    }

    return (double)(local ? R_mktime(tm) : R_timegm(tm));

}

/*

   Interface to localtime_r or gmtime_r.

   Version in each PATH.  This is PATH 2).

   Used in do_asPOSIXlt and do_strptime.

*/

static stm * localtime0(const double *tp, const int local, stm *ltm)

{

    double d = *tp;

    LOCALTIME_MK_(t);

    return local ? R_localtime_r(&t, ltm) : R_gmtime_r(&t, ltm);

}

#else

//--------------------------------------------------------- long clause ----

// PATH 1), using system functions.

/*

   Substitute for timegm (which is non-POSIX) -- with no checking.  Also,

   returns double and needs to be wider than a 32-bit time_t.  So we

   could use timegm if it exists _and_ time_t is 64-bit _and_ it supports

   a full range of dates (macOS's does not).

   Used in guess_offset, mktime0 in PATH 1).

*/

static double timegm00 (stm *tm)

{

    // NA handling may no longer be needed, but left in for safety

    // (it caused UBSAN errors).

    double day = mkdate00(tm); // handles NA inputs

    if (day == NA_REAL) return NA_REAL;

    return tm->tm_sec + (tm->tm_min * 60) + (tm->tm_hour * 3600)

  + day * 86400.0;

}

// no known examples recently

#ifndef HAVE_POSIX_LEAPSECONDS

static int n_leapseconds = 27; // 2017-01, sync with .leap.seconds in R (!)

static const time_t leapseconds[] = // dput(unclass(.leap.seconds)) :

{  78796800, 94694400,126230400,157766400,189302400,220924800,252460800,

  283996800,315532800,362793600,394329600,425865600,489024000,567993600,

  631152000,662688000,709948800,741484800,773020800,820454400,867715200,

   915148800,1136073600,1230768000,1341100800,1435708800,1483228800};

#endif

static double guess_offset (stm *tm)

{

    double offset, offset1, offset2;

    int i, wday, year, oldmonth, oldisdst, oldmday;

    stm oldtm;

    /*

       Adjust as best we can for timezones: if isdst is unknown, use

       the smaller offset at same day in Jan or July of a valid year.

       We don't know the timezone rules, but if we choose a year with

       July 1 on the same day of the week we will likely get guess

       right (since they are usually on Sunday mornings not in Jan/Feb).

       Update for R 2.7.0: no one had DST before 1916, so just use the offset

       in 1902, if available.

    */

    memcpy(&oldtm, tm, sizeof(stm));

    if(tm->tm_year < 2) { /* no DST */

  tm->tm_year = 2;

  mktime(tm);

  offset1 = (double) mktime(tm) - timegm00(tm);

  memcpy(tm, &oldtm, sizeof(stm));

  tm->tm_isdst = 0;

  return offset1;

    }

    oldmonth = tm->tm_mon;

    oldmday = tm->tm_mday;

    /* We know there was no DST prior to 1916 */

    oldisdst = (tm->tm_year < 16) ? 0 : tm->tm_isdst;

    /* so now look for a suitable year */

    tm->tm_mon = 6;

    tm->tm_mday = 1;

    tm->tm_isdst = -1;

    mkdate00(tm); // fixes tm_wday and tm_yday

    wday = tm->tm_wday;

    if (oldtm.tm_year > 137) { /* in the unknown future */

  for(i = 130; i < 137; i++) { /* These cover all the possibilities */

      tm->tm_year = i;

      mktime(tm);

      if(tm->tm_wday == wday) break;

  }

    } else { /* a benighted OS with date before 1970 */

  /* We could not use 1970 because of the Windows bug with

     1970-01-01 east of GMT. */

  for(i = 71; i < 82; i++) { /* These cover all the possibilities */

      tm->tm_year = i;

      mktime(tm);

      if(tm->tm_wday == wday) break;

  }

    }

    year = i;

    /* Now look up offset in January */

    tm->tm_mday = oldmday;

    tm->tm_mon = 0;

    tm->tm_year = year;

    tm->tm_isdst = -1;

    offset1 = (double) mktime(tm) - timegm00(tm);

    /* and in July */

    tm->tm_year = year;

    tm->tm_mon = 6;

    tm->tm_isdst = -1;

    offset2 = (double) mktime(tm) - timegm00(tm);

    if(oldisdst > 0) {

  offset = (offset1 > offset2) ? offset2 : offset1;

    } else {

  offset = (offset1 > offset2) ? offset1 : offset2;

    }

    /* now try to guess dst if unknown */

    tm->tm_mon = oldmonth;

    tm->tm_isdst = -1;

    if(oldisdst < 0) {

  offset1 = (double) mktime(tm) - timegm00(tm);

  oldisdst = (offset1 < offset) ? 1:0;

  if(oldisdst) offset = offset1;

    }

    /* restore all as mktime might alter it */

    memcpy(tm, &oldtm, sizeof(stm));

    /* and then set isdst */

    tm->tm_isdst = oldisdst;

    return offset;

}

/*

   Interface to mktime or timegm00, version in each PATH.

   Called from do_asPOSIXct and do_strptime.

   This is the version for PATH 1)

*/

static double mktime0 (stm *tm, const int local)

{

    double res;

    bool OK;

    if(validate_tm(tm) < 0) {

#ifdef EOVERFLOW

  errno = EOVERFLOW;

#else

  errno = 79;

#endif

  return -1.;

    }

    if(!local) return timegm00(tm);

/*

   Platforms with a 32-bit time_t will fail before 1901-12-13 and after 2038-01-19.

   macOS 10.9 gave -1 for dates prior to 1902 and ignored DST after 2037

   macOS 13 gives -1 for dates prior to 1900

   Windows UCRT (and in 2004) gives -1 for dates prior to 1970

   https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_16

   states 'the relationship is undefined' prior to 1970.

   glibc from 2.2.5 until late 2004 also gave -1 for such dates.

*/

    if(sizeof(time_t) == 8) {

  OK = true;

#ifndef HAVE_WORKING_MKTIME_AFTER_2037

  OK = OK && tm->tm_year < 138;

#endif

#ifndef HAVE_WORKING_MKTIME_BEFORE_1902

  OK = OK && tm->tm_year >= 02;

  if (tm->tm_year < 02) {

      if(!warn1902)

    warning(_("datetimes before 1902 may not be accurate: warns once per session"));

      warn1902 = true;

  }

#endif

#ifndef HAVE_WORKING_MKTIME_BEFORE_1970

  OK = OK && tm->tm_year >= 70;

#endif

    } else {  // 32-bit time_t

  OK = tm->tm_year < 138 && tm->tm_year >= 02;

  if (tm->tm_year < 02) {

      if(!warn1902)

    warning(_("datetimes before 1902 may not be accurate: warns once per session"));

      warn1902 = true;

  }

#ifndef HAVE_WORKING_MKTIME_BEFORE_1970

  OK = OK && tm->tm_year >= 70;

#endif

    }

    if(OK) {

  res = (double) mktime(tm);

  if (res == -1.) return res;

#ifndef HAVE_POSIX_LEAPSECONDS

  for(int i = 0; i < n_leapseconds; i++)

      if(res > leapseconds[i]) res -= 1.0;

#endif

  return res;

/* watch the side effect here: both calls alter their arg */

    } else {

  double offset = guess_offset(tm);

#ifdef HAVE_TM_GMTOFF

  tm->tm_gmtoff = (long)offset;

#endif

  return offset + timegm00(tm);

    }

}

/*

   Interface to localtime[_r] or gmtime[_r] or internal substitute.

   Version in each PATH: this is PATH 1)

   Used in do_asPOSIXlt and do_strptime.

*/

static stm * localtime0(const double *tp, const int local, stm *ltm)

{

    double d = *tp;

    bool OK = true;;

/* as mktime is broken, do not trust localtime */

    if (sizeof(time_t) == 8) {

  OK = true;

#ifndef HAVE_WORKING_MKTIME_AFTER_2037

  OK = OK && d < 2147483647.0;

#endif

#ifndef HAVE_WORKING_MKTIME_BEFORE_1902

  if (d <= -2147483647.0) {

      if(!warn1902)

    warning(_("datetimes before 1902 may not be accurate: warns once per session"));

      warn1902 = true;

      OK = false;

  }

  OK = OK && d > -2147483647.0;

#endif

#ifndef HAVE_WORKING_MKTIME_BEFORE_1970

  OK = OK && d >= 0.0;

#endif

    } else { // 32-bit time_t

  if (d <= -2147483647.0) {

      if(!warn1902)

    warning(_("datetimes before 1902 may not be accurate: warns once per session"));

      warn1902 = true;

      OK = false;

  }

  OK = OK && d < 2147483647.0;

#ifndef HAVE_WORKING_MKTIME_BEFORE_1970

  OK = OK && d >= 0.0;

#endif

    }

    if(OK) {

  LOCALTIME_MK_(t);

#ifndef HAVE_POSIX_LEAPSECONDS

  for(int y = 0; y < n_leapseconds; y++) if(t > leapseconds[y] + y - 1) t++;

#endif

  // Recent Linux and macOS have localtime_r

#ifdef HAVE_LOCALTIME_R

  return local ? localtime_r(&t, ltm) : gmtime_r(&t, ltm);

#else

  return local ? localtime(&t) : gmtime(&t);

#endif

    } // end of OK

    // internal substitute code.

    double dday = floor(d/86400.0);

//    static stm ltm0, *res = &ltm0;

    stm *res = ltm; // be like localtime_r

    // This cannot exceed (2^31-1) years in either direction from 1970

    if (fabs(dday) > 784368402400) { //bail out

  res->tm_year = NA_INTEGER;

  res->tm_mon = NA_INTEGER;

  res->tm_mday = NA_INTEGER;

  res->tm_yday = NA_INTEGER;

  res->tm_wday = NA_INTEGER;

  res->tm_hour = NA_INTEGER;

  res->tm_min = NA_INTEGER;

  res->tm_sec = NA_INTEGER;

  res->tm_isdst = -1;

  return res;

    }

    int left = (int) (d - dday * 86400.0 + 1e-6); // allow for fractional secs

    memset(res, 0, sizeof(stm));

    /* hour, min, and sec */

    res->tm_hour = left / 3600;

    left %= 3600;

    res->tm_min = left / 60;

    res->tm_sec = left % 60;

    /* weekday: 1970-01-01 was a Thursday */

    int tmp = (int)(dday - 7 * floor(dday/7)); // day % 7

    if ((res->tm_wday = ((tmp + 4) % 7)) < 0) res->tm_wday += 7;

    /* year & day within year */

    /* every 400 years is exactly 146097 days long and the

       pattern is repeated */

    double rounds = floor(floor(dday) / 146097.0);

    dday -= 146097.0 * rounds;

    int y = (int)(1970 + rounds * 400);

    if (dday >= 0)

  for ( ; dday >= (tmp = days_in_year(y)); dday -= tmp, y++);

    else

  for ( ; dday < 0; --y, dday += days_in_year(y) );

    y = res->tm_year = y - 1900;

    int day = (int) dday;

    res->tm_yday = day;

    /* month within year */

    int mon;

    for (mon = 0;

   day >= (tmp = days_in_month(mon, y)); // days_in_month is 1900-based

   day -= tmp, mon++);

    res->tm_mon = mon;

    res->tm_mday = day + 1;

    if(local) {

  /*  daylight saving time is unknown */

  res->tm_isdst = -1;

  /* Try to fix up time zone differences: cf PR#15480 */

  int sdiff = (int) guess_offset(res);

  /* New strategy in 4.3.0: convert as if in UTC, then guess

     offset and redo. */

  d -= sdiff;

  dday = floor(d/86400.0);

  left = (int) (d - dday * 86400.0 + 1e-6);

  res->tm_hour = left / 3600;

  left %= 3600;

  res->tm_min = left / 60;

  res->tm_sec = left % 60;

  tmp = (int)(dday - 7 * floor(dday/7)); // day % 7

  if ((res->tm_wday = ((tmp + 4) % 7)) < 0) res->tm_wday += 7;

  rounds = floor(floor(dday) / 146097.0);

  dday -= 146097.0 * rounds;

  int y = (int)(1970 + rounds * 400);

  if (dday >= 0)

      for ( ; dday >= (tmp = days_in_year(y)); dday -= tmp, y++);

  else

      for ( ; dday < 0; --y, dday += days_in_year(y) );

  y = res->tm_year = y - 1900;

  int day = (int) dday;

  res->tm_yday = day;

  /* month within year */

  int mon;

  for (mon = 0;

       day >= (tmp = days_in_month(mon, y));

       day -= tmp, mon++);

  res->tm_mon = mon;

  res->tm_mday = day + 1;

  validate_tm(res);

#ifdef HAVE_TM_GMTOFF

  res->tm_gmtoff = -sdiff;

#endif

  // No DST before 1916

  if(res->tm_year < 16) res->tm_isdst = 0;

  return res;

    } else {

  res->tm_isdst = 0; /* no dst in UTC */

  return res;

    }

} /* localtime0() */

#endif // end of PATH 1) ---------------------------------------------

/* Some functions below need to set environment variable TZ and then

   (attempt to) set the time-zone accordingly (via set_tz, tzset).

   On exit, they attempt to restore the previous TZ and re-set the time-zone

   (via reset_tz, tzset). Functions set_tz, reset_tz and the internal tzcode

   tzset() may issue warnings, which may be turned into errors and cause a long

   jump (PR#17966), before or after setting the time-zone (to the required one,

   or as a fallback to UTC).

   struct tzset_info ... holds information for resetting the time zone

                         during local and non-local returns

   prepare_reset_tz() .. initializes tzset_info and sets up context

   set_tz()           .. local setting of tz

   reset_tz()         .. local re-setting, also invoked non-locally

   prepare_dummy_reset_tz()

                      .. initializes tzset_info for local invocation

                         so that it does nothing (could go away

                         after some refactoring)

*/

typedef struct tzset_info {

    char oldtz[1001]; /* previous value of TZ variable */

    bool hadtz; /* TZ variable existed previously */

    bool settz; /* TZ variable was set by us */

    RCNTXT cntxt;

    bool end_context_on_reset;

      /* should endcontext() be called from reset_tz()? */

} tzset_info;

static void reset_tz(tzset_info *si);

static void cend_reset_tz(void *data)

{

    tzset_info *si = (tzset_info *)data;

    si->end_context_on_reset = false;

    reset_tz(si);

}

static void prepare_reset_tz(tzset_info *si)

{

    si->settz = false;

    /* set up a context which will reset tz if there is an error */

    begincontext(&si->cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,

                 R_NilValue, R_NilValue);

    si->cntxt.cend = &cend_reset_tz;

    si->cntxt.cenddata = si;

    si->end_context_on_reset = true;

}

static void prepare_dummy_reset_tz(tzset_info *si)

{

    si->settz = false;

    si->end_context_on_reset = false;

}

static bool set_tz(const char *tz, tzset_info *si)

{

    si->settz = false;

    char *p = getenv("TZ");

    if(p) {

  if (strlen(p) > 1000)

      error("time zone specification is too long");

  strcpy(si->oldtz, p);

  si->hadtz = true;

    } else

  si->hadtz = false;

    /* To force tzset() call to refresh tzname, first call tzset() while TZ=UTC.

       If the desired setting is actually TZ=UTC and tzname is not refreshed,

       it is OK, because UTC has only one possible time zone abbreviation.

    */

    int status = -1; // code = {set,put}env();

#ifdef HAVE_SETENV

    status = setenv("TZ", "UTC", 1);

#elif defined(HAVE_PUTENV)

    {

  static char e[] = "TZ=UTC";

  status = putenv(e);

    }

#endif

    if(!status) tzset();

    if(!tz[0]) {

  if(status) {

      tzset();

      return si->settz;

  } else if(si->hadtz) {

      tz = si->oldtz;

  } else {

#ifdef HAVE_UNSETENV

      if(unsetenv("TZ")) warning(_("problem with unsetting timezone"));

#elif defined(HAVE_PUTENV_UNSET)

      static char e[] = "TZ";

      if(putenv(e)) warning(_("problem with unsetting timezone"));

#elif defined(HAVE_PUTENV_UNSET2)

      static char e[] = "TZ=";

      if(putenv(e)) warning(_("problem with unsetting timezone"));

#endif

      tzset();

      return si->settz;

  }

    }

#ifdef HAVE_SETENV

    if(setenv("TZ", tz, 1)) warning(_("problem with setting timezone"));

    else si->settz = true;

#elif defined(HAVE_PUTENV)

    {

  /* This could be dynamic, but setenv is strongly preferred

     (but not available on Windows)

     "A program should not alter or free the string"

  */

  static char buff[1010];

  if (strlen(tz) > 1000)

      error("time zone specification is too long");

  strcpy(buff, "TZ="); strcat(buff, tz);

  if(putenv(buff)) warning(_("problem with setting timezone"));

  else si->settz = true;

    }

#else

    warning(_("cannot set timezones on this system"));

#endif

    tzset();

    return si->settz;

}

static void reset_tz(tzset_info *si)

{

    if (si->end_context_on_reset) {

  endcontext(&si->cntxt);

  si->end_context_on_reset = false; /* guard against double reset */

    }

    if (!si->settz)

  return;

    si->settz = false; /* better avoid recursive attempts */

    if(si->hadtz) {

#ifdef HAVE_SETENV

  if(setenv("TZ", si->oldtz, 1))

      warning(_("problem with setting timezone"));

#elif defined(HAVE_PUTENV)

  {

      static char buff[1010];

      strcpy(buff, "TZ="); strcat(buff, si->oldtz); // could use strncat

      if(putenv(buff)) warning(_("problem with setting timezone"));

  }

#endif

    } else {

#ifdef HAVE_UNSETENV

  // FreeBSD variants used not to return a value, but POSIX requires this

  if(unsetenv("TZ")) warning(_("problem with unsetting timezone"));

#elif defined(HAVE_PUTENV_UNSET)

  if(putenv("TZ")) warning(_("problem with unsetting timezone"));

#elif defined(HAVE_PUTENV_UNSET2)

  if(putenv("TZ=")) warning(_("problem with unsetting timezone"));

#endif

    }

    tzset();

}

// called from do_strptime

static void glibc_fix(stm *tm, bool *invalid)

{

    /* set mon and mday which glibc does not always set.

       Use current year/... if none has been specified.

       Specifying mon but not mday nor yday is invalid.

    */

    time_t t = time(NULL);

    stm *tm0;

    int tmp;

#ifndef HAVE_POSIX_LEAPSECONDS

    t -= n_leapseconds;

#endif

    // Recent Linux and macOS have localtime_r

#ifdef HAVE_LOCALTIME_R

    stm tm2;

    tm0 = localtime_r(&t, &tm2);

#else

    tm0 = localtime(&t);

#endif

    if(tm->tm_year == NA_INTEGER) tm->tm_year = tm0->tm_year;

    if(tm->tm_mon != NA_INTEGER && tm->tm_mday != NA_INTEGER) return;

    // at least one of the month and the day of the month is missing

    if(tm->tm_yday != NA_INTEGER) {

  // since we have yday, let that take precedence over mon/mday

  int yday = tm->tm_yday, mon = 0;

  if (yday < 0 || yday >= days_in_year(1900 + tm->tm_year)) {

      *invalid = true;

      return;

  }

  while(yday >= (tmp = days_in_month(mon, tm->tm_year))) {

      yday -= tmp;

      mon++;

  }

  tm->tm_mon = mon;

  tm->tm_mday = yday + 1;

    } else {

  if(tm->tm_mday == NA_INTEGER) {

      if(tm->tm_mon != NA_INTEGER) {

    *invalid = true;

    return;

      } else tm->tm_mday = tm0->tm_mday;

  }

  if(tm->tm_mon == NA_INTEGER) tm->tm_mon = tm0->tm_mon;

    }

}

// Used in do_asPOSIXlt do_strptime do_D2POSIXlt do_balancePOSIXlt

static void

makelt(stm *tm, SEXP ans, R_xlen_t i, bool valid, double frac_secs)

{

    if(valid) {

  REAL(   VECTOR_ELT(ans, 0))[i] = tm->tm_sec + frac_secs;

  INTEGER(VECTOR_ELT(ans, 1))[i] = tm->tm_min;

  INTEGER(VECTOR_ELT(ans, 2))[i] = tm->tm_hour;

  INTEGER(VECTOR_ELT(ans, 3))[i] = tm->tm_mday;

  INTEGER(VECTOR_ELT(ans, 4))[i] = tm->tm_mon;

  INTEGER(VECTOR_ELT(ans, 5))[i] = tm->tm_year;

  INTEGER(VECTOR_ELT(ans, 6))[i] = tm->tm_wday;

  INTEGER(VECTOR_ELT(ans, 7))[i] = tm->tm_yday;

  INTEGER(VECTOR_ELT(ans, 8))[i] = tm->tm_isdst;

    } else {

  REAL(VECTOR_ELT(ans, 0))[i] = frac_secs;

  for(int j = 1; j < 8; j++)

      INTEGER(VECTOR_ELT(ans, j))[i] = NA_INTEGER;

  INTEGER(VECTOR_ELT(ans, 8))[i] = -1; // isdst

    }

}

// Used in do_asPOSIXlt do_strptime

// Uses tz from enclosing function

#define SET_TZONE         \

    /* set now in case this gets changed by conversions. */ \

    SEXP tzone;           \

    if (isUTC) {         \

  tzone = PROTECT(mkString(tz));     \

    } else {           \

  tzone = PROTECT(allocVector(STRSXP, 3)); \

  SET_STRING_ELT(tzone, 0, mkChar(tz));    \

  SET_STRING_ELT(tzone, 1, mkChar(R_tzname[0]));  \

  SET_STRING_ELT(tzone, 2, mkChar(R_tzname[1]));  \

    }

// Used in do_asPOSIXlt()  and  do_strptime() -- uses (stz, isUTC, tz) from enclosing function

#define GET_tz_n_CHECK              \

   if(!isString(stz) || LENGTH(stz) != 1)       \

  error(_("invalid '%s' value"), "tz");       \

   const char *tz = CHAR(STRING_ELT(stz, 0));       \

   bool new_tz = strlen(tz) == 0;  /* tz = "" */      \

   if(new_tz) {               \

  /* do a direct look up here as this does not otherwise    \

     work on Windows */           \

  char *p = getenv("TZ");           \

  if(p) {               \

      stz = mkString(p); /* make a copy */      \

      tz = CHAR(STRING_ELT(stz, 0));       \

      PROTECT(stz);            \

  } else               \

      new_tz = false;           \

    }                  \

    /*                  \

       isUTC here means that the timezone has been set to UTC   \

       either  by default, for example as the system timezone   \

       or      via TZ="UTC",            \

       or      via a 'tz' argument.         \

                  \

       It controls setting TZ, the use of gmtime vs localtime, forcing  \

       isdst = 0 and how the "tzone" attribute is set.      \

    */                  \

    bool isUTC = (strcmp(tz, "GMT") == 0 || strcmp(tz, "UTC") == 0);  \

    /*                  \

      if !isUTC we need to set the tz, not set tm_isdst and use mktime  \