windows-xp/Source/XPSP1/NT/admin/wmi/wbem/winmgmt/wbemcomn/datetimeparser.cpp

/*++

Copyright (C) 1996-2001 Microsoft Corporation

Module Name:

    DATETIMEPARSER.CPP

Abstract:

    Parses a date/time string and converts it into it's component values.

History:

    raymcc  25-Jul-99       Updated to bypass strict checks on DMTF
                            formats due to backward compatibility issues
                            and breaks reported by other teams.  See
                            NOT_USED_IN_WIN2000 #idndef bracketed code.


--*/

//=============================================================================
//
//  CDateTimeParser
//
//  Parses a date/time string and converts it into it's component values.
//
//  Supported DMTF date/time formats:
//  1:  yyyymmddhhmmss.uuuuuu+UTC
//  2:  yyyymmddhhmmss.uuuuuu-UTC
//
//  Supported date formats:
//  1:  Mon[th] dd[,] [yy]yy
//  2:  Mon[th][,] yyyy
//  3:  Mon[th] [yy]yy dd
//  4:  dd Mon[th][,][ ][yy]yy
//  5:  dd [yy]yy Mon[th]
//  6:  [yy]yy Mon[th] dd
//  7:  yyyy Mon[th]
//  8:  yyyy dd Mon[th]
//  9:  [M]M{/-.}dd{/-,}[yy]yy      ->Has to be same separator!
//  10: dd{/-.}[M]M{/-.}[yy]yy      ->Has to be same separator!
//  11: [M]M{/-.}[yy]yy{/-.}dd      ->Has to be same separator!
//  12: dd{/-.}[yy]yy{/-.}[M]M      ->Has to be same separator!
//  13: [yy]yy{/-.}dd{/-.}[M]M      ->Has to be same separator!
//  14: [yy]yy{/-.}[M]M{/-.}dd      ->Has to be same separator!
//  15: [yy]yyMMdd and yyyy[MM[dd]]
//
//  Supported Time formats:
//  1:  hh[ ]{AP}M
//  2:  hh:mm
//  3:  hh:mm[ ]{AP}M
//  4:  hh:mm:ss
//  5:  hh:mm:ss[ ]{AP}M
//  6:  hh:mm:ss:uuu
//  7:  hh:mm:ss.[[u]u]u
//  8:  hh:mm:ss:uuu[ ]{AP}M
//  9:  hh:mm:ss.[[u]u]u[ ]{AP}M
//=============================================================================

#include "precomp.h"
#include <string.h>
#include <stdio.h>
#include "DateTimeParser.h"
#include <TCHAR.h>

//=============================================================================
//  Constructor. This takes a DateTime string and parses it.
//=============================================================================
CDateTimeParser::CDateTimeParser(const TCHAR *pszDateTime)
:   m_nDayFormatPreference(mdy)
{
    // Get the prefered date format by using NLS locale call
    GetPreferedDateFormat();

    //Get the localised long month strings
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME1, m_pszFullMonth[0]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME2, m_pszFullMonth[1]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME3, m_pszFullMonth[2]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME4, m_pszFullMonth[3]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME5, m_pszFullMonth[4]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME6, m_pszFullMonth[5]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME7, m_pszFullMonth[6]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME8, m_pszFullMonth[7]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME9, m_pszFullMonth[8]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME10, m_pszFullMonth[9]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME11, m_pszFullMonth[10]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME12, m_pszFullMonth[11]);
    GetLocalInfoAndAlloc(LOCALE_SMONTHNAME13, m_pszFullMonth[12]);

    //Get the localised short month strings
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME1, m_pszShortMonth[0]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME2, m_pszShortMonth[1]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME3, m_pszShortMonth[2]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME4, m_pszShortMonth[3]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME5, m_pszShortMonth[4]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME6, m_pszShortMonth[5]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME7, m_pszShortMonth[6]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME8, m_pszShortMonth[7]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME9, m_pszShortMonth[8]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME10, m_pszShortMonth[9]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME11, m_pszShortMonth[10]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME12, m_pszShortMonth[11]);
    GetLocalInfoAndAlloc(LOCALE_SABBREVMONTHNAME13, m_pszShortMonth[12]);

    //Get the localised AM/PM strings
    GetLocalInfoAndAlloc(LOCALE_S1159, m_pszAmPm[0]);
    GetLocalInfoAndAlloc(LOCALE_S2359, m_pszAmPm[1]);

    //Decode the date time string.
    SetDateTime(pszDateTime);
}

CDateTimeParser::CDateTimeParser( void )
:   m_nDayFormatPreference(mdy),
    m_bValidDateTime( FALSE ),
    m_nDay( 0 ),
    m_nMonth( 0 ),
    m_nYear( 0 ),
    m_nHours( 0 ),
    m_nMinutes( 0 ),
    m_nSeconds( 0 ),
    m_nMicroseconds( 0 ),
    m_nUTC( 0 )
{
    ZeroMemory( m_pszFullMonth, sizeof(m_pszFullMonth) );
    ZeroMemory( m_pszShortMonth, sizeof(m_pszShortMonth) );
    ZeroMemory( m_pszAmPm, sizeof(m_pszAmPm) );
}

//=============================================================================
//  Destructor.  Tidies up after itself.
//=============================================================================
CDateTimeParser::~CDateTimeParser()
{
    if ( NULL != m_pszFullMonth[0] ) delete [] m_pszFullMonth[0];
    if ( NULL != m_pszFullMonth[1] ) delete [] m_pszFullMonth[1];
    if ( NULL != m_pszFullMonth[2] ) delete [] m_pszFullMonth[2];
    if ( NULL != m_pszFullMonth[3] ) delete [] m_pszFullMonth[3];
    if ( NULL != m_pszFullMonth[4] ) delete [] m_pszFullMonth[4];
    if ( NULL != m_pszFullMonth[5] ) delete [] m_pszFullMonth[5];
    if ( NULL != m_pszFullMonth[6] ) delete [] m_pszFullMonth[6];
    if ( NULL != m_pszFullMonth[7] ) delete [] m_pszFullMonth[7];
    if ( NULL != m_pszFullMonth[8] ) delete [] m_pszFullMonth[8];
    if ( NULL != m_pszFullMonth[9] ) delete [] m_pszFullMonth[9];
    if ( NULL != m_pszFullMonth[10] ) delete [] m_pszFullMonth[10];
    if ( NULL != m_pszFullMonth[11] ) delete [] m_pszFullMonth[11];
    if ( NULL != m_pszFullMonth[12] ) delete [] m_pszFullMonth[12];

    if ( NULL != m_pszShortMonth[0] ) delete [] m_pszShortMonth[0];
    if ( NULL != m_pszShortMonth[1] ) delete [] m_pszShortMonth[1];
    if ( NULL != m_pszShortMonth[2] ) delete [] m_pszShortMonth[2];
    if ( NULL != m_pszShortMonth[3] ) delete [] m_pszShortMonth[3];
    if ( NULL != m_pszShortMonth[4] ) delete [] m_pszShortMonth[4];
    if ( NULL != m_pszShortMonth[5] ) delete [] m_pszShortMonth[5];
    if ( NULL != m_pszShortMonth[6] ) delete [] m_pszShortMonth[6];
    if ( NULL != m_pszShortMonth[7] ) delete [] m_pszShortMonth[7];
    if ( NULL != m_pszShortMonth[8] ) delete [] m_pszShortMonth[8];
    if ( NULL != m_pszShortMonth[9] ) delete [] m_pszShortMonth[9];
    if ( NULL != m_pszShortMonth[10] ) delete [] m_pszShortMonth[10];
    if ( NULL != m_pszShortMonth[11] ) delete [] m_pszShortMonth[11];
    if ( NULL != m_pszShortMonth[12] ) delete [] m_pszShortMonth[12];

    if ( NULL != m_pszAmPm[0] ) delete [] m_pszAmPm[0];
    if ( NULL != m_pszAmPm[1] ) delete [] m_pszAmPm[1];
}

TCHAR* CDateTimeParser::AllocAmPm()
{
    TCHAR* pszAP = new TCHAR[4];

    if (pszAP)
    {
        pszAP[0] = ' ';
        pszAP[1] = m_pszAmPm[0][0];
        pszAP[2] = m_pszAmPm[1][0];
        pszAP[3] = 0;
    }

    return pszAP;
}

//=============================================================================
//  Does a GetLocalInfo and allocates the buffer large enough for the item.
//=============================================================================
void CDateTimeParser::GetLocalInfoAndAlloc(LCTYPE LCType, LPTSTR &lpLCData)
{
    int nSize;
    nSize = GetLocaleInfo(LOCALE_USER_DEFAULT, LCType, NULL, 0);
    lpLCData =  new TCHAR[nSize];

    if (lpLCData)
        GetLocaleInfo(LOCALE_USER_DEFAULT, LCType, lpLCData, nSize);
}

//=============================================================================
//  Uses locale call to work out the prefered date format.
//=============================================================================
void CDateTimeParser::GetPreferedDateFormat()
{
    int nSize;
    if (!(nSize = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SSHORTDATE, NULL, 0)))
        return;     // will use default of mdy
    TCHAR* lpLCData =  new TCHAR[nSize];
    if(lpLCData == NULL)
        return;

    if (!GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SSHORTDATE, lpLCData, nSize))
    {
        delete [] lpLCData;
        return;     // will use default of mdy
    }

    nSize -= 2;     // index of last character

    // It is only necessary to check first and last character to determine format
    if (lpLCData[0] == 'M')
    {
        if (lpLCData[nSize] == 'y')
            m_nDayFormatPreference = mdy;
        else // lpLCData[nSize] == 'd'
            m_nDayFormatPreference = myd;
    }
    else if (lpLCData[0] == 'd')
    {
        if (lpLCData[nSize] == 'y')
            m_nDayFormatPreference = dmy;
        else // lpLCData[nSize] == 'M'
            m_nDayFormatPreference = dym;
    }
    else // lpLCPata[0] == 'y'
    {
        if (lpLCData[nSize] == 'd')
            m_nDayFormatPreference = ymd;
        else // lpLCData[nSize] == 'M'
            m_nDayFormatPreference = ydm;
    }
    delete [] lpLCData;
}


//=============================================================================
//  Tidies up and parses a new date and time.
//=============================================================================
BOOL CDateTimeParser::SetDateTime(const TCHAR *pszDateTime)
{
    ResetDateTime(TRUE);

    if (CheckDMTFDateTimeFormatInternal(pszDateTime) == TRUE)
        return TRUE;

    if (CheckDateFormat(pszDateTime, TRUE) == TRUE)
        return TRUE;

    if (CheckTimeFormat(pszDateTime, TRUE) == TRUE)
        return TRUE;

    return TRUE;
}

//=============================================================================
//  Resets all the date/time values to the default values.
//  If bSQL is TRUE it sets to the SQL default.  Otherwise
//  sets to the DMTF default.
//=============================================================================
void CDateTimeParser::ResetDateTime(BOOL bSQL)
{
    ResetDate(bSQL);
    ResetTime(bSQL);
}

void CDateTimeParser::ResetDate(BOOL bSQL)
{
    m_bValidDateTime = FALSE;
    m_nDay = 1;
    m_nMonth = 1;
    m_nYear = 1990;
}

void CDateTimeParser::ResetTime(BOOL bSQL)
{
    m_bValidDateTime = FALSE;
    m_nHours = 0;
    m_nMinutes = 0;
    m_nSeconds = 0;
    m_nMicroseconds = 0;
    m_nUTC = 0;
}

//=============================================================================
//  Checks the date time for a valid DMTF string
//  1:  yyyymmddhhmmss.uuuuuu+UTC
//  2:  yyyymmddhhmmss.uuuuuu-UTC
// Note, this code is a near duplicate of the checks used to test the interval format.
//=============================================================================
BOOL CDateTimeParser::CheckDMTFDateTimeFormatInternal(const TCHAR *pszDateTime)
{
    if (lstrlen(pszDateTime) != 25)
        return FALSE;

    //Validate digits and puntuation...
    for (int i = 0; i < 14; i++)
    {
        if (!isdigit(pszDateTime[i]))
            return FALSE;
    }
    if (pszDateTime[i] != '.')
        return FALSE;
    for (i++;i < 21; i++)
    {
        if (!isdigit(pszDateTime[i]))
            return FALSE;
    }
    if ((pszDateTime[i] != '+') && (pszDateTime[i] != '-'))
        return FALSE;
    for (i++; i < 25; i++)
    {
        if (!isdigit(pszDateTime[i]))
            return FALSE;
    }

    m_nYear = ((pszDateTime[0] - '0') * 1000) +
              ((pszDateTime[1] - '0') * 100) +
              ((pszDateTime[2] - '0') * 10) +
               (pszDateTime[3] - '0');

    if (m_nYear < 1601)
        return FALSE;

    m_nMonth = ((pszDateTime[4] - '0') * 10) +
                (pszDateTime[5] - '0');

    if (m_nMonth < 1 || m_nMonth > 12)
        return FALSE;

    m_nDay = ((pszDateTime[6] - '0') * 10) +
              (pszDateTime[7] - '0');

    if (m_nDay < 1 || m_nDay > 31)
        return FALSE;

    m_nHours = ((pszDateTime[8] - '0') * 10) +
                (pszDateTime[9] - '0');

    if (m_nHours > 23)
        return FALSE;

    m_nMinutes = ((pszDateTime[10] - '0') * 10) +
                  (pszDateTime[11] - '0');

    if (m_nMinutes > 59)
        return FALSE;

    m_nSeconds = ((pszDateTime[12] - '0') * 10) +
                  (pszDateTime[13] - '0');

    if (m_nSeconds > 59)
        return FALSE;

    //14 is '.'

    m_nMicroseconds = ((pszDateTime[15] - '0') * 100000) +
                      ((pszDateTime[16] - '0') * 10000) +
                      ((pszDateTime[17] - '0') * 1000) +
                      ((pszDateTime[18] - '0') * 100) +
                      ((pszDateTime[19] - '0') * 10) +
                       (pszDateTime[20] - '0');

    //21 is '+' or '-'

    m_nUTC = ((pszDateTime[22] - '0') * 100) +
             ((pszDateTime[23] - '0') * 10) +
              (pszDateTime[24] - '0');

    if (pszDateTime[21] == '-')
        m_nUTC = 0 - m_nUTC;

    m_bValidDateTime = TRUE;

    return TRUE;
}

//=============================================================================
//  Static helper function so outside code can do quick DMTF format checks.
//=============================================================================
BOOL CDateTimeParser::CheckDMTFDateTimeFormat(
    const TCHAR *wszDateTime,
    BOOL bFailIfRelative,
    BOOL bFailIfUnzoned
    )
{

    if (wszDateTime == 0)
        return FALSE;

    int nLen = lstrlen(wszDateTime);
    if (nLen != 25)
        return FALSE;

    // Do two quick checks.  Ensure that the . and : are in
    // the right places or at least that * chars are there.

    wchar_t c1 = wszDateTime[14];
    wchar_t c2 = wszDateTime[21];
    if (!(c1 == L'.' || c1 == L'*'))
        return FALSE;
    if (!(c2 == L'+' || c2 == L'*' || c2 == '-'))
        return FALSE;

    return TRUE;

#ifdef NOT_USED_IN_WIN2000

    BOOL    bReturn = FALSE;

    // Temporary buffer for conversion
    char    szTemp[64];
    int     nNumChars = WideCharToMultiByte( CP_ACP, 0L, wszDateTime, -1, NULL, 0, NULL, NULL );

    if ( nNumChars < sizeof(szTemp) - 1 )
    {
        // We know it will fit, so do the conversion and use the date/time parser to
        // perform a conversion
        WideCharToMultiByte( CP_ACP, 0L, wszDateTime, -1, szTemp, sizeof(szTemp), NULL, NULL );

        // Check for use of asterisks for relative date/time
        if (!bFailIfRelative)
        {
            // Check year and if ALL asterisks then replace with a valid number
            if (szTemp[0] == '*' && szTemp[1] == '*' && szTemp[2] == '*' && szTemp[3] == '*')
            {
                szTemp[0] = '1'; szTemp[1] = '9'; szTemp[2] = '9'; szTemp[3] = '0';
            }
            // Check month and if ALL asterisks then replace with a valid number
            if (szTemp[4] == '*' && szTemp[5] == '*')
            {
                szTemp[4] = '0'; szTemp[5] = '1';
            }
            // Check day and if ALL asterisks then replace with a valid number
            if (szTemp[6] == '*' && szTemp[7] == '*')
            {
                szTemp[6] = '0'; szTemp[7] = '1';
            }
            // Check hour and if ALL asterisks then replace with a valid number
            if (szTemp[8] == '*' && szTemp[9] == '*')
            {
                szTemp[8] = '0'; szTemp[9] = '0';
            }
            // Check minutes and if ALL asterisks then replace with a valid number
            if (szTemp[10] == '*' && szTemp[11] == '*')
            {
                szTemp[10] = '0'; szTemp[11] = '0';
            }
            // Check seconds and if ALL asterisks then replace with a valid number
            if (szTemp[12] == '*' && szTemp[13] == '*')
            {
                szTemp[12] = '0'; szTemp[13] = '0';
            }
            // Check microseconds and if ALL asterisks then replace with a valid number
            if (szTemp[15] == '*' && szTemp[16] == '*' && szTemp[17] == '*' &&
                szTemp[18] == '*' && szTemp[19] == '*' && szTemp[20] == '*')
            {
                szTemp[15] = '0'; szTemp[16] = '0'; szTemp[17] = '0';
                szTemp[18] = '0'; szTemp[19] = '0'; szTemp[20] = '0';
            }
        }

        // Check for use of asterisks for unzoned date/time
        if (!bFailIfUnzoned)
        {
            // Check UTC and if ALL asterisks then replace with a valid number
            if (szTemp[22] == '*' && szTemp[23] == '*' && szTemp[24] == '*')
            {
                szTemp[22] = '0'; szTemp[23] = '0'; szTemp[24] = '0';
            }
        }

        CDateTimeParser dtParse;

        bReturn = dtParse.CheckDMTFDateTimeFormatInternal( szTemp );
    }

    return bReturn;
#endif

}

//=============================================================================
//  Static helper function so outside code can do quick DMTF format checks.
//  Currently, a time interval can only be validated, it cannot be used
//  to initialize a CDateTimeParser instance.
//=============================================================================
BOOL CDateTimeParser::CheckDMTFDateTimeInterval(
    LPCTSTR wszInterval
    )
{

    if (wszInterval == 0)
        return FALSE;

    int nLen = lstrlen(wszInterval);
    if (nLen != 25)
        return FALSE;

    // Do two quick checks.  Ensure that the . and : are in
    // the right places or at least that * chars are there.

    wchar_t c1 = wszInterval[14];
    wchar_t c2 = wszInterval[21];
    if (!(c1 == L'.' || c1 == L'*'))
        return FALSE;
    if (!(c2 == L':' || c2 == L'*'))
        return FALSE;


    return TRUE;

#ifdef NOT_USED_IN_WIN2000

    // Temporary buffer for conversion
    char    szTemp[64];
    int     nNumChars = WideCharToMultiByte( CP_ACP, 0L, wszInterval, -1, NULL, 0, NULL, NULL );

    if ( nNumChars < sizeof(szTemp) - 1 )
    {
        // We know it will fit, so do the conversion and use the date/time parser to
        // perform a conversion
        WideCharToMultiByte( CP_ACP, 0L, wszInterval, -1, szTemp, sizeof(szTemp), NULL, NULL );

        // =======================================================================================
        // Check the date time for a valid DMTF interval string:
        //   ddddddddHHMMSS.mmmmmm:000
        // Note, this code is a near duplicate of the checks used to test the non-interval format.
        // =======================================================================================

        if (strlen(szTemp) != 25)
            return FALSE;

        //Validate digits and puntuation...
        for (int i = 0; i < 14; i++)
        {
            if (!isdigit(szTemp[i]))
                return FALSE;
        }
        if (szTemp[i] != '.')
            return FALSE;
        for (i++;i < 21; i++)
        {
            if (!isdigit(szTemp[i]))
                return FALSE;
        }
        if (szTemp[i] != ':')
            return FALSE;
        for (i++; i < 25; i++)
        {
            if (szTemp[i] != '0')
                return FALSE;
        }

        int nHours = ((szTemp[8] - '0') * 10) +
                    (szTemp[9] - '0');

        if (nHours > 23)
            return FALSE;

        int nMinutes = ((szTemp[10] - '0') * 10) +
                      (szTemp[11] - '0');

        if (nMinutes > 59)
            return FALSE;

        int nSeconds = ((szTemp[12] - '0') * 10) +
                      (szTemp[13] - '0');

        if (nSeconds > 59)
            return FALSE;

        return TRUE;
    }

    return FALSE;
#endif

}

//=============================================================================
//  Goes through each of the date formats checking to see if any are valid
//=============================================================================
BOOL CDateTimeParser::CheckDateFormat(const TCHAR *pszDate, BOOL bCheckTimeAfter)
{
    if (DateFormat1(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat2(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat3(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat4(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat5(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat6(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat7(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat8(pszDate, bCheckTimeAfter))
        return TRUE;
    if (DateFormat15(pszDate, bCheckTimeAfter))
        return TRUE;

    switch(m_nDayFormatPreference)
    {
    case dmy:
        if (DateFormat10(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        break;
    case dym:
        if (DateFormat12(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        break;
    case mdy:
        if (DateFormat9(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        break;
    case myd:
        if (DateFormat11(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        break;
    case ydm:
        if (DateFormat13(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        break;
    case ymd:
        if (DateFormat14(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat14(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat9(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat10(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat11(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat12(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("/"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("-"), bCheckTimeAfter))
            return TRUE;
        if (DateFormat13(pszDate, __TEXT("."), bCheckTimeAfter))
            return TRUE;
        break;
    default:
        return FALSE;
    }

    return FALSE;
}

//=============================================================================
//  Goes through each of the time formats checking to see if any are valid
//  Order is important here.  Re-arranged to properly recognize AM/PM - mdavis.
//=============================================================================
BOOL CDateTimeParser::CheckTimeFormat(const TCHAR *pszTime, BOOL bCheckDateAfter)
{
    if (TimeFormat1(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat3(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat2(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat5(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat4(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat8(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat6(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat9(pszTime, bCheckDateAfter))
        return TRUE;
    if (TimeFormat7(pszTime, bCheckDateAfter))
        return TRUE;

    return FALSE;
}

//=============================================================================
//  Checks for date/time in the following format...
//  'Mon[th] dd[,] [yy]yy'
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat1(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidMonthString(pszString, __TEXT(" "), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (IsValidDayNumber(NULL, __TEXT(" ,")) != ok)
        goto error;

    if (IsValidYearNumber(NULL, __TEXT(" "), FALSE) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date/time in the following format...
//  'Mon[th][,] yyyy'
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat2(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidMonthString(pszString, __TEXT(" ,"), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (IsValidYearNumber(NULL, __TEXT(" "), TRUE) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date/time in the following format...
//  'Mon[th] [yy]yy dd'
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat3(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidMonthString(pszString, __TEXT(" ,"), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (IsValidYearNumber(NULL, __TEXT(" "), FALSE) != ok)
        goto error;

    if (IsValidDayNumber(NULL, __TEXT(" ")) != ok)
        goto error;


    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }
    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date/time in the following format...
//  'dd Mon[th][,][ ][yy]yy'
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat4(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidDayNumber(pszString, __TEXT(" ")) != ok)
        goto error;

    if (IsValidMonthString(NULL, __TEXT(" ,"), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (IsValidYearNumber(NULL, __TEXT(" "), FALSE) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date/time in the following format...
//  'dd [yy]yy Mon[th]'
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat5(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidDayNumber(pszString, __TEXT(" ")) != ok)
        goto error;

    if (IsValidYearNumber(NULL, __TEXT(" "), FALSE) != ok)
        goto error;

    if (IsValidMonthString(NULL, __TEXT(" "), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date/time in the following format...
//  '[yy]yy Mon[th] dd'
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat6(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidYearNumber(pszString, __TEXT(" "), FALSE) != ok)
        goto error;

    if (IsValidMonthString(NULL, __TEXT(" "), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (IsValidDayNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == ' ')
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != '\0')
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  yyyy Mon[th]
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat7(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];


    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidYearNumber(pszString, __TEXT(" "), TRUE) != ok)
        goto error;

    if (IsValidMonthString(NULL, __TEXT(" "), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date/time in the following format...
//  yyyy dd Mon[th]
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat8(const TCHAR *pszDateTime, BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidYearNumber(pszString, __TEXT(" "), TRUE) != ok)
        goto error;

    if (IsValidDayNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (IsValidMonthString(NULL, __TEXT(" "), m_pszFullMonth, m_pszShortMonth) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != '\0')
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  '[M]M{/-.}dd{/-.}[yy]yy         -> Separators have to be the same
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat9(const TCHAR *pszDateTime,
                                  const TCHAR *pszDateSeparator,
                                  BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];


    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidMonthNumber(pszString, pszDateSeparator) != ok)
        goto error;

    if (IsValidDayNumber(NULL, pszDateSeparator) != ok)
        goto error;

    if (IsValidYearNumber(NULL, __TEXT(" "), FALSE) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;


    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  dd{/-.}[M]M{/-.}[yy]yy      -> Separators have to be the same
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat10(const TCHAR *pszDateTime,
                                   const TCHAR *pszDateSeparator,
                                   BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidDayNumber(pszString, pszDateSeparator) != ok)
        goto error;

    if (IsValidMonthNumber(NULL, pszDateSeparator) != ok)
        goto error;

    if (IsValidYearNumber(NULL, __TEXT(" "), FALSE) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  [M]M{/-.}[yy]yy{/-.}dd      ->Has to be same separator!
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat11(const TCHAR *pszDateTime,
                                   const TCHAR *pszDateSeparator,
                                   BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidMonthNumber(pszString, pszDateSeparator) != ok)
        goto error;

    if (IsValidYearNumber(NULL, pszDateSeparator, FALSE) != ok)
        goto error;

    if (IsValidDayNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  dd{/-.}[yy]yy{/-.}[M]M      ->Has to be same separator!
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat12(const TCHAR *pszDateTime,
                                   const TCHAR *pszDateSeparator,
                                   BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidDayNumber(pszString, pszDateSeparator) != ok)
        goto error;

    if (IsValidYearNumber(NULL, pszDateSeparator, FALSE) != ok)
        goto error;

    if (IsValidMonthNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  [yy]yy{/-.}dd{/-.}[M]M      ->Has to be same separator!
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat13(const TCHAR *pszDateTime,
                                   const TCHAR *pszDateSeparator,
                                   BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidYearNumber(pszString, pszDateSeparator, FALSE) != ok)
        goto error;

    if (IsValidDayNumber(NULL, pszDateSeparator) != ok)
        goto error;

    if (IsValidMonthNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  [yy]yy{/-.}[M]M{/-.}dd      ->Has to be same separator!
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat14(const TCHAR *pszDateTime,
                                   const TCHAR *pszDateSeparator,
                                   BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidYearNumber(pszString, pszDateSeparator, FALSE) != ok)
        goto error;

    if (IsValidMonthNumber(NULL, pszDateSeparator) != ok)
        goto error;

    if (IsValidDayNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for date in the following format...
//  [yy]yyMMdd
//  yyyy[MM[dd]]
//  passes remaining string on to time parser if bCheckTimeAfter is set
//=============================================================================
BOOL CDateTimeParser::DateFormat15(const TCHAR *pszDateTime,
                                   BOOL bCheckTimeAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidYearMonthDayNumber(pszString) != ok)
        goto error;

    if (bCheckTimeAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the time
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckTimeFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetDate(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}


//=============================================================================
//  Checks for time in the following format...
//  hh[ ]{AP}M
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat1(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1],
          *pszAP = AllocAmPm();

    if (!pszString || !pszAP)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, pszAP) != ok)
        goto error;

    if (IsValidAmPmString(NULL, __TEXT(" "), m_pszAmPm) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;
    delete [] pszAP;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    if (pszAP)
        delete [] pszAP;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat2(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm[ ]{AP}M
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat3(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1],
          *pszAP = AllocAmPm();

    if (!pszString || !pszAP)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, pszAP) != ok)
        goto error;

    if (IsValidAmPmString(NULL, __TEXT(" "), m_pszAmPm) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;
    delete [] pszAP;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    if (pszAP)
        delete [] pszAP;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm:ss
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat4(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidSecondNumber(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm:ss[ ]{AP}M
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat5(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1],
          *pszAP = AllocAmPm();

    if (!pszString || !pszAP)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidSecondNumber(NULL, pszAP) != ok)
        goto error;

    if (IsValidAmPmString(NULL, __TEXT(" "), m_pszAmPm) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;
    delete [] pszAP;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    if (pszAP)
        delete [] pszAP;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm:ss:uuu
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat6(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidSecondNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidColonMillisecond(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm:ss.[[u]u]u
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat7(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1];

    if (!pszString)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidSecondNumber(NULL, __TEXT(".")) != ok)
        goto error;

    if (IsValidDotMillisecond(NULL, __TEXT(" ")) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm:ss:uuu[ ]{AP}M
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat8(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1],
          *pszAP = AllocAmPm();

    if (!pszString || !pszAP)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidSecondNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidColonMillisecond(NULL, pszAP) != ok)
        goto error;

    if (IsValidAmPmString(NULL, __TEXT(" "), m_pszAmPm) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;
    delete [] pszAP;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    if (pszAP)
        delete [] pszAP;

    return FALSE;
}

//=============================================================================
//  Checks for time in the following format...
//  hh:mm:ss.[[u]u]u[ ]{AP}M
//  passes remaining string on to date parser if bCheckDateAfter is set
//=============================================================================
BOOL CDateTimeParser::TimeFormat9(const TCHAR *pszDateTime, BOOL bCheckDateAfter)
{
    //Copy of string which we can change...
    TCHAR *pszString = new TCHAR[lstrlen(pszDateTime) + 1],
          *pszAP = AllocAmPm();

    if (!pszString || !pszAP)
        goto error;

    lstrcpy(pszString, pszDateTime);

    if (IsValidHourNumber(pszString, __TEXT(":")) != ok)
        goto error;

    if (IsValidMinuteNumber(NULL, __TEXT(":")) != ok)
        goto error;

    if (IsValidSecondNumber(NULL, __TEXT(".")) != ok)
        goto error;

    if (IsValidDotMillisecond(NULL, pszAP) != ok)
        goto error;

    if (IsValidAmPmString(NULL, __TEXT(" "), m_pszAmPm) != ok)
        goto error;

    if (bCheckDateAfter)
    {
        //Get the remaining string
        TCHAR *pszRemainingString = _tcstok(NULL, __TEXT(""));

        if (pszRemainingString)
        {
            //Skip white space
            while (*pszRemainingString == __TEXT(' '))
                pszRemainingString++;

            //if we are not at the end of the string pass on to the date
            //parser
            if (*pszRemainingString != __TEXT('\0'))
            {
                if (!CheckDateFormat(pszRemainingString, FALSE))
                {
                    goto error;
                }
            }
        }
    }

    delete [] pszString;
    delete [] pszAP;

    //mark date/time as valid...
    m_bValidDateTime = TRUE;

    return TRUE;

error:
    //mark date/time as invalid...
    ResetTime(TRUE);

    //Tidy up
    if (pszString)
        delete [] pszString;

    if (pszAP)
        delete [] pszAP;

    return FALSE;
}


//=========================================================================
//Check the month.
//=========================================================================
int CDateTimeParser::IsValidMonthString(TCHAR *pszString,
                                           const TCHAR *pszSeparator,
                                           TCHAR *pszFullMonth[],
                                           TCHAR *pszShortMonth[])
{
    BOOL bOK = FALSE;

    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    //Skip spaces
    while (*pszToken == __TEXT(' '))
        pszToken++;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Work through the possible months...
    for (int i = 0; i < 12; i++)
    {
        if ((lstrcmpi(pszShortMonth[i], pszToken) == 0) ||
            (lstrcmpi(pszFullMonth[i], pszToken) == 0))
        {
            //That is valid...
            bOK = TRUE;
            break;
        }
    }

    //Is this a valid month?
    if (!bOK)
    {
        return failed;
    }

    m_nMonth = i + 1;

    return ok;
}

//=========================================================================
//Check the month as a number.
//=========================================================================
int CDateTimeParser::IsValidMonthNumber(TCHAR *pszString,
                                        const TCHAR *pszSeparator)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    //Skip spaces...
    while (*pszToken == __TEXT(' '))
        pszToken++;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //convert it to a number
    i = _ttoi(pszToken);

    if ((i < 1) || (i > 12))
        return failed;

    m_nMonth = (unsigned char)i;

    return ok;
}

//=========================================================================
//Check the day.
//=========================================================================
int CDateTimeParser::IsValidDayNumber(TCHAR *pszString,
                                      const TCHAR *pszSeparator)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    //Skip spaces...
    while (*pszToken == __TEXT(' '))
        pszToken++;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //convert it to a number
    i = _ttoi(pszToken);

    if ((i < 1) || (i > 31))
        return failed;

    m_nDay = (unsigned char)i;

    return ok;
}

//=========================================================================
//Check the year.
//=========================================================================
int CDateTimeParser::IsValidYearNumber(TCHAR *pszString,
                                       const TCHAR *pszSeparator,
                                       BOOL bFourDigitsOnly)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    //Skip space
    while (*pszToken == __TEXT(' '))
        pszToken++;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //Needs to be 2 or 4 digits
    if ((i != 2) && (i != 4))
        return failed;

    if ((i == 2) && bFourDigitsOnly)
        return failed;

    //convert it to a number
    m_nYear = _ttoi(pszToken);

    //Do any conversions for 2 digit years...
    if ((i == 2) && (m_nYear < 50))
    {
        m_nYear += 2000;
    }
    else if (i == 2)
    {
        m_nYear += 1900;
    }

    return ok;
}

//=========================================================================
//Check the hours.
//=========================================================================
int CDateTimeParser::IsValidHourNumber(TCHAR *pszString,
                                       const TCHAR *pszSeparator)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    //Skip space
    while (*pszToken == __TEXT(' '))
        pszToken++;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //convert it to a number
    i = _ttoi(pszToken);

    //Validate a little
    if ((i < 0) || (i > 23))
        return failed;

    m_nHours = (unsigned char)i;

    return ok;
}

//=========================================================================
//Check the Minutes.
//=========================================================================
int CDateTimeParser::IsValidMinuteNumber(TCHAR *pszString,
                                         const TCHAR *pszSeparator)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //convert it to a number
    i = _ttoi(pszToken);

    //Validate a little
    if ((i < 0) || (i > 59))
        return failed;

    m_nMinutes = (unsigned char)i;

    return ok;
}

//=========================================================================
//Check the Seconds.
//=========================================================================
int CDateTimeParser::IsValidSecondNumber(TCHAR *pszString,
                                         const TCHAR *pszSeparator)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //convert it to a number
    i = _ttoi(pszToken);

    //Validate a little
    if ((i < 0) || (i > 59))
        return failed;

    m_nSeconds = (unsigned char)i;

    return ok;
}

//=========================================================================
//Check the milliseconds.  This is a colon prefix version
//=========================================================================
int CDateTimeParser::IsValidColonMillisecond(TCHAR *pszString,
                                             const TCHAR *pszSeparator)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //convert it to a number
    i = _ttoi(pszToken);

    //Validate a little
    if ((i < 0) || (i > 999))
        return failed;

    //milliseconds to microseconds
    m_nMicroseconds = i * 1000;

    return ok;
}

//=========================================================================
//Check the milliseconds.  This is a dot prefix (decimal) version
//=========================================================================
int CDateTimeParser::IsValidDotMillisecond(TCHAR *pszString,
                                           const TCHAR *pszSeparator)
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //convert it to a number
    int nVal = _ttoi(pszToken);

    //Convert the value into thousandths of a second.
    if (i < 3)
        nVal *= 10;

    if (i < 2)
        nVal *= 10;

    //Validate a little
    if ((nVal < 0) || (nVal > 999))
        return failed;

    //milliseconds to microseconds
    m_nMicroseconds = nVal * 1000;

    return ok;
}

//=========================================================================
//Check the AM/PM part.
//=========================================================================
int CDateTimeParser::IsValidAmPmString(TCHAR *pszString,
                                       const TCHAR *pszSeparator,
                                       TCHAR *pszAmPm[])
{
    TCHAR *pszToken = _tcstok(pszString, pszSeparator);
    if (pszToken == NULL)
        return nothingLeft;

    BOOL bOK = FALSE;

    //Skip spaces
    while (*pszToken == __TEXT(' '))
    {
        pszToken++;
    }

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    //Work through the possible AM/PM items...
    for (int i = 0; i < 2; i++)
    {
        if (lstrcmpi(pszAmPm[i], pszToken) == 0)
        {
            //That is valid...
            bOK = TRUE;
            break;
        }
    }

    if (!bOK)
        return failed;

    if (i == 1)
    {
        //PM adds 12 hours
        m_nHours += 12;
    }
    else if (m_nHours == 12)
    {
        //for AM, 12 o'clock equals 0 in 24 hour time.
        m_nHours = 0;
    }


    //Does this make the number too large now?
    if (m_nHours > 23)
        return failed;

    return ok;
}

//=========================================================================
//  Check the purely numeric year, month, day format...
//  [yy]yyMMdd
//  yyyy[MMdd]
//  NOTE:   6 and 8 digit dates are always ymd.
//          4 digits is always year
//=========================================================================
int CDateTimeParser::IsValidYearMonthDayNumber(TCHAR *pszString)
{
    int j;
    TCHAR *pszToken = _tcstok(pszString, __TEXT(" "));
    if (pszToken == NULL)
        return nothingLeft;

    BOOL bOK = FALSE;

    //Skip spaces
    while (*pszToken == __TEXT(' '))
    {
        pszToken++;
    }

    if (*pszToken == __TEXT('\0'))
        return nothingLeft;

    //Check it is digits...
    for (int i = 0; pszToken[i] != __TEXT('\0'); i++)
    {
        if (!isdigit(pszToken[i]))
            return failed;
    }

    //We support 4, 6 and 8 digits
    if ((i != 4) && (i != 6) && (i != 8))
        return failed;

    //4 digit years...
    if ((i == 4) || (i == 8))
    {
        m_nYear = 0;
        for (j = 0;j < 4; j++)
        {
            m_nYear *= 10;
            m_nYear += (*pszToken - '0');
            pszToken++;
        }
    }
    else
    {
        //2 digit years
        m_nYear = 0;
        for (j = 0;j < 2; j++)
        {
            m_nYear *= 10;
            m_nYear += (*pszToken - '0');
            pszToken++;
        }

        if (m_nYear >= 50)
        {
            m_nYear += 1900;
        }
        else
        {
            m_nYear += 2000;
        }
    }

    //If we have month and year...
    if (i > 4)
    {
        m_nMonth = ((*pszToken - __TEXT('0')) * 10) + (*(pszToken+1) - __TEXT('0'));
        pszToken += 2;

        if ((m_nMonth < 0) && (m_nMonth > 12))
            return failed;

        m_nDay = ((*pszToken - __TEXT('0')) * 10) + (*(pszToken+1) - __TEXT('0'));
        if ((m_nDay < 0) && (m_nDay > 31))
            return failed;
    }

    return ok;
}

int CDateTimeParser::FillDMTF(WCHAR* pwszBuffer)
{
    if(!IsValidDateTime())
        return failed;

    swprintf(pwszBuffer, L"%04d%02d%02d%02d%02d%02d.%06d%c%03d",
        m_nYear, m_nMonth, m_nDay, m_nHours, m_nMinutes, m_nSeconds,
        m_nMicroseconds,
        ((m_nUTC >= 0)?L'+':L'-'),
        ((m_nUTC >= 0)?m_nUTC:-m_nUTC));

    return ok;
}

BOOL NormalizeCimDateTime(
    IN  LPCWSTR pszSrc,
    OUT BSTR *strAdjusted
    )
{
    int yr = 0, mo = 0, da = 0, hh = 0, mm = 0, ss = 0, micro = 0, utcOffset = 0;
    wchar_t wcSign = 0;

    if (pszSrc == 0 || strAdjusted == 0)
        return FALSE;

    // Parse DMTF format.
    // yyyymmddhhmmss.mmmmmmsuuu
    // =========================

    swscanf(pszSrc, L"%04d%02d%02d%02d%02d%02d.%06d%C%03d",
        &yr, &mo, &da, &hh, &mm, &ss, &micro, &wcSign, &utcOffset
        );

    if (wcSign == 0)
        return FALSE;

    // Convert to Win32 time for adjustment.
    // =====================================

    SYSTEMTIME st;
    FILETIME ft;

    st.wYear = WORD(yr);
    st.wMonth = WORD(mo);
    st.wDay = WORD(da);
    st.wDayOfWeek = 0;
    st.wHour = WORD(hh);
    st.wMinute = WORD(mm);
    st.wSecond = WORD(ss);
    st.wMilliseconds = WORD(micro / 1000);

    BOOL bRes = SystemTimeToFileTime(&st, &ft);
    if (!bRes)
        return bRes;

    ULARGE_INTEGER ul;
    ul.HighPart = ft.dwHighDateTime;
    ul.LowPart = ft.dwLowDateTime;
    unsigned __int64 u64 = ul.QuadPart;

    // Adjust rest of time so that we normalize to UTC

    if (wcSign == L'-')
        u64 += (unsigned __int64) 600000000 * (unsigned __int64) utcOffset;
    else
        u64 -= (unsigned __int64) 600000000 * (unsigned __int64) utcOffset;

    ul.QuadPart = u64;
    ft.dwHighDateTime = ul.HighPart;
    ft.dwLowDateTime = ul.LowPart;

    bRes = FileTimeToSystemTime(&ft, &st);
    if (!bRes)
        return bRes;

    wchar_t buf[128];
    swprintf(buf, L"%04d%02d%02d%02d%02d%02d.%06d+000",
        st.wYear, st.wMonth, st.wDay,
        st.wHour, st.wMinute, st.wSecond, st.wMilliseconds*1000
        );

    *strAdjusted = SysAllocString(buf);
    if (*strAdjusted == 0)
        return FALSE;

    return TRUE;
}