The R Project SVN R

/*
 *  R : A Computer Language for Statistical Data Analysis
 *  Copyright (c) 1989 The Regents of the University of California.
 *  Copyright (C) 2013-2014 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/
 */

/*
  Based on code from tzcode, which is turn said to be
  'Based on the UCB version with the copyright notice appearing below.'

  Extensive changes for use with R.

** Copyright (c) 1989 The Regents of the University of California.
** All rights reserved.
**
** Redistribution and use in source and binary forms are permitted
** provided that the above copyright notice and this paragraph are
** duplicated in all such forms and that any documentation,
** advertising materials, and other materials related to such
** distribution and use acknowledge that the software was developed
** by the University of California, Berkeley. The name of the
** University may not be used to endorse or promote products derived
** from this software without specific prior written permission.
** THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/


#include <config.h>

#undef HAVE_TM_ZONE
#define HAVE_TM_ZONE 1
#undef HAVE_TM_GMTOFF
#define HAVE_TM_GMTOFF 1

#include "tzfile.h"
#include <fcntl.h>
#include <locale.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h> // memcpy
#include <ctype.h>
#include <limits.h> // for INT_MAX

#include "datetime.h"

static char * _add(const char *, char *, const char *);
static char * _conv(int, const char *, char *, const char *);
static char * _fmt(const char *, const stm *, char *, const char *);
static char * _yconv(int, int, int, int, char *, const char *);

size_t
R_strftime(char * const s, const size_t maxsize, const char *const format,
       const stm *const t)
{
    char *p;
    R_tzset();

    p = _fmt(((format == NULL) ? "%c" : format), t, s, s + maxsize);
    if (p == s + maxsize)
    return 0;
    *p = '\0';
    return p - s;
}

#ifdef HAVE_NL_LANGINFO
// This was part of the configure check
# include <langinfo.h>

#else
static char *orig(const char *fmt, const stm *const t)
{
    static char buff[100]; // no known name is over 20 bytes
    struct tm tm;
    memset(&tm, 0, sizeof(struct tm));
    tm.tm_sec = t->tm_sec; tm.tm_min = t->tm_min; tm.tm_hour = t->tm_hour;
    tm.tm_mday = t->tm_mday; tm.tm_mon = t->tm_mon; tm.tm_year = t->tm_year;
    tm.tm_wday = t->tm_wday; tm.tm_yday = t->tm_yday;
    tm.tm_isdst = t->tm_isdst;
    strftime(buff, 100, fmt, &tm);
    return buff;
}
#endif

static char *
_fmt(const char *format, const stm *const t, char * pt, const char *const ptlim)
{
    for ( ; *format; ++format) {
    if (*format == '%') {
        /* Check for POSIX 2008 / GNU modifiers */
        char pad = '\0'; const char *f; int width = -1;
        // first look to see if this is %..Y
        for (f = format+1; *f ; f++)
        if(! (isdigit(*f) || *f == '_' || *f == '+')) break;
        if (*f == 'Y')  {
        while (1)
        {
            switch (*++format) {
            case '0':
            case '+': // pad with zeroes, and more (not here)
            case '_': // pad with spaces: GNU extension
            pad = *format;
            continue;
            default:
            break;
            }
            break;
        }
        if (isdigit (*format))
        {
            width = 0;
            do
            {
            if (width > INT_MAX / 10 || 
                (width == INT_MAX / 10 && *format - '0' > INT_MAX % 10))
                width = INT_MAX;
            else {width *= 10; width += *format - '0';}
            format++;
            }
            while (isdigit (*format));
        }
        --format;
        }

    label:
        switch (*++format) {
        case '\0':
        --format;
        break;

        /* now the locale-dependent cases */
#ifdef HAVE_NL_LANGINFO
        case 'A':
        pt = _add((t->tm_wday < 0 || t->tm_wday >= 7) ?
              "?" : nl_langinfo(DAY_1 + t->tm_wday),
              pt, ptlim);
        continue;
        case 'a':
        pt = _add((t->tm_wday < 0 || t->tm_wday >= 7) ?
              "?" : nl_langinfo(ABDAY_1 + t->tm_wday),
              pt, ptlim);
        continue;
        case 'B':
        pt = _add((t->tm_mon < 0 || t->tm_mon >= 12) ?
              "?" : nl_langinfo(MON_1 + t->tm_mon),
              pt, ptlim);
        continue;
        case 'b':
        case 'h':
        pt = _add((t->tm_mon < 0 || t->tm_mon >= 12) ?
              "?" : nl_langinfo(ABMON_1 + t->tm_mon),
              pt, ptlim);
        continue;
        case 'c':
        pt = _fmt(nl_langinfo(D_T_FMT), t, pt, ptlim);
        continue;
        case 'p':
        pt = _add(nl_langinfo(t->tm_hour < 12 ? AM_STR : PM_STR),
              pt, ptlim);
        continue;
        case 'P':
        {
            char *p = nl_langinfo(t->tm_hour < 12 ? AM_STR : PM_STR),
            *q, buff[20];
            for (q = buff; *p; ) *q++ = (char) tolower(*p++);
            *q = '\0'; 
            pt = _add(buff, pt, ptlim);
        }
        continue;
        case 'X':
        pt = _fmt(nl_langinfo(T_FMT), t, pt, ptlim);
        continue;
        case 'x':
        pt = _fmt(nl_langinfo(D_FMT), t, pt, ptlim);
        continue;
#else
        case 'A':
        pt = _add((t->tm_wday < 0 || t->tm_wday >= 7) ?
              "?" : orig("%A", t),
              pt, ptlim);
        continue;
        case 'a':
        pt = _add((t->tm_wday < 0 || t->tm_wday >= 7) ?
              "?" : orig("%a", t),
              pt, ptlim);
        continue;
        case 'B':
        pt = _add((t->tm_mon < 0 || t->tm_mon >= 12) ?
              "?" : orig("%B", t),
              pt, ptlim);
        continue;
        case 'b':
        case 'h':
        pt = _add((t->tm_mon < 0 || t->tm_mon >= 12) ?
              "?" : orig("%b", t),
              pt, ptlim);
        continue;
        case 'c':
        // In a C locale this is supposed to be
        // "%a %b %e %T %Y". It is not on Windows ....
#ifdef _WIN32
        pt = _fmt("%a %b %e %T %Y", t, pt, ptlim);
#else
        pt = _fmt(orig("%c", t), t, pt, ptlim);
#endif
        continue;
        case 'p':
        pt = _add(orig("%p", t), pt, ptlim);
        continue;
        case 'P':
        {
            char *p = orig("%p", t), *q, buff[20];
            for (q = buff; *p; ) *q++ = (char) tolower(*p++);
            *q = '\0'; 
            pt = _add(buff, pt, ptlim);
        }
        continue;
        case 'X':
        pt = _fmt(orig("%X", t), t, pt, ptlim);
        continue;
        case 'x':
        pt = _fmt(orig("%x", t), t, pt, ptlim);
        continue;
#endif
        /* now the locale-independent ones */
        case 'C':
        pt = _yconv(t->tm_year, TM_YEAR_BASE, 1, 0, pt, ptlim);
        continue;
        case 'D':
        pt = _fmt("%m/%d/%y", t, pt, ptlim);
        continue;
        case 'd':
        pt = _conv(t->tm_mday, "%02d", pt, ptlim);
        continue;
        case 'E':
        case 'O':
        /*
        ** C99 locale modifiers.
        ** The sequences
        **  %Ec %EC %Ex %EX %Ey %EY
        **  %Od %oe %OH %OI %Om %OM
        **  %OS %Ou %OU %OV %Ow %OW %Oy
        ** are supposed to provide alternate
        ** representations.
        */
        goto label;
        case 'e':
        pt = _conv(t->tm_mday, "%2d", pt, ptlim);
        continue;
        case 'F':
        pt = _fmt("%Y-%m-%d", t, pt, ptlim);
        continue;
        case 'H':
        pt = _conv(t->tm_hour, "%02d", pt, ptlim);
        continue;
        case 'I':
        pt = _conv((t->tm_hour % 12) ? (t->tm_hour % 12) : 12,
               "%02d", pt, ptlim);
        continue;
        case 'j':
        pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
        continue;
        case 'k':
        pt = _conv(t->tm_hour, "%2d", pt, ptlim);
        continue;
        case 'l':
        pt = _conv((t->tm_hour % 12) ? (t->tm_hour % 12) : 12,
               "%2d", pt, ptlim);
        continue;
        case 'M':
        pt = _conv(t->tm_min, "%02d", pt, ptlim);
        continue;
        case 'm':
        pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
        continue;
        case 'n':
        pt = _add("\n", pt, ptlim);
        continue;
        case 'R':
        pt = _fmt("%H:%M", t, pt, ptlim);
        continue;
        case 'r':
        pt = _fmt("%I:%M:%S %p", t, pt, ptlim);
        continue;
        case 'S':
        pt = _conv(t->tm_sec, "%02d", pt, ptlim);
        continue;
        case 's':
        {
        stm  tm = *t;
        char buf[22]; // <= 19 digs + sign + terminator
        int_fast64_t mkt = R_mktime(&tm);
#ifdef _WIN32
        // not ISO C99, so warns
        (void) snprintf(buf, 22, "%I64d", mkt);
#else
        (void) snprintf(buf, 22, "%lld", (long long) mkt);
#endif
        pt = _add(buf, pt, ptlim);
        }
        continue;
        case 'T':
        pt = _fmt("%H:%M:%S", t, pt, ptlim);
        continue;
        case 't':
        pt = _add("\t", pt, ptlim);
        continue;
        case 'U':
        pt = _conv((t->tm_yday + 7 - t->tm_wday) / 7,
               "%02d", pt, ptlim);
        continue;
        case 'u':
        pt = _conv((t->tm_wday == 0) ? 7 : t->tm_wday, "%d", pt, ptlim);
        continue;
        case 'V':   /* ISO 8601 week number */
        case 'G':   /* ISO 8601 year (four digits) */
        case 'g':   /* ISO 8601 year (two digits) */
        {
        int year, base, yday, wday, w;

        year = t->tm_year;
        base = TM_YEAR_BASE;
        yday = t->tm_yday;
        wday = t->tm_wday;
        for ( ; ; ) {
            int len, bot, top;

            len = isleap_sum(year, base) ? DAYSPERLYEAR : DAYSPERNYEAR;
            /*
            ** What yday (-3 ... 3) does
            ** the ISO year begin on?
            */
            bot = ((yday + 11 - wday) % 7) - 3;
            /*
            ** What yday does the NEXT
            ** ISO year begin on?
            */
            top = bot - (len % 7);
            if (top < -3)
            top += 7;
            top += len;
            if (yday >= top) {
            ++base;
            w = 1;
            break;
            }
            if (yday >= bot) {
            w = 1 + ((yday - bot) / 7);
            break;
            }
            --base;
            yday += isleap_sum(year, base) ? DAYSPERLYEAR : DAYSPERNYEAR;
        }
        if (*format == 'V')
            pt = _conv(w, "%02d", pt, ptlim);
        else if (*format == 'g')
            pt = _yconv(year, base, 0, 1, pt, ptlim);
        else // %G
            pt = _yconv(year, base, 1, 1, pt, ptlim);
        }
        continue;
        case 'v':
        pt = _fmt("%e-%b-%Y", t, pt, ptlim);
        continue;
        case 'W':
        pt = _conv((t->tm_yday + 7 -
                (t->tm_wday ? (t->tm_wday - 1) : (7 - 1))) / 7,
               "%02d", pt, ptlim);
        continue;
        case 'w':
        pt = _conv(t->tm_wday, "%d", pt, ptlim);
        continue;
        case 'y':
        pt = _yconv(t->tm_year, TM_YEAR_BASE, 0, 1, pt, ptlim);
        continue;
        case 'Y':
//      pt = _yconv(t->tm_year, TM_YEAR_BASE, 1, 1, pt, ptlim);
        {
        char buf[20] = "%";
        int year = TM_YEAR_BASE + t->tm_year;
        if (pad == '\0') { pad = '0'; width = 4;}
        if (pad == '0' || pad == '+') strcat(buf, "0");
        if (width > 0) sprintf(buf+strlen(buf), "%u", width);
        if (pad == '+' && year > 9999) strcat(buf, "+");
        strcat(buf, "d");
        pt = _conv(year, buf, pt, ptlim);
        }
        continue;
        case 'Z':
#ifdef HAVE_TM_ZONE
        if (t->tm_zone != NULL)
            pt = _add(t->tm_zone, pt, ptlim);
        else
#endif
        if (t->tm_isdst >= 0)
            pt = _add(R_tzname[t->tm_isdst != 0], pt, ptlim);
        /*
        ** C99 says that %Z must be replaced by the
        ** empty string if the time zone is not
        ** determinable.
        */
        continue;
        case 'z':
        {
        long  diff;
        char const *sign;

        if (t->tm_isdst < 0)
            continue;
#ifdef HAVE_TM_GMTOFF
        diff = t->tm_gmtoff;
#else
        diff = R_timegm(t) - R_mktime(t);
#endif
        if (diff < 0) {
            sign = "-";
            diff = -diff;
        } else  sign = "+";
        pt = _add(sign, pt, ptlim);
        diff /= SECSPERMIN;
        diff = (diff / MINSPERHOUR) * 100 + (diff % MINSPERHOUR);
        pt = _conv((int) diff, "%04d", pt, ptlim);
        }
        continue;
        case '+':
        pt = _fmt("%a %b %e %H:%M:%S %Z %Y", t, pt, ptlim);
        continue;
        case '%':
        default:
        break;
        }
    }
    if (pt == ptlim)
        break;
    *pt++ = *format;
    }
    return pt;
}

static char *
_conv(const int n, const char *const format, char *const pt,
      const char *const ptlim)
{
    char  buf[12];

    (void) snprintf(buf, 12, format, n);
    return _add(buf, pt, ptlim);
}

static char *
_add(const char *str, char *pt, const char *const ptlim)
{
    while (pt < ptlim && (*pt = *str++) != '\0')
    ++pt;
    return pt;
}

/*
** POSIX and the C Standard are unclear or inconsistent about
** what %C and %y do if the year is negative or exceeds 9999.
** Use the convention that %C concatenated with %y yields the
** same output as %Y, and that %Y contains at least 4 bytes,
** with more only if necessary.

* Explained in POSIX 2008, at least.
*/

static char *
_yconv(const int a, const int b, 
       const int convert_top, const int convert_yy,
       char *pt, const char *const ptlim)
{
    int lead, trail;

#define DIVISOR 100
    trail = a % DIVISOR + b % DIVISOR;
    lead = a / DIVISOR + b / DIVISOR + trail / DIVISOR;
    trail %= DIVISOR;
    if (trail < 0 && lead > 0) {
    trail += DIVISOR;
    --lead;
    } else if (lead < 0 && trail > 0) {
    trail -= DIVISOR;
    ++lead;
    }
    if (convert_top) {
    if (lead == 0 && trail < 0)
        pt = _add("-0", pt, ptlim);
    else pt = _conv(lead, "%02d", pt, ptlim);
    }
    if (convert_yy)
    pt = _conv(((trail < 0) ? -trail : trail), "%02d", pt, ptlim);
    return pt;
}