able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cmd/cclock.c

1276 lines
35 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1988-1999 Microsoft Corporation
Module Name:
cclock.c
Abstract:
time/date functions
--*/
#include "cmd.h"
#define MMDDYY 0
#define DDMMYY 1
#define YYMMDD 2
extern TCHAR Fmt04[], Fmt05[], Fmt06[], Fmt10[], Fmt11[];
extern TCHAR Fmt17[], Fmt15[];
extern unsigned DosErr;
extern unsigned LastRetCode;
// for keeping current console output codepage.
extern UINT CurrentCP;
BOOL TimeAmPm=TRUE;
TCHAR TimeSeparator[8];
TCHAR DateSeparator[8];
TCHAR DecimalPlace[8];
int DateFormat;
TCHAR *DateFormatString;
TCHAR ThousandSeparator[8];
TCHAR ShortMondayName[16];
TCHAR ShortTuesdayName[16];
TCHAR ShortWednesdayName[16];
TCHAR ShortThursdayName[16];
TCHAR ShortFridayName[16];
TCHAR ShortSaturdayName[16];
TCHAR ShortSundayName[16];
TCHAR AMIndicator[8];
TCHAR PMIndicator[8];
ULONG YearWidth;
//
// We snapshot the current LCID at startup and modify it based on the current known
// set of scripts that Console supports.
//
LCID CmdGetUserDefaultLCID(
void
)
{
LCID CmdLcid = GetUserDefaultLCID();
#ifdef LANGPACK
if (
(PRIMARYLANGID(CmdLcid) == LANG_ARABIC) ||
(PRIMARYLANGID(CmdLcid) == LANG_HEBREW) ||
(PRIMARYLANGID(CmdLcid) == LANG_THAI) ||
(PRIMARYLANGID(CmdLcid) == LANG_HINDI) ||
(PRIMARYLANGID(CmdLcid) == LANG_TAMIL) ||
(PRIMARYLANGID(CmdLcid) == LANG_FARSI)
) {
CmdLcid = MAKELCID (MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT); // 0x409;
}
#endif
return CmdLcid;
}
VOID
InitLocale( VOID )
{
TCHAR Buffer[128];
LCID CmdLcid = CmdGetUserDefaultLCID( );
// get the time separator
if (GetLocaleInfo(CmdLcid, LOCALE_STIME, Buffer, sizeof(TimeSeparator)))
_tcscpy(TimeSeparator, Buffer);
else
_tcscpy(TimeSeparator, TEXT(":"));
// determine if we're 0-12 or 0-24
if (GetLocaleInfo(CmdLcid, LOCALE_ITIME, Buffer, 128)) {
TimeAmPm = _tcscmp(Buffer,TEXT("1"));
}
_tcscpy(AMIndicator, TEXT("a"));
_tcscpy(PMIndicator, TEXT("p"));
//
// get the date ordering
//
DateFormat = MMDDYY;
if (GetLocaleInfo(CmdLcid, LOCALE_IDATE, Buffer, 128)) {
switch (Buffer[0]) {
case TEXT('0'):
DateFormat = MMDDYY;
DateFormatString = TEXT( "MM/dd/yy" );
break;
case TEXT('1'):
DateFormat = DDMMYY;
DateFormatString = TEXT( "dd/MM/yy" );
break;
case TEXT('2'):
DateFormat = YYMMDD;
DateFormatString = TEXT( "yy/MM/dd" );
break;
default:
break;
}
}
//
// Get the date width
//
YearWidth = 2;
if (GetLocaleInfo( CmdLcid, LOCALE_ICENTURY, Buffer, 128 )) {
if (Buffer[0] == TEXT( '1' )) {
YearWidth = 4;
}
}
// get the date separator
if (GetLocaleInfo(CmdLcid, LOCALE_SDATE, Buffer, sizeof(DateSeparator)))
_tcscpy(DateSeparator, Buffer);
else
_tcscpy(DateSeparator, TEXT("/"));
// get the short day names
if (GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME1, Buffer, sizeof(ShortMondayName)))
_tcscpy(ShortMondayName, Buffer);
else
_tcscpy(ShortMondayName, TEXT("Mon"));
if (GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME2, Buffer, sizeof(ShortTuesdayName)))
_tcscpy(ShortTuesdayName, Buffer);
else
_tcscpy(ShortTuesdayName, TEXT("Tue"));
if (GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME3, Buffer, sizeof(ShortWednesdayName)))
_tcscpy(ShortWednesdayName, Buffer);
else
_tcscpy(ShortWednesdayName, TEXT("Wed"));
if (GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME4, Buffer, sizeof(ShortThursdayName)))
_tcscpy(ShortThursdayName, Buffer);
else
_tcscpy(ShortThursdayName, TEXT("Thu"));
if (GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME5, Buffer, sizeof(ShortFridayName)))
_tcscpy(ShortFridayName, Buffer);
else
_tcscpy(ShortFridayName, TEXT("Fri"));
if (GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME6, Buffer, sizeof(ShortSaturdayName)))
_tcscpy(ShortSaturdayName, Buffer);
else
_tcscpy(ShortSaturdayName, TEXT("Sat"));
if (GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME7, Buffer, sizeof(ShortSundayName)))
_tcscpy(ShortSundayName, Buffer);
else
_tcscpy(ShortSundayName, TEXT("Sun"));
// get decimal and thousand separator strings
if (GetLocaleInfo(CmdLcid, LOCALE_SDECIMAL, Buffer, sizeof(DecimalPlace)))
_tcscpy(DecimalPlace, Buffer);
else
_tcscpy(DecimalPlace, TEXT("."));
if (GetLocaleInfo(CmdLcid, LOCALE_STHOUSAND, Buffer, sizeof(ThousandSeparator)))
_tcscpy(ThousandSeparator, Buffer);
else
_tcscpy(ThousandSeparator, TEXT(","));
//
// Set locale so that we can correctly process extended characters
// Note: The string passed in is expected to be ASCII, not unicode
//
setlocale( LC_ALL, ".OCP" ) ;
}
BOOLEAN
SetDateTime(
IN LPSYSTEMTIME OsDateAndTime
)
{
//
// We have to do this twice in order to get the leap year set correctly.
//
SetLocalTime( OsDateAndTime );
return(SetLocalTime( OsDateAndTime ) != 0);
}
/*** eDate - begin the execution of the Date command
*
* Purpose:
* To display and/or set the system date.
*
* Args:
* n - the parse tree node containing the date command
*
* int eDate(struct cmdnode *n)
*
* Returns:
* SUCCESS always.
*
*/
int eDate(n)
struct cmdnode *n ;
{
BOOL bTerse = FALSE;
PTCHAR pArgs = n->argptr;
DEBUG((CLGRP, DALVL, "eDATE: argptr = `%s'", n->argptr)) ;
//
// If extensions are enabled, allow a /T switch
// to disable inputing a new DATE, just display the
// current date.
//
if (fEnableExtensions)
while ( (pArgs = mystrchr( pArgs, TEXT('/') )) != NULL ) {
TCHAR c = (TCHAR) _totlower(*(pArgs+1));
if ( c == TEXT('t') )
bTerse = TRUE;
pArgs += 2; // just skip it
}
if ( bTerse ) {
PrintDate(NULL, PD_PTDATE, (TCHAR *)NULL, 0) ;
cmd_printf(CrLf);
return(LastRetCode = SUCCESS);
}
if ((n->argptr == NULL) ||
(*(n->argptr = EatWS(n->argptr, NULL)) == NULLC)) {
PutStdOut(MSG_CURRENT_DATE, NOARGS) ;
PrintDate(NULL, PD_PTDATE, (TCHAR *)NULL, 0) ;
cmd_printf(CrLf);
};
return(LastRetCode = GetVerSetDateTime(n->argptr, EDATE)) ;
}
/*** eTime - begin the execution of the Time command
*
* Purpose:
* To display and/or set the system date.
*
* int eTime(struct cmdnode *n)
*
* Args:
* n - the parse tree node containing the time command
*
* Returns:
* SUCCESS always.
*
*/
int eTime(n)
struct cmdnode *n ;
{
BOOL bTerse = FALSE;
PTCHAR pArgs = n->argptr;
DEBUG((CLGRP, TILVL, "eTIME: argptr = `%s'", n->argptr)) ;
//
// If extensions are enabled, allow a /T switch
// to disable inputing a new TIME, just display the
// current time.
//
if (fEnableExtensions)
while ( (pArgs = mystrchr( pArgs, TEXT('/') )) != NULL ) {
TCHAR c = (TCHAR) _totlower(*(pArgs+1));
if ( c == TEXT('t') )
bTerse = TRUE;
pArgs += 2; // just skip it
}
if ( bTerse ) {
PrintTime(NULL, PD_PTDATE, (TCHAR *)NULL, 0) ;
cmd_printf(CrLf);
return(LastRetCode = SUCCESS);
}
if ((n->argptr == NULL) ||
(*(n->argptr = EatWS(n->argptr, NULL)) == NULLC)) {
PutStdOut(MSG_CURRENT_TIME, NOARGS) ;
PrintTime(NULL, PT_TIME, (TCHAR *)NULL, 0) ;
cmd_printf(CrLf);
};
return(LastRetCode = GetVerSetDateTime(n->argptr, ETIME)) ;
}
/*** PrintDate - print the date
*
* Purpose:
* To print the date either in the format used by the Date command or
* the format used by the Dir command. The structure Cinfo is checked
* for the country date format.
*
* PrintDate(int flag, TCHAR *buffer)
*
* Args:
* flag - indicates which format to print
* *buffer - indicates whether or not to print date message
*
* Notes:
*/
int PrintDate(crt_time,flag,buffer,cch)
struct tm *crt_time ;
int flag ;
TCHAR *buffer;
int cch;
{
TCHAR DayOfWeek[10];
TCHAR datebuf [32] ;
unsigned i, j, k, m;
int ptr = 0;
struct tm xcrt_time ;
SYSTEMTIME SystemTime;
FILETIME FileTime;
FILETIME LocalFileTime;
int cchUsed;
BOOL NeedDayOfWeek = TRUE;
DEBUG((CLGRP, DALVL, "PRINTDATE: flag = %d", flag)) ;
//
// PrintDate is never called with PD_DATE and buffer == NULL
// PrintDate is never called with PD_DIR and buffer == NULL
// PrintDate is never called with PD_PTDATE and buffer != NULL
//
// Another way of saying this is:
// PD_DATE => output to buffer
// PD_DIR => output to buffer
// PD_DIR2000 => output to buffer
// PD_PTDATE => print out
//
// PD_DIR MM/DD/YY
// PD_DIR2000 MM/DD/YYYY
// PD_DATE Japan: MM/DD/YYYY DayOfWeek Rest: DayOfWeek MM/DD/YYYY
// PD_PTDATE Japan: MM/DD/YYYY DayOfWeek Rest: DayOfWeek MM/DD/YYYY
//
//
// If no time was input, then use the current system time. Convert from the
// various formats to something standard.
//
if (!crt_time) {
GetSystemTime(&SystemTime);
SystemTimeToFileTime(&SystemTime,&FileTime);
} else {
xcrt_time = *crt_time;
ConverttmToFILETIME(&xcrt_time,&FileTime);
}
FileTimeToLocalFileTime(&FileTime,&LocalFileTime);
FileTimeToSystemTime( &LocalFileTime, &SystemTime );
//
// SystemTime now contains the correct local time
// FileTime now contains the correct local time
//
//
// If extensions are enabled, we format things in the culturally
// correct format (from international control panel). if not, then
// we display it as best we can from NT 4.
//
if (fEnableExtensions) {
TCHAR LocaleDateFormat[128];
PTCHAR p;
BOOL InQuotes = FALSE;
//
// Map the locale to one that is acceptable to the console subsystem
//
if (!GetLocaleInfo( CmdGetUserDefaultLCID( ),
LOCALE_SSHORTDATE,
LocaleDateFormat,
sizeof( LocaleDateFormat ) / sizeof( LocaleDateFormat[0] ))) {
//
// Not enough room for this format, cheat and use the one we
// assumed from the DateFormat
//
_tcscpy( LocaleDateFormat, DateFormatString );
}
//
// The format string may be expanded with widely varying widths. We
// adjust this string to try to make sure that they are all fixed widths.
//
// The picture formats only have varying widths for:
// d (no leading zero date)
// dddd(full date name)
// M (no leading zero month)
// MMMM(full month name)
//
// So, if we see d or M, we change it to dd or MM (leading zero)
// If we see dddd or MMMM we change it to ddd or MMM (three char abbrev)
//
p = LocaleDateFormat;
while (*p != TEXT( '\0' )) {
TCHAR c = *p;
//
// Text inside single quotes is left alone
//
if (c == TEXT( '\'' )) {
InQuotes = !InQuotes;
p++;
} else if (InQuotes) {
p++;
} else if (c == TEXT( 'd' ) || c == TEXT( 'M' )) {
//
// Count the number of identical chars
//
int Count = 0;
while (*p == c) {
Count++;
p++;
}
//
// Reset p and shuffle string around based on the repetition count
//
p -= Count;
if (Count == 1) {
//
// Move string right by one and copy the first char
//
memmove( (PUCHAR) &p[1], (PUCHAR) &p[0], sizeof( TCHAR ) * (_tcslen( &p[0] ) + 1));
//
// Skip over the format string
//
p += 2;
} else {
//
// If the format string is specifying a day of week (d), then we do not
// need to add on the DayOfWeek, below
//
if (c == TEXT( 'd' )) {
NeedDayOfWeek = FALSE;
}
if (Count > 3) {
//
// Move string left from the first different char to just after the 3rd
// repetition
//
memmove( (PUCHAR) &p[3], (PUCHAR) &p[Count], sizeof( TCHAR ) * (_tcslen( &p[Count] ) + 1));
//
// Skip over the format string
//
p += 3;
} else {
//
// Skip over the 2 or 3 count
//
p += Count;
}
}
} else {
p++;
}
}
GetDateFormat( CmdGetUserDefaultLCID( ),
0,
&SystemTime,
LocaleDateFormat,
datebuf,
sizeof( datebuf ) / sizeof( datebuf[0] ));
} else {
i = SystemTime.wMonth;
j = SystemTime.wDay;
k = SystemTime.wYear;
//
// only print last two digits for DIR listings
//
if (flag == PD_DIR) {
k = k % 100;
}
if (DateFormat == YYMMDD ) {
m = k ; /* Swap all values */
k = j ;
j = i ;
i = m ;
} else if (DateFormat == DDMMYY) {
m = i ; /* Swap mon/day for Europe */
i = j ;
j = m ;
}
DEBUG((CLGRP, DALVL, "PRINTDATE: i = %d j = %d k = %d", i, j, k)) ;
//
// Format the current date and current day of week
//
_sntprintf(datebuf, 32, Fmt10, i, DateSeparator, j, DateSeparator, k);
}
_tcscpy( DayOfWeek, dayptr( SystemTime.wDayOfWeek )) ;
//
// If there is no input buffer, we display the day-of-week and date
// according to language preference. Only in DBCS codepages (aka Japan)
// does the day of week FOLLOW the date
//
if (buffer == NULL) {
//
// This can only be PD_PTDATE
//
//
// No day of week means we simply display the date
//
if (!NeedDayOfWeek) {
cchUsed = cmd_printf( Fmt11, datebuf );
} else if (IsDBCSCodePage()) {
cchUsed = cmd_printf( Fmt15, datebuf, DayOfWeek ); // "%s %s "
} else {
cchUsed = cmd_printf( Fmt15, DayOfWeek, datebuf ); // "%s %s "
}
} else {
//
// for PD_DATE, we need to output the date in the correct spot
//
if (NeedDayOfWeek && flag == PD_DATE) {
if (IsDBCSCodePage()) {
_tcscpy( buffer, datebuf );
_tcscat( buffer, TEXT( " " ));
_tcscat( buffer, DayOfWeek );
} else {
_tcscpy( buffer, DayOfWeek );
_tcscat( buffer, TEXT( " " ));
_tcscat( buffer, datebuf );
}
} else {
//
// PD_DIR and PD_DIR2000 only get the date
//
_tcscpy( buffer, datebuf );
}
cchUsed = _tcslen( buffer );
}
return cchUsed;
}
/*** PrintTime - print the time
*
* Purpose:
* To print the time either in the format used by the Time command or
* the format used by the Dir command. The structure Cinfo is checked
* for the country time format.
*
* PrintTime(int flag)
*
* Args:
* flag - indicates which format to print
*
*/
int PrintTime(crt_time, flag, buffer, cch)
struct tm *crt_time ;
int flag ;
TCHAR *buffer;
int cch;
{
TCHAR *ampm ;
unsigned hr ;
SYSTEMTIME SystemTime;
FILETIME FileTime;
FILETIME LocalFileTime;
int cchUsed;
if (!crt_time) {
GetSystemTime(&SystemTime);
SystemTimeToFileTime(&SystemTime,&FileTime);
} else {
ConverttmToFILETIME(crt_time,&FileTime);
}
FileTimeToLocalFileTime(&FileTime,&LocalFileTime);
FileTimeToSystemTime( &LocalFileTime, &SystemTime );
//
// PT_TIME implies Time Command format. This is nothing more
// than 24 hour clock with tenths
//
if (flag == PT_TIME) { /* Print time in Time command format */
if (!buffer) {
cchUsed = cmd_printf(Fmt06,
SystemTime.wHour, TimeSeparator,
SystemTime.wMinute, TimeSeparator,
SystemTime.wSecond, DecimalPlace,
SystemTime.wMilliseconds/10
) ;
} else {
cchUsed = _sntprintf(buffer, cch, Fmt06,
SystemTime.wHour, TimeSeparator,
SystemTime.wMinute, TimeSeparator,
SystemTime.wSecond, DecimalPlace,
SystemTime.wMilliseconds/10
) ;
}
} else {
TCHAR TimeBuffer[32];
//
// Print time in Dir command format. If extensions are enabled
// then we have the culturally correct time, otherwise we use
// the NT 4 format.
//
if (fEnableExtensions) {
TCHAR LocaleTimeFormat[128];
PTCHAR p;
BOOL InQuotes = FALSE;
if (!GetLocaleInfo( CmdGetUserDefaultLCID( ),
LOCALE_STIMEFORMAT,
LocaleTimeFormat,
sizeof( LocaleTimeFormat ) / sizeof( LocaleTimeFormat[0] ))) {
//
// Not enough room for this format, cheat and use the one we
// assumed from the DateFormat
//
_tcscpy( LocaleTimeFormat, TEXT( "HH:mm:ss t" ));
}
//
// Scan the string looking for "h", "H", or "m" and make sure there are two of them.
// If there is a single one, replicate it. We do this to ensure leading zeros
// which we need to make this a fixed-width string
//
p = LocaleTimeFormat;
while (*p != TEXT( '\0' )) {
TCHAR c = *p;
//
// Text inside single quotes is left alone
//
if (c == TEXT( '\'' )) {
InQuotes = !InQuotes;
p++;
} else if (InQuotes) {
p++;
} else if (c == TEXT( 'h' ) || c == TEXT( 'H' ) || c == TEXT( 'm' )) {
//
// Count the number of identical chars
//
int Count = 0;
while (*p == c) {
Count++;
p++;
}
//
// Reset p and shuffle string around based on the repetition count
//
p -= Count;
if (Count == 1) {
memmove( (PUCHAR) &p[1], (PUCHAR) &p[0], sizeof( TCHAR ) * (_tcslen( &p[0] ) + 1));
*p = c;
}
p++;
}
p++;
}
cchUsed = GetTimeFormat( CmdGetUserDefaultLCID( ),
TIME_NOSECONDS,
&SystemTime,
LocaleTimeFormat,
TimeBuffer,
sizeof( TimeBuffer ) / sizeof( TimeBuffer[0] ));
if (cchUsed == 0) {
TimeBuffer[0] = TEXT( '\0' );
}
} else {
ampm = AMIndicator ;
hr = SystemTime.wHour;
if ( TimeAmPm ) { /* 12 hour am/pm format */
if ( hr >= 12) {
if (hr > 12) {
hr -= 12 ;
}
ampm = PMIndicator ;
} else if (hr == 0) {
hr = 12 ;
}
} else { /* 24 hour format */
ampm = TEXT( " " );
}
_sntprintf( TimeBuffer,
sizeof( TimeBuffer ) / sizeof( TimeBuffer[0] ),
Fmt04,
hr,
TimeSeparator,
SystemTime.wMinute,
ampm );
}
if (!buffer) {
cchUsed = CmdPutString( TimeBuffer );
} else {
_tcsncpy( buffer, TimeBuffer, cch );
buffer[cch] = TEXT( '\0' );
cchUsed = _tcslen( buffer );
}
}
return cchUsed;
}
/*** GetVerSetDateTime - controls the changing of the date/time
*
* Purpose:
* To prompt the user for a date or time, verify it, and set it.
* On entry, if *dtstr is not '\0', it already points to a date or time
* string.
*
* If null input is given to one of the prompts, the command execution
* ends; neither the date or the time is changed.
*
* Once valid input has been received the date/time is updated.
*
* int GetVerSetDateTime(TCHAR *dtstr, int call)
*
* Args:
* dtstr - ptr to command line date/time string and is used to hold a ptr
* to the tokenized date/time string
* call - indicates whether to prompt for date or time
*
*/
int GetVerSetDateTime(dtstr, call)
TCHAR *dtstr ;
int call ;
{
TCHAR dtseps[16] ; /* Date/Time separators passed to TokStr() */
TCHAR *scan;
TCHAR separators[16];
TCHAR LocalBuf[MAX_PATH];
unsigned int dformat ;
SYSTEMTIME OsDateAndTime;
LONG cbRead;
int ret;
if (call == EDATE) { /* Initialize date/time separator list */
dtseps[0] = TEXT('/') ;
dtseps[1] = TEXT('-') ;
dtseps[2] = TEXT('.') ;
_tcscpy(&dtseps[3], DateSeparator) ;
} else {
dtseps[0] = TEXT(':');
dtseps[1] = TEXT('.');
dtseps[2] = TimeSeparator[0] ;
_tcscpy(&dtseps[3], DecimalPlace) ; /* decimal separator should */
/* always be last */
}
DEBUG((CLGRP, DALVL|TILVL, "GVSDT: dtseps = `%s'", dtseps)) ;
for ( ; ; ) { /* Date/time get-verify-set loop */
if ((dtstr) && (*dtstr != NULLC)) { /* If a date/time was passed copy it into input buffer */
_tcscpy(LocalBuf, dtstr) ;
*dtstr = NULLC ;
} else { /* Otherwise, prompt for new date/time */
switch (DateFormat) { /* M012 */
/* case USA: */
case MMDDYY: /* @@ */
dformat = MSG_ENTER_NEW_DATE ;
break ;
/* case JAPAN:
case CHINA:
case SWEDEN:
case FCANADA: @@ */
case YYMMDD:
dformat = MSG_ENTER_JAPAN_DATE ;
break ;
default:
dformat = MSG_ENTER_DEF_DATE ;
} ;
if ( call == EDATE )
PutStdOut(dformat, ONEARG, DateSeparator );
else
PutStdOut(MSG_ENTER_NEW_TIME, NOARGS);
scan = LocalBuf;
ret = ReadBufFromInput(CRTTONT(STDIN),LocalBuf,MAX_PATH,&cbRead);
if (ret && cbRead != 0) {
*(scan + cbRead) = NULLC ;
} else {
//
// attempt to read past eof or error in pipe
// etc.
//
return( FAILURE );
}
for (scan = LocalBuf; *scan; scan++)
if ( (*scan == '\n') || (*scan == '\r' )) {
*scan = '\0';
break;
}
if (!FileIsDevice(STDIN))
cmd_printf(Fmt17, LocalBuf) ;
DEBUG((CLGRP, DALVL|TILVL, "GVSDT: LocalBuf = `%s'", LocalBuf)) ;
}
_tcscpy( separators, dtseps);
_tcscat( separators, TEXT(";") );
if (*(dtstr = TokStr(LocalBuf,separators, TS_SDTOKENS )) == NULLC)
return( SUCCESS ) ; /* If empty input, return */
/* - Fill date/time buffer with correct date time and overlay that
* of the user
*/
GetLocalTime( &OsDateAndTime );
if (((call == EDATE) ? VerifyDateString(&OsDateAndTime,dtstr,dtseps) :
VerifyTimeString(&OsDateAndTime,dtstr,dtseps))) {
if (SetDateTime( &OsDateAndTime )) {
return( SUCCESS ) ;
} else {
if (GetLastError() == ERROR_PRIVILEGE_NOT_HELD) {
PutStdErr(GetLastError(),NOARGS);
return( FAILURE );
}
}
}
DEBUG((CLGRP, DALVL|TILVL, "GVSDT: Bad date/time entered.")) ;
PutStdOut(((call == EDATE) ? MSG_INVALID_DATE : MSG_REN_INVALID_TIME), NOARGS);
*dtstr = NULLC ;
}
return( SUCCESS );
}
/*** VerifyDateString - verifies a date string
*
* Purpose:
* To verify a date string and load it into OsDateAndTime.
*
* VerifyDateString(TCHAR *dtoks, TCHAR *dseps)
*
* Args:
* OsDateAndTime - where to store output numbers.
* dtoks - tokenized date string
* dseps - valid date separator characters
*
* Returns:
* TRUE if the date string is valid.
* FALSE if the date string is invalid.
*
*/
VerifyDateString(OsDateAndTime, dtoks, dseps)
LPSYSTEMTIME OsDateAndTime ;
TCHAR *dtoks ;
TCHAR *dseps ;
{
int indexes[3] ; /* Storage for date elements */
int i ; /* Work variable */
int y, d, m ; /* Array indexes */
switch (DateFormat) { /* Set array according to date format */
case MMDDYY:
m = 0 ;
d = 1 ;
y = 2 ;
break ;
case YYMMDD:
y = 0 ;
m = 1 ;
d = 2 ;
break ;
default:
d = 0 ;
m = 1 ;
y = 2 ;
}
DEBUG((CLGRP, DALVL, "VDATES: m = %d, d = %d, y = %d", m, d, y)) ;
/* Loop through the tokens in dtoks, and load them into the array. Note
* that the separators are also tokens in the string requiring the token
* pointer to be advanced twice for each element.
*/
for (i = 0 ; i < 3 ; i++, dtoks += _tcslen(dtoks)+1) {
TCHAR *j;
int Length;
DEBUG((CLGRP, DALVL, "VDATES: i = %d dtoks = `%ws'", i, dtoks)) ;
//
// The atoi() return code will not suffice to reject date field strings with
// non-digit characters. It is zero, both for error and for the valid integer
// zero. Also, a string like "8$" will return 8. For that reason, each
// character must be tested.
//
j = dtoks;
while (*j != TEXT( '\0' )) {
if (!_istdigit( *j )) {
return FALSE;
}
j++;
}
//
// Verify lengths:
// years can be 2 or 4 chars in length
// Days can be 1 or 2 chars in length
// Months can be 1 or 2 chars in length
//
indexes[i] = _tcstol(dtoks, NULL, 10) ;
Length = (int)(j - dtoks);
if (i == y) {
if (Length != 2 && Length != 4) {
return FALSE;
} else if (Length == 4 && indexes[i] < 1600) {
return FALSE;
}
} else
if (Length != 1 && Length != 2) {
return FALSE;
}
dtoks = j + 1;
DEBUG((CLGRP, DALVL, "VDATES: *dtoks = %02x", *dtoks)) ;
if (i < 2 && (!*dtoks || !_tcschr(dseps, *dtoks)))
return(FALSE) ;
}
//
// FIX,FIX - need to calculate OsDateAndTime->wDayOfWeek
//
OsDateAndTime->wDay = (WORD)indexes[d] ;
OsDateAndTime->wMonth = (WORD)indexes[m] ;
//
// Take two-digit years and convert them appropriately:
// 80...99 => 1980...1999
// 00...79 => 2000...2079
//
// Four-digit years are taken at face value
//
if (indexes[y] < 0) {
return FALSE;
} else if (00 <= indexes[y] && indexes[y] <= 79) {
indexes[y] += 2000;
} else if (80 <= indexes[y] && indexes[y] <= 99) {
indexes[y] += 1900;
} else if (100 <= indexes[y] && indexes[y] <= 1979) {
return FALSE;
}
OsDateAndTime->wYear = (WORD)indexes[y] ;
return(TRUE) ;
}
/*** VerifyTimeString - verifies a time string
*
* Purpose:
* To verify a date string and load it into OsDateAndTime.
*
* VerifyTimeString(TCHAR *ttoks)
*
* Args: /
* OsDateAndTime - where to store output numbers.
* ttoks - Tokenized time string. NOTE: Each time field and each
* separator field is an individual token in the time string.
* Thus the token advancing formula "str += mystrlen(str)+1",
* must be used twice to go from one time field to the next.
*
* Returns:
* TRUE if the time string is valid.
* FALSE if the time string is invalid.
*
*/
VerifyTimeString(OsDateAndTime, ttoks, tseps)
LPSYSTEMTIME OsDateAndTime ;
TCHAR *ttoks ;
TCHAR *tseps ;
{
int i ; /* Work variables */
int j ;
TCHAR *p1, *p2;
WORD *pp;
TCHAR tsuffixes[] = TEXT("aApP");
p2 = &tseps[ 1 ];
pp = &OsDateAndTime->wHour;
for (i = 0 ; i < 4 ; i++, ttoks += mystrlen(ttoks)+1) {
DEBUG((CLGRP,TILVL, "VTIMES: ttoks = `%ws' i = %d", ttoks, i)) ;
/* First insure that field is <= 2 bytes and they are digits. Note this
* also verifies that field is present.
*/
if ((j = mystrlen(ttoks)) > 2 ||
!_istdigit(*ttoks) ||
(*(ttoks+1) && !_istdigit(*(ttoks+1))))
break;
*pp++ = (TCHAR)_tcstol(ttoks, NULL, 10) ; /* Field OK, store int */
ttoks += j+1 ; /* Adv to separator tok */
DEBUG((CLGRP, TILVL, "VTIMES: separator = `%ws'", ttoks)) ;
if (!*ttoks) /* No separator field? */
break ; /* If so, exit loop */
/* handle AM or PM
*/
if (mystrchr(tsuffixes, *ttoks)) {
goto HandleAMPM;
}
/* M000 - Fixed ability to use '.' as separator for time strings
*/
if ( i < 2 ) {
if ( ! (p1 = mystrchr(tseps, *ttoks) ) )
return(FALSE) ;
} else {
if (*ttoks != *p2) /* Is decimal seperator */
return(FALSE) ; /* valid. */
}
} ;
//
// see if there's an a or p specified. if there's a P, adjust
// for PM time
//
if (*ttoks) {
BOOL pm;
if (!mystrchr(tsuffixes, *ttoks)) {
return FALSE;
}
HandleAMPM:
pm = (*ttoks == TEXT('p') || *ttoks == TEXT('P'));
// if we're here, we've encountered an 'a' or 'p'. make
// sure that it's the last character or that the only
// character left is an 'm'. remember that since
// 'a' and 'p' are separators, they get separated from the 'm'.
ttoks += 2; // go past 'a' or 'p' plus null.
if (*ttoks != NULLC &&
*ttoks != TEXT('m') &&
*ttoks != TEXT('M')) {
return FALSE;
}
if (pm) {
if (OsDateAndTime->wHour != 12) {
OsDateAndTime->wHour += 12;
}
} else {
if (OsDateAndTime->wHour == 12) {
OsDateAndTime->wHour -= 12;
}
}
}
/* M002 - If we got at least one field, fill the rest with 00's
*/
while (++i < 4)
*pp++ = 0 ;
return(TRUE) ;
}
VOID
ConverttmToFILETIME (
struct tm *Time,
LPFILETIME FileTime
)
/*++
Routine Description:
This routine converts an NtTime value to its corresponding Fat time
value.
Arguments:
Time - Supplies the C Runtime Time value to convert from
FileTime - Receives the equivalent File date and time
Return Value:
BOOLEAN - TRUE if the Nt time value is within the range of Fat's
time range, and FALSE otherwise
--*/
{
SYSTEMTIME SystemTime;
if (!Time) {
GetSystemTime(&SystemTime);
} else {
//
// Pack the input time/date into a system time record
//
SystemTime.wYear = (WORD)Time->tm_year;
SystemTime.wMonth = (WORD)(Time->tm_mon+1); // C is [0..11]
// NT is [1..12]
SystemTime.wDay = (WORD)Time->tm_mday;
SystemTime.wHour = (WORD)Time->tm_hour;
SystemTime.wMinute = (WORD)Time->tm_min;
SystemTime.wSecond = (WORD)Time->tm_sec;
SystemTime.wDayOfWeek = (WORD)Time->tm_wday;
SystemTime.wMilliseconds = 0;
}
SystemTimeToFileTime( &SystemTime, FileTime );
}
VOID
ConvertFILETIMETotm (
LPFILETIME FileTime,
struct tm *Time
)
/*++
Routine Description:
This routine converts a file time to its corresponding C Runtime time
value.
Arguments:
FileTime - Supplies the File date and time to convert from
Time - Receives the equivalent C Runtime Time value
Return Value:
--*/
{
SYSTEMTIME SystemTime;
// why skip printing the date if it's invalid?
//if (FileTime->dwLowDateTime == 0 && FileTime->dwHighDateTime == 0) {
// return( FALSE );
// }
FileTimeToSystemTime( FileTime, &SystemTime );
//
// Pack the input time/date into a time field record
//
Time->tm_year = SystemTime.wYear;
Time->tm_mon = SystemTime.wMonth-1; // NT is [1..12]
// C is [0..11]
Time->tm_mday = SystemTime.wDay;
Time->tm_hour = SystemTime.wHour;
Time->tm_min = SystemTime.wMinute;
Time->tm_sec = SystemTime.wSecond;
Time->tm_wday = SystemTime.wDayOfWeek;
Time->tm_yday = 0;
Time->tm_isdst = 0;
}
Reference in a new issue Copy permalink