Headers diff for pdh.dll between 5.2.3790.3959-Windows 5.0 and 6.0.6002.18005-Windows 6.0 versions

pdh.h (5.2.3790.3959-Windows 5.0)		pdh.h (6.0.6002.18005-Windows 6.0)
/*++		/*++


Copyright (C) 1996-1999 Microsoft Corporation		Copyright (c) Microsoft Corporation. All rights reserved.

Module Name:		Module Name:

PDH.H		PDH.H

Abstract:		Abstract:

Header file for the Performance Data Helper (PDH) DLL functions.		Header file for the Performance Data Helper (PDH) DLL functions.

--*/		--*/

skipping to change at line 53		skipping to change at line 53
// v1.3 of the PDH -- adds log service control & stubs for NT5/PDH v2 fn's		// v1.3 of the PDH -- adds log service control & stubs for NT5/PDH v2 fn's
// v2.0 of the PDH -- is the NT v 5.0 B2 version		// v2.0 of the PDH -- is the NT v 5.0 B2 version
#define PDH_VERSION ((DWORD)((PDH_CVERSION_WIN50) + 0x0003))		#define PDH_VERSION ((DWORD)((PDH_CVERSION_WIN50) + 0x0003))

// define severity masks		// define severity masks
#define IsSuccessSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0x00000000L) ? TRUE : FALSE)		#define IsSuccessSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0x00000000L) ? TRUE : FALSE)
#define IsInformationalSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0x40000000L) ? TRUE : FALSE)		#define IsInformationalSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0x40000000L) ? TRUE : FALSE)
#define IsWarningSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0x80000000L) ? TRUE : FALSE)		#define IsWarningSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0x80000000L) ? TRUE : FALSE)
#define IsErrorSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0xC0000000L) ? TRUE : FALSE)		#define IsErrorSeverity(ErrorCode) ((((DWORD)(ErrorCode) & (0xC0000000L) ) == 0xC0000000L) ? TRUE : FALSE)


		#if (_WIN32_WINDOWS >= 0x0501 \|\| _WIN32_WINNT >= 0x0501 \|\| (defined(NTDDI_VERSIO N) && NTDDI_VERSION >= NTDDI_WINXP))
#define MAX_COUNTER_PATH 256 // Maximum counter path length. This is an o bsolute constance.		#define MAX_COUNTER_PATH 256 // Maximum counter path length. This is an o bsolute constance.


		#if (_WIN32_WINDOWS >= 0x0502 \|\| _WIN32_WINNT >= 0x0502 \|\| (defined(NTDDI_VERSIO N) && NTDDI_VERSION >= NTDDI_WIN2003))
#define PDH_MAX_COUNTER_NAME 1024 // Maximum counter name length.		#define PDH_MAX_COUNTER_NAME 1024 // Maximum counter name length.
#define PDH_MAX_INSTANCE_NAME 1024 // Maximum counter instance name length.		#define PDH_MAX_INSTANCE_NAME 1024 // Maximum counter instance name length.
#define PDH_MAX_COUNTER_PATH 2048 // Maximum full counter path length.		#define PDH_MAX_COUNTER_PATH 2048 // Maximum full counter path length.
#define PDH_MAX_DATASOURCE_PATH 1024 // MAximum full counter log name length.		#define PDH_MAX_DATASOURCE_PATH 1024 // MAximum full counter log name length.

		#endif

		#define PDH_OBJECT_HAS_INSTANCES ((DWORD) 0x00000001)
		#endif

// data type definitions		// data type definitions

typedef HANDLE PDH_HCOUNTER;		typedef HANDLE PDH_HCOUNTER;
typedef HANDLE PDH_HQUERY;		typedef HANDLE PDH_HQUERY;
typedef HANDLE PDH_HLOG;		typedef HANDLE PDH_HLOG;

typedef PDH_HCOUNTER HCOUNTER;		typedef PDH_HCOUNTER HCOUNTER;
typedef PDH_HQUERY HQUERY;		typedef PDH_HQUERY HQUERY;
#ifndef _LMHLOGDEFINED_		#ifndef _LMHLOGDEFINED_

skipping to change at line 81		skipping to change at line 87

#ifdef INVALID_HANDLE_VALUE		#ifdef INVALID_HANDLE_VALUE
#undef INVALID_HANDLE_VALUE		#undef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE ((HANDLE)((LONG_PTR)-1))		#define INVALID_HANDLE_VALUE ((HANDLE)((LONG_PTR)-1))
#endif		#endif

#define H_REALTIME_DATASOURCE NULL		#define H_REALTIME_DATASOURCE NULL
#define H_WBEM_DATASOURCE INVALID_HANDLE_VALUE		#define H_WBEM_DATASOURCE INVALID_HANDLE_VALUE

typedef struct _PDH_RAW_COUNTER {		typedef struct _PDH_RAW_COUNTER {

DWORD CStatus;		volatile DWORD CStatus;
FILETIME TimeStamp;		FILETIME TimeStamp;
LONGLONG FirstValue;		LONGLONG FirstValue;
LONGLONG SecondValue;		LONGLONG SecondValue;
DWORD MultiCount;		DWORD MultiCount;
} PDH_RAW_COUNTER, * PPDH_RAW_COUNTER;		} PDH_RAW_COUNTER, * PPDH_RAW_COUNTER;

typedef struct _PDH_RAW_COUNTER_ITEM_A {		typedef struct _PDH_RAW_COUNTER_ITEM_A {
LPSTR szName;		LPSTR szName;
PDH_RAW_COUNTER RawValue;		PDH_RAW_COUNTER RawValue;
} PDH_RAW_COUNTER_ITEM_A, * PPDH_RAW_COUNTER_ITEM_A;		} PDH_RAW_COUNTER_ITEM_A, * PPDH_RAW_COUNTER_ITEM_A;

skipping to change at line 304		skipping to change at line 310
//		//
// Time value constants		// Time value constants
//		//
#define MAX_TIME_VALUE ((LONGLONG) 0x7FFFFFFFFFFFFFFF)		#define MAX_TIME_VALUE ((LONGLONG) 0x7FFFFFFFFFFFFFFF)
#define MIN_TIME_VALUE ((LONGLONG) 0)		#define MIN_TIME_VALUE ((LONGLONG) 0)

// function definitions		// function definitions

PDH_FUNCTION		PDH_FUNCTION
PdhGetDllVersion(		PdhGetDllVersion(

IN LPDWORD lpdwVersion		__out_opt LPDWORD lpdwVersion
);		);

//		//
// Query Functions		// Query Functions
//		//

PDH_FUNCTION		PDH_FUNCTION
PdhOpenQueryW(		PdhOpenQueryW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN DWORD_PTR dwUserData,		__in DWORD_PTR dwUserData,
IN PDH_HQUERY * phQuery		__out PDH_HQUERY * phQuery
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhOpenQueryA(		PdhOpenQueryA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN DWORD_PTR dwUserData,		__in DWORD_PTR dwUserData,
IN PDH_HQUERY * phQuery		__out PDH_HQUERY * phQuery
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhAddCounterW(		PdhAddCounterW(

IN PDH_HQUERY hQuery,		__in PDH_HQUERY hQuery,
IN LPCWSTR szFullCounterPath,		__in LPCWSTR szFullCounterPath,
IN DWORD_PTR dwUserData,		__in DWORD_PTR dwUserData,
IN PDH_HCOUNTER * phCounter		__out PDH_HCOUNTER * phCounter
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhAddCounterA(		PdhAddCounterA(

IN PDH_HQUERY hQuery,		__in PDH_HQUERY hQuery,
IN LPCSTR szFullCounterPath,		__in LPCSTR szFullCounterPath,
IN DWORD_PTR dwUserData,		__in DWORD_PTR dwUserData,
IN PDH_HCOUNTER * phCounter		__out PDH_HCOUNTER * phCounter
);		);


		#if (_WIN32_WINDOWS >= 0x0600 \|\| _WIN32_WINNT >= 0x0600 \|\| (defined(NTDDI_VERSIO
		N) && NTDDI_VERSION >= NTDDI_LONGHORN))
		PDH_FUNCTION
		PdhAddEnglishCounterW(
		__in PDH_HQUERY hQuery,
		__in LPCWSTR szFullCounterPath,
		__in DWORD_PTR dwUserData,
		__out PDH_HCOUNTER * phCounter
		);

		PDH_FUNCTION
		PdhAddEnglishCounterA(
		__in PDH_HQUERY hQuery,
		__in LPCSTR szFullCounterPath,
		__in DWORD_PTR dwUserData,
		__out PDH_HCOUNTER * phCounter
		);

		PDH_FUNCTION
		PdhCollectQueryDataWithTime(
		__inout PDH_HQUERY hQuery,
		__out LONGLONG * pllTimeStamp
		);

		PDH_FUNCTION
		PdhValidatePathExW(
		__in_opt PDH_HLOG hDataSource,
		__in LPCWSTR szFullPathBuffer
		);

		PDH_FUNCTION
		PdhValidatePathExA(
		__in_opt PDH_HLOG hDataSource,
		__in LPCSTR szFullPathBuffer
		);
		#endif

PDH_FUNCTION		PDH_FUNCTION
PdhRemoveCounter(		PdhRemoveCounter(

IN PDH_HCOUNTER hCounter		__in PDH_HCOUNTER hCounter
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhCollectQueryData(		PdhCollectQueryData(

IN PDH_HQUERY hQuery		__inout PDH_HQUERY hQuery
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhCloseQuery(		PdhCloseQuery(

IN PDH_HQUERY hQuery		__inout PDH_HQUERY hQuery
);		);

//		//
// Counter Functions		// Counter Functions
//		//

PDH_FUNCTION		PDH_FUNCTION
PdhGetFormattedCounterValue(		PdhGetFormattedCounterValue(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN DWORD dwFormat,		__in DWORD dwFormat,
IN LPDWORD lpdwType,		__out_opt LPDWORD lpdwType,
IN PPDH_FMT_COUNTERVALUE pValue		__out PPDH_FMT_COUNTERVALUE pValue
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetFormattedCounterArrayA(		PdhGetFormattedCounterArrayA(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN DWORD dwFormat,		__in DWORD dwFormat,
IN LPDWORD lpdwBufferSize,		__inout LPDWORD lpdwBufferSize,
IN LPDWORD lpdwItemCount,		__out LPDWORD lpdwItemCount,
IN PPDH_FMT_COUNTERVALUE_ITEM_A ItemBuffer		__out_bcount_opt(* lpdwBufferSize) PPDH_FMT_COUNTERVALUE_ITEM_A ItemBuffer
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetFormattedCounterArrayW(		PdhGetFormattedCounterArrayW(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN DWORD dwFormat,		__in DWORD dwFormat,
IN LPDWORD lpdwBufferSize,		__inout LPDWORD lpdwBufferSize,
IN LPDWORD lpdwItemCount,		__out LPDWORD lpdwItemCount,
IN PPDH_FMT_COUNTERVALUE_ITEM_W ItemBuffer		__out_bcount_opt(* lpdwBufferSize) PPDH_FMT_COUNTERVALUE_ITEM_W ItemBuffer
);		);

// dwFormat flag values		// dwFormat flag values
//		//
#define PDH_FMT_RAW ((DWORD) 0x00000010)		#define PDH_FMT_RAW ((DWORD) 0x00000010)
#define PDH_FMT_ANSI ((DWORD) 0x00000020)		#define PDH_FMT_ANSI ((DWORD) 0x00000020)
#define PDH_FMT_UNICODE ((DWORD) 0x00000040)		#define PDH_FMT_UNICODE ((DWORD) 0x00000040)
#define PDH_FMT_LONG ((DWORD) 0x00000100)		#define PDH_FMT_LONG ((DWORD) 0x00000100)
#define PDH_FMT_DOUBLE ((DWORD) 0x00000200)		#define PDH_FMT_DOUBLE ((DWORD) 0x00000200)
#define PDH_FMT_LARGE ((DWORD) 0x00000400)		#define PDH_FMT_LARGE ((DWORD) 0x00000400)
#define PDH_FMT_NOSCALE ((DWORD) 0x00001000)		#define PDH_FMT_NOSCALE ((DWORD) 0x00001000)
#define PDH_FMT_1000 ((DWORD) 0x00002000)		#define PDH_FMT_1000 ((DWORD) 0x00002000)
#define PDH_FMT_NODATA ((DWORD) 0x00004000)		#define PDH_FMT_NODATA ((DWORD) 0x00004000)
#define PDH_FMT_NOCAP100 ((DWORD) 0x00008000)		#define PDH_FMT_NOCAP100 ((DWORD) 0x00008000)
#define PERF_DETAIL_COSTLY ((DWORD) 0x00010000)		#define PERF_DETAIL_COSTLY ((DWORD) 0x00010000)
#define PERF_DETAIL_STANDARD ((DWORD) 0x0000FFFF)		#define PERF_DETAIL_STANDARD ((DWORD) 0x0000FFFF)

PDH_FUNCTION		PDH_FUNCTION
PdhGetRawCounterValue(		PdhGetRawCounterValue(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN LPDWORD lpdwType,		__out_opt LPDWORD lpdwType,
IN PPDH_RAW_COUNTER pValue		__out PPDH_RAW_COUNTER pValue
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetRawCounterArrayA(		PdhGetRawCounterArrayA(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN LPDWORD lpdwBufferSize,		__inout LPDWORD lpdwBufferSize,
IN LPDWORD lpdwItemCount,		__out LPDWORD lpdwItemCount,
IN PPDH_RAW_COUNTER_ITEM_A ItemBuffer		__out_bcount_opt(* lpdwBufferSize) PPDH_RAW_COUNTER_ITEM_A ItemBuffer
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetRawCounterArrayW(		PdhGetRawCounterArrayW(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN LPDWORD lpdwBufferSize,		__inout LPDWORD lpdwBufferSize,
IN LPDWORD lpdwItemCount,		__out LPDWORD lpdwItemCount,
IN PPDH_RAW_COUNTER_ITEM_W ItemBuffer		__out_bcount_opt(* lpdwBufferSize) PPDH_RAW_COUNTER_ITEM_W ItemBuffer
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhCalculateCounterFromRawValue(		PdhCalculateCounterFromRawValue(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN DWORD dwFormat,		__in DWORD dwFormat,
IN PPDH_RAW_COUNTER rawValue1,		__in PPDH_RAW_COUNTER rawValue1,
IN PPDH_RAW_COUNTER rawValue2,		__in PPDH_RAW_COUNTER rawValue2,
IN PPDH_FMT_COUNTERVALUE fmtValue		__out PPDH_FMT_COUNTERVALUE fmtValue
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhComputeCounterStatistics(		PdhComputeCounterStatistics(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN DWORD dwFormat,		__in DWORD dwFormat,
IN DWORD dwFirstEntry,		__in DWORD dwFirstEntry,
IN DWORD dwNumEntries,		__in DWORD dwNumEntries,
IN PPDH_RAW_COUNTER lpRawValueArray,		__in PPDH_RAW_COUNTER lpRawValueArray,
IN PPDH_STATISTICS data		__out PPDH_STATISTICS data
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetCounterInfoW(		PdhGetCounterInfoW(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN BOOLEAN bRetrieveExplainText,		__in BOOLEAN bRetrieveExplainText,
IN LPDWORD pdwBufferSize,		__inout LPDWORD pdwBufferSize,
IN PPDH_COUNTER_INFO_W lpBuffer		__out_bcount_opt(* pdwBufferSize) PPDH_COUNTER_INFO_W lpBuffer
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetCounterInfoA(		PdhGetCounterInfoA(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN BOOLEAN bRetrieveExplainText,		__in BOOLEAN bRetrieveExplainText,
IN LPDWORD pdwBufferSize,		__inout LPDWORD pdwBufferSize,
IN PPDH_COUNTER_INFO_A lpBuffer		__out_bcount_opt(* pdwBufferSize) PPDH_COUNTER_INFO_A lpBuffer
);		);

#define PDH_MAX_SCALE (7L)		#define PDH_MAX_SCALE (7L)
#define PDH_MIN_SCALE (-7L)		#define PDH_MIN_SCALE (-7L)

PDH_FUNCTION		PDH_FUNCTION
PdhSetCounterScaleFactor(		PdhSetCounterScaleFactor(

IN PDH_HCOUNTER hCounter,		__inout PDH_HCOUNTER hCounter,
IN LONG lFactor		__in LONG lFactor
);		);
//		//
// Browsing and enumeration functions		// Browsing and enumeration functions
//		//
PDH_FUNCTION		PDH_FUNCTION
PdhConnectMachineW(		PdhConnectMachineW(

IN LPCWSTR szMachineName		__in_opt LPCWSTR szMachineName
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhConnectMachineA(		PdhConnectMachineA(

IN LPCSTR szMachineName		__in_opt LPCSTR szMachineName
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumMachinesW(		PdhEnumMachinesW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN LPWSTR mszMachineList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPWSTR mszMachineList
IN LPDWORD pcchBufferSize		,
		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumMachinesA(		PdhEnumMachinesA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN LPSTR mszMachineList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPSTR mszMachineList,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectsW(		PdhEnumObjectsW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPWSTR mszObjectList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPWSTR mszObjectList
IN LPDWORD pcchBufferSize,		,
IN DWORD dwDetailLevel,		__inout LPDWORD pcchBufferSize,
IN BOOL bRefresh		__in DWORD dwDetailLevel,
		__in BOOL bRefresh
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectsA(		PdhEnumObjectsA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPSTR mszObjectList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPSTR mszObjectList
IN LPDWORD pcchBufferSize,		,
IN DWORD dwDetailLevel,		__inout LPDWORD pcchBufferSize,
IN BOOL bRefresh		__in DWORD dwDetailLevel,
		__in BOOL bRefresh
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectItemsW(		PdhEnumObjectItemsW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPCWSTR szObjectName,		__in LPCWSTR szObjectName,
IN LPWSTR mszCounterList,		__out_ecount_opt(* pcchCounterListLength)__nullnullterminated LPWSTR mszCo
IN LPDWORD pcchCounterListLength,		unterList,
IN LPWSTR mszInstanceList,		__inout LPDWORD pcchCounterListLength,
IN LPDWORD pcchInstanceListLength,		__out_ecount_opt(* pcchInstanceListLength)__nullnullterminated LPWSTR mszIn
IN DWORD dwDetailLevel,		stanceList,
IN DWORD dwFlags		__inout LPDWORD pcchInstanceListLength,
		__in DWORD dwDetailLevel,
		__in DWORD dwFlags
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectItemsA(		PdhEnumObjectItemsA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPCSTR szObjectName,		__in LPCSTR szObjectName,
IN LPSTR mszCounterList,		__out_ecount_opt(* pcchCounterListLength)__nullnullterminated LPSTR mszCo
IN LPDWORD pcchCounterListLength,		unterList,
IN LPSTR mszInstanceList,		__inout LPDWORD pcchCounterListLength,
IN LPDWORD pcchInstanceListLength,		__out_ecount_opt(* pcchInstanceListLength)__nullnullterminated LPSTR mszIn
IN DWORD dwDetailLevel,		stanceList,
IN DWORD dwFlags		__inout LPDWORD pcchInstanceListLength,
		__in DWORD dwDetailLevel,
		__in DWORD dwFlags
);		);


#define PDH_OBJECT_HAS_INSTANCES ((DWORD) 0x00000001)

PDH_FUNCTION		PDH_FUNCTION
PdhMakeCounterPathW(		PdhMakeCounterPathW(

IN PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathElements,		__in PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathElements,
IN LPWSTR szFullPathBuffer,		__out_ecount_opt(* pcchBufferSize) LPWSTR szFullPathBuffer,
IN LPDWORD pcchBufferSize,		__inout LPDWORD pcchBufferSize,
IN DWORD dwFlags		__in DWORD dwFlags
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhMakeCounterPathA(		PdhMakeCounterPathA(

IN PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements,		__in PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements,
IN LPSTR szFullPathBuffer,		__out_ecount_opt(* pcchBufferSize) LPSTR szFullPathBuffer,
IN LPDWORD pcchBufferSize,		__inout LPDWORD pcchBufferSize,
IN DWORD dwFlags		__in DWORD dwFlags
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhParseCounterPathW(		PdhParseCounterPathW(

IN LPCWSTR szFullPathBuffer,		__in LPCWSTR szFullPathBuffer,
IN PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathElements,		__out_bcount_opt(* pdwBufferSize) PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathE
IN LPDWORD pdwBufferSize,		lements,
IN DWORD dwFlags		__inout LPDWORD pdwBufferSize,
		__in DWORD dwFlags
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhParseCounterPathA(		PdhParseCounterPathA(

IN LPCSTR szFullPathBuffer,		__in LPCSTR szFullPathBuffer,
IN PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements,		__out_bcount_opt(* pdwBufferSize) PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathE
IN LPDWORD pdwBufferSize,		lements,
IN DWORD dwFlags		__inout LPDWORD pdwBufferSize,
		__in DWORD dwFlags
);		);

#define PDH_PATH_WBEM_RESULT ((DWORD) 0x00000001)		#define PDH_PATH_WBEM_RESULT ((DWORD) 0x00000001)
#define PDH_PATH_WBEM_INPUT ((DWORD) 0x00000002)		#define PDH_PATH_WBEM_INPUT ((DWORD) 0x00000002)

#define PDH_PATH_LANG_FLAGS(LangId, Flags) ((DWORD)(((LangId & 0x0000FFFF) << 1 6) \| (Flags & 0x0000FFFF)))		#define PDH_PATH_LANG_FLAGS(LangId, Flags) ((DWORD)(((LangId & 0x0000FFFF) << 1 6) \| (Flags & 0x0000FFFF)))

PDH_FUNCTION		PDH_FUNCTION
PdhParseInstanceNameW(		PdhParseInstanceNameW(

IN LPCWSTR szInstanceString,		__in LPCWSTR szInstanceString,
IN LPWSTR szInstanceName,		__out_ecount_opt(* pcchInstanceNameLength) LPWSTR szInstanceName,
IN LPDWORD pcchInstanceNameLength,		__inout LPDWORD pcchInstanceNameLength,
IN LPWSTR szParentName,		__out_ecount_opt(* pcchParentNameLength) LPWSTR szParentName,
IN LPDWORD pcchParentNameLength,		__inout LPDWORD pcchParentNameLength,
IN LPDWORD lpIndex		__out LPDWORD lpIndex
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhParseInstanceNameA(		PdhParseInstanceNameA(

IN LPCSTR szInstanceString,		__in LPCSTR szInstanceString,
IN LPSTR szInstanceName,		__out_ecount_opt(* pcchInstanceNameLength) LPSTR szInstanceName,
IN LPDWORD pcchInstanceNameLength,		__inout LPDWORD pcchInstanceNameLength,
IN LPSTR szParentName,		__out_ecount_opt(* pcchParentNameLength) LPSTR szParentName,
IN LPDWORD pcchParentNameLength,		__inout LPDWORD pcchParentNameLength,
IN LPDWORD lpIndex		__out LPDWORD lpIndex
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhValidatePathW(		PdhValidatePathW(

IN LPCWSTR szFullPathBuffer		__in LPCWSTR szFullPathBuffer
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhValidatePathA(		PdhValidatePathA(

IN LPCSTR szFullPathBuffer		__in LPCSTR szFullPathBuffer
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfObjectW(		PdhGetDefaultPerfObjectW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPWSTR szDefaultObjectName,		__out_ecount_opt(* pcchBufferSize) LPWSTR szDefaultObjectName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfObjectA(		PdhGetDefaultPerfObjectA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPSTR szDefaultObjectName,		__out_ecount_opt(* pcchBufferSize) LPSTR szDefaultObjectName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfCounterW(		PdhGetDefaultPerfCounterW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPCWSTR szObjectName,		__in LPCWSTR szObjectName,
IN LPWSTR szDefaultCounterName,		__out_ecount_opt(* pcchBufferSize) LPWSTR szDefaultCounterName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfCounterA(		PdhGetDefaultPerfCounterA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPCSTR szObjectName,		__in LPCSTR szObjectName,
IN LPSTR szDefaultCounterName,		__out_ecount_opt(* pcchBufferSize) LPSTR szDefaultCounterName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

typedef PDH_STATUS (__stdcall * CounterPathCallBack)(DWORD_PTR);		typedef PDH_STATUS (__stdcall * CounterPathCallBack)(DWORD_PTR);

#if _MSC_VER >= 1200		#if _MSC_VER >= 1200
#pragma warning(push)		#pragma warning(push)
#endif		#endif
#pragma warning ( disable : 4214 ) // Disable warning messages		#pragma warning ( disable : 4214 ) // Disable warning messages


		#if (_WIN32_WINDOWS >= 0x0501 \|\| _WIN32_WINNT >= 0x0501 \|\| (defined(NTDDI_VERSIO
		N) && NTDDI_VERSION >= NTDDI_WINXP))
typedef struct _BrowseDlgConfig_HW {		typedef struct _BrowseDlgConfig_HW {
// Configuration flags		// Configuration flags
DWORD bIncludeInstanceIndex:1,		DWORD bIncludeInstanceIndex:1,
bSingleCounterPerAdd:1,		bSingleCounterPerAdd:1,
bSingleCounterPerDialog:1,		bSingleCounterPerDialog:1,
bLocalCountersOnly:1,		bLocalCountersOnly:1,
bWildCardInstances:1,		bWildCardInstances:1,
bHideDetailBox:1,		bHideDetailBox:1,
bInitializePath:1,		bInitializePath:1,
bDisableMachineSelection:1,		bDisableMachineSelection:1,

skipping to change at line 740		skipping to change at line 790
bWildCardInstances:1,		bWildCardInstances:1,
bHideDetailBox:1,		bHideDetailBox:1,
bInitializePath:1,		bInitializePath:1,
bDisableMachineSelection:1,		bDisableMachineSelection:1,
bIncludeCostlyObjects:1,		bIncludeCostlyObjects:1,
bShowObjectBrowser:1,		bShowObjectBrowser:1,
bReserved:22;		bReserved:22;

HWND hWndOwner;		HWND hWndOwner;
LPSTR szDataSource;		LPSTR szDataSource;

		__field_ecount(cchReturnPathLength) LPSTR szReturnPathBuffer;
		DWORD cchReturnPathLength;
		CounterPathCallBack pCallBack;
		DWORD_PTR dwCallBackArg;
		PDH_STATUS CallBackStatus;
		DWORD dwDefaultDetailLevel;
		LPSTR szDialogBoxCaption;
		} PDH_BROWSE_DLG_CONFIG_A, * PPDH_BROWSE_DLG_CONFIG_A;
		#else

		typedef struct _BrowseDlgConfig_W {
		// Configuration flags
		DWORD bIncludeInstanceIndex:1,
		bSingleCounterPerAdd:1,
		bSingleCounterPerDialog:1,
		bLocalCountersOnly:1,
		bWildCardInstances:1,
		bHideDetailBox:1,
		bInitializePath:1,
		bDisableMachineSelection:1,
		bIncludeCostlyObjects:1,
		bReserved:23;

		HWND hWndOwner;
		LPWSTR szDataSource;
		LPWSTR szReturnPathBuffer;
		DWORD cchReturnPathLength;
		CounterPathCallBack pCallBack;
		DWORD_PTR dwCallBackArg;
		PDH_STATUS CallBackStatus;
		DWORD dwDefaultDetailLevel;
		LPWSTR szDialogBoxCaption;
		} PDH_BROWSE_DLG_CONFIG_W, * PPDH_BROWSE_DLG_CONFIG_W;

		typedef struct _BrowseDlgConfig_A {
		// Configuration flags
		DWORD bIncludeInstanceIndex:1,
		bSingleCounterPerAdd:1,
		bSingleCounterPerDialog:1,
		bLocalCountersOnly:1,
		bWildCardInstances:1,
		bHideDetailBox:1,
		bInitializePath:1,
		bDisableMachineSelection:1,
		bIncludeCostlyObjects:1,
		bReserved:23;

		HWND hWndOwner;
		LPSTR szDataSource;
LPSTR szReturnPathBuffer;		LPSTR szReturnPathBuffer;
DWORD cchReturnPathLength;		DWORD cchReturnPathLength;
CounterPathCallBack pCallBack;		CounterPathCallBack pCallBack;
DWORD_PTR dwCallBackArg;		DWORD_PTR dwCallBackArg;
PDH_STATUS CallBackStatus;		PDH_STATUS CallBackStatus;
DWORD dwDefaultDetailLevel;		DWORD dwDefaultDetailLevel;
LPSTR szDialogBoxCaption;		LPSTR szDialogBoxCaption;
} PDH_BROWSE_DLG_CONFIG_A, * PPDH_BROWSE_DLG_CONFIG_A;		} PDH_BROWSE_DLG_CONFIG_A, * PPDH_BROWSE_DLG_CONFIG_A;

		#endif

#if _MSC_VER >= 1200		#if _MSC_VER >= 1200
#pragma warning(pop)		#pragma warning(pop)
#else		#else
#pragma warning ( default : 4214 )		#pragma warning ( default : 4214 )
#endif		#endif

PDH_FUNCTION		PDH_FUNCTION
PdhBrowseCountersW(		PdhBrowseCountersW(

IN PPDH_BROWSE_DLG_CONFIG_W pBrowseDlgData		__in PPDH_BROWSE_DLG_CONFIG_W pBrowseDlgData
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhBrowseCountersA(		PdhBrowseCountersA(

IN PPDH_BROWSE_DLG_CONFIG_A pBrowseDlgData		__in PPDH_BROWSE_DLG_CONFIG_A pBrowseDlgData
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhExpandCounterPathW(		PdhExpandCounterPathW(

IN LPCWSTR szWildCardPath,		__in LPCWSTR szWildCardPath,
IN LPWSTR mszExpandedPathList,		__out_ecount_opt(* pcchPathListLength)__nullnullterminated LPWSTR mszExpand
IN LPDWORD pcchPathListLength		edPathList,
		__inout LPDWORD pcchPathListLength
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhExpandCounterPathA(		PdhExpandCounterPathA(

IN LPCSTR szWildCardPath,		__in LPCSTR szWildCardPath,
IN LPSTR mszExpandedPathList,		__out_ecount_opt(* pcchPathListLength)__nullnullterminated LPSTR mszExpand
IN LPDWORD pcchPathListLength		edPathList,
		__inout LPDWORD pcchPathListLength
);		);

//		//
// v2.0 functions		// v2.0 functions
//		//
PDH_FUNCTION		PDH_FUNCTION
PdhLookupPerfNameByIndexW(		PdhLookupPerfNameByIndexW(

IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN DWORD dwNameIndex,		__in DWORD dwNameIndex,
IN LPWSTR szNameBuffer,		__out_ecount_opt(* pcchNameBufferSize) LPWSTR szNameBuffer,
IN LPDWORD pcchNameBufferSize		__inout LPDWORD pcchNameBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhLookupPerfNameByIndexA(		PdhLookupPerfNameByIndexA(

IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN DWORD dwNameIndex,		__in DWORD dwNameIndex,
IN LPSTR szNameBuffer,		__out_ecount_opt(* pcchNameBufferSize) LPSTR szNameBuffer,
IN LPDWORD pcchNameBufferSize		__inout LPDWORD pcchNameBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhLookupPerfIndexByNameW(		PdhLookupPerfIndexByNameW(

IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPCWSTR szNameBuffer,		__in LPCWSTR szNameBuffer,
IN LPDWORD pdwIndex		__out LPDWORD pdwIndex
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhLookupPerfIndexByNameA(		PdhLookupPerfIndexByNameA(

IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPCSTR szNameBuffer,		__in LPCSTR szNameBuffer,
IN LPDWORD pdwIndex		__out LPDWORD pdwIndex
);		);

#define PDH_NOEXPANDCOUNTERS 1		#define PDH_NOEXPANDCOUNTERS 1
#define PDH_NOEXPANDINSTANCES 2		#define PDH_NOEXPANDINSTANCES 2

		#if (_WIN32_WINDOWS >= 0x0502 \|\| _WIN32_WINNT >= 0x0502 \|\| (defined(NTDDI_VERSIO N) && NTDDI_VERSION >= NTDDI_WIN2003))
#define PDH_REFRESHCOUNTERS 4		#define PDH_REFRESHCOUNTERS 4

		#endif

PDH_FUNCTION		PDH_FUNCTION
PdhExpandWildCardPathA(		PdhExpandWildCardPathA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN LPCSTR szWildCardPath,		__in LPCSTR szWildCardPath,
IN LPSTR mszExpandedPathList,		__out_ecount_opt(* pcchPathListLength)__nullnullterminated LPSTR mszExpand
IN LPDWORD pcchPathListLength,		edPathList,
IN DWORD dwFlags		__inout LPDWORD pcchPathListLength,
		__in DWORD dwFlags
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhExpandWildCardPathW(		PdhExpandWildCardPathW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN LPCWSTR szWildCardPath,		__in LPCWSTR szWildCardPath,
IN LPWSTR mszExpandedPathList,		__out_ecount_opt(* pcchPathListLength)__nullnullterminated LPWSTR mszExpand
IN LPDWORD pcchPathListLength,		edPathList,
IN DWORD dwFlags		__inout LPDWORD pcchPathListLength,
		__in DWORD dwFlags
);		);

//		//
// Logging Functions		// Logging Functions
//		//

#define PDH_LOG_READ_ACCESS ((DWORD) 0x00010000)		#define PDH_LOG_READ_ACCESS ((DWORD) 0x00010000)
#define PDH_LOG_WRITE_ACCESS ((DWORD) 0x00020000)		#define PDH_LOG_WRITE_ACCESS ((DWORD) 0x00020000)
#define PDH_LOG_UPDATE_ACCESS ((DWORD) 0x00040000)		#define PDH_LOG_UPDATE_ACCESS ((DWORD) 0x00040000)
#define PDH_LOG_ACCESS_MASK ((DWORD) 0x000F0000)		#define PDH_LOG_ACCESS_MASK ((DWORD) 0x000F0000)

#define PDH_LOG_CREATE_NEW ((DWORD) 0x00000001)		#define PDH_LOG_CREATE_NEW ((DWORD) 0x00000001)
#define PDH_LOG_CREATE_ALWAYS ((DWORD) 0x00000002)		#define PDH_LOG_CREATE_ALWAYS ((DWORD) 0x00000002)
#define PDH_LOG_OPEN_ALWAYS ((DWORD) 0x00000003)		#define PDH_LOG_OPEN_ALWAYS ((DWORD) 0x00000003)
#define PDH_LOG_OPEN_EXISTING ((DWORD) 0x00000004)		#define PDH_LOG_OPEN_EXISTING ((DWORD) 0x00000004)
#define PDH_LOG_CREATE_MASK ((DWORD) 0x0000000F)		#define PDH_LOG_CREATE_MASK ((DWORD) 0x0000000F)

#define PDH_LOG_OPT_USER_STRING ((DWORD) 0x01000000)		#define PDH_LOG_OPT_USER_STRING ((DWORD) 0x01000000)
#define PDH_LOG_OPT_CIRCULAR ((DWORD) 0x02000000)		#define PDH_LOG_OPT_CIRCULAR ((DWORD) 0x02000000)
#define PDH_LOG_OPT_MAX_IS_BYTES ((DWORD) 0x04000000)		#define PDH_LOG_OPT_MAX_IS_BYTES ((DWORD) 0x04000000)

		#if (_WIN32_WINDOWS >= 0x0501 \|\| _WIN32_WINNT >= 0x0501 \|\| (defined(NTDDI_VERSIO N) && NTDDI_VERSION >= NTDDI_WINXP))
#define PDH_LOG_OPT_APPEND ((DWORD) 0x08000000)		#define PDH_LOG_OPT_APPEND ((DWORD) 0x08000000)

		#endif
#define PDH_LOG_OPT_MASK ((DWORD) 0x0F000000)		#define PDH_LOG_OPT_MASK ((DWORD) 0x0F000000)

#define PDH_LOG_TYPE_UNDEFINED 0		#define PDH_LOG_TYPE_UNDEFINED 0
#define PDH_LOG_TYPE_CSV 1		#define PDH_LOG_TYPE_CSV 1
#define PDH_LOG_TYPE_TSV 2		#define PDH_LOG_TYPE_TSV 2

//#define PDH_LOG_TYPE_BINARY 3 // this is the retired binary format
#define PDH_LOG_TYPE_TRACE_KERNEL 4		#define PDH_LOG_TYPE_TRACE_KERNEL 4
#define PDH_LOG_TYPE_TRACE_GENERIC 5		#define PDH_LOG_TYPE_TRACE_GENERIC 5
#define PDH_LOG_TYPE_PERFMON 6		#define PDH_LOG_TYPE_PERFMON 6

		#if (_WIN32_WINDOWS >= 0x0501 \|\| _WIN32_WINNT >= 0x0501 \|\| (defined(NTDDI_VERSIO
		N) && NTDDI_VERSION >= NTDDI_WINXP))
		//#define PDH_LOG_TYPE_BINARY 3 // this is the retired binary format
#define PDH_LOG_TYPE_SQL 7		#define PDH_LOG_TYPE_SQL 7
#define PDH_LOG_TYPE_BINARY 8		#define PDH_LOG_TYPE_BINARY 8

		#else
		#define PDH_LOG_TYPE_BINARY 3
		#endif

PDH_FUNCTION		PDH_FUNCTION
PdhOpenLogW(		PdhOpenLogW(

IN LPCWSTR szLogFileName,		__in LPCWSTR szLogFileName,
IN DWORD dwAccessFlags,		__in DWORD dwAccessFlags,
IN LPDWORD lpdwLogType,		__inout LPDWORD lpdwLogType,
IN PDH_HQUERY hQuery,		__in_opt PDH_HQUERY hQuery,
IN DWORD dwMaxSize,		__in DWORD dwMaxSize,
IN LPCWSTR szUserCaption,		__in_opt LPCWSTR szUserCaption,
IN PDH_HLOG * phLog		__out PDH_HLOG * phLog
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhOpenLogA(		PdhOpenLogA(

IN LPCSTR szLogFileName,		__in LPCSTR szLogFileName,
IN DWORD dwAccessFlags,		__in DWORD dwAccessFlags,
IN LPDWORD lpdwLogType,		__inout LPDWORD lpdwLogType,
IN PDH_HQUERY hQuery,		__in_opt PDH_HQUERY hQuery,
IN DWORD dwMaxSize,		__in DWORD dwMaxSize,
IN LPCSTR szUserCaption,		__in_opt LPCSTR szUserCaption,
IN PDH_HLOG * phLog		__out PDH_HLOG * phLog
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhUpdateLogW(		PdhUpdateLogW(

IN PDH_HLOG hLog,		__in PDH_HLOG hLog,
IN LPCWSTR szUserString		__in_opt LPCWSTR szUserString
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhUpdateLogA(		PdhUpdateLogA(

IN PDH_HLOG hLog,		__in PDH_HLOG hLog,
IN LPCSTR szUserString		__in_opt LPCSTR szUserString
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhUpdateLogFileCatalog(		PdhUpdateLogFileCatalog(

IN PDH_HLOG hLog		__in PDH_HLOG hLog
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetLogFileSize(		PdhGetLogFileSize(

IN PDH_HLOG hLog,		__in PDH_HLOG hLog,
IN LONGLONG * llSize		__out LONGLONG * llSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhCloseLog(		PdhCloseLog(

IN PDH_HLOG hLog,		__in PDH_HLOG hLog,
IN DWORD dwFlags		__in DWORD dwFlags
);		);

#define PDH_FLAGS_CLOSE_QUERY ((DWORD) 0x00000001)		#define PDH_FLAGS_CLOSE_QUERY ((DWORD) 0x00000001)
//		//
// Data source selection dialog		// Data source selection dialog
//		//
#define PDH_FLAGS_FILE_BROWSER_ONLY ((DWORD) 0x00000001)		#define PDH_FLAGS_FILE_BROWSER_ONLY ((DWORD) 0x00000001)

PDH_FUNCTION		PDH_FUNCTION
PdhSelectDataSourceW(		PdhSelectDataSourceW(

IN HWND hWndOwner,		__in HWND hWndOwner,
IN DWORD dwFlags,		__in DWORD dwFlags,
IN LPWSTR szDataSource,		__inout_ecount(* pcchBufferLength) LPWSTR szDataSource,
IN LPDWORD pcchBufferLength		__inout LPDWORD pcchBufferLength
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhSelectDataSourceA(		PdhSelectDataSourceA(

IN HWND hWndOwner,		__in HWND hWndOwner,
IN DWORD dwFlags,		__in DWORD dwFlags,
IN LPSTR szDataSource,		__inout_ecount(* pcchBufferLength) LPSTR szDataSource,
IN LPDWORD pcchBufferLength		__inout LPDWORD pcchBufferLength
);		);

BOOL		BOOL
PdhIsRealTimeQuery(		PdhIsRealTimeQuery(

IN PDH_HQUERY hQuery		__in PDH_HQUERY hQuery
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhSetQueryTimeRange(		PdhSetQueryTimeRange(

IN PDH_HQUERY hQuery,		__in PDH_HQUERY hQuery,
IN PPDH_TIME_INFO pInfo		__in PPDH_TIME_INFO pInfo
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetDataSourceTimeRangeW(		PdhGetDataSourceTimeRangeW(

IN LPCWSTR szDataSource,		__in_opt LPCWSTR szDataSource,
IN LPDWORD pdwNumEntries,		__out LPDWORD pdwNumEntries,
IN PPDH_TIME_INFO pInfo,		__out_bcount(* pdwBufferSize) PPDH_TIME_INFO pInfo,
IN LPDWORD pdwBufferSize		__inout LPDWORD pdwBufferSize
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetDataSourceTimeRangeA(		PdhGetDataSourceTimeRangeA(

IN LPCSTR szDataSource,		__in_opt LPCSTR szDataSource,
IN LPDWORD pdwNumEntries,		__out LPDWORD pdwNumEntries,
IN PPDH_TIME_INFO pInfo,		__out_bcount(* pdwBufferSize) PPDH_TIME_INFO pInfo,
IN LPDWORD dwBufferSize		__inout LPDWORD pdwBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhCollectQueryDataEx(		PdhCollectQueryDataEx(

IN PDH_HQUERY hQuery,		__in PDH_HQUERY hQuery,
IN DWORD dwIntervalTime,		__in DWORD dwIntervalTime,
IN HANDLE hNewDataEvent		__in HANDLE hNewDataEvent
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhFormatFromRawValue(		PdhFormatFromRawValue(

IN DWORD dwCounterType,		__in DWORD dwCounterType,
IN DWORD dwFormat,		__in DWORD dwFormat,
IN LONGLONG * pTimeBase,		__in LONGLONG * pTimeBase,
IN PPDH_RAW_COUNTER pRawValue1,		__in PPDH_RAW_COUNTER pRawValue1,
IN PPDH_RAW_COUNTER pRawValue2,		__in PPDH_RAW_COUNTER pRawValue2,
IN PPDH_FMT_COUNTERVALUE pFmtValue		__out PPDH_FMT_COUNTERVALUE pFmtValue
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetCounterTimeBase(		PdhGetCounterTimeBase(

IN PDH_HCOUNTER hCounter,		__in PDH_HCOUNTER hCounter,
IN LONGLONG * pTimeBase		__out LONGLONG * pTimeBase
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhReadRawLogRecord(		PdhReadRawLogRecord(

IN PDH_HLOG hLog,		__in PDH_HLOG hLog,
IN FILETIME ftRecord,		__in FILETIME ftRecord,
IN PPDH_RAW_LOG_RECORD pRawLogRecord,		__out_bcount_opt(* pdwBufferLength) PPDH_RAW_LOG_RECORD pRawLogRecord,
IN LPDWORD pdwBufferLength		__inout LPDWORD pdwBufferLength
);		);

#define DATA_SOURCE_REGISTRY ((DWORD) 0x00000001)		#define DATA_SOURCE_REGISTRY ((DWORD) 0x00000001)
#define DATA_SOURCE_LOGFILE ((DWORD) 0x00000002)		#define DATA_SOURCE_LOGFILE ((DWORD) 0x00000002)
#define DATA_SOURCE_WBEM ((DWORD) 0x00000004)		#define DATA_SOURCE_WBEM ((DWORD) 0x00000004)

PDH_FUNCTION		PDH_FUNCTION
PdhSetDefaultRealTimeDataSource(		PdhSetDefaultRealTimeDataSource(

IN DWORD dwDataSourceId		__in DWORD dwDataSourceId
);		);


		#if (_WIN32_WINDOWS >= 0x0501 \|\| _WIN32_WINNT >= 0x0501 \|\| (defined(NTDDI_VERSIO N) && NTDDI_VERSION >= NTDDI_WINXP))
// Extended API for WMI event trace logfile format		// Extended API for WMI event trace logfile format
//		//
PDH_FUNCTION		PDH_FUNCTION
PdhBindInputDataSourceW(		PdhBindInputDataSourceW(

IN PDH_HLOG * phDataSource,		__out PDH_HLOG * phDataSource,
IN LPCWSTR LogFileNameList		__in_opt LPCWSTR LogFileNameList
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhBindInputDataSourceA(		PdhBindInputDataSourceA(

IN PDH_HLOG * phDataSource,		__out PDH_HLOG * phDataSource,
IN LPCSTR LogFileNameList		__in_opt LPCSTR LogFileNameList
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhOpenQueryH(		PdhOpenQueryH(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN DWORD_PTR dwUserData,		__in DWORD_PTR dwUserData,
IN PDH_HQUERY * phQuery		__out PDH_HQUERY * phQuery
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumMachinesHW(		PdhEnumMachinesHW(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPWSTR mszMachineList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPWSTR mszMachineLi
IN LPDWORD pcchBufferSize		st,
		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumMachinesHA(		PdhEnumMachinesHA(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPSTR mszMachineList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPSTR mszMachineLi
IN LPDWORD pcchBufferSize		st,
		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectsHW(		PdhEnumObjectsHW(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPWSTR mszObjectList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPWSTR mszObjectLis
IN LPDWORD pcchBufferSize,		t,
IN DWORD dwDetailLevel,		__inout LPDWORD pcchBufferSize,
IN BOOL bRefresh		__in DWORD dwDetailLevel,
		__in BOOL bRefresh
) ;		) ;

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectsHA(		PdhEnumObjectsHA(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPSTR mszObjectList,		__out_ecount_opt(* pcchBufferSize)__nullnullterminated LPSTR mszObjectLis
IN LPDWORD pcchBufferSize,		t,
IN DWORD dwDetailLevel,		__inout LPDWORD pcchBufferSize,
IN BOOL bRefresh		__in DWORD dwDetailLevel,
		__in BOOL bRefresh
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectItemsHW(		PdhEnumObjectItemsHW(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPCWSTR szObjectName,		__in LPCWSTR szObjectName,
IN LPWSTR mszCounterList,		__out_ecount_opt(* pcchCounterListLength)__nullnullterminated LPWSTR mszCo
IN LPDWORD pcchCounterListLength,		unterList,
IN LPWSTR mszInstanceList,		__inout LPDWORD pcchCounterListLength,
IN LPDWORD pcchInstanceListLength,		__out_ecount_opt(* pcchInstanceListLength)__nullnullterminated LPWSTR mszI
IN DWORD dwDetailLevel,		nstanceList,
IN DWORD dwFlags		__inout LPDWORD pcchInstanceListLength,
		__in DWORD dwDetailLevel,
		__in DWORD dwFlags
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumObjectItemsHA(		PdhEnumObjectItemsHA(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPCSTR szObjectName,		__in LPCSTR szObjectName,
IN LPSTR mszCounterList,		__out_ecount_opt(* pcchCounterListLength)__nullnullterminated LPSTR mszCo
IN LPDWORD pcchCounterListLength,		unterList,
IN LPSTR mszInstanceList,		__inout LPDWORD pcchCounterListLength,
IN LPDWORD pcchInstanceListLength,		__out_ecount_opt(* pcchInstanceListLength)__nullnullterminated LPSTR mszI
IN DWORD dwDetailLevel,		nstanceList,
IN DWORD dwFlags		__inout LPDWORD pcchInstanceListLength,
		__in DWORD dwDetailLevel,
		__in DWORD dwFlags
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhExpandWildCardPathHW(		PdhExpandWildCardPathHW(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCWSTR szWildCardPath,		__in LPCWSTR szWildCardPath,
IN LPWSTR mszExpandedPathList,		__out_ecount_opt(* pcchPathListLength)__nullnullterminated LPWSTR mszExpan
IN LPDWORD pcchPathListLength,		dedPathList,
IN DWORD dwFlags		__inout LPDWORD pcchPathListLength,
		__in DWORD dwFlags
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhExpandWildCardPathHA(		PdhExpandWildCardPathHA(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCSTR szWildCardPath,		__in LPCSTR szWildCardPath,
IN LPSTR mszExpandedPathList,		__out_ecount_opt(* pcchPathListLength)__nullnullterminated LPSTR mszExpan
IN LPDWORD pcchPathListLength,		dedPathList,
IN DWORD dwFlags		__inout LPDWORD pcchPathListLength,
		__in DWORD dwFlags
);		);


		__success(return == ERROR_SUCCESS)
PDH_FUNCTION		PDH_FUNCTION
PdhGetDataSourceTimeRangeH(		PdhGetDataSourceTimeRangeH(

IN PDH_HLOG hDataSource,		__inout_opt PDH_HLOG hDataSource,
IN LPDWORD pdwNumEntries,		__out LPDWORD pdwNumEntries,
IN PPDH_TIME_INFO pInfo,		__out_bcount(* pdwBufferSize) PPDH_TIME_INFO pInfo,
IN LPDWORD pdwBufferSize		__inout LPDWORD pdwBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfObjectHW(		PdhGetDefaultPerfObjectHW(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPWSTR szDefaultObjectName,		__out_ecount_opt(* pcchBufferSize) LPWSTR szDefaultObjectName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfObjectHA(		PdhGetDefaultPerfObjectHA(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPSTR szDefaultObjectName,		__out_ecount_opt(* pcchBufferSize) LPSTR szDefaultObjectName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfCounterHW(		PdhGetDefaultPerfCounterHW(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCWSTR szMachineName,		__in_opt LPCWSTR szMachineName,
IN LPCWSTR szObjectName,		__in LPCWSTR szObjectName,
IN LPWSTR szDefaultCounterName,		__out_ecount_opt(* pcchBufferSize) LPWSTR szDefaultCounterName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhGetDefaultPerfCounterHA(		PdhGetDefaultPerfCounterHA(

IN PDH_HLOG hDataSource,		__in_opt PDH_HLOG hDataSource,
IN LPCSTR szMachineName,		__in_opt LPCSTR szMachineName,
IN LPCSTR szObjectName,		__in LPCSTR szObjectName,
IN LPSTR szDefaultCounterName,		__out_ecount_opt(* pcchBufferSize) LPSTR szDefaultCounterName,
IN LPDWORD pcchBufferSize		__inout LPDWORD pcchBufferSize
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhBrowseCountersHW(		PdhBrowseCountersHW(

IN PPDH_BROWSE_DLG_CONFIG_HW pBrowseDlgData		__in PPDH_BROWSE_DLG_CONFIG_HW pBrowseDlgData
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhBrowseCountersHA(		PdhBrowseCountersHA(

IN PPDH_BROWSE_DLG_CONFIG_HA pBrowseDlgData		__in PPDH_BROWSE_DLG_CONFIG_HA pBrowseDlgData
);		);

//Check that a DSN points to a database that contains the correct Perfmon tables .		//Check that a DSN points to a database that contains the correct Perfmon tables .
PDH_FUNCTION		PDH_FUNCTION
PdhVerifySQLDBW(		PdhVerifySQLDBW(

IN LPCWSTR szDataSource		__in LPCWSTR szDataSource
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhVerifySQLDBA(		PdhVerifySQLDBA(

IN LPCSTR szDataSource		__in LPCSTR szDataSource
);		);

//Create the correct perfmon tables in the database pointed to by a DSN.		//Create the correct perfmon tables in the database pointed to by a DSN.
PDH_FUNCTION		PDH_FUNCTION
PdhCreateSQLTablesW(		PdhCreateSQLTablesW(

IN LPCWSTR szDataSource		__in LPCWSTR szDataSource
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhCreateSQLTablesA(		PdhCreateSQLTablesA(

IN LPCSTR szDataSource		__in LPCSTR szDataSource
);		);

//Return the list of Log set names in the database pointed to by the DSN.		//Return the list of Log set names in the database pointed to by the DSN.
PDH_FUNCTION		PDH_FUNCTION
PdhEnumLogSetNamesW(		PdhEnumLogSetNamesW(

IN LPCWSTR szDataSource,		__in LPCWSTR szDataSource,
IN LPWSTR mszDataSetNameList,		__out_ecount_opt(* pcchBufferLength)__nullnullterminated LPWSTR mszDataSetN
IN LPDWORD pcchBufferLength		ameList,
		__inout LPDWORD pcchBufferLength
);		);

PDH_FUNCTION		PDH_FUNCTION
PdhEnumLogSetNamesA(		PdhEnumLogSetNamesA(

IN LPCSTR szDataSource,		__in LPCSTR szDataSource,
IN LPSTR mszDataSetNameList,		__out_ecount_opt(* pcchBufferLength)__nullnullterminated LPSTR mszDataSetN
IN LPDWORD pcchBufferLength		ameList,
		__inout LPDWORD pcchBufferLength
);		);

//Retrieve the GUID for an open Log Set		//Retrieve the GUID for an open Log Set
PDH_FUNCTION		PDH_FUNCTION
PdhGetLogSetGUID(		PdhGetLogSetGUID(

IN PDH_HLOG hLog,		__in PDH_HLOG hLog,
IN GUID * pGuid,		__out_opt GUID * pGuid,
IN int * pRunId		__out_opt int * pRunId
);		);

//Set the RunID for an open Log Set		//Set the RunID for an open Log Set
PDH_FUNCTION		PDH_FUNCTION
PdhSetLogSetRunID(		PdhSetLogSetRunID(

IN PDH_HLOG hLog,		__inout PDH_HLOG hLog,
IN int RunId		__in int RunId
);		);

		#endif

//		//
// Unicode/ANSI compatibility section		// Unicode/ANSI compatibility section
//		//
#ifdef UNICODE		#ifdef UNICODE
#ifndef _UNICODE		#ifndef _UNICODE
#define _UNICODE		#define _UNICODE
#endif		#endif
#endif		#endif

#ifdef _UNICODE		#ifdef _UNICODE
#ifndef UNICODE		#ifndef UNICODE
#define UNICODE		#define UNICODE
#endif		#endif
#endif		#endif

#ifdef UNICODE		#ifdef UNICODE
// start of UNICODE definitions		// start of UNICODE definitions
#define PdhOpenQuery PdhOpenQueryW		#define PdhOpenQuery PdhOpenQueryW
#define PdhAddCounter PdhAddCounterW		#define PdhAddCounter PdhAddCounterW

		#if (_WIN32_WINDOWS >= 0x0600 \|\| _WIN32_WINNT >= 0x0600 \|\| (defined(NTDDI_VERSIO
		N) && NTDDI_VERSION >= NTDDI_LONGHORN))
		#define PdhAddEnglishCounter PdhAddEnglishCounterW
		#define PdhValidatePathEx PdhValidatePathExW
		#endif
#define PdhGetCounterInfo PdhGetCounterInfoW		#define PdhGetCounterInfo PdhGetCounterInfoW
#define PDH_COUNTER_INFO PDH_COUNTER_INFO_W		#define PDH_COUNTER_INFO PDH_COUNTER_INFO_W
#define PPDH_COUNTER_INFO PPDH_COUNTER_INFO_W		#define PPDH_COUNTER_INFO PPDH_COUNTER_INFO_W
#define PdhConnectMachine PdhConnectMachineW		#define PdhConnectMachine PdhConnectMachineW
#define PdhEnumMachines PdhEnumMachinesW		#define PdhEnumMachines PdhEnumMachinesW
#define PdhEnumObjects PdhEnumObjectsW		#define PdhEnumObjects PdhEnumObjectsW
#define PdhEnumObjectItems PdhEnumObjectItemsW		#define PdhEnumObjectItems PdhEnumObjectItemsW
#define PdhMakeCounterPath PdhMakeCounterPathW		#define PdhMakeCounterPath PdhMakeCounterPathW
#define PDH_COUNTER_PATH_ELEMENTS PDH_COUNTER_PATH_ELEMENTS_W		#define PDH_COUNTER_PATH_ELEMENTS PDH_COUNTER_PATH_ELEMENTS_W
#define PPDH_COUNTER_PATH_ELEMENTS PPDH_COUNTER_PATH_ELEMENTS_W		#define PPDH_COUNTER_PATH_ELEMENTS PPDH_COUNTER_PATH_ELEMENTS_W
#define PdhParseCounterPath PdhParseCounterPathW		#define PdhParseCounterPath PdhParseCounterPathW
#define PdhParseInstanceName PdhParseInstanceNameW		#define PdhParseInstanceName PdhParseInstanceNameW
#define PdhValidatePath PdhValidatePathW		#define PdhValidatePath PdhValidatePathW
#define PdhGetDefaultPerfObject PdhGetDefaultPerfObjectW		#define PdhGetDefaultPerfObject PdhGetDefaultPerfObjectW
#define PdhGetDefaultPerfCounter PdhGetDefaultPerfCounterW		#define PdhGetDefaultPerfCounter PdhGetDefaultPerfCounterW
#define PdhBrowseCounters PdhBrowseCountersW		#define PdhBrowseCounters PdhBrowseCountersW

#define PdhBrowseCountersH PdhBrowseCountersHW
#define PDH_BROWSE_DLG_CONFIG PDH_BROWSE_DLG_CONFIG_W		#define PDH_BROWSE_DLG_CONFIG PDH_BROWSE_DLG_CONFIG_W
#define PPDH_BROWSE_DLG_CONFIG PPDH_BROWSE_DLG_CONFIG_W		#define PPDH_BROWSE_DLG_CONFIG PPDH_BROWSE_DLG_CONFIG_W

#define PDH_BROWSE_DLG_CONFIG_H PDH_BROWSE_DLG_CONFIG_HW
#define PPDH_BROWSE_DLG_CONFIG_H PPDH_BROWSE_DLG_CONFIG_HW
#define PdhExpandCounterPath PdhExpandCounterPathW		#define PdhExpandCounterPath PdhExpandCounterPathW
// v2.0 functions		// v2.0 functions
#define PDH_FMT_COUNTERVALUE_ITEM PDH_FMT_COUNTERVALUE_ITEM_W		#define PDH_FMT_COUNTERVALUE_ITEM PDH_FMT_COUNTERVALUE_ITEM_W
#define PPDH_FMT_COUNTERVALUE_ITEM PPDH_FMT_COUNTERVALUE_ITEM_W		#define PPDH_FMT_COUNTERVALUE_ITEM PPDH_FMT_COUNTERVALUE_ITEM_W
#define PDH_RAW_COUNTER_ITEM PDH_RAW_COUNTER_ITEM_W		#define PDH_RAW_COUNTER_ITEM PDH_RAW_COUNTER_ITEM_W
#define PPDH_RAW_COUNTER_ITEM PPDH_RAW_COUNTER_ITEM_W		#define PPDH_RAW_COUNTER_ITEM PPDH_RAW_COUNTER_ITEM_W
#define PdhGetFormattedCounterArray PdhGetFormattedCounterArrayW		#define PdhGetFormattedCounterArray PdhGetFormattedCounterArrayW
#define PdhGetRawCounterArray PdhGetRawCounterArrayW		#define PdhGetRawCounterArray PdhGetRawCounterArrayW
#define PdhLookupPerfNameByIndex PdhLookupPerfNameByIndexW		#define PdhLookupPerfNameByIndex PdhLookupPerfNameByIndexW

#define PdhLookupPerfIndexByName PdhLookupPerfIndexByNameW
#define PdhOpenLog PdhOpenLogW		#define PdhOpenLog PdhOpenLogW
#define PdhUpdateLog PdhUpdateLogW		#define PdhUpdateLog PdhUpdateLogW
#define PdhSelectDataSource PdhSelectDataSourceW		#define PdhSelectDataSource PdhSelectDataSourceW
#define PdhGetDataSourceTimeRange PdhGetDataSourceTimeRangeW		#define PdhGetDataSourceTimeRange PdhGetDataSourceTimeRangeW
#define PDH_LOG_SERVICE_QUERY_INFO PDH_LOG_SERVICE_QUERY_INFO_W		#define PDH_LOG_SERVICE_QUERY_INFO PDH_LOG_SERVICE_QUERY_INFO_W
#define PPDH_LOG_SERVICE_QUERY_INFO PPDH_LOG_SERVICE_QUERY_INFO_W		#define PPDH_LOG_SERVICE_QUERY_INFO PPDH_LOG_SERVICE_QUERY_INFO_W
#define PdhLogServiceControl PdhLogServiceControlW		#define PdhLogServiceControl PdhLogServiceControlW
#define PdhLogServiceQuery PdhLogServiceQueryW		#define PdhLogServiceQuery PdhLogServiceQueryW
#define PdhExpandWildCardPath PdhExpandWildCardPathW		#define PdhExpandWildCardPath PdhExpandWildCardPathW


		#if (_WIN32_WINDOWS >= 0x0501 \|\| _WIN32_WINNT >= 0x0501 \|\| (defined(NTDDI_VERSIO
		N) && NTDDI_VERSION >= NTDDI_WINXP))
#define PdhBindInputDataSource PdhBindInputDataSourceW		#define PdhBindInputDataSource PdhBindInputDataSourceW

		#define PdhBrowseCountersH PdhBrowseCountersHW
		#define PDH_BROWSE_DLG_CONFIG_H PDH_BROWSE_DLG_CONFIG_HW
		#define PPDH_BROWSE_DLG_CONFIG_H PPDH_BROWSE_DLG_CONFIG_HW
#define PdhEnumMachinesH PdhEnumMachinesHW		#define PdhEnumMachinesH PdhEnumMachinesHW
#define PdhEnumObjectsH PdhEnumObjectsHW		#define PdhEnumObjectsH PdhEnumObjectsHW
#define PdhEnumObjectItemsH PdhEnumObjectItemsHW		#define PdhEnumObjectItemsH PdhEnumObjectItemsHW
#define PdhExpandWildCardPathH PdhExpandWildCardPathHW		#define PdhExpandWildCardPathH PdhExpandWildCardPathHW
#define PdhGetDefaultPerfObjectH PdhGetDefaultPerfObjectHW		#define PdhGetDefaultPerfObjectH PdhGetDefaultPerfObjectHW
#define PdhGetDefaultPerfCounterH PdhGetDefaultPerfCounterHW		#define PdhGetDefaultPerfCounterH PdhGetDefaultPerfCounterHW
#define PdhEnumLogSetNames PdhEnumLogSetNamesW		#define PdhEnumLogSetNames PdhEnumLogSetNamesW
#define PdhCreateSQLTables PdhCreateSQLTablesW		#define PdhCreateSQLTables PdhCreateSQLTablesW
#define PdhVerifySQLDB PdhVerifySQLDBW		#define PdhVerifySQLDB PdhVerifySQLDBW

		#define PdhLookupPerfIndexByName PdhLookupPerfIndexByNameW
		#endif

// end of UNICODE definitions		// end of UNICODE definitions
#else		#else
// start of ANSI definitions		// start of ANSI definitions
#define PdhOpenQuery PdhOpenQueryA		#define PdhOpenQuery PdhOpenQueryA
#define PdhAddCounter PdhAddCounterA		#define PdhAddCounter PdhAddCounterA

		#if (_WIN32_WINDOWS >= 0x0600 \|\| _WINNT_WINNT >= 0x0600 \|\| (defined(NTDDI_VERSIO
		N) && NTDDI_VERSION >= NTDDI_LONGHORN))
		#define PdhAddEnglishCounter PdhAddEnglishCounterA
		#define PdhValidatePathEx PdhValidatePathExA
		#endif
#define PdhGetCounterInfo PdhGetCounterInfoA		#define PdhGetCounterInfo PdhGetCounterInfoA
#define PDH_COUNTER_INFO PDH_COUNTER_INFO_A		#define PDH_COUNTER_INFO PDH_COUNTER_INFO_A
#define PPDH_COUNTER_INFO PPDH_COUNTER_INFO_A		#define PPDH_COUNTER_INFO PPDH_COUNTER_INFO_A
#define PdhConnectMachine PdhConnectMachineA		#define PdhConnectMachine PdhConnectMachineA
#define PdhEnumMachines PdhEnumMachinesA		#define PdhEnumMachines PdhEnumMachinesA
#define PdhEnumObjects PdhEnumObjectsA		#define PdhEnumObjects PdhEnumObjectsA
#define PdhEnumObjectItems PdhEnumObjectItemsA		#define PdhEnumObjectItems PdhEnumObjectItemsA
#define PdhMakeCounterPath PdhMakeCounterPathA		#define PdhMakeCounterPath PdhMakeCounterPathA
#define PDH_COUNTER_PATH_ELEMENTS PDH_COUNTER_PATH_ELEMENTS_A		#define PDH_COUNTER_PATH_ELEMENTS PDH_COUNTER_PATH_ELEMENTS_A
#define PPDH_COUNTER_PATH_ELEMENTS PPDH_COUNTER_PATH_ELEMENTS_A		#define PPDH_COUNTER_PATH_ELEMENTS PPDH_COUNTER_PATH_ELEMENTS_A
#define PdhParseCounterPath PdhParseCounterPathA		#define PdhParseCounterPath PdhParseCounterPathA
#define PdhParseInstanceName PdhParseInstanceNameA		#define PdhParseInstanceName PdhParseInstanceNameA
#define PdhValidatePath PdhValidatePathA		#define PdhValidatePath PdhValidatePathA
#define PdhGetDefaultPerfObject PdhGetDefaultPerfObjectA		#define PdhGetDefaultPerfObject PdhGetDefaultPerfObjectA
#define PdhGetDefaultPerfCounter PdhGetDefaultPerfCounterA		#define PdhGetDefaultPerfCounter PdhGetDefaultPerfCounterA
#define PdhBrowseCounters PdhBrowseCountersA		#define PdhBrowseCounters PdhBrowseCountersA

#define PdhBrowseCountersH PdhBrowseCountersHA
#define PDH_BROWSE_DLG_CONFIG PDH_BROWSE_DLG_CONFIG_A		#define PDH_BROWSE_DLG_CONFIG PDH_BROWSE_DLG_CONFIG_A
#define PPDH_BROWSE_DLG_CONFIG PPDH_BROWSE_DLG_CONFIG_A		#define PPDH_BROWSE_DLG_CONFIG PPDH_BROWSE_DLG_CONFIG_A

#define PDH_BROWSE_DLG_CONFIG_H PDH_BROWSE_DLG_CONFIG_HA
#define PPDH_BROWSE_DLG_CONFIG_H PPDH_BROWSE_DLG_CONFIG_HA
#define PdhExpandCounterPath PdhExpandCounterPathA		#define PdhExpandCounterPath PdhExpandCounterPathA
// v2.0 functions		// v2.0 functions
#define PDH_FMT_COUNTERVALUE_ITEM PDH_FMT_COUNTERVALUE_ITEM_A		#define PDH_FMT_COUNTERVALUE_ITEM PDH_FMT_COUNTERVALUE_ITEM_A
#define PPDH_FMT_COUNTERVALUE_ITEM PPDH_FMT_COUNTERVALUE_ITEM_A		#define PPDH_FMT_COUNTERVALUE_ITEM PPDH_FMT_COUNTERVALUE_ITEM_A
#define PDH_RAW_COUNTER_ITEM PDH_RAW_COUNTER_ITEM_A		#define PDH_RAW_COUNTER_ITEM PDH_RAW_COUNTER_ITEM_A
#define PPDH_RAW_COUNTER_ITEM PPDH_RAW_COUNTER_ITEM_A		#define PPDH_RAW_COUNTER_ITEM PPDH_RAW_COUNTER_ITEM_A
#define PdhGetFormattedCounterArray PdhGetFormattedCounterArrayA		#define PdhGetFormattedCounterArray PdhGetFormattedCounterArrayA
#define PdhGetRawCounterArray PdhGetRawCounterArrayA		#define PdhGetRawCounterArray PdhGetRawCounterArrayA
#define PdhLookupPerfNameByIndex PdhLookupPerfNameByIndexA		#define PdhLookupPerfNameByIndex PdhLookupPerfNameByIndexA

#define PdhLookupPerfIndexByName PdhLookupPerfIndexByNameA
#define PdhOpenLog PdhOpenLogA		#define PdhOpenLog PdhOpenLogA
#define PdhUpdateLog PdhUpdateLogA		#define PdhUpdateLog PdhUpdateLogA
#define PdhSelectDataSource PdhSelectDataSourceA		#define PdhSelectDataSource PdhSelectDataSourceA
#define PdhGetDataSourceTimeRange PdhGetDataSourceTimeRangeA		#define PdhGetDataSourceTimeRange PdhGetDataSourceTimeRangeA
#define PDH_LOG_SERVICE_QUERY_INFO PDH_LOG_SERVICE_QUERY_INFO_A		#define PDH_LOG_SERVICE_QUERY_INFO PDH_LOG_SERVICE_QUERY_INFO_A
#define PPDH_LOG_SERVICE_QUERY_INFO PPDH_LOG_SERVICE_QUERY_INFO_A		#define PPDH_LOG_SERVICE_QUERY_INFO PPDH_LOG_SERVICE_QUERY_INFO_A
#define PdhLogServiceControl PdhLogServiceControlA		#define PdhLogServiceControl PdhLogServiceControlA
#define PdhLogServiceQuery PdhLogServiceQueryA		#define PdhLogServiceQuery PdhLogServiceQueryA
#define PdhExpandWildCardPath PdhExpandWildCardPathA		#define PdhExpandWildCardPath PdhExpandWildCardPathA


		#if (_WIN32_WINDOWS >= 0x0501 \|\| _WIN32_WINNT >= 0x0501 \|\| (defined(NTDDI_VERSIO
		N) && NTDDI_VERSION >= NTDDI_WINXP))
#define PdhBindInputDataSource PdhBindInputDataSourceA		#define PdhBindInputDataSource PdhBindInputDataSourceA

		#define PDH_BROWSE_DLG_CONFIG_H PDH_BROWSE_DLG_CONFIG_HA
		#define PPDH_BROWSE_DLG_CONFIG_H PPDH_BROWSE_DLG_CONFIG_HA
		#define PdhBrowseCountersH PdhBrowseCountersHA
#define PdhEnumMachinesH PdhEnumMachinesHA		#define PdhEnumMachinesH PdhEnumMachinesHA
#define PdhEnumObjectsH PdhEnumObjectsHA		#define PdhEnumObjectsH PdhEnumObjectsHA
#define PdhEnumObjectItemsH PdhEnumObjectItemsHA		#define PdhEnumObjectItemsH PdhEnumObjectItemsHA
#define PdhExpandWildCardPathH PdhExpandWildCardPathHA		#define PdhExpandWildCardPathH PdhExpandWildCardPathHA
#define PdhGetDefaultPerfObjectH PdhGetDefaultPerfObjectHA		#define PdhGetDefaultPerfObjectH PdhGetDefaultPerfObjectHA
#define PdhGetDefaultPerfCounterH PdhGetDefaultPerfCounterHA		#define PdhGetDefaultPerfCounterH PdhGetDefaultPerfCounterHA
#define PdhEnumLogSetNames PdhEnumLogSetNamesA		#define PdhEnumLogSetNames PdhEnumLogSetNamesA
#define PdhCreateSQLTables PdhCreateSQLTablesA		#define PdhCreateSQLTables PdhCreateSQLTablesA
#define PdhVerifySQLDB PdhVerifySQLDBA		#define PdhVerifySQLDB PdhVerifySQLDBA

		#define PdhLookupPerfIndexByName PdhLookupPerfIndexByNameA
		#endif

// end of ANSI definitions		// end of ANSI definitions
#endif // UNICODE		#endif // UNICODE

#if _MSC_VER >= 1200		#if _MSC_VER >= 1200
#pragma warning(pop)		#pragma warning(pop)
#else		#else
#pragma warning ( default : 4201 )		#pragma warning ( default : 4201 )
#endif		#endif


End of changes. 138 change blocks.
345 lines changed or deleted		506 lines changed or added

This html diff was produced by rfcdiff 1.41.