/*++

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];


#define SHORT_NAME_LENGTH   32

TCHAR ShortMondayName[SHORT_NAME_LENGTH];
TCHAR ShortTuesdayName[SHORT_NAME_LENGTH];
TCHAR ShortWednesdayName[SHORT_NAME_LENGTH];
TCHAR ShortThursdayName[SHORT_NAME_LENGTH];
TCHAR ShortFridayName[SHORT_NAME_LENGTH];
TCHAR ShortSaturdayName[SHORT_NAME_LENGTH];
TCHAR ShortSundayName[SHORT_NAME_LENGTH];

#define AMPM_INDICATOR_LENGTH   32

TCHAR AMIndicator[AMPM_INDICATOR_LENGTH];
TCHAR PMIndicator[AMPM_INDICATOR_LENGTH];
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, TimeSeparator, sizeof(TimeSeparator) / sizeof( TCHAR )))
        _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, DateSeparator, sizeof(DateSeparator) / sizeof( TCHAR )))
        _tcscpy(DateSeparator, TEXT("/"));

    // get the short day names
    if (!GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME1, ShortMondayName, sizeof(ShortMondayName) / sizeof( TCHAR )))
        _tcscpy(ShortMondayName, TEXT("Mon"));
    
    if (!GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME2, ShortTuesdayName, sizeof(ShortTuesdayName) / sizeof( TCHAR )))
        _tcscpy(ShortTuesdayName, TEXT("Tue"));
    
    if (!GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME3, ShortWednesdayName, sizeof(ShortWednesdayName) / sizeof( TCHAR )))
        _tcscpy(ShortWednesdayName, TEXT("Wed"));
    
    if (!GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME4, ShortThursdayName, sizeof(ShortThursdayName) / sizeof( TCHAR )))
        _tcscpy(ShortThursdayName, TEXT("Thu"));
    
    if (!GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME5, ShortFridayName, sizeof(ShortFridayName) / sizeof( TCHAR )))
        _tcscpy(ShortFridayName, TEXT("Fri"));
    
    if (!GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME6, ShortSaturdayName, sizeof(ShortSaturdayName) / sizeof( TCHAR )))
        _tcscpy(ShortSaturdayName, TEXT("Sat"));
    
    if (!GetLocaleInfo(CmdLcid, LOCALE_SABBREVDAYNAME7, ShortSundayName, sizeof(ShortSundayName) / sizeof( TCHAR )))
        _tcscpy(ShortSundayName, TEXT("Sun"));

    // get decimal and thousand separator strings
    if (!GetLocaleInfo(CmdLcid, LOCALE_SDECIMAL, DecimalPlace, sizeof(DecimalPlace) / sizeof( TCHAR )))
        _tcscpy(DecimalPlace, TEXT("."));
    
    if (!GetLocaleInfo(CmdLcid, LOCALE_STHOUSAND, ThousandSeparator, sizeof(ThousandSeparator) / sizeof( TCHAR )))
        _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" ) ;
}


/**** dayptr - return pointer to day of the week
 *
 * Purpose:
 *      To return a pointer to the string representing the current day of
 *      the week.
 *
 * Args:
 *      dow - number representing the day of the week.
 *
 */

TCHAR *dayptr( dow )
unsigned dow;
{
    switch ( dow ) {
    case 0:  return ShortSundayName;
    case 1:  return ShortMondayName;
    case 2:  return ShortTuesdayName;
    case 3:  return ShortWednesdayName;
    case 4:  return ShortThursdayName;
    case 5:  return ShortFridayName;
    default: return ShortSaturdayName;
    }
}

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[SHORT_NAME_LENGTH];
    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 */
            if (_tcslen( dtstr ) >= MAX_PATH) {
                PutStdOut(((call == EDATE) ? MSG_INVALID_DATE : MSG_REN_INVALID_TIME), NOARGS);
                return FAILURE;
            }
            
            _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;
}