windows-server-2003/public/internal/admin/inc/cmdline.h

// ****************************************************************************
//
//  Copyright (c) 2000 Microsoft Corporation
//
//  Module Name:
//
//        Cmdline.h
//
//  Abstract:
//
//        This modules contains the common functionality file headers and type
//        definitions
//
//  Author:
//
//        Sunil G.V.N. Murali ([email protected]) 1-Sep-2000
//
//  Revision History:
//
//        Sunil G.V.N. Murali ([email protected]) 1-Sep-2000 : Created It.
//
// ****************************************************************************

#ifndef __CMDLINE_H
#define __CMDLINE_H

#ifndef CMDLINE_VERSION
#define CMDLINE_VERSION         100
#endif

#ifndef UNICODE
#error this library can be compiled only in UNICODE environment
#endif

#ifdef __cplusplus
extern "C" {
#endif

// constants / defines

#define MAX_RES_STRING                  254
#define MAX_STRING_LENGTH               254

// stubs for 'displaying'
#define DISPLAY_MESSAGE( file, message )           ShowMessage( file, message )


#if CMDLINE_VERSION == 100

// ****************************************************************************
// all the below stuff in deprecated in cmdline library version
// greater that 1.0
// ****************************************************************************

//
// custom macros ( for trapping memory leaks )
//
#ifdef _DEBUG

#define __malloc( size )        \
        _malloc_dbg( size, _NORMAL_BLOCK, __FILE__, __LINE__ )

#define __calloc( count, size )         \
        _calloc_dbg( count, size, _NORMAL_BLOCK, __FILE__, __LINE__ )

#define __free( block )                             \
        if ( (block) != NULL )                      \
        {                                           \
            _free_dbg( (block), _NORMAL_BLOCK );    \
            (block) = NULL;                         \
        }                                           \
        1

#define __realloc( block, size )                                    \
        (((block) != NULL) ?                                        \
                _realloc_dbg( (block), size,                        \
                            _NORMAL_BLOCK, __FILE__, __LINE__ ) :   \
                __malloc( size ))

#else   // #ifdef _DEBUG

#define __malloc( size )            malloc( size )

#define __calloc( count, size )     calloc( count, size )

#define __free( block )             \
        if ( (block) != NULL )      \
        {                           \
            free( (block) );        \
            (block) = NULL;         \
        }                           \
        1

#define __realloc( block, size )                \
        (((block) != NULL) ? realloc( block, size ) : __malloc( size ))

#endif  // #ifdef _DEBUG

//
// custom macros
//
#define CHECK_NULL( statement, value )  \
        if ( ( statement ) == NULL )    \
        {                               \
            return value;               \
        }       \
        1

#define SHOW_RESULT_MESSAGE( server, tag, message )             \
        if ( IsLocalSystem( server ) == TRUE )                  \
        {                                                       \
                DISPLAY_MESSAGE2( stderr, szBuffer,             \
                        _T( "%s %s" ), tag, message );          \
        }                                                       \
        else                                                    \
        {                                                       \
                DISPLAY_MESSAGE3( stderr, szBuffer,             \
                    _T( "%s %s: %s" ), tag, server, message );  \
        }                                                       \
        1

//
// string formatting stubs
#define FORMAT_STRING( buffer, format, value )                          \
        swprintf( buffer, format, value )

#define FORMAT_STRING2( buffer, format, value1, value2 )                \
        swprintf( buffer, format, value1, value2 )

#define FORMAT_STRING3( buffer, format, value1, value2, value3 )        \
        swprintf( buffer, format, value1, value2, value3 )

#define FORMAT_STRING_EX( buffer, format, value, length, alignflag )    \
        swprintf( buffer, format, value );      \
        AdjustStringLength( buffer, length, alignflag )

#define FORMAT_STRING_EX2( buffer, format, value1, value2, length, alignflag )  \
        swprintf( buffer, format, value1, value2 );                             \
        AdjustStringLength( buffer, length, alignflag )

#define FORMAT_STRING_EX3( buffer, format, value1, value2, value3, length, alignflag )  \
        swprintf( buffer, format, value1, value2, value3 );                             \
        AdjustStringLength( buffer, length, alignflag )

//
// stubs for 'displaying'
#define DISPLAY_MESSAGE( file, message )                                    \
        ShowMessage( file, message )

#define DISPLAY_MESSAGE1( file, buffer, format, value1 )                    \
        FORMAT_STRING( buffer, format, value1 );                            \
        ShowMessage( file, buffer )

#define DISPLAY_MESSAGE2( file, buffer, format, value1, value2 )            \
        FORMAT_STRING2( buffer, format, value1, value2 );                   \
        ShowMessage( file, buffer )

#define DISPLAY_MESSAGE3( file, buffer, format, value1, value2, value3 )    \
        FORMAT_STRING3( buffer, format, value1, value2, value3 );           \
        ShowMessage( file, buffer )

//
// display messages from resource file's string table ( stubs )
#define DISPLAY_RES_MESSAGE( file, id ) \
        ShowResMessage( file, id )

#define DISPLAY_RES_MESSAGE1( file, buffer, id, value1 )        \
        FORMAT_STRING( buffer, GetResString( id ), value1 );    \
        ShowMessage( file, buffer )

#define DISPLAY_RES_MESSAGE2( file, buffer, id, value1, value2 )        \
        FORMAT_STRING2( buffer, GetResString( id ), value1, value2 );   \
        ShowMessage( file, buffer )

#define DISPLAY_RES_MESSAGE3( file, buffer, id, value1, value2, value3 )        \
        FORMAT_STRING3( buffer, GetResString( id ), value1, value2, value3 );   \
        ShowMessage( file, buffer )



#define MAX_USERNAME_LENGTH             64
#define MAX_PASSWORD_LENGTH             64

#define FULL_SUCCESS                    0
#define PARTIALLY_SUCCESS               128
#define COMPLETELY_FAILED               255

//
// type definitions
//
typedef TCHAR __STRING_32[ 32 ];
typedef TCHAR __STRING_64[ 64 ];
typedef TCHAR __STRING_128[ 128 ];
typedef TCHAR __STRING_256[ 256 ];
typedef TCHAR __STRING_512[ 512 ];
typedef TCHAR __STRING_1024[ 1024 ];
typedef TCHAR __STRING_2048[ 2048 ];
typedef TCHAR __STRING_4096[ 4096 ];
typedef TCHAR __RESOURCE_STRING [ MAX_RES_STRING + 1 ];
typedef TCHAR __MAX_SIZE_STRING[ MAX_STRING_LENGTH + 1 ];


// string manipulation macros
#define STRING_COPY_STATIC( destination, source )           \
            StringCopy( destination, source, SIZE_OF_ARRAY( destination ) )

#define STRING_COPY_DYNAMIC( destination, source )          \
            StringCopyEx( destination, source )

#define STRING_CONCAT_STATIC( destination, source )         \
        StringConcat( destination, source, SIZE_OF_ARRAY( destination ) )

#define STRING_CONCAT_DYNAMIC( destination, source )        \
        StringConcatEx( destination, source )

#define STRING_COPY( destination, source )      \
    if ( destination != NULL && _msize( destination ) != -1 )       \
    {                                                               \
        STRING_COPY_DYNAMIC( destination, source );                 \
    }                                                               \
    else                                                            \
    {                                                               \
        STRING_COPY_STATIC( destination, source );                  \
    }                                                               \
    1

#define STRING_CONCAT( destination, source )     \
    if ( destination != NULL && _msize( destination ) != -1 )       \
    {                                                               \
        STRING_CONCAT_DYNAMIC( destination, source );               \
    }                                                               \
    else                                                            \
    {                                                               \
        STRING_CONCAT_STATIC( destination, source );                \
    }                                                               \
    1

//
// function re-defs
//
#ifdef UNICODE

#define GetCompatibleStringFromMultiByte        GetAsUnicodeStringEx
#define GetCompatibleStringFromUnicode          GetAsUnicodeString

#else

#define GetCompatibleStringFromMultiByte        GetAsMultiByteString
#define GetCompatibleStringFromUnicode          GetAsMultiByteStringEx

#endif  // UNICODE

/////////
// conversion functions
// old legacy functions -- these are made obsolete
LPSTR GetAsMultiByteString( LPCWSTR pszSource,
                            LPSTR pszDestination, DWORD dwLength );
LPWSTR GetAsUnicodeStringEx( LPCSTR pszSource,
                             LPWSTR pwszDestination, DWORD dwLength );

/////////
// this function is mapped to the StringCopyW
// LPWSTR GetAsUnicodeString( LPCWSTR pszSource,
//                            LPWSTR pwszDestination,
//                            DWORD dwLength );
#define GetAsUnicodeString( source,                                         \
                            destination,                                    \
                            length )        StringCopyW( destination,       \
                                                         source,            \
                                                         length )

/////////
// this function is mapped to its another function which is of similar type
// LPSTR GetAsMultiByteStringEx( LPCWSTR pwszSource,
//                               LPSTR pszDestination, DWORD dwLength );
#define GetAsMultiByteStringEx      GetAsMultiByteString

// ****************************************************************************
// all the above stuff is deprecated in cmdline library version
// greater that 1.0
// ****************************************************************************

#endif      // CMDLINE_VERSION == 100


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                      COMMON FUNCTIONALITY                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

// wrappers for quote meta
#define _X( text )              text
#define _X1( text )             text
#define _X2( text )             text
#define _X3( text )             text

//
// macros
//
#define TAG_ERROR                    GetResString( IDS_TAG_ERROR )
#define TAG_WARNING                  GetResString( IDS_TAG_WARNING )
#define TAG_SUCCESS                  GetResString( IDS_TAG_SUCCESS )
#define TAG_INFORMATION              GetResString( IDS_TAG_INFORMATION )
#define SIZE_OF_ARRAY( array )       ( sizeof( array ) / sizeof( array[ 0 ] ) )

//
// constants / defines / enumerations
//
#define _DEFAULT_CODEPAGE               CP_OEMCP

#define BACK_SPACE                      0x08
#define BLANK_CHAR                      0x00
#define CARRIAGE_RETURN                 0x0D

#define ASTERIX                         _T( "*" )
#define BEEP_SOUND                      _T( "\a" )

#define TRIM_LEFT                       0x00000001
#define TRIM_RIGHT                      0x00000002
#define TRIM_ALL                        0x00000003

extern const WCHAR cwchNullChar;
extern const WCHAR cwszNullString[ 2 ];

#if CMDLINE_VERSION == 100
#define NULL_CHAR                       L'\0'
#define NULL_STRING                     L"\0"
#endif

#define V_NOT_AVAILABLE                 GetResString( IDS_V_NOT_AVAILABLE )
#define ERROR_OS_INCOMPATIBLE           GetResString( IDS_ERROR_OS_INCOMPATIBLE )
#define ERROR_REMOTE_INCOMPATIBLE       GetResString( IDS_ERROR_REMOTE_INCOMPATIBLE )

// macros for copy or concatenation ansi/unicode strings
#ifdef UNICODE

#define StringCopy              StringCopyW
#define StringCopyEx            StringCopyExW
#define StringConcat            StringConcatW
#define StringConcatEx          StringConcatExW
#define StringLength            StringLengthW
#define StringCompare           StringCompareW
#define StringCompareEx         StringCompareExW
#else

#define StringCopy              StringCopyA
#define StringCopyEx            StringCopyExA
#define StringConcat            StringConcatA
#define StringConcatEx          StringConcatExA
#define StringLength            StringLengthA
#define StringCompare           StringCompareA
#define StringCompareEx         StringCompareExA

#endif

//
// flags -- specific to ShowLastErrorEx
#define SLE_TYPE_ERROR          0x00000001
#define SLE_TYPE_INFO           0x00000002
#define SLE_TYPE_WARNING        0x00000004
#define SLE_TYPE_SUCCESS        0x00000008
#define SLE_SYSTEM              0x00010000
#define SLE_INTERNAL            0x00020000
#define SLE_MASK                0x000F0000

//
// pattern matching flags
#define PATTERN_LOCALE_USENGLISH             0x00000001
#define PATTERN_NOPARSING                    0x00000002
#define PATTERN_COMPARE_IGNORECASE           0x00000100
#define PATTERN_COMPARE_IGNOREKANATYPE       0x00000200
#define PATTERN_COMPARE_IGNORENONSPACE       0x00000400
#define PATTERN_COMPARE_IGNORESYMBOLS        0x00000800
#define PATTERN_COMPARE_IGNOREWIDTH          0x00001000
#define PATTERN_COMPARE_STRINGSORT           0x00002000



//
// function prototypes
//

BOOL InitGlobals();

LPCWSTR GetReason();
BOOL SetReason( LPCWSTR pwszReason );
BOOL SetReason2( DWORD dwCount, LPCWSTR pwszFormat, ... );

BOOL SaveLastError();
DWORD WNetSaveLastError();
BOOL ShowLastError( FILE* fp );
BOOL ShowLastErrorEx( FILE* fp, DWORD dwFlags );

BOOL ReleaseGlobals();

BOOL IsWin2KOrLater();
BOOL IsCompatibleOperatingSystem( DWORD dwVersion );
BOOL SetOsVersion( DWORD dwMajor, DWORD dwMinor, WORD wServicePackMajor );

LPCWSTR GetResString( UINT uID );
LPCWSTR GetResString2( UINT uID, DWORD dwIndexNumber );

double AsFloat( LPCWSTR pwszValue );
BOOL IsFloatingPoint( LPCWSTR pwszValue );
LONG AsLong( LPCWSTR pwszValue, DWORD dwBase );
BOOL IsNumeric( LPCWSTR pwszValue, DWORD dwBase, BOOL bSigned );

LPCWSTR FindChar( LPCWSTR pwszString, WCHAR wch, DWORD dwFrom );
LONG FindChar2( LPCWSTR pwszString, WCHAR wch, BOOL bIgnoreCase, DWORD dwFrom );
BOOL InString( LPCWSTR pwszString, LPCWSTR pwszList, BOOL bIgnoreCase );
LPCWSTR FindOneOf( LPCWSTR pwszText, LPCWSTR pwszTextToFind, DWORD dwFrom );
LONG FindOneOf2( LPCWSTR pwszText, LPCWSTR pwszTextToFind, BOOL bIgnoreCase, DWORD dwFrom );
LPCWSTR FindString( LPCWSTR pwszText, LPCWSTR pwszTextToFind, DWORD dwFrom );
LONG FindString2( LPCWSTR pwszText, LPCWSTR pwszTextToFind, BOOL bIgnoreCase, DWORD dwFrom );

LONG StringLengthInBytes( LPCWSTR pwszText );

LPCWSTR TrimString( LPWSTR pwszString, DWORD dwFlags );
LPCWSTR TrimString2( LPWSTR pwszString, LPCWSTR pwszTrimChars, DWORD dwFlags );
LPCWSTR QuoteMeta( LPCWSTR pwszText, DWORD dwQuoteIndex );
LPCWSTR AdjustStringLength( LPWSTR pwszValue, DWORD dwLength, BOOL bPadLeft );
LPCWSTR Replicate( LPWSTR pwszBuffer,
                   LPCWSTR pwszText, DWORD dwCount, DWORD dwLength );

BOOL IsConsoleFile( FILE* fp );
LCID GetSupportedUserLocale( BOOL* pbLocaleChanged );

BOOL StringCopyExA( LPSTR pszDest, LPCSTR pszSource );
BOOL StringConcatExA( LPSTR pszDest, LPCSTR pszSource );
BOOL StringCopyExW( LPWSTR pwszDest, LPCWSTR pwszSource );
BOOL StringConcatExW( LPWSTR pwszDest, LPCWSTR pwszSource );
BOOL StringCopyA( LPSTR pszDest, LPCSTR pszSource, LONG lSize );
BOOL StringConcatA( LPSTR pszDest, LPCSTR pszSource, LONG lSize );
BOOL StringCopyW( LPWSTR pwszDest, LPCWSTR pwszSource, LONG lSize );
BOOL StringConcatW( LPWSTR pwszDest, LPCWSTR pwszSource, LONG lSize );
DWORD StringLengthA( LPCSTR pszSource, DWORD dwReserved );
DWORD StringLengthW( LPCWSTR pwszSource, DWORD dwReserved );

LONG StringCompareW( LPCWSTR pwszString1,
                     LPCWSTR pwszString2, BOOL bIgnoreCase, DWORD dwCount );
LONG StringCompareA( LPCSTR pwszString1,
                     LPCSTR pwszString2, BOOL bIgnoreCase, DWORD dwCount );
LONG StringCompareExW( LPCWSTR pwszString1,
                       LPCWSTR pwszString2, BOOL bIgnoreCase, DWORD dwCount );
LONG StringCompareExA( LPCSTR pwszString1,
                       LPCSTR pwszString2, BOOL bIgnoreCase, DWORD dwCount );

BOOL ShowResMessage( FILE* fp, UINT uID );
BOOL ShowMessage( FILE* fp, LPCWSTR pwszMessage );
BOOL ShowMessageEx( FILE* fp, DWORD dwCount, BOOL bStyle, LPCWSTR pwszFormat, ... );

BOOL GetAsUnicodeString2( LPCSTR pszSource, LPWSTR pwszDestination, DWORD* pdwLength );
BOOL GetAsMultiByteString2( LPCWSTR pwszSource, LPSTR pszDestination, DWORD* pdwLength );

BOOL GetPassword( LPWSTR pwszPassword, DWORD dwMaxPasswordSize );

BOOL MatchPattern( LPWSTR pwszPattern, LPWSTR pwszText );

LPCWSTR ParsePattern( LPCWSTR pwszPattern );
BOOL MatchPatternEx( LPCWSTR pwszText, LPCWSTR pwszPattern, DWORD dwFlags );

BOOL FreeMemory( LPVOID* ppv );
BOOL CheckMemory( LPVOID pv );
LPVOID AllocateMemory( DWORD dwBytes );
BOOL ReallocateMemory( LPVOID* ppv, DWORD dwBytesNew );
LONG GetBufferSize( LPVOID pv );

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                      REMOTE CONNECTIVITY                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

//
// error codes
//
#define E_LOCAL_CREDENTIALS             0xA0010001              // 1010 0000 0000 0001 0000 0000 0000 0001
#define I_NO_CLOSE_CONNECTION           0x50010001              // 0101 0000 0000 0001 0000 0000 0000 0001

//
// structs
//
typedef struct tagConnectionInfo
{
    DWORD dwFlags;                                  // flags
    LPCTSTR pszServer;                              // server name
    LPTSTR pszUserName;                             // user name
    DWORD dwUserLength;                             // max. no. of characters allowed for user name
    LPTSTR pszPassword;                             // password
    DWORD dwPasswordLength;                         // max. no. of characters allowed for password
    LPCTSTR pszShare;                               // tells the custom share name
    LPVOID lpReserved1;                             // reserved for future use
    LPVOID lpReserved2;                             // reserved for future use
    LPVOID lpReserved3;                             // reserved for future use
} TCONNECTIONINFO, *PTCONNECTIONINFO;

//
// connection info flags
//

// general flags
#define CI_ACCEPT_PASSWORD              0x00000001                      // 0000 0001

// share (if nothing specified, default will be assumed as IPC$ )
#define CI_SHARE_IPC                    0x00000010                      // 0000 0000 0001 XXXX XXXX
#define CI_SHARE_ADMIN                  0x00000020                      // 0000 0000 0010 XXXX XXXX
#define CI_SHARE_CUSTOM                 0x00000040                      // 0000 0001 0000 XXXX XXXX

// extra flag used while closing connection
#define CI_CLOSE_BY_FORCE               0x10000000

//
// function prototypes
//

BOOL IsUserAdmin();
BOOL IsUNCFormat( LPCWSTR pwszServer );
BOOL IsLocalSystem( LPCWSTR pwszServer );
BOOL IsValidServer( LPCWSTR pwszServer );
BOOL IsValidIPAddress( LPCWSTR pwszAddress );

BOOL GetHostByIPAddr( LPCWSTR pwszServer,
                      LPWSTR pwszHostName,
                      DWORD* pdwHostNameLength, BOOL bNeedFQDN );

DWORD GetTargetVersion( LPCWSTR pwszServer );

DWORD ConnectServer( LPCWSTR pwszServer, LPCWSTR pwszUser, LPCWSTR pwszPassword );
DWORD ConnectServer2( LPCWSTR pwszServer, LPCWSTR pwszUser,
                      LPCWSTR pwszPassword, LPCWSTR pwszShare );

DWORD CloseConnection( LPCWSTR pwszServer );
DWORD CloseConnection2( LPCWSTR pwszServer, LPCWSTR pwszShare, DWORD dwFlags );

BOOL EstablishConnectionEx( PTCONNECTIONINFO pci );
BOOL EstablishConnection( LPCWSTR pwszServer,
                          LPWSTR pwszUserName, DWORD dwUserLength,
                          LPWSTR pwszPassword, DWORD dwPasswordLength, BOOL bNeedPassword );


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                 MULTI-DIMENSIONAL MULTI-TYPE DYNAMIC ARRAYS               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

//
// constants / defines / enumerations
//

// item types supported by dynamic array
#define DA_TYPE_NONE                    0x00000000
#define DA_TYPE_GENERAL                 0x00010000
#define DA_TYPE_STRING                  0x00020000
#define DA_TYPE_LONG                    0x00030000
#define DA_TYPE_DWORD                   0x00040000
#define DA_TYPE_BOOL                    0x00050000
#define DA_TYPE_FLOAT                   0x00060000
#define DA_TYPE_DOUBLE                  0x00070000
#define DA_TYPE_ARRAY                   0x00080000
#define DA_TYPE_HANDLE                  0x00090000
#define DA_TYPE_SYSTEMTIME              0x000A0000
#define DA_TYPE_FILETIME                0x000B0000

//
// type definitions
//
typedef VOID* TARRAY;
typedef TARRAY* PTARRAY;

//
// public function prototypes
//

//
// array pointer validation function(s)
BOOL IsValidArray( TARRAY pArray );

//
// dynamic array creation / destraction functions
TARRAY CreateDynamicArray();
VOID DestroyDynamicArray( PTARRAY pArray );

//
// general helper function(s)
DWORD DynArrayGetCount( TARRAY pArray );
DWORD DynArrayGetCount2( TARRAY pArray, DWORD dwRow );
DWORD DynArrayGetItemType( TARRAY pArray, DWORD dwIndex );
DWORD DynArrayGetItemType2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );

//
// adding columns
LONG DynArrayAddColumns( TARRAY pArray, DWORD dwColumns );
LONG DynArrayInsertColumns( TARRAY pArray, DWORD dwIndex, DWORD dwColumns );

//
// array append function(s) ( for one-dimensional array )
LONG DynArrayAppend( TARRAY pArray, LPVOID pValue );
LONG DynArrayAppendLong( TARRAY pArray, LONG lValue );
LONG DynArrayAppendBOOL( TARRAY pArray, BOOL bValue );
LONG DynArrayAppendDWORD( TARRAY pArray, DWORD dwValue );
LONG DynArrayAppendFloat( TARRAY pArray, float dwValue );
LONG DynArrayAppendDouble( TARRAY pArray, double dwValue );
LONG DynArrayAppendString( TARRAY pArray, LPCTSTR szValue, DWORD dwLength );
LONG DynArrayAppendHandle( TARRAY pArray, HANDLE hValue );
LONG DynArrayAppendSystemTime( TARRAY pArray, SYSTEMTIME stValue );
LONG DynArrayAppendFileTime( TARRAY pArray, FILETIME ftValue );

// helper to append 2-dimensional array
LONG DynArrayAppendRow( TARRAY pArray, DWORD dwColumns );

//  ( for two-dimensional array )
LONG DynArrayAppend2( TARRAY pArray, DWORD dwRow, LPVOID pValue );
LONG DynArrayAppendLong2( TARRAY pArray, DWORD dwRow, LONG lValue );
LONG DynArrayAppendBOOL2( TARRAY pArray, DWORD dwRow, BOOL bValue );
LONG DynArrayAppendDWORD2( TARRAY pArray, DWORD dwRow, DWORD dwValue );
LONG DynArrayAppendFloat2( TARRAY pArray, DWORD dwRow, float dwValue );
LONG DynArrayAppendDouble2( TARRAY pArray, DWORD dwRow, double dwValue );
LONG DynArrayAppendString2( TARRAY pArray, DWORD dwRow, LPCTSTR szValue, DWORD dwLength );
LONG DynArrayAppendHandle2( TARRAY pArray, DWORD dwRow, HANDLE hValue );
LONG DynArrayAppendSystemTime2( TARRAY pArray, DWORD dwRow, SYSTEMTIME stValue );
LONG DynArrayAppendFileTime2( TARRAY pArray, DWORD dwRow, FILETIME ftValue );

//
// array insert function(s) ( for one-dimensional array )
LONG DynArrayInsert( TARRAY pArray, DWORD dwIndex, LPVOID pValue );
LONG DynArrayInsertLong( TARRAY pArray, DWORD dwIndex, LONG lValue );
LONG DynArrayInsertBOOL( TARRAY pArray, DWORD dwIndex, BOOL bValue );
LONG DynArrayInsertDWORD( TARRAY pArray, DWORD dwIndex, DWORD dwValue );
LONG DynArrayInsertFloat( TARRAY pArray, DWORD dwIndex, float dwValue );
LONG DynArrayInsertDouble( TARRAY pArray, DWORD dwIndex, double dwValue );
LONG DynArrayInsertString( TARRAY pArray, DWORD dwIndex, LPCTSTR szValue, DWORD dwLength );
LONG DynArrayInsertHandle( TARRAY pArray, DWORD dwIndex, HANDLE hValue );
LONG DynArrayInsertSystemTime( TARRAY pArray, DWORD dwIndex, SYSTEMTIME stValue );
LONG DynArrayInsertFileTime( TARRAY pArray, DWORD dwIndex, FILETIME ftValue );

// helper to insert 2-dimensional array
LONG DynArrayInsertRow( TARRAY pArray, DWORD dwIndex, DWORD dwColumns );

// ( for two-dimensional array )
LONG DynArrayInsert2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, LPVOID pValue );
LONG DynArrayInsertLong2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, LONG lValue );
LONG DynArrayInsertBOOL2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, BOOL bValue );
LONG DynArrayInsertDWORD2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, DWORD dwValue );
LONG DynArrayInsertFloat2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, float dwValue );
LONG DynArrayInsertDouble2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, double dwValue );
LONG DynArrayInsertString2( TARRAY pArray, DWORD dwRow,
                                                    DWORD dwColIndex, LPCTSTR szValue, DWORD dwLength );
LONG DynArrayInsertHandle2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, HANDLE hValue );
LONG DynArrayInsertSystemTime2( TARRAY pArray, DWORD dwRow,
                                                         DWORD dwColIndex, SYSTEMTIME stValue );
LONG DynArrayInsertFileTime2( TARRAY pArray, DWORD dwRow,
                                                          DWORD dwColIndex, FILETIME ftValue );

//
// item value set function(s) ( for one-dimensional array )
BOOL DynArraySet( TARRAY pArray, DWORD dwIndex, LPVOID pValue );
BOOL DynArraySetLong( TARRAY pArray, DWORD dwIndex, LONG lValue );
BOOL DynArraySetBOOL( TARRAY pArray, DWORD dwIndex, BOOL bValue );
BOOL DynArraySetDWORD( TARRAY pArray, DWORD dwIndex, DWORD dwValue );
BOOL DynArraySetFloat( TARRAY pArray, DWORD dwIndex, float dwValue );
BOOL DynArraySetDouble( TARRAY pArray, DWORD dwIndex, double dwValue );
BOOL DynArraySetString( TARRAY pArray, DWORD dwIndex, LPCTSTR szValue, DWORD dwLength );
BOOL DynArraySetHandle( TARRAY pArray, DWORD dwIndex, HANDLE hValue );
BOOL DynArraySetSystemTime( TARRAY pArray, DWORD dwIndex, SYSTEMTIME stValue );
BOOL DynArraySetFileTime( TARRAY pArray, DWORD dwIndex, FILETIME ftValue );

// ( for two-dimensional array )
BOOL DynArraySet2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, LPVOID pValue );
BOOL DynArraySetLong2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, LONG lValue );
BOOL DynArraySetBOOL2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, BOOL bValue );
BOOL DynArraySetDWORD2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, DWORD dwValue );
BOOL DynArraySetFloat2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, float dwValue );
BOOL DynArraySetDouble2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, double dwValue );
BOOL DynArraySetString2( TARRAY pArray, DWORD dwRow,
                         DWORD dwColumn, LPCTSTR szValue, DWORD dwLength );
BOOL DynArraySetHandle2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, HANDLE hValue );
BOOL DynArraySetSystemTime2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, SYSTEMTIME stValue );
BOOL DynArraySetFileTime2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, FILETIME ftValue );

//
// item value get function(s) ( for one-dimensional array )
LPVOID DynArrayItem( TARRAY pArray, DWORD dwIndex );
LONG DynArrayItemAsLong( TARRAY pArray, DWORD dwIndex );
BOOL DynArrayItemAsBOOL( TARRAY pArray, DWORD dwIndex );
DWORD DynArrayItemAsDWORD( TARRAY pArray, DWORD dwIndex );
float DynArrayItemAsFloat( TARRAY pArray, DWORD dwIndex );
double DynArrayItemAsDouble( TARRAY pArray, DWORD dwIndex );
LPCTSTR DynArrayItemAsString( TARRAY pArray, DWORD dwIndex );
HANDLE DynArrayItemAsHandle( TARRAY pArrray, DWORD dwIndex );
SYSTEMTIME DynArrayItemAsSystemTime( TARRAY pArray, DWORD dwIndex );
FILETIME DynArrayItemAsFileTime( TARRAY pArray, DWORD dwIndex );
DWORD DynArrayItemAsStringEx( TARRAY pArray, DWORD dwIndex, LPTSTR szBuffer, DWORD dwLength );

// ( for two-dimensional array )
LPVOID DynArrayItem2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
LONG DynArrayItemAsLong2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
BOOL DynArrayItemAsBOOL2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
DWORD DynArrayItemAsDWORD2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
float DynArrayItemAsFloat2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
double DynArrayItemAsDouble2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
LPCTSTR DynArrayItemAsString2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
HANDLE DynArrayItemAsHandle2( TARRAY pArrray, DWORD dwRow, DWORD dwColumn );
SYSTEMTIME DynArrayItemAsSystemTime2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
FILETIME DynArrayItemAsFileTime2( TARRAY pArray, DWORD dwRow, DWORD dwColumn );
DWORD DynArrayItemAsStringEx2( TARRAY pArray,
                               DWORD dwRow, DWORD dwColumn, LPTSTR szBuffer, DWORD dwLength );

//
// array item removal function(s) ( for one-dimensional array )
VOID DynArrayRemoveAll( TARRAY pArray );
BOOL DynArrayRemove( TARRAY pArray, DWORD dwIndex );

// ( for two-dimensional array )
BOOL DynArrayRemoveColumn( TARRAY pArray, DWORD dwRow, DWORD dwColumn );

//
// find value function(s) ( for one-dimensional array )
LONG DynArrayFindLong( TARRAY pArray, LONG lValue );
LONG DynArrayFindDWORD( TARRAY pArray, DWORD dwValue );
LONG DynArrayFindString( TARRAY pArray, LPCTSTR szValue, BOOL bIgnoreCase, DWORD dwCount );
LONG DynArrayFindFloat( TARRAY pArray, float fValue );
LONG DynArrayFindDouble( TARRAY pArray, double dblValue );
LONG DynArrayFindHandle( TARRAY pArray, HANDLE hValue );
LONG DynArrayFindSystemTime( TARRAY pArray, SYSTEMTIME stValue );
LONG DynArrayFindFileTime( TARRAY pArray, FILETIME ftValue );

// ( for two-dimensional array )
LONG DynArrayFindLong2( TARRAY pArray, DWORD dwRow, LONG lValue );
LONG DynArrayFindDWORD2( TARRAY pArray, DWORD dwRow, DWORD dwValue );
LONG DynArrayFindString2( TARRAY pArray, DWORD dwRow,
                          LPCTSTR szValue, BOOL bIgnoreCase, DWORD dwCount );
LONG DynArrayFindFloat2( TARRAY pArray, DWORD dwRow, float fValue );
LONG DynArrayFindDouble2( TARRAY pArray, DWORD dwRow, double dblValue );
LONG DynArrayFindHandle2( TARRAY pArray, DWORD dwRow, HANDLE hValue );
LONG DynArrayFindSystemTime2( TARRAY pArray, DWORD dwRow, SYSTEMTIME stValue );
LONG DynArrayFindFileTime2( TARRAY pArray, DWORD dwRow, FILETIME ftValue );

// ( for two-dimensional array ... column wise searching )
LONG DynArrayFindLongEx( TARRAY pArray, DWORD dwColumn, LONG lValue );
LONG DynArrayFindDWORDEx( TARRAY pArray, DWORD dwColumn, DWORD dwValue );
LONG DynArrayFindStringEx( TARRAY pArray, DWORD dwColumn,
                           LPCTSTR szValue, BOOL bIgnoreCase, DWORD dwCount );
LONG DynArrayFindFloatEx( TARRAY pArray, DWORD dwColumn, float fValue );
LONG DynArrayFindDoubleEx( TARRAY pArray, DWORD dwColumn, double dblValue );
LONG DynArrayFindHandleEx( TARRAY pArray, DWORD dwColumn, HANDLE hValue );
LONG DynArrayFindSystemTimeEx( TARRAY pArray, DWORD dwColumn, SYSTEMTIME ftValue );
LONG DynArrayFindFileTimeEx( TARRAY pArray, DWORD dwColumn, FILETIME ftValue );

//
// array attachment helpers ( one-dimensional )
LONG DynArrayAppendEx( TARRAY pArray, TARRAY pArrItem );
LONG DynArrayInsertEx( TARRAY pArray, DWORD dwIndex, TARRAY pArrItem );
BOOL DynArraySetEx( TARRAY pArray, DWORD dwIndex, TARRAY pArrItem );

// ( for two-dimensional array )
LONG DynArrayAppendEx2( TARRAY pArray, DWORD dwRow, TARRAY pArrItem );
LONG DynArrayInsertEx2( TARRAY pArray, DWORD dwRow, DWORD dwColIndex, TARRAY pArrItem );
BOOL DynArraySetEx2( TARRAY pArray, DWORD dwRow, DWORD dwColumn, TARRAY pArrItem );


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                            COMMONAND LINE PARSING                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

//
//  constants / definitions / enumerations
//

// type ( dwType )
#define CP_TYPE_TEXT                    0x00000001              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 0001
#define CP_TYPE_NUMERIC                 0x00000002              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 0010
#define CP_TYPE_UNUMERIC                0x00000003              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 0011
#define CP_TYPE_DATE                    0x00000004              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 0100
#define CP_TYPE_TIME                    0x00000005              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 0101
#define CP_TYPE_DATETIME                0x00000006              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 0110
#define CP_TYPE_FLOAT                   0x00000007              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 0111
#define CP_TYPE_DOUBLE                  0x00000008              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 1000
#define CP_TYPE_CUSTOM                  0x00000009              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 1001
#define CP_TYPE_BOOLEAN                 0x0000000A              // XXXX XXXX XXXX XXXX XXXX XXXX 0000 1010
#define CP_TYPE_MASK                    0x000000FF              // XXXX XXXX XXXX XXXX XXXX XXXX 1111 1111

//
// version 1
//

#define CP_MODE_ARRAY                   0x00000100              // 0001 XXXX XXXX
#define CP_MODE_VALUES                  0x00000200              // 0010 XXXX XXXX
#define CP_MODE_MASK                    0x00000F00              // 1111 XXXX XXXX

#define CP_VALUE_OPTIONAL               0x00001000              // 0001 XXXX XXXX XXXX
#define CP_VALUE_MANDATORY              0x00002000              // 0010 XXXX XXXX XXXX
#define CP_VALUE_NODUPLICATES           0x00004000              // 0100 XXXX XXXX XXXX
#define CP_VALUE_NOLENGTHCHECK          0x00008000              // 1000 XXXX XXXX XXXX
#define CP_VALUE_MASK                   0x0000F000              // 1111 XXXX XXXX XXXX

#define CP_MAIN_OPTION                  0x00010000              // 0000 0000 0001 XXXX XXXX XXXX XXXX
#define CP_USAGE                        0x00020000              // 0000 0000 0010 XXXX XXXX XXXX XXXX
#define CP_DEFAULT                      0x00040000              // 0000 0000 0100 XXXX XXXX XXXX XXXX
#define CP_MANDATORY                    0x00080000              // 0000 0000 1000 XXXX XXXX XXXX XXXX
#define CP_CASESENSITIVE                0x00100000              // 0000 0001 0000 XXXX XXXX XXXX XXXX
#define CP_IGNOREVALUE                  0x00200000              // 0000 0010 0000 XXXX XXXX XXXX XXXX
#define CP_MASK                         0x0FFF0000              // 1111 1111 1111 XXXX XXXX XXXX XXXX

//
// version 2
//

#define CP2_MODE_ARRAY                  0x00000001              // XXXX XXXX XXXX XXXX XXXX XXXX XXXX 0001
#define CP2_MODE_VALUES                 0x00000002              // XXXX XXXX XXXX XXXX XXXX XXXX XXXX 0010
#define CP2_MODE_MASK                   0x0000000F              // XXXX XXXX XXXX XXXX XXXX XXXX XXXX 1111

#define CP2_VALUE_OPTIONAL              0x00000010              // XXXX XXXX XXXX XXXX 0000 0000 0001 XXXX
#define CP2_VALUE_NODUPLICATES          0x00000020              // XXXX XXXX XXXX XXXX 0000 0000 0010 XXXX
#define CP2_VALUE_TRIMINPUT             0x00000040              // XXXX XXXX XXXX XXXX 0000 0000 0100 XXXX
#define CP2_VALUE_NONULL                0x00000080              // XXXX XXXX XXXX XXXX 0000 0000 1000 XXXX
#define CP2_VALUE_MASK                  0x0000FFF0              // XXXX XXXX XXXX XXXX 1111 1111 1111 XXXX

#define CP2_ALLOCMEMORY                 0x00010000              // XXXX 0000 0000 0001 XXXX XXXX XXXX XXXX
#define CP2_USAGE                       0x00020000              // XXXX 0000 0000 0010 XXXX XXXX XXXX XXXX
#define CP2_DEFAULT                     0x00040000              // XXXX 0000 0000 0100 XXXX XXXX XXXX XXXX
#define CP2_MANDATORY                   0x00080000              // XXXX 0000 0000 1000 XXXX XXXX XXXX XXXX
#define CP2_CASESENSITIVE               0x00100000              // XXXX 0000 0001 0000 XXXX XXXX XXXX XXXX
#define CP2_MASK                        0x0FFF0000              // XXXX 1111 1111 1111 XXXX XXXX XXXX XXXX

//
// user defined types
//
typedef TCHAR OPTION[ 256 ];
typedef TCHAR OPTVALUE[ 256 ];

// custom value validation routine prototype
typedef BOOL ( *PARSERFUNC )( LPCWSTR pwszOption, LPCWSTR pwszValue, LPVOID pData );
typedef BOOL ( *PARSERFUNC2 )( LPCWSTR pwszOption, LPCWSTR pwszValue, LPVOID pData, DWORD* pdwIncrement );

// command line parser -- version 1
typedef struct __tagCmdParser
{
    OPTION szOption;                // options
    DWORD dwFlags;                  // flags ( specifies the type etc )
    DWORD dwCount;                  // tells the no. of times the option can repeat
    DWORD dwActuals;                // no. of times the option actually repeated
    LPVOID pValue;                  // pointer to the option value
    OPTVALUE szValues;              // to hold valid value in case flag = CP_MODE_VALUES
    PARSERFUNC pFunction;           // pointer to custom value validation function
    LPVOID pFunctionData;           // extra data that will be passed to custom function
} TCMDPARSER;

typedef TCMDPARSER* PTCMDPARSER;

extern const CHAR cszParserSignature[ 8 ];

// command line parser version 2
typedef struct __tagCmdParser2
{
    CHAR szSignature[ 8 ];          // should always be "PARSER2\0"

    DWORD dwType;                   // type of the argument
    DWORD64 dwFlags;                // flags

    DWORD dwCount;                  // tells the no. of times the option can repeat
    DWORD dwActuals;                // no. of times the option actually repeated

    LPCWSTR pwszOptions;            // options
    LPCWSTR pwszFriendlyName;       // specifies friendly name for the option
    LPCWSTR pwszValues;             // to hold valid value in case flag = CP_MODE_VALUES
                                    // format that can be used for this
                                    // CP_TYPE_TEXT         apple|orange|banana
                                    // ********************************************
                                    // CP_TYPE_NUMERIC      1,100;105;200,256;1000,
                                    // CP_TYPE_UNUMERIC     (this example tells
                                    //                       argument can be any
                                    //                       number from 1 to 100
                                    //                       or 105 or 200 or
                                    //                       256 or any value
                                    //                       greater than or
                                    //                       equal to 1000

    LPVOID pValue;                  // pointer to the option value
    DWORD dwLength;                 // max. length of argument value that can be stored
                                    // valid only for CP_TYPE_TEXT

    PARSERFUNC2 pFunction;          // pointer to custom value validation function
    LPVOID pFunctionData;           // extra data that will be passed to custom function

    DWORD dwReserved;               // reserver for future use
    LPVOID pReserved1;              // reserved for future use
    LPVOID pReserved2;              // reserved for future use
    LPVOID pReserved3;              // reserved for future use

} TCMDPARSER2;

typedef TCMDPARSER2* PTCMDPARSER2;

BOOL DoParseParam2( DWORD dwCount,
                    LPCWSTR argv[],
                    LONG lSubOptionIndex,
                    DWORD dwOptionsCount,
                    PTCMDPARSER2 pcmdOptions,
                    DWORD dwReserved );

//
// public function prototypes
//
LONG GetOptionCount( LPCTSTR szOption,
                     DWORD dwCount, PTCMDPARSER pcmdOptions );
BOOL DoParseParam( DWORD dwCount,
                   LPCTSTR argv[],
                   DWORD dwOptionsCount,
                   PTCMDPARSER pcmdOptions );

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                        VALIDATING AND FILTERING RESULTS                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

//
//  constants / definitions / enumerations
//

// types
#define F_TYPE_TEXT                             0x00000001              // 0000 0000 0001
#define F_TYPE_NUMERIC                  0x00000002              // 0000 0000 0010
#define F_TYPE_UNUMERIC                 0x00000003              // 0000 0000 0011
#define F_TYPE_DATE                             0x00000004              // 0000 0000 0100
#define F_TYPE_TIME                             0x00000005              // 0000 0000 0101
#define F_TYPE_DATETIME                 0x00000006              // 0000 0000 0110
#define F_TYPE_FLOAT                    0x00000007              // 0000 0000 0111
#define F_TYPE_DOUBLE                   0x00000008              // 0000 0000 1000
#define F_TYPE_CUSTOM                   0x00000009              // 0000 0000 1001
#define F_TYPE_MASK                             0x00000FFF              // 1111 1111 1111

// modes
#define F_MODE_VALUES                   0x00001000              // 0001 XXXX XXXX XXXX
#define F_MODE_PATTERN                  0x00002000              // 0010 XXXX XXXX XXXX
#define F_MODE_ARRAY                    0x00004000              // 0100 XXXX XXXX XXXX

// custom filter data validation result
#define F_FILTER_INVALID                0x00000000
#define F_FILTER_VALID                  0x00000001
#define F_RESULT_KEEP                   0x000000FF
#define F_RESULT_REMOVE                 0x00000000

//
// Bit no. 2 is '='
// Bit no. 3 is '<'
// Bit no. 4 is '>'
//
//              7654 3210
// EQ   0000 0010               0x02
// NE   1111 XX0X               0xFD
// LT   0000 0100               0x04
// GT   0000 1000               0x08
// LE   0000 0110               0x06
// GE   0000 1010               0x0A
//
#define MASK_EQ         0x00000002
#define MASK_NE         0x000000FC
#define MASK_LT         0x00000004
#define MASK_GT         0x00000008
#define MASK_LE         0x00000006
#define MASK_GE         0x0000000A
#define MASK_ALL        0x000000FF

// mathematical operators
#define MATH_EQ         _T( "=" )
#define MATH_NE         _T( "!=" )
#define MATH_LT         _T( "<" )
#define MATH_GT         _T( ">" )
#define MATH_LE         _T( "<=" )
#define MATH_GE         _T( ">=" )

// parsed filters information
#define F_PARSED_INDEX_FILTER                   0
#define F_PARSED_INDEX_PROPERTY                 1
#define F_PARSED_INDEX_OPERATOR                 2
#define F_PARSED_INDEX_VALUE                    3

#define F_PARSED_INFO_COUNT                             4

//
// structures / user defined data types
//
typedef TCHAR OPERATORS[ 101 ];
typedef TCHAR FILTERVALUES[ 256 ];
typedef TCHAR FILTERPROPERTY[ 256 ];

// custom value validation routine prototype
typedef DWORD ( *FILTERFUNC )( LPCTSTR pszProperty, LPCTSTR pszOperator,
                                                           LPCTSTR pszValue, LPVOID pData, TARRAY arrRow );

typedef struct __tagFilterConfig
{
        DWORD dwColumn;                         // mapping from filter to column in data
        FILTERPROPERTY szProperty;      // filter property
        OPERATORS szOperators;          // valid operators for the filter
        DWORD dwFlags;                          // flags ( specifies the valid type for the filter )
        FILTERVALUES szValues;          // to hold valid value in case flag = F_MODE_VALUES
        FILTERFUNC pFunction;           // pointer to custom value validation function
        LPVOID pFunctionData;           // extra data that will be passed to custom function
} TFILTERCONFIG;

typedef TFILTERCONFIG *PTFILTERCONFIG;

//
// public function prototypes
//
LPCTSTR FindOperator( LPCTSTR szOperator );
BOOL ParseAndValidateFilter( DWORD dwCount,
                                                         PTFILTERCONFIG pfilterConfigs,
                                                         TARRAY arrFiltersArgs, PTARRAY parrParsedFilters );
BOOL CanFilterRecord( DWORD dwCount,
                                      TFILTERCONFIG filterConfigs[],
                                      TARRAY arrRecord, TARRAY arrParsedFilters );
DWORD FilterResults( DWORD dwCount,
                                         TFILTERCONFIG arrFilters[],
                                     TARRAY arrData, TARRAY arrParsedFilters );

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                               DISPLAYING RESULTS                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

//
//  constants / definitions / enumerations
//

// formats
#define SR_FORMAT_LIST                          0x00000001              // 0000 0001
#define SR_FORMAT_TABLE                         0x00000002              // 0000 0010
#define SR_FORMAT_CSV                           0x00000003              // 0000 0011
#define SR_FORMAT_MASK                          0x0000000F              // 1111 1111

// column types
#define SR_TYPE_NONE                            0x00000000              // 0000 0000 0000 0000 XXXX XXXX
#define SR_TYPE_STRING                          0x00000010              // 0000 0000 0000 0001 XXXX XXXX
#define SR_TYPE_NUMERIC                         0x00000020              // 0000 0000 0000 0010 XXXX XXXX
#define SR_TYPE_FLOAT                           0x00000030              // 0000 0000 0000 0011 XXXX XXXX
#define SR_TYPE_DOUBLE                          0x00000040              // 0000 0000 0000 0100 XXXX XXXX
#define SR_TYPE_DATE                            0x00000050              // 0000 0000 0000 0101 XXXX XXXX
#define SR_TYPE_TIME                            0x00000060              // 0000 0000 0000 0110 XXXX XXXX
#define SR_TYPE_DATETIME                        0x00000070              // 0000 0000 0000 0111 XXXX XXXX
#define SR_TYPE_CUSTOM                          0x00000080              // 0000 0000 0000 1000 XXXX XXXX
#define SR_TYPE_MASK                            0x00000FF0              // 1111 1111 1111 1111 XXXX XXXX

// flags ( global level )
#define SR_NOHEADER                             0x00001000              // 0000 0001 XXXX XXXX XXXX XXXX XXXX XXXX

// flags ( column level )
#define SR_HIDECOLUMN                           0x00001000              // 0000 0000 0001 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_VALUEFORMAT                          0x00002000              // 0000 0000 0010 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_ARRAY                                0x00004000              // 0000 0000 0100 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_WORDWRAP                             0x00008000              // 0000 0000 1000 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_ALIGN_LEFT                           0x00010000              // 0000 0001 0000 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_ALIGN_RIGHT                          0x00020000              // 0000 0010 0000 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_ALIGN_CENTER                         0x00040000              // 0000 0100 0000 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_NO_TRUNCATION                        0x00088000              // 0000 1000 1000 XXXX XXXX XXXX XXXX XXXX XXXX
#define SR_SHOW_NA_WHEN_BLANK                   0x00100000              // 0001 0000 0000 XXXX XXXX XXXX XXXX XXXX XXXX

//
// user defined types
//

// custom value formatter
typedef TCHAR COLHEADER[ 256 ];
typedef TCHAR COLFORMAT[ 65 ];
typedef VOID ( *FORMATFUNC )( DWORD dwColumn, TARRAY arrData, LPVOID pData, LPTSTR szValue );

typedef struct __tagColumns
{
        COLHEADER szColumn;                             // column header name
        DWORD dwWidth;                                  // width of each field
        DWORD dwFlags;                                  // flags ( specifies the type etc )
        COLFORMAT szFormat;                             // custom format
        FORMATFUNC pFunction;                   // formatter function
        LPVOID pFunctionData;                   // function data
} TCOLUMNS;

typedef TCOLUMNS* PTCOLUMNS;

//
// public functions
//
VOID ShowResults( DWORD dwColumns, PTCOLUMNS pColumns, DWORD dwFlags, TARRAY arrData );

///////////////////////////////////////////////////////////////////////////////////
//                    COMING UP *** DO NOT USE UNLESS INTIMATED                  //
///////////////////////////////////////////////////////////////////////////////////
VOID ShowResults2( FILE* fp, DWORD dwColumns, PTCOLUMNS pColumns, DWORD dwFlags, TARRAY arrData );
///////////////////////////////////////////////////////////////////////////////////

#ifdef __cplusplus
}
#endif

#endif  // __CMDLINE_H