GeneralsZeroHour/GeneralsMD/Code/Tools/matchbot/wlib/xtime.cpp

/*
**	Command & Conquer Generals Zero Hour(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	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 3 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, see <http://www.gnu.org/licenses/>.
*/

/****************************************************************************\

xtime                      Neal Kettler

Improved version of the Wtime library (V->W->X...)

Handles signed times better and dates long
long long after you'll be dead.

\****************************************************************************/

#include <ctype.h>
#include <time.h>
#ifndef _WINDOWS
#include <sys/time.h>
#endif
#include "xtime.h"

static char *DAYS[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};

static char *FULLDAYS[]={"Sunday","Monday","Tuesday","Wednesday","Thursday",
               "Friday","Saturday"};

static char *MONTHS[]={"Jan","Feb","Mar","Apr","May","Jun","Jul",
               "Aug","Sep","Oct","Nov","Dec"};

static char *FULLMONTHS[]={"January","February","March","April","May","June",
               "July","August","September","October","November","December"};


#define IS_LEAP(y) ((y) % 4) == 0 && (! ((y) % 100) == 0 || ((y) % 400) == 0)
#define LEAPS_THRU_END_OF(y) ((y) / 4 - (y) / 100 + (y) / 400)


/////////////// Utility functions ///////////////////

//
// Return the daycount since year 0 for the specified date.
// month = 1-12, day = 1-31 year = 0...
//
static sint32 Get_Day(int month, int day, int year)
{
  time_t days;

  static int DaysAtMonth[] =
      {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};

  /* Add up number of straight days + number of leap days + days */
  /* up to the month + the day of month. */

  days = (year * 365) + (year / 4) - (year / 100) + (year / 400) +
      DaysAtMonth[month-1] + day;

  /* If we haven't hit Feb 29, and this is a leap year, we need to */
  /* subtract out the leap day that was added above for this year */

  if (month < 3 && IS_LEAP(year))
      --days;
    return(days);
}



//
// Get the year from a daycount since year 0
// Also get the daycount since the start of the year
//
// Ayecarumba what a pain in the ass!
//
static bit8 Get_Date_From_Day(sint32 days, OUT sint32 &year, OUT sint32 &yday)
{
  //register long int rem;
  register long int y;
  //register const unsigned short int *ip;
 
  if (days <= 365)
  {
    year=0;
    yday=days+1;  // 1 based
    return(TRUE);
  }

  y = 1;
  days-=365;

  days--;  // zero based
 
  //
  // As far as I can tell there's no non-iteritive way to
  //   do this...
  //
  while (days < 0 || days >= (IS_LEAP (y) ? 366 : 365))
  {
    /* Guess a corrected year, assuming 365 days per year.  */
    long int yg = y + days / 365 - (days % 365 < 0);
 
    /* Adjust DAYS and Y to match the guessed year.  */
    days -= ((yg - y) * 365
        + LEAPS_THRU_END_OF (yg - 1)
        - LEAPS_THRU_END_OF (y - 1));
      y = yg;
  }
  year=y;
  yday=days+1;  // 1 based
  return(TRUE);
}


//
// Get the max day of a given month in a given year
//
int Max_Day(int month, int year)
{
  static char dayTable[2][13] = {
    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
    {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
  };
  bit8 isleap=IS_LEAP(year);
  return(dayTable[isleap][month]);
}



/**********************************************************
int main(int argc, char *argv[])
{
  Xtime wtime;
  int month,mday,year,hour,minute,second,day;
  int i;
  int dayoffset;
  int yr;
  int yday;
  int ydaycount;

  wtime.set(719528,0);

***********************************************
  for (year=0; year<10000; year++)
  {
    ydaycount=1;
    for (month=1; month<=12; month++)
    {
      for (day=1; day<=Max_Day(month,year); day++)
      {
        dayoffset=Get_Day(month,day,year);
        assert (GetDateFromDay(dayoffset,yr,yday)==TRUE);

        //printf("Yday=%d YdayCount=%d\n",yday,ydaycount);

        if (yr!=year)
        {
          printf("MO=%d  DAY=%d  YEAR=%d  YR=%d\n",month,day,year,yr);
          assert(0);
        }
        if (yday != ydaycount)
        {
          printf("MO=%d  DAY=%d  YEAR=%d  YR=%d\n",month,day,year,yr);
          printf("Yday=%d YdayCount=%d\n",yday,ydaycount);
          assert(0);
        }
        ydaycount++;
      }
    } 
    printf("(%d) ",year);
  }
***************************************

  ///////wtime.addSeconds((60*60*24)-(60*60*8));
  ////////wtime.addSeconds(-(60*60*8));  // timezone delta

  dayoffset=Get_Day(1,1,1970);
  printf("DAYOFFSET = %d\n",dayoffset);


  wtime.getTime(month, mday, year, hour, minute, second);
  printf("\n%s %d  %d  %d:%02d:%02d\n\n",
    MONTHS[month-1],mday,year,hour,minute,second);

  struct  timeval   unixtime;
  struct  timezone  unixtzone;
  time_t    ttime;
  tm        tmtime;

  memset(&tmtime,0,sizeof(tmtime));
  ttime=0;
  unixtime.tv_sec=0;
  unixtime.tv_usec=0;

  //gettimeofday(&unixtime,&unixtzone);
  //ttime=time(NULL);
  tmtime=*gmtime(&ttime);

  printf("TIME->CTIME = %s\n",ctime(&ttime));
  printf("GTOD->CTIE = %s\n",ctime(&(unixtime.tv_sec)));
  printf("TIME->GMT->ASCTIME = %s\n",asctime(&tmtime));
}
***************************************************************/



//
// Construct with current clock time
//
Xtime::Xtime(void)
{
  update();
}

//
// Copy constructor
//
Xtime::Xtime( Xtime &other )
{
  day_=other.day_;
  msec_=other.msec_;
}

//
// Set to a time_t (1970-2038)
//
Xtime::Xtime( time_t other )
{
  day_=719528;  // days from year 0 to Jan1, 1970
  // Add seconds from time_t
  addSeconds(other);
  msec_=0;
}

Xtime::~Xtime()
{
}

//
// Add some number of seconds to the time (seconds can be negative)
//
void Xtime::addSeconds(sint32 seconds)
{
  // Add to day counter first
  day_+=(seconds/86400);
  msec_+=(seconds % 86400)*1000;

  // Now normalize in case msec is > 1 days worth
  normalize();
}

//
// If msec is > 1 days worth, adjust the day count
//   & decrement the msec counter until OK.
//
void Xtime::normalize(void)
{
  day_+=(msec_/86400000);
  msec_%=86400000;
 
  while (msec_ < 0)
  {
    day_--;
    msec_+=86400000;
  }
}

//
// Update time to hold the current clock time
// (breaks in 2038 :-)
//
void Xtime::update(void)
{
  day_=719528;  // day_s from year 0 to Jan1, 1970
  msec_=0;

 #ifdef _WINDOWS
  struct _timeb    wintime;
  _ftime(&wintime);
  addSeconds(wintime.time);
  msec_+=wintime.millitm;
 #endif
 #ifndef _WINDOWS
  struct timeval   unixtime;
  struct timezone  unixtzone;
  gettimeofday(&unixtime,&unixtzone);
  addSeconds(unixtime.tv_sec);
  msec_+=(unixtime.tv_usec/1000);
 #endif

  // Now normalize in case msec is > 1 days worth
  normalize();
}


// This takes the standard Microsoft time formatting string
// make sure the out string is big enough
// An example format would be "mm/dd/yy hh:mm:ss"
// CHANGE:  Joe Howes  06/30/99
// To specify 12-hour format, use "aa" instead of "hh".
// The hours will be 12 hour and the string will be
// appended with " AM" or " PM".
bit8 Xtime::FormatTime(char *out, char *format)
{
  int lastWasH=0;
  int ampmflag = 0;
  out[0]=0;
  char *ptr=format;
 
  if (*ptr=='"') ptr++;  // skip past open quote if exists
 
  while (*ptr!=0)
  {
    if (lastWasH>0)
      lastWasH--;
 
    if (isspace(*ptr))
    {
      if (lastWasH==1) lastWasH=2;
      sprintf(out+strlen(out),"%c",*ptr);
      ptr+=1;
    }
    else if (strncmp(ptr,"\"",1)==0)
    {
      break;
    }
    else if (strncmp(ptr,":",1)==0)
    {
      if (lastWasH==1) lastWasH=2;
      sprintf(out+strlen(out),":");
      ptr+=1;
    }
    else if (strncmp(ptr,"/",1)==0)
    {
      sprintf(out+strlen(out),"/");
      ptr+=1;
    }
    else if (strncmp(ptr,"c",1)==0)
    {
      sprintf(out+strlen(out),"%ld/%ld/%02ld %ld:%02ld:%02ld",getMonth(),
        getMDay(),getYear()%100,getHour(),getMinute(),getSecond());
      ptr+=1;
    }
    else if (strncmp(ptr,"dddddd",6)==0)
    {
      sprintf(out+strlen(out),"%s %02ld, %ld",FULLMONTHS[getMonth()-1],
        getMDay(),getYear());
      ptr+=6;
    }
    else if (strncmp(ptr,"ddddd",5)==0)
    {
      sprintf(out+strlen(out),"%ld/%ld/%02ld",getMonth(),getMDay(),
        getYear()%100);
      ptr+=5;
    }
    /*else if (strncmp(ptr,"dddd",4)==0)
    {
      sprintf(out+strlen(out),"%s",FULLDAYS[getWDay()-1]);
      ptr+=4;
    }
    else if (strncmp(ptr,"ddd",3)==0)
    {
      sprintf(out+strlen(out),"%s",DAYS[getWDay()-1]);
      ptr+=3;
    }*/
    else if (strncmp(ptr,"dd",2)==0)
    {
      sprintf(out+strlen(out),"%02ld",getMDay());
      ptr+=2;
    }
    else if (strncmp(ptr,"d",1)==0)
    {
      sprintf(out+strlen(out),"%ld",getMDay());
      ptr+=1;
    }
    /*else if (strncmp(ptr,"ww",2)==0)
    {
      sprintf(out+strlen(out),"%02ld",getYWeek());
      ptr+=2;
    }*/
    /*else if (strncmp(ptr,"w",1)==0)
    {
      sprintf(out+strlen(out),"%ld",getWDay());
      ptr+=1;
    }*/
    else if (strncmp(ptr,"mmmm",4)==0)
    {
      sprintf(out+strlen(out),"%s",FULLMONTHS[getMonth()-1]);
      ptr+=4;
    }
    else if (strncmp(ptr,"mmm",3)==0)
    {
      sprintf(out+strlen(out),"%s",MONTHS[getMonth()-1]);
      ptr+=3;
    }
    else if (strncmp(ptr,"mm",2)==0)
    {
      if (lastWasH==1)
        sprintf(out+strlen(out),"%02ld",getMinute());
      else
        sprintf(out+strlen(out),"%02ld",getMonth());
      ptr+=2;
    }
    else if (strncmp(ptr,"m",1)==0)
    {
      if (lastWasH==1)
        sprintf(out+strlen(out),"%ld",getMinute());
      else
        sprintf(out+strlen(out),"%ld",getMonth());
      ptr+=1;
    }
    else if (strncmp(ptr,"q",1)==0)
    {
      sprintf(out+strlen(out),"%ld",((getMonth()-1)/4)+1);  // GetQuarter
      ptr+=1;
    }
    else if (strncmp(ptr,"yyyy",4)==0)
    {
      sprintf(out+strlen(out),"%ld",getYear());
      ptr+=4;
    }
    else if (strncmp(ptr,"yy",2)==0)
    {
      sprintf(out+strlen(out),"%02ld",getYear()%100);
      ptr+=2;
    }
    /*else if (strncmp(ptr,"y",1)==0)
    {
      sprintf(out+strlen(out),"%ld",getYDay());
      ptr+=1;
    }*/
    else if (strncmp(ptr,"hh",2)==0)
    {
      sprintf(out+strlen(out),"%02ld",getHour());
      lastWasH=2;  // needs to be 1 after top of loop decs it
      ptr+=2;
    }
    else if (strncmp(ptr,"h",1)==0)
    {
      sprintf(out+strlen(out),"%ld",getHour());
      lastWasH=2;  // needs to be 1 after top of loop decs it
      ptr+=1;
    }
    else if (strncmp(ptr,"nn",2)==0)
    {
      sprintf(out+strlen(out),"%02ld",getMinute());
      ptr+=2;
    }
    else if (strncmp(ptr,"n",1)==0)
    {
      sprintf(out+strlen(out),"%ld",getMinute());
      ptr+=1;
    }
    else if (strncmp(ptr,"ss",2)==0)
    {
      sprintf(out+strlen(out),"%02ld",getSecond());
      ptr+=2;
    }
    else if (strncmp(ptr,"s",1)==0)
    {
      sprintf(out+strlen(out),"%ld",getSecond());
      ptr+=1;
    }
    else if (strncmp(ptr,"ttttt",5)==0)
    {
      sprintf(out+strlen(out),"%ld:%02ld:%02ld",getHour(),getMinute(),
        getSecond());
      ptr+=5;
    }
    else if (strncmp(ptr,"aa",2)==0)
    {
      uint32 tmp = (getHour() <= 12) ? getHour() : getHour() - 12;
      sprintf(out+strlen(out),"%02ld", tmp);
      lastWasH=2;  // needs to be 1 after top of loop decs it
      ptr+=2;
      ampmflag = 1;
    }
   else  // an unknown char, move to next
     ptr++;
  }
  if(ampmflag)
  {
    char ampm[4];
    if( getHour() < 12 )
      strcpy(ampm, " AM");
    else
      strcpy(ampm, " PM");
    sprintf(out+strlen(out), "%s", ampm);
  }
  return(TRUE);
}
 
/**************************************

 REPLACE THIS CRAP

// Parses a date string that's in modified RFC 1123 format
// Can have a +minutes after the normal time
// eg: Thu, 20 Jun 1996 17:33:49 +100
// Returns true if successfully parsed, false otherwise
bit8 Xtime::ParseDate(char *in)
{
  int i;
  uint32 minOffset;
  struct tm t;
  char *ptr=in;
  while ((!isgraph(*ptr))&&(*ptr!=0)) ptr++;  // skip to start of string
  if (*ptr==0) return(FALSE);
  t.tm_wday_=-1;
  for (i=0; i<7; i++)  // parse day_ of week
    if (strncmp(ptr,DAYS[i],strlen(DAYS[i]))==0)
      t.tm_wday_=i;
  if (t.tm_wday_==-1)
    return(FALSE);
  while ((!isdigit(*ptr))&&(*ptr!=0)) ptr++;  // skip to day_ of month
  if (*ptr==0) return(FALSE);
  t.tm_mday_=atoi(ptr);
  while ((!isalpha(*ptr))&&(*ptr!=0)) ptr++;  // skip to month
  if (*ptr==0) return(FALSE);
  t.tm_mon=-1;
  for (i=0; i<12; i++)  // match month
    if (strncmp(ptr,MONTHS[i],strlen(MONTHS[i]))==0) t.tm_mon=i;
  if (t.tm_mon==-1) return(FALSE);
  while ((!isdigit(*ptr))&&(*ptr!=0)) ptr++;
  if (*ptr==0) return(FALSE);
  t.tm_year=atoi(ptr);
  if (t.tm_year<70)  // if they specify a 2 digit year, we'll be nice
    t.tm_year+=2000;
  else if (t.tm_year<100)
    t.tm_year+=1900;
  if (t.tm_year>2200)  // I doubt my code will be around for another 203 years
    return(FALSE);
  while ((isdigit(*ptr))&&(*ptr!=0)) ptr++;  // skip to end of year
  if (*ptr==0) return(FALSE);

  while ((!isgraph(*ptr))&&(*ptr!=0)) ptr++;  // skip to start of time
  if (*ptr==0) return(FALSE);

  t.tm_hour=atoi(ptr);
  while ((*ptr!=':')&&(*ptr!=0)) ptr++;
  ptr++; // skip past colon
  if (*ptr==0) return(FALSE);
  t.tm_min=atoi(ptr);
  while ((*ptr!=':')&&(*ptr!=0)) ptr++;
  ptr++; // skip past colon
  if (*ptr==0) return(FALSE);
  t.tm_sec=atoi(ptr);
  t.tm_year%=100;   // 1996 is stored as 96, not 1996
  t.tm_isdst=-1;    // day_light savings info isn't available

  sec=(uint32)(mktime(&t));
  if ((sint32)sec==-1)
    return(FALSE);


  // The next part of the time is OPTIONAL (+minutes)

  // first skip past the seconds 
  while ((isdigit(*ptr))&&(*ptr!=0)) ptr++;
  if (*ptr==0) return(TRUE);

  // skip past any spaces 
  while ((isspace(*ptr))&&(*ptr!=0)) ptr++;
  if (*ptr!='+')
  {
    //printf("\nNOPE ptr was '%s'\n",ptr);
    return(TRUE);
  }
  ptr++;
  if (*ptr==0)
  {
    //printf("\nPTR WAS 0\n");
    return(TRUE);
  }
 
  minOffset=atol(ptr);
  //printf("\n\nAdding %d minutes!\n\n",minOffset);
  sec+=minOffset*60;  // add the minutes as seconds
  return(TRUE);
}



// In addition to PrintTime & PrintDate there is the 'Print' function
//   which prints both in RFC 1123 format

void Xtime::PrintTime(FILE *out) const
{
  char string[80];
  PrintTime(string);
  fprintf(out,"%s",string);
}

void Xtime::PrintTime(char *out) const
{
  sprintf(out," %02lu:%02lu:%02lu",GetHour(),GetMinute(),GetSecond());
}

void Xtime::PrintDate(FILE *out) const
{
  char string[80];
  PrintDate(string);
  fprintf(out,"%s",string);
}

void Xtime::PrintDate(char *out) const
{
  sprintf(out,"%s, %lu %s %lu",DAYS[GetWDay()-1],GetMDay(),MONTHS[GetMonth()-1],
    GetYear());
}
********************************************/

// Get day_s since year 0
sint32 Xtime::getDay(void) const
{
  return(day_);
}

// Get msecs since start of day
sint32 Xtime::getMsec(void) const
{
  return(msec_);
}

// Set days since year 0
void Xtime::setDay(sint32 newday)
{
  day_=newday;
}

// Set msec since start of this day
void Xtime::setMsec(sint32 newmsec)
{
  msec_=newmsec;
}

// Set both
void Xtime::set(sint32 newday, sint32 newmsec)
{
  day_=newday;
  msec_=newmsec;
}


//
// Get a timeval ptr from a Xtime class
// May fail if timeval can't hold a year this big or small
//
bit8 Xtime::getTimeval(struct timeval &tv)
{
  // A timeval can only hold dates from 1970-2038
  if ((day_ < 719528) || (day_ >= 719528+24855))
    return(FALSE);

  // Compute seconds since Jan 1, 1970
  uint32 seconds=day_-719528;
  seconds*=(60*60*24);
  seconds+=(msec_/1000);

  tv.tv_sec=seconds;
  tv.tv_usec=(msec_%1000)*1000;
  return(TRUE);
}

//
// Set the time
//
bit8 Xtime::setTime(int month, int mday, int year, int hour, int minute, int second)
{
  day_=Get_Day(month,mday,year);
  msec_=(hour*1000*60*60)+(minute*1000*60)+(second*1000);
  return(TRUE);
}



int Xtime::getYDay(void) const   // Day of Year  (1-366)  (366 = leap yr)
{
	int year;
	sint32 dayofyear;
	if (Get_Date_From_Day(day_,year,dayofyear)==FALSE)
		return(-1);
	return dayofyear;
}


//
// Get all the components of the time in the usual normalized format.
//
// Most of the uglyness is in Get_Date_From_Day() 
//
bit8 Xtime::getTime(int &month, int &mday, int &year, int &hour, int &minute, int &second) const
{
  int i;
  sint32 dayofyear;
  if (Get_Date_From_Day(day_,year,dayofyear)==FALSE)
    return(FALSE);

  static int DaysAtMonth[2][12] = {
        {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},   // normal
        {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}    // leap year
  };

  month=0;

  bit8 isleap=IS_LEAP(year);
  for (i=0; i<12; i++)
  {
    if (DaysAtMonth[isleap][i] >= dayofyear)
      break;
    month=i;
  }
  month++;  // 1 based

  mday=dayofyear-DaysAtMonth[isleap][month-1];

  // Whew! Now all we have to do is figure out H/M/S from the msec!
  hour=(msec_/3600000)%24;  // 1000*60*60
  minute=(msec_/60000)%60;  // 1000*60 
  second=(msec_/ 1000)%60;  // 1000

  return(TRUE);
}

//
// These are for getting components of the time in the
//   standard ranges.  Like Day 1-31, Second 0-59, etc...
//
int Xtime::getSecond(void) const
{
  int month,mday,year,hour,minute,second;
  getTime(month, mday, year, hour, minute, second);
  return(second);
}
int Xtime::getMinute(void) const
{
  int month,mday,year,hour,minute,second;
  getTime(month, mday, year, hour, minute, second);
  return(minute);
}
int Xtime::getHour(void) const
{
  int month,mday,year,hour,minute,second;
  getTime(month, mday, year, hour, minute, second);
  return(hour);
}
int Xtime::getMDay(void) const
{
  int month,mday,year,hour,minute,second;
  getTime(month, mday, year, hour, minute, second);
  return(mday);
}

int Xtime::getMonth(void) const
{
  int month,mday,year,hour,minute,second;
  getTime(month, mday, year, hour, minute, second);
  return(month);
}

// based at year 0 (real 0, not 1970)
int Xtime::getYear(void) const
{
  int month,mday,year,hour,minute,second;
  getTime(month, mday, year, hour, minute, second);
  return(year);
}


//
// Set the seconds value (0-59)
//
bit8 Xtime::setSecond(sint32 sec)
{
  sint32 second=(msec_/ 1000)%60;
  msec_-=(second*1000);
  msec_+=(sec*1000);
  return(TRUE);
}

//
// Set the minutes value (0-59)
//
bit8 Xtime::setMinute(sint32 min)
{
  sint32 minute=(msec_/60000)%60;  // 1000*60 
  msec_-=(minute*60000);
  msec_+=(min*60000);
  return(TRUE);
}

//
// Set the minutes value (0-23)
//
bit8 Xtime::setHour(sint32 hour)
{
  hour=(msec_/3600000)%24;  // 1000*60*60
  msec_-=(hour*3600000);
  msec_+=(hour*3600000);
  return(TRUE);
}

//
// Set the year value
// Results are undefined if you're moving from Feb 29, to a non leap year
//
bit8 Xtime::setYear(sint32 _year)
{
  // extract the date
  int month,mday,year,hour,min,sec;
  getTime(month,mday,year,hour,min,sec);

  // modify & rebuild
  year=_year;
  day_=Get_Day(month,mday,year);
  return(TRUE);
}

//
// Modify the month
//
bit8 Xtime::setMonth(sint32 _month)
{
  // extract the date
  int month,mday,year,hour,min,sec;
  getTime(month,mday,year,hour,min,sec);

  // modify & rebuild
  month=_month;
  day_=Get_Day(month,mday,year);
  return(TRUE);
}


//
// Modify the day of the month 
//
bit8 Xtime::setMDay(sint32 _mday)
{
  // extract the date
  int month,mday,year,hour,min,sec;
  getTime(month,mday,year,hour,min,sec);

  // modify & rebuild
  mday=_mday;
  day_=Get_Day(month,mday,year);
  return(TRUE);
}


//
// Compare two times.  The time better be normalized
//   which it would be unless you've put bad stuff in it!
//
// 1 = *this > other
//-1 = *this < other
// 0 = *this == other
int   Xtime::compare(const Xtime &other) const
{
  if ((day_==other.day_)&&(msec_==other.msec_))
    return(0);        // equal

  else if (day_>other.day_)
    return(1);
  else if (day_<other.day_)
    return(-1);
  else if (msec_>other.msec_)
    return(1);
  else
    return(-1);
}
  

bit8 Xtime::operator == ( const Xtime &other ) const
{
  bit8 retval=compare(other);
  if (retval==0)
    return(TRUE);
  else
    return(FALSE);
}

bit8 Xtime::operator != ( const Xtime &other ) const
{
  bit8 retval=compare(other);
  if (retval==0)
    return(FALSE);
  else
    return(TRUE);
}

bit8 Xtime::operator < ( const Xtime &other ) const
{
  int retval=compare(other);
  if (retval==-1)
    return(TRUE);
  else
    return(FALSE);
}

bit8 Xtime::operator > ( const Xtime &other ) const
{
  int retval=compare(other);
  if (retval==1)
    return(TRUE);
  else
    return(FALSE);
}

bit8 Xtime::operator <= ( const Xtime &other ) const
{
  int retval=compare(other);
  if ((retval==-1)||(retval==0))
    return(TRUE);
  else
    return(FALSE);
}

bit8 Xtime::operator >= ( const Xtime &other ) const
{
  int retval=compare(other);
  if ((retval==1)||(retval==0))
    return(TRUE);
  else
    return(FALSE);
}


Xtime &Xtime::operator += (const Xtime &other)
{
  day_+=other.day_;
  msec_+=other.msec_;
  normalize();
  return *this;
}

Xtime &Xtime::operator -= (const Xtime &other)
{
  day_-=other.day_;
  msec_-=other.msec_;
  normalize();
  return *this;
}

Xtime Xtime::operator - (Xtime &other)
{
  Xtime temp(*this);
  temp-=other;
  return(temp);
}

Xtime Xtime::operator + (Xtime &other)
{
  Xtime temp(*this);
  temp+=other;
  return(temp);
}


Xtime   &Xtime::operator = (const Xtime &other)
{
  day_=other.day_;
  msec_=other.msec_;
  return *this;
}


Xtime &Xtime::operator += (const time_t other)
{
  addSeconds(other);
  return *this;
}


Xtime &Xtime::operator -= (const time_t other)
{
  addSeconds(-((sint32)other));
  return *this;
}


Xtime Xtime::operator - (time_t other)
{
  Xtime temp(*this);
  temp-=other;
  return(temp);
}


Xtime Xtime::operator + (time_t other)
{
  Xtime temp(*this);
  temp+=other;
  return(temp);
}

Xtime &Xtime::operator = (const time_t other)
{
  msec_=0;
  day_=719528;  // Jan 1, 1970
  addSeconds(other);
  return *this;
}