745 lines
17 KiB
C
Executable File
745 lines
17 KiB
C
Executable File
/* d4date.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
|
||
|
||
#include "d4all.h"
|
||
#ifndef S4UNIX
|
||
#ifdef __TURBOC__
|
||
#pragma hdrstop
|
||
#endif /* __TUROBC__ */
|
||
#endif /* S4UNIX */
|
||
|
||
#define JULIAN_ADJUSTMENT 1721425L
|
||
#define S4NULL_DATE 1.0E100 /* may not compile on some Op.Sys. */
|
||
/* Set to MAXDOUBLE ? */
|
||
static int monthTot[] =
|
||
{ 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 } ;
|
||
/* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
|
||
31 28 31 30 31 30 31 31 30 31 30 31
|
||
*/
|
||
|
||
typedef struct
|
||
{
|
||
char cdow[12] ;
|
||
} DOW ;
|
||
|
||
typedef struct
|
||
{
|
||
char cmonth[10] ;
|
||
} MONTH ;
|
||
|
||
static DOW dayOfWeek[] =
|
||
#ifndef S4LANGUAGE
|
||
{
|
||
{ "\0 " },
|
||
{ "Sunday\0 " },
|
||
{ "Monday\0 " },
|
||
{ "Tuesday\0 " },
|
||
{ "Wednesday\0 " },
|
||
{ "Thursday\0 " },
|
||
{ "Friday\0 " },
|
||
{ "Saturday\0 " },
|
||
} ;
|
||
#else
|
||
#ifdef S4GERMAN
|
||
{
|
||
{ "\0 " },
|
||
{ "Sonntag\0 " },
|
||
{ "Montag\0 " },
|
||
{ "Dienstag\0 " },
|
||
{ "Mittwoch\0 " },
|
||
{ "Donnerstag\0" },
|
||
{ "Freitag\0 " },
|
||
{ "Samstag\0 " },
|
||
} ;
|
||
#endif
|
||
#ifdef S4FRENCH
|
||
{
|
||
{ "\0 " },
|
||
{ "Dimanche\0 " },
|
||
{ "Lundi\0 " },
|
||
{ "Mardi\0 " },
|
||
{ "Mercredi\0 " },
|
||
{ "Jeudi\0 " },
|
||
{ "Vendredi\0 " },
|
||
{ "Samedi\0 " },
|
||
} ;
|
||
#endif
|
||
#ifdef S4SWEDISH
|
||
{
|
||
{ "\0 " },
|
||
{ "M†ndag\0 " },
|
||
{ "Tisdag\0 " },
|
||
{ "Onsdag\0 " },
|
||
{ "Torsdag\0 " },
|
||
{ "Fredag\0 " },
|
||
{ "L”rdag\0 " },
|
||
{ "S”ndag\0 " },
|
||
} ;
|
||
#endif
|
||
#ifdef S4FINNISH
|
||
{
|
||
{ "\0 " },
|
||
{ "Maanantai\0 " },
|
||
{ "Tiistai\0 " },
|
||
{ "Keskiviikko " },
|
||
{ "Torstai\0 " },
|
||
{ "Perjantai\0 " },
|
||
{ "Lauantai\0 " },
|
||
{ "Suununtai\0 " },
|
||
} ;
|
||
#endif
|
||
#ifdef S4NORWEGIAN
|
||
{
|
||
{ "\0 " },
|
||
{ "Mandag\0 " },
|
||
{ "Tirsdag\0 " },
|
||
{ "Onsdag\0 " },
|
||
{ "Torsdag\0 " },
|
||
{ "Fredag\0 " },
|
||
{ "L”rdag\0 " },
|
||
{ "S”ndag\0 " },
|
||
} ;
|
||
#endif
|
||
#endif
|
||
|
||
static MONTH monthOfYear[] =
|
||
#ifndef S4LANGUAGE
|
||
{
|
||
{ "\0 " },
|
||
{ "January\0 " },
|
||
{ "February\0" },
|
||
{ "March\0 " },
|
||
{ "April\0 " },
|
||
{ "May\0 " },
|
||
{ "June\0 " },
|
||
{ "July\0 " },
|
||
{ "August\0 " },
|
||
{ "September" },
|
||
{ "October\0 " },
|
||
{ "November\0" },
|
||
{ "December\0" },
|
||
} ;
|
||
#else
|
||
#ifdef S4GERMAN
|
||
{
|
||
{ "\0 " },
|
||
{ "Januar\0 " },
|
||
{ "Februar\0 " },
|
||
{ "M„rz\0 " },
|
||
{ "April\0 " },
|
||
{ "Mai\0 " },
|
||
{ "Juni\0 " },
|
||
{ "Juli\0 " },
|
||
{ "August\0 " },
|
||
{ "September" },
|
||
{ "Oktober\0 " },
|
||
{ "November\0" },
|
||
{ "Dezember\0" },
|
||
} ;
|
||
#endif
|
||
#ifdef S4FRENCH
|
||
{
|
||
{ "\0 " },
|
||
{ "Janvier\0 " },
|
||
{ "F‚vrier\0 " },
|
||
{ "Mars\0 " },
|
||
{ "Avril\0 " },
|
||
{ "Mai\0 " },
|
||
{ "Juin\0 " },
|
||
{ "Juillet\0 " },
|
||
{ "Ao–t\0 " },
|
||
{ "Septembre" },
|
||
{ "Octobre\0 " },
|
||
{ "Novembre\0" },
|
||
{ "D‚cembre\0" },
|
||
} ;
|
||
#endif
|
||
#ifdef S4SWEDISH
|
||
{
|
||
{ "\0 " },
|
||
{ "Januari\0 " },
|
||
{ "Februari\0" },
|
||
{ "Mars\0 " },
|
||
{ "April\0 " },
|
||
{ "Maj\0 " },
|
||
{ "Juni\0 " },
|
||
{ "Juli\0 " },
|
||
{ "Augusti\0 " },
|
||
{ "September" },
|
||
{ "Oktober\0 " },
|
||
{ "November\0" },
|
||
{ "December\0" },
|
||
} ;
|
||
#endif
|
||
#ifdef S4FINNISH
|
||
{
|
||
{ "\0 " },
|
||
{ "Tammikuu\0" },
|
||
{ "Helmikuu\0" },
|
||
{ "Maaliskuu" },
|
||
{ "Huhtikuu\0" },
|
||
{ "Toukokuu\0" },
|
||
{ "Kes„kuu\0 " },
|
||
{ "Hein„kuu\0" },
|
||
{ "Elokuu\0 " },
|
||
{ "Syyskuu\0 " },
|
||
{ "Lokakuu\0 " },
|
||
{ "Marraskuu" },
|
||
{ "Joulukuu\0" },
|
||
} ;
|
||
#endif
|
||
#ifdef S4NORWEGIAN
|
||
{
|
||
{ "\0 " },
|
||
{ "Januar\0 " },
|
||
{ "Februar\0 " },
|
||
{ "Mars\0 " },
|
||
{ "April\0 " },
|
||
{ "Mai\0 " },
|
||
{ "Juni\0 " },
|
||
{ "Juli\0 " },
|
||
{ "August \0 " },
|
||
{ "September" },
|
||
{ "Oktober\0 " },
|
||
{ "November\0" },
|
||
{ "Desember\0" },
|
||
} ;
|
||
#endif
|
||
#endif
|
||
|
||
#ifndef S4SERVER
|
||
const char *S4FUNCTION code4dateFormat( CODE4 *c4 )
|
||
{
|
||
#ifdef E4PARM_HIGH
|
||
if ( c4 == 0 )
|
||
{
|
||
error4( c4, e4parm_null, E96303 ) ;
|
||
return 0 ;
|
||
}
|
||
#endif
|
||
|
||
#ifdef S4SERVER
|
||
return c4->currentClient->trans.dateFormat ;
|
||
#else
|
||
return c4->c4trans.trans.dateFormat ;
|
||
#endif
|
||
}
|
||
|
||
int S4FUNCTION code4dateFormatSet( CODE4 *c4, const char *str )
|
||
{
|
||
#ifdef S4CLIENT
|
||
CONNECTION4 *connection ;
|
||
CONNECTION4DATE_FORMAT_SET_INFO_IN infoIn ;
|
||
int rc ;
|
||
#endif
|
||
|
||
#ifdef E4PARM_HIGH
|
||
if ( c4 == 0 || str == 0 )
|
||
return error4( c4, e4parm_null, E96302 ) ;
|
||
if ( strlen( str ) >= sizeof( c4->c4trans.trans.dateFormat ) )
|
||
return error4( c4, e4parm, E96302 ) ;
|
||
#endif
|
||
|
||
#ifdef S4SERVER
|
||
strcpy( c4->currentClient->trans.dateFormat, str ) ;
|
||
#else
|
||
strcpy( c4->c4trans.trans.dateFormat, str ) ;
|
||
#ifdef S4CLIENT
|
||
if ( c4->defaultServer != 0 )
|
||
{
|
||
connection = c4->defaultServer->connect ;
|
||
#ifdef E4ANALYZE
|
||
if ( connection == 0 )
|
||
return error4( c4, e4struct, E96302 ) ;
|
||
#endif
|
||
connection4assign( connection, CON4DATE_FORMAT, 0L, 0L ) ;
|
||
memcpy( infoIn.dateFormat, &c4->c4trans.trans.dateFormat, sizeof( c4->c4trans.trans.dateFormat ) ) ;
|
||
connection4addData( connection, &infoIn, sizeof(CONNECTION4DATE_FORMAT_SET_INFO_IN), 0 ) ;
|
||
connection4send( connection ) ;
|
||
rc = connection4receive( connection ) ;
|
||
if ( rc < 0 )
|
||
return error4stack( c4, rc, E96302 ) ;
|
||
rc = connection4status( connection ) ;
|
||
if ( rc < 0 )
|
||
connection4error( connection, c4, rc, E96302 ) ;
|
||
return rc ;
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
return 0 ;
|
||
}
|
||
#endif
|
||
|
||
int S4FUNCTION date4isLeap( const char *date )
|
||
{
|
||
int year ;
|
||
|
||
year = date4year( date ) ;
|
||
return ( ( ((year%4 == 0) && (year%100 != 0)) || (year%400 == 0 )) ? 1 : 0 ) ;
|
||
}
|
||
|
||
static int c4Julian( const int year, const int month, const int day )
|
||
{
|
||
/* Returns */
|
||
/* >0 The day of the year starting from 1 */
|
||
/* Ex. Jan 1, returns 1 */
|
||
/* -1 Illegal Date */
|
||
int isLeap, monthDays ;
|
||
|
||
isLeap = ( ((year%4 == 0) && (year%100 != 0)) || (year%400 == 0) ) ? 1 : 0 ;
|
||
|
||
monthDays = monthTot[ month+1 ] - monthTot[ month] ;
|
||
if ( month == 2 ) monthDays += isLeap ;
|
||
|
||
if ( year < 0 ||
|
||
month < 1 || month > 12 ||
|
||
day < 1 || day > monthDays )
|
||
return( -1 ) ; /* Illegal Date */
|
||
|
||
if ( month <= 2 ) isLeap = 0 ;
|
||
|
||
return( monthTot[month] + day + isLeap ) ;
|
||
}
|
||
|
||
static int c4monDy( const int year, const int days, int *monthPtr, int *dayPtr )
|
||
{
|
||
/* Given the year and the day of the year, returns the month and day of month. */
|
||
int isLeap, i ;
|
||
|
||
isLeap = ( ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0) ) ? 1 : 0 ;
|
||
if ( days <= 59 )
|
||
isLeap = 0 ;
|
||
|
||
for( i = 2; i <= 13; i++)
|
||
{
|
||
if ( days <= monthTot[i] + isLeap )
|
||
{
|
||
*monthPtr = --i ;
|
||
if ( i <= 2)
|
||
isLeap = 0 ;
|
||
|
||
*dayPtr = days - monthTot[ i] - isLeap ;
|
||
return 0 ;
|
||
}
|
||
}
|
||
*dayPtr = 0 ;
|
||
*monthPtr = 0 ;
|
||
|
||
return -1 ;
|
||
}
|
||
|
||
static long c4ytoj( const int y )
|
||
{
|
||
int yr ;
|
||
/* Calculates the number of days to the year */
|
||
/* This calculation takes into account the fact that */
|
||
/* 1) Years divisible by 400 are always leap years. */
|
||
/* 2) Years divisible by 100 but not 400 are not leap years. */
|
||
/* 3) Otherwise, years divisible by four are leap years. */
|
||
/* Since we do not want to consider the current year, we will */
|
||
/* subtract the year by 1 before doing the calculation. */
|
||
yr = y - 1 ;
|
||
return( yr*365L + yr/4L - yr/100L + yr/400L ) ;
|
||
}
|
||
|
||
int S4FUNCTION date4assign( char *datePtr, const long ldate )
|
||
{
|
||
/* Converts from a Julian day to the dbf file date format. */
|
||
long totDays ;
|
||
int iTemp, year, nDays, maxDays, month, day ;
|
||
|
||
if ( ldate <= 0 )
|
||
{
|
||
memset( datePtr, ' ', 8 ) ;
|
||
return 0L ;
|
||
}
|
||
|
||
totDays = ldate - JULIAN_ADJUSTMENT ;
|
||
iTemp = (int)( (double)totDays / 365.2425 ) ;
|
||
year = iTemp + 1 ;
|
||
nDays = (int)( totDays - c4ytoj( year ) ) ;
|
||
if ( nDays <= 0 )
|
||
{
|
||
year-- ;
|
||
nDays = (int)( totDays - c4ytoj( year ) ) ;
|
||
}
|
||
|
||
if ( (( year % 4 == 0 ) && ( year % 100 )) || ( year % 400 == 0 ) )
|
||
maxDays = 366 ;
|
||
else
|
||
maxDays = 365 ;
|
||
|
||
if ( nDays > maxDays )
|
||
{
|
||
year++ ;
|
||
nDays -= maxDays ;
|
||
}
|
||
|
||
#ifdef E4MISC
|
||
if ( c4monDy( year, nDays, &month, &day ) < 0 )
|
||
return error4( 0, e4result, E96301 ) ;
|
||
#else
|
||
c4monDy( year, nDays, &month, &day ) ;
|
||
#endif
|
||
|
||
c4ltoa45( (long)year, datePtr, -4 ) ;
|
||
c4ltoa45( (long)month, datePtr + 4, -2 ) ;
|
||
c4ltoa45( (long)day, datePtr + 6, -2 ) ;
|
||
|
||
return 0 ;
|
||
}
|
||
|
||
S4CONST char *S4FUNCTION date4cdow( const char *datePtr )
|
||
{
|
||
return dayOfWeek[date4dow(datePtr)].cdow ;
|
||
}
|
||
|
||
S4CONST char *S4FUNCTION date4cmonth( const char *datePtr )
|
||
{
|
||
return monthOfYear[date4month( datePtr )].cmonth ;
|
||
}
|
||
|
||
/* inlined*/
|
||
/*int S4FUNCTION date4day( const char *datePtr )*/
|
||
/*{*/
|
||
/* return (int)c4atol( datePtr + 6, 2 ) ;*/
|
||
/*}*/
|
||
|
||
int S4FUNCTION date4dow( const char *datePtr )
|
||
{
|
||
long date ;
|
||
date = date4long(datePtr) ;
|
||
if ( date < 0 )
|
||
return 0 ;
|
||
return (int)( ( date + 1 ) % 7 ) + 1 ;
|
||
}
|
||
|
||
void S4FUNCTION date4format( const char *datePtr, char *result, char *picture )
|
||
{
|
||
int rest, mNum ;
|
||
unsigned int resultLen, length ;
|
||
char *ptrEnd, *monthPtr, tChar ;
|
||
|
||
resultLen = strlen( picture ) ;
|
||
memset( result, ' ', resultLen ) ;
|
||
|
||
c4upper( picture ) ;
|
||
c4encode( result, datePtr, picture, "CCYYMMDD" ) ;
|
||
|
||
ptrEnd = strchr( picture, 'M' ) ;
|
||
if ( ptrEnd )
|
||
{
|
||
monthPtr = result+ (int)( ptrEnd - picture ) ;
|
||
length = 0 ;
|
||
while ( *(ptrEnd++) == 'M' )
|
||
length++ ;
|
||
|
||
if ( length > 2)
|
||
{
|
||
/* Convert from a numeric form to character format for month */
|
||
if (!c4memcmp( datePtr+4, " ", 2 )) /* if blank month */
|
||
{
|
||
memset( monthPtr, ' ', length ) ;
|
||
return ;
|
||
}
|
||
|
||
mNum = c4atoi( datePtr+4, 2) ;
|
||
|
||
if ( mNum < 1)
|
||
mNum = 1 ;
|
||
if ( mNum > 12)
|
||
mNum = 12 ;
|
||
|
||
rest = length - 9 ;
|
||
if (length > 9)
|
||
length = 9 ;
|
||
|
||
memcpy( monthPtr, monthOfYear[mNum].cmonth, length ) ;
|
||
if (rest > 0)
|
||
memset( monthPtr+length, (int) ' ', (size_t)rest ) ;
|
||
|
||
tChar = monthOfYear[mNum].cmonth[length] ;
|
||
if( tChar == '\0' || tChar == ' ' )
|
||
{
|
||
mNum = strlen(monthOfYear[mNum].cmonth) ;
|
||
if ( (unsigned)mNum != length )
|
||
monthPtr[mNum] = ' ' ;
|
||
}
|
||
#ifdef S4WINDOWS
|
||
OemToAnsi( result, result ) ;
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
|
||
double S4FUNCTION date4formatMdx( const char *datePtr )
|
||
{
|
||
long ldate ;
|
||
ldate = date4long(datePtr) ;
|
||
if ( ldate == 0 )
|
||
return (double) S4NULL_DATE ; /* Blank or Null date */
|
||
return (double)ldate ;
|
||
}
|
||
|
||
int S4FUNCTION date4formatMdx2( const char *datePtr, double *doubPtr )
|
||
{
|
||
long ldate ;
|
||
|
||
ldate = date4long(datePtr) ;
|
||
if ( ldate == 0 )
|
||
*doubPtr = (double)S4NULL_DATE ; /* Blank or Null date */
|
||
else
|
||
*doubPtr = (double)ldate ;
|
||
return 0 ;
|
||
}
|
||
|
||
void S4FUNCTION date4init( char *datePtr, const char *dateData, char *picture )
|
||
{
|
||
char *monthStart, monthData[10], buf[2] ;
|
||
int yearCount, monthCount, dayCount, centuryCount, i, length ;
|
||
|
||
dayCount = 5 ;
|
||
monthCount = 3 ;
|
||
yearCount = 1 ;
|
||
centuryCount= -1 ;
|
||
|
||
memset( datePtr, ' ', 8 ) ;
|
||
|
||
c4upper( picture ) ;
|
||
for ( i=0; picture[i] != '\0'; i++ )
|
||
{
|
||
switch( picture[i] )
|
||
{
|
||
case 'D':
|
||
if ( ++dayCount >= 8 )
|
||
break ;
|
||
datePtr[dayCount] = dateData[i] ;
|
||
break ;
|
||
case 'M':
|
||
if ( ++monthCount >=6 )
|
||
break ;
|
||
datePtr[monthCount] = dateData[i] ;
|
||
break ;
|
||
case 'Y':
|
||
if ( ++yearCount >= 4 )
|
||
break ;
|
||
datePtr[yearCount] = dateData[i] ;
|
||
break ;
|
||
case 'C':
|
||
if ( ++centuryCount >= 2 )
|
||
break ;
|
||
datePtr[centuryCount] = dateData[i] ;
|
||
break ;
|
||
default:
|
||
break ;
|
||
}
|
||
}
|
||
|
||
if ( strcmp( datePtr, " " ) == 0 )
|
||
return ;
|
||
|
||
if ( centuryCount == -1 )
|
||
memcpy( datePtr, "19", (size_t)2 ) ;
|
||
if ( yearCount == 1 )
|
||
memcpy( datePtr + 2, "01", (size_t)2 ) ;
|
||
if ( monthCount == 3 )
|
||
memcpy( datePtr + 4, "01", (size_t)2 ) ;
|
||
if ( dayCount == 5 )
|
||
memcpy( datePtr + 6, "01", (size_t)2 ) ;
|
||
|
||
if ( monthCount >= 6 )
|
||
{
|
||
/* Convert the Month from Character Form to Date Format */
|
||
monthStart = strchr( picture, 'M' ) ;
|
||
|
||
length = monthCount - 3 ; /* Number of 'M' characters in picture */
|
||
|
||
memcpy( datePtr+4, " ", (size_t)2 ) ;
|
||
|
||
if ( length > 3 )
|
||
length = 3 ;
|
||
memcpy( monthData, dateData + (int)( monthStart - picture ), (size_t)length) ;
|
||
while ( length > 0 )
|
||
if ( monthData[length-1] == ' ' )
|
||
length-- ;
|
||
else
|
||
break ;
|
||
|
||
monthData[length] = '\0' ;
|
||
|
||
c4lower( monthData ) ;
|
||
buf[0] = monthData[0] ;
|
||
buf[1] = 0 ;
|
||
c4upper(buf) ;
|
||
monthData[0] = buf[0] ;
|
||
|
||
if ( length > 0 )
|
||
for( i = 1 ; i <= 12; i++ )
|
||
{
|
||
if ( c4memcmp( monthOfYear[i].cmonth, monthData, (size_t)length ) == 0 )
|
||
{
|
||
c4ltoa45( (long) i, datePtr+4, 2 ) ; /* Found Month Match */
|
||
break ;
|
||
}
|
||
}
|
||
}
|
||
|
||
for ( i = 0 ; i < 8 ; i++ )
|
||
if ( datePtr[i] == ' ' )
|
||
datePtr[i] = '0' ;
|
||
}
|
||
|
||
long S4FUNCTION date4long( const char *datePtr )
|
||
{
|
||
/* Returns: */
|
||
/* >0 - Julian day */
|
||
/* That is the number of days since the date Jan 1, 4713 BC */
|
||
/* Ex. Jan 1, 1981 is 2444606 */
|
||
/* 0 - NULL Date (dbfDate is all blank) */
|
||
/* -1 - Illegal Date */
|
||
int year, month, day, dayYear, i ;
|
||
|
||
/* first verify that the input date is valid --> which returns a -1 */
|
||
for ( i = 0 ; i < 8 ; i++ )
|
||
if ( ( datePtr[i] < '0' || datePtr[i] > '9' ) && datePtr[i] != ' ' )
|
||
return -1 ;
|
||
|
||
year = c4atoi( datePtr, 4 ) ;
|
||
if ( year == 0)
|
||
if ( c4memcmp( datePtr, " ", 8 ) == 0)
|
||
return 0 ;
|
||
|
||
month = c4atoi( datePtr + 4, 2 ) ;
|
||
day = c4atoi( datePtr + 6, 2 ) ;
|
||
dayYear = c4Julian( year, month, day ) ;
|
||
if ( dayYear < 1 ) /* Illegal Date */
|
||
return -1L ;
|
||
|
||
return ( c4ytoj( year ) + dayYear + JULIAN_ADJUSTMENT ) ;
|
||
}
|
||
|
||
void S4FUNCTION date4timeNow( char *timeData )
|
||
{
|
||
long timeVal ;
|
||
struct tm *tmPtr ;
|
||
|
||
time( (time_t *)&timeVal) ;
|
||
tmPtr = localtime( (time_t *)&timeVal) ;
|
||
|
||
c4ltoa45( (long)tmPtr->tm_hour, timeData, -2) ;
|
||
timeData[2] = ':' ;
|
||
c4ltoa45( (long)tmPtr->tm_min, timeData + 3, -2) ;
|
||
timeData[5] = ':' ;
|
||
c4ltoa45( (long)tmPtr->tm_sec, timeData + 6, -2) ;
|
||
}
|
||
|
||
void S4FUNCTION date4today( char *datePtr )
|
||
{
|
||
long timeVal ;
|
||
struct tm *tmPtr ;
|
||
|
||
time( (time_t *)&timeVal ) ;
|
||
tmPtr = localtime( (time_t *)&timeVal ) ;
|
||
|
||
c4ltoa45( 1900L + tmPtr->tm_year, datePtr, -4 ) ;
|
||
c4ltoa45( (long)tmPtr->tm_mon + 1, datePtr + 4, -2 ) ;
|
||
c4ltoa45( (long)tmPtr->tm_mday, datePtr + 6, -2 ) ;
|
||
}
|
||
|
||
/* inlined*/
|
||
/*int S4FUNCTION date4month( const char *datePtr )*/
|
||
/*{*/
|
||
/* return (int)c4atol( datePtr + 4, 2 ) ;*/
|
||
/*}*/
|
||
/*int S4FUNCTION date4year( const char *yearPtr )*/
|
||
/*{*/
|
||
/* return (int)c4atol( yearPtr, 4 ) ;*/
|
||
/*}*/
|
||
|
||
|
||
#ifdef S4VB_DOS
|
||
|
||
|
||
/* DATE Functions */
|
||
|
||
void date4assign_v( char *date, long julianDay )
|
||
{
|
||
date4assign( c4buf, julianDay ) ;
|
||
c4buf[8] = '\0' ;
|
||
u4ctov( date, c4buf ) ;
|
||
}
|
||
|
||
char * date4cdow_v( char *date )
|
||
{
|
||
return v4str( date4cdow( c4str(date) ) ) ;
|
||
}
|
||
|
||
char * date4cmonth_v( char *date )
|
||
{
|
||
return v4str( date4cmonth( c4str(date) ) ) ;
|
||
}
|
||
|
||
int date4day_v( char *date )
|
||
{
|
||
return date4day( c4str(date) ) ;
|
||
}
|
||
|
||
int date4dow_v( char *date )
|
||
{
|
||
return date4dow( c4str(date) ) ;
|
||
}
|
||
|
||
void date4format_v( char *vDate, char *vRes, char *vPic )
|
||
{
|
||
char cDate[9], cRes[255], cPic[255] ;
|
||
|
||
u4vtoc( cDate, sizeof(cDate), vDate ) ;
|
||
u4vtoc( cPic, sizeof(cPic), vPic ) ;
|
||
|
||
date4format( cDate, cRes, cPic ) ;
|
||
u4ctov( vRes, cRes ) ;
|
||
|
||
}
|
||
|
||
double date4formatMdx ( char *date )
|
||
{
|
||
return date4formatMdx( c4str(date) ) ;
|
||
}
|
||
|
||
void date4init_v( char *vRes, char *vDate, char *vPic )
|
||
{
|
||
char cRes[9],cDate[255],cPic[255] ;
|
||
|
||
u4vtoc( cDate, sizeof(cDate), vDate ) ;
|
||
u4vtoc( cPic, sizeof(cPic), vPic ) ;
|
||
|
||
date4init( cRes, cDate, cPic ) ;
|
||
|
||
cRes[8] = '\0' ;
|
||
|
||
u4ctov( vRes, cRes ) ;
|
||
}
|
||
|
||
long date4long_v( char *date )
|
||
{
|
||
return date4long( c4str(date) ) ;
|
||
}
|
||
|
||
int date4month_v( char *date )
|
||
{
|
||
return date4month( c4str(date) ) ;
|
||
}
|
||
|
||
void date4today_v( char *vDate )
|
||
{
|
||
date4today( c4buf ) ;
|
||
u4ctov( vDate, c4buf ) ;
|
||
}
|
||
|
||
int date4year_v( char *date )
|
||
{
|
||
return date4year( c4str(date) ) ;
|
||
}
|
||
|
||
#endif /* S4VB_DOS */
|