#include "config.h"
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "libgfortran.h"
#undef HAVE_NO_DATE_TIME
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# ifdef HAVE_TIME_H
# include <time.h>
# else
# define HAVE_NO_DATE_TIME
# endif
# endif
#endif
#ifndef abs
#define abs(x) ((x)>=0 ? (x) : -(x))
#endif
#define DATE_LEN 8
#define TIME_LEN 10
#define ZONE_LEN 5
#define VALUES_SIZE 8
extern void date_and_time (char *, char *, char *, gfc_array_i4 *,
GFC_INTEGER_4, GFC_INTEGER_4, GFC_INTEGER_4);
export_proto(date_and_time);
void
date_and_time (char *__date, char *__time, char *__zone,
gfc_array_i4 *__values, GFC_INTEGER_4 __date_len,
GFC_INTEGER_4 __time_len, GFC_INTEGER_4 __zone_len)
{
int i;
char date[DATE_LEN + 1];
char timec[TIME_LEN + 1];
char zone[ZONE_LEN + 1];
GFC_INTEGER_4 values[VALUES_SIZE];
#ifndef HAVE_NO_DATE_TIME
time_t lt;
struct tm local_time;
struct tm UTC_time;
#if HAVE_GETTIMEOFDAY
{
struct timeval tp;
if (!gettimeofday (&tp, NULL))
{
lt = tp.tv_sec;
values[7] = tp.tv_usec / 1000;
}
else
{
lt = time (NULL);
values[7] = 0;
}
}
#else
lt = time (NULL);
values[7] = 0;
#endif
if (lt != (time_t) -1)
{
local_time = *localtime (<);
UTC_time = *gmtime (<);
values[0] = 1900 + local_time.tm_year;
values[1] = 1 + local_time.tm_mon;
values[2] = local_time.tm_mday;
values[3] = (local_time.tm_min - UTC_time.tm_min +
60 * (local_time.tm_hour - UTC_time.tm_hour +
24 * (local_time.tm_yday - UTC_time.tm_yday)));
values[4] = local_time.tm_hour;
values[5] = local_time.tm_min;
values[6] = local_time.tm_sec;
#if HAVE_SNPRINTF
if (__date)
snprintf (date, DATE_LEN + 1, "%04d%02d%02d",
values[0], values[1], values[2]);
if (__time)
snprintf (timec, TIME_LEN + 1, "%02d%02d%02d.%03d",
values[4], values[5], values[6], values[7]);
if (__zone)
snprintf (zone, ZONE_LEN + 1, "%+03d%02d",
values[3] / 60, abs (values[3] % 60));
#else
if (__date)
sprintf (date, "%04d%02d%02d", values[0], values[1], values[2]);
if (__time)
sprintf (timec, "%02d%02d%02d.%03d",
values[4], values[5], values[6], values[7]);
if (__zone)
sprintf (zone, "%+03d%02d",
values[3] / 60, abs (values[3] % 60));
#endif
}
else
{
memset (date, ' ', DATE_LEN);
date[DATE_LEN] = '\0';
memset (timec, ' ', TIME_LEN);
timec[TIME_LEN] = '\0';
memset (zone, ' ', ZONE_LEN);
zone[ZONE_LEN] = '\0';
for (i = 0; i < VALUES_SIZE; i++)
values[i] = - GFC_INTEGER_4_HUGE;
}
#else
memset (date, ' ', DATE_LEN);
date[DATE_LEN] = '\0';
memset (timec, ' ', TIME_LEN);
timec[TIME_LEN] = '\0';
memset (zone, ' ', ZONE_LEN);
zone[ZONE_LEN] = '\0';
for (i = 0; i < VALUES_SIZE; i++)
values[i] = - GFC_INTEGER_4_HUGE;
#endif
if (__values)
{
size_t len, delta, elt_size;
elt_size = GFC_DESCRIPTOR_SIZE (__values);
len = __values->dim[0].ubound + 1 - __values->dim[0].lbound;
delta = __values->dim[0].stride;
if (delta == 0)
delta = 1;
assert (len >= VALUES_SIZE);
if (elt_size == 4)
{
GFC_INTEGER_4 *vptr4 = __values->data;
for (i = 0; i < VALUES_SIZE; i++, vptr4 += delta)
*vptr4 = values[i];
}
else if (elt_size == 8)
{
GFC_INTEGER_8 *vptr8 = (GFC_INTEGER_8 *)__values->data;
for (i = 0; i < VALUES_SIZE; i++, vptr8 += delta)
{
if (values[i] == - GFC_INTEGER_4_HUGE)
*vptr8 = - GFC_INTEGER_8_HUGE;
else
*vptr8 = values[i];
}
}
else
abort ();
}
if (__zone)
{
assert (__zone_len >= ZONE_LEN);
fstrcpy (__zone, ZONE_LEN, zone, ZONE_LEN);
}
if (__time)
{
assert (__time_len >= TIME_LEN);
fstrcpy (__time, TIME_LEN, timec, TIME_LEN);
}
if (__date)
{
assert (__date_len >= DATE_LEN);
fstrcpy (__date, DATE_LEN, date, DATE_LEN);
}
}
extern GFC_REAL_4 secnds (GFC_REAL_4 *);
export_proto(secnds);
GFC_REAL_4
secnds (GFC_REAL_4 *x)
{
GFC_INTEGER_4 values[VALUES_SIZE];
GFC_REAL_4 temp1, temp2;
gfc_array_i4 *avalues = internal_malloc_size (sizeof (gfc_array_i4));
avalues->data = &values[0];
GFC_DESCRIPTOR_DTYPE (avalues) = ((GFC_DTYPE_REAL << GFC_DTYPE_TYPE_SHIFT)
& GFC_DTYPE_TYPE_MASK) +
(4 << GFC_DTYPE_SIZE_SHIFT);
avalues->dim[0].ubound = 7;
avalues->dim[0].lbound = 0;
avalues->dim[0].stride = 1;
date_and_time (NULL, NULL, NULL, avalues, 0, 0, 0);
free_mem (avalues);
temp1 = 3600.0 * (GFC_REAL_4)values[4] +
60.0 * (GFC_REAL_4)values[5] +
(GFC_REAL_4)values[6] +
0.001 * (GFC_REAL_4)values[7];
temp2 = fmod (*x, 86400.0);
temp2 = (temp1 - temp2 >= 0.0) ? temp2 : (temp2 - 86400.0);
return temp1 - temp2;
}
static void
itime0 (int x[3])
{
#ifndef HAVE_NO_DATE_TIME
time_t lt;
struct tm local_time;
lt = time (NULL);
if (lt != (time_t) -1)
{
local_time = *localtime (<);
x[0] = local_time.tm_hour;
x[1] = local_time.tm_min;
x[2] = local_time.tm_sec;
}
#else
x[0] = x[1] = x[2] = -1;
#endif
}
extern void itime_i4 (gfc_array_i4 *);
export_proto(itime_i4);
void
itime_i4 (gfc_array_i4 *__values)
{
int x[3], i;
size_t len, delta;
GFC_INTEGER_4 *vptr;
itime0(x);
len = __values->dim[0].ubound + 1 - __values->dim[0].lbound;
assert (len >= 3);
delta = __values->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = __values->data;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
extern void itime_i8 (gfc_array_i8 *);
export_proto(itime_i8);
void
itime_i8 (gfc_array_i8 *__values)
{
int x[3], i;
size_t len, delta;
GFC_INTEGER_8 *vptr;
itime0(x);
len = __values->dim[0].ubound + 1 - __values->dim[0].lbound;
assert (len >= 3);
delta = __values->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = __values->data;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
static void
idate0 (int x[3])
{
#ifndef HAVE_NO_DATE_TIME
time_t lt;
struct tm local_time;
lt = time (NULL);
if (lt != (time_t) -1)
{
local_time = *localtime (<);
x[0] = local_time.tm_mday;
x[1] = 1 + local_time.tm_mon;
x[2] = 1900 + local_time.tm_year;
}
#else
x[0] = x[1] = x[2] = -1;
#endif
}
extern void idate_i4 (gfc_array_i4 *);
export_proto(idate_i4);
void
idate_i4 (gfc_array_i4 *__values)
{
int x[3], i;
size_t len, delta;
GFC_INTEGER_4 *vptr;
idate0(x);
len = __values->dim[0].ubound + 1 - __values->dim[0].lbound;
assert (len >= 3);
delta = __values->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = __values->data;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
extern void idate_i8 (gfc_array_i8 *);
export_proto(idate_i8);
void
idate_i8 (gfc_array_i8 *__values)
{
int x[3], i;
size_t len, delta;
GFC_INTEGER_8 *vptr;
idate0(x);
len = __values->dim[0].ubound + 1 - __values->dim[0].lbound;
assert (len >= 3);
delta = __values->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = __values->data;
for (i = 0; i < 3; i++, vptr += delta)
*vptr = x[i];
}
static void
gmtime_0 (const time_t * t, int x[9])
{
struct tm lt;
lt = *gmtime (t);
x[0] = lt.tm_sec;
x[1] = lt.tm_min;
x[2] = lt.tm_hour;
x[3] = lt.tm_mday;
x[4] = lt.tm_mon;
x[5] = lt.tm_year;
x[6] = lt.tm_wday;
x[7] = lt.tm_yday;
x[8] = lt.tm_isdst;
}
extern void gmtime_i4 (GFC_INTEGER_4 *, gfc_array_i4 *);
export_proto(gmtime_i4);
void
gmtime_i4 (GFC_INTEGER_4 * t, gfc_array_i4 * tarray)
{
int x[9], i;
size_t len, delta;
GFC_INTEGER_4 *vptr;
time_t tt;
tt = (time_t) *t;
gmtime_0(&tt, x);
len = tarray->dim[0].ubound + 1 - tarray->dim[0].lbound;
assert (len >= 9);
delta = tarray->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = tarray->data;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}
extern void gmtime_i8 (GFC_INTEGER_8 *, gfc_array_i8 *);
export_proto(gmtime_i8);
void
gmtime_i8 (GFC_INTEGER_8 * t, gfc_array_i8 * tarray)
{
int x[9], i;
size_t len, delta;
GFC_INTEGER_8 *vptr;
time_t tt;
tt = (time_t) *t;
gmtime_0(&tt, x);
len = tarray->dim[0].ubound + 1 - tarray->dim[0].lbound;
assert (len >= 9);
delta = tarray->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = tarray->data;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}
static void
ltime_0 (const time_t * t, int x[9])
{
struct tm lt;
lt = *localtime (t);
x[0] = lt.tm_sec;
x[1] = lt.tm_min;
x[2] = lt.tm_hour;
x[3] = lt.tm_mday;
x[4] = lt.tm_mon;
x[5] = lt.tm_year;
x[6] = lt.tm_wday;
x[7] = lt.tm_yday;
x[8] = lt.tm_isdst;
}
extern void ltime_i4 (GFC_INTEGER_4 *, gfc_array_i4 *);
export_proto(ltime_i4);
void
ltime_i4 (GFC_INTEGER_4 * t, gfc_array_i4 * tarray)
{
int x[9], i;
size_t len, delta;
GFC_INTEGER_4 *vptr;
time_t tt;
tt = (time_t) *t;
ltime_0(&tt, x);
len = tarray->dim[0].ubound + 1 - tarray->dim[0].lbound;
assert (len >= 9);
delta = tarray->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = tarray->data;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}
extern void ltime_i8 (GFC_INTEGER_8 *, gfc_array_i8 *);
export_proto(ltime_i8);
void
ltime_i8 (GFC_INTEGER_8 * t, gfc_array_i8 * tarray)
{
int x[9], i;
size_t len, delta;
GFC_INTEGER_8 *vptr;
time_t tt;
tt = (time_t) * t;
ltime_0(&tt, x);
len = tarray->dim[0].ubound + 1 - tarray->dim[0].lbound;
assert (len >= 9);
delta = tarray->dim[0].stride;
if (delta == 0)
delta = 1;
vptr = tarray->data;
for (i = 0; i < 9; i++, vptr += delta)
*vptr = x[i];
}