StdLib: GCC 6 build fixes

[mirror_edk2.git] / StdLib / LibC / Time / Time.c

/**\r
  Definitions and Implementation for <time.h>.\r
\r
  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
  This program and the accompanying materials are licensed and made available under\r
  the terms and conditions of the BSD License that accompanies this distribution.\r
  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php.\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
  Portions derived from the NIH time zone package file, localtime.c,\r
  which contains the following notice:\r
\r
    This file is in the public domain, so clarified as of\r
    1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov).\r
\r
  NetBSD: localtime.c,v 1.39 2006/03/22 14:01:30 christos Exp\r
**/\r
#include  <Uefi.h>\r
#include  <Library/UefiLib.h>\r
#include  <Library/TimerLib.h>\r
#include  <Library/BaseLib.h>\r
#include  <Library/UefiRuntimeServicesTableLib.h>\r
//#include  <Library/UefiRuntimeLib.h>\r
\r
#include  <LibConfig.h>\r
\r
#include  <errno.h>\r
#include  <limits.h>\r
#include  <time.h>\r
#include  <reentrant.h>\r
#include  "tzfile.h"\r
#include  "TimeVals.h"\r
#include  <MainData.h>\r
#include  <extern.h>      // Library/include/extern.h: Private to implementation\r
\r
#if defined(_MSC_VER)           /* Handle Microsoft VC++ compiler specifics. */\r
// Keep compiler quiet about casting from function to data pointers\r
#pragma warning ( disable : 4054 )\r
#endif  /* defined(_MSC_VER) */\r
\r
/* #######################  Private Data  ################################# */\r
\r
#if 0\r
static EFI_TIME TimeBuffer;\r
\r
  static  UINT16   MonthOffs[12] = {\r
     00,\r
     31,   59,   90,  120,\r
    151,  181,  212,  243,\r
    273,  304,  334\r
  };\r
  static  clock_t   y2kOffs = 730485;\r
#endif\r
\r
const int  mon_lengths[2][MONSPERYEAR] = {\r
  { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },\r
  { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }\r
};\r
\r
const int  year_lengths[2] = {\r
  DAYSPERNYEAR, DAYSPERLYEAR\r
};\r
\r
\r
static const char *wday_name[7] = {\r
  "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"\r
};\r
\r
static const char *mon_name[12] = {\r
  "Jan", "Feb", "Mar", "Apr", "May", "Jun",\r
  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"\r
};\r
\r
static int    gmt_is_set;\r
\r
/* ###############  Implementation Functions  ############################ */\r
// Forward reference\r
static void\r
localsub(const time_t * const timep, const long   offset, struct tm * const tmp);\r
\r
clock_t\r
__getCPS(void)\r
{\r
  return gMD->ClocksPerSecond;\r
}\r
\r
static void\r
timesub(\r
  const time_t        * const timep,\r
  const long                  offset,\r
  const struct state  * const sp,\r
        struct tm     * const tmp\r
  )\r
{\r
  const struct lsinfo *  lp;\r
  time_t /*INTN*/     days;\r
  time_t /*INTN*/     rem;\r
  time_t /*INTN*/      y;\r
  int      yleap;\r
  const int *    ip;\r
  time_t /*INTN*/     corr;\r
  int      hit;\r
  int      i;\r
\r
  corr = 0;\r
  hit = 0;\r
#ifdef ALL_STATE\r
  i = (sp == NULL) ? 0 : sp->leapcnt;\r
#endif /* defined ALL_STATE */\r
#ifndef ALL_STATE\r
  i = sp->leapcnt;\r
#endif /* State Farm */\r
  while (--i >= 0) {\r
    lp = &sp->lsis[i];\r
    if (*timep >= lp->ls_trans) {\r
      if (*timep == lp->ls_trans) {\r
        hit = ((i == 0 && lp->ls_corr > 0) ||\r
               lp->ls_corr > sp->lsis[i - 1].ls_corr);\r
        if (hit)\r
          while (i > 0                                                &&\r
                 sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 &&\r
                 sp->lsis[i].ls_corr  == sp->lsis[i - 1].ls_corr  + 1 )\r
          {\r
            ++hit;\r
            --i;\r
          }\r
      }\r
      corr = lp->ls_corr;\r
      break;\r
    }\r
  }\r
  days = *timep / SECSPERDAY;\r
  rem = *timep % SECSPERDAY;\r
  rem += (offset - corr);\r
  while (rem < 0) {\r
    rem += SECSPERDAY;\r
    --days;\r
  }\r
  while (rem >= SECSPERDAY) {\r
    rem -= SECSPERDAY;\r
    ++days;\r
  }\r
  tmp->tm_hour = (int) (rem / SECSPERHOUR);\r
  rem = rem % SECSPERHOUR;\r
  tmp->tm_min = (int) (rem / SECSPERMIN);\r
  /*\r
  ** A positive leap second requires a special\r
  ** representation.  This uses "... ??:59:60" et seq.\r
  */\r
  tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;\r
  tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);\r
  if (tmp->tm_wday < 0)\r
    tmp->tm_wday += DAYSPERWEEK;\r
  y = EPOCH_YEAR;\r
  while (days < 0 || days >= (LONG32) year_lengths[yleap = isleap(y)]) {\r
    time_t /*INTN*/  newy;\r
\r
    newy = (y + days / DAYSPERNYEAR);\r
    if (days < 0)\r
      --newy;\r
    days -= (newy - y) * DAYSPERNYEAR +\r
      LEAPS_THRU_END_OF(newy - 1) -\r
      LEAPS_THRU_END_OF(y - 1);\r
    y = newy;\r
  }\r
  tmp->tm_year = (int)(y - TM_YEAR_BASE);\r
  tmp->tm_yday = (int) days;\r
  ip = mon_lengths[yleap];\r
  for (tmp->tm_mon = 0; days >= (LONG32) ip[tmp->tm_mon]; ++(tmp->tm_mon))\r
    days = days - (LONG32) ip[tmp->tm_mon];\r
  tmp->tm_mday = (int) (days + 1);\r
  tmp->tm_isdst = 0;\r
#ifdef TM_GMTOFF\r
  tmp->TM_GMTOFF = offset;\r
#endif /* defined TM_GMTOFF */\r
}\r
\r
/* ###############  Time Manipulation Functions  ########################## */\r
\r
/**\r
**/\r
double\r
difftime(time_t time1, time_t time0)\r
{\r
  return (double)(time1 - time0);\r
}\r
\r
/*\r
** Adapted from code provided by Robert Elz, who writes:\r
**  The "best" way to do mktime I think is based on an idea of Bob\r
**  Kridle's (so its said...) from a long time ago.\r
**  [kridle@xinet.com as of 1996-01-16.]\r
**  It does a binary search of the time_t space.  Since time_t's are\r
**  just 32 bits, its a max of 32 iterations (even at 64 bits it\r
**  would still be very reasonable).\r
*/\r
\r
#ifndef WRONG\r
#define WRONG (-1)\r
#endif /* !defined WRONG */\r
\r
/*\r
** Simplified normalize logic courtesy Paul Eggert (eggert@twinsun.com).\r
*/\r
\r
static int\r
increment_overflow(int * number, int delta)\r
{\r
  int number0;\r
\r
  number0 = *number;\r
  *number += delta;\r
  return (*number < number0) != (delta < 0);\r
}\r
\r
static int\r
normalize_overflow(int * const tensptr, int * const unitsptr, const int base)\r
{\r
  register int  tensdelta;\r
\r
  tensdelta = (*unitsptr >= 0)  ?\r
              (*unitsptr / base) : (-1 - (-1 - *unitsptr) / base);\r
  *unitsptr -= tensdelta * base;\r
  return increment_overflow(tensptr, tensdelta);\r
}\r
\r
static int\r
tmcomp(const struct tm * const atmp, const struct tm * const btmp)\r
{\r
  register int  result;\r
\r
  if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&\r
      (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&\r
      (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&\r
      (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&\r
      (result = (atmp->tm_min - btmp->tm_min)) == 0)\r
    result = atmp->tm_sec - btmp->tm_sec;\r
  return result;\r
}\r
\r
static time_t\r
time2sub(\r
  struct tm * const tmp,\r
  void (* const funcp)(const time_t*, long, struct tm*),\r
  const long offset,\r
  int * const okayp,\r
  const int do_norm_secs\r
  )\r
{\r
  register const struct state * sp;\r
  register int                  dir;\r
  register int                  bits;\r
  register int                  i, j ;\r
  register int                  saved_seconds;\r
  time_t                        newt;\r
  time_t                        t;\r
  struct tm                     yourtm, mytm;\r
\r
  *okayp = FALSE;\r
  yourtm = *tmp;    // Create a copy of tmp\r
  if (do_norm_secs) {\r
    if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec,\r
                           SECSPERMIN))\r
      return WRONG;\r
  }\r
  if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))\r
    return WRONG;\r
  if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))\r
    return WRONG;\r
  if (normalize_overflow(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR))\r
    return WRONG;\r
  /*\r
  ** Turn yourtm.tm_year into an actual year number for now.\r
  ** It is converted back to an offset from TM_YEAR_BASE later.\r
  */\r
  if (increment_overflow(&yourtm.tm_year, TM_YEAR_BASE))\r
    return WRONG;\r
  while (yourtm.tm_mday <= 0) {\r
    if (increment_overflow(&yourtm.tm_year, -1))\r
      return WRONG;\r
    i = yourtm.tm_year + (1 < yourtm.tm_mon);\r
    yourtm.tm_mday += year_lengths[isleap(i)];\r
  }\r
  while (yourtm.tm_mday > DAYSPERLYEAR) {\r
    i = yourtm.tm_year + (1 < yourtm.tm_mon);\r
    yourtm.tm_mday -= year_lengths[isleap(i)];\r
    if (increment_overflow(&yourtm.tm_year, 1))\r
      return WRONG;\r
  }\r
  for ( ; ; ) {\r
    i = mon_lengths[isleap(yourtm.tm_year)][yourtm.tm_mon];\r
    if (yourtm.tm_mday <= i)\r
      break;\r
    yourtm.tm_mday -= i;\r
    if (++yourtm.tm_mon >= MONSPERYEAR) {\r
      yourtm.tm_mon = 0;\r
      if (increment_overflow(&yourtm.tm_year, 1))\r
        return WRONG;\r
    }\r
  }\r
  if (increment_overflow(&yourtm.tm_year, -TM_YEAR_BASE))\r
    return WRONG;\r
  if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)\r
    saved_seconds = 0;\r
  else if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR) {\r
    /*\r
    ** We can't set tm_sec to 0, because that might push the\r
    ** time below the minimum representable time.\r
    ** Set tm_sec to 59 instead.\r
    ** This assumes that the minimum representable time is\r
    ** not in the same minute that a leap second was deleted from,\r
    ** which is a safer assumption than using 58 would be.\r
    */\r
    if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))\r
      return WRONG;\r
    saved_seconds = yourtm.tm_sec;\r
    yourtm.tm_sec = SECSPERMIN - 1;\r
  } else {\r
    saved_seconds = yourtm.tm_sec;\r
    yourtm.tm_sec = 0;\r
  }\r
  /*\r
  ** Divide the search space in half\r
  ** (this works whether time_t is signed or unsigned).\r
  */\r
  bits = TYPE_BIT(time_t) - 1;\r
  /*\r
  ** Set t to the midpoint of our binary search.\r
  **\r
  ** If time_t is signed, then 0 is just above the median,\r
  ** assuming two's complement arithmetic.\r
  ** If time_t is unsigned, then (1 << bits) is just above the median.\r
  */\r
  t = TYPE_SIGNED(time_t) ? 0 : (((time_t) 1) << bits);\r
  for ( ; ; ) {\r
    (*funcp)(&t, offset, &mytm);    // Convert t to broken-down time in mytm\r
    dir = tmcomp(&mytm, &yourtm);   // Is mytm larger, equal, or less than yourtm?\r
    if (dir != 0) {                 // If mytm != yourtm...\r
      if (bits-- < 0)                   // If we have exhausted all the bits..\r
        return WRONG;                       // Return that we failed\r
      if (bits < 0)                     // If on the last bit...\r
        --t; /* may be needed if new t is minimal */\r
      else if (dir > 0)                 // else if mytm > yourtm...\r
        t -= ((time_t) 1) << bits;          // subtract half the remaining time-space\r
      else  t += ((time_t) 1) << bits;      // otherwise add half the remaining time-space\r
      continue;                     // Repeat for the next half\r
    }\r
    if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)\r
      break;\r
    /*\r
    ** Right time, wrong type.\r
    ** Hunt for right time, right type.\r
    ** It's okay to guess wrong since the guess\r
    ** gets checked.\r
    */\r
    /*\r
    ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.\r
    */\r
    sp = (const struct state *)\r
      (((void *) funcp == (void *) localsub) ?\r
       lclptr : gmtptr);\r
#ifdef ALL_STATE\r
    if (sp == NULL)\r
      return WRONG;\r
#endif /* defined ALL_STATE */\r
    for (i = sp->typecnt - 1; i >= 0; --i) {\r
      if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)\r
        continue;\r
      for (j = sp->typecnt - 1; j >= 0; --j) {\r
        if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)\r
          continue;\r
        newt = t + sp->ttis[j].tt_gmtoff -\r
          sp->ttis[i].tt_gmtoff;\r
        (*funcp)(&newt, offset, &mytm);\r
        if (tmcomp(&mytm, &yourtm) != 0)\r
          continue;\r
        if (mytm.tm_isdst != yourtm.tm_isdst)\r
          continue;\r
        /*\r
        ** We have a match.\r
        */\r
        t = newt;\r
        goto label;\r
      }\r
    }\r
    return WRONG;\r
  }\r
  label:\r
  newt = t + saved_seconds;\r
  if ((newt < t) != (saved_seconds < 0))\r
    return WRONG;\r
  t = newt;\r
  (*funcp)(&t, offset, tmp);\r
  *okayp = TRUE;\r
  return t;\r
}\r
\r
time_t\r
time2(struct tm * const tmp, void (* const funcp)(const time_t*, long, struct tm*),\r
      const long offset, int * const okayp)\r
{\r
  time_t  t;\r
\r
  /*\r
  ** First try without normalization of seconds\r
  ** (in case tm_sec contains a value associated with a leap second).\r
  ** If that fails, try with normalization of seconds.\r
  */\r
  t = time2sub(tmp, funcp, offset, okayp, FALSE);\r
  return *okayp ? t : time2sub(tmp, funcp, offset, okayp, TRUE);\r
}\r
\r
static time_t\r
time1(\r
  struct tm * const tmp,\r
  void (* const funcp)(const time_t *, long, struct tm *),\r
  const long offset\r
  )\r
{\r
  register time_t               t;\r
  register const struct state * sp;\r
  register int                  samei, otheri;\r
  register int                  sameind, otherind;\r
  register int                  i;\r
  register int                  nseen;\r
  int                           seen[TZ_MAX_TYPES];\r
  int                           types[TZ_MAX_TYPES];\r
  int                           okay;\r
\r
  if (tmp->tm_isdst > 1)\r
    tmp->tm_isdst = 1;\r
  t = time2(tmp, funcp, offset, &okay);\r
#ifdef PCTS\r
  /*\r
  ** PCTS code courtesy Grant Sullivan (grant@osf.org).\r
  */\r
  if (okay)\r
    return t;\r
  if (tmp->tm_isdst < 0)\r
    tmp->tm_isdst = 0;  /* reset to std and try again */\r
#endif /* defined PCTS */\r
#ifndef PCTS\r
  if (okay || tmp->tm_isdst < 0)\r
    return t;\r
#endif /* !defined PCTS */\r
  /*\r
  ** We're supposed to assume that somebody took a time of one type\r
  ** and did some math on it that yielded a "struct tm" that's bad.\r
  ** We try to divine the type they started from and adjust to the\r
  ** type they need.\r
  */\r
  /*\r
  ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.\r
  */\r
  sp = (const struct state *) (((void *) funcp == (void *) localsub) ?\r
                               lclptr : gmtptr);\r
#ifdef ALL_STATE\r
  if (sp == NULL)\r
    return WRONG;\r
#endif /* defined ALL_STATE */\r
  for (i = 0; i < sp->typecnt; ++i)\r
    seen[i] = FALSE;\r
  nseen = 0;\r
    for (i = sp->timecnt - 1; i >= 0; --i)\r
      if (!seen[sp->types[i]]) {\r
        seen[sp->types[i]] = TRUE;\r
        types[nseen++] = sp->types[i];\r
      }\r
    for (sameind = 0; sameind < nseen; ++sameind) {\r
      samei = types[sameind];\r
      if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)\r
        continue;\r
      for (otherind = 0; otherind < nseen; ++otherind) {\r
        otheri = types[otherind];\r
        if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)\r
          continue;\r
        tmp->tm_sec += (int)(sp->ttis[otheri].tt_gmtoff -\r
                             sp->ttis[samei].tt_gmtoff);\r
        tmp->tm_isdst = !tmp->tm_isdst;\r
        t = time2(tmp, funcp, offset, &okay);\r
        if (okay)\r
          return t;\r
        tmp->tm_sec -= (int)(sp->ttis[otheri].tt_gmtoff -\r
                             sp->ttis[samei].tt_gmtoff);\r
        tmp->tm_isdst = !tmp->tm_isdst;\r
      }\r
    }\r
    return WRONG;\r
}\r
\r
/** The mktime function converts the broken-down time, expressed as local time,\r
    in the structure pointed to by timeptr into a calendar time value with the\r
    same encoding as that of the values returned by the time function.  The\r
    original values of the tm_wday and tm_yday components of the structure are\r
    ignored, and the original values of the other components are not restricted\r
    to the ranges indicated above.  Thus, a positive or zero value for tm_isdst\r
    causes the mktime function to presume initially that Daylight Saving Time,\r
    respectively, is or is not in effect for the specified time. A negative\r
    value causes it to attempt to determine whether Daylight Saving Time is in\r
    effect for the specified time.  On successful completion, the values of the\r
    tm_wday and tm_yday components of the structure are set appropriately, and\r
    the other components are set to represent the specified calendar time, but\r
    with their values forced to the ranges indicated above; the final value of\r
    tm_mday is not set until tm_mon and tm_year are determined.\r
\r
    @return   The mktime function returns the specified calendar time encoded\r
              as a value of type time_t.  If the calendar time cannot be\r
              represented, the function returns the value (time_t)(-1).\r
**/\r
time_t\r
mktime(struct tm *timeptr)\r
{\r
  /* From NetBSD */\r
  time_t result;\r
\r
  rwlock_wrlock(&lcl_lock);\r
  tzset();\r
  result = time1(timeptr, &localsub, 0L);\r
  rwlock_unlock(&lcl_lock);\r
  return (result);\r
}\r
\r
/** The time function determines the current calendar time.  The encoding of\r
    the value is unspecified.\r
\r
    @return   The time function returns the implementation's best approximation\r
              to the current calendar time.  The value (time_t)(-1) is returned\r
              if the calendar time is not available.  If timer is not a null\r
              pointer, the return value is also assigned to the object it\r
              points to.\r
**/\r
time_t\r
time(time_t *timer)\r
{\r
  time_t      CalTime;\r
  EFI_STATUS  Status;\r
  EFI_TIME   *ET;\r
  struct tm  *BT;\r
\r
  ET = &gMD->TimeBuffer;\r
  BT = &gMD->BDTime;\r
\r
  // Get EFI Time\r
  Status = gRT->GetTime( ET, NULL);\r
//  Status = EfiGetTime( ET, NULL);\r
  EFIerrno = Status;\r
  if( Status != RETURN_SUCCESS) {\r
    return (time_t)-1;\r
  }\r
\r
  // Convert EFI time to broken-down time.\r
  Efi2Tm( ET, BT);\r
\r
  // Convert to time_t\r
  CalTime  =  mktime(&gMD->BDTime);\r
\r
  if( timer != NULL) {\r
    *timer = CalTime;\r
  }\r
  return CalTime;   // Return calendar time in microseconds\r
}\r
\r
/** The clock function determines the processor time used.\r
\r
    @return   The clock function returns the implementation's best\r
              approximation to the processor time used by the program since the\r
              beginning of an implementation-defined era related only to the\r
              program invocation.  To determine the time in seconds, the value\r
              returned by the clock function should be divided by the value of\r
              the macro CLOCKS_PER_SEC.  If the processor time used is not\r
              available or its value cannot be represented, the function\r
              returns the value (clock_t)(-1).\r
**/\r
clock_t\r
clock(void)\r
{\r
  clock_t   retval;\r
  time_t    temp;\r
\r
  temp = time(NULL);\r
  retval = ((clock_t)((UINT32)temp)) - gMD->AppStartTime;\r
  return retval;\r
}\r
\r
/* #################  Time Conversion Functions  ########################## */\r
/*\r
    Except for the strftime function, these functions each return a pointer to\r
    one of two types of static objects: a broken-down time structure or an\r
    array of char.  Execution of any of the functions that return a pointer to\r
    one of these object types may overwrite the information in any object of\r
    the same type pointed to by the value returned from any previous call to\r
    any of them.  The implementation shall behave as if no other library\r
    functions call these functions.\r
*/\r
\r
/** The asctime function converts the broken-down time in the structure pointed\r
    to by timeptr into a string in the form\r
      Sun Sep 16 01:03:52 1973\n\0\r
    using the equivalent of the following algorithm.\r
\r
      char *asctime(const struct tm *timeptr)\r
      {\r
        static const char wday_name[7][3] = {\r
          "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"\r
        };\r
        static const char mon_name[12][3] = {\r
          "Jan", "Feb", "Mar", "Apr", "May", "Jun",\r
          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"\r
        };\r
        static char result[26];\r
        sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",\r
                wday_name[timeptr->tm_wday],\r
                mon_name[timeptr->tm_mon],\r
                timeptr->tm_mday, timeptr->tm_hour,\r
                timeptr->tm_min, timeptr->tm_sec,\r
                1900 + timeptr->tm_year);\r
        return result;\r
      }\r
    @return   The asctime function returns a pointer to the string.\r
**/\r
char *\r
asctime(const struct tm *timeptr)\r
{\r
  register const char * wn;\r
  register const char * mn;\r
\r
  if (timeptr->tm_wday < 0 || timeptr->tm_wday >= DAYSPERWEEK)\r
    wn = "???";\r
  else  wn = wday_name[timeptr->tm_wday];\r
  if (timeptr->tm_mon < 0 || timeptr->tm_mon >= MONSPERYEAR)\r
    mn = "???";\r
  else  mn = mon_name[timeptr->tm_mon];\r
  /*\r
  ** The X3J11-suggested format is\r
  **  "%.3s %.3s%3d %02.2d:%02.2d:%02.2d %d\n"\r
  ** Since the .2 in 02.2d is ignored, we drop it.\r
  */\r
  (void)snprintf(gMD->ASasctime,\r
                 sizeof (char[ASCTIME_BUFLEN]),\r
                 "%.3s %.3s%3d %02d:%02d:%02d %d\r\n",    // explicit CRLF for EFI\r
                 wn, mn,\r
                 timeptr->tm_mday, timeptr->tm_hour,\r
                 timeptr->tm_min, timeptr->tm_sec,\r
                 TM_YEAR_BASE + timeptr->tm_year);\r
  return gMD->ASasctime;\r
}\r
\r
/**\r
**/\r
char *\r
ctime(const time_t *timer)\r
{\r
  return asctime(localtime(timer));\r
}\r
\r
/*\r
** gmtsub is to gmtime as localsub is to localtime.\r
*/\r
void\r
gmtsub(\r
  const time_t * const  timep,\r
  const long            offset,\r
  struct tm    * const  tmp\r
  )\r
{\r
#ifdef _REENTRANT\r
  static mutex_t gmt_mutex = MUTEX_INITIALIZER;\r
#endif\r
\r
  mutex_lock(&gmt_mutex);\r
  if (!gmt_is_set) {\r
    gmt_is_set = TRUE;\r
#ifdef ALL_STATE\r
    gmtptr = (struct state *) malloc(sizeof *gmtptr);\r
    if (gmtptr != NULL)\r
#endif /* defined ALL_STATE */\r
      gmtload(gmtptr);\r
  }\r
  mutex_unlock(&gmt_mutex);\r
  timesub(timep, offset, gmtptr, tmp);\r
#ifdef TM_ZONE\r
  /*\r
  ** Could get fancy here and deliver something such as\r
  ** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,\r
  ** but this is no time for a treasure hunt.\r
  */\r
  if (offset != 0)\r
    tmp->TM_ZONE = (__aconst char *)__UNCONST(wildabbr);\r
  else {\r
#ifdef ALL_STATE\r
    if (gmtptr == NULL)\r
      tmp->TM_ZONE = (__aconst char *)__UNCONST(gmt);\r
    else  tmp->TM_ZONE = gmtptr->chars;\r
#endif /* defined ALL_STATE */\r
#ifndef ALL_STATE\r
    tmp->TM_ZONE = gmtptr->chars;\r
#endif /* State Farm */\r
  }\r
#endif /* defined TM_ZONE */\r
}\r
\r
/**\r
**/\r
struct tm *\r
gmtime(const time_t *timer)\r
{\r
  gmtsub(timer, 0L, &gMD->BDTime);\r
  return &gMD->BDTime;\r
}\r
\r
static void\r
localsub(const time_t * const timep, const long   offset, struct tm * const tmp)\r
{\r
  register struct state *   sp;\r
  register const struct ttinfo *  ttisp;\r
  register int      i;\r
  const time_t      t = *timep;\r
\r
  sp = lclptr;\r
#ifdef ALL_STATE\r
  if (sp == NULL) {\r
    gmtsub(timep, offset, tmp);\r
    return;\r
  }\r
#endif /* defined ALL_STATE */\r
  if (sp->timecnt == 0 || t < sp->ats[0]) {\r
    i = 0;\r
    while (sp->ttis[i].tt_isdst)\r
      if (++i >= sp->typecnt) {\r
        i = 0;\r
        break;\r
      }\r
  } else {\r
    for (i = 1; i < sp->timecnt; ++i)\r
      if (t < sp->ats[i])\r
      break;\r
    i = sp->types[i - 1];\r
  }\r
  ttisp = &sp->ttis[i];\r
  /*\r
  ** To get (wrong) behavior that's compatible with System V Release 2.0\r
  ** you'd replace the statement below with\r
  **  t += ttisp->tt_gmtoff;\r
  **  timesub(&t, 0L, sp, tmp);\r
  */\r
  timesub(&t, ttisp->tt_gmtoff, sp, tmp);\r
  tmp->tm_isdst = ttisp->tt_isdst;\r
  tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];\r
#ifdef TM_ZONE\r
  tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];\r
#endif /* defined TM_ZONE */\r
}\r
\r
/**\r
**/\r
struct tm *\r
localtime(const time_t *timer)\r
{\r
  tzset();\r
  localsub(timer, 0L, &gMD->BDTime);\r
  return &gMD->BDTime;\r
}\r