datetime.c

Go to the documentation of this file.

/*****************************************************************************/
#include "tpcclibConfig.h"
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <locale.h>
#include <ctype.h>
#include <unistd.h>
#include <math.h>
/*****************************************************************************/
 
/*****************************************************************************/
#include "tpcextensions.h"
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_GMTIME_R
struct tm* gmtime_r(
  const time_t *t, 
  struct tm *tm
) {
  struct tm *ltm=gmtime(t);
  if(ltm==NULL || tm==NULL) return(NULL);
  *tm=*ltm; tm->tm_isdst=-1;
  return tm;
}
#endif // HAVE_GMTIME_R
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_LOCALTIME_R
struct tm* localtime_r(
  const time_t *t, 
  struct tm *tm
) {
  struct tm *ltm=localtime(t);
  if(ltm==NULL || tm==NULL) return(NULL);
  *tm=*ltm; tm->tm_isdst=-1;
  return tm;
}
#endif // HAVE_LOCALTIME_R
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_TIMEGM 
time_t timegm(
  struct tm *tm
) {
#if defined HAVE_GMTIME_R
  {
  time_t temp_lt;
  struct tm temp_gm;
  if(!tm) temp_lt=0; else temp_lt=mktime(tm);
  if(gmtime_r(&temp_lt, &temp_gm)==NULL) return((time_t)-1);
  return(time_t)(temp_lt + (temp_lt - mktime(&temp_gm)));
  }
#else
  time_t temp_lt;
  struct tm *temp_gm;
  if(!tm) temp_lt=0; else {tm->tm_isdst=-1; temp_lt=mktime(tm);}
  temp_gm=gmtime(&temp_lt); if(temp_gm) temp_gm->tm_isdst=-1;
  return(time_t)(temp_lt + (temp_lt - mktime(temp_gm)));
#endif
}
#endif // HAVE_TIMEGM
/*****************************************************************************/
 
/*****************************************************************************/
char* ctime_r_int(
  const time_t *t,
  char *buf
) {
  if(buf==NULL) return(NULL);
  buf[0]=(char)0;
  struct tm tm;
  if(!gmtime_r(t, &tm)) return(NULL);
  if(!strftime(buf, 20, "%Y-%m-%d %H:%M:%S", &tm)) return(NULL);
  return(buf);
}
/*****************************************************************************/
 
/*****************************************************************************/

static const unsigned short __mon_yday[2][13] = {
    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
    {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
};
/*****************************************************************************/
 
/*****************************************************************************/
int strDateValid(
  const char *str
) {
  if(str==NULL || strnlen(str, 10)<10) return 1;
  if(str[4]!='-' || str[7]!='-') return 2;
  if(strncasecmp(str, "YYYY-MM-DD", 10)==0) return -1;
  int Y, M, D, n;
  n=sscanf(str, "%4d-%2d-%2d", &Y, &M, &D); if(n!=3) return 3;
  if(M>12 || D>31) return -1;
  if(Y<0 || M<1 || D<1) return -1;
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strDateValid2(
  const char *str,
  char *intdate
) {
  if(str==NULL || strnlen(str, 10)<8) return 1;
  int n; char *cptr;
  cptr=(char*)str; n=strcspn(cptr, "./"); if(n<1 || n>2) return 2;
  cptr+=n+1; n=strcspn(cptr, "./"); if(n<1 || n>2) return 2;
  cptr+=n+1; n=strcspn(cptr, "./- \t\n\r"); if(n!=4) return 2;
  if(strncasecmp(str, "DD.MM.YYYY", 10)==0 || strncasecmp(str, "DD/MM/YYYY", 10)==0) {
    return -1;
  }
  int Y, M, D;
  n=sscanf(str, "%d/%d/%4d", &D, &M, &Y);
  if(n<3) n=sscanf(str, "%d.%d.%4d", &D, &M, &Y);
  if(n!=3) return 3;
  if(M>12 || D>31) return -1;
  if(Y<0 || M<1 || D<1) return -1;
  if(intdate!=NULL) sprintf(intdate, "%04d-%02d-%02d", Y, M, D);
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strDateValid3(
  const char *str,
  char *intdate
) {
  if(str==NULL || strnlen(str, 8)<6) return 1;
  int n; char *cptr;
  cptr=(char*)str; n=strcspn(cptr, "./"); if(n<1 || n>2) return 2;
  cptr+=n+1; n=strcspn(cptr, "./"); if(n<1 || n>2) return 2;
  cptr+=n+1; n=strcspn(cptr, "./- \t\n\r"); if(n!=2) return 2;
  if(strncasecmp(str, "DD.MM.YY", 8)==0 || strncasecmp(str, "DD/MM/YY", 8)==0) {
    return -1;
  }
  int Y, M, D;
  n=sscanf(str, "%d/%d/%2d", &D, &M, &Y);
  if(n<3) n=sscanf(str, "%d.%d.%2d", &D, &M, &Y);
  if(n!=3) return 3;
  if(Y>99 || M>12 || D>31) return -1;
  if(Y<0 || M<1 || D<1) return -1;
  if(intdate!=NULL) {
    if(Y>=70) Y+=1900; else Y+=2000;
    sprintf(intdate, "%04d-%02d-%02d", Y, M, D);
  }
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strDateValid4(
  int dateint,
  char *intdate,
  int *year,
  int *month,
  int *day
) {
  if(dateint<18000101 || dateint>99991231) return 1;
  int Y, M, D, n;
  n=dateint/100; D=dateint-100*n; Y=n/100; M=n-100*Y;
  if(M>12 || D>31) return -1;
  if(Y<1 || M<1 || D<1) return -1;
  if(year!=NULL) *year=Y;
  if(month!=NULL) *month=M;
  if(day!=NULL) *day=D;
  if(intdate!=NULL) {sprintf(intdate, "%04d-%02d-%02d", Y, M, D);}
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strTimeValid(
  const char *str
) {
  if(str==NULL || strnlen(str, 8)<8) return 1;
  if(str[2]!=':' || str[5]!=':') return 2;
  if(strncasecmp(str, "hh:mm:ss", 8)==0) return -1;
  int h, m, s, n;
  n=sscanf(str, "%d:%d:%d", &h, &m, &s); if(n!=3) return 3;
  if(h<0 || h>23 || m<0 || m>59 || s<0 || s>59) return -1;
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strDateTimeValid(
  const char *str,
  char *intdate
) {
  int ret1, ret2, len;
  char correct_date[20], *time_ptr=NULL, tmp[20];
 
  if(str==NULL) return 1;
  // 1/1/70 00:00:00 or 1970-01-01 00:00:00
  if(strnlen(str, 19)<15) return 1;
  /* Separate date and time */
  len=strcspn(str, " \t");
  if(len<6 || len>10) return 1;
  strlcpy(tmp, str, len+1); time_ptr=(char*)str+len+1;
  /* and check the date */
  correct_date[0]=(char)0;
  if((ret1=strDateValid(tmp))<=0) {strlcpy(correct_date, tmp, 20);}
  else if((ret1=strDateValid2(tmp, correct_date))<=0) {}
  else if((ret1=strDateValid3(tmp, correct_date))<=0) {}
  else {return 2;}
 
  /* the check the time */
  ret2=strTimeValid(time_ptr);
  if(ret1>0) {if(ret2>=0) return(100*ret1+ret2); else return(100*ret2);}
  if(ret2>0) return(10*ret2);
  if(ret1<0) {if(ret2<0) return(-3); else return(-1);}
  if(ret2<0) return(-2);
  if(intdate!=NULL) sprintf(intdate, "%10.10s %8.8s", correct_date, time_ptr);
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int strDateTimeRead(
  const char *str,
  struct tm *date
) {
  char buf[32];
  int ret, n, YYYY=0, MM=0, DD=0, hh=0, mm=0, ss=0;
 
  ret=strDateTimeValid(str, buf); if(ret!=0) return(ret);
  n=sscanf(buf, "%d-%d-%d %d:%d:%d", &YYYY, &MM, &DD, &hh, &mm, &ss);
  if(n!=6) return(40);
  date->tm_year=YYYY-1900; date->tm_mday=DD; date->tm_mon=MM-1;
  date->tm_hour=hh; date->tm_min=mm; date->tm_sec=ss; date->tm_isdst=-1;
#ifdef HAVE_TM_GMTOFF
  date->tm_gmtoff=0L;
#endif
  ret=strftime(buf, 32, "%Y-%m-%d %H:%M:%S", date);
  if(ret==0) return(50);
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/
int strDateRead(  
  const char *str,
  struct tm *date
) {
  char buf[32];
  int ret, n, YYYY=0, MM=0, DD=0;
 
  if(strnlen(str, 10)<8) return 1;
  if((ret=strDateValid(str))<=0) {
    strlcpy(buf, str, 11); 
  } else {
    ret=strDateValid2(str, buf);
    if(ret>0) ret=strDateValid3(str, buf);
  }
  if(ret>0) return 2;
  n=sscanf(buf, "%d-%d-%d", &YYYY, &MM, &DD);
  if(n!=3) return(3);
  date->tm_year=YYYY-1900; date->tm_mday=DD; date->tm_mon=MM-1;
  date->tm_hour=0; date->tm_min=0; date->tm_sec=0; date->tm_isdst=-1;
  ret=strftime(buf, 32, "%Y-%m-%d %H:%M:%S", date);
  if(ret==0) return(4);
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/

long int math_div(long int a, long int b)
{
  return a/b - (a%b < 0);
}
/*****************************************************************************/
 
/*****************************************************************************/
int isleapyear(long year)
{
  return (year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0);
}
/*****************************************************************************/
 
/*****************************************************************************/
long int leaps_between(long int year1, long int year2)
{
  long int leaps1, leaps2;
 
  leaps1=math_div(year1-1, 4) - math_div(year1-1, 100) + math_div(year1-1, 400);
  leaps2=math_div(year2-1, 4) - math_div(year2-1, 100) + math_div(year2-1, 400);
  return(leaps2-leaps1);
}
/*****************************************************************************/
 
/*****************************************************************************/

void time_to_tm(
  time_t totalsecs,
  int offset,
  struct tm *result
) {
  long int days, rem, y, yg;
  const unsigned short *ip;
 
  days=totalsecs/86400; rem=totalsecs%86400; rem+=offset;
  while(rem<0) {rem+=86400; --days;}
  while(rem>=86400) {rem-=86400; ++days;}
  result->tm_hour=rem/3600;
  rem%=3600; result->tm_min=rem/60;
  result->tm_sec=rem%60;
 
  /* January 1, 1970 was a Thursday. */
  result->tm_wday=(4+days)%7;
  if(result->tm_wday<0) result->tm_wday+=7;
  y=1970;
  while(days<0 || days>=(isleapyear(y)?366:365)) {
    /* Guess a corrected year, assuming 365 days per year. */
    yg=y+math_div(days, 365);
    /* Adjust days and y to match the guessed year. */
    days-=(yg-y)*365 + leaps_between(y, yg);
    y=yg;
  }
  result->tm_year=y-1900; result->tm_yday=days;
  ip=__mon_yday[isleapyear(y)];
  for(y=11; days<ip[y]; y--) continue;
  days-=ip[y]; result->tm_mon=y; result->tm_mday=days+1;
  result->tm_isdst=-1;
}
/*****************************************************************************/
 
/*****************************************************************************/
double tmDifference(
  struct tm *tm1,
  struct tm *tm0
) {
  return(difftime(mktime(tm1), mktime(tm0)));
}
/*****************************************************************************/
 
/*****************************************************************************/
void tmAdd(
  int s,
  struct tm *d
) {
  if(d==NULL) return;
  d->tm_sec+=s; 
  //mktime(d); // this automatically normalizes sec to hours etc if necessary
  timegm(d); // this automatically normalizes sec to hours etc if necessary
}
/*****************************************************************************/
 
/*****************************************************************************/
double strDateTimeDifference(
  const char *dt1,
  const char *dt0
) {
  if(dt1==NULL || dt0==NULL) return(0.0);
  struct tm tm1, tm0;
  if(strDateTimeRead(dt1, &tm1) || strDateTimeRead(dt0, &tm0)) return(0.0);
  return(tmDifference(&tm1, &tm0));
}
/*****************************************************************************/
 
/*****************************************************************************/
int strDateTimeAdd(
  int s,
  char *dt
) {
  if(dt==NULL) return(1);
  struct tm tm0;
  if(strDateTimeRead(dt, &tm0)) return(1);
  if(s==0) return(0);
  tmAdd(s, &tm0);
  if(!strftime(dt, 20, "%Y-%m-%d %H:%M:%S", &tm0)) return(2);
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/
double timespecDifference(
  struct timespec const *ts2,
  struct timespec const *ts1
) {
  if(ts1==NULL || ts2==NULL) return(nan(""));
  if(ts2->tv_sec < ts1->tv_sec)
    return(-timespecDifference(ts1, ts2));
  else
    return((double)(ts2->tv_sec - ts1->tv_sec) + (ts2->tv_nsec - ts1->tv_nsec)*1E-09);
}
/*****************************************************************************/
 
/*****************************************************************************/