#define COMPILING_RCPP

#include <Rcpp.h>

#include <time.h> // for gmtime

#include <Rcpp/exceptions.h>

namespace Rcpp {

// Taken (in 2010) from R's src/main/datetime.c and made a member function called with C++ reference

// Later, R added the following comment we now (in 2016) add

/*

// Now, R only ships share/zoneinfo on Windows AFAIK

/* Substitute for mktime -- no checking, always in GMT */

// [[Rcpp::register]]

double mktime00(struct tm &tm) {

}

#undef isleap

#undef days_in_year

#include "sys/types.h" /* for time_t */

#include "string.h"

#include "limits.h" /* for CHAR_BIT et al. */

#define _NO_OLDNAMES /* avoid tznames */

#include "time.h"

#undef _NO_OLDNAMES

#include <errno.h>

#ifndef EOVERFLOW

# define EOVERFLOW 79

#endif

#include "stdlib.h"

#include "stdint.h"

#include "stdio.h"

#include "fcntl.h"

#include "float.h" /* for FLT_MAX and DBL_MAX */

#include <unistd.h> // solaris needs this for read() and close()

#define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)

#define TYPE_SIGNED(type) (((type) -1) < 0)

#define TYPE_INTEGRAL(type) (((type) 0.5) != 0.5)

#define TWOS_COMPLEMENT(t) ((t) ~ (t) 0 < 0)

#define GRANDPARENTED "Local time zone must be set--see zic manual page"

#define YEARSPERREPEAT 400 /* years before a Gregorian repeat */

#define AVGSECSPERYEAR 31556952L

#define SECSPERREPEAT ((int_fast64_t) YEARSPERREPEAT * (int_fast64_t) AVGSECSPERYEAR)

#define SECSPERREPEAT_BITS 34 /* ceil(log2(SECSPERREPEAT)) */

#define is_digit(c) ((unsigned)(c) - '0' <= 9)

#define INITIALIZE(x) (x = 0)

#define MAXVAL(t, b) \

((t) (((t) 1 << ((b) - 1 - TYPE_SIGNED(t))) \

- 1 + ((t) 1 << ((b) - 1 - TYPE_SIGNED(t)))))

#define MINVAL(t, b) \

((t) (TYPE_SIGNED(t) ? - TWOS_COMPLEMENT(t) - MAXVAL(t, b) : 0))

static time_t const time_t_min = MINVAL(time_t, TYPE_BIT(time_t));

static time_t const time_t_max = MAXVAL(time_t, TYPE_BIT(time_t));

//#include "tzfile.h" // from src/extra/tzone/tzfile.h

// BEGIN ------------------------------------------------------------------------------------------ tzfile.h

#ifndef TZFILE_H

#define TZFILE_H

#ifndef TZDIR

#define TZDIR "/usr/local/etc/zoneinfo" /* Time zone object file directory */

#endif /* !defined TZDIR */

#ifndef TZDEFAULT

#define TZDEFAULT "localtime" // NB this is "UTC" in R, but R also loads tz data

#endif /* !defined TZDEFAULT */

#ifndef TZDEFRULES

#define TZDEFRULES "America/New_York"

#endif /* !defined TZDEFRULES */

#define TZ_MAGIC "TZif"

struct tzhead {

};

#ifndef TZ_MAX_TIMES

#define TZ_MAX_TIMES 1200

#endif /* !defined TZ_MAX_TIMES */

#ifndef TZ_MAX_TYPES

#ifndef NOSOLAR

#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */

#endif /* !defined NOSOLAR */

#ifdef NOSOLAR

#define TZ_MAX_TYPES 20 /* Maximum number of local time types */

#endif /* !defined NOSOLAR */

#endif /* !defined TZ_MAX_TYPES */

#ifndef TZ_MAX_CHARS

#define TZ_MAX_CHARS 100 /* Maximum number of abbreviation characters */

/* (limited by what unsigned chars can hold) */

#endif /* !defined TZ_MAX_CHARS */

#ifndef TZ_MAX_LEAPS

#define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */

#endif /* !defined TZ_MAX_LEAPS */

#define SECSPERMIN 60

#define MINSPERHOUR 60

#define HOURSPERDAY 24

#define DAYSPERWEEK 7

#define DAYSPERNYEAR 365

#define DAYSPERLYEAR 366

#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR)

#define SECSPERDAY ((int_fast32_t) SECSPERHOUR * HOURSPERDAY)

#define MONSPERYEAR 12

#define TM_SUNDAY 0

#define TM_MONDAY 1

#define TM_TUESDAY 2

#define TM_WEDNESDAY 3

#define TM_THURSDAY 4

#define TM_FRIDAY 5

#define TM_SATURDAY 6

#define TM_JANUARY 0

#define TM_FEBRUARY 1

#define TM_MARCH 2

#define TM_APRIL 3

#define TM_MAY 4

#define TM_JUNE 5

#define TM_JULY 6

#define TM_AUGUST 7

#define TM_SEPTEMBER 8

#define TM_OCTOBER 9

#define TM_NOVEMBER 10

#define TM_DECEMBER 11

#define TM_YEAR_BASE 1900

#define EPOCH_YEAR 1970

#define EPOCH_WDAY TM_THURSDAY

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

#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400)

#endif /* !defined TZFILE_H */

// -------------------------------------------------------------------------------------- END tzfile.h

//#include "localtime.c" // from src/extra/tzone/localtime.c

// note though that was included is partial as we support only gmtime_()

// BEGIN --------------------------------------------------------------------------------- localtime.c

#ifdef O_BINARY

#define OPEN_MODE (O_RDONLY | O_BINARY)

#endif /* defined O_BINARY */

#ifndef O_BINARY

#define OPEN_MODE O_RDONLY

#endif /* !defined O_BINARY */

static const char gmt[] = "GMT";

/*

#ifndef TZDEFRULESTRING

#define TZDEFRULESTRING ",M4.1.0,M10.5.0"

#endif /* !defined TZDEFDST */

#define BIGGEST(a, b) (((a) > (b)) ? (a) : (b))

#ifdef TZNAME_MAX

#define MY_TZNAME_MAX TZNAME_MAX

#endif /* defined TZNAME_MAX */

#ifndef TZNAME_MAX

#define MY_TZNAME_MAX 255

#endif /* !defined TZNAME_MAX */

struct ttinfo { /* time type information */

};

struct lsinfo { /* leap second information */

time_t ls_trans; /* transition time */

int_fast64_t ls_corr; /* correction to apply */

};

struct state {

};

struct rule {

};

#define JULIAN_DAY 0 /* Jn - Julian day */

#define DAY_OF_YEAR 1 /* n - day of year */

#define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */

static const int mon_lengths[2][MONSPERYEAR] = {

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

{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

};

static const int year_lengths[2] = {

DAYSPERNYEAR, DAYSPERLYEAR

};

static int gmt_is_set;

//static struct state lclmem;

static struct state gmtmem;

//#define lclptr (&lclmem)

#define gmtptr (&gmtmem)

static struct tm tm;

//extern const char *getTZinfo(void);

static int tzparse(const char * name, struct state * sp, int lastditch);

static int typesequiv(const struct state * sp, int a, int b);

static const char * getsecs(const char * strp, int_fast32_t * secsp);

static const char * getnum(const char * strp, int * const nump, const int min, const int max);

static const char * getrule(const char * strp, struct rule * const rulep);

static int_fast32_t transtime(int year, const struct rule * rulep, int_fast32_t offset);

static struct tm * timesub(const time_t *timep, int_fast32_t offset, const struct state *sp, struct tm *tmp);

static int leaps_thru_end_of(const int y);

/*

static int increment_overflow(int *const ip, int j) {

}

static int increment_overflow_time(time_t *tp, int_fast32_t j) { // #nocov start

}

static int_fast32_t detzcode(const char *const codep) {

}

static int_fast64_t detzcode64(const char *const codep) {

}

static int differ_by_repeat(const time_t t1, const time_t t0) {

}

static const char * getzname(const char * strp) {

char c;

while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' &&

c != '+')

++strp;

return strp;

}

static const char * getqzname(const char *strp, const int delim) {

int c;

while ((c = *strp) != '\0' && c != delim)

++strp;

return strp;

}

static const char * getoffset(const char *strp, int_fast32_t *const offsetp) {

int neg = 0;

if (*strp == '-') {

neg = 1;

++strp;

} else if (*strp == '+')

++strp;

strp = getsecs(strp, offsetp);

if (strp == NULL)

return NULL; /* illegal time */

if (neg)

*offsetp = -*offsetp;

return strp;

}

static const char * getsecs(const char *strp, int_fast32_t *const secsp) {

int num;

/*

strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);

if (strp == NULL)

return NULL;

*secsp = num * (int_fast32_t) SECSPERHOUR;

if (*strp == ':') {

++strp;

strp = getnum(strp, &num, 0, MINSPERHOUR - 1);

if (strp == NULL)

return NULL;

*secsp += num * SECSPERMIN;

if (*strp == ':') {

++strp;

/* 'SECSPERMIN' allows for leap seconds. */

strp = getnum(strp, &num, 0, SECSPERMIN);

if (strp == NULL)

return NULL;

*secsp += num;

}

}

return strp;

}

static const char * getnum(const char * strp, int * const nump, const int min, const int max) {

char c;

int num;

if (strp == NULL || !is_digit(c = *strp))

return NULL;

num = 0;

do {

num = num * 10 + (c - '0');

if (num > max)

return NULL; /* illegal value */

c = *++strp;

} while (is_digit(c));

if (num < min)

return NULL; /* illegal value */

*nump = num;

return strp;

}

static const char * getrule(const char * strp, struct rule * const rulep) {

if (*strp == 'J') {

/*

rulep->r_type = JULIAN_DAY;

++strp;

strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);

} else if (*strp == 'M') {

/*

rulep->r_type = MONTH_NTH_DAY_OF_WEEK;

++strp;

strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);

if (strp == NULL)

return NULL;

if (*strp++ != '.')

return NULL;

strp = getnum(strp, &rulep->r_week, 1, 5);

if (strp == NULL)

return NULL;

if (*strp++ != '.')

return NULL;

strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);

} else if (is_digit(*strp)) {

/*

rulep->r_type = DAY_OF_YEAR;

strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);

} else return NULL; /* invalid format */

if (strp == NULL)

return NULL;

if (*strp == '/') {

/*

++strp;

strp = getsecs(strp, &rulep->r_time);

} else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */

return strp;

}

// this routine modified / simplified / reduced in 2010

static int tzload(const char * name, struct state * const sp, const int doextend) {

}

/*

static int_fast32_t transtime(const int year, const struct rule *const rulep, const int_fast32_t offset) {

}

/*

static int tzparse(const char * name, struct state * const sp, const int lastditch) {