开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaPdh.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：121k
源码类别：

Windows编程

开发平台：

Delphi

JwaPdh.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Performance Data Helper API interface Unit for Object Pascal                 }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: pdh.h, released June 2000. The original Pascal         }
  9. { code is: Pdh.pas, released December 2000. The initial developer of the       }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaPdh;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "pdh.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaWinBase, JwaWinType, JwaWinPerf;
  59. type
  60.   PDH_STATUS = DWORD;
  61.   {$EXTERNALSYM PDH_STATUS}
  63. const
  65. // version info
  67.   PDH_CVERSION_WIN40 = DWORD($0400);
  68.   {$EXTERNALSYM PDH_CVERSION_WIN40}
  69.   PDH_CVERSION_WIN50 = DWORD($0500);
  70.   {$EXTERNALSYM PDH_CVERSION_WIN50}
  72. // v1.1 revision of PDH -- basic log functions
  73. // v1.2 of the PDH -- adds variable instance counters
  74. // v1.3 of the PDH -- adds log service control & stubs for NT5/PDH v2 fn's
  75. // v2.0 of the PDH -- is the NT v 5.0 B2 version
  77.   PDH_VERSION        = DWORD((PDH_CVERSION_WIN50) + $0003);
  78.   {$EXTERNALSYM PDH_VERSION}
  80. // define severity masks
  82. function IsSuccessSeverity(ErrorCode: Longint): Boolean;
  83. {$EXTERNALSYM IsSuccessSeverity}
  84. function IsInformationalSeverity(ErrorCode: Longint): Boolean;
  85. {$EXTERNALSYM IsInformationalSeverity}
  86. function IsWarningSeverity(ErrorCode: Longint): Boolean;
  87. {$EXTERNALSYM IsWarningSeverity}
  88. function IsErrorSeverity(ErrorCode: Longint): Boolean;
  89. {$EXTERNALSYM IsErrorSeverity}
  91. const
  92.   MAX_COUNTER_PATH = 256;         // Maximum counter path length
  93.   {$EXTERNALSYM MAX_COUNTER_PATH}
  95.   PDH_MAX_COUNTER_NAME    = 1024;  // Maximum counter name length.
  96.   {$EXTERNALSYM PDH_MAX_COUNTER_NAME}
  97.   PDH_MAX_INSTANCE_NAME   = 1024;  // Maximum counter instance name length.
  98.   {$EXTERNALSYM PDH_MAX_INSTANCE_NAME}
  99.   PDH_MAX_COUNTER_PATH    = 2048;  // Maximum full counter path length.
  100.   {$EXTERNALSYM PDH_MAX_COUNTER_PATH}
  101.   PDH_MAX_DATASOURCE_PATH = 1024;  // MAximum full counter log name length.
  102.   {$EXTERNALSYM PDH_MAX_DATASOURCE_PATH}
  104. // data type definitions
  106. type
  107.   PDH_HCOUNTER = HANDLE;
  108.   {$EXTERNALSYM PDH_HCOUNTER}
  109.   PDH_HQUERY = HANDLE;
  110.   {$EXTERNALSYM PDH_HQUERY}
  111.   PDH_HLOG = HANDLE;
  112.   {$EXTERNALSYM PDH_HLOG}
  114.   HCOUNTER = PDH_HCOUNTER;
  115.   {$EXTERNALSYM HCOUNTER}
  116.   HQUERY = PDH_HQUERY;
  117.   {$EXTERNALSYM HQUERY}
  118.   HLOG = PDH_HLOG;
  119.   {$EXTERNALSYM HLOG}
  121. const
  122.   INVALID_HANDLE_VALUE = HANDLE(LONG_PTR(-1));
  123.   {$EXTERNALSYM INVALID_HANDLE_VALUE}
  125.   H_REALTIME_DATASOURCE = NULL;
  126.   {$EXTERNALSYM H_REALTIME_DATASOURCE}
  127.   H_WBEM_DATASOURCE     = INVALID_HANDLE_VALUE;
  128.   {$EXTERNALSYM H_WBEM_DATASOURCE}
  130. type
  131.   PPDH_RAW_COUNTER = ^PDH_RAW_COUNTER;
  132.   {$EXTERNALSYM PPDH_RAW_COUNTER}
  133.   _PDH_RAW_COUNTER = record
  134.     CStatus: DWORD;
  135.     TimeStamp: FILETIME;
  136.     FirstValue: LONGLONG;
  137.     SecondValue: LONGLONG;
  138.     MultiCount: DWORD;
  139.   end;
  140.   {$EXTERNALSYM _PDH_RAW_COUNTER}
  141.   PDH_RAW_COUNTER = _PDH_RAW_COUNTER;
  142.   {$EXTERNALSYM PDH_RAW_COUNTER}
  143.   TPdhRawCounter = PDH_RAW_COUNTER;
  144.   PPdhRawCounter = PPDH_RAW_COUNTER;
  146.   PPDH_RAW_COUNTER_ITEM_A = ^PDH_RAW_COUNTER_ITEM_A;
  147.   {$EXTERNALSYM PPDH_RAW_COUNTER_ITEM_A}
  148.   _PDH_RAW_COUNTER_ITEM_A = record
  149.     szName: LPSTR;
  150.     RawValue: PDH_RAW_COUNTER;
  151.   end;
  152.   {$EXTERNALSYM _PDH_RAW_COUNTER_ITEM_A}
  153.   PDH_RAW_COUNTER_ITEM_A = _PDH_RAW_COUNTER_ITEM_A;
  154.   {$EXTERNALSYM PDH_RAW_COUNTER_ITEM_A}
  155.   TPdhRawCounterItemA = PDH_RAW_COUNTER_ITEM_A;
  156.   PPdhRawCounterItemA = PPDH_RAW_COUNTER_ITEM_A;
  158.   PPDH_RAW_COUNTER_ITEM_W = ^PDH_RAW_COUNTER_ITEM_W;
  159.   {$EXTERNALSYM PPDH_RAW_COUNTER_ITEM_W}
  160.   _PDH_RAW_COUNTER_ITEM_W = record
  161.     szName: LPWSTR;
  162.     RawValue: PDH_RAW_COUNTER;
  163.   end;
  164.   {$EXTERNALSYM _PDH_RAW_COUNTER_ITEM_W}
  165.   PDH_RAW_COUNTER_ITEM_W = _PDH_RAW_COUNTER_ITEM_W;
  166.   {$EXTERNALSYM PDH_RAW_COUNTER_ITEM_W}
  167.   TPdhRawCounterItemW = PDH_RAW_COUNTER_ITEM_W;
  168.   PPdhRawCounterItemW = PPDH_RAW_COUNTER_ITEM_W;
  170. {$IFDEF UNICODE}
  171.   PPdhRawCounterItem = PPdhRawCounterItemW;
  172.   PDH_RAW_COUNTER_ITEM = _PDH_RAW_COUNTER_ITEM_W;
  173.   {$EXTERNALSYM PDH_RAW_COUNTER_ITEM}
  174.   PPDH_RAW_COUNTER_ITEM = PPDH_RAW_COUNTER_ITEM_W;
  175.   {$EXTERNALSYM PPDH_RAW_COUNTER_ITEM}
  176.   TPdhRawCounterItem = _PDH_RAW_COUNTER_ITEM_W;
  177. {$ELSE}
  178.   PPdhRawCounterItem = PPdhRawCounterItemA;
  179.   PDH_RAW_COUNTER_ITEM = _PDH_RAW_COUNTER_ITEM_A;
  180.   {$EXTERNALSYM PDH_RAW_COUNTER_ITEM}
  181.   PPDH_RAW_COUNTER_ITEM = PPDH_RAW_COUNTER_ITEM_A;
  182.   {$EXTERNALSYM PPDH_RAW_COUNTER_ITEM}
  183.   TPdhRawCounterItem = _PDH_RAW_COUNTER_ITEM_A;
  184. {$ENDIF}
  186.   PPDH_FMT_COUNTERVALUE = ^PDH_FMT_COUNTERVALUE;
  187.   {$EXTERNALSYM PPDH_FMT_COUNTERVALUE}
  188.   _PDH_FMT_COUNTERVALUE = record
  189.     CStatus: DWORD;
  190.     case Longint of
  191.       1: (longValue: LONG);
  192.       2: (doubleValue: Double);
  193.       3: (largeValue: LONGLONG);
  194.       4: (AnsiStringValue: LPSTR);
  195.       5: (WideStringValue: LPCWSTR);
  196.   end;
  197.   {$EXTERNALSYM _PDH_FMT_COUNTERVALUE}
  198.   PDH_FMT_COUNTERVALUE = _PDH_FMT_COUNTERVALUE;
  199.   {$EXTERNALSYM PDH_FMT_COUNTERVALUE}
  200.   TPdhFmtCounterValue = PDH_FMT_COUNTERVALUE;
  201.   PPdhFmtCounterValue = PPDH_FMT_COUNTERVALUE;
  203.   PPDH_FMT_COUNTERVALUE_ITEM_A = ^PDH_FMT_COUNTERVALUE_ITEM_A;
  204.   {$EXTERNALSYM PPDH_FMT_COUNTERVALUE_ITEM_A}
  205.   _PDH_FMT_COUNTERVALUE_ITEM_A = record
  206.     szName: LPSTR;
  207.     FmtValue: PDH_FMT_COUNTERVALUE;
  208.   end;
  209.   {$EXTERNALSYM _PDH_FMT_COUNTERVALUE_ITEM_A}
  210.   PDH_FMT_COUNTERVALUE_ITEM_A = _PDH_FMT_COUNTERVALUE_ITEM_A;
  211.   {$EXTERNALSYM PDH_FMT_COUNTERVALUE_ITEM_A}
  212.   TPdhFmtCounterValueItemA = PDH_FMT_COUNTERVALUE_ITEM_A;
  213.   PPdhFmtCounterValueItemA = PPDH_FMT_COUNTERVALUE_ITEM_A;
  215.   PPDH_FMT_COUNTERVALUE_ITEM_W = ^PDH_FMT_COUNTERVALUE_ITEM_W;
  216.   {$EXTERNALSYM PPDH_FMT_COUNTERVALUE_ITEM_W}
  217.   _PDH_FMT_COUNTERVALUE_ITEM_W = record
  218.     szName: LPWSTR;
  219.     FmtValue: PDH_FMT_COUNTERVALUE;
  220.   end;
  221.   {$EXTERNALSYM _PDH_FMT_COUNTERVALUE_ITEM_W}
  222.   PDH_FMT_COUNTERVALUE_ITEM_W = _PDH_FMT_COUNTERVALUE_ITEM_W;
  223.   {$EXTERNALSYM PDH_FMT_COUNTERVALUE_ITEM_W}
  224.   TPdhFmtCounterValueItemW = PDH_FMT_COUNTERVALUE_ITEM_W;
  225.   PPdhFmtCounterValueItemW = PPDH_FMT_COUNTERVALUE_ITEM_W;
  227. {$IFDEF UNICODE}
  228.   PPdhFmtCounterValueItem = PPdhFmtCounterValueItemW;
  229.   PDH_FMT_COUNTERVALUE_ITEM = _PDH_FMT_COUNTERVALUE_ITEM_W;
  230.   {$EXTERNALSYM PDH_FMT_COUNTERVALUE_ITEM}
  231.   PPDH_FMT_COUNTERVALUE_ITEM = PPDH_FMT_COUNTERVALUE_ITEM_W;
  232.   {$EXTERNALSYM PPDH_FMT_COUNTERVALUE_ITEM}
  233.   TPdhFmtCounterValueItem = _PDH_FMT_COUNTERVALUE_ITEM_W;
  234. {$ELSE}
  235.   PPdhFmtCounterValueItem = PPdhFmtCounterValueItemA;
  236.   PDH_FMT_COUNTERVALUE_ITEM = _PDH_FMT_COUNTERVALUE_ITEM_A;
  237.   {$EXTERNALSYM PDH_FMT_COUNTERVALUE_ITEM}
  238.   PPDH_FMT_COUNTERVALUE_ITEM = PPDH_FMT_COUNTERVALUE_ITEM_A;
  239.   {$EXTERNALSYM PPDH_FMT_COUNTERVALUE_ITEM}
  240.   TPdhFmtCounterValueItem = _PDH_FMT_COUNTERVALUE_ITEM_A;
  241. {$ENDIF}
  243.   PPDH_STATISTICS = ^PDH_STATISTICS;
  244.   {$EXTERNALSYM PPDH_STATISTICS}
  245.   _PDH_STATISTICS = record
  246.     dwFormat: DWORD;
  247.     Count: DWORD;
  248.     min: PDH_FMT_COUNTERVALUE;
  249.     max: PDH_FMT_COUNTERVALUE;
  250.     mean: PDH_FMT_COUNTERVALUE;
  251.   end;
  252.   {$EXTERNALSYM _PDH_STATISTICS}
  253.   PDH_STATISTICS = _PDH_STATISTICS;
  254.   {$EXTERNALSYM PDH_STATISTICS}
  255.   TPdhStatistics = PDH_STATISTICS;
  256.   PPdhStatistics = PPDH_STATISTICS;
  258.   PPDH_COUNTER_PATH_ELEMENTS_A = ^PDH_COUNTER_PATH_ELEMENTS_A;
  259.   {$EXTERNALSYM PPDH_COUNTER_PATH_ELEMENTS_A}
  260.   _PDH_COUNTER_PATH_ELEMENTS_A = record
  261.     szMachineName: LPSTR;
  262.     szObjectName: LPSTR;
  263.     szInstanceName: LPSTR;
  264.     szParentInstance: LPSTR;
  265.     dwInstanceIndex: DWORD;
  266.     szCounterName: LPSTR;
  267.   end;
  268.   {$EXTERNALSYM _PDH_COUNTER_PATH_ELEMENTS_A}
  269.   PDH_COUNTER_PATH_ELEMENTS_A = _PDH_COUNTER_PATH_ELEMENTS_A;
  270.   {$EXTERNALSYM PDH_COUNTER_PATH_ELEMENTS_A}
  271.   TPdhCounterPathElementsA = PDH_COUNTER_PATH_ELEMENTS_A;
  272.   PPdhCounterPathElementsA = PPDH_COUNTER_PATH_ELEMENTS_A;
  274.   PPDH_COUNTER_PATH_ELEMENTS_W = ^PDH_COUNTER_PATH_ELEMENTS_W;
  275.   {$EXTERNALSYM PPDH_COUNTER_PATH_ELEMENTS_W}
  276.   _PDH_COUNTER_PATH_ELEMENTS_W = record
  277.     szMachineName: LPWSTR;
  278.     szObjectName: LPWSTR;
  279.     szInstanceName: LPWSTR;
  280.     szParentInstance: LPWSTR;
  281.     dwInstanceIndex: DWORD;
  282.     szCounterName: LPWSTR;
  283.   end;
  284.   {$EXTERNALSYM _PDH_COUNTER_PATH_ELEMENTS_W}
  285.   PDH_COUNTER_PATH_ELEMENTS_W = _PDH_COUNTER_PATH_ELEMENTS_W;
  286.   {$EXTERNALSYM PDH_COUNTER_PATH_ELEMENTS_W}
  287.   TPdhCounterPathElementsW = PDH_COUNTER_PATH_ELEMENTS_W;
  288.   PPdhCounterPathElementsW = PPDH_COUNTER_PATH_ELEMENTS_W;
  290. {$IFDEF UNICODE}
  291.   PPdhCounterPathElements = PPdhCounterPathElementsW;
  292.   PDH_COUNTER_PATH_ELEMENTS = _PDH_COUNTER_PATH_ELEMENTS_W;
  293.   {$EXTERNALSYM PDH_COUNTER_PATH_ELEMENTS}
  294.   PPDH_COUNTER_PATH_ELEMENTS = PPDH_COUNTER_PATH_ELEMENTS_W;
  295.   {$EXTERNALSYM PPDH_COUNTER_PATH_ELEMENTS}
  296.   TPdhCounterPathElements = _PDH_COUNTER_PATH_ELEMENTS_W;
  297. {$ELSE}
  298.   PPdhCounterPathElements = PPdhCounterPathElementsA;
  299.   PDH_COUNTER_PATH_ELEMENTS = _PDH_COUNTER_PATH_ELEMENTS_A;
  300.   {$EXTERNALSYM PDH_COUNTER_PATH_ELEMENTS}
  301.   PPDH_COUNTER_PATH_ELEMENTS = PPDH_COUNTER_PATH_ELEMENTS_A;
  302.   {$EXTERNALSYM PPDH_COUNTER_PATH_ELEMENTS}
  303.   TPdhCounterPathElements = _PDH_COUNTER_PATH_ELEMENTS_A;
  304. {$ENDIF}
  306.   PPDH_DATA_ITEM_PATH_ELEMENTS_A = ^PDH_DATA_ITEM_PATH_ELEMENTS_A;
  307.   {$EXTERNALSYM PPDH_DATA_ITEM_PATH_ELEMENTS_A}
  308.   _PDH_DATA_ITEM_PATH_ELEMENTS_A = record
  309.     szMachineName: LPSTR;
  310.     ObjectGUID: GUID;
  311.     dwItemId: DWORD;
  312.     szInstanceName: LPSTR;
  313.   end;
  314.   {$EXTERNALSYM _PDH_DATA_ITEM_PATH_ELEMENTS_A}
  315.   PDH_DATA_ITEM_PATH_ELEMENTS_A = _PDH_DATA_ITEM_PATH_ELEMENTS_A;
  316.   {$EXTERNALSYM PDH_DATA_ITEM_PATH_ELEMENTS_A}
  317.   TPdhDataItemPathElementsA = PDH_DATA_ITEM_PATH_ELEMENTS_A;
  318.   PPdhDataItemPathElementsA = PPDH_DATA_ITEM_PATH_ELEMENTS_A;
  320.   PPDH_DATA_ITEM_PATH_ELEMENTS_W = ^PDH_DATA_ITEM_PATH_ELEMENTS_W;
  321.   {$EXTERNALSYM PPDH_DATA_ITEM_PATH_ELEMENTS_W}
  322.   _PDH_DATA_ITEM_PATH_ELEMENTS_W = record
  323.     szMachineName: LPWSTR;
  324.     ObjectGUID: GUID;
  325.     dwItemId: DWORD;
  326.     szInstanceName: LPWSTR;
  327.   end;
  328.   {$EXTERNALSYM _PDH_DATA_ITEM_PATH_ELEMENTS_W}
  329.   PDH_DATA_ITEM_PATH_ELEMENTS_W = _PDH_DATA_ITEM_PATH_ELEMENTS_W;
  330.   {$EXTERNALSYM PDH_DATA_ITEM_PATH_ELEMENTS_W}
  331.   TPdhDataItemPathElementsW = PDH_DATA_ITEM_PATH_ELEMENTS_W;
  332.   PPdhDataItemPathElementsW = PPDH_DATA_ITEM_PATH_ELEMENTS_W;
  334. {$IFDEF UNICODE}
  335.   PPdhDataItemPathElements = PPdhDataItemPathElementsW;
  336.   PDH_DATA_ITEM_PATH_ELEMENTS = _PDH_DATA_ITEM_PATH_ELEMENTS_W;
  337.   {$EXTERNALSYM PDH_DATA_ITEM_PATH_ELEMENTS}
  338.   PPDH_DATA_ITEM_PATH_ELEMENTS = PPDH_DATA_ITEM_PATH_ELEMENTS_W;
  339.   {$EXTERNALSYM PPDH_DATA_ITEM_PATH_ELEMENTS}
  340.   TPdhDataItemPathElements = _PDH_DATA_ITEM_PATH_ELEMENTS_W;
  341. {$ELSE}
  342.   PPdhDataItemPathElements = PPdhDataItemPathElementsA;
  343.   PDH_DATA_ITEM_PATH_ELEMENTS = _PDH_DATA_ITEM_PATH_ELEMENTS_A;
  344.   {$EXTERNALSYM PDH_DATA_ITEM_PATH_ELEMENTS}
  345.   PPDH_DATA_ITEM_PATH_ELEMENTS = PPDH_DATA_ITEM_PATH_ELEMENTS_A;
  346.   {$EXTERNALSYM PPDH_DATA_ITEM_PATH_ELEMENTS}
  347.   TPdhDataItemPathElements = _PDH_DATA_ITEM_PATH_ELEMENTS_A;
  348. {$ENDIF}
  350.   PPDH_COUNTER_INFO_A = ^PDH_COUNTER_INFO_A;
  351.   {$EXTERNALSYM PPDH_COUNTER_INFO_A}
  352.   _PDH_COUNTER_INFO_A = record
  353.     dwLength: DWORD;
  354.     dwType: DWORD;
  355.     CVersion: DWORD;
  356.     CStatus: DWORD;
  357.     lScale: LONG;
  358.     lDefaultScale: LONG;
  359.     dwUserData: DWORD_PTR;
  360.     dwQueryUserData: DWORD_PTR;
  361.     szFullPath: LPSTR;
  362.     Union: record
  363.       case Longint of
  364.         1: (DataItemPath: PDH_DATA_ITEM_PATH_ELEMENTS_A);
  365.         2: (CounterPath: PDH_COUNTER_PATH_ELEMENTS_A);
  366.         3: (szMachineName: LPSTR;
  367.             szObjectName: LPSTR;
  368.             szInstanceName: LPSTR;
  369.             szParentInstance: LPSTR;
  370.             dwInstanceIndex: DWORD;
  371.             szCounterName: LPSTR);
  372.     end;
  373.     szExplainText: LPSTR;
  374.     DataBuffer: array [0..0] of DWORD;
  375.   end;
  376.   {$EXTERNALSYM _PDH_COUNTER_INFO_A}
  377.   PDH_COUNTER_INFO_A = _PDH_COUNTER_INFO_A;
  378.   {$EXTERNALSYM PDH_COUNTER_INFO_A}
  379.   TPdhCounterInfoA = PDH_COUNTER_INFO_A;
  380.   PPdhCounterInfoA = PPDH_COUNTER_INFO_A;
  382.   PPDH_COUNTER_INFO_W = ^PDH_COUNTER_INFO_W;
  383.   {$EXTERNALSYM PPDH_COUNTER_INFO_W}
  384.   _PDH_COUNTER_INFO_W = record
  385.     dwLength: DWORD;
  386.     dwType: DWORD;
  387.     CVersion: DWORD;
  388.     CStatus: DWORD;
  389.     lScale: LONG;
  390.     lDefaultScale: LONG;
  391.     dwUserData: DWORD_PTR;
  392.     dwQueryUserData: DWORD_PTR;
  393.     szFullPath: LPWSTR;
  394.     Union: record
  395.       case Longint of
  396.         1: (DataItemPath: PDH_DATA_ITEM_PATH_ELEMENTS_W);
  397.         2: (CounterPath: PDH_COUNTER_PATH_ELEMENTS_W);
  398.         3: (szMachineName: LPWSTR;
  399.             szObjectName: LPWSTR;
  400.             szInstanceName: LPWSTR;
  401.             szParentInstance: LPWSTR;
  402.             dwInstanceIndex: DWORD;
  403.             szCounterName: LPWSTR);
  404.     end;
  405.     szExplainText: LPWSTR;
  406.     DataBuffer: array [0..0] of DWORD;
  407.   end;
  408.   {$EXTERNALSYM _PDH_COUNTER_INFO_W}
  409.   PDH_COUNTER_INFO_W = _PDH_COUNTER_INFO_W;
  410.   {$EXTERNALSYM PDH_COUNTER_INFO_W}
  411.   TPdhCounterInfoW = PDH_COUNTER_INFO_W;
  412.   PPdhCounterInfoW = PPDH_COUNTER_INFO_W;
  414. {$IFDEF UNICODE}
  415.   PPdhCounterInfo = PPdhCounterInfoW;
  416.   PDH_COUNTER_INFO = _PDH_COUNTER_INFO_W;
  417.   {$EXTERNALSYM PDH_COUNTER_INFO}
  418.   PPDH_COUNTER_INFO = PPDH_COUNTER_INFO_W;
  419.   {$EXTERNALSYM PPDH_COUNTER_INFO}
  420.   TPdhCounterInfo = _PDH_COUNTER_INFO_W;
  421. {$ELSE}
  422.   PPdhCounterInfo = PPdhCounterInfoA;
  423.   PDH_COUNTER_INFO = _PDH_COUNTER_INFO_A;
  424.   {$EXTERNALSYM PDH_COUNTER_INFO}
  425.   PPDH_COUNTER_INFO = PPDH_COUNTER_INFO_A;
  426.   {$EXTERNALSYM PPDH_COUNTER_INFO}
  427.   TPdhCounterInfo = _PDH_COUNTER_INFO_A;
  428. {$ENDIF}
  430.   PPDH_TIME_INFO = ^PDH_TIME_INFO;
  431.   {$EXTERNALSYM PPDH_TIME_INFO}
  432.   _PDH_TIME_INFO = record
  433.     StartTime: LONGLONG;
  434.     EndTime: LONGLONG;
  435.     SampleCount: DWORD;
  436.   end;
  437.   {$EXTERNALSYM _PDH_TIME_INFO}
  438.   PDH_TIME_INFO = _PDH_TIME_INFO;
  439.   {$EXTERNALSYM PDH_TIME_INFO}
  440.   TPdhTimeInfo = PDH_TIME_INFO;
  441.   PPdhTimeInfo = PPDH_TIME_INFO;
  443.   PPDH_RAW_LOG_RECORD = ^PDH_RAW_LOG_RECORD;
  444.   {$EXTERNALSYM PPDH_RAW_LOG_RECORD}
  445.   _PDH_RAW_LOG_RECORD = record
  446.     dwStructureSize: DWORD;
  447.     dwRecordType: DWORD;
  448.     dwItems: DWORD;
  449.     RawBytes: array [0..0] of UCHAR;
  450.   end;
  451.   {$EXTERNALSYM _PDH_RAW_LOG_RECORD}
  452.   PDH_RAW_LOG_RECORD = _PDH_RAW_LOG_RECORD;
  453.   {$EXTERNALSYM PDH_RAW_LOG_RECORD}
  454.   TPdhRawLogRecord = PDH_RAW_LOG_RECORD;
  455.   PPdhRawLogRecord = PPDH_RAW_LOG_RECORD;
  457.   PPDH_LOG_SERVICE_QUERY_INFO_A = ^PDH_LOG_SERVICE_QUERY_INFO_A;
  458.   {$EXTERNALSYM PPDH_LOG_SERVICE_QUERY_INFO_A}
  459.   _PDH_LOG_SERVICE_QUERY_INFO_A = record
  460.     dwSize: DWORD;
  461.     dwFlags: DWORD;
  462.     dwLogQuota: DWORD;
  463.     szLogFileCaption: LPSTR;
  464.     szDefaultDir: LPSTR;
  465.     szBaseFileName: LPSTR;
  466.     dwFileType: DWORD;
  467.     dwReserved: DWORD;
  468.     Union: record
  469.       case Longint of
  470.       1: (PdlAutoNameInterval: DWORD;
  471.           PdlAutoNameUnits: DWORD;
  472.           PdlCommandFilename: LPSTR;
  473.           PdlCounterList: LPSTR;
  474.           PdlAutoNameFormat: DWORD;
  475.           PdlSampleInterval: DWORD;
  476.           PdlLogStartTime: FILETIME;
  477.           PdlLogEndTime: FILETIME);
  478.       2: (TlNumberOfBuffers: DWORD;
  479.           TlMinimumBuffers: DWORD;
  480.           TlMaximumBuffers: DWORD;
  481.           TlFreeBuffers: DWORD;
  482.           TlBufferSize: DWORD;
  483.           TlEventsLost: DWORD;
  484.           TlLoggerThreadId: DWORD;
  485.           TlBuffersWritten: DWORD;
  486.           TlLogHandle: DWORD;
  487.           TlLogFileName: LPSTR);
  488.     end;
  489.   end;
  490.   {$EXTERNALSYM _PDH_LOG_SERVICE_QUERY_INFO_A}
  491.   PDH_LOG_SERVICE_QUERY_INFO_A = _PDH_LOG_SERVICE_QUERY_INFO_A;
  492.   {$EXTERNALSYM _PDH_LOG_SERVICE_QUERY_INFO_A}
  493.   TPdhLogServiceQueryInfoA = PDH_LOG_SERVICE_QUERY_INFO_A;
  494.   PPdhLogServiceQueryInfoA = PPDH_LOG_SERVICE_QUERY_INFO_A;
  496.   PPDH_LOG_SERVICE_QUERY_INFO_W = ^PDH_LOG_SERVICE_QUERY_INFO_W;
  497.   {$EXTERNALSYM PPDH_LOG_SERVICE_QUERY_INFO_W}
  498.   _PDH_LOG_SERVICE_QUERY_INFO_W = record
  499.     dwSize: DWORD;
  500.     dwFlags: DWORD;
  501.     dwLogQuota: DWORD;
  502.     szLogFileCaption: LPWSTR;
  503.     szDefaultDir: LPWSTR;
  504.     szBaseFileName: LPWSTR;
  505.     dwFileType: DWORD;
  506.     dwReserved: DWORD;
  507.     Union: record
  508.       case Longint of
  509.       1: (PdlAutoNameInterval: DWORD;
  510.           PdlAutoNameUnits: DWORD;
  511.           PdlCommandFilename: LPWSTR;
  512.           PdlCounterList: LPWSTR;
  513.           PdlAutoNameFormat: DWORD;
  514.           PdlSampleInterval: DWORD;
  515.           PdlLogStartTime: FILETIME;
  516.           PdlLogEndTime: FILETIME);
  517.       2: (TlNumberOfBuffers: DWORD;
  518.           TlMinimumBuffers: DWORD;
  519.           TlMaximumBuffers: DWORD;
  520.           TlFreeBuffers: DWORD;
  521.           TlBufferSize: DWORD;
  522.           TlEventsLost: DWORD;
  523.           TlLoggerThreadId: DWORD;
  524.           TlBuffersWritten: DWORD;
  525.           TlLogHandle: DWORD;
  526.           TlLogFileName: LPWSTR);
  527.     end;
  528.   end;
  529.   {$EXTERNALSYM _PDH_LOG_SERVICE_QUERY_INFO_W}
  530.   PDH_LOG_SERVICE_QUERY_INFO_W = _PDH_LOG_SERVICE_QUERY_INFO_W;
  531.   {$EXTERNALSYM PDH_LOG_SERVICE_QUERY_INFO_W}
  532.   TPdhLogServiceQueryInfoW = PDH_LOG_SERVICE_QUERY_INFO_W;
  533.   PPdhLogServiceQueryInfoW = PPDH_LOG_SERVICE_QUERY_INFO_W;
  535. {$IFDEF UNICODE}
  536.   PPdhLogServiceQueryInfo = PPdhLogServiceQueryInfoW;
  537.   PDH_LOG_SERVICE_QUERY_INFO = _PDH_LOG_SERVICE_QUERY_INFO_W;
  538.   {$EXTERNALSYM PDH_LOG_SERVICE_QUERY_INFO}
  539.   PPDH_LOG_SERVICE_QUERY_INFO = PPDH_LOG_SERVICE_QUERY_INFO_W;
  540.   {$EXTERNALSYM PPDH_LOG_SERVICE_QUERY_INFO}
  541.   TPdhLogServiceQueryInfo = _PDH_LOG_SERVICE_QUERY_INFO_W;
  542. {$ELSE}
  543.   PPdhLogServiceQueryInfo = PPdhLogServiceQueryInfoA;
  544.   PDH_LOG_SERVICE_QUERY_INFO = _PDH_LOG_SERVICE_QUERY_INFO_A;
  545.   {$EXTERNALSYM PDH_LOG_SERVICE_QUERY_INFO}
  546.   PPDH_LOG_SERVICE_QUERY_INFO = PPDH_LOG_SERVICE_QUERY_INFO_A;
  547.   {$EXTERNALSYM PPDH_LOG_SERVICE_QUERY_INFO}
  548.   TPdhLogServiceQueryInfo = _PDH_LOG_SERVICE_QUERY_INFO_A;
  549. {$ENDIF}
  551. //
  552. //  Time value constants
  553. //
  555. const
  556.   MAX_TIME_VALUE = LONGLONG($7FFFFFFFFFFFFFFF);
  557.   {$EXTERNALSYM MAX_TIME_VALUE}
  558.   MIN_TIME_VALUE = LONGLONG(0);
  559.   {$EXTERNALSYM MIN_TIME_VALUE}
  561. // function definitions
  563. function PdhGetDllVersion(var lpdwVersion: DWORD): PDH_STATUS; stdcall;
  564. {$EXTERNALSYM PdhGetDllVersion}
  566. //
  567. //  Query Functions
  568. //
  570. function PdhOpenQueryA(szDataSource: LPCSTR; dwUserData: DWORD_PTR;
  571.   var phQuery: PDH_HQUERY): PDH_STATUS; stdcall;
  572. {$EXTERNALSYM PdhOpenQueryA}
  573. function PdhOpenQueryW(szDataSource: LPCWSTR; dwUserData: DWORD_PTR;
  574.   var phQuery: PDH_HQUERY): PDH_STATUS; stdcall;
  575. {$EXTERNALSYM PdhOpenQueryW}
  577. {$IFDEF UNICODE}
  578. function PdhOpenQuery(szDataSource: LPCWSTR; dwUserData: DWORD_PTR;
  579.   var phQuery: PDH_HQUERY): PDH_STATUS; stdcall;
  580. {$EXTERNALSYM PdhOpenQuery}
  581. {$ELSE}
  582. function PdhOpenQuery(szDataSource: LPCSTR; dwUserData: DWORD_PTR;
  583.   var phQuery: PDH_HQUERY): PDH_STATUS; stdcall;
  584. {$EXTERNALSYM PdhOpenQuery}
  585. {$ENDIF}
  587. function PdhAddCounterA(hQuery: PDH_HQUERY; szFullCounterPath: LPCSTR;
  588.   dwUserData: DWORD_PTR; var phCounter: PDH_HCOUNTER): PDH_STATUS; stdcall;
  589. {$EXTERNALSYM PdhAddCounterA}
  590. function PdhAddCounterW(hQuery: PDH_HQUERY; szFullCounterPath: LPCWSTR;
  591.   dwUserData: DWORD_PTR; var phCounter: PDH_HCOUNTER): PDH_STATUS; stdcall;
  592. {$EXTERNALSYM PdhAddCounterW}
  594. {$IFDEF UNICODE}
  595. function PdhAddCounter(hQuery: PDH_HQUERY; szFullCounterPath: LPCWSTR;
  596.   dwUserData: DWORD_PTR; var phCounter: PDH_HCOUNTER): PDH_STATUS; stdcall;
  597. {$EXTERNALSYM PdhAddCounter}
  598. {$ELSE}
  599. function PdhAddCounter(hQuery: PDH_HQUERY; szFullCounterPath: LPCSTR;
  600.   dwUserData: DWORD_PTR; var phCounter: PDH_HCOUNTER): PDH_STATUS; stdcall;
  601. {$EXTERNALSYM PdhAddCounter}
  602. {$ENDIF}
  604. function PdhRemoveCounter(hCounter: PDH_HCOUNTER): PDH_STATUS; stdcall;
  605. {$EXTERNALSYM PdhRemoveCounter}
  607. function PdhCollectQueryData(hQuery: PDH_HQUERY): PDH_STATUS; stdcall;
  608. {$EXTERNALSYM PdhCollectQueryData}
  610. function PdhCloseQuery(hQuery: PDH_HQUERY): PDH_STATUS; stdcall;
  611. {$EXTERNALSYM PdhCloseQuery}
  613. //
  614. //  Counter Functions
  615. //
  617. function PdhGetFormattedCounterValue(hCounter: PDH_HCOUNTER; dwFormat: DWORD;
  618.   lpdwType: LPDWORD; var pValue: PDH_FMT_COUNTERVALUE): PDH_STATUS; stdcall;
  619. {$EXTERNALSYM PdhGetFormattedCounterValue}
  621. function PdhGetFormattedCounterArrayA(hCounter: PDH_HCOUNTER; dwFormat: DWORD;
  622.   var lpdwBufferSize, lpdwItemCount: DWORD;
  623.   var ItemBuffer: PDH_FMT_COUNTERVALUE_ITEM_A): PDH_STATUS; stdcall;
  624. {$EXTERNALSYM PdhGetFormattedCounterArrayA}
  625. function PdhGetFormattedCounterArrayW(hCounter: PDH_HCOUNTER; dwFormat: DWORD;
  626.   var lpdwBufferSize, lpdwItemCount: DWORD;
  627.   var ItemBuffer: PDH_FMT_COUNTERVALUE_ITEM_W): PDH_STATUS; stdcall;
  628. {$EXTERNALSYM PdhGetFormattedCounterArrayW}
  630. {$IFDEF UNICODE}
  631. function PdhGetFormattedCounterArray(hCounter: PDH_HCOUNTER; dwFormat: DWORD;
  632.   var lpdwBufferSize, lpdwItemCount: DWORD;
  633.   var ItemBuffer: PDH_FMT_COUNTERVALUE_ITEM_W): PDH_STATUS; stdcall;
  634. {$EXTERNALSYM PdhGetFormattedCounterArray}
  635. {$ELSE}
  636. function PdhGetFormattedCounterArray(hCounter: PDH_HCOUNTER; dwFormat: DWORD;
  637.   var lpdwBufferSize, lpdwItemCount: DWORD;
  638.   var ItemBuffer: PDH_FMT_COUNTERVALUE_ITEM_A): PDH_STATUS; stdcall;
  639. {$EXTERNALSYM PdhGetFormattedCounterArray}
  640. {$ENDIF}
  642. // dwFormat flag values
  644. const
  645.   PDH_FMT_RAW      = DWORD($00000010);
  646.   {$EXTERNALSYM PDH_FMT_RAW}
  647.   PDH_FMT_ANSI     = DWORD($00000020);
  648.   {$EXTERNALSYM PDH_FMT_ANSI}
  649.   PDH_FMT_UNICODE  = DWORD($00000040);
  650.   {$EXTERNALSYM PDH_FMT_UNICODE}
  651.   PDH_FMT_LONG     = DWORD($00000100);
  652.   {$EXTERNALSYM PDH_FMT_LONG}
  653.   PDH_FMT_DOUBLE   = DWORD($00000200);
  654.   {$EXTERNALSYM PDH_FMT_DOUBLE}
  655.   PDH_FMT_LARGE    = DWORD($00000400);
  656.   {$EXTERNALSYM PDH_FMT_LARGE}
  657.   PDH_FMT_NOSCALE  = DWORD($00001000);
  658.   {$EXTERNALSYM PDH_FMT_NOSCALE}
  659.   PDH_FMT_1000     = DWORD($00002000);
  660.   {$EXTERNALSYM PDH_FMT_1000}
  661.   PDH_FMT_NODATA   = DWORD($00004000);
  662.   {$EXTERNALSYM PDH_FMT_NODATA}
  663.   PDH_FMT_NOCAP100 = DWORD($00008000);
  664.   {$EXTERNALSYM PDH_FMT_NODATA}
  666.   PERF_DETAIL_COSTLY   = DWORD($00010000);
  667.   {$EXTERNALSYM PERF_DETAIL_COSTLY}
  668.   PERF_DETAIL_STANDARD = DWORD($0000FFFF);
  669.   {$EXTERNALSYM PERF_DETAIL_STANDARD}
  671. function PdhGetRawCounterValue(hCounter: PDH_HCOUNTER; lpdwType: LPDWORD;
  672.   var pValue: PDH_RAW_COUNTER): PDH_STATUS; stdcall;
  673. {$EXTERNALSYM PdhGetRawCounterValue}
  675. function PdhGetRawCounterArrayA(hCounter: PDH_HCOUNTER; var lpdwBufferSize,
  676.   lpdwItemCount: DWORD; var ItemBuffer: PDH_RAW_COUNTER_ITEM_A): PDH_STATUS; stdcall;
  677. {$EXTERNALSYM PdhGetRawCounterArrayA}
  678. function PdhGetRawCounterArrayW(hCounter: PDH_HCOUNTER; var lpdwBufferSize,
  679.   lpdwItemCount: DWORD; var ItemBuffer: PDH_RAW_COUNTER_ITEM_W): PDH_STATUS; stdcall;
  680. {$EXTERNALSYM PdhGetRawCounterArrayW}
  682. {$IFDEF UNICODE}
  683. function PdhGetRawCounterArray(hCounter: PDH_HCOUNTER; var lpdwBufferSize,
  684.   lpdwItemCount: DWORD; var ItemBuffer: PDH_RAW_COUNTER_ITEM_W): PDH_STATUS; stdcall;
  685. {$EXTERNALSYM PdhGetRawCounterArray}
  686. {$ELSE}
  687. function PdhGetRawCounterArray(hCounter: PDH_HCOUNTER; var lpdwBufferSize,
  688.   lpdwItemCount: DWORD; var ItemBuffer: PDH_RAW_COUNTER_ITEM_A): PDH_STATUS; stdcall;
  689. {$EXTERNALSYM PdhGetRawCounterArray}
  690. {$ENDIF}
  692. function PdhCalculateCounterFromRawValue(hCounter: PDH_HCOUNTER; dwFormat: DWORD;
  693.   rawValue1, rawValue2: PPDH_RAW_COUNTER; var fmtValue: PDH_FMT_COUNTERVALUE): PDH_STATUS; stdcall;
  694. {$EXTERNALSYM PdhCalculateCounterFromRawValue}
  696. function PdhComputeCounterStatistics(hCounter: PDH_HCOUNTER; dwFormat, dwFirstEntry,
  697.   dwNumEntries: DWORD; lpRawValueArray: PPDH_RAW_COUNTER; var data: PDH_STATISTICS): PDH_STATUS; stdcall;
  698. {$EXTERNALSYM PdhComputeCounterStatistics}
  700. function PdhGetCounterInfoA(hCounter: PDH_HCOUNTER; bRetrieveExplainText: Boolean;
  701.   var pdwBufferSize: DWORD; lpBuffer: PPDH_COUNTER_INFO_A): PDH_STATUS; stdcall;
  702. {$EXTERNALSYM PdhGetCounterInfoA}
  703. function PdhGetCounterInfoW(hCounter: PDH_HCOUNTER; bRetrieveExplainText: Boolean;
  704.   var pdwBufferSize: DWORD; lpBuffer: PPDH_COUNTER_INFO_W): PDH_STATUS; stdcall;
  705. {$EXTERNALSYM PdhGetCounterInfoW}
  707. {$IFDEF UNICODE}
  708. function PdhGetCounterInfo(hCounter: PDH_HCOUNTER; bRetrieveExplainText: Boolean;
  709.   var pdwBufferSize: DWORD; lpBuffer: PPDH_COUNTER_INFO_W): PDH_STATUS; stdcall;
  710. {$EXTERNALSYM PdhGetCounterInfo}
  711. {$ELSE}
  712. function PdhGetCounterInfo(hCounter: PDH_HCOUNTER; bRetrieveExplainText: Boolean;
  713.   var pdwBufferSize: DWORD; lpBuffer: PPDH_COUNTER_INFO_A): PDH_STATUS; stdcall;
  714. {$EXTERNALSYM PdhGetCounterInfo}
  715. {$ENDIF}
  717. const
  718.   PDH_MAX_SCALE = Longint(7);
  719.   {$EXTERNALSYM PDH_MAX_SCALE}
  720.   PDH_MIN_SCALE = Longint(-7);
  721.   {$EXTERNALSYM PDH_MIN_SCALE}
  723. function PdhSetCounterScaleFactor(hCounter: PDH_HCOUNTER; lFactor: LONG): PDH_STATUS; stdcall;
  724. {$EXTERNALSYM PdhSetCounterScaleFactor}
  726. //
  727. //   Browsing and enumeration functions
  728. //
  730. function PdhConnectMachineA(szMachineName: LPCSTR): PDH_STATUS; stdcall;
  731. {$EXTERNALSYM PdhConnectMachineA}
  732. function PdhConnectMachineW(szMachineName: LPCWSTR): PDH_STATUS; stdcall;
  733. {$EXTERNALSYM PdhConnectMachineW}
  735. {$IFDEF UNICODE}
  736. function PdhConnectMachine(szMachineName: LPCWSTR): PDH_STATUS; stdcall;
  737. {$EXTERNALSYM PdhConnectMachine}
  738. {$ELSE}
  739. function PdhConnectMachine(szMachineName: LPCSTR): PDH_STATUS; stdcall;
  740. {$EXTERNALSYM PdhConnectMachine}
  741. {$ENDIF}
  743. function PdhEnumMachinesA(szDataSource: LPCSTR; mszMachineList: LPSTR;
  744.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  745. {$EXTERNALSYM PdhEnumMachinesA}
  746. function PdhEnumMachinesW(szDataSource: LPCWSTR; mszMachineList: LPWSTR;
  747.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  748. {$EXTERNALSYM PdhEnumMachinesW}
  750. {$IFDEF UNICODE}
  751. function PdhEnumMachines(szDataSource: LPCWSTR; mszMachineList: LPWSTR;
  752.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  753. {$EXTERNALSYM PdhEnumMachines}
  754. {$ELSE}
  755. function PdhEnumMachines(szDataSource: LPCSTR; mszMachineList: LPSTR;
  756.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  757. {$EXTERNALSYM PdhEnumMachines}
  758. {$ENDIF}
  760. function PdhEnumObjectsA(szDataSource, szMachineName: LPCSTR; mszObjectList: LPSTR;
  761.   var pcchBufferSize: DWORD; dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  762. {$EXTERNALSYM PdhEnumObjectsA}
  763. function PdhEnumObjectsW(szDataSource, szMachineName: LPCWSTR; mszObjectList: LPWSTR;
  764.   var pcchBufferSize: DWORD; dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  765. {$EXTERNALSYM PdhEnumObjectsW}
  767. {$IFDEF UNICODE}
  768. function PdhEnumObjects(szDataSource, szMachineName: LPCWSTR; mszObjectList: LPWSTR;
  769.   var pcchBufferSize: DWORD; dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  770. {$EXTERNALSYM PdhEnumObjects}
  771. {$ELSE}
  772. function PdhEnumObjects(szDataSource, szMachineName: LPCSTR; mszObjectList: LPSTR;
  773.   var pcchBufferSize: DWORD; dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  774. {$EXTERNALSYM PdhEnumObjects}
  775. {$ENDIF}
  777. function PdhEnumObjectItemsA(szDataSource, szMachineName, szObjectName: LPCSTR;
  778.   mszCounterList: LPSTR; var pcchCounterListLength: DWORD; mszInstanceList: LPSTR;
  779.   var pcchInstanceListLength: DWORD; dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  780. {$EXTERNALSYM PdhEnumObjectItemsA}
  781. function PdhEnumObjectItemsW(szDataSource, szMachineName, szObjectName: LPCWSTR;
  782.   mszCounterList: LPWSTR; var pcchCounterListLength: DWORD; mszInstanceList: LPWSTR;
  783.   var pcchInstanceListLength: DWORD; dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  784. {$EXTERNALSYM PdhEnumObjectItemsW}
  786. {$IFDEF UNICODE}
  787. function PdhEnumObjectItems(szDataSource, szMachineName, szObjectName: LPCWSTR;
  788.   mszCounterList: LPWSTR; var pcchCounterListLength: DWORD; mszInstanceList: LPWSTR;
  789.   var pcchInstanceListLength: DWORD; dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  790. {$EXTERNALSYM PdhEnumObjectItems}
  791. {$ELSE}
  792. function PdhEnumObjectItems(szDataSource, szMachineName, szObjectName: LPCSTR;
  793.   mszCounterList: LPSTR; var pcchCounterListLength: DWORD; mszInstanceList: LPSTR;
  794.   var pcchInstanceListLength: DWORD; dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  795. {$EXTERNALSYM PdhEnumObjectItems}
  796. {$ENDIF}
  798. const
  799.   PDH_OBJECT_HAS_INSTANCES  = $00000001;
  800.   {$EXTERNALSYM PDH_OBJECT_HAS_INSTANCES}
  802. function PdhMakeCounterPathA(pCounterPathElements: PPDH_COUNTER_PATH_ELEMENTS_A;
  803.   szFullPathBuffer: LPSTR; var pcchBufferSize: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  804. {$EXTERNALSYM PdhMakeCounterPathA}
  805. function PdhMakeCounterPathW(pCounterPathElements: PPDH_COUNTER_PATH_ELEMENTS_W;
  806.   szFullPathBuffer: LPWSTR; var pcchBufferSize: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  807. {$EXTERNALSYM PdhMakeCounterPathW}
  809. {$IFDEF UNICODE}
  810. function PdhMakeCounterPath(pCounterPathElements: PPDH_COUNTER_PATH_ELEMENTS_W;
  811.   szFullPathBuffer: LPWSTR; var pcchBufferSize: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  812. {$EXTERNALSYM PdhMakeCounterPath}
  813. {$ELSE}
  814. function PdhMakeCounterPath(pCounterPathElements: PPDH_COUNTER_PATH_ELEMENTS_A;
  815.   szFullPathBuffer: LPSTR; var pcchBufferSize: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  816. {$EXTERNALSYM PdhMakeCounterPath}
  817. {$ENDIF}
  819. // todo shouldn't pCounterPathElements be a pointer to ...?
  821. function PdhParseCounterPathA(szFullPathBuffer: LPCSTR;
  822.   pCounterPathElements: PDH_COUNTER_PATH_ELEMENTS_A; var pdwBufferSize: DWORD;
  823.   dwFlags: DWORD): PDH_STATUS; stdcall;
  824. {$EXTERNALSYM PdhParseCounterPathA}
  825. function PdhParseCounterPathW(szFullPathBuffer: LPCWSTR;
  826.   pCounterPathElements: PDH_COUNTER_PATH_ELEMENTS_W; var pdwBufferSize: DWORD;
  827.   dwFlags: DWORD): PDH_STATUS; stdcall;
  828. {$EXTERNALSYM PdhParseCounterPathW}
  830. {$IFDEF UNICODE}
  831. function PdhParseCounterPath(szFullPathBuffer: LPCWSTR;
  832.   pCounterPathElements: PDH_COUNTER_PATH_ELEMENTS_W; var pdwBufferSize: DWORD;
  833.   dwFlags: DWORD): PDH_STATUS; stdcall;
  834. {$EXTERNALSYM PdhParseCounterPath}
  835. {$ELSE}
  836. function PdhParseCounterPath(szFullPathBuffer: LPCSTR;
  837.   pCounterPathElements: PDH_COUNTER_PATH_ELEMENTS_A; var pdwBufferSize: DWORD;
  838.   dwFlags: DWORD): PDH_STATUS; stdcall;
  839. {$EXTERNALSYM PdhParseCounterPath}
  840. {$ENDIF}
  842. const
  843.   PDH_PATH_WBEM_RESULT       = DWORD($00000001);
  844.   {$EXTERNALSYM PDH_PATH_WBEM_RESULT}
  845.   PDH_PATH_WBEM_INPUT        = DWORD($00000002);
  846.   {$EXTERNALSYM PDH_PATH_WBEM_INPUT}
  848. function PDH_PATH_LANG_FLAGS(LangId, Flags: DWORD): DWORD;
  849. {$EXTERNALSYM PDH_PATH_LANG_FLAGS}
  851. function PdhParseInstanceNameA(szInstanceString: LPSTR; szInstanceName: LPCSTR;
  852.   var pcchInstanceNameLength: DWORD; szParentName: LPSTR;
  853.   var pcchParentNameLength: DWORD; lpIndex: LPDWORD): PDH_STATUS; stdcall;
  854. {$EXTERNALSYM PdhParseInstanceNameA}
  855. function PdhParseInstanceNameW(szInstanceString: LPWSTR; szInstanceName: LPCWSTR;
  856.   var pcchInstanceNameLength: DWORD; szParentName: LPWSTR;
  857.   var pcchParentNameLength: DWORD; lpIndex: LPDWORD): PDH_STATUS; stdcall;
  858. {$EXTERNALSYM PdhParseInstanceNameW}
  860. {$IFDEF UNICODE}
  861. function PdhParseInstanceName(szInstanceString: LPWSTR; szInstanceName: LPCWSTR;
  862.   var pcchInstanceNameLength: DWORD; szParentName: LPWSTR;
  863.   var pcchParentNameLength: DWORD; lpIndex: LPDWORD): PDH_STATUS; stdcall;
  864. {$EXTERNALSYM PdhParseInstanceName}
  865. {$ELSE}
  866. function PdhParseInstanceName(szInstanceString: LPSTR; szInstanceName: LPCSTR;
  867.   var pcchInstanceNameLength: DWORD; szParentName: LPSTR;
  868.   var pcchParentNameLength: DWORD; lpIndex: LPDWORD): PDH_STATUS; stdcall;
  869. {$EXTERNALSYM PdhParseInstanceName}
  870. {$ENDIF}
  872. function PdhValidatePathA(szFullPathBuffer: LPCSTR): PDH_STATUS; stdcall;
  873. {$EXTERNALSYM PdhValidatePathA}
  874. function PdhValidatePathW(szFullPathBuffer: LPCWSTR): PDH_STATUS; stdcall;
  875. {$EXTERNALSYM PdhValidatePathW}
  877. {$IFDEF UNICODE}
  878. function PdhValidatePath(szFullPathBuffer: LPCWSTR): PDH_STATUS; stdcall;
  879. {$EXTERNALSYM PdhValidatePath}
  880. {$ELSE}
  881. function PdhValidatePath(szFullPathBuffer: LPCSTR): PDH_STATUS; stdcall;
  882. {$EXTERNALSYM PdhValidatePath}
  883. {$ENDIF}
  885. function PdhGetDefaultPerfObjectA(szDataSource, szMachineName: LPCSTR;
  886.   szDefaultObjectName: LPSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  887. {$EXTERNALSYM PdhGetDefaultPerfObjectA}
  888. function PdhGetDefaultPerfObjectW(szDataSource, szMachineName: LPCWSTR;
  889.   szDefaultObjectName: LPWSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  890. {$EXTERNALSYM PdhGetDefaultPerfObjectW}
  892. {$IFDEF UNICODE}
  893. function PdhGetDefaultPerfObject(szDataSource, szMachineName: LPCWSTR;
  894.   szDefaultObjectName: LPWSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  895. {$EXTERNALSYM PdhGetDefaultPerfObject}
  896. {$ELSE}
  897. function PdhGetDefaultPerfObject(szDataSource, szMachineName: LPCSTR;
  898.   szDefaultObjectName: LPSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  899. {$EXTERNALSYM PdhGetDefaultPerfObject}
  900. {$ENDIF}
  902. function PdhGetDefaultPerfCounterA(szDataSource, szMachineName, szObjectName: LPCSTR;
  903.   szDefaultCounterName: LPSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  904. {$EXTERNALSYM PdhGetDefaultPerfCounterA}
  905. function PdhGetDefaultPerfCounterW(szDataSource, szMachineName, szObjectName: LPCWSTR;
  906.   szDefaultCounterName: LPWSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  907. {$EXTERNALSYM PdhGetDefaultPerfCounterW}
  909. {$IFDEF UNICODE}
  910. function PdhGetDefaultPerfCounter(szDataSource, szMachineName, szObjectName: LPCWSTR;
  911.   szDefaultCounterName: LPWSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  912. {$EXTERNALSYM PdhGetDefaultPerfCounter}
  913. {$ELSE}
  914. function PdhGetDefaultPerfCounter(szDataSource, szMachineName, szObjectName: LPCSTR;
  915.   szDefaultCounterName: LPSTR; var pcchBufferSize: DWORD): PDH_STATUS; stdcall;
  916. {$EXTERNALSYM PdhGetDefaultPerfCounter}
  917. {$ENDIF}
  919. type
  920.   CounterPathCallBack = function (dwArg: DWORD_PTR): PDH_STATUS; stdcall;
  921.   {$EXTERNALSYM CounterPathCallBack}
  923. const
  924.   PDH_CF_INCLUDEINSTANCEINDEX    = 1 shl 0;
  925.   PDH_CF_SINGLECOUNTERPERADD     = 1 shl 1;
  926.   PDH_CF_SINGLECOUNTERPERDIALOG  = 1 shl 2;
  927.   PDH_CF_LOCALCOUNTERSONLY       = 1 shl 3;
  928.   PDH_CF_WILDCARDINSTANCES       = 1 shl 4;
  929.   PDH_CF_HIDEDETAILBOX           = 1 shl 5;
  930.   PDH_CF_INITIALIZEPATH          = 1 shl 6;
  931.   PDH_CF_DISABLEMACHINESELECTION = 1 shl 7;
  932.   PDH_CF_INCLUDECOSTLYOBJECTS    = 1 shl 8;
  933.   PDH_CF_SHOWOBJECTBROWSER       = 1 shl 9;
  934.   PDH_CF_RESERVED                = DWORD($FFFFFD00);
  936. type
  937.   _BrowseDlgConfig_HW = record
  938.     // Configuration flags
  939.     dwConfigFlags: DWORD;
  940.     hWndOwner: HWND;
  941.     hDataSource: PDH_HLOG;
  942.     szReturnPathBuffer: LPWSTR;
  943.     cchReturnPathLength: DWORD;
  944.     pCallBack: CounterPathCallBack;
  945.     dwCallBackArg: DWORD_PTR;
  946.     CallBackStatus: PDH_STATUS;
  947.     dwDefaultDetailLevel: DWORD;
  948.     szDialogBoxCaption: LPWSTR;
  949.   end;
  950.   {$EXTERNALSYM _BrowseDlgConfig_HW}
  951.   PDH_BROWSE_DLG_CONFIG_HW = _BrowseDlgConfig_HW;
  952.   {$EXTERNALSYM PDH_BROWSE_DLG_CONFIG_HW}
  953.   PPDH_BROWSE_DLG_CONFIG_HW = ^PDH_BROWSE_DLG_CONFIG_HW;
  954.   {$EXTERNALSYM PPDH_BROWSE_DLG_CONFIG_HW}
  955.   TPdhBrowseDlgConfigHW = PDH_BROWSE_DLG_CONFIG_HW;
  956.   PPdhBrowseDlgConfigHW = PPDH_BROWSE_DLG_CONFIG_HW;
  958.   _BrowseDlgConfig_HA = record
  959.     // Configuration flags
  960.     dwConfigFlags: DWORD;
  961.     hWndOwner: HWND;
  962.     hDataSource: PDH_HLOG;
  963.     szReturnPathBuffer: LPSTR;
  964.     cchReturnPathLength: DWORD;
  965.     pCallBack: CounterPathCallBack;
  966.     dwCallBackArg: DWORD_PTR;
  967.     CallBackStatus: PDH_STATUS;
  968.     dwDefaultDetailLevel: DWORD;
  969.     szDialogBoxCaption: LPSTR;
  970.   end;
  971.   {$EXTERNALSYM _BrowseDlgConfig_HA}
  972.   PDH_BROWSE_DLG_CONFIG_HA = _BrowseDlgConfig_HA;
  973.   {$EXTERNALSYM PDH_BROWSE_DLG_CONFIG_HA}
  974.   PPDH_BROWSE_DLG_CONFIG_HA = ^PDH_BROWSE_DLG_CONFIG_HA;
  975.   {$EXTERNALSYM PPDH_BROWSE_DLG_CONFIG_HA}
  976.   TPdhBrowseDlGconfigHA = PDH_BROWSE_DLG_CONFIG_HA;
  977.   PPdhBrowseDlGconfigHA = PPDH_BROWSE_DLG_CONFIG_HA;
  979.   PPDH_BROWSE_DLG_CONFIG_A = ^_BrowseDlgConfig_A;
  980.   {$EXTERNALSYM PPDH_BROWSE_DLG_CONFIG_A}
  981.   _BrowseDlgConfig_A = record
  982.     dwConfigFlags: DWORD;
  983.     hWndOwner: HWND;
  984.     szDataSource: LPSTR;
  985.     szReturnPathBuffer: LPSTR;
  986.     cchReturnPathLength: DWORD;
  987.     pCallBack: CounterPathCallBack;
  988.     dwCallBackArg: DWORD_PTR;
  989.     CallBackStatus: PDH_STATUS;
  990.     dwDefaultDetailLevel: DWORD;
  991.     szDialogBoxCaption: LPSTR;
  992.   end;
  993.   {$EXTERNALSYM _BrowseDlgConfig_A}
  994.   PDH_BROWSE_DLG_CONFIG_A = _BrowseDlgConfig_A;
  995.   {$EXTERNALSYM PDH_BROWSE_DLG_CONFIG_A}
  996.   TPdhBrowseDlgConfigA = PDH_BROWSE_DLG_CONFIG_A;
  997.   PPdhBrowseDlgConfigA = PPDH_BROWSE_DLG_CONFIG_A;
  999.   PPDH_BROWSE_DLG_CONFIG_W = ^_BrowseDlgConfig_W;
  1000.   {$EXTERNALSYM PPDH_BROWSE_DLG_CONFIG_W}
  1001.   _BrowseDlgConfig_W = record
  1002.     dwConfigFlags: DWORD;
  1003.     hWndOwner: HWND;
  1004.     szDataSource: LPWSTR;
  1005.     szReturnPathBuffer: LPWSTR;
  1006.     cchReturnPathLength: DWORD;
  1007.     pCallBack: CounterPathCallBack;
  1008.     dwCallBackArg: DWORD_PTR;
  1009.     CallBackStatus: PDH_STATUS;
  1010.     dwDefaultDetailLevel: DWORD;
  1011.     szDialogBoxCaption: LPWSTR;
  1012.   end;
  1013.   {$EXTERNALSYM _BrowseDlgConfig_W}
  1014.   PDH_BROWSE_DLG_CONFIG_W = _BrowseDlgConfig_W;
  1015.   {$EXTERNALSYM PDH_BROWSE_DLG_CONFIG_W}
  1016.   TPdhBrowseDlgConfigW = PDH_BROWSE_DLG_CONFIG_W;
  1017.   PPdhBrowseDlgConfigW = PPDH_BROWSE_DLG_CONFIG_W;
  1019. {$IFDEF UNICODE}
  1020.   PPdhBrowseDlgConfig = PPdhBrowseDlgConfigW;
  1021.   PDH_BROWSE_DLG_CONFIG = PDH_BROWSE_DLG_CONFIG_W;
  1022.   {$EXTERNALSYM PDH_BROWSE_DLG_CONFIG}
  1023.   PPDH_BROWSE_DLG_CONFIG = PPDH_BROWSE_DLG_CONFIG_W;
  1024.   {$EXTERNALSYM PPDH_BROWSE_DLG_CONFIG}
  1025.   TPdhBrowseDlgConfig = TPdhBrowseDlgConfigW;
  1026. {$ELSE}
  1027.   PPdhBrowseDlgConfig = PPdhBrowseDlgConfigA;
  1028.   PDH_BROWSE_DLG_CONFIG = PDH_BROWSE_DLG_CONFIG_A;
  1029.   {$EXTERNALSYM PDH_BROWSE_DLG_CONFIG}
  1030.   PPDH_BROWSE_DLG_CONFIG = PPDH_BROWSE_DLG_CONFIG_A;
  1031.   {$EXTERNALSYM PPDH_BROWSE_DLG_CONFIG}
  1032.   TPdhBrowseDlgConfig = TPdhBrowseDlgConfigA;
  1033. {$ENDIF}
  1035. function PdhBrowseCountersA(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_A): PDH_STATUS; stdcall;
  1036. {$EXTERNALSYM PdhBrowseCountersA}
  1037. function PdhBrowseCountersW(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_W): PDH_STATUS; stdcall;
  1038. {$EXTERNALSYM PdhBrowseCountersW}
  1040. {$IFDEF UNICODE}
  1041. function PdhBrowseCounters(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_W): PDH_STATUS; stdcall;
  1042. {$EXTERNALSYM PdhBrowseCounters}
  1043. {$ELSE}
  1044. function PdhBrowseCounters(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_A): PDH_STATUS; stdcall;
  1045. {$EXTERNALSYM PdhBrowseCounters}
  1046. {$ENDIF}
  1048. function PdhExpandCounterPathA(szWildCardPath: LPCSTR; mszExpandedPathList: LPSTR;
  1049.   var pcchPathListLength: DWORD): PDH_STATUS; stdcall;
  1050. {$EXTERNALSYM PdhExpandCounterPathA}
  1051. function PdhExpandCounterPathW(szWildCardPath: LPCWSTR; mszExpandedPathList: LPWSTR;
  1052.   var pcchPathListLength: DWORD): PDH_STATUS; stdcall;
  1053. {$EXTERNALSYM PdhExpandCounterPathW}
  1055. {$IFDEF UNICODE}
  1056. function PdhExpandCounterPath(szWildCardPath: LPCWSTR; mszExpandedPathList: LPWSTR;
  1057.   var pcchPathListLength: DWORD): PDH_STATUS; stdcall;
  1058. {$EXTERNALSYM PdhExpandCounterPath}
  1059. {$ELSE}
  1060. function PdhExpandCounterPath(szWildCardPath: LPCSTR; mszExpandedPathList: LPSTR;
  1061.   var pcchPathListLength: DWORD): PDH_STATUS; stdcall;
  1062. {$EXTERNALSYM PdhExpandCounterPath}
  1063. {$ENDIF}
  1065. //
  1066. //  v2.0 functions
  1067. //
  1069. function PdhLookupPerfNameByIndexA(szMachineName: LPCSTR; dwNameIndex: DWORD;
  1070.   szNameBuffer: LPSTR; var pcchNameBufferSize: DWORD): PDH_STATUS; stdcall;
  1071. {$EXTERNALSYM PdhLookupPerfNameByIndexA}
  1072. function PdhLookupPerfNameByIndexW(szMachineName: LPCWSTR; dwNameIndex: DWORD;
  1073.   szNameBuffer: LPWSTR; var pcchNameBufferSize: DWORD): PDH_STATUS; stdcall;
  1074. {$EXTERNALSYM PdhLookupPerfNameByIndexW}
  1076. {$IFDEF UNICODE}
  1077. function PdhLookupPerfNameByIndex(szMachineName: LPCWSTR; dwNameIndex: DWORD;
  1078.   szNameBuffer: LPWSTR; var pcchNameBufferSize: DWORD): PDH_STATUS; stdcall;
  1079. {$EXTERNALSYM PdhLookupPerfNameByIndex}
  1080. {$ELSE}
  1081. function PdhLookupPerfNameByIndex(szMachineName: LPCSTR; dwNameIndex: DWORD;
  1082.   szNameBuffer: LPSTR; var pcchNameBufferSize: DWORD): PDH_STATUS; stdcall;
  1083. {$EXTERNALSYM PdhLookupPerfNameByIndex}
  1084. {$ENDIF}
  1086. function PdhLookupPerfIndexByNameA(szMachineName, szNameBuffer: LPCSTR;
  1087.   var pdwIndex: DWORD): PDH_STATUS; stdcall;
  1088. {$EXTERNALSYM PdhLookupPerfIndexByNameA}
  1089. function PdhLookupPerfIndexByNameW(szMachineName, szNameBuffer: LPCWSTR;
  1090.   var pdwIndex: DWORD): PDH_STATUS; stdcall;
  1091. {$EXTERNALSYM PdhLookupPerfIndexByNameW}
  1093. {$IFDEF UNICODE}
  1094. function PdhLookupPerfIndexByName(szMachineName, szNameBuffer: LPCWSTR;
  1095.   var pdwIndex: DWORD): PDH_STATUS; stdcall;
  1096. {$EXTERNALSYM PdhLookupPerfIndexByName}
  1097. {$ELSE}
  1098. function PdhLookupPerfIndexByName(szMachineName, szNameBuffer: LPCSTR;
  1099.   var pdwIndex: DWORD): PDH_STATUS; stdcall;
  1100. {$EXTERNALSYM PdhLookupPerfIndexByName}
  1101. {$ENDIF}
  1103. const
  1104.   PDH_NOEXPANDCOUNTERS   = 1;
  1105.   {$EXTERNALSYM PDH_NOEXPANDCOUNTERS}
  1106.   PDH_NOEXPANDINSTANCES  = 2;
  1107.   {$EXTERNALSYM PDH_NOEXPANDINSTANCES}
  1109. function PdhExpandWildCardPathA(szDataSource, szWildCardPath: LPCSTR;
  1110.   mszExpandedPathList: LPSTR; var pcchPathListLength: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1111. {$EXTERNALSYM PdhExpandWildCardPathA}
  1112. function PdhExpandWildCardPathW(szDataSource, szWildCardPath: LPCWSTR;
  1113.   mszExpandedPathList: LPWSTR; var pcchPathListLength: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1114. {$EXTERNALSYM PdhExpandWildCardPathW}
  1116. {$IFDEF UNICODE}
  1117. function PdhExpandWildCardPath(szDataSource, szWildCardPath: LPCWSTR;
  1118.   mszExpandedPathList: LPWSTR; var pcchPathListLength: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1119. {$EXTERNALSYM PdhExpandWildCardPath}
  1120. {$ELSE}
  1121. function PdhExpandWildCardPath(szDataSource, szWildCardPath: LPCSTR;
  1122.   mszExpandedPathList: LPSTR; var pcchPathListLength: DWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1123. {$EXTERNALSYM PdhExpandWildCardPath}
  1124. {$ENDIF}
  1126. //
  1127. //   Logging Functions
  1128. //
  1130. const
  1131.   PDH_LOG_READ_ACCESS        = DWORD($00010000);
  1132.   {$EXTERNALSYM PDH_LOG_READ_ACCESS}
  1133.   PDH_LOG_WRITE_ACCESS       = DWORD($00020000);
  1134.   {$EXTERNALSYM PDH_LOG_WRITE_ACCESS}
  1135.   PDH_LOG_UPDATE_ACCESS      = DWORD($00040000);
  1136.   {$EXTERNALSYM PDH_LOG_UPDATE_ACCESS}
  1137.   PDH_LOG_ACCESS_MASK        = DWORD($000F0000);
  1138.   {$EXTERNALSYM PDH_LOG_ACCESS_MASK}
  1140.   PDH_LOG_CREATE_NEW         = DWORD($00000001);
  1141.   {$EXTERNALSYM PDH_LOG_CREATE_NEW}
  1142.   PDH_LOG_CREATE_ALWAYS      = DWORD($00000002);
  1143.   {$EXTERNALSYM PDH_LOG_CREATE_ALWAYS}
  1144.   PDH_LOG_OPEN_ALWAYS        = DWORD($00000003);
  1145.   {$EXTERNALSYM PDH_LOG_OPEN_ALWAYS}
  1146.   PDH_LOG_OPEN_EXISTING      = DWORD($00000004);
  1147.   {$EXTERNALSYM PDH_LOG_OPEN_EXISTING}
  1148.   PDH_LOG_CREATE_MASK        = DWORD($0000000F);
  1149.   {$EXTERNALSYM PDH_LOG_CREATE_MASK}
  1151.   PDH_LOG_OPT_USER_STRING    = DWORD($01000000);
  1152.   {$EXTERNALSYM PDH_LOG_OPT_USER_STRING}
  1153.   PDH_LOG_OPT_CIRCULAR       = DWORD($02000000);
  1154.   {$EXTERNALSYM PDH_LOG_OPT_CIRCULAR}
  1155.   PDH_LOG_OPT_MAX_IS_BYTES   = DWORD($04000000);
  1156.   {$EXTERNALSYM PDH_LOG_OPT_MAX_IS_BYTES}
  1157.   PDH_LOG_OPT_APPEND         = DWORD($08000000);
  1158.   {$EXTERNALSYM PDH_LOG_OPT_APPEND}
  1159.   PDH_LOG_OPT_MASK           = DWORD($0F000000);
  1160.   {$EXTERNALSYM PDH_LOG_OPT_MASK}
  1162.   PDH_LOG_TYPE_UNDEFINED     = 0;
  1163.   {$EXTERNALSYM PDH_LOG_TYPE_UNDEFINED}
  1164.   PDH_LOG_TYPE_CSV           = 1;
  1165.   {$EXTERNALSYM PDH_LOG_TYPE_CSV}
  1166.   PDH_LOG_TYPE_TSV           = 2;
  1167.   {$EXTERNALSYM PDH_LOG_TYPE_TSV}
  1168.   //PDH_LOG_TYPE_BINARY        = 3;  // this is the retired binary format
  1169.   //{$EXTERNALSYM PDH_LOG_TYPE_BINARY}
  1170.   PDH_LOG_TYPE_TRACE_KERNEL  = 4;
  1171.   {$EXTERNALSYM PDH_LOG_TYPE_TRACE_KERNEL}
  1172.   PDH_LOG_TYPE_TRACE_GENERIC = 5;
  1173.   {$EXTERNALSYM PDH_LOG_TYPE_TRACE_GENERIC}
  1174.   PDH_LOG_TYPE_PERFMON       = 6;
  1175.   {$EXTERNALSYM PDH_LOG_TYPE_PERFMON}
  1176.   PDH_LOG_TYPE_SQL           = 7;
  1177.   {$EXTERNALSYM PDH_LOG_TYPE_SQL}
  1178.   PDH_LOG_TYPE_BINARY        = 8;
  1179.   {$EXTERNALSYM PDH_LOG_TYPE_BINARY}
  1181. function PdhOpenLogA(szLogFileName: LPCSTR; dwAccessFlags: DWORD;
  1182.   lpdwLogType: LPDWORD; hQuery: PDH_HQUERY; dwMaxRecords: DWORD;
  1183.   szUserCaption: LPCSTR; var phLog: PDH_HLOG): PDH_STATUS; stdcall;
  1184. {$EXTERNALSYM PdhOpenLogA}
  1185. function PdhOpenLogW(szLogFileName: LPCWSTR; dwAccessFlags: DWORD;
  1186.   lpdwLogType: LPDWORD; hQuery: PDH_HQUERY; dwMaxRecords: DWORD;
  1187.   szUserCaption: LPCWSTR; var phLog: PDH_HLOG): PDH_STATUS; stdcall;
  1188. {$EXTERNALSYM PdhOpenLogW}
  1190. {$IFDEF UNICODE}
  1191. function PdhOpenLog(szLogFileName: LPCWSTR; dwAccessFlags: DWORD;
  1192.   lpdwLogType: LPDWORD; hQuery: PDH_HQUERY; dwMaxRecords: DWORD;
  1193.   szUserCaption: LPCWSTR; var phLog: PDH_HLOG): PDH_STATUS; stdcall;
  1194. {$EXTERNALSYM PdhOpenLog}
  1195. {$ELSE}
  1196. function PdhOpenLog(szLogFileName: LPCSTR; dwAccessFlags: DWORD;
  1197.   lpdwLogType: LPDWORD; hQuery: PDH_HQUERY; dwMaxRecords: DWORD;
  1198.   szUserCaption: LPCSTR; var phLog: PDH_HLOG): PDH_STATUS; stdcall;
  1199. {$EXTERNALSYM PdhOpenLog}
  1200. {$ENDIF}
  1202. function PdhUpdateLogA(hLog: PDH_HLOG; szUserString: LPCSTR): PDH_STATUS; stdcall;
  1203. {$EXTERNALSYM PdhUpdateLogA}
  1204. function PdhUpdateLogW(hLog: PDH_HLOG; szUserString: LPCWSTR): PDH_STATUS; stdcall;
  1205. {$EXTERNALSYM PdhUpdateLogW}
  1207. {$IFDEF UNICODE}
  1208. function PdhUpdateLog(hLog: PDH_HLOG; szUserString: LPCWSTR): PDH_STATUS; stdcall;
  1209. {$EXTERNALSYM PdhUpdateLog}
  1210. {$ELSE}
  1211. function PdhUpdateLog(hLog: PDH_HLOG; szUserString: LPCSTR): PDH_STATUS; stdcall;
  1212. {$EXTERNALSYM PdhUpdateLog}
  1213. {$ENDIF}
  1215. function PdhUpdateLogFileCatalog(hLog: PDH_HLOG): PDH_STATUS; stdcall;
  1216. {$EXTERNALSYM PdhUpdateLogFileCatalog}
  1218. function PdhGetLogFileSize(hLog: PDH_HLOG; var llSize: LONGLONG): PDH_STATUS; stdcall;
  1219. {$EXTERNALSYM PdhGetLogFileSize}
  1221. function PdhCloseLog(hLog: PDH_HLOG; dwFlags: DWORD): PDH_STATUS; stdcall;
  1222. {$EXTERNALSYM PdhCloseLog}
  1224. const
  1225.   PDH_FLAGS_CLOSE_QUERY = DWORD($00000001);
  1226.   {$EXTERNALSYM PDH_FLAGS_CLOSE_QUERY}
  1228. //
  1229. //  Data source selection dialog
  1230. //
  1232. const
  1233.   PDH_FLAGS_FILE_BROWSER_ONLY = DWORD($00000001);
  1234.   {$EXTERNALSYM PDH_FLAGS_FILE_BROWSER_ONLY}
  1236. function PdhSelectDataSourceA(hWndOwner: HWND; dwFlags: DWORD;
  1237.   szDataSource: LPSTR; var pcchBufferLength: DWORD): PDH_STATUS; stdcall;
  1238. {$EXTERNALSYM PdhSelectDataSourceA}
  1239. function PdhSelectDataSourceW(hWndOwner: HWND; dwFlags: DWORD;
  1240.   szDataSource: LPWSTR; var pcchBufferLength: DWORD): PDH_STATUS; stdcall;
  1241. {$EXTERNALSYM PdhSelectDataSourceW}
  1243. {$IFDEF UNICODE}
  1244. function PdhSelectDataSource(hWndOwner: HWND; dwFlags: DWORD;
  1245.   szDataSource: LPWSTR; var pcchBufferLength: DWORD): PDH_STATUS; stdcall;
  1246. {$EXTERNALSYM PdhSelectDataSource}
  1247. {$ELSE}
  1248. function PdhSelectDataSource(hWndOwner: HWND; dwFlags: DWORD;
  1249.   szDataSource: LPSTR; var pcchBufferLength: DWORD): PDH_STATUS; stdcall;
  1250. {$EXTERNALSYM PdhSelectDataSource}
  1251. {$ENDIF}
  1253. function PdhIsRealTimeQuery(hQuery: PDH_HQUERY): BOOL; stdcall;
  1254. {$EXTERNALSYM PdhIsRealTimeQuery}
  1256. function PdhSetQueryTimeRange(hQuery: PDH_HQUERY; var pInfo: PDH_TIME_INFO): PDH_STATUS; stdcall;
  1257. {$EXTERNALSYM PdhSetQueryTimeRange}
  1259. function PdhGetDataSourceTimeRangeA(szDataSource: LPCSTR; var pdwNumEntries: DWORD;
  1260.   var pInfo: PDH_TIME_INFO; pdwBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1261. {$EXTERNALSYM PdhGetDataSourceTimeRangeA}
  1262. function PdhGetDataSourceTimeRangeW(szDataSource: LPCWSTR; var pdwNumEntries: DWORD;
  1263.   var pInfo: PDH_TIME_INFO; pdwBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1264. {$EXTERNALSYM PdhGetDataSourceTimeRangeW}
  1266. {$IFDEF UNICODE}
  1267. function PdhGetDataSourceTimeRange(szDataSource: LPCWSTR; var pdwNumEntries: DWORD;
  1268.   var pInfo: PDH_TIME_INFO; pdwBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1269. {$EXTERNALSYM PdhGetDataSourceTimeRange}
  1270. {$ELSE}
  1271. function PdhGetDataSourceTimeRange(szDataSource: LPCSTR; var pdwNumEntries: DWORD;
  1272.   var pInfo: PDH_TIME_INFO; pdwBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1273. {$EXTERNALSYM PdhGetDataSourceTimeRange}
  1274. {$ENDIF}
  1276. function PdhCollectQueryDataEx(hQuery: PDH_HQUERY; dwIntervalTime: DWORD;
  1277.   hNewDataEvent: HANDLE): PDH_STATUS; stdcall;
  1278. {$EXTERNALSYM PdhCollectQueryDataEx}
  1280. function PdhFormatFromRawValue(dwCounterType, dwFormat: DWORD;
  1281.   var pTimeBase: LONGLONG; pRawValue1, pRawValue2: PPDH_RAW_COUNTER;
  1282.   var pFmtValue: PDH_FMT_COUNTERVALUE): PDH_STATUS; stdcall;
  1283. {$EXTERNALSYM PdhFormatFromRawValue}
  1285. function PdhGetCounterTimeBase(hCounter: PDH_HCOUNTER; var pTimeBase: LONGLONG): PDH_STATUS; stdcall;
  1286. {$EXTERNALSYM PdhGetCounterTimeBase}
  1288. function PdhReadRawLogRecord(hLog: PDH_HLOG; ftRecord: FILETIME;
  1289.   var pRawLogRecord: PDH_RAW_LOG_RECORD; pdwBufferLength: LPDWORD): PDH_STATUS; stdcall;
  1290. {$EXTERNALSYM PdhReadRawLogRecord}
  1292. const
  1293.   DATA_SOURCE_REGISTRY    = DWORD($00000001);
  1294.   {$EXTERNALSYM DATA_SOURCE_REGISTRY}
  1295.   DATA_SOURCE_LOGFILE     = DWORD($00000002);
  1296.   {$EXTERNALSYM DATA_SOURCE_LOGFILE}
  1297.   DATA_SOURCE_WBEM        = DWORD($00000004);
  1298.   {$EXTERNALSYM DATA_SOURCE_WBEM}
  1300. function PdhSetDefaultRealTimeDataSource(dwDataSourceId: DWORD): PDH_STATUS; stdcall;
  1301. {$EXTERNALSYM PdhSetDefaultRealTimeDataSource}
  1303. // Extended API for WMI event trace logfile format
  1304. //
  1306. function PdhBindInputDataSourceW(var phDataSource: PDH_HLOG; LogFileNameList: LPCWSTR): PDH_STATUS; stdcall;
  1307. {$EXTERNALSYM PdhBindInputDataSourceW}
  1308. function PdhBindInputDataSourceA(var phDataSource: PDH_HLOG; LogFileNameList: LPCSTR): PDH_STATUS; stdcall;
  1309. {$EXTERNALSYM PdhBindInputDataSourceA}
  1311. {$IFDEF UNICODE}
  1312. function PdhBindInputDataSource(var phDataSource: PDH_HLOG; LogFileNameList: LPCWSTR): PDH_STATUS; stdcall;
  1313. {$EXTERNALSYM PdhBindInputDataSource}
  1314. {$ELSE}
  1315. function PdhBindInputDataSource(var phDataSource: PDH_HLOG; LogFileNameList: LPCSTR): PDH_STATUS; stdcall;
  1316. {$EXTERNALSYM PdhBindInputDataSource}
  1317. {$ENDIF}
  1319. function PdhOpenQueryH(hDataSource: PDH_HLOG; dwUserData: DWORD_PTR; var phQuery: PDH_HQUERY): PDH_STATUS; stdcall;
  1320. {$EXTERNALSYM PdhOpenQueryH}
  1322. function PdhEnumMachinesHW(hDataSource: PDH_HLOG; mszMachineList: LPWSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1323. {$EXTERNALSYM PdhEnumMachinesHW}
  1324. function PdhEnumMachinesHA(hDataSource: PDH_HLOG; mszMachineList: LPSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1325. {$EXTERNALSYM PdhEnumMachinesHA}
  1327. {$IFDEF UNICODE}
  1328. function PdhEnumMachinesH(hDataSource: PDH_HLOG; mszMachineList: LPWSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1329. {$EXTERNALSYM PdhEnumMachinesH}
  1330. {$ELSE}
  1331. function PdhEnumMachinesH(hDataSource: PDH_HLOG; mszMachineList: LPSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1332. {$EXTERNALSYM PdhEnumMachinesH}
  1333. {$ENDIF}
  1335. function PdhEnumObjectsHW(hDataSource: PDH_HLOG; szMachineName: LPCWSTR; mszObjectList: LPWSTR; pcchBufferSize: LPDWORD;
  1336.   dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  1337. {$EXTERNALSYM PdhEnumObjectsHW}
  1338. function PdhEnumObjectsHA(hDataSource: PDH_HLOG; szMachineName: LPCSTR; mszObjectList: LPSTR; pcchBufferSize: LPDWORD;
  1339.   dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  1340. {$EXTERNALSYM PdhEnumObjectsHA}
  1342. {$IFDEF UNICODE}
  1343. function PdhEnumObjectsH(hDataSource: PDH_HLOG; szMachineName: LPCWSTR; mszObjectList: LPWSTR; pcchBufferSize: LPDWORD;
  1344.   dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  1345. {$EXTERNALSYM PdhEnumObjectsH}
  1346. {$ELSE}
  1347. function PdhEnumObjectsH(hDataSource: PDH_HLOG; szMachineName: LPCSTR; mszObjectList: LPSTR; pcchBufferSize: LPDWORD;
  1348.   dwDetailLevel: DWORD; bRefresh: BOOL): PDH_STATUS; stdcall;
  1349. {$EXTERNALSYM PdhEnumObjectsH}
  1350. {$ENDIF}
  1352. function PdhEnumObjectItemsHW(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCWSTR; mszCounterList: LPWSTR;
  1353.   pcchCounterListLength: LPDWORD; mszInstanceList: LPWSTR; pcchInstanceListLength: LPDWORD;
  1354.   dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  1355. {$EXTERNALSYM PdhEnumObjectItemsHW}
  1356. function PdhEnumObjectItemsHA(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCSTR; mszCounterList: LPSTR;
  1357.   pcchCounterListLength: LPDWORD; mszInstanceList: LPSTR; pcchInstanceListLength: LPDWORD;
  1358.   dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  1359. {$EXTERNALSYM PdhEnumObjectItemsHA}
  1361. {$IFDEF UNICODE}
  1362. function PdhEnumObjectItemsH(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCWSTR; mszCounterList: LPWSTR;
  1363.   pcchCounterListLength: LPDWORD; mszInstanceList: LPWSTR; pcchInstanceListLength: LPDWORD;
  1364.   dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  1365. {$EXTERNALSYM PdhEnumObjectItemsH}
  1366. {$ELSE}
  1367. function PdhEnumObjectItemsH(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCSTR; mszCounterList: LPSTR;
  1368.   pcchCounterListLength: LPDWORD; mszInstanceList: LPSTR; pcchInstanceListLength: LPDWORD;
  1369.   dwDetailLevel, dwFlags: DWORD): PDH_STATUS; stdcall;
  1370. {$EXTERNALSYM PdhEnumObjectItemsH}
  1371. {$ENDIF}
  1373. function PdhExpandWildCardPathHW(hDataSource: PDH_HLOG; szWildCardPath: LPCWSTR; mszExpandedPathList: LPWSTR;
  1374.   pcchPathListLength: LPDWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1375. {$EXTERNALSYM PdhExpandWildCardPathHW}
  1376. function PdhExpandWildCardPathHA(hDataSource: PDH_HLOG; szWildCardPath: LPCSTR; mszExpandedPathList: LPSTR;
  1377.   pcchPathListLength: LPDWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1378. {$EXTERNALSYM PdhExpandWildCardPathHA}
  1380. {$IFDEF UNICODE}
  1381. function PdhExpandWildCardPathH(hDataSource: PDH_HLOG; szWildCardPath: LPCWSTR; mszExpandedPathList: LPWSTR;
  1382.   pcchPathListLength: LPDWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1383. {$EXTERNALSYM PdhExpandWildCardPathH}
  1384. {$ELSE}
  1385. function PdhExpandWildCardPathH(hDataSource: PDH_HLOG; szWildCardPath: LPCSTR; mszExpandedPathList: LPSTR;
  1386.   pcchPathListLength: LPDWORD; dwFlags: DWORD): PDH_STATUS; stdcall;
  1387. {$EXTERNALSYM PdhExpandWildCardPathH}
  1388. {$ENDIF}
  1390. function PdhGetDataSourceTimeRangeH(hDataSource: PDH_HLOG; pdwNumEntries: LPDWORD; pInfo: PPDH_TIME_INFO;
  1391.   pdwBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1392. {$EXTERNALSYM PdhGetDataSourceTimeRangeH}
  1394. function PdhGetDefaultPerfObjectHW(hDataSource: PDH_HLOG; szMachineName: LPCWSTR; szDefaultObjectName: LPWSTR;
  1395.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1396. {$EXTERNALSYM PdhGetDefaultPerfObjectHW}
  1397. function PdhGetDefaultPerfObjectHA(hDataSource: PDH_HLOG; szMachineName: LPCSTR; szDefaultObjectName: LPSTR;
  1398.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1399. {$EXTERNALSYM PdhGetDefaultPerfObjectHA}
  1401. {$IFDEF UNICODE}
  1402. function PdhGetDefaultPerfObjectH(hDataSource: PDH_HLOG; szMachineName: LPCWSTR; szDefaultObjectName: LPWSTR;
  1403.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1404. {$EXTERNALSYM PdhGetDefaultPerfObjectH}
  1405. {$ELSE}
  1406. function PdhGetDefaultPerfObjectH(hDataSource: PDH_HLOG; szMachineName: LPCSTR; szDefaultObjectName: LPSTR;
  1407.   pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1408. {$EXTERNALSYM PdhGetDefaultPerfObjectH}
  1409. {$ENDIF}
  1411. function PdhGetDefaultPerfCounterHW(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCWSTR;
  1412.   szDefaultCounterName: LPWSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1413. {$EXTERNALSYM PdhGetDefaultPerfCounterHW}
  1414. function PdhGetDefaultPerfCounterHA(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCSTR;
  1415.   szDefaultCounterName: LPSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1416. {$EXTERNALSYM PdhGetDefaultPerfCounterHA}
  1418. {$IFDEF UNICODE}
  1419. function PdhGetDefaultPerfCounterH(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCWSTR;
  1420.   szDefaultCounterName: LPWSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1421. {$EXTERNALSYM PdhGetDefaultPerfCounterH}
  1422. {$ELSE}
  1423. function PdhGetDefaultPerfCounterH(hDataSource: PDH_HLOG; szMachineName, szObjectName: LPCSTR;
  1424.   szDefaultCounterName: LPSTR; pcchBufferSize: LPDWORD): PDH_STATUS; stdcall;
  1425. {$EXTERNALSYM PdhGetDefaultPerfCounterH}
  1426. {$ENDIF}
  1428. function PdhBrowseCountersHW(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_HW): PDH_STATUS; stdcall;
  1429. {$EXTERNALSYM PdhBrowseCountersHW}
  1430. function PdhBrowseCountersHA(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_HA): PDH_STATUS; stdcall;
  1431. {$EXTERNALSYM PdhBrowseCountersHA}
  1433. {$IFDEF UNICODE}
  1434. function PdhBrowseCountersH(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_HW): PDH_STATUS; stdcall;
  1435. {$EXTERNALSYM PdhBrowseCountersH}
  1436. {$ELSE}
  1437. function PdhBrowseCountersH(const pBrowseDlgData: PDH_BROWSE_DLG_CONFIG_HA): PDH_STATUS; stdcall;
  1438. {$EXTERNALSYM PdhBrowseCountersH}
  1439. {$ENDIF}
  1441. //Check that a DSN points to a database that contains the correct Perfmon tables.
  1443. function PdhVerifySQLDBW(szDataSource: LPCWSTR): PDH_STATUS; stdcall;
  1444. {$EXTERNALSYM PdhVerifySQLDBW}
  1445. function PdhVerifySQLDBA(szDataSource: LPCSTR): PDH_STATUS; stdcall;
  1446. {$EXTERNALSYM PdhVerifySQLDBA}
  1448. {$IFDEF UNICODE}
  1449. function PdhVerifySQLDB(szDataSource: LPCWSTR): PDH_STATUS; stdcall;
  1450. {$EXTERNALSYM PdhVerifySQLDB}
  1451. {$ELSE}
  1452. function PdhVerifySQLDB(szDataSource: LPCSTR): PDH_STATUS; stdcall;
  1453. {$EXTERNALSYM PdhVerifySQLDB}
  1454. {$ENDIF}
  1456. //Create the correct perfmon tables in the database pointed to by a DSN.
  1458. function PdhCreateSQLTablesW(szDataSource: LPCWSTR): PDH_STATUS; stdcall;
  1459. {$EXTERNALSYM PdhCreateSQLTablesW}
  1460. function PdhCreateSQLTablesA(szDataSource: LPCSTR): PDH_STATUS; stdcall;
  1461. {$EXTERNALSYM PdhCreateSQLTablesA}
  1463. {$IFDEF UNICODE}
  1464. function PdhCreateSQLTables(szDataSource: LPCWSTR): PDH_STATUS; stdcall;
  1465. {$EXTERNALSYM PdhCreateSQLTables}
  1466. {$ELSE}
  1467. function PdhCreateSQLTables(szDataSource: LPCSTR): PDH_STATUS; stdcall;
  1468. {$EXTERNALSYM PdhCreateSQLTables}
  1469. {$ENDIF}
  1471. //Return the list of Log set names in the database pointed to by the DSN.
  1473. function PdhEnumLogSetNamesW(szDataSource: LPCWSTR; mszDataSetNameList: LPWSTR; pcchBufferLength: LPDWORD): PDH_STATUS; stdcall;
  1474. {$EXTERNALSYM PdhEnumLogSetNamesW}
  1475. function PdhEnumLogSetNamesA(szDataSource: LPCSTR; mszDataSetNameList: LPSTR; pcchBufferLength: LPDWORD): PDH_STATUS; stdcall;
  1476. {$EXTERNALSYM PdhEnumLogSetNamesA}
  1478. {$IFDEF UNICODE}
  1479. function PdhEnumLogSetNames(szDataSource: LPCWSTR; mszDataSetNameList: LPWSTR; pcchBufferLength: LPDWORD): PDH_STATUS; stdcall;
  1480. {$EXTERNALSYM PdhEnumLogSetNames}
  1481. {$ELSE}
  1482. function PdhEnumLogSetNames(szDataSource: LPCSTR; mszDataSetNameList: LPSTR; pcchBufferLength: LPDWORD): PDH_STATUS; stdcall;
  1483. {$EXTERNALSYM PdhEnumLogSetNames}
  1484. {$ENDIF}
  1486. //Retrieve the GUID for an open Log Set
  1488. function PdhGetLogSetGUID(hLog: PDH_HLOG; pGuid: LPGUID; pRunId: LPINT): PDH_STATUS; stdcall;
  1489. {$EXTERNALSYM PdhGetLogSetGUID}
  1491. //Set the RunID for an open Log Set
  1493. function PdhSetLogSetRunID(hLog: PDH_HLOG; RunId: Integer): PDH_STATUS; stdcall;
  1494. {$EXTERNALSYM PdhSetLogSetRunID}
  1496. implementation
  1498. const
  1499.   PdhLib = 'pdh.dll';
  1501. function IsSuccessSeverity(ErrorCode: Longint): Boolean;
  1502. begin
  1503.   Result := (ErrorCode and $C0000000) = $00000000;
  1504. end;
  1506. function IsInformationalSeverity(ErrorCode: Longint): Boolean;
  1507. begin
  1508.   Result := (ErrorCode and $C0000000) = $40000000;
  1509. end;
  1511. function IsWarningSeverity(ErrorCode: Longint): Boolean;
  1512. begin
  1513.   Result := (ErrorCode and $C0000000) = $80000000;
  1514. end;
  1516. function IsErrorSeverity(ErrorCode: Longint): Boolean;
  1517. begin
  1518.   Result := (ErrorCode and $C0000000) = $C0000000;
  1519. end;
  1522. {$IFDEF DYNAMIC_LINK}
  1523. var
  1524.   _PdhGetDllVersion: Pointer;
  1526. function PdhGetDllVersion;
  1527. begin
  1528.   GetProcedureAddress(_PdhGetDllVersion, PdhLib, 'PdhGetDllVersion');
  1529.   asm
  1530.     mov esp, ebp
  1531.     pop ebp
  1532.     jmp [_PdhGetDllVersion]
  1533.   end;
  1534. end;
  1535. {$ELSE}
  1536. function PdhGetDllVersion; external PdhLib name 'PdhGetDllVersion';
  1537. {$ENDIF DYNAMIC_LINK}
  1539. {$IFDEF DYNAMIC_LINK}
  1540. var
  1541.   _PdhOpenQueryA: Pointer;
  1543. function PdhOpenQueryA;
  1544. begin
  1545.   GetProcedureAddress(_PdhOpenQueryA, PdhLib, 'PdhOpenQueryA');
  1546.   asm
  1547.     mov esp, ebp
  1548.     pop ebp
  1549.     jmp [_PdhOpenQueryA]
  1550.   end;
  1551. end;
  1552. {$ELSE}
  1553. function PdhOpenQueryA; external PdhLib name 'PdhOpenQueryA';
  1554. {$ENDIF DYNAMIC_LINK}
  1556. {$IFDEF DYNAMIC_LINK}
  1557. var
  1558.   _PdhOpenQueryW: Pointer;
  1560. function PdhOpenQueryW;
  1561. begin
  1562.   GetProcedureAddress(_PdhOpenQueryW, PdhLib, 'PdhOpenQueryW');
  1563.   asm
  1564.     mov esp, ebp
  1565.     pop ebp
  1566.     jmp [_PdhOpenQueryW]
  1567.   end;
  1568. end;
  1569. {$ELSE}
  1570. function PdhOpenQueryW; external PdhLib name 'PdhOpenQueryW';
  1571. {$ENDIF DYNAMIC_LINK}
  1572. {$IFDEF UNICODE}
  1574. {$IFDEF DYNAMIC_LINK}
  1575. var
  1576.   _PdhOpenQuery: Pointer;
  1578. function PdhOpenQuery;
  1579. begin
  1580.   GetProcedureAddress(_PdhOpenQuery, PdhLib, 'PdhOpenQueryW');
  1581.   asm
  1582.     mov esp, ebp
  1583.     pop ebp
  1584.     jmp [_PdhOpenQuery]
  1585.   end;
  1586. end;
  1587. {$ELSE}
  1588. function PdhOpenQuery; external PdhLib name 'PdhOpenQueryW';
  1589. {$ENDIF DYNAMIC_LINK}
  1590. {$ELSE}
  1592. {$IFDEF DYNAMIC_LINK}
  1593. var
  1594.   _PdhOpenQuery: Pointer;
  1596. function PdhOpenQuery;
  1597. begin
  1598.   GetProcedureAddress(_PdhOpenQuery, PdhLib, 'PdhOpenQueryA');
  1599.   asm
  1600.     mov esp, ebp
  1601.     pop ebp
  1602.     jmp [_PdhOpenQuery]
  1603.   end;
  1604. end;
  1605. {$ELSE}
  1606. function PdhOpenQuery; external PdhLib name 'PdhOpenQueryA';
  1607. {$ENDIF DYNAMIC_LINK}
  1608. {$ENDIF}
  1610. {$IFDEF DYNAMIC_LINK}
  1611. var
  1612.   _PdhAddCounterA: Pointer;
  1614. function PdhAddCounterA;
  1615. begin
  1616.   GetProcedureAddress(_PdhAddCounterA, PdhLib, 'PdhAddCounterA');
  1617.   asm
  1618.     mov esp, ebp
  1619.     pop ebp
  1620.     jmp [_PdhAddCounterA]
  1621.   end;
  1622. end;
  1623. {$ELSE}
  1624. function PdhAddCounterA; external PdhLib name 'PdhAddCounterA';
  1625. {$ENDIF DYNAMIC_LINK}
  1627. {$IFDEF DYNAMIC_LINK}
  1628. var
  1629.   _PdhAddCounterW: Pointer;
  1631. function PdhAddCounterW;
  1632. begin
  1633.   GetProcedureAddress(_PdhAddCounterW, PdhLib, 'PdhAddCounterW');
  1634.   asm
  1635.     mov esp, ebp
  1636.     pop ebp
  1637.     jmp [_PdhAddCounterW]
  1638.   end;
  1639. end;
  1640. {$ELSE}
  1641. function PdhAddCounterW; external PdhLib name 'PdhAddCounterW';
  1642. {$ENDIF DYNAMIC_LINK}
  1643. {$IFDEF UNICODE}
  1645. {$IFDEF DYNAMIC_LINK}
  1646. var
  1647.   _PdhAddCounter: Pointer;
  1649. function PdhAddCounter;
  1650. begin
  1651.   GetProcedureAddress(_PdhAddCounter, PdhLib, 'PdhAddCounterW');
  1652.   asm
  1653.     mov esp, ebp
  1654.     pop ebp
  1655.     jmp [_PdhAddCounter]
  1656.   end;
  1657. end;
  1658. {$ELSE}
  1659. function PdhAddCounter; external PdhLib name 'PdhAddCounterW';
  1660. {$ENDIF DYNAMIC_LINK}
  1661. {$ELSE}
  1663. {$IFDEF DYNAMIC_LINK}
  1664. var
  1665.   _PdhAddCounter: Pointer;
  1667. function PdhAddCounter;
  1668. begin
  1669.   GetProcedureAddress(_PdhAddCounter, PdhLib, 'PdhAddCounterA');
  1670.   asm
  1671.     mov esp, ebp
  1672.     pop ebp
  1673.     jmp [_PdhAddCounter]
  1674.   end;
  1675. end;
  1676. {$ELSE}
  1677. function PdhAddCounter; external PdhLib name 'PdhAddCounterA';
  1678. {$ENDIF DYNAMIC_LINK}
  1679. {$ENDIF}
  1681. {$IFDEF DYNAMIC_LINK}
  1682. var
  1683.   _PdhRemoveCounter: Pointer;
  1685. function PdhRemoveCounter;
  1686. begin
  1687.   GetProcedureAddress(_PdhRemoveCounter, PdhLib, 'PdhRemoveCounter');
  1688.   asm
  1689.     mov esp, ebp
  1690.     pop ebp
  1691.     jmp [_PdhRemoveCounter]
  1692.   end;
  1693. end;
  1694. {$ELSE}
  1695. function PdhRemoveCounter; external PdhLib name 'PdhRemoveCounter';
  1696. {$ENDIF DYNAMIC_LINK}
  1698. {$IFDEF DYNAMIC_LINK}
  1699. var
  1700.   _PdhCollectQueryData: Pointer;
  1702. function PdhCollectQueryData;
  1703. begin
  1704.   GetProcedureAddress(_PdhCollectQueryData, PdhLib, 'PdhCollectQueryData');
  1705.   asm
  1706.     mov esp, ebp
  1707.     pop ebp
  1708.     jmp [_PdhCollectQueryData]
  1709.   end;
  1710. end;
  1711. {$ELSE}
  1712. function PdhCollectQueryData; external PdhLib name 'PdhCollectQueryData';
  1713. {$ENDIF DYNAMIC_LINK}
  1715. {$IFDEF DYNAMIC_LINK}
  1716. var
  1717.   _PdhCloseQuery: Pointer;
  1719. function PdhCloseQuery;
  1720. begin
  1721.   GetProcedureAddress(_PdhCloseQuery, PdhLib, 'PdhCloseQuery');
  1722.   asm
  1723.     mov esp, ebp
  1724.     pop ebp
  1725.     jmp [_PdhCloseQuery]
  1726.   end;
  1727. end;
  1728. {$ELSE}
  1729. function PdhCloseQuery; external PdhLib name 'PdhCloseQuery';
  1730. {$ENDIF DYNAMIC_LINK}
  1732. {$IFDEF DYNAMIC_LINK}
  1733. var
  1734.   _PdhGetFormattedCounterValue: Pointer;
  1736. function PdhGetFormattedCounterValue;
  1737. begin
  1738.   GetProcedureAddress(_PdhGetFormattedCounterValue, PdhLib, 'PdhGetFormattedCounterValue');
  1739.   asm
  1740.     mov esp, ebp
  1741.     pop ebp
  1742.     jmp [_PdhGetFormattedCounterValue]
  1743.   end;
  1744. end;
  1745. {$ELSE}
  1746. function PdhGetFormattedCounterValue; external PdhLib name 'PdhGetFormattedCounterValue';
  1747. {$ENDIF DYNAMIC_LINK}
  1749. {$IFDEF DYNAMIC_LINK}
  1750. var
  1751.   _PdhGetFormattedCounterArrayA: Pointer;
  1753. function PdhGetFormattedCounterArrayA;
  1754. begin
  1755.   GetProcedureAddress(_PdhGetFormattedCounterArrayA, PdhLib, 'PdhGetFormattedCounterArrayA');
  1756.   asm
  1757.     mov esp, ebp
  1758.     pop ebp
  1759.     jmp [_PdhGetFormattedCounterArrayA]
  1760.   end;
  1761. end;
  1762. {$ELSE}
  1763. function PdhGetFormattedCounterArrayA; external PdhLib name 'PdhGetFormattedCounterArrayA';
  1764. {$ENDIF DYNAMIC_LINK}
  1766. {$IFDEF DYNAMIC_LINK}
  1767. var
  1768.   _PdhGetFormattedCounterArrayW: Pointer;
  1770. function PdhGetFormattedCounterArrayW;
  1771. begin
  1772.   GetProcedureAddress(_PdhGetFormattedCounterArrayW, PdhLib, 'PdhGetFormattedCounterArrayW');
  1773.   asm
  1774.     mov esp, ebp
  1775.     pop ebp
  1776.     jmp [_PdhGetFormattedCounterArrayW]
  1777.   end;
  1778. end;
  1779. {$ELSE}
  1780. function PdhGetFormattedCounterArrayW; external PdhLib name 'PdhGetFormattedCounterArrayW';
  1781. {$ENDIF DYNAMIC_LINK}
  1782. {$IFDEF UNICODE}
  1784. {$IFDEF DYNAMIC_LINK}
  1785. var
  1786.   _PdhGetFormattedCounterArray: Pointer;
  1788. function PdhGetFormattedCounterArray;
  1789. begin
  1790.   GetProcedureAddress(_PdhGetFormattedCounterArray, PdhLib, 'PdhGetFormattedCounterArrayW');
  1791.   asm
  1792.     mov esp, ebp
  1793.     pop ebp
  1794.     jmp [_PdhGetFormattedCounterArray]
  1795.   end;
  1796. end;
  1797. {$ELSE}
  1798. function PdhGetFormattedCounterArray; external PdhLib name 'PdhGetFormattedCounterArrayW';
  1799. {$ENDIF DYNAMIC_LINK}
  1800. {$ELSE}
  1802. {$IFDEF DYNAMIC_LINK}
  1803. var
  1804.   _PdhGetFormattedCounterArray: Pointer;
  1806. function PdhGetFormattedCounterArray;
  1807. begin
  1808.   GetProcedureAddress(_PdhGetFormattedCounterArray, PdhLib, 'PdhGetFormattedCounterArrayA');
  1809.   asm
  1810.     mov esp, ebp
  1811.     pop ebp
  1812.     jmp [_PdhGetFormattedCounterArray]
  1813.   end;
  1814. end;
  1815. {$ELSE}
  1816. function PdhGetFormattedCounterArray; external PdhLib name 'PdhGetFormattedCounterArrayA';
  1817. {$ENDIF DYNAMIC_LINK}
  1818. {$ENDIF}
  1820. {$IFDEF DYNAMIC_LINK}
  1821. var
  1822.   _PdhGetRawCounterValue: Pointer;
  1824. function PdhGetRawCounterValue;
  1825. begin
  1826.   GetProcedureAddress(_PdhGetRawCounterValue, PdhLib, 'PdhGetRawCounterValue');
  1827.   asm
  1828.     mov esp, ebp
  1829.     pop ebp
  1830.     jmp [_PdhGetRawCounterValue]
  1831.   end;
  1832. end;
  1833. {$ELSE}
  1834. function PdhGetRawCounterValue; external PdhLib name 'PdhGetRawCounterValue';
  1835. {$ENDIF DYNAMIC_LINK}
  1837. {$IFDEF DYNAMIC_LINK}
  1838. var
  1839.   _PdhGetRawCounterArrayA: Pointer;
  1841. function PdhGetRawCounterArrayA;
  1842. begin
  1843.   GetProcedureAddress(_PdhGetRawCounterArrayA, PdhLib, 'PdhGetRawCounterArrayA');
  1844.   asm
  1845.     mov esp, ebp
  1846.     pop ebp
  1847.     jmp [_PdhGetRawCounterArrayA]
  1848.   end;
  1849. end;
  1850. {$ELSE}
  1851. function PdhGetRawCounterArrayA; external PdhLib name 'PdhGetRawCounterArrayA';
  1852. {$ENDIF DYNAMIC_LINK}
  1854. {$IFDEF DYNAMIC_LINK}
  1855. var
  1856.   _PdhGetRawCounterArrayW: Pointer;
  1858. function PdhGetRawCounterArrayW;
  1859. begin
  1860.   GetProcedureAddress(_PdhGetRawCounterArrayW, PdhLib, 'PdhGetRawCounterArrayW');
  1861.   asm
  1862.     mov esp, ebp
  1863.     pop ebp
  1864.     jmp [_PdhGetRawCounterArrayW]
  1865.   end;
  1866. end;
  1867. {$ELSE}
  1868. function PdhGetRawCounterArrayW; external PdhLib name 'PdhGetRawCounterArrayW';
  1869. {$ENDIF DYNAMIC_LINK}
  1870. {$IFDEF UNICODE}
  1872. {$IFDEF DYNAMIC_LINK}
  1873. var
  1874.   _PdhGetRawCounterArray: Pointer;
  1876. function PdhGetRawCounterArray;
  1877. begin
  1878.   GetProcedureAddress(_PdhGetRawCounterArray, PdhLib, 'PdhGetRawCounterArrayW');
  1879.   asm
  1880.     mov esp, ebp
  1881.     pop ebp
  1882.     jmp [_PdhGetRawCounterArray]
  1883.   end;
  1884. end;
  1885. {$ELSE}
  1886. function PdhGetRawCounterArray; external PdhLib name 'PdhGetRawCounterArrayW';
  1887. {$ENDIF DYNAMIC_LINK}
  1888. {$ELSE}
  1890. {$IFDEF DYNAMIC_LINK}
  1891. var
  1892.   _PdhGetRawCounterArray: Pointer;
  1894. function PdhGetRawCounterArray;
  1895. begin
  1896.   GetProcedureAddress(_PdhGetRawCounterArray, PdhLib, 'PdhGetRawCounterArrayA');
  1897.   asm
  1898.     mov esp, ebp
  1899.     pop ebp
  1900.     jmp [_PdhGetRawCounterArray]
  1901.   end;
  1902. end;
  1903. {$ELSE}
  1904. function PdhGetRawCounterArray; external PdhLib name 'PdhGetRawCounterArrayA';
  1905. {$ENDIF DYNAMIC_LINK}
  1906. {$ENDIF}
  1908. {$IFDEF DYNAMIC_LINK}
  1909. var
  1910.   _PdhCalculateCounterFromRawValue: Pointer;
  1912. function PdhCalculateCounterFromRawValue;
  1913. begin
  1914.   GetProcedureAddress(_PdhCalculateCounterFromRawValue, PdhLib, 'PdhCalculateCounterFromRawValue');
  1915.   asm
  1916.     mov esp, ebp
  1917.     pop ebp
  1918.     jmp [_PdhCalculateCounterFromRawValue]
  1919.   end;
  1920. end;
  1921. {$ELSE}
  1922. function PdhCalculateCounterFromRawValue; external PdhLib name 'PdhCalculateCounterFromRawValue';
  1923. {$ENDIF DYNAMIC_LINK}
  1925. {$IFDEF DYNAMIC_LINK}
  1926. var
  1927.   _PdhComputeCounterStatistics: Pointer;
  1929. function PdhComputeCounterStatistics;
  1930. begin
  1931.   GetProcedureAddress(_PdhComputeCounterStatistics, PdhLib, 'PdhComputeCounterStatistics');
  1932.   asm
  1933.     mov esp, ebp
  1934.     pop ebp
  1935.     jmp [_PdhComputeCounterStatistics]
  1936.   end;
  1937. end;
  1938. {$ELSE}
  1939. function PdhComputeCounterStatistics; external PdhLib name 'PdhComputeCounterStatistics';
  1940. {$ENDIF DYNAMIC_LINK}
  1942. {$IFDEF DYNAMIC_LINK}
  1943. var
  1944.   _PdhGetCounterInfoA: Pointer;
  1946. function PdhGetCounterInfoA;
  1947. begin
  1948.   GetProcedureAddress(_PdhGetCounterInfoA, PdhLib, 'PdhGetCounterInfoA');
  1949.   asm
  1950.     mov esp, ebp
  1951.     pop ebp
  1952.     jmp [_PdhGetCounterInfoA]
  1953.   end;
  1954. end;
  1955. {$ELSE}
  1956. function PdhGetCounterInfoA; external PdhLib name 'PdhGetCounterInfoA';
  1957. {$ENDIF DYNAMIC_LINK}
  1959. {$IFDEF DYNAMIC_LINK}
  1960. var
  1961.   _PdhGetCounterInfoW: Pointer;
  1963. function PdhGetCounterInfoW;
  1964. begin
  1965.   GetProcedureAddress(_PdhGetCounterInfoW, PdhLib, 'PdhGetCounterInfoW');
  1966.   asm
  1967.     mov esp, ebp
  1968.     pop ebp
  1969.     jmp [_PdhGetCounterInfoW]
  1970.   end;
  1971. end;
  1972. {$ELSE}
  1973. function PdhGetCounterInfoW; external PdhLib name 'PdhGetCounterInfoW';
  1974. {$ENDIF DYNAMIC_LINK}
  1975. {$IFDEF UNICODE}
  1977. {$IFDEF DYNAMIC_LINK}
  1978. var
  1979.   _PdhGetCounterInfo: Pointer;
  1981. function PdhGetCounterInfo;
  1982. begin
  1983.   GetProcedureAddress(_PdhGetCounterInfo, PdhLib, 'PdhGetCounterInfoW');
  1984.   asm
  1985.     mov esp, ebp
  1986.     pop ebp
  1987.     jmp [_PdhGetCounterInfo]
  1988.   end;
  1989. end;
  1990. {$ELSE}
  1991. function PdhGetCounterInfo; external PdhLib name 'PdhGetCounterInfoW';
  1992. {$ENDIF DYNAMIC_LINK}
  1993. {$ELSE}
  1995. {$IFDEF DYNAMIC_LINK}
  1996. var
  1997.   _PdhGetCounterInfo: Pointer;
  1999. function PdhGetCounterInfo;
  2000. begin
  2001.   GetProcedureAddress(_PdhGetCounterInfo, PdhLib, 'PdhGetCounterInfoA');
  2002.   asm
  2003.     mov esp, ebp
  2004.     pop ebp
  2005.     jmp [_PdhGetCounterInfo]
  2006.   end;
  2007. end;
  2008. {$ELSE}
  2009. function PdhGetCounterInfo; external PdhLib name 'PdhGetCounterInfoA';
  2010. {$ENDIF DYNAMIC_LINK}
  2011. {$ENDIF}
  2013. {$IFDEF DYNAMIC_LINK}
  2014. var
  2015.   _PdhSetCounterScaleFactor: Pointer;
  2017. function PdhSetCounterScaleFactor;
  2018. begin
  2019.   GetProcedureAddress(_PdhSetCounterScaleFactor, PdhLib, 'PdhSetCounterScaleFactor');
  2020.   asm
  2021.     mov esp, ebp
  2022.     pop ebp
  2023.     jmp [_PdhSetCounterScaleFactor]
  2024.   end;
  2025. end;
  2026. {$ELSE}
  2027. function PdhSetCounterScaleFactor; external PdhLib name 'PdhSetCounterScaleFactor';
  2028. {$ENDIF DYNAMIC_LINK}
  2030. {$IFDEF DYNAMIC_LINK}
  2031. var
  2032.   _PdhConnectMachineA: Pointer;
  2034. function PdhConnectMachineA;
  2035. begin
  2036.   GetProcedureAddress(_PdhConnectMachineA, PdhLib, 'PdhConnectMachineA');
  2037.   asm
  2038.     mov esp, ebp
  2039.     pop ebp
  2040.     jmp [_PdhConnectMachineA]
  2041.   end;
  2042. end;
  2043. {$ELSE}
  2044. function PdhConnectMachineA; external PdhLib name 'PdhConnectMachineA';
  2045. {$ENDIF DYNAMIC_LINK}
  2047. {$IFDEF DYNAMIC_LINK}
  2048. var
  2049.   _PdhConnectMachineW: Pointer;
  2051. function PdhConnectMachineW;
  2052. begin
  2053.   GetProcedureAddress(_PdhConnectMachineW, PdhLib, 'PdhConnectMachineW');
  2054.   asm
  2055.     mov esp, ebp
  2056.     pop ebp
  2057.     jmp [_PdhConnectMachineW]
  2058.   end;
  2059. end;
  2060. {$ELSE}
  2061. function PdhConnectMachineW; external PdhLib name 'PdhConnectMachineW';
  2062. {$ENDIF DYNAMIC_LINK}
  2063. {$IFDEF UNICODE}
  2065. {$IFDEF DYNAMIC_LINK}
  2066. var
  2067.   _PdhConnectMachine: Pointer;
  2069. function PdhConnectMachine;
  2070. begin
  2071.   GetProcedureAddress(_PdhConnectMachine, PdhLib, 'PdhConnectMachineW');
  2072.   asm
  2073.     mov esp, ebp
  2074.     pop ebp
  2075.     jmp [_PdhConnectMachine]
  2076.   end;
  2077. end;
  2078. {$ELSE}
  2079. function PdhConnectMachine; external PdhLib name 'PdhConnectMachineW';
  2080. {$ENDIF DYNAMIC_LINK}
  2081. {$ELSE}
  2083. {$IFDEF DYNAMIC_LINK}
  2084. var
  2085.   _PdhConnectMachine: Pointer;
  2087. function PdhConnectMachine;
  2088. begin
  2089.   GetProcedureAddress(_PdhConnectMachine, PdhLib, 'PdhConnectMachineA');
  2090.   asm
  2091.     mov esp, ebp
  2092.     pop ebp
  2093.     jmp [_PdhConnectMachine]
  2094.   end;
  2095. end;
  2096. {$ELSE}
  2097. function PdhConnectMachine; external PdhLib name 'PdhConnectMachineA';
  2098. {$ENDIF DYNAMIC_LINK}
  2099. {$ENDIF}
  2101. {$IFDEF DYNAMIC_LINK}
  2102. var
  2103.   _PdhEnumMachinesA: Pointer;
  2105. function PdhEnumMachinesA;
  2106. begin
  2107.   GetProcedureAddress(_PdhEnumMachinesA, PdhLib, 'PdhEnumMachinesA');
  2108.   asm
  2109.     mov esp, ebp
  2110.     pop ebp
  2111.     jmp [_PdhEnumMachinesA]
  2112.   end;
  2113. end;
  2114. {$ELSE}
  2115. function PdhEnumMachinesA; external PdhLib name 'PdhEnumMachinesA';
  2116. {$ENDIF DYNAMIC_LINK}
  2118. {$IFDEF DYNAMIC_LINK}
  2119. var
  2120.   _PdhEnumMachinesW: Pointer;
  2122. function PdhEnumMachinesW;
  2123. begin
  2124.   GetProcedureAddress(_PdhEnumMachinesW, PdhLib, 'PdhEnumMachinesW');
  2125.   asm
  2126.     mov esp, ebp
  2127.     pop ebp
  2128.     jmp [_PdhEnumMachinesW]
  2129.   end;
  2130. end;
  2131. {$ELSE}
  2132. function PdhEnumMachinesW; external PdhLib name 'PdhEnumMachinesW';
  2133. {$ENDIF DYNAMIC_LINK}
  2134. {$IFDEF UNICODE}
  2136. {$IFDEF DYNAMIC_LINK}
  2137. var
  2138.   _PdhEnumMachines: Pointer;
  2140. function PdhEnumMachines;
  2141. begin
  2142.   GetProcedureAddress(_PdhEnumMachines, PdhLib, 'PdhEnumMachinesW');
  2143.   asm
  2144.     mov esp, ebp
  2145.     pop ebp
  2146.     jmp [_PdhEnumMachines]
  2147.   end;
  2148. end;
  2149. {$ELSE}
  2150. function PdhEnumMachines; external PdhLib name 'PdhEnumMachinesW';
  2151. {$ENDIF DYNAMIC_LINK}
  2152. {$ELSE}
  2154. {$IFDEF DYNAMIC_LINK}
  2155. var
  2156.   _PdhEnumMachines: Pointer;
  2158. function PdhEnumMachines;
  2159. begin
  2160.   GetProcedureAddress(_PdhEnumMachines, PdhLib, 'PdhEnumMachinesA');
  2161.   asm
  2162.     mov esp, ebp
  2163.     pop ebp
  2164.     jmp [_PdhEnumMachines]
  2165.   end;
  2166. end;
  2167. {$ELSE}
  2168. function PdhEnumMachines; external PdhLib name 'PdhEnumMachinesA';
  2169. {$ENDIF DYNAMIC_LINK}
  2170. {$ENDIF}
  2172. {$IFDEF DYNAMIC_LINK}
  2173. var
  2174.   _PdhEnumObjectsA: Pointer;
  2176. function PdhEnumObjectsA;
  2177. begin
  2178.   GetProcedureAddress(_PdhEnumObjectsA, PdhLib, 'PdhEnumObjectsA');
  2179.   asm
  2180.     mov esp, ebp
  2181.     pop ebp
  2182.     jmp [_PdhEnumObjectsA]
  2183.   end;
  2184. end;
  2185. {$ELSE}
  2186. function PdhEnumObjectsA; external PdhLib name 'PdhEnumObjectsA';
  2187. {$ENDIF DYNAMIC_LINK}
  2189. {$IFDEF DYNAMIC_LINK}
  2190. var
  2191.   _PdhEnumObjectsW: Pointer;
  2193. function PdhEnumObjectsW;
  2194. begin
  2195.   GetProcedureAddress(_PdhEnumObjectsW, PdhLib, 'PdhEnumObjectsW');
  2196.   asm
  2197.     mov esp, ebp
  2198.     pop ebp
  2199.     jmp [_PdhEnumObjectsW]
  2200.   end;
  2201. end;
  2202. {$ELSE}
  2203. function PdhEnumObjectsW; external PdhLib name 'PdhEnumObjectsW';
  2204. {$ENDIF DYNAMIC_LINK}
  2205. {$IFDEF UNICODE}
  2207. {$IFDEF DYNAMIC_LINK}
  2208. var
  2209.   _PdhEnumObjects: Pointer;
  2211. function PdhEnumObjects;
  2212. begin
  2213.   GetProcedureAddress(_PdhEnumObjects, PdhLib, 'PdhEnumObjectsW');
  2214.   asm
  2215.     mov esp, ebp
  2216.     pop ebp
  2217.     jmp [_PdhEnumObjects]
  2218.   end;
  2219. end;
  2220. {$ELSE}
  2221. function PdhEnumObjects; external PdhLib name 'PdhEnumObjectsW';
  2222. {$ENDIF DYNAMIC_LINK}
  2223. {$ELSE}
  2225. {$IFDEF DYNAMIC_LINK}
  2226. var
  2227.   _PdhEnumObjects: Pointer;
  2229. function PdhEnumObjects;
  2230. begin
  2231.   GetProcedureAddress(_PdhEnumObjects, PdhLib, 'PdhEnumObjectsA');
  2232.   asm
  2233.     mov esp, ebp
  2234.     pop ebp
  2235.     jmp [_PdhEnumObjects]
  2236.   end;
  2237. end;
  2238. {$ELSE}
  2239. function PdhEnumObjects; external PdhLib name 'PdhEnumObjectsA';
  2240. {$ENDIF DYNAMIC_LINK}
  2241. {$ENDIF}
  2243. {$IFDEF DYNAMIC_LINK}
  2244. var
  2245.   _PdhEnumObjectItemsA: Pointer;
  2247. function PdhEnumObjectItemsA;
  2248. begin
  2249.   GetProcedureAddress(_PdhEnumObjectItemsA, PdhLib, 'PdhEnumObjectItemsA');
  2250.   asm
  2251.     mov esp, ebp
  2252.     pop ebp
  2253.     jmp [_PdhEnumObjectItemsA]
  2254.   end;
  2255. end;
  2256. {$ELSE}
  2257. function PdhEnumObjectItemsA; external PdhLib name 'PdhEnumObjectItemsA';
  2258. {$ENDIF DYNAMIC_LINK}
  2260. {$IFDEF DYNAMIC_LINK}
  2261. var
  2262.   _PdhEnumObjectItemsW: Pointer;
  2264. function PdhEnumObjectItemsW;
  2265. begin
  2266.   GetProcedureAddress(_PdhEnumObjectItemsW, PdhLib, 'PdhEnumObjectItemsW');
  2267.   asm
  2268.     mov esp, ebp
  2269.     pop ebp
  2270.     jmp [_PdhEnumObjectItemsW]
  2271.   end;
  2272. end;
  2273. {$ELSE}
  2274. function PdhEnumObjectItemsW; external PdhLib name 'PdhEnumObjectItemsW';
  2275. {$ENDIF DYNAMIC_LINK}
  2276. {$IFDEF UNICODE}
  2278. {$IFDEF DYNAMIC_LINK}
  2279. var
  2280.   _PdhEnumObjectItems: Pointer;
  2282. function PdhEnumObjectItems;
  2283. begin
  2284.   GetProcedureAddress(_PdhEnumObjectItems, PdhLib, 'PdhEnumObjectItemsW');
  2285.   asm
  2286.     mov esp, ebp
  2287.     pop ebp
  2288.     jmp [_PdhEnumObjectItems]
  2289.   end;
  2290. end;
  2291. {$ELSE}
  2292. function PdhEnumObjectItems; external PdhLib name 'PdhEnumObjectItemsW';
  2293. {$ENDIF DYNAMIC_LINK}
  2294. {$ELSE}
  2296. {$IFDEF DYNAMIC_LINK}
  2297. var
  2298.   _PdhEnumObjectItems: Pointer;
  2300. function PdhEnumObjectItems;
  2301. begin
  2302.   GetProcedureAddress(_PdhEnumObjectItems, PdhLib, 'PdhEnumObjectItemsA');
  2303.   asm
  2304.     mov esp, ebp
  2305.     pop ebp
  2306.     jmp [_PdhEnumObjectItems]
  2307.   end;
  2308. end;
  2309. {$ELSE}
  2310. function PdhEnumObjectItems; external PdhLib name 'PdhEnumObjectItemsA';
  2311. {$ENDIF DYNAMIC_LINK}
  2312. {$ENDIF}
  2314. {$IFDEF DYNAMIC_LINK}
  2315. var
  2316.   _PdhMakeCounterPathA: Pointer;
  2318. function PdhMakeCounterPathA;
  2319. begin
  2320.   GetProcedureAddress(_PdhMakeCounterPathA, PdhLib, 'PdhMakeCounterPathA');
  2321.   asm
  2322.     mov esp, ebp
  2323.     pop ebp
  2324.     jmp [_PdhMakeCounterPathA]
  2325.   end;
  2326. end;
  2327. {$ELSE}
  2328. function PdhMakeCounterPathA; external PdhLib name 'PdhMakeCounterPathA';
  2329. {$ENDIF DYNAMIC_LINK}
  2331. {$IFDEF DYNAMIC_LINK}
  2332. var
  2333.   _PdhMakeCounterPathW: Pointer;
  2335. function PdhMakeCounterPathW;
  2336. begin
  2337.   GetProcedureAddress(_PdhMakeCounterPathW, PdhLib, 'PdhMakeCounterPathW');
  2338.   asm
  2339.     mov esp, ebp
  2340.     pop ebp
  2341.     jmp [_PdhMakeCounterPathW]
  2342.   end;
  2343. end;
  2344. {$ELSE}
  2345. function PdhMakeCounterPathW; external PdhLib name 'PdhMakeCounterPathW';
  2346. {$ENDIF DYNAMIC_LINK}
  2347. {$IFDEF UNICODE}
  2349. {$IFDEF DYNAMIC_LINK}
  2350. var
  2351.   _PdhMakeCounterPath: Pointer;
  2353. function PdhMakeCounterPath;
  2354. begin
  2355.   GetProcedureAddress(_PdhMakeCounterPath, PdhLib, 'PdhMakeCounterPathW');
  2356.   asm
  2357.     mov esp, ebp
  2358.     pop ebp
  2359.     jmp [_PdhMakeCounterPath]
  2360.   end;
  2361. end;
  2362. {$ELSE}
  2363. function PdhMakeCounterPath; external PdhLib name 'PdhMakeCounterPathW';
  2364. {$ENDIF DYNAMIC_LINK}
  2365. {$ELSE}
  2367. {$IFDEF DYNAMIC_LINK}
  2368. var
  2369.   _PdhMakeCounterPath: Pointer;
  2371. function PdhMakeCounterPath;
  2372. begin
  2373.   GetProcedureAddress(_PdhMakeCounterPath, PdhLib, 'PdhMakeCounterPathA');
  2374.   asm
  2375.     mov esp, ebp
  2376.     pop ebp
  2377.     jmp [_PdhMakeCounterPath]
  2378.   end;
  2379. end;
  2380. {$ELSE}
  2381. function PdhMakeCounterPath; external PdhLib name 'PdhMakeCounterPathA';
  2382. {$ENDIF DYNAMIC_LINK}
  2383. {$ENDIF}
  2385. {$IFDEF DYNAMIC_LINK}
  2386. var
  2387.   _PdhParseCounterPathA: Pointer;
  2389. function PdhParseCounterPathA;
  2390. begin
  2391.   GetProcedureAddress(_PdhParseCounterPathA, PdhLib, 'PdhParseCounterPathA');
  2392.   asm
  2393.     mov esp, ebp
  2394.     pop ebp
  2395.     jmp [_PdhParseCounterPathA]
  2396.   end;
  2397. end;
  2398. {$ELSE}
  2399. function PdhParseCounterPathA; external PdhLib name 'PdhParseCounterPathA';
  2400. {$ENDIF DYNAMIC_LINK}
  2402. {$IFDEF DYNAMIC_LINK}
  2403. var
  2404.   _PdhParseCounterPathW: Pointer;
  2406. function PdhParseCounterPathW;
  2407. begin
  2408.   GetProcedureAddress(_PdhParseCounterPathW, PdhLib, 'PdhParseCounterPathW');
  2409.   asm
  2410.     mov esp, ebp
  2411.     pop ebp
  2412.     jmp [_PdhParseCounterPathW]
  2413.   end;
  2414. end;
  2415. {$ELSE}
  2416. function PdhParseCounterPathW; external PdhLib name 'PdhParseCounterPathW';
  2417. {$ENDIF DYNAMIC_LINK}
  2418. {$IFDEF UNICODE}
  2420. {$IFDEF DYNAMIC_LINK}
  2421. var
  2422.   _PdhParseCounterPath: Pointer;
  2424. function PdhParseCounterPath;
  2425. begin
  2426.   GetProcedureAddress(_PdhParseCounterPath, PdhLib, 'PdhParseCounterPathW');
  2427.   asm
  2428.     mov esp, ebp
  2429.     pop ebp
  2430.     jmp [_PdhParseCounterPath]
  2431.   end;
  2432. end;
  2433. {$ELSE}
  2434. function PdhParseCounterPath; external PdhLib name 'PdhParseCounterPathW';
  2435. {$ENDIF DYNAMIC_LINK}
  2436. {$ELSE}
  2438. {$IFDEF DYNAMIC_LINK}
  2439. var
  2440.   _PdhParseCounterPath: Pointer;
  2442. function PdhParseCounterPath;
  2443. begin
  2444.   GetProcedureAddress(_PdhParseCounterPath, PdhLib, 'PdhParseCounterPathA');
  2445.   asm
  2446.     mov esp, ebp
  2447.     pop ebp
  2448.     jmp [_PdhParseCounterPath]
  2449.   end;
  2450. end;
  2451. {$ELSE}
  2452. function PdhParseCounterPath; external PdhLib name 'PdhParseCounterPathA';
  2453. {$ENDIF DYNAMIC_LINK}
  2454. {$ENDIF}
  2456. function PDH_PATH_LANG_FLAGS(LangId, Flags: DWORD): DWORD;
  2457. begin
  2458.   Result := DWORD(((LangId and $0000FFFF) shl 16) or (Flags and $0000FFFF));
  2459. end;
  2462. {$IFDEF DYNAMIC_LINK}
  2463. var
  2464.   _PdhParseInstanceNameA: Pointer;
  2466. function PdhParseInstanceNameA;
  2467. begin
  2468.   GetProcedureAddress(_PdhParseInstanceNameA, PdhLib, 'PdhParseInstanceNameA');
  2469.   asm
  2470.     mov esp, ebp
  2471.     pop ebp
  2472.     jmp [_PdhParseInstanceNameA]
  2473.   end;
  2474. end;
  2475. {$ELSE}
  2476. function PdhParseInstanceNameA; external PdhLib name 'PdhParseInstanceNameA';
  2477. {$ENDIF DYNAMIC_LINK}
  2479. {$IFDEF DYNAMIC_LINK}
  2480. var
  2481.   _PdhParseInstanceNameW: Pointer;
  2483. function PdhParseInstanceNameW;
  2484. begin
  2485.   GetProcedureAddress(_PdhParseInstanceNameW, PdhLib, 'PdhParseInstanceNameW');
  2486.   asm
  2487.     mov esp, ebp
  2488.     pop ebp
  2489.     jmp [_PdhParseInstanceNameW]
  2490.   end;
  2491. end;
  2492. {$ELSE}
  2493. function PdhParseInstanceNameW; external PdhLib name 'PdhParseInstanceNameW';
  2494. {$ENDIF DYNAMIC_LINK}
  2495. {$IFDEF UNICODE}
  2497. {$IFDEF DYNAMIC_LINK}
  2498. var
  2499.   _PdhParseInstanceName: Pointer;
  2501. function PdhParseInstanceName;
  2502. begin
  2503.   GetProcedureAddress(_PdhParseInstanceName, PdhLib, 'PdhParseInstanceNameW');
  2504.   asm
  2505.     mov esp, ebp
  2506.     pop ebp
  2507.     jmp [_PdhParseInstanceName]
  2508.   end;
  2509. end;
  2510. {$ELSE}
  2511. function PdhParseInstanceName; external PdhLib name 'PdhParseInstanceNameW';
  2512. {$ENDIF DYNAMIC_LINK}
  2513. {$ELSE}
  2515. {$IFDEF DYNAMIC_LINK}
  2516. var
  2517.   _PdhParseInstanceName: Pointer;
  2519. function PdhParseInstanceName;
  2520. begin
  2521.   GetProcedureAddress(_PdhParseInstanceName, PdhLib, 'PdhParseInstanceNameA');
  2522.   asm
  2523.     mov esp, ebp
  2524.     pop ebp
  2525.     jmp [_PdhParseInstanceName]
  2526.   end;
  2527. end;
  2528. {$ELSE}
  2529. function PdhParseInstanceName; external PdhLib name 'PdhParseInstanceNameA';
  2530. {$ENDIF DYNAMIC_LINK}
  2531. {$ENDIF}
  2533. {$IFDEF DYNAMIC_LINK}
  2534. var
  2535.   _PdhValidatePathA: Pointer;
  2537. function PdhValidatePathA;
  2538. begin
  2539.   GetProcedureAddress(_PdhValidatePathA, PdhLib, 'PdhValidatePathA');
  2540.   asm
  2541.     mov esp, ebp
  2542.     pop ebp
  2543.     jmp [_PdhValidatePathA]
  2544.   end;
  2545. end;
  2546. {$ELSE}
  2547. function PdhValidatePathA; external PdhLib name 'PdhValidatePathA';
  2548. {$ENDIF DYNAMIC_LINK}
  2550. {$IFDEF DYNAMIC_LINK}
  2551. var
  2552.   _PdhValidatePathW: Pointer;
  2554. function PdhValidatePathW;
  2555. begin
  2556.   GetProcedureAddress(_PdhValidatePathW, PdhLib, 'PdhValidatePathW');
  2557.   asm
  2558.     mov esp, ebp
  2559.     pop ebp
  2560.     jmp [_PdhValidatePathW]
  2561.   end;
  2562. end;
  2563. {$ELSE}
  2564. function PdhValidatePathW; external PdhLib name 'PdhValidatePathW';
  2565. {$ENDIF DYNAMIC_LINK}
  2566. {$IFDEF UNICODE}
  2568. {$IFDEF DYNAMIC_LINK}
  2569. var
  2570.   _PdhValidatePath: Pointer;
  2572. function PdhValidatePath;
  2573. begin
  2574.   GetProcedureAddress(_PdhValidatePath, PdhLib, 'PdhValidatePathW');
  2575.   asm
  2576.     mov esp, ebp
  2577.     pop ebp
  2578.     jmp [_PdhValidatePath]
  2579.   end;
  2580. end;
  2581. {$ELSE}
  2582. function PdhValidatePath; external PdhLib name 'PdhValidatePathW';
  2583. {$ENDIF DYNAMIC_LINK}
  2584. {$ELSE}
  2586. {$IFDEF DYNAMIC_LINK}
  2587. var
  2588.   _PdhValidatePath: Pointer;
  2590. function PdhValidatePath;
  2591. begin
  2592.   GetProcedureAddress(_PdhValidatePath, PdhLib, 'PdhValidatePathA');
  2593.   asm
  2594.     mov esp, ebp
  2595.     pop ebp
  2596.     jmp [_PdhValidatePath]
  2597.   end;
  2598. end;
  2599. {$ELSE}
  2600. function PdhValidatePath; external PdhLib name 'PdhValidatePathA';
  2601. {$ENDIF DYNAMIC_LINK}
  2602. {$ENDIF}
  2604. {$IFDEF DYNAMIC_LINK}
  2605. var
  2606.   _PdhGetDefaultPerfObjectA: Pointer;
  2608. function PdhGetDefaultPerfObjectA;
  2609. begin
  2610.   GetProcedureAddress(_PdhGetDefaultPerfObjectA, PdhLib, 'PdhGetDefaultPerfObjectA');
  2611.   asm
  2612.     mov esp, ebp
  2613.     pop ebp
  2614.     jmp [_PdhGetDefaultPerfObjectA]
  2615.   end;
  2616. end;
  2617. {$ELSE}
  2618. function PdhGetDefaultPerfObjectA; external PdhLib name 'PdhGetDefaultPerfObjectA';
  2619. {$ENDIF DYNAMIC_LINK}
  2621. {$IFDEF DYNAMIC_LINK}
  2622. var
  2623.   _PdhGetDefaultPerfObjectW: Pointer;
  2625. function PdhGetDefaultPerfObjectW;
  2626. begin
  2627.   GetProcedureAddress(_PdhGetDefaultPerfObjectW, PdhLib, 'PdhGetDefaultPerfObjectW');
  2628.   asm
  2629.     mov esp, ebp
  2630.     pop ebp
  2631.     jmp [_PdhGetDefaultPerfObjectW]
  2632.   end;
  2633. end;
  2634. {$ELSE}
  2635. function PdhGetDefaultPerfObjectW; external PdhLib name 'PdhGetDefaultPerfObjectW';
  2636. {$ENDIF DYNAMIC_LINK}
  2637. {$IFDEF UNICODE}
  2639. {$IFDEF DYNAMIC_LINK}
  2640. var
  2641.   _PdhGetDefaultPerfObject: Pointer;
  2643. function PdhGetDefaultPerfObject;
  2644. begin
  2645.   GetProcedureAddress(_PdhGetDefaultPerfObject, PdhLib, 'PdhGetDefaultPerfObjectW');
  2646.   asm
  2647.     mov esp, ebp
  2648.     pop ebp
  2649.     jmp [_PdhGetDefaultPerfObject]
  2650.   end;
  2651. end;
  2652. {$ELSE}
  2653. function PdhGetDefaultPerfObject; external PdhLib name 'PdhGetDefaultPerfObjectW';
  2654. {$ENDIF DYNAMIC_LINK}
  2655. {$ELSE}
  2657. {$IFDEF DYNAMIC_LINK}
  2658. var
  2659.   _PdhGetDefaultPerfObject: Pointer;
  2661. function PdhGetDefaultPerfObject;
  2662. begin
  2663.   GetProcedureAddress(_PdhGetDefaultPerfObject, PdhLib, 'PdhGetDefaultPerfObjectA');
  2664.   asm
  2665.     mov esp, ebp
  2666.     pop ebp
  2667.     jmp [_PdhGetDefaultPerfObject]
  2668.   end;
  2669. end;
  2670. {$ELSE}
  2671. function PdhGetDefaultPerfObject; external PdhLib name 'PdhGetDefaultPerfObjectA';
  2672. {$ENDIF DYNAMIC_LINK}
  2673. {$ENDIF}
  2675. {$IFDEF DYNAMIC_LINK}
  2676. var
  2677.   _PdhGetDefaultPerfCounterA: Pointer;
  2679. function PdhGetDefaultPerfCounterA;
  2680. begin
  2681.   GetProcedureAddress(_PdhGetDefaultPerfCounterA, PdhLib, 'PdhGetDefaultPerfCounterA');
  2682.   asm
  2683.     mov esp, ebp
  2684.     pop ebp
  2685.     jmp [_PdhGetDefaultPerfCounterA]
  2686.   end;
  2687. end;
  2688. {$ELSE}
  2689. function PdhGetDefaultPerfCounterA; external PdhLib name 'PdhGetDefaultPerfCounterA';
  2690. {$ENDIF DYNAMIC_LINK}
  2692. {$IFDEF DYNAMIC_LINK}
  2693. var
  2694.   _PdhGetDefaultPerfCounterW: Pointer;
  2696. function PdhGetDefaultPerfCounterW;
  2697. begin
  2698.   GetProcedureAddress(_PdhGetDefaultPerfCounterW, PdhLib, 'PdhGetDefaultPerfCounterW');
  2699.   asm
  2700.     mov esp, ebp
  2701.     pop ebp
  2702.     jmp [_PdhGetDefaultPerfCounterW]
  2703.   end;
  2704. end;
  2705. {$ELSE}
  2706. function PdhGetDefaultPerfCounterW; external PdhLib name 'PdhGetDefaultPerfCounterW';
  2707. {$ENDIF DYNAMIC_LINK}
  2708. {$IFDEF UNICODE}
  2710. {$IFDEF DYNAMIC_LINK}
  2711. var
  2712.   _PdhGetDefaultPerfCounter: Pointer;
  2714. function PdhGetDefaultPerfCounter;
  2715. begin
  2716.   GetProcedureAddress(_PdhGetDefaultPerfCounter, PdhLib, 'PdhGetDefaultPerfCounterW');
  2717.   asm
  2718.     mov esp, ebp
  2719.     pop ebp
  2720.     jmp [_PdhGetDefaultPerfCounter]
  2721.   end;
  2722. end;
  2723. {$ELSE}
  2724. function PdhGetDefaultPerfCounter; external PdhLib name 'PdhGetDefaultPerfCounterW';
  2725. {$ENDIF DYNAMIC_LINK}
  2726. {$ELSE}
  2728. {$IFDEF DYNAMIC_LINK}
  2729. var
  2730.   _PdhGetDefaultPerfCounter: Pointer;
  2732. function PdhGetDefaultPerfCounter;
  2733. begin
  2734.   GetProcedureAddress(_PdhGetDefaultPerfCounter, PdhLib, 'PdhGetDefaultPerfCounterA');
  2735.   asm
  2736.     mov esp, ebp
  2737.     pop ebp
  2738.     jmp [_PdhGetDefaultPerfCounter]
  2739.   end;
  2740. end;
  2741. {$ELSE}
  2742. function PdhGetDefaultPerfCounter; external PdhLib name 'PdhGetDefaultPerfCounterA';
  2743. {$ENDIF DYNAMIC_LINK}
  2744. {$ENDIF}
  2746. {$IFDEF DYNAMIC_LINK}
  2747. var
  2748.   _PdhBrowseCountersA: Pointer;
  2750. function PdhBrowseCountersA;
  2751. begin
  2752.   GetProcedureAddress(_PdhBrowseCountersA, PdhLib, 'PdhBrowseCountersA');
  2753.   asm
  2754.     mov esp, ebp
  2755.     pop ebp
  2756.     jmp [_PdhBrowseCountersA]
  2757.   end;
  2758. end;
  2759. {$ELSE}
  2760. function PdhBrowseCountersA; external PdhLib name 'PdhBrowseCountersA';
  2761. {$ENDIF DYNAMIC_LINK}
  2763. {$IFDEF DYNAMIC_LINK}
  2764. var
  2765.   _PdhBrowseCountersW: Pointer;
  2767. function PdhBrowseCountersW;
  2768. begin
  2769.   GetProcedureAddress(_PdhBrowseCountersW, PdhLib, 'PdhBrowseCountersW');
  2770.   asm
  2771.     mov esp, ebp
  2772.     pop ebp
  2773.     jmp [_PdhBrowseCountersW]
  2774.   end;
  2775. end;
  2776. {$ELSE}
  2777. function PdhBrowseCountersW; external PdhLib name 'PdhBrowseCountersW';
  2778. {$ENDIF DYNAMIC_LINK}
  2779. {$IFDEF UNICODE}
  2781. {$IFDEF DYNAMIC_LINK}
  2782. var
  2783.   _PdhBrowseCounters: Pointer;
  2785. function PdhBrowseCounters;
  2786. begin
  2787.   GetProcedureAddress(_PdhBrowseCounters, PdhLib, 'PdhBrowseCountersW');
  2788.   asm
  2789.     mov esp, ebp
  2790.     pop ebp
  2791.     jmp [_PdhBrowseCounters]
  2792.   end;
  2793. end;
  2794. {$ELSE}
  2795. function PdhBrowseCounters; external PdhLib name 'PdhBrowseCountersW';
  2796. {$ENDIF DYNAMIC_LINK}
  2797. {$ELSE}
  2799. {$IFDEF DYNAMIC_LINK}
  2800. var
  2801.   _PdhBrowseCounters: Pointer;
  2803. function PdhBrowseCounters;
  2804. begin
  2805.   GetProcedureAddress(_PdhBrowseCounters, PdhLib, 'PdhBrowseCountersA');
  2806.   asm
  2807.     mov esp, ebp
  2808.     pop ebp
  2809.     jmp [_PdhBrowseCounters]
  2810.   end;
  2811. end;
  2812. {$ELSE}
  2813. function PdhBrowseCounters; external PdhLib name 'PdhBrowseCountersA';
  2814. {$ENDIF DYNAMIC_LINK}
  2815. {$ENDIF}
  2817. {$IFDEF DYNAMIC_LINK}
  2818. var
  2819.   _PdhExpandCounterPathA: Pointer;
  2821. function PdhExpandCounterPathA;
  2822. begin
  2823.   GetProcedureAddress(_PdhExpandCounterPathA, PdhLib, 'PdhExpandCounterPathA');
  2824.   asm
  2825.     mov esp, ebp
  2826.     pop ebp
  2827.     jmp [_PdhExpandCounterPathA]
  2828.   end;
  2829. end;
  2830. {$ELSE}
  2831. function PdhExpandCounterPathA; external PdhLib name 'PdhExpandCounterPathA';
  2832. {$ENDIF DYNAMIC_LINK}
  2834. {$IFDEF DYNAMIC_LINK}
  2835. var
  2836.   _PdhExpandCounterPathW: Pointer;
  2838. function PdhExpandCounterPathW;
  2839. begin
  2840.   GetProcedureAddress(_PdhExpandCounterPathW, PdhLib, 'PdhExpandCounterPathW');
  2841.   asm
  2842.     mov esp, ebp
  2843.     pop ebp
  2844.     jmp [_PdhExpandCounterPathW]
  2845.   end;
  2846. end;
  2847. {$ELSE}
  2848. function PdhExpandCounterPathW; external PdhLib name 'PdhExpandCounterPathW';
  2849. {$ENDIF DYNAMIC_LINK}
  2850. {$IFDEF UNICODE}
  2852. {$IFDEF DYNAMIC_LINK}
  2853. var
  2854.   _PdhExpandCounterPath: Pointer;
  2856. function PdhExpandCounterPath;
  2857. begin
  2858.   GetProcedureAddress(_PdhExpandCounterPath, PdhLib, 'PdhExpandCounterPathW');
  2859.   asm
  2860.     mov esp, ebp
  2861.     pop ebp
  2862.     jmp [_PdhExpandCounterPath]
  2863.   end;
  2864. end;
  2865. {$ELSE}
  2866. function PdhExpandCounterPath; external PdhLib name 'PdhExpandCounterPathW';
  2867. {$ENDIF DYNAMIC_LINK}
  2868. {$ELSE}
  2870. {$IFDEF DYNAMIC_LINK}
  2871. var
  2872.   _PdhExpandCounterPath: Pointer;
  2874. function PdhExpandCounterPath;
  2875. begin
  2876.   GetProcedureAddress(_PdhExpandCounterPath, PdhLib, 'PdhExpandCounterPathA');
  2877.   asm
  2878.     mov esp, ebp
  2879.     pop ebp
  2880.     jmp [_PdhExpandCounterPath]
  2881.   end;
  2882. end;
  2883. {$ELSE}
  2884. function PdhExpandCounterPath; external PdhLib name 'PdhExpandCounterPathA';
  2885. {$ENDIF DYNAMIC_LINK}
  2886. {$ENDIF}
  2888. {$IFDEF DYNAMIC_LINK}
  2889. var
  2890.   _PdhLookupPerfNameByIndexA: Pointer;
  2892. function PdhLookupPerfNameByIndexA;
  2893. begin
  2894.   GetProcedureAddress(_PdhLookupPerfNameByIndexA, PdhLib, 'PdhLookupPerfNameByIndexA');
  2895.   asm
  2896.     mov esp, ebp
  2897.     pop ebp
  2898.     jmp [_PdhLookupPerfNameByIndexA]
  2899.   end;
  2900. end;
  2901. {$ELSE}
  2902. function PdhLookupPerfNameByIndexA; external PdhLib name 'PdhLookupPerfNameByIndexA';
  2903. {$ENDIF DYNAMIC_LINK}
  2905. {$IFDEF DYNAMIC_LINK}
  2906. var
  2907.   _PdhLookupPerfNameByIndexW: Pointer;
  2909. function PdhLookupPerfNameByIndexW;
  2910. begin
  2911.   GetProcedureAddress(_PdhLookupPerfNameByIndexW, PdhLib, 'PdhLookupPerfNameByIndexW');
  2912.   asm
  2913.     mov esp, ebp
  2914.     pop ebp
  2915.     jmp [_PdhLookupPerfNameByIndexW]
  2916.   end;
  2917. end;
  2918. {$ELSE}
  2919. function PdhLookupPerfNameByIndexW; external PdhLib name 'PdhLookupPerfNameByIndexW';
  2920. {$ENDIF DYNAMIC_LINK}
  2921. {$IFDEF UNICODE}
  2923. {$IFDEF DYNAMIC_LINK}
  2924. var
  2925.   _PdhLookupPerfNameByIndex: Pointer;
  2927. function PdhLookupPerfNameByIndex;
  2928. begin
  2929.   GetProcedureAddress(_PdhLookupPerfNameByIndex, PdhLib, 'PdhLookupPerfNameByIndexW');
  2930.   asm
  2931.     mov esp, ebp
  2932.     pop ebp
  2933.     jmp [_PdhLookupPerfNameByIndex]
  2934.   end;
  2935. end;
  2936. {$ELSE}
  2937. function PdhLookupPerfNameByIndex; external PdhLib name 'PdhLookupPerfNameByIndexW';
  2938. {$ENDIF DYNAMIC_LINK}
  2939. {$ELSE}
  2941. {$IFDEF DYNAMIC_LINK}
  2942. var
  2943.   _PdhLookupPerfNameByIndex: Pointer;
  2945. function PdhLookupPerfNameByIndex;
  2946. begin
  2947.   GetProcedureAddress(_PdhLookupPerfNameByIndex, PdhLib, 'PdhLookupPerfNameByIndexA');
  2948.   asm
  2949.     mov esp, ebp
  2950.     pop ebp
  2951.     jmp [_PdhLookupPerfNameByIndex]
  2952.   end;
  2953. end;
  2954. {$ELSE}
  2955. function PdhLookupPerfNameByIndex; external PdhLib name 'PdhLookupPerfNameByIndexA';
  2956. {$ENDIF DYNAMIC_LINK}
  2957. {$ENDIF}
  2959. {$IFDEF DYNAMIC_LINK}
  2960. var
  2961.   _PdhLookupPerfIndexByNameA: Pointer;
  2963. function PdhLookupPerfIndexByNameA;
  2964. begin
  2965.   GetProcedureAddress(_PdhLookupPerfIndexByNameA, PdhLib, 'PdhLookupPerfIndexByNameA');
  2966.   asm
  2967.     mov esp, ebp
  2968.     pop ebp
  2969.     jmp [_PdhLookupPerfIndexByNameA]
  2970.   end;
  2971. end;
  2972. {$ELSE}
  2973. function PdhLookupPerfIndexByNameA; external PdhLib name 'PdhLookupPerfIndexByNameA';
  2974. {$ENDIF DYNAMIC_LINK}
  2976. {$IFDEF DYNAMIC_LINK}
  2977. var
  2978.   _PdhLookupPerfIndexByNameW: Pointer;
  2980. function PdhLookupPerfIndexByNameW;
  2981. begin
  2982.   GetProcedureAddress(_PdhLookupPerfIndexByNameW, PdhLib, 'PdhLookupPerfIndexByNameW');
  2983.   asm
  2984.     mov esp, ebp
  2985.     pop ebp
  2986.     jmp [_PdhLookupPerfIndexByNameW]
  2987.   end;
  2988. end;
  2989. {$ELSE}
  2990. function PdhLookupPerfIndexByNameW; external PdhLib name 'PdhLookupPerfIndexByNameW';
  2991. {$ENDIF DYNAMIC_LINK}
  2992. {$IFDEF UNICODE}
  2994. {$IFDEF DYNAMIC_LINK}
  2995. var
  2996.   _PdhLookupPerfIndexByName: Pointer;
  2998. function PdhLookupPerfIndexByName;
  2999. begin
  3000.   GetProcedureAddress(_PdhLookupPerfIndexByName, PdhLib, 'PdhLookupPerfIndexByNameW');
  3001.   asm
  3002.     mov esp, ebp
  3003.     pop ebp
  3004.     jmp [_PdhLookupPerfIndexByName]
  3005.   end;
  3006. end;
  3007. {$ELSE}
  3008. function PdhLookupPerfIndexByName; external PdhLib name 'PdhLookupPerfIndexByNameW';
  3009. {$ENDIF DYNAMIC_LINK}
  3010. {$ELSE}
  3012. {$IFDEF DYNAMIC_LINK}
  3013. var
  3014.   _PdhLookupPerfIndexByName: Pointer;
  3016. function PdhLookupPerfIndexByName;
  3017. begin
  3018.   GetProcedureAddress(_PdhLookupPerfIndexByName, PdhLib, 'PdhLookupPerfIndexByNameA');
  3019.   asm
  3020.     mov esp, ebp
  3021.     pop ebp
  3022.     jmp [_PdhLookupPerfIndexByName]
  3023.   end;
  3024. end;
  3025. {$ELSE}
  3026. function PdhLookupPerfIndexByName; external PdhLib name 'PdhLookupPerfIndexByNameA';
  3027. {$ENDIF DYNAMIC_LINK}
  3028. {$ENDIF}
  3030. {$IFDEF DYNAMIC_LINK}
  3031. var
  3032.   _PdhExpandWildCardPathA: Pointer;
  3034. function PdhExpandWildCardPathA;
  3035. begin
  3036.   GetProcedureAddress(_PdhExpandWildCardPathA, PdhLib, 'PdhExpandWildCardPathA');
  3037.   asm
  3038.     mov esp, ebp
  3039.     pop ebp
  3040.     jmp [_PdhExpandWildCardPathA]
  3041.   end;
  3042. end;
  3043. {$ELSE}
  3044. function PdhExpandWildCardPathA; external PdhLib name 'PdhExpandWildCardPathA';
  3045. {$ENDIF DYNAMIC_LINK}
  3047. {$IFDEF DYNAMIC_LINK}
  3048. var
  3049.   _PdhExpandWildCardPathW: Pointer;
  3051. function PdhExpandWildCardPathW;
  3052. begin
  3053.   GetProcedureAddress(_PdhExpandWildCardPathW, PdhLib, 'PdhExpandWildCardPathW');
  3054.   asm
  3055.     mov esp, ebp
  3056.     pop ebp
  3057.     jmp [_PdhExpandWildCardPathW]
  3058.   end;
  3059. end;
  3060. {$ELSE}
  3061. function PdhExpandWildCardPathW; external PdhLib name 'PdhExpandWildCardPathW';
  3062. {$ENDIF DYNAMIC_LINK}
  3063. {$IFDEF UNICODE}
  3065. {$IFDEF DYNAMIC_LINK}
  3066. var
  3067.   _PdhExpandWildCardPath: Pointer;
  3069. function PdhExpandWildCardPath;
  3070. begin
  3071.   GetProcedureAddress(_PdhExpandWildCardPath, PdhLib, 'PdhExpandWildCardPathW');
  3072.   asm
  3073.     mov esp, ebp
  3074.     pop ebp
  3075.     jmp [_PdhExpandWildCardPath]
  3076.   end;
  3077. end;
  3078. {$ELSE}
  3079. function PdhExpandWildCardPath; external PdhLib name 'PdhExpandWildCardPathW';
  3080. {$ENDIF DYNAMIC_LINK}
  3081. {$ELSE}
  3083. {$IFDEF DYNAMIC_LINK}
  3084. var
  3085.   _PdhExpandWildCardPath: Pointer;
  3087. function PdhExpandWildCardPath;
  3088. begin
  3089.   GetProcedureAddress(_PdhExpandWildCardPath, PdhLib, 'PdhExpandWildCardPathA');
  3090.   asm
  3091.     mov esp, ebp
  3092.     pop ebp
  3093.     jmp [_PdhExpandWildCardPath]
  3094.   end;
  3095. end;
  3096. {$ELSE}
  3097. function PdhExpandWildCardPath; external PdhLib name 'PdhExpandWildCardPathA';
  3098. {$ENDIF DYNAMIC_LINK}
  3099. {$ENDIF}
  3101. {$IFDEF DYNAMIC_LINK}
  3102. var
  3103.   _PdhOpenLogA: Pointer;
  3105. function PdhOpenLogA;
  3106. begin
  3107.   GetProcedureAddress(_PdhOpenLogA, PdhLib, 'PdhOpenLogA');
  3108.   asm
  3109.     mov esp, ebp
  3110.     pop ebp
  3111.     jmp [_PdhOpenLogA]
  3112.   end;
  3113. end;
  3114. {$ELSE}
  3115. function PdhOpenLogA; external PdhLib name 'PdhOpenLogA';
  3116. {$ENDIF DYNAMIC_LINK}
  3118. {$IFDEF DYNAMIC_LINK}
  3119. var
  3120.   _PdhOpenLogW: Pointer;
  3122. function PdhOpenLogW;
  3123. begin
  3124.   GetProcedureAddress(_PdhOpenLogW, PdhLib, 'PdhOpenLogW');
  3125.   asm
  3126.     mov esp, ebp
  3127.     pop ebp
  3128.     jmp [_PdhOpenLogW]
  3129.   end;
  3130. end;
  3131. {$ELSE}
  3132. function PdhOpenLogW; external PdhLib name 'PdhOpenLogW';
  3133. {$ENDIF DYNAMIC_LINK}
  3134. {$IFDEF UNICODE}
  3136. {$IFDEF DYNAMIC_LINK}
  3137. var
  3138.   _PdhOpenLog: Pointer;
  3140. function PdhOpenLog;
  3141. begin
  3142.   GetProcedureAddress(_PdhOpenLog, PdhLib, 'PdhOpenLogW');
  3143.   asm
  3144.     mov esp, ebp
  3145.     pop ebp
  3146.     jmp [_PdhOpenLog]
  3147.   end;
  3148. end;
  3149. {$ELSE}
  3150. function PdhOpenLog; external PdhLib name 'PdhOpenLogW';
  3151. {$ENDIF DYNAMIC_LINK}
  3152. {$ELSE}
  3154. {$IFDEF DYNAMIC_LINK}
  3155. var
  3156.   _PdhOpenLog: Pointer;
  3158. function PdhOpenLog;
  3159. begin
  3160.   GetProcedureAddress(_PdhOpenLog, PdhLib, 'PdhOpenLogA');
  3161.   asm
  3162.     mov esp, ebp
  3163.     pop ebp
  3164.     jmp [_PdhOpenLog]
  3165.   end;
  3166. end;
  3167. {$ELSE}
  3168. function PdhOpenLog; external PdhLib name 'PdhOpenLogA';
  3169. {$ENDIF DYNAMIC_LINK}
  3170. {$ENDIF}
  3172. {$IFDEF DYNAMIC_LINK}
  3173. var
  3174.   _PdhUpdateLogA: Pointer;
  3176. function PdhUpdateLogA;
  3177. begin
  3178.   GetProcedureAddress(_PdhUpdateLogA, PdhLib, 'PdhUpdateLogA');
  3179.   asm
  3180.     mov esp, ebp
  3181.     pop ebp
  3182.     jmp [_PdhUpdateLogA]
  3183.   end;
  3184. end;
  3185. {$ELSE}
  3186. function PdhUpdateLogA; external PdhLib name 'PdhUpdateLogA';
  3187. {$ENDIF DYNAMIC_LINK}
  3189. {$IFDEF DYNAMIC_LINK}
  3190. var
  3191.   _PdhUpdateLogW: Pointer;
  3193. function PdhUpdateLogW;
  3194. begin
  3195.   GetProcedureAddress(_PdhUpdateLogW, PdhLib, 'PdhUpdateLogW');
  3196.   asm
  3197.     mov esp, ebp
  3198.     pop ebp
  3199.     jmp [_PdhUpdateLogW]
  3200.   end;
  3201. end;
  3202. {$ELSE}
  3203. function PdhUpdateLogW; external PdhLib name 'PdhUpdateLogW';
  3204. {$ENDIF DYNAMIC_LINK}
  3205. {$IFDEF UNICODE}
  3207. {$IFDEF DYNAMIC_LINK}
  3208. var
  3209.   _PdhUpdateLog: Pointer;
  3211. function PdhUpdateLog;
  3212. begin
  3213.   GetProcedureAddress(_PdhUpdateLog, PdhLib, 'PdhUpdateLogW');
  3214.   asm
  3215.     mov esp, ebp
  3216.     pop ebp
  3217.     jmp [_PdhUpdateLog]
  3218.   end;
  3219. end;
  3220. {$ELSE}
  3221. function PdhUpdateLog; external PdhLib name 'PdhUpdateLogW';
  3222. {$ENDIF DYNAMIC_LINK}
  3223. {$ELSE}
  3225. {$IFDEF DYNAMIC_LINK}
  3226. var
  3227.   _PdhUpdateLog: Pointer;
  3229. function PdhUpdateLog;
  3230. begin
  3231.   GetProcedureAddress(_PdhUpdateLog, PdhLib, 'PdhUpdateLogA');
  3232.   asm
  3233.     mov esp, ebp
  3234.     pop ebp
  3235.     jmp [_PdhUpdateLog]
  3236.   end;
  3237. end;
  3238. {$ELSE}
  3239. function PdhUpdateLog; external PdhLib name 'PdhUpdateLogA';
  3240. {$ENDIF DYNAMIC_LINK}
  3241. {$ENDIF}
  3243. {$IFDEF DYNAMIC_LINK}
  3244. var
  3245.   _PdhUpdateLogFileCatalog: Pointer;
  3247. function PdhUpdateLogFileCatalog;
  3248. begin
  3249.   GetProcedureAddress(_PdhUpdateLogFileCatalog, PdhLib, 'PdhUpdateLogFileCatalog');
  3250.   asm
  3251.     mov esp, ebp
  3252.     pop ebp
  3253.     jmp [_PdhUpdateLogFileCatalog]
  3254.   end;
  3255. end;
  3256. {$ELSE}
  3257. function PdhUpdateLogFileCatalog; external PdhLib name 'PdhUpdateLogFileCatalog';
  3258. {$ENDIF DYNAMIC_LINK}
  3260. {$IFDEF DYNAMIC_LINK}
  3261. var
  3262.   _PdhGetLogFileSize: Pointer;
  3264. function PdhGetLogFileSize;
  3265. begin
  3266.   GetProcedureAddress(_PdhGetLogFileSize, PdhLib, 'PdhGetLogFileSize');
  3267.   asm
  3268.     mov esp, ebp
  3269.     pop ebp
  3270.     jmp [_PdhGetLogFileSize]
  3271.   end;
  3272. end;
  3273. {$ELSE}
  3274. function PdhGetLogFileSize; external PdhLib name 'PdhGetLogFileSize';
  3275. {$ENDIF DYNAMIC_LINK}
  3277. {$IFDEF DYNAMIC_LINK}
  3278. var
  3279.   _PdhCloseLog: Pointer;
  3281. function PdhCloseLog;
  3282. begin
  3283.   GetProcedureAddress(_PdhCloseLog, PdhLib, 'PdhCloseLog');
  3284.   asm
  3285.     mov esp, ebp
  3286.     pop ebp
  3287.     jmp [_PdhCloseLog]
  3288.   end;
  3289. end;
  3290. {$ELSE}
  3291. function PdhCloseLog; external PdhLib name 'PdhCloseLog';
  3292. {$ENDIF DYNAMIC_LINK}
  3294. {$IFDEF DYNAMIC_LINK}
  3295. var
  3296.   _PdhSelectDataSourceA: Pointer;
  3298. function PdhSelectDataSourceA;
  3299. begin
  3300.   GetProcedureAddress(_PdhSelectDataSourceA, PdhLib, 'PdhSelectDataSourceA');
  3301.   asm
  3302.     mov esp, ebp
  3303.     pop ebp
  3304.     jmp [_PdhSelectDataSourceA]
  3305.   end;
  3306. end;
  3307. {$ELSE}
  3308. function PdhSelectDataSourceA; external PdhLib name 'PdhSelectDataSourceA';
  3309. {$ENDIF DYNAMIC_LINK}
  3311. {$IFDEF DYNAMIC_LINK}
  3312. var
  3313.   _PdhSelectDataSourceW: Pointer;
  3315. function PdhSelectDataSourceW;
  3316. begin
  3317.   GetProcedureAddress(_PdhSelectDataSourceW, PdhLib, 'PdhSelectDataSourceW');
  3318.   asm
  3319.     mov esp, ebp
  3320.     pop ebp
  3321.     jmp [_PdhSelectDataSourceW]
  3322.   end;
  3323. end;
  3324. {$ELSE}
  3325. function PdhSelectDataSourceW; external PdhLib name 'PdhSelectDataSourceW';
  3326. {$ENDIF DYNAMIC_LINK}
  3327. {$IFDEF UNICODE}
  3329. {$IFDEF DYNAMIC_LINK}
  3330. var
  3331.   _PdhSelectDataSource: Pointer;
  3333. function PdhSelectDataSource;
  3334. begin
  3335.   GetProcedureAddress(_PdhSelectDataSource, PdhLib, 'PdhSelectDataSourceW');
  3336.   asm
  3337.     mov esp, ebp
  3338.     pop ebp
  3339.     jmp [_PdhSelectDataSource]
  3340.   end;
  3341. end;
  3342. {$ELSE}
  3343. function PdhSelectDataSource; external PdhLib name 'PdhSelectDataSourceW';
  3344. {$ENDIF DYNAMIC_LINK}
  3345. {$ELSE}
  3347. {$IFDEF DYNAMIC_LINK}
  3348. var
  3349.   _PdhSelectDataSource: Pointer;
  3351. function PdhSelectDataSource;
  3352. begin
  3353.   GetProcedureAddress(_PdhSelectDataSource, PdhLib, 'PdhSelectDataSourceA');
  3354.   asm
  3355.     mov esp, ebp
  3356.     pop ebp
  3357.     jmp [_PdhSelectDataSource]
  3358.   end;
  3359. end;
  3360. {$ELSE}
  3361. function PdhSelectDataSource; external PdhLib name 'PdhSelectDataSourceA';
  3362. {$ENDIF DYNAMIC_LINK}
  3363. {$ENDIF}
  3365. {$IFDEF DYNAMIC_LINK}
  3366. var
  3367.   _PdhIsRealTimeQuery: Pointer;
  3369. function PdhIsRealTimeQuery;
  3370. begin
  3371.   GetProcedureAddress(_PdhIsRealTimeQuery, PdhLib, 'PdhIsRealTimeQuery');
  3372.   asm
  3373.     mov esp, ebp
  3374.     pop ebp
  3375.     jmp [_PdhIsRealTimeQuery]
  3376.   end;
  3377. end;
  3378. {$ELSE}
  3379. function PdhIsRealTimeQuery; external PdhLib name 'PdhIsRealTimeQuery';
  3380. {$ENDIF DYNAMIC_LINK}
  3382. {$IFDEF DYNAMIC_LINK}
  3383. var
  3384.   _PdhSetQueryTimeRange: Pointer;
  3386. function PdhSetQueryTimeRange;
  3387. begin
  3388.   GetProcedureAddress(_PdhSetQueryTimeRange, PdhLib, 'PdhSetQueryTimeRange');
  3389.   asm
  3390.     mov esp, ebp
  3391.     pop ebp
  3392.     jmp [_PdhSetQueryTimeRange]
  3393.   end;
  3394. end;
  3395. {$ELSE}
  3396. function PdhSetQueryTimeRange; external PdhLib name 'PdhSetQueryTimeRange';
  3397. {$ENDIF DYNAMIC_LINK}
  3399. {$IFDEF DYNAMIC_LINK}
  3400. var
  3401.   _PdhGetDataSourceTimeRangeA: Pointer;
  3403. function PdhGetDataSourceTimeRangeA;
  3404. begin
  3405.   GetProcedureAddress(_PdhGetDataSourceTimeRangeA, PdhLib, 'PdhGetDataSourceTimeRangeA');
  3406.   asm
  3407.     mov esp, ebp
  3408.     pop ebp
  3409.     jmp [_PdhGetDataSourceTimeRangeA]
  3410.   end;
  3411. end;
  3412. {$ELSE}
  3413. function PdhGetDataSourceTimeRangeA; external PdhLib name 'PdhGetDataSourceTimeRangeA';
  3414. {$ENDIF DYNAMIC_LINK}
  3416. {$IFDEF DYNAMIC_LINK}
  3417. var
  3418.   _PdhGetDataSourceTimeRangeW: Pointer;
  3420. function PdhGetDataSourceTimeRangeW;
  3421. begin
  3422.   GetProcedureAddress(_PdhGetDataSourceTimeRangeW, PdhLib, 'PdhGetDataSourceTimeRangeW');
  3423.   asm
  3424.     mov esp, ebp
  3425.     pop ebp
  3426.     jmp [_PdhGetDataSourceTimeRangeW]
  3427.   end;
  3428. end;
  3429. {$ELSE}
  3430. function PdhGetDataSourceTimeRangeW; external PdhLib name 'PdhGetDataSourceTimeRangeW';
  3431. {$ENDIF DYNAMIC_LINK}
  3432. {$IFDEF UNICODE}
  3434. {$IFDEF DYNAMIC_LINK}
  3435. var
  3436.   _PdhGetDataSourceTimeRange: Pointer;
  3438. function PdhGetDataSourceTimeRange;
  3439. begin
  3440.   GetProcedureAddress(_PdhGetDataSourceTimeRange, PdhLib, 'PdhGetDataSourceTimeRangeW');
  3441.   asm
  3442.     mov esp, ebp
  3443.     pop ebp
  3444.     jmp [_PdhGetDataSourceTimeRange]
  3445.   end;
  3446. end;
  3447. {$ELSE}
  3448. function PdhGetDataSourceTimeRange; external PdhLib name 'PdhGetDataSourceTimeRangeW';
  3449. {$ENDIF DYNAMIC_LINK}
  3450. {$ELSE}
  3452. {$IFDEF DYNAMIC_LINK}
  3453. var
  3454.   _PdhGetDataSourceTimeRange: Pointer;
  3456. function PdhGetDataSourceTimeRange;
  3457. begin
  3458.   GetProcedureAddress(_PdhGetDataSourceTimeRange, PdhLib, 'PdhGetDataSourceTimeRangeA');
  3459.   asm
  3460.     mov esp, ebp
  3461.     pop ebp
  3462.     jmp [_PdhGetDataSourceTimeRange]
  3463.   end;
  3464. end;
  3465. {$ELSE}
  3466. function PdhGetDataSourceTimeRange; external PdhLib name 'PdhGetDataSourceTimeRangeA';
  3467. {$ENDIF DYNAMIC_LINK}
  3468. {$ENDIF}
  3470. {$IFDEF DYNAMIC_LINK}
  3471. var
  3472.   _PdhCollectQueryDataEx: Pointer;
  3474. function PdhCollectQueryDataEx;
  3475. begin
  3476.   GetProcedureAddress(_PdhCollectQueryDataEx, PdhLib, 'PdhCollectQueryDataEx');
  3477.   asm
  3478.     mov esp, ebp
  3479.     pop ebp
  3480.     jmp [_PdhCollectQueryDataEx]
  3481.   end;
  3482. end;
  3483. {$ELSE}
  3484. function PdhCollectQueryDataEx; external PdhLib name 'PdhCollectQueryDataEx';
  3485. {$ENDIF DYNAMIC_LINK}
  3487. {$IFDEF DYNAMIC_LINK}
  3488. var
  3489.   _PdhFormatFromRawValue: Pointer;
  3491. function PdhFormatFromRawValue;
  3492. begin
  3493.   GetProcedureAddress(_PdhFormatFromRawValue, PdhLib, 'PdhFormatFromRawValue');
  3494.   asm
  3495.     mov esp, ebp
  3496.     pop ebp
  3497.     jmp [_PdhFormatFromRawValue]
  3498.   end;
  3499. end;
  3500. {$ELSE}
  3501. function PdhFormatFromRawValue; external PdhLib name 'PdhFormatFromRawValue';
  3502. {$ENDIF DYNAMIC_LINK}
  3504. {$IFDEF DYNAMIC_LINK}
  3505. var
  3506.   _PdhGetCounterTimeBase: Pointer;
  3508. function PdhGetCounterTimeBase;
  3509. begin
  3510.   GetProcedureAddress(_PdhGetCounterTimeBase, PdhLib, 'PdhGetCounterTimeBase');
  3511.   asm
  3512.     mov esp, ebp
  3513.     pop ebp
  3514.     jmp [_PdhGetCounterTimeBase]
  3515.   end;
  3516. end;
  3517. {$ELSE}
  3518. function PdhGetCounterTimeBase; external PdhLib name 'PdhGetCounterTimeBase';
  3519. {$ENDIF DYNAMIC_LINK}
  3521. {$IFDEF DYNAMIC_LINK}
  3522. var
  3523.   _PdhReadRawLogRecord: Pointer;
  3525. function PdhReadRawLogRecord;
  3526. begin
  3527.   GetProcedureAddress(_PdhReadRawLogRecord, PdhLib, 'PdhReadRawLogRecord');
  3528.   asm
  3529.     mov esp, ebp
  3530.     pop ebp
  3531.     jmp [_PdhReadRawLogRecord]
  3532.   end;
  3533. end;
  3534. {$ELSE}
  3535. function PdhReadRawLogRecord; external PdhLib name 'PdhReadRawLogRecord';
  3536. {$ENDIF DYNAMIC_LINK}
  3538. {$IFDEF DYNAMIC_LINK}
  3539. var
  3540.   _PdhSetDefaultRealTimeDataSource: Pointer;
  3542. function PdhSetDefaultRealTimeDataSource;
  3543. begin
  3544.   GetProcedureAddress(_PdhSetDefaultRealTimeDataSource, PdhLib, 'PdhSetDefaultRealTimeDataSource');
  3545.   asm
  3546.     mov esp, ebp
  3547.     pop ebp
  3548.     jmp [_PdhSetDefaultRealTimeDataSource]
  3549.   end;
  3550. end;
  3551. {$ELSE}
  3552. function PdhSetDefaultRealTimeDataSource; external PdhLib name 'PdhSetDefaultRealTimeDataSource';
  3553. {$ENDIF DYNAMIC_LINK}
  3555. {$IFDEF DYNAMIC_LINK}
  3556. var
  3557.   _PdhBindInputDataSourceW: Pointer;
  3559. function PdhBindInputDataSourceW;
  3560. begin
  3561.   GetProcedureAddress(_PdhBindInputDataSourceW, PdhLib, 'PdhBindInputDataSourceW');
  3562.   asm
  3563.     mov esp, ebp
  3564.     pop ebp
  3565.     jmp [_PdhBindInputDataSourceW]
  3566.   end;
  3567. end;
  3568. {$ELSE}
  3569. function PdhBindInputDataSourceW; external PdhLib name 'PdhBindInputDataSourceW';
  3570. {$ENDIF DYNAMIC_LINK}
  3572. {$IFDEF DYNAMIC_LINK}
  3573. var
  3574.   _PdhBindInputDataSourceA: Pointer;
  3576. function PdhBindInputDataSourceA;
  3577. begin
  3578.   GetProcedureAddress(_PdhBindInputDataSourceA, PdhLib, 'PdhBindInputDataSourceA');
  3579.   asm
  3580.     mov esp, ebp
  3581.     pop ebp
  3582.     jmp [_PdhBindInputDataSourceA]
  3583.   end;
  3584. end;
  3585. {$ELSE}
  3586. function PdhBindInputDataSourceA; external PdhLib name 'PdhBindInputDataSourceA';
  3587. {$ENDIF DYNAMIC_LINK}
  3588. {$IFDEF UNICODE}
  3590. {$IFDEF DYNAMIC_LINK}
  3591. var
  3592.   _PdhBindInputDataSource: Pointer;
  3594. function PdhBindInputDataSource;
  3595. begin
  3596.   GetProcedureAddress(_PdhBindInputDataSource, PdhLib, 'PdhBindInputDataSourceW');
  3597.   asm
  3598.     mov esp, ebp
  3599.     pop ebp
  3600.     jmp [_PdhBindInputDataSource]
  3601.   end;
  3602. end;
  3603. {$ELSE}
  3604. function PdhBindInputDataSource; external PdhLib name 'PdhBindInputDataSourceW';
  3605. {$ENDIF DYNAMIC_LINK}
  3606. {$ELSE}
  3608. {$IFDEF DYNAMIC_LINK}
  3609. var
  3610.   _PdhBindInputDataSource: Pointer;
  3612. function PdhBindInputDataSource;
  3613. begin
  3614.   GetProcedureAddress(_PdhBindInputDataSource, PdhLib, 'PdhBindInputDataSourceA');
  3615.   asm
  3616.     mov esp, ebp
  3617.     pop ebp
  3618.     jmp [_PdhBindInputDataSource]
  3619.   end;
  3620. end;
  3621. {$ELSE}
  3622. function PdhBindInputDataSource; external PdhLib name 'PdhBindInputDataSourceA';
  3623. {$ENDIF DYNAMIC_LINK}
  3624. {$ENDIF}
  3626. {$IFDEF DYNAMIC_LINK}
  3627. var
  3628.   _PdhOpenQueryH: Pointer;
  3630. function PdhOpenQueryH;
  3631. begin
  3632.   GetProcedureAddress(_PdhOpenQueryH, PdhLib, 'PdhOpenQueryH');
  3633.   asm
  3634.     mov esp, ebp
  3635.     pop ebp
  3636.     jmp [_PdhOpenQueryH]
  3637.   end;
  3638. end;
  3639. {$ELSE}
  3640. function PdhOpenQueryH; external PdhLib name 'PdhOpenQueryH';
  3641. {$ENDIF DYNAMIC_LINK}
  3643. {$IFDEF DYNAMIC_LINK}
  3644. var
  3645.   _PdhEnumMachinesHW: Pointer;
  3647. function PdhEnumMachinesHW;
  3648. begin
  3649.   GetProcedureAddress(_PdhEnumMachinesHW, PdhLib, 'PdhEnumMachinesHW');
  3650.   asm
  3651.     mov esp, ebp
  3652.     pop ebp
  3653.     jmp [_PdhEnumMachinesHW]
  3654.   end;
  3655. end;
  3656. {$ELSE}
  3657. function PdhEnumMachinesHW; external PdhLib name 'PdhEnumMachinesHW';
  3658. {$ENDIF DYNAMIC_LINK}
  3660. {$IFDEF DYNAMIC_LINK}
  3661. var
  3662.   _PdhEnumMachinesHA: Pointer;
  3664. function PdhEnumMachinesHA;
  3665. begin
  3666.   GetProcedureAddress(_PdhEnumMachinesHA, PdhLib, 'PdhEnumMachinesHA');
  3667.   asm
  3668.     mov esp, ebp
  3669.     pop ebp
  3670.     jmp [_PdhEnumMachinesHA]
  3671.   end;
  3672. end;
  3673. {$ELSE}
  3674. function PdhEnumMachinesHA; external PdhLib name 'PdhEnumMachinesHA';
  3675. {$ENDIF DYNAMIC_LINK}
  3676. {$IFDEF UNICODE}
  3678. {$IFDEF DYNAMIC_LINK}
  3679. var
  3680.   _PdhEnumMachinesH: Pointer;
  3682. function PdhEnumMachinesH;
  3683. begin
  3684.   GetProcedureAddress(_PdhEnumMachinesH, PdhLib, 'PdhEnumMachinesHW');
  3685.   asm
  3686.     mov esp, ebp
  3687.     pop ebp
  3688.     jmp [_PdhEnumMachinesH]
  3689.   end;
  3690. end;
  3691. {$ELSE}
  3692. function PdhEnumMachinesH; external PdhLib name 'PdhEnumMachinesHW';
  3693. {$ENDIF DYNAMIC_LINK}
  3694. {$ELSE}
  3696. {$IFDEF DYNAMIC_LINK}
  3697. var
  3698.   _PdhEnumMachinesH: Pointer;
  3700. function PdhEnumMachinesH;
  3701. begin
  3702.   GetProcedureAddress(_PdhEnumMachinesH, PdhLib, 'PdhEnumMachinesHA');
  3703.   asm
  3704.     mov esp, ebp
  3705.     pop ebp
  3706.     jmp [_PdhEnumMachinesH]
  3707.   end;
  3708. end;
  3709. {$ELSE}
  3710. function PdhEnumMachinesH; external PdhLib name 'PdhEnumMachinesHA';
  3711. {$ENDIF DYNAMIC_LINK}
  3712. {$ENDIF}
  3714. {$IFDEF DYNAMIC_LINK}
  3715. var
  3716.   _PdhEnumObjectsHW: Pointer;
  3718. function PdhEnumObjectsHW;
  3719. begin
  3720.   GetProcedureAddress(_PdhEnumObjectsHW, PdhLib, 'PdhEnumObjectsHW');
  3721.   asm
  3722.     mov esp, ebp
  3723.     pop ebp
  3724.     jmp [_PdhEnumObjectsHW]
  3725.   end;
  3726. end;
  3727. {$ELSE}
  3728. function PdhEnumObjectsHW; external PdhLib name 'PdhEnumObjectsHW';
  3729. {$ENDIF DYNAMIC_LINK}
  3731. {$IFDEF DYNAMIC_LINK}
  3732. var
  3733.   _PdhEnumObjectsHA: Pointer;
  3735. function PdhEnumObjectsHA;
  3736. begin
  3737.   GetProcedureAddress(_PdhEnumObjectsHA, PdhLib, 'PdhEnumObjectsHA');
  3738.   asm
  3739.     mov esp, ebp
  3740.     pop ebp
  3741.     jmp [_PdhEnumObjectsHA]
  3742.   end;
  3743. end;
  3744. {$ELSE}
  3745. function PdhEnumObjectsHA; external PdhLib name 'PdhEnumObjectsHA';
  3746. {$ENDIF DYNAMIC_LINK}
  3747. {$IFDEF UNICODE}
  3749. {$IFDEF DYNAMIC_LINK}
  3750. var
  3751.   _PdhEnumObjectsH: Pointer;
  3753. function PdhEnumObjectsH;
  3754. begin
  3755.   GetProcedureAddress(_PdhEnumObjectsH, PdhLib, 'PdhEnumObjectsHW');
  3756.   asm
  3757.     mov esp, ebp
  3758.     pop ebp
  3759.     jmp [_PdhEnumObjectsH]
  3760.   end;
  3761. end;
  3762. {$ELSE}
  3763. function PdhEnumObjectsH; external PdhLib name 'PdhEnumObjectsHW';
  3764. {$ENDIF DYNAMIC_LINK}
  3765. {$ELSE}
  3767. {$IFDEF DYNAMIC_LINK}
  3768. var
  3769.   _PdhEnumObjectsH: Pointer;
  3771. function PdhEnumObjectsH;
  3772. begin
  3773.   GetProcedureAddress(_PdhEnumObjectsH, PdhLib, 'PdhEnumObjectsHA');
  3774.   asm
  3775.     mov esp, ebp
  3776.     pop ebp
  3777.     jmp [_PdhEnumObjectsH]
  3778.   end;
  3779. end;
  3780. {$ELSE}
  3781. function PdhEnumObjectsH; external PdhLib name 'PdhEnumObjectsHA';
  3782. {$ENDIF DYNAMIC_LINK}
  3783. {$ENDIF}
  3785. {$IFDEF DYNAMIC_LINK}
  3786. var
  3787.   _PdhEnumObjectItemsHW: Pointer;
  3789. function PdhEnumObjectItemsHW;
  3790. begin
  3791.   GetProcedureAddress(_PdhEnumObjectItemsHW, PdhLib, 'PdhEnumObjectItemsHW');
  3792.   asm
  3793.     mov esp, ebp
  3794.     pop ebp
  3795.     jmp [_PdhEnumObjectItemsHW]
  3796.   end;
  3797. end;
  3798. {$ELSE}
  3799. function PdhEnumObjectItemsHW; external PdhLib name 'PdhEnumObjectItemsHW';
  3800. {$ENDIF DYNAMIC_LINK}
  3802. {$IFDEF DYNAMIC_LINK}
  3803. var
  3804.   _PdhEnumObjectItemsHA: Pointer;
  3806. function PdhEnumObjectItemsHA;
  3807. begin
  3808.   GetProcedureAddress(_PdhEnumObjectItemsHA, PdhLib, 'PdhEnumObjectItemsHA');
  3809.   asm
  3810.     mov esp, ebp
  3811.     pop ebp
  3812.     jmp [_PdhEnumObjectItemsHA]
  3813.   end;
  3814. end;
  3815. {$ELSE}
  3816. function PdhEnumObjectItemsHA; external PdhLib name 'PdhEnumObjectItemsHA';
  3817. {$ENDIF DYNAMIC_LINK}
  3818. {$IFDEF UNICODE}
  3820. {$IFDEF DYNAMIC_LINK}
  3821. var
  3822.   _PdhEnumObjectItemsH: Pointer;
  3824. function PdhEnumObjectItemsH;
  3825. begin
  3826.   GetProcedureAddress(_PdhEnumObjectItemsH, PdhLib, 'PdhEnumObjectItemsHW');
  3827.   asm
  3828.     mov esp, ebp
  3829.     pop ebp
  3830.     jmp [_PdhEnumObjectItemsH]
  3831.   end;
  3832. end;
  3833. {$ELSE}
  3834. function PdhEnumObjectItemsH; external PdhLib name 'PdhEnumObjectItemsHW';
  3835. {$ENDIF DYNAMIC_LINK}
  3836. {$ELSE}
  3838. {$IFDEF DYNAMIC_LINK}
  3839. var
  3840.   _PdhEnumObjectItemsH: Pointer;
  3842. function PdhEnumObjectItemsH;
  3843. begin
  3844.   GetProcedureAddress(_PdhEnumObjectItemsH, PdhLib, 'PdhEnumObjectItemsHA');
  3845.   asm
  3846.     mov esp, ebp
  3847.     pop ebp
  3848.     jmp [_PdhEnumObjectItemsH]
  3849.   end;
  3850. end;
  3851. {$ELSE}
  3852. function PdhEnumObjectItemsH; external PdhLib name 'PdhEnumObjectItemsHA';
  3853. {$ENDIF DYNAMIC_LINK}
  3854. {$ENDIF}
  3856. {$IFDEF DYNAMIC_LINK}
  3857. var
  3858.   _PdhExpandWildCardPathHW: Pointer;
  3860. function PdhExpandWildCardPathHW;
  3861. begin
  3862.   GetProcedureAddress(_PdhExpandWildCardPathHW, PdhLib, 'PdhExpandWildCardPathHW');
  3863.   asm
  3864.     mov esp, ebp
  3865.     pop ebp
  3866.     jmp [_PdhExpandWildCardPathHW]
  3867.   end;
  3868. end;
  3869. {$ELSE}
  3870. function PdhExpandWildCardPathHW; external PdhLib name 'PdhExpandWildCardPathHW';
  3871. {$ENDIF DYNAMIC_LINK}
  3873. {$IFDEF DYNAMIC_LINK}
  3874. var
  3875.   _PdhExpandWildCardPathHA: Pointer;
  3877. function PdhExpandWildCardPathHA;
  3878. begin
  3879.   GetProcedureAddress(_PdhExpandWildCardPathHA, PdhLib, 'PdhExpandWildCardPathHA');
  3880.   asm
  3881.     mov esp, ebp
  3882.     pop ebp
  3883.     jmp [_PdhExpandWildCardPathHA]
  3884.   end;
  3885. end;
  3886. {$ELSE}
  3887. function PdhExpandWildCardPathHA; external PdhLib name 'PdhExpandWildCardPathHA';
  3888. {$ENDIF DYNAMIC_LINK}
  3889. {$IFDEF UNICODE}
  3891. {$IFDEF DYNAMIC_LINK}
  3892. var
  3893.   _PdhExpandWildCardPathH: Pointer;
  3895. function PdhExpandWildCardPathH;
  3896. begin
  3897.   GetProcedureAddress(_PdhExpandWildCardPathH, PdhLib, 'PdhExpandWildCardPathHW');
  3898.   asm
  3899.     mov esp, ebp
  3900.     pop ebp
  3901.     jmp [_PdhExpandWildCardPathH]
  3902.   end;
  3903. end;
  3904. {$ELSE}
  3905. function PdhExpandWildCardPathH; external PdhLib name 'PdhExpandWildCardPathHW';
  3906. {$ENDIF DYNAMIC_LINK}
  3907. {$ELSE}
  3909. {$IFDEF DYNAMIC_LINK}
  3910. var
  3911.   _PdhExpandWildCardPathH: Pointer;
  3913. function PdhExpandWildCardPathH;
  3914. begin
  3915.   GetProcedureAddress(_PdhExpandWildCardPathH, PdhLib, 'PdhExpandWildCardPathHA');
  3916.   asm
  3917.     mov esp, ebp
  3918.     pop ebp
  3919.     jmp [_PdhExpandWildCardPathH]
  3920.   end;
  3921. end;
  3922. {$ELSE}
  3923. function PdhExpandWildCardPathH; external PdhLib name 'PdhExpandWildCardPathHA';
  3924. {$ENDIF DYNAMIC_LINK}
  3925. {$ENDIF}
  3927. {$IFDEF DYNAMIC_LINK}
  3928. var
  3929.   _PdhGetDataSourceTimeRangeH: Pointer;
  3931. function PdhGetDataSourceTimeRangeH;
  3932. begin
  3933.   GetProcedureAddress(_PdhGetDataSourceTimeRangeH, PdhLib, 'PdhGetDataSourceTimeRangeH');
  3934.   asm
  3935.     mov esp, ebp
  3936.     pop ebp
  3937.     jmp [_PdhGetDataSourceTimeRangeH]
  3938.   end;
  3939. end;
  3940. {$ELSE}
  3941. function PdhGetDataSourceTimeRangeH; external PdhLib name 'PdhGetDataSourceTimeRangeH';
  3942. {$ENDIF DYNAMIC_LINK}
  3944. {$IFDEF DYNAMIC_LINK}
  3945. var
  3946.   _PdhGetDefaultPerfObjectHW: Pointer;
  3948. function PdhGetDefaultPerfObjectHW;
  3949. begin
  3950.   GetProcedureAddress(_PdhGetDefaultPerfObjectHW, PdhLib, 'PdhGetDefaultPerfObjectHW');
  3951.   asm
  3952.     mov esp, ebp
  3953.     pop ebp
  3954.     jmp [_PdhGetDefaultPerfObjectHW]
  3955.   end;
  3956. end;
  3957. {$ELSE}
  3958. function PdhGetDefaultPerfObjectHW; external PdhLib name 'PdhGetDefaultPerfObjectHW';
  3959. {$ENDIF DYNAMIC_LINK}
  3961. {$IFDEF DYNAMIC_LINK}
  3962. var
  3963.   _PdhGetDefaultPerfObjectHA: Pointer;
  3965. function PdhGetDefaultPerfObjectHA;
  3966. begin
  3967.   GetProcedureAddress(_PdhGetDefaultPerfObjectHA, PdhLib, 'PdhGetDefaultPerfObjectHA');
  3968.   asm
  3969.     mov esp, ebp
  3970.     pop ebp
  3971.     jmp [_PdhGetDefaultPerfObjectHA]
  3972.   end;
  3973. end;
  3974. {$ELSE}
  3975. function PdhGetDefaultPerfObjectHA; external PdhLib name 'PdhGetDefaultPerfObjectHA';
  3976. {$ENDIF DYNAMIC_LINK}
  3977. {$IFDEF UNICODE}
  3979. {$IFDEF DYNAMIC_LINK}
  3980. var
  3981.   _PdhGetDefaultPerfObjectH: Pointer;
  3983. function PdhGetDefaultPerfObjectH;
  3984. begin
  3985.   GetProcedureAddress(_PdhGetDefaultPerfObjectH, PdhLib, 'PdhGetDefaultPerfObjectHW');
  3986.   asm
  3987.     mov esp, ebp
  3988.     pop ebp
  3989.     jmp [_PdhGetDefaultPerfObjectH]
  3990.   end;
  3991. end;
  3992. {$ELSE}
  3993. function PdhGetDefaultPerfObjectH; external PdhLib name 'PdhGetDefaultPerfObjectHW';
  3994. {$ENDIF DYNAMIC_LINK}
  3995. {$ELSE}
  3997. {$IFDEF DYNAMIC_LINK}
  3998. var
  3999.   _PdhGetDefaultPerfObjectH: Pointer;
  4001. function PdhGetDefaultPerfObjectH;
  4002. begin
  4003.   GetProcedureAddress(_PdhGetDefaultPerfObjectH, PdhLib, 'PdhGetDefaultPerfObjectHA');
  4004.   asm
  4005.     mov esp, ebp
  4006.     pop ebp
  4007.     jmp [_PdhGetDefaultPerfObjectH]
  4008.   end;
  4009. end;
  4010. {$ELSE}
  4011. function PdhGetDefaultPerfObjectH; external PdhLib name 'PdhGetDefaultPerfObjectHA';
  4012. {$ENDIF DYNAMIC_LINK}
  4013. {$ENDIF}
  4015. {$IFDEF DYNAMIC_LINK}
  4016. var
  4017.   _PdhGetDefaultPerfCounterHW: Pointer;
  4019. function PdhGetDefaultPerfCounterHW;
  4020. begin
  4021.   GetProcedureAddress(_PdhGetDefaultPerfCounterHW, PdhLib, 'PdhGetDefaultPerfCounterHW');
  4022.   asm
  4023.     mov esp, ebp
  4024.     pop ebp
  4025.     jmp [_PdhGetDefaultPerfCounterHW]
  4026.   end;
  4027. end;
  4028. {$ELSE}
  4029. function PdhGetDefaultPerfCounterHW; external PdhLib name 'PdhGetDefaultPerfCounterHW';
  4030. {$ENDIF DYNAMIC_LINK}
  4032. {$IFDEF DYNAMIC_LINK}
  4033. var
  4034.   _PdhGetDefaultPerfCounterHA: Pointer;
  4036. function PdhGetDefaultPerfCounterHA;
  4037. begin
  4038.   GetProcedureAddress(_PdhGetDefaultPerfCounterHA, PdhLib, 'PdhGetDefaultPerfCounterHA');
  4039.   asm
  4040.     mov esp, ebp
  4041.     pop ebp
  4042.     jmp [_PdhGetDefaultPerfCounterHA]
  4043.   end;
  4044. end;
  4045. {$ELSE}
  4046. function PdhGetDefaultPerfCounterHA; external PdhLib name 'PdhGetDefaultPerfCounterHA';
  4047. {$ENDIF DYNAMIC_LINK}
  4048. {$IFDEF UNICODE}
  4050. {$IFDEF DYNAMIC_LINK}
  4051. var
  4052.   _PdhGetDefaultPerfCounterH: Pointer;
  4054. function PdhGetDefaultPerfCounterH;
  4055. begin
  4056.   GetProcedureAddress(_PdhGetDefaultPerfCounterH, PdhLib, 'PdhGetDefaultPerfCounterHW');
  4057.   asm
  4058.     mov esp, ebp
  4059.     pop ebp
  4060.     jmp [_PdhGetDefaultPerfCounterH]
  4061.   end;
  4062. end;
  4063. {$ELSE}
  4064. function PdhGetDefaultPerfCounterH; external PdhLib name 'PdhGetDefaultPerfCounterHW';
  4065. {$ENDIF DYNAMIC_LINK}
  4066. {$ELSE}
  4068. {$IFDEF DYNAMIC_LINK}
  4069. var
  4070.   _PdhGetDefaultPerfCounterH: Pointer;
  4072. function PdhGetDefaultPerfCounterH;
  4073. begin
  4074.   GetProcedureAddress(_PdhGetDefaultPerfCounterH, PdhLib, 'PdhGetDefaultPerfCounterHA');
  4075.   asm
  4076.     mov esp, ebp
  4077.     pop ebp
  4078.     jmp [_PdhGetDefaultPerfCounterH]
  4079.   end;
  4080. end;
  4081. {$ELSE}
  4082. function PdhGetDefaultPerfCounterH; external PdhLib name 'PdhGetDefaultPerfCounterHA';
  4083. {$ENDIF DYNAMIC_LINK}
  4084. {$ENDIF}
  4086. {$IFDEF DYNAMIC_LINK}
  4087. var
  4088.   _PdhBrowseCountersHW: Pointer;
  4090. function PdhBrowseCountersHW;
  4091. begin
  4092.   GetProcedureAddress(_PdhBrowseCountersHW, PdhLib, 'PdhBrowseCountersHW');
  4093.   asm
  4094.     mov esp, ebp
  4095.     pop ebp
  4096.     jmp [_PdhBrowseCountersHW]
  4097.   end;
  4098. end;
  4099. {$ELSE}
  4100. function PdhBrowseCountersHW; external PdhLib name 'PdhBrowseCountersHW';
  4101. {$ENDIF DYNAMIC_LINK}
  4103. {$IFDEF DYNAMIC_LINK}
  4104. var
  4105.   _PdhBrowseCountersHA: Pointer;
  4107. function PdhBrowseCountersHA;
  4108. begin
  4109.   GetProcedureAddress(_PdhBrowseCountersHA, PdhLib, 'PdhBrowseCountersHA');
  4110.   asm
  4111.     mov esp, ebp
  4112.     pop ebp
  4113.     jmp [_PdhBrowseCountersHA]
  4114.   end;
  4115. end;
  4116. {$ELSE}
  4117. function PdhBrowseCountersHA; external PdhLib name 'PdhBrowseCountersHA';
  4118. {$ENDIF DYNAMIC_LINK}
  4119. {$IFDEF UNICODE}
  4121. {$IFDEF DYNAMIC_LINK}
  4122. var
  4123.   _PdhBrowseCountersH: Pointer;
  4125. function PdhBrowseCountersH;
  4126. begin
  4127.   GetProcedureAddress(_PdhBrowseCountersH, PdhLib, 'PdhBrowseCountersHW');
  4128.   asm
  4129.     mov esp, ebp
  4130.     pop ebp
  4131.     jmp [_PdhBrowseCountersH]
  4132.   end;
  4133. end;
  4134. {$ELSE}
  4135. function PdhBrowseCountersH; external PdhLib name 'PdhBrowseCountersHW';
  4136. {$ENDIF DYNAMIC_LINK}
  4137. {$ELSE}
  4139. {$IFDEF DYNAMIC_LINK}
  4140. var
  4141.   _PdhBrowseCountersH: Pointer;
  4143. function PdhBrowseCountersH;
  4144. begin
  4145.   GetProcedureAddress(_PdhBrowseCountersH, PdhLib, 'PdhBrowseCountersHA');
  4146.   asm
  4147.     mov esp, ebp
  4148.     pop ebp
  4149.     jmp [_PdhBrowseCountersH]
  4150.   end;
  4151. end;
  4152. {$ELSE}
  4153. function PdhBrowseCountersH; external PdhLib name 'PdhBrowseCountersHA';
  4154. {$ENDIF DYNAMIC_LINK}
  4155. {$ENDIF}
  4157. {$IFDEF DYNAMIC_LINK}
  4158. var
  4159.   _PdhVerifySQLDBW: Pointer;
  4161. function PdhVerifySQLDBW;
  4162. begin
  4163.   GetProcedureAddress(_PdhVerifySQLDBW, PdhLib, 'PdhVerifySQLDBW');
  4164.   asm
  4165.     mov esp, ebp
  4166.     pop ebp
  4167.     jmp [_PdhVerifySQLDBW]
  4168.   end;
  4169. end;
  4170. {$ELSE}
  4171. function PdhVerifySQLDBW; external PdhLib name 'PdhVerifySQLDBW';
  4172. {$ENDIF DYNAMIC_LINK}
  4174. {$IFDEF DYNAMIC_LINK}
  4175. var
  4176.   _PdhVerifySQLDBA: Pointer;
  4178. function PdhVerifySQLDBA;
  4179. begin
  4180.   GetProcedureAddress(_PdhVerifySQLDBA, PdhLib, 'PdhVerifySQLDBA');
  4181.   asm
  4182.     mov esp, ebp
  4183.     pop ebp
  4184.     jmp [_PdhVerifySQLDBA]
  4185.   end;
  4186. end;
  4187. {$ELSE}
  4188. function PdhVerifySQLDBA; external PdhLib name 'PdhVerifySQLDBA';
  4189. {$ENDIF DYNAMIC_LINK}
  4190. {$IFDEF UNICODE}
  4192. {$IFDEF DYNAMIC_LINK}
  4193. var
  4194.   _PdhVerifySQLDB: Pointer;
  4196. function PdhVerifySQLDB;
  4197. begin
  4198.   GetProcedureAddress(_PdhVerifySQLDB, PdhLib, 'PdhVerifySQLDBW');
  4199.   asm
  4200.     mov esp, ebp
  4201.     pop ebp
  4202.     jmp [_PdhVerifySQLDB]
  4203.   end;
  4204. end;
  4205. {$ELSE}
  4206. function PdhVerifySQLDB; external PdhLib name 'PdhVerifySQLDBW';
  4207. {$ENDIF DYNAMIC_LINK}
  4208. {$ELSE}
  4210. {$IFDEF DYNAMIC_LINK}
  4211. var
  4212.   _PdhVerifySQLDB: Pointer;
  4214. function PdhVerifySQLDB;
  4215. begin
  4216.   GetProcedureAddress(_PdhVerifySQLDB, PdhLib, 'PdhVerifySQLDBA');
  4217.   asm
  4218.     mov esp, ebp
  4219.     pop ebp
  4220.     jmp [_PdhVerifySQLDB]
  4221.   end;
  4222. end;
  4223. {$ELSE}
  4224. function PdhVerifySQLDB; external PdhLib name 'PdhVerifySQLDBA';
  4225. {$ENDIF DYNAMIC_LINK}
  4226. {$ENDIF}
  4228. {$IFDEF DYNAMIC_LINK}
  4229. var
  4230.   _PdhCreateSQLTablesW: Pointer;
  4232. function PdhCreateSQLTablesW;
  4233. begin
  4234.   GetProcedureAddress(_PdhCreateSQLTablesW, PdhLib, 'PdhCreateSQLTablesW');
  4235.   asm
  4236.     mov esp, ebp
  4237.     pop ebp
  4238.     jmp [_PdhCreateSQLTablesW]
  4239.   end;
  4240. end;
  4241. {$ELSE}
  4242. function PdhCreateSQLTablesW; external PdhLib name 'PdhCreateSQLTablesW';
  4243. {$ENDIF DYNAMIC_LINK}
  4245. {$IFDEF DYNAMIC_LINK}
  4246. var
  4247.   _PdhCreateSQLTablesA: Pointer;
  4249. function PdhCreateSQLTablesA;
  4250. begin
  4251.   GetProcedureAddress(_PdhCreateSQLTablesA, PdhLib, 'PdhCreateSQLTablesA');
  4252.   asm
  4253.     mov esp, ebp
  4254.     pop ebp
  4255.     jmp [_PdhCreateSQLTablesA]
  4256.   end;
  4257. end;
  4258. {$ELSE}
  4259. function PdhCreateSQLTablesA; external PdhLib name 'PdhCreateSQLTablesA';
  4260. {$ENDIF DYNAMIC_LINK}
  4261. {$IFDEF UNICODE}
  4263. {$IFDEF DYNAMIC_LINK}
  4264. var
  4265.   _PdhCreateSQLTables: Pointer;
  4267. function PdhCreateSQLTables;
  4268. begin
  4269.   GetProcedureAddress(_PdhCreateSQLTables, PdhLib, 'PdhCreateSQLTablesW');
  4270.   asm
  4271.     mov esp, ebp
  4272.     pop ebp
  4273.     jmp [_PdhCreateSQLTables]
  4274.   end;
  4275. end;
  4276. {$ELSE}
  4277. function PdhCreateSQLTables; external PdhLib name 'PdhCreateSQLTablesW';
  4278. {$ENDIF DYNAMIC_LINK}
  4279. {$ELSE}
  4281. {$IFDEF DYNAMIC_LINK}
  4282. var
  4283.   _PdhCreateSQLTables: Pointer;
  4285. function PdhCreateSQLTables;
  4286. begin
  4287.   GetProcedureAddress(_PdhCreateSQLTables, PdhLib, 'PdhCreateSQLTablesA');
  4288.   asm
  4289.     mov esp, ebp
  4290.     pop ebp
  4291.     jmp [_PdhCreateSQLTables]
  4292.   end;
  4293. end;
  4294. {$ELSE}
  4295. function PdhCreateSQLTables; external PdhLib name 'PdhCreateSQLTablesA';
  4296. {$ENDIF DYNAMIC_LINK}
  4297. {$ENDIF}
  4299. {$IFDEF DYNAMIC_LINK}
  4300. var
  4301.   _PdhEnumLogSetNamesW: Pointer;
  4303. function PdhEnumLogSetNamesW;
  4304. begin
  4305.   GetProcedureAddress(_PdhEnumLogSetNamesW, PdhLib, 'PdhEnumLogSetNamesW');
  4306.   asm
  4307.     mov esp, ebp
  4308.     pop ebp
  4309.     jmp [_PdhEnumLogSetNamesW]
  4310.   end;
  4311. end;
  4312. {$ELSE}
  4313. function PdhEnumLogSetNamesW; external PdhLib name 'PdhEnumLogSetNamesW';
  4314. {$ENDIF DYNAMIC_LINK}
  4316. {$IFDEF DYNAMIC_LINK}
  4317. var
  4318.   _PdhEnumLogSetNamesA: Pointer;
  4320. function PdhEnumLogSetNamesA;
  4321. begin
  4322.   GetProcedureAddress(_PdhEnumLogSetNamesA, PdhLib, 'PdhEnumLogSetNamesA');
  4323.   asm
  4324.     mov esp, ebp
  4325.     pop ebp
  4326.     jmp [_PdhEnumLogSetNamesA]
  4327.   end;
  4328. end;
  4329. {$ELSE}
  4330. function PdhEnumLogSetNamesA; external PdhLib name 'PdhEnumLogSetNamesA';
  4331. {$ENDIF DYNAMIC_LINK}
  4332. {$IFDEF UNICODE}
  4334. {$IFDEF DYNAMIC_LINK}
  4335. var
  4336.   _PdhEnumLogSetNames: Pointer;
  4338. function PdhEnumLogSetNames;
  4339. begin
  4340.   GetProcedureAddress(_PdhEnumLogSetNames, PdhLib, 'PdhEnumLogSetNamesW');
  4341.   asm
  4342.     mov esp, ebp
  4343.     pop ebp
  4344.     jmp [_PdhEnumLogSetNames]
  4345.   end;
  4346. end;
  4347. {$ELSE}
  4348. function PdhEnumLogSetNames; external PdhLib name 'PdhEnumLogSetNamesW';
  4349. {$ENDIF DYNAMIC_LINK}
  4350. {$ELSE}
  4352. {$IFDEF DYNAMIC_LINK}
  4353. var
  4354.   _PdhEnumLogSetNames: Pointer;
  4356. function PdhEnumLogSetNames;
  4357. begin
  4358.   GetProcedureAddress(_PdhEnumLogSetNames, PdhLib, 'PdhEnumLogSetNamesA');
  4359.   asm
  4360.     mov esp, ebp
  4361.     pop ebp
  4362.     jmp [_PdhEnumLogSetNames]
  4363.   end;
  4364. end;
  4365. {$ELSE}
  4366. function PdhEnumLogSetNames; external PdhLib name 'PdhEnumLogSetNamesA';
  4367. {$ENDIF DYNAMIC_LINK}
  4368. {$ENDIF}
  4370. {$IFDEF DYNAMIC_LINK}
  4371. var
  4372.   _PdhGetLogSetGUID: Pointer;
  4374. function PdhGetLogSetGUID;
  4375. begin
  4376.   GetProcedureAddress(_PdhGetLogSetGUID, PdhLib, 'PdhGetLogSetGUID');
  4377.   asm
  4378.     mov esp, ebp
  4379.     pop ebp
  4380.     jmp [_PdhGetLogSetGUID]
  4381.   end;
  4382. end;
  4383. {$ELSE}
  4384. function PdhGetLogSetGUID; external PdhLib name 'PdhGetLogSetGUID';
  4385. {$ENDIF DYNAMIC_LINK}
  4387. {$IFDEF DYNAMIC_LINK}
  4388. var
  4389.   _PdhSetLogSetRunID: Pointer;
  4391. function PdhSetLogSetRunID;
  4392. begin
  4393.   GetProcedureAddress(_PdhSetLogSetRunID, PdhLib, 'PdhSetLogSetRunID');
  4394.   asm
  4395.     mov esp, ebp
  4396.     pop ebp
  4397.     jmp [_PdhSetLogSetRunID]
  4398.   end;
  4399. end;
  4400. {$ELSE}
  4401. function PdhSetLogSetRunID; external PdhLib name 'PdhSetLogSetRunID';
  4402. {$ENDIF DYNAMIC_LINK}
  4405. end.