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

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

Windows编程

开发平台：

Delphi

JwaWinReg.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Windows Registry 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: winreg.h, released June 2000. The original Pascal      }
  9. { code is: WinReg.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 JwaWinReg;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "WinReg.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaReason, JwaWinBase, JwaWinNT, JwaWinType;
  59. //
  60. // Requested Key access mask type.
  61. //
  63. type
  64.   REGSAM = ACCESS_MASK;
  65.   {$EXTERNALSYM REGSAM}
  67. //
  68. // Reserved Key Handles.
  69. //
  71. const
  72.   HKEY_CLASSES_ROOT     = HKEY(ULONG_PTR(LONG($80000000)));
  73.   {$EXTERNALSYM HKEY_CLASSES_ROOT}
  74.   HKEY_CURRENT_USER     = HKEY(ULONG_PTR(LONG($80000001)));
  75.   {$EXTERNALSYM HKEY_CURRENT_USER}
  76.   HKEY_LOCAL_MACHINE    = HKEY(ULONG_PTR(LONG($80000002)));
  77.   {$EXTERNALSYM HKEY_LOCAL_MACHINE}
  78.   HKEY_USERS            = HKEY(ULONG_PTR(LONG($80000003)));
  79.   {$EXTERNALSYM HKEY_USERS}
  80.   HKEY_PERFORMANCE_DATA = HKEY(ULONG_PTR(LONG($80000004)));
  81.   {$EXTERNALSYM HKEY_PERFORMANCE_DATA}
  82.   HKEY_PERFORMANCE_TEXT    = HKEY(ULONG_PTR(LONG($80000050)));
  83.   {$EXTERNALSYM HKEY_PERFORMANCE_TEXT}
  84.   HKEY_PERFORMANCE_NLSTEXT = HKEY(ULONG_PTR(LONG($80000060)));
  85.   {$EXTERNALSYM HKEY_PERFORMANCE_NLSTEXT}
  86.   HKEY_CURRENT_CONFIG   = HKEY(ULONG_PTR(LONG($80000005)));
  87.   {$EXTERNALSYM HKEY_CURRENT_CONFIG}
  88.   HKEY_DYN_DATA         = HKEY(ULONG_PTR(LONG($80000006)));
  89.   {$EXTERNALSYM HKEY_DYN_DATA}
  91.   PROVIDER_KEEPS_VALUE_LENGTH = $1;
  92.   {$EXTERNALSYM PROVIDER_KEEPS_VALUE_LENGTH}
  94. type
  95.   val_context = record
  96.     valuelen: Integer;       // the total length of this value
  97.     value_context: LPVOID;   // provider's context
  98.     val_buff_ptr: LPVOID;    // where in the ouput buffer the value is.
  99.   end;
  100.   {$EXTERNALSYM val_context}
  101.   PVALCONTEXT = ^val_context;
  102.   {$EXTERNALSYM PVALCONTEXT}
  103.   TValContext = val_context;
  105.   PVALUEA = record           // Provider supplied value/context.
  106.     pv_valuename: LPSTR;     // The value name pointer
  107.     pv_valuelen: Integer;
  108.     pv_value_context: LPVOID;
  109.     pv_type: DWORD;
  110.   end;
  111.   {$EXTERNALSYM PVALUEA}
  112.   PPVALUEA = ^PVALUEA;
  113.   {$EXTERNALSYM PPVALUEA}
  114.   TPValueA = PVALUEA;
  116.   PVALUEW = record           // Provider supplied value/context.
  117.     pv_valuename: LPWSTR;    // The value name pointer
  118.     pv_valuelen: Integer;
  119.     pv_value_context: LPVOID;
  120.     pv_type: DWORD;
  121.   end;
  122.   {$EXTERNALSYM PVALUEW}
  123.   PPVALUEW = ^PVALUEW;
  124.   {$EXTERNALSYM PPVALUEW}
  125.   TPValueW = PVALUEW;
  127. {$IFDEF UNICODE}
  128.   PVALUE = PVALUEW;
  129.   {$EXTERNALSYM PVALUE}
  130.   PPVALUE = PPVALUEW;
  131.   {$EXTERNALSYM PPVALUE}
  132.   TPValue = TPValueW;
  133. {$ELSE}
  134.   PVALUE = PVALUEA;
  135.   {$EXTERNALSYM PVALUE}
  136.   PPVALUE = PPVALUEA;
  137.   {$EXTERNALSYM PPVALUE}
  138.   TPValue = TPValueA;
  139. {$ENDIF}
  141.   QUERYHANDLER = function (keycontext: LPVOID; val_list: PVALCONTEXT;
  142.     num_vals: DWORD; outputbuffer: LPVOID; total_outlen: LPDWORD;
  143.     input_blen: DWORD): DWORD; cdecl;
  144.   {$EXTERNALSYM QUERYHANDLER}
  145.   PQUERYHANDLER = ^QUERYHANDLER;
  146.   {$EXTERNALSYM PQUERYHANDLER}
  147.   TQueryHandler = QUERYHANDLER;
  149.   provider_info = record
  150.     pi_R0_1val: PQUERYHANDLER;
  151.     pi_R0_allvals: PQUERYHANDLER;
  152.     pi_R3_1val: PQUERYHANDLER;
  153.     pi_R3_allvals: PQUERYHANDLER;
  154.     pi_flags: DWORD;    // capability flags (none defined yet).
  155.     pi_key_context: LPVOID;
  156.   end;
  157.   {$EXTERNALSYM provider_info}
  158.   REG_PROVIDER = provider_info;
  159.   {$EXTERNALSYM REG_PROVIDER}
  160.   PPROVIDER = ^provider_info;
  161.   {$EXTERNALSYM PPROVIDER}
  162.   TProviderInfo = provider_info;
  163.   PProviderInfo = ^provider_info;
  165.   value_entA = record
  166.     ve_valuename: LPSTR;
  167.     ve_valuelen: DWORD;
  168.     ve_valueptr: DWORD_PTR;
  169.     ve_type: DWORD;
  170.   end;
  171.   {$EXTERNALSYM value_entA}
  172.   VALENTA = value_entA;
  173.   {$EXTERNALSYM VALENTA}
  174.   PVALENTA = ^VALENTA;
  175.   {$EXTERNALSYM PVALENTA}
  176.   TValueEntA = value_entA;
  177.   PValueEntA = ^value_entA;
  179.   value_entW = record
  180.     ve_valuename: LPWSTR;
  181.     ve_valuelen: DWORD;
  182.     ve_valueptr: DWORD_PTR;
  183.     ve_type: DWORD;
  184.   end;
  185.   {$EXTERNALSYM value_entW}
  186.   VALENTW = value_entW;
  187.   {$EXTERNALSYM VALENTW}
  188.   PVALENTW = ^VALENTW;
  189.   {$EXTERNALSYM PVALENTW}
  190.   TValueEntW = value_entW;
  191.   PValueEntW = ^value_entW;
  193. {$IFDEF UNICODE}
  194.   VALENT = VALENTW;
  195.   {$EXTERNALSYM VALENT}
  196.   PVALENT = PVALENTW;
  197.   {$EXTERNALSYM PVALENT}
  198.   TValueEnt = TValueEntW;
  199.   PValueEnt = PValueEntW;
  200. {$ELSE}
  201.   VALENT = VALENTA;
  202.   {$EXTERNALSYM VALENT}
  203.   PVALENT = PVALENTA;
  204.   {$EXTERNALSYM PVALENT}
  205.   TValueEnt = TValueEntA;
  206.   PValueEnt = PValueEntA;
  207. {$ENDIF}
  209. //
  210. // Default values for parameters that do not exist in the Win 3.1
  211. // compatible APIs.
  212. //
  214. const
  215.   WIN31_CLASS = nil;
  216.   {$EXTERNALSYM WIN31_CLASS}
  218. //
  219. // API Prototypes.
  220. //
  222. function RegCloseKey(hKey: HKEY): LONG; stdcall;
  223. {$EXTERNALSYM RegCloseKey}
  225. function RegOverridePredefKey(hKey: HKEY; hNewHKey: HKEY): LONG; stdcall;
  226. {$EXTERNALSYM RegOverridePredefKey}
  228. function RegOpenUserClassesRoot(hToken: HANDLE; dwOptions: DWORD;
  229.   samDesired: REGSAM; var phkResult: HKEY): LONG; stdcall;
  230. {$EXTERNALSYM RegOpenUserClassesRoot}
  232. function RegOpenCurrentUser(samDesired: REGSAM; var phkResult: HKEY): LONG; stdcall;
  233. {$EXTERNALSYM RegOpenCurrentUser}
  235. function RegDisablePredefinedCache: LONG; stdcall;
  236. {$EXTERNALSYM RegDisablePredefinedCache}
  238. function RegConnectRegistryA(lpMachineName: LPCSTR; hKey: HKEY;
  239.   var phkResult: HKEY): LONG; stdcall;
  240. {$EXTERNALSYM RegConnectRegistryA}
  241. function RegConnectRegistryW(lpMachineName: LPCWSTR; hKey: HKEY;
  242.   var phkResult: HKEY): LONG; stdcall;
  243. {$EXTERNALSYM RegConnectRegistryW}
  245. {$IFDEF UNICODE}
  246. function RegConnectRegistry(lpMachineName: LPCWSTR; hKey: HKEY;
  247.   var phkResult: HKEY): LONG; stdcall;
  248. {$EXTERNALSYM RegConnectRegistry}
  249. {$ELSE}
  250. function RegConnectRegistry(lpMachineName: LPCSTR; hKey: HKEY;
  251.   var phkResult: HKEY): LONG; stdcall;
  252. {$EXTERNALSYM RegConnectRegistry}
  253. {$ENDIF}
  255. function RegCreateKeyA(hKey: HKEY; lpSubKey: LPCSTR; var phkResult: HKEY): LONG; stdcall;
  256. {$EXTERNALSYM RegCreateKeyA}
  257. function RegCreateKeyW(hKey: HKEY; lpSubKey: LPCWSTR; var phkResult: HKEY): LONG; stdcall;
  258. {$EXTERNALSYM RegCreateKeyW}
  260. {$IFDEF UNICODE}
  261. function RegCreateKey(hKey: HKEY; lpSubKey: LPCWSTR; var phkResult: HKEY): LONG; stdcall;
  262. {$EXTERNALSYM RegCreateKey}
  263. {$ELSE}
  264. function RegCreateKey(hKey: HKEY; lpSubKey: LPCSTR; var phkResult: HKEY): LONG; stdcall;
  265. {$EXTERNALSYM RegCreateKey}
  266. {$ENDIF}
  268. function RegCreateKeyExA(hKey: HKEY; lpSubKey: LPCSTR; Reserved: DWORD;
  269.   lpClass: LPSTR; dwOptions: DWORD; samDesired: REGSAM;
  270.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; var phkResult: HKEY;
  271.   lpdwDisposition: LPDWORD): LONG; stdcall;
  272. {$EXTERNALSYM RegCreateKeyExA}
  273. function RegCreateKeyExW(hKey: HKEY; lpSubKey: LPCWSTR; Reserved: DWORD;
  274.   lpClass: LPWSTR; dwOptions: DWORD; samDesired: REGSAM;
  275.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; var phkResult: HKEY;
  276.   lpdwDisposition: LPDWORD): LONG; stdcall;
  277. {$EXTERNALSYM RegCreateKeyExW}
  279. {$IFDEF UNICODE}
  280. function RegCreateKeyEx(hKey: HKEY; lpSubKey: LPCWSTR; Reserved: DWORD;
  281.   lpClass: LPWSTR; dwOptions: DWORD; samDesired: REGSAM;
  282.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; var phkResult: HKEY;
  283.   lpdwDisposition: LPDWORD): LONG; stdcall;
  284. {$EXTERNALSYM RegCreateKeyEx}
  285. {$ELSE}
  286. function RegCreateKeyEx(hKey: HKEY; lpSubKey: LPCSTR; Reserved: DWORD;
  287.   lpClass: LPSTR; dwOptions: DWORD; samDesired: REGSAM;
  288.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; var phkResult: HKEY;
  289.   lpdwDisposition: LPDWORD): LONG; stdcall;
  290. {$EXTERNALSYM RegCreateKeyEx}
  291. {$ENDIF}
  293. function RegDeleteKeyA(hKey: HKEY; lpSubKey: LPCSTR): LONG; stdcall;
  294. {$EXTERNALSYM RegDeleteKeyA}
  295. function RegDeleteKeyW(hKey: HKEY; lpSubKey: LPCWSTR): LONG; stdcall;
  296. {$EXTERNALSYM RegDeleteKeyW}
  298. {$IFDEF UNICODE}
  299. function RegDeleteKey(hKey: HKEY; lpSubKey: LPCWSTR): LONG; stdcall;
  300. {$EXTERNALSYM RegDeleteKey}
  301. {$ELSE}
  302. function RegDeleteKey(hKey: HKEY; lpSubKey: LPCSTR): LONG; stdcall;
  303. {$EXTERNALSYM RegDeleteKey}
  304. {$ENDIF}
  306. function RegDeleteValueA(hKey: HKEY; lpValueName: LPCSTR): LONG; stdcall;
  307. {$EXTERNALSYM RegDeleteValueA}
  308. function RegDeleteValueW(hKey: HKEY; lpValueName: LPCWSTR): LONG; stdcall;
  309. {$EXTERNALSYM RegDeleteValueW}
  311. {$IFDEF UNICODE}
  312. function RegDeleteValue(hKey: HKEY; lpValueName: LPCWSTR): LONG; stdcall;
  313. {$EXTERNALSYM RegDeleteValue}
  314. {$ELSE}
  315. function RegDeleteValue(hKey: HKEY; lpValueName: LPCSTR): LONG; stdcall;
  316. {$EXTERNALSYM RegDeleteValue}
  317. {$ENDIF}
  319. function RegEnumKeyA(hKey: HKEY; dwIndex: DWORD; lpName: LPSTR; cbName: DWORD): LONG; stdcall;
  320. {$EXTERNALSYM RegEnumKeyA}
  321. function RegEnumKeyW(hKey: HKEY; dwIndex: DWORD; lpName: LPWSTR; cbName: DWORD): LONG; stdcall;
  322. {$EXTERNALSYM RegEnumKeyW}
  324. {$IFDEF UNICODE}
  325. function RegEnumKey(hKey: HKEY; dwIndex: DWORD; lpName: LPWSTR; cbName: DWORD): LONG; stdcall;
  326. {$EXTERNALSYM RegEnumKey}
  327. {$ELSE}
  328. function RegEnumKey(hKey: HKEY; dwIndex: DWORD; lpName: LPSTR; cbName: DWORD): LONG; stdcall;
  329. {$EXTERNALSYM RegEnumKey}
  330. {$ENDIF}
  332. function RegEnumKeyExA(hKey: HKEY; dwIndex: DWORD; lpName: LPSTR;
  333.   var lpcbName: DWORD; lpReserved: LPDWORD; lpClass: LPSTR; lpcbClass: LPDWORD;
  334.   lpftLastWriteTime: PFILETIME): LONG; stdcall;
  335. {$EXTERNALSYM RegEnumKeyExA}
  336. function RegEnumKeyExW(hKey: HKEY; dwIndex: DWORD; lpName: LPWSTR;
  337.   var lpcbName: DWORD; lpReserved: LPDWORD; lpClass: LPWSTR; lpcbClass: LPDWORD;
  338.   lpftLastWriteTime: PFILETIME): LONG; stdcall;
  339. {$EXTERNALSYM RegEnumKeyExW}
  341. {$IFDEF UNICODE}
  342. function RegEnumKeyEx(hKey: HKEY; dwIndex: DWORD; lpName: LPWSTR;
  343.   var lpcbName: LPDWORD; lpReserved: LPDWORD; lpClass: LPWSTR; lpcbClass: LPDWORD;
  344.   lpftLastWriteTime: PFILETIME): LONG; stdcall;
  345. {$EXTERNALSYM RegEnumKeyEx}
  346. {$ELSE}
  347. function RegEnumKeyEx(hKey: HKEY; dwIndex: DWORD; lpName: LPSTR;
  348.   var lpcbName: DWORD; lpReserved: LPDWORD; lpClass: LPSTR; lpcbClass: LPDWORD;
  349.   lpftLastWriteTime: PFILETIME): LONG; stdcall;
  350. {$EXTERNALSYM RegEnumKeyEx}
  351. {$ENDIF}
  353. function RegEnumValueA(hKey: HKEY; dwIndex: DWORD; lpValueName: LPSTR;
  354.   var lpcbValueName: DWORD; lpReserved, lpType: LPDWORD; lpData: LPBYTE;
  355.   lpcbData: LPDWORD): LONG; stdcall;
  356. {$EXTERNALSYM RegEnumValueA}
  357. function RegEnumValueW(hKey: HKEY; dwIndex: DWORD; lpValueName: LPWSTR;
  358.   var lpcbValueName: DWORD; lpReserved, lpType: LPDWORD; lpData: LPBYTE;
  359.   lpcbData: LPDWORD): LONG; stdcall;
  360. {$EXTERNALSYM RegEnumValueW}
  362. {$IFDEF UNICODE}
  363. function RegEnumValue(hKey: HKEY; dwIndex: DWORD; lpValueName: LPWSTR;
  364.   var lpcbValueName: DWORD; lpReserved, lpType: LPDWORD; lpData: LPBYTE;
  365.   lpcbData: LPDWORD): LONG; stdcall;
  366. {$EXTERNALSYM RegEnumValue}
  367. {$ELSE}
  368. function RegEnumValue(hKey: HKEY; dwIndex: DWORD; lpValueName: LPSTR;
  369.   var lpcbValueName: DWORD; lpReserved, lpType: LPDWORD; lpData: LPBYTE;
  370.   lpcbData: LPDWORD): LONG; stdcall;
  371. {$EXTERNALSYM RegEnumValue}
  372. {$ENDIF}
  374. function RegFlushKey(hKey: HKEY): LONG; stdcall;
  375. {$EXTERNALSYM RegFlushKey}
  377. function RegGetKeySecurity(hKey: HKEY; SecurityInformation: SECURITY_INFORMATION;
  378.   pSecurityDescriptor: PSECURITY_DESCRIPTOR; var lpcbSecurityDescriptor: DWORD): LONG; stdcall;
  379. {$EXTERNALSYM RegGetKeySecurity}
  381. function RegLoadKeyA(hKey: HKEY; lpSubKey: LPCSTR; lpFile: LPCSTR): LONG; stdcall;
  382. {$EXTERNALSYM RegLoadKeyA}
  383. function RegLoadKeyW(hKey: HKEY; lpSubKey: LPCWSTR; lpFile: LPCWSTR): LONG; stdcall;
  384. {$EXTERNALSYM RegLoadKeyW}
  386. {$IFDEF UNICODE}
  387. function RegLoadKey(hKey: HKEY; lpSubKey: LPCWSTR; lpFile: LPCWSTR): LONG; stdcall;
  388. {$EXTERNALSYM RegLoadKey}
  389. {$ELSE}
  390. function RegLoadKey(hKey: HKEY; lpSubKey: LPCSTR; lpFile: LPCSTR): LONG; stdcall;
  391. {$EXTERNALSYM RegLoadKey}
  392. {$ENDIF}
  394. function RegNotifyChangeKeyValue(hKey: HKEY; bWatchSubtree: BOOL;
  395.   dwNotifyFilter: DWORD; hEvent: HANDLE; fAsynchronus: BOOL): LONG;
  396. {$EXTERNALSYM RegNotifyChangeKeyValue}
  398. function RegOpenKeyA(hKey: HKEY; lpSubKey: LPCSTR; var phkResult: HKEY): LONG; stdcall;
  399. {$EXTERNALSYM RegOpenKeyA}
  400. function RegOpenKeyW(hKey: HKEY; lpSubKey: LPCWSTR; var phkResult: HKEY): LONG; stdcall;
  401. {$EXTERNALSYM RegOpenKeyW}
  403. {$IFDEF UNICODE}
  404. function RegOpenKey(hKey: HKEY; lpSubKey: LPCWSTR; var phkResult: HKEY): LONG; stdcall;
  405. {$EXTERNALSYM RegOpenKey}
  406. {$ELSE}
  407. function RegOpenKey(hKey: HKEY; lpSubKey: LPCSTR; var phkResult: HKEY): LONG; stdcall;
  408. {$EXTERNALSYM RegOpenKey}
  409. {$ENDIF}
  411. function RegOpenKeyExA(hKey: HKEY; lpSubKey: LPCSTR; ulOptions: DWORD;
  412.   samDesired: REGSAM; var phkResult: HKEY): LONG; stdcall;
  413. {$EXTERNALSYM RegOpenKeyExA}
  414. function RegOpenKeyExW(hKey: HKEY; lpSubKey: LPCWSTR; ulOptions: DWORD;
  415.   samDesired: REGSAM; var phkResult: HKEY): LONG; stdcall;
  416. {$EXTERNALSYM RegOpenKeyExW}
  418. {$IFDEF UNICODE}
  419. function RegOpenKeyEx(hKey: HKEY; lpSubKey: LPCWSTR; ulOptions: DWORD;
  420.   samDesired: REGSAM; var phkResult: HKEY): LONG; stdcall;
  421. {$EXTERNALSYM RegOpenKeyEx}
  422. {$ELSE}
  423. function RegOpenKeyEx(hKey: HKEY; lpSubKey: LPCSTR; ulOptions: DWORD;
  424.   samDesired: REGSAM; var phkResult: HKEY): LONG; stdcall;
  425. {$EXTERNALSYM RegOpenKeyEx}
  426. {$ENDIF}
  428. function RegQueryInfoKeyA(hKey: HKEY; lpClass: LPSTR; lpcbClass, lpReserved,
  429.   lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen,
  430.   lpcbMaxValueLen, lpcbSecurityDescriptor: LPDWORD; lpftLastWriteTime: PFILETIME): LONG; stdcall;
  431. {$EXTERNALSYM RegQueryInfoKeyA}
  432. function RegQueryInfoKeyW(hKey: HKEY; lpClass: LPWSTR; lpcbClass, lpReserved,
  433.   lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen,
  434.   lpcbMaxValueLen, lpcbSecurityDescriptor: LPDWORD; lpftLastWriteTime: PFILETIME): LONG; stdcall;
  435. {$EXTERNALSYM RegQueryInfoKeyW}
  437. {$IFDEF UNICODE}
  438. function RegQueryInfoKey(hKey: HKEY; lpClass: LPWSTR; lpcbClass, lpReserved,
  439.   lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen,
  440.   lpcbMaxValueLen, lpcbSecurityDescriptor: LPDWORD; lpftLastWriteTime: PFILETIME): LONG; stdcall;
  441. {$EXTERNALSYM RegQueryInfoKey}
  442. {$ELSE}
  443. function RegQueryInfoKey(hKey: HKEY; lpClass: LPSTR; lpcbClass, lpReserved,
  444.   lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen, lpcValues, lpcbMaxValueNameLen,
  445.   lpcbMaxValueLen, lpcbSecurityDescriptor: LPDWORD; lpftLastWriteTime: PFILETIME): LONG; stdcall;
  446. {$EXTERNALSYM RegQueryInfoKey}
  447. {$ENDIF}
  449. function RegQueryValueA(hKey: HKEY; lpSubKey: LPCSTR; lpValue: LPSTR;
  450.   var lpcbValue: LONG): LONG; stdcall;
  451. {$EXTERNALSYM RegQueryValueA}
  452. function RegQueryValueW(hKey: HKEY; lpSubKey: LPCWSTR; lpValue: LPWSTR;
  453.   var lpcbValue: LONG): LONG; stdcall;
  454. {$EXTERNALSYM RegQueryValueW}
  456. {$IFDEF UNICODE}
  457. function RegQueryValue(hKey: HKEY; lpSubKey: LPCWSTR; lpValue: LPWSTR;
  458.   var lpcbValue: LONG): LONG; stdcall;
  459. {$EXTERNALSYM RegQueryValue}
  460. {$ELSE}
  461. function RegQueryValue(hKey: HKEY; lpSubKey: LPCSTR; lpValue: LPSTR;
  462.   var lpcbValue: LONG): LONG; stdcall;
  463. {$EXTERNALSYM RegQueryValue}
  464. {$ENDIF}
  466. function RegQueryMultipleValuesA(hKey: HKEY; val_list: PVALENTA; num_vals: DWORD;
  467.   lpValueBuf: LPSTR; var ldwTotsize: DWORD): LONG; stdcall;
  468. {$EXTERNALSYM RegQueryMultipleValuesA}
  469. function RegQueryMultipleValuesW(hKey: HKEY; val_list: PVALENTW; num_vals: DWORD;
  470.   lpValueBuf: LPWSTR; var ldwTotsize: DWORD): LONG; stdcall;
  471. {$EXTERNALSYM RegQueryMultipleValuesW}
  473. {$IFDEF UNICODE}
  474. function RegQueryMultipleValues(hKey: HKEY; val_list: PVALENTW; num_vals: DWORD;
  475.   lpValueBuf: LPWSTR; var ldwTotsize: DWORD): LONG; stdcall;
  476. {$EXTERNALSYM RegQueryMultipleValues}
  477. {$ELSE}
  478. function RegQueryMultipleValues(hKey: HKEY; val_list: PVALENTA; num_vals: DWORD;
  479.   lpValueBuf: LPSTR; var ldwTotsize: DWORD): LONG; stdcall;
  480. {$EXTERNALSYM RegQueryMultipleValues}
  481. {$ENDIF}
  483. function RegQueryValueExA(hKey: HKEY; lpValueName: LPCSTR; lpReserved: LPDWORD;
  484.   lpType: LPDWORD; lpData: LPBYTE; lpcbData: LPDWORD): LONG; stdcall;
  485. {$EXTERNALSYM RegQueryValueExA}
  486. function RegQueryValueExW(hKey: HKEY; lpValueName: LPCWSTR; lpReserved: LPDWORD;
  487.   lpType: LPDWORD; lpData: LPBYTE; lpcbData: LPDWORD): LONG; stdcall;
  488. {$EXTERNALSYM RegQueryValueExW}
  490. {$IFDEF UNICODE}
  491. function RegQueryValueEx(hKey: HKEY; lpValueName: LPCWSTR; lpReserved: LPDWORD;
  492.   lpType: LPDWORD; lpData: LPBYTE; lpcbData: LPDWORD): LONG; stdcall;
  493. {$EXTERNALSYM RegQueryValueEx}
  494. {$ELSE}
  495. function RegQueryValueEx(hKey: HKEY; lpValueName: LPCSTR; lpReserved: LPDWORD;
  496.   lpType: LPDWORD; lpData: LPBYTE; lpcbData: LPDWORD): LONG; stdcall;
  497. {$EXTERNALSYM RegQueryValueEx}
  498. {$ENDIF}
  500. function RegReplaceKeyA(hKey: HKEY; lpSubKey: LPCSTR; lpNewFile: LPCSTR;
  501.   lpOldFile: LPCSTR): LONG; stdcall;
  502. {$EXTERNALSYM RegReplaceKeyA}
  503. function RegReplaceKeyW(hKey: HKEY; lpSubKey: LPCWSTR; lpNewFile: LPCWSTR;
  504.   lpOldFile: LPCWSTR): LONG; stdcall;
  505. {$EXTERNALSYM RegReplaceKeyW}
  507. {$IFDEF UNICODE}
  508. function RegReplaceKey(hKey: HKEY; lpSubKey: LPCWSTR; lpNewFile: LPCWSTR;
  509.   lpOldFile: LPCWSTR): LONG; stdcall;
  510. {$EXTERNALSYM RegReplaceKey}
  511. {$ELSE}
  512. function RegReplaceKey(hKey: HKEY; lpSubKey: LPCSTR; lpNewFile: LPCSTR;
  513.   lpOldFile: LPCSTR): LONG; stdcall;
  514. {$EXTERNALSYM RegReplaceKey}
  515. {$ENDIF}
  517. function RegRestoreKeyA(hKey: HKEY; lpFile: LPCSTR; dwFlags: DWORD): LONG; stdcall;
  518. {$EXTERNALSYM RegRestoreKeyA}
  519. function RegRestoreKeyW(hKey: HKEY; lpFile: LPCWSTR; dwFlags: DWORD): LONG; stdcall;
  520. {$EXTERNALSYM RegRestoreKeyW}
  522. {$IFDEF UNICODE}
  523. function RegRestoreKey(hKey: HKEY; lpFile: LPCWSTR; dwFlags: DWORD): LONG; stdcall;
  524. {$EXTERNALSYM RegRestoreKey}
  525. {$ELSE}
  526. function RegRestoreKey(hKey: HKEY; lpFile: LPCSTR; dwFlags: DWORD): LONG; stdcall;
  527. {$EXTERNALSYM RegRestoreKey}
  528. {$ENDIF}
  530. function RegSaveKeyA(hKey: HKEY; lpFile: LPCSTR;
  531.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG; stdcall;
  532. {$EXTERNALSYM RegSaveKeyA}
  533. function RegSaveKeyW(hKey: HKEY; lpFile: LPCWSTR;
  534.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG; stdcall;
  535. {$EXTERNALSYM RegSaveKeyW}
  537. {$IFDEF UNICODE}
  538. function RegSaveKey(hKey: HKEY; lpFile: LPCWSTR;
  539.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG; stdcall;
  540. {$EXTERNALSYM RegSaveKey}
  541. {$ELSE}
  542. function RegSaveKey(hKey: HKEY; lpFile: LPCSTR;
  543.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): LONG; stdcall;
  544. {$EXTERNALSYM RegSaveKey}
  545. {$ENDIF}
  547. function RegSetKeySecurity(hKey: HKEY; SecurityInformation: SECURITY_INFORMATION;
  548.   pSecurityDescriptor: PSECURITY_DESCRIPTOR): LONG; stdcall;
  549. {$EXTERNALSYM RegSetKeySecurity}
  551. function RegSetValueA(hKey: HKEY; lpSubKey: LPCSTR; dwType: DWORD;
  552.   lpData: LPCSTR; cbData: DWORD): LONG; stdcall;
  553. {$EXTERNALSYM RegSetValueA}
  554. function RegSetValueW(hKey: HKEY; lpSubKey: LPCWSTR; dwType: DWORD;
  555.   lpData: LPCWSTR; cbData: DWORD): LONG; stdcall;
  556. {$EXTERNALSYM RegSetValueW}
  558. {$IFDEF UNICODE}
  559. function RegSetValue(hKey: HKEY; lpSubKey: LPCWSTR; dwType: DWORD;
  560.   lpData: LPCWSTR; cbData: DWORD): LONG; stdcall;
  561. {$EXTERNALSYM RegSetValue}
  562. {$ELSE}
  563. function RegSetValue(hKey: HKEY; lpSubKey: LPCSTR; dwType: DWORD;
  564.   lpData: LPCSTR; cbData: DWORD): LONG; stdcall;
  565. {$EXTERNALSYM RegSetValue}
  566. {$ENDIF}
  568. function RegSetValueExA(hKey: HKEY; lpValueName: LPCSTR; Reserved: DWORD;
  569.   dwType: DWORD; lpData: LPBYTE; cbData: DWORD): LONG; stdcall;
  570. {$EXTERNALSYM RegSetValueExA}
  571. function RegSetValueExW(hKey: HKEY; lpValueName: LPCWSTR; Reserved: DWORD;
  572.   dwType: DWORD; lpData: LPBYTE; cbData: DWORD): LONG; stdcall;
  573. {$EXTERNALSYM RegSetValueExW}
  575. {$IFDEF UNICODE}
  576. function RegSetValueEx(hKey: HKEY; lpValueName: LPCWSTR; Reserved: DWORD;
  577.   dwType: DWORD; lpData: LPBYTE; cbData: DWORD): LONG; stdcall;
  578. {$EXTERNALSYM RegSetValueEx}
  579. {$ELSE}
  580. function RegSetValueEx(hKey: HKEY; lpValueName: LPCSTR; Reserved: DWORD;
  581.   dwType: DWORD; lpData: LPBYTE; cbData: DWORD): LONG; stdcall;
  582. {$EXTERNALSYM RegSetValueEx}
  583. {$ENDIF}
  585. function RegUnLoadKeyA(hKey: HKEY; lpSubKey: LPCSTR): LONG; stdcall;
  586. {$EXTERNALSYM RegUnLoadKeyA}
  587. function RegUnLoadKeyW(hKey: HKEY; lpSubKey: LPCWSTR): LONG; stdcall;
  588. {$EXTERNALSYM RegUnLoadKeyW}
  590. {$IFDEF UNICODE}
  591. function RegUnLoadKey(hKey: HKEY; lpSubKey: LPCWSTR): LONG; stdcall;
  592. {$EXTERNALSYM RegUnLoadKey}
  593. {$ELSE}
  594. function RegUnLoadKey(hKey: HKEY; lpSubKey: LPCSTR): LONG; stdcall;
  595. {$EXTERNALSYM RegUnLoadKey}
  596. {$ENDIF}
  598. //
  599. // Remoteable System Shutdown APIs
  600. //
  602. function InitiateSystemShutdownA(lpMachineName: LPSTR; lpMessage: LPSTR;
  603.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL): BOOL; stdcall;
  604. {$EXTERNALSYM InitiateSystemShutdownA}
  605. function InitiateSystemShutdownW(lpMachineName: LPWSTR; lpMessage: LPWSTR;
  606.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL): BOOL; stdcall;
  607. {$EXTERNALSYM InitiateSystemShutdownW}
  609. {$IFDEF UNICODE}
  610. function InitiateSystemShutdown(lpMachineName: LPWSTR; lpMessage: LPWSTR;
  611.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL): BOOL; stdcall;
  612. {$EXTERNALSYM InitiateSystemShutdown}
  613. {$ELSE}
  614. function InitiateSystemShutdown(lpMachineName: LPSTR; lpMessage: LPSTR;
  615.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL): BOOL; stdcall;
  616. {$EXTERNALSYM InitiateSystemShutdown}
  617. {$ENDIF}
  619. function AbortSystemShutdownA(lpMachineName: LPSTR): BOOL; stdcall;
  620. {$EXTERNALSYM AbortSystemShutdownA}
  621. function AbortSystemShutdownW(lpMachineName: LPWSTR): BOOL; stdcall;
  622. {$EXTERNALSYM AbortSystemShutdownW}
  624. {$IFDEF UNICODE}
  625. function AbortSystemShutdown(lpMachineName: LPWSTR): BOOL; stdcall;
  626. {$EXTERNALSYM AbortSystemShutdown}
  627. {$ELSE}
  628. function AbortSystemShutdown(lpMachineName: LPSTR): BOOL; stdcall;
  629. {$EXTERNALSYM AbortSystemShutdown}
  630. {$ENDIF}
  632. //
  633. // defines for InitiateSystemShutdownEx reason codes
  634. //
  636. const
  637.   REASON_SWINSTALL    = SHTDN_REASON_MAJOR_SOFTWARE or SHTDN_REASON_MINOR_INSTALLATION;
  638.   {$EXTERNALSYM REASON_SWINSTALL}
  639.   REASON_HWINSTALL    = SHTDN_REASON_MAJOR_HARDWARE or SHTDN_REASON_MINOR_INSTALLATION;
  640.   {$EXTERNALSYM REASON_HWINSTALL}
  641.   REASON_SERVICEHANG  = SHTDN_REASON_MAJOR_SOFTWARE or SHTDN_REASON_MINOR_HUNG;
  642.   {$EXTERNALSYM REASON_SERVICEHANG}
  643.   REASON_UNSTABLE     = SHTDN_REASON_MAJOR_SYSTEM or SHTDN_REASON_MINOR_UNSTABLE;
  644.   {$EXTERNALSYM REASON_UNSTABLE}
  645.   REASON_SWHWRECONF   = SHTDN_REASON_MAJOR_SOFTWARE or SHTDN_REASON_MINOR_RECONFIG;
  646.   {$EXTERNALSYM REASON_SWHWRECONF}
  647.   REASON_OTHER        = SHTDN_REASON_MAJOR_OTHER or SHTDN_REASON_MINOR_OTHER;
  648.   {$EXTERNALSYM REASON_OTHER}
  649.   REASON_UNKNOWN      = SHTDN_REASON_UNKNOWN;
  650.   {$EXTERNALSYM REASON_UNKNOWN}
  651.   REASON_LEGACY_API   = SHTDN_REASON_LEGACY_API;
  652.   {$EXTERNALSYM REASON_LEGACY_API}
  653.   REASON_PLANNED_FLAG = SHTDN_REASON_FLAG_PLANNED;
  654.   {$EXTERNALSYM REASON_PLANNED_FLAG}
  656. //
  657. // MAX Shutdown TimeOut == 10 Years in seconds
  658. //
  660.   MAX_SHUTDOWN_TIMEOUT = (10*365*24*60*60);
  661.   {$EXTERNALSYM MAX_SHUTDOWN_TIMEOUT}
  663. function InitiateSystemShutdownExA(lpMachineName: LPSTR; lpMessage: LPSTR;
  664.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL; dwReason: DWORD): BOOL; stdcall;
  665. {$EXTERNALSYM InitiateSystemShutdownExA}
  666. function InitiateSystemShutdownExW(lpMachineName: LPWSTR; lpMessage: LPWSTR;
  667.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL; dwReason: DWORD): BOOL; stdcall;
  668. {$EXTERNALSYM InitiateSystemShutdownExW}
  670. {$IFDEF UNICODE}
  671. function InitiateSystemShutdownEx(lpMachineName: LPWSTR; lpMessage: LPWSTR;
  672.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL; dwReason: DWORD): BOOL; stdcall;
  673. {$EXTERNALSYM InitiateSystemShutdownEx}
  674. {$ELSE}
  675. function InitiateSystemShutdownEx(lpMachineName: LPSTR; lpMessage: LPSTR;
  676.   dwTimeout: DWORD; bForceAppsClosed, bRebootAfterShutdown: BOOL; dwReason: DWORD): BOOL; stdcall;
  677. {$EXTERNALSYM InitiateSystemShutdownEx}
  678. {$ENDIF}
  680. function RegSaveKeyExA(hKey: HKEY; lpFile: LPCSTR;
  681.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; Flags: DWORD): LONG; stdcall;
  682. {$EXTERNALSYM RegSaveKeyExA}
  683. function RegSaveKeyExW(hKey: HKEY; lpFile: LPCWSTR;
  684.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; Flags: DWORD): LONG; stdcall;
  685. {$EXTERNALSYM RegSaveKeyExW}
  687. {$IFDEF UNICODE}
  688. function RegSaveKeyEx(hKey: HKEY; lpFile: LPCWSTR;
  689.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; Flags: DWORD): LONG; stdcall;
  690. {$EXTERNALSYM RegSaveKeyEx}
  691. {$ELSE}
  692. function RegSaveKeyEx(hKey: HKEY; lpFile: LPCSTR;
  693.   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; Flags: DWORD): LONG; stdcall;
  694. {$EXTERNALSYM RegSaveKeyEx}
  695. {$ENDIF}
  697. function Wow64Win32ApiEntry(dwFuncNumber, dwFlag, dwRes: DWORD): LONG; stdcall;
  698. {$EXTERNALSYM Wow64Win32ApiEntry}
  700. implementation
  702. const
  703.   advapi32 = 'advapi32.dll';
  706. {$IFDEF DYNAMIC_LINK}
  707. var
  708.   _RegCloseKey: Pointer;
  710. function RegCloseKey;
  711. begin
  712.   GetProcedureAddress(_RegCloseKey, advapi32, 'RegCloseKey');
  713.   asm
  714.     mov esp, ebp
  715.     pop ebp
  716.     jmp [_RegCloseKey]
  717.   end;
  718. end;
  719. {$ELSE}
  720. function RegCloseKey; external advapi32 name 'RegCloseKey';
  721. {$ENDIF DYNAMIC_LINK}
  723. {$IFDEF DYNAMIC_LINK}
  724. var
  725.   _RegOverridePredefKey: Pointer;
  727. function RegOverridePredefKey;
  728. begin
  729.   GetProcedureAddress(_RegOverridePredefKey, advapi32, 'RegOverridePredefKey');
  730.   asm
  731.     mov esp, ebp
  732.     pop ebp
  733.     jmp [_RegOverridePredefKey]
  734.   end;
  735. end;
  736. {$ELSE}
  737. function RegOverridePredefKey; external advapi32 name 'RegOverridePredefKey';
  738. {$ENDIF DYNAMIC_LINK}
  740. {$IFDEF DYNAMIC_LINK}
  741. var
  742.   _RegOpenUserClassesRoot: Pointer;
  744. function RegOpenUserClassesRoot;
  745. begin
  746.   GetProcedureAddress(_RegOpenUserClassesRoot, advapi32, 'RegOpenUserClassesRoot');
  747.   asm
  748.     mov esp, ebp
  749.     pop ebp
  750.     jmp [_RegOpenUserClassesRoot]
  751.   end;
  752. end;
  753. {$ELSE}
  754. function RegOpenUserClassesRoot; external advapi32 name 'RegOpenUserClassesRoot';
  755. {$ENDIF DYNAMIC_LINK}
  757. {$IFDEF DYNAMIC_LINK}
  758. var
  759.   _RegOpenCurrentUser: Pointer;
  761. function RegOpenCurrentUser;
  762. begin
  763.   GetProcedureAddress(_RegOpenCurrentUser, advapi32, 'RegOpenCurrentUser');
  764.   asm
  765.     mov esp, ebp
  766.     pop ebp
  767.     jmp [_RegOpenCurrentUser]
  768.   end;
  769. end;
  770. {$ELSE}
  771. function RegOpenCurrentUser; external advapi32 name 'RegOpenCurrentUser';
  772. {$ENDIF DYNAMIC_LINK}
  774. {$IFDEF DYNAMIC_LINK}
  775. var
  776.   _RegDisablePredefinedCache: Pointer;
  778. function RegDisablePredefinedCache;
  779. begin
  780.   GetProcedureAddress(_RegDisablePredefinedCache, advapi32, 'RegDisablePredefinedCache');
  781.   asm
  782.     mov esp, ebp
  783.     pop ebp
  784.     jmp [_RegDisablePredefinedCache]
  785.   end;
  786. end;
  787. {$ELSE}
  788. function RegDisablePredefinedCache; external advapi32 name 'RegDisablePredefinedCache';
  789. {$ENDIF DYNAMIC_LINK}
  791. {$IFDEF DYNAMIC_LINK}
  792. var
  793.   _RegConnectRegistryA: Pointer;
  795. function RegConnectRegistryA;
  796. begin
  797.   GetProcedureAddress(_RegConnectRegistryA, advapi32, 'RegConnectRegistryA');
  798.   asm
  799.     mov esp, ebp
  800.     pop ebp
  801.     jmp [_RegConnectRegistryA]
  802.   end;
  803. end;
  804. {$ELSE}
  805. function RegConnectRegistryA; external advapi32 name 'RegConnectRegistryA';
  806. {$ENDIF DYNAMIC_LINK}
  808. {$IFDEF DYNAMIC_LINK}
  809. var
  810.   _RegConnectRegistryW: Pointer;
  812. function RegConnectRegistryW;
  813. begin
  814.   GetProcedureAddress(_RegConnectRegistryW, advapi32, 'RegConnectRegistryW');
  815.   asm
  816.     mov esp, ebp
  817.     pop ebp
  818.     jmp [_RegConnectRegistryW]
  819.   end;
  820. end;
  821. {$ELSE}
  822. function RegConnectRegistryW; external advapi32 name 'RegConnectRegistryW';
  823. {$ENDIF DYNAMIC_LINK}
  824. {$IFDEF UNICODE}
  826. {$IFDEF DYNAMIC_LINK}
  827. var
  828.   _RegConnectRegistry: Pointer;
  830. function RegConnectRegistry;
  831. begin
  832.   GetProcedureAddress(_RegConnectRegistry, advapi32, 'RegConnectRegistryW');
  833.   asm
  834.     mov esp, ebp
  835.     pop ebp
  836.     jmp [_RegConnectRegistry]
  837.   end;
  838. end;
  839. {$ELSE}
  840. function RegConnectRegistry; external advapi32 name 'RegConnectRegistryW';
  841. {$ENDIF DYNAMIC_LINK}
  842. {$ELSE}
  844. {$IFDEF DYNAMIC_LINK}
  845. var
  846.   _RegConnectRegistry: Pointer;
  848. function RegConnectRegistry;
  849. begin
  850.   GetProcedureAddress(_RegConnectRegistry, advapi32, 'RegConnectRegistryA');
  851.   asm
  852.     mov esp, ebp
  853.     pop ebp
  854.     jmp [_RegConnectRegistry]
  855.   end;
  856. end;
  857. {$ELSE}
  858. function RegConnectRegistry; external advapi32 name 'RegConnectRegistryA';
  859. {$ENDIF DYNAMIC_LINK}
  860. {$ENDIF}
  862. {$IFDEF DYNAMIC_LINK}
  863. var
  864.   _RegCreateKeyA: Pointer;
  866. function RegCreateKeyA;
  867. begin
  868.   GetProcedureAddress(_RegCreateKeyA, advapi32, 'RegCreateKeyA');
  869.   asm
  870.     mov esp, ebp
  871.     pop ebp
  872.     jmp [_RegCreateKeyA]
  873.   end;
  874. end;
  875. {$ELSE}
  876. function RegCreateKeyA; external advapi32 name 'RegCreateKeyA';
  877. {$ENDIF DYNAMIC_LINK}
  879. {$IFDEF DYNAMIC_LINK}
  880. var
  881.   _RegCreateKeyW: Pointer;
  883. function RegCreateKeyW;
  884. begin
  885.   GetProcedureAddress(_RegCreateKeyW, advapi32, 'RegCreateKeyW');
  886.   asm
  887.     mov esp, ebp
  888.     pop ebp
  889.     jmp [_RegCreateKeyW]
  890.   end;
  891. end;
  892. {$ELSE}
  893. function RegCreateKeyW; external advapi32 name 'RegCreateKeyW';
  894. {$ENDIF DYNAMIC_LINK}
  895. {$IFDEF UNICODE}
  897. {$IFDEF DYNAMIC_LINK}
  898. var
  899.   _RegCreateKey: Pointer;
  901. function RegCreateKey;
  902. begin
  903.   GetProcedureAddress(_RegCreateKey, advapi32, 'RegCreateKeyW');
  904.   asm
  905.     mov esp, ebp
  906.     pop ebp
  907.     jmp [_RegCreateKey]
  908.   end;
  909. end;
  910. {$ELSE}
  911. function RegCreateKey; external advapi32 name 'RegCreateKeyW';
  912. {$ENDIF DYNAMIC_LINK}
  913. {$ELSE}
  915. {$IFDEF DYNAMIC_LINK}
  916. var
  917.   _RegCreateKey: Pointer;
  919. function RegCreateKey;
  920. begin
  921.   GetProcedureAddress(_RegCreateKey, advapi32, 'RegCreateKeyA');
  922.   asm
  923.     mov esp, ebp
  924.     pop ebp
  925.     jmp [_RegCreateKey]
  926.   end;
  927. end;
  928. {$ELSE}
  929. function RegCreateKey; external advapi32 name 'RegCreateKeyA';
  930. {$ENDIF DYNAMIC_LINK}
  931. {$ENDIF}
  933. {$IFDEF DYNAMIC_LINK}
  934. var
  935.   _RegCreateKeyExA: Pointer;
  937. function RegCreateKeyExA;
  938. begin
  939.   GetProcedureAddress(_RegCreateKeyExA, advapi32, 'RegCreateKeyExA');
  940.   asm
  941.     mov esp, ebp
  942.     pop ebp
  943.     jmp [_RegCreateKeyExA]
  944.   end;
  945. end;
  946. {$ELSE}
  947. function RegCreateKeyExA; external advapi32 name 'RegCreateKeyExA';
  948. {$ENDIF DYNAMIC_LINK}
  950. {$IFDEF DYNAMIC_LINK}
  951. var
  952.   _RegCreateKeyExW: Pointer;
  954. function RegCreateKeyExW;
  955. begin
  956.   GetProcedureAddress(_RegCreateKeyExW, advapi32, 'RegCreateKeyExW');
  957.   asm
  958.     mov esp, ebp
  959.     pop ebp
  960.     jmp [_RegCreateKeyExW]
  961.   end;
  962. end;
  963. {$ELSE}
  964. function RegCreateKeyExW; external advapi32 name 'RegCreateKeyExW';
  965. {$ENDIF DYNAMIC_LINK}
  966. {$IFDEF UNICODE}
  968. {$IFDEF DYNAMIC_LINK}
  969. var
  970.   _RegCreateKeyEx: Pointer;
  972. function RegCreateKeyEx;
  973. begin
  974.   GetProcedureAddress(_RegCreateKeyEx, advapi32, 'RegCreateKeyExW');
  975.   asm
  976.     mov esp, ebp
  977.     pop ebp
  978.     jmp [_RegCreateKeyEx]
  979.   end;
  980. end;
  981. {$ELSE}
  982. function RegCreateKeyEx; external advapi32 name 'RegCreateKeyExW';
  983. {$ENDIF DYNAMIC_LINK}
  984. {$ELSE}
  986. {$IFDEF DYNAMIC_LINK}
  987. var
  988.   _RegCreateKeyEx: Pointer;
  990. function RegCreateKeyEx;
  991. begin
  992.   GetProcedureAddress(_RegCreateKeyEx, advapi32, 'RegCreateKeyExA');
  993.   asm
  994.     mov esp, ebp
  995.     pop ebp
  996.     jmp [_RegCreateKeyEx]
  997.   end;
  998. end;
  999. {$ELSE}
  1000. function RegCreateKeyEx; external advapi32 name 'RegCreateKeyExA';
  1001. {$ENDIF DYNAMIC_LINK}
  1002. {$ENDIF}
  1004. {$IFDEF DYNAMIC_LINK}
  1005. var
  1006.   _RegDeleteKeyA: Pointer;
  1008. function RegDeleteKeyA;
  1009. begin
  1010.   GetProcedureAddress(_RegDeleteKeyA, advapi32, 'RegDeleteKeyA');
  1011.   asm
  1012.     mov esp, ebp
  1013.     pop ebp
  1014.     jmp [_RegDeleteKeyA]
  1015.   end;
  1016. end;
  1017. {$ELSE}
  1018. function RegDeleteKeyA; external advapi32 name 'RegDeleteKeyA';
  1019. {$ENDIF DYNAMIC_LINK}
  1021. {$IFDEF DYNAMIC_LINK}
  1022. var
  1023.   _RegDeleteKeyW: Pointer;
  1025. function RegDeleteKeyW;
  1026. begin
  1027.   GetProcedureAddress(_RegDeleteKeyW, advapi32, 'RegDeleteKeyW');
  1028.   asm
  1029.     mov esp, ebp
  1030.     pop ebp
  1031.     jmp [_RegDeleteKeyW]
  1032.   end;
  1033. end;
  1034. {$ELSE}
  1035. function RegDeleteKeyW; external advapi32 name 'RegDeleteKeyW';
  1036. {$ENDIF DYNAMIC_LINK}
  1037. {$IFDEF UNICODE}
  1039. {$IFDEF DYNAMIC_LINK}
  1040. var
  1041.   _RegDeleteKey: Pointer;
  1043. function RegDeleteKey;
  1044. begin
  1045.   GetProcedureAddress(_RegDeleteKey, advapi32, 'RegDeleteKeyW');
  1046.   asm
  1047.     mov esp, ebp
  1048.     pop ebp
  1049.     jmp [_RegDeleteKey]
  1050.   end;
  1051. end;
  1052. {$ELSE}
  1053. function RegDeleteKey; external advapi32 name 'RegDeleteKeyW';
  1054. {$ENDIF DYNAMIC_LINK}
  1055. {$ELSE}
  1057. {$IFDEF DYNAMIC_LINK}
  1058. var
  1059.   _RegDeleteKey: Pointer;
  1061. function RegDeleteKey;
  1062. begin
  1063.   GetProcedureAddress(_RegDeleteKey, advapi32, 'RegDeleteKeyA');
  1064.   asm
  1065.     mov esp, ebp
  1066.     pop ebp
  1067.     jmp [_RegDeleteKey]
  1068.   end;
  1069. end;
  1070. {$ELSE}
  1071. function RegDeleteKey; external advapi32 name 'RegDeleteKeyA';
  1072. {$ENDIF DYNAMIC_LINK}
  1073. {$ENDIF}
  1075. {$IFDEF DYNAMIC_LINK}
  1076. var
  1077.   _RegDeleteValueA: Pointer;
  1079. function RegDeleteValueA;
  1080. begin
  1081.   GetProcedureAddress(_RegDeleteValueA, advapi32, 'RegDeleteValueA');
  1082.   asm
  1083.     mov esp, ebp
  1084.     pop ebp
  1085.     jmp [_RegDeleteValueA]
  1086.   end;
  1087. end;
  1088. {$ELSE}
  1089. function RegDeleteValueA; external advapi32 name 'RegDeleteValueA';
  1090. {$ENDIF DYNAMIC_LINK}
  1092. {$IFDEF DYNAMIC_LINK}
  1093. var
  1094.   _RegDeleteValueW: Pointer;
  1096. function RegDeleteValueW;
  1097. begin
  1098.   GetProcedureAddress(_RegDeleteValueW, advapi32, 'RegDeleteValueW');
  1099.   asm
  1100.     mov esp, ebp
  1101.     pop ebp
  1102.     jmp [_RegDeleteValueW]
  1103.   end;
  1104. end;
  1105. {$ELSE}
  1106. function RegDeleteValueW; external advapi32 name 'RegDeleteValueW';
  1107. {$ENDIF DYNAMIC_LINK}
  1108. {$IFDEF UNICODE}
  1110. {$IFDEF DYNAMIC_LINK}
  1111. var
  1112.   _RegDeleteValue: Pointer;
  1114. function RegDeleteValue;
  1115. begin
  1116.   GetProcedureAddress(_RegDeleteValue, advapi32, 'RegDeleteValueW');
  1117.   asm
  1118.     mov esp, ebp
  1119.     pop ebp
  1120.     jmp [_RegDeleteValue]
  1121.   end;
  1122. end;
  1123. {$ELSE}
  1124. function RegDeleteValue; external advapi32 name 'RegDeleteValueW';
  1125. {$ENDIF DYNAMIC_LINK}
  1126. {$ELSE}
  1128. {$IFDEF DYNAMIC_LINK}
  1129. var
  1130.   _RegDeleteValue: Pointer;
  1132. function RegDeleteValue;
  1133. begin
  1134.   GetProcedureAddress(_RegDeleteValue, advapi32, 'RegDeleteValueA');
  1135.   asm
  1136.     mov esp, ebp
  1137.     pop ebp
  1138.     jmp [_RegDeleteValue]
  1139.   end;
  1140. end;
  1141. {$ELSE}
  1142. function RegDeleteValue; external advapi32 name 'RegDeleteValueA';
  1143. {$ENDIF DYNAMIC_LINK}
  1144. {$ENDIF}
  1146. {$IFDEF DYNAMIC_LINK}
  1147. var
  1148.   _RegEnumKeyA: Pointer;
  1150. function RegEnumKeyA;
  1151. begin
  1152.   GetProcedureAddress(_RegEnumKeyA, advapi32, 'RegEnumKeyA');
  1153.   asm
  1154.     mov esp, ebp
  1155.     pop ebp
  1156.     jmp [_RegEnumKeyA]
  1157.   end;
  1158. end;
  1159. {$ELSE}
  1160. function RegEnumKeyA; external advapi32 name 'RegEnumKeyA';
  1161. {$ENDIF DYNAMIC_LINK}
  1163. {$IFDEF DYNAMIC_LINK}
  1164. var
  1165.   _RegEnumKeyW: Pointer;
  1167. function RegEnumKeyW;
  1168. begin
  1169.   GetProcedureAddress(_RegEnumKeyW, advapi32, 'RegEnumKeyW');
  1170.   asm
  1171.     mov esp, ebp
  1172.     pop ebp
  1173.     jmp [_RegEnumKeyW]
  1174.   end;
  1175. end;
  1176. {$ELSE}
  1177. function RegEnumKeyW; external advapi32 name 'RegEnumKeyW';
  1178. {$ENDIF DYNAMIC_LINK}
  1179. {$IFDEF UNICODE}
  1181. {$IFDEF DYNAMIC_LINK}
  1182. var
  1183.   _RegEnumKey: Pointer;
  1185. function RegEnumKey;
  1186. begin
  1187.   GetProcedureAddress(_RegEnumKey, advapi32, 'RegEnumKeyW');
  1188.   asm
  1189.     mov esp, ebp
  1190.     pop ebp
  1191.     jmp [_RegEnumKey]
  1192.   end;
  1193. end;
  1194. {$ELSE}
  1195. function RegEnumKey; external advapi32 name 'RegEnumKeyW';
  1196. {$ENDIF DYNAMIC_LINK}
  1197. {$ELSE}
  1199. {$IFDEF DYNAMIC_LINK}
  1200. var
  1201.   _RegEnumKey: Pointer;
  1203. function RegEnumKey;
  1204. begin
  1205.   GetProcedureAddress(_RegEnumKey, advapi32, 'RegEnumKeyA');
  1206.   asm
  1207.     mov esp, ebp
  1208.     pop ebp
  1209.     jmp [_RegEnumKey]
  1210.   end;
  1211. end;
  1212. {$ELSE}
  1213. function RegEnumKey; external advapi32 name 'RegEnumKeyA';
  1214. {$ENDIF DYNAMIC_LINK}
  1215. {$ENDIF}
  1217. {$IFDEF DYNAMIC_LINK}
  1218. var
  1219.   _RegEnumKeyExA: Pointer;
  1221. function RegEnumKeyExA;
  1222. begin
  1223.   GetProcedureAddress(_RegEnumKeyExA, advapi32, 'RegEnumKeyExA');
  1224.   asm
  1225.     mov esp, ebp
  1226.     pop ebp
  1227.     jmp [_RegEnumKeyExA]
  1228.   end;
  1229. end;
  1230. {$ELSE}
  1231. function RegEnumKeyExA; external advapi32 name 'RegEnumKeyExA';
  1232. {$ENDIF DYNAMIC_LINK}
  1234. {$IFDEF DYNAMIC_LINK}
  1235. var
  1236.   _RegEnumKeyExW: Pointer;
  1238. function RegEnumKeyExW;
  1239. begin
  1240.   GetProcedureAddress(_RegEnumKeyExW, advapi32, 'RegEnumKeyExW');
  1241.   asm
  1242.     mov esp, ebp
  1243.     pop ebp
  1244.     jmp [_RegEnumKeyExW]
  1245.   end;
  1246. end;
  1247. {$ELSE}
  1248. function RegEnumKeyExW; external advapi32 name 'RegEnumKeyExW';
  1249. {$ENDIF DYNAMIC_LINK}
  1250. {$IFDEF UNICODE}
  1252. {$IFDEF DYNAMIC_LINK}
  1253. var
  1254.   _RegEnumKeyEx: Pointer;
  1256. function RegEnumKeyEx;
  1257. begin
  1258.   GetProcedureAddress(_RegEnumKeyEx, advapi32, 'RegEnumKeyExW');
  1259.   asm
  1260.     mov esp, ebp
  1261.     pop ebp
  1262.     jmp [_RegEnumKeyEx]
  1263.   end;
  1264. end;
  1265. {$ELSE}
  1266. function RegEnumKeyEx; external advapi32 name 'RegEnumKeyExW';
  1267. {$ENDIF DYNAMIC_LINK}
  1268. {$ELSE}
  1270. {$IFDEF DYNAMIC_LINK}
  1271. var
  1272.   _RegEnumKeyEx: Pointer;
  1274. function RegEnumKeyEx;
  1275. begin
  1276.   GetProcedureAddress(_RegEnumKeyEx, advapi32, 'RegEnumKeyExA');
  1277.   asm
  1278.     mov esp, ebp
  1279.     pop ebp
  1280.     jmp [_RegEnumKeyEx]
  1281.   end;
  1282. end;
  1283. {$ELSE}
  1284. function RegEnumKeyEx; external advapi32 name 'RegEnumKeyExA';
  1285. {$ENDIF DYNAMIC_LINK}
  1286. {$ENDIF}
  1288. {$IFDEF DYNAMIC_LINK}
  1289. var
  1290.   _RegEnumValueA: Pointer;
  1292. function RegEnumValueA;
  1293. begin
  1294.   GetProcedureAddress(_RegEnumValueA, advapi32, 'RegEnumValueA');
  1295.   asm
  1296.     mov esp, ebp
  1297.     pop ebp
  1298.     jmp [_RegEnumValueA]
  1299.   end;
  1300. end;
  1301. {$ELSE}
  1302. function RegEnumValueA; external advapi32 name 'RegEnumValueA';
  1303. {$ENDIF DYNAMIC_LINK}
  1305. {$IFDEF DYNAMIC_LINK}
  1306. var
  1307.   _RegEnumValueW: Pointer;
  1309. function RegEnumValueW;
  1310. begin
  1311.   GetProcedureAddress(_RegEnumValueW, advapi32, 'RegEnumValueW');
  1312.   asm
  1313.     mov esp, ebp
  1314.     pop ebp
  1315.     jmp [_RegEnumValueW]
  1316.   end;
  1317. end;
  1318. {$ELSE}
  1319. function RegEnumValueW; external advapi32 name 'RegEnumValueW';
  1320. {$ENDIF DYNAMIC_LINK}
  1321. {$IFDEF UNICODE}
  1323. {$IFDEF DYNAMIC_LINK}
  1324. var
  1325.   _RegEnumValue: Pointer;
  1327. function RegEnumValue;
  1328. begin
  1329.   GetProcedureAddress(_RegEnumValue, advapi32, 'RegEnumValueW');
  1330.   asm
  1331.     mov esp, ebp
  1332.     pop ebp
  1333.     jmp [_RegEnumValue]
  1334.   end;
  1335. end;
  1336. {$ELSE}
  1337. function RegEnumValue; external advapi32 name 'RegEnumValueW';
  1338. {$ENDIF DYNAMIC_LINK}
  1339. {$ELSE}
  1341. {$IFDEF DYNAMIC_LINK}
  1342. var
  1343.   _RegEnumValue: Pointer;
  1345. function RegEnumValue;
  1346. begin
  1347.   GetProcedureAddress(_RegEnumValue, advapi32, 'RegEnumValueA');
  1348.   asm
  1349.     mov esp, ebp
  1350.     pop ebp
  1351.     jmp [_RegEnumValue]
  1352.   end;
  1353. end;
  1354. {$ELSE}
  1355. function RegEnumValue; external advapi32 name 'RegEnumValueA';
  1356. {$ENDIF DYNAMIC_LINK}
  1357. {$ENDIF}
  1359. {$IFDEF DYNAMIC_LINK}
  1360. var
  1361.   _RegFlushKey: Pointer;
  1363. function RegFlushKey;
  1364. begin
  1365.   GetProcedureAddress(_RegFlushKey, advapi32, 'RegFlushKey');
  1366.   asm
  1367.     mov esp, ebp
  1368.     pop ebp
  1369.     jmp [_RegFlushKey]
  1370.   end;
  1371. end;
  1372. {$ELSE}
  1373. function RegFlushKey; external advapi32 name 'RegFlushKey';
  1374. {$ENDIF DYNAMIC_LINK}
  1376. {$IFDEF DYNAMIC_LINK}
  1377. var
  1378.   _RegGetKeySecurity: Pointer;
  1380. function RegGetKeySecurity;
  1381. begin
  1382.   GetProcedureAddress(_RegGetKeySecurity, advapi32, 'RegGetKeySecurity');
  1383.   asm
  1384.     mov esp, ebp
  1385.     pop ebp
  1386.     jmp [_RegGetKeySecurity]
  1387.   end;
  1388. end;
  1389. {$ELSE}
  1390. function RegGetKeySecurity; external advapi32 name 'RegGetKeySecurity';
  1391. {$ENDIF DYNAMIC_LINK}
  1393. {$IFDEF DYNAMIC_LINK}
  1394. var
  1395.   _RegLoadKeyA: Pointer;
  1397. function RegLoadKeyA;
  1398. begin
  1399.   GetProcedureAddress(_RegLoadKeyA, advapi32, 'RegLoadKeyA');
  1400.   asm
  1401.     mov esp, ebp
  1402.     pop ebp
  1403.     jmp [_RegLoadKeyA]
  1404.   end;
  1405. end;
  1406. {$ELSE}
  1407. function RegLoadKeyA; external advapi32 name 'RegLoadKeyA';
  1408. {$ENDIF DYNAMIC_LINK}
  1410. {$IFDEF DYNAMIC_LINK}
  1411. var
  1412.   _RegLoadKeyW: Pointer;
  1414. function RegLoadKeyW;
  1415. begin
  1416.   GetProcedureAddress(_RegLoadKeyW, advapi32, 'RegLoadKeyW');
  1417.   asm
  1418.     mov esp, ebp
  1419.     pop ebp
  1420.     jmp [_RegLoadKeyW]
  1421.   end;
  1422. end;
  1423. {$ELSE}
  1424. function RegLoadKeyW; external advapi32 name 'RegLoadKeyW';
  1425. {$ENDIF DYNAMIC_LINK}
  1426. {$IFDEF UNICODE}
  1428. {$IFDEF DYNAMIC_LINK}
  1429. var
  1430.   _RegLoadKey: Pointer;
  1432. function RegLoadKey;
  1433. begin
  1434.   GetProcedureAddress(_RegLoadKey, advapi32, 'RegLoadKeyW');
  1435.   asm
  1436.     mov esp, ebp
  1437.     pop ebp
  1438.     jmp [_RegLoadKey]
  1439.   end;
  1440. end;
  1441. {$ELSE}
  1442. function RegLoadKey; external advapi32 name 'RegLoadKeyW';
  1443. {$ENDIF DYNAMIC_LINK}
  1444. {$ELSE}
  1446. {$IFDEF DYNAMIC_LINK}
  1447. var
  1448.   _RegLoadKey: Pointer;
  1450. function RegLoadKey;
  1451. begin
  1452.   GetProcedureAddress(_RegLoadKey, advapi32, 'RegLoadKeyA');
  1453.   asm
  1454.     mov esp, ebp
  1455.     pop ebp
  1456.     jmp [_RegLoadKey]
  1457.   end;
  1458. end;
  1459. {$ELSE}
  1460. function RegLoadKey; external advapi32 name 'RegLoadKeyA';
  1461. {$ENDIF DYNAMIC_LINK}
  1462. {$ENDIF}
  1464. type
  1465.   TRegNotifyChangeKeyValue = function (hKey: HKEY; bWatchSubtree: LongBool; dwNotifyFilter: DWORD; hEvent: HANDLE; fAsynchronus: LongBool): LONG; stdcall;
  1467. var
  1468.   _RegNotifyChangeKeyValue: Pointer;
  1470. function RegNotifyChangeKeyValue(hKey: HKEY; bWatchSubtree: LongBool; dwNotifyFilter: DWORD; hEvent: HANDLE; fAsynchronus: LongBool): LONG;
  1471. begin
  1472.   GetProcedureAddress(_RegNotifyChangeKeyValue, advapi32, 'RegNotifyChangeKeyValue');
  1473.   if bWatchSubTree then
  1474.     Result := TRegNotifyChangeKeyValue(_RegNotifyChangeKeyValue)(hKey, LongBool(1), dwNotifyFilter, hEvent, fAsynchronus)
  1475.   else
  1476.     Result := TRegNotifyChangeKeyValue(_RegNotifyChangeKeyValue)(hKey, LongBool(0), dwNotifyFilter, hEvent, fAsynchronus);
  1477. end;
  1479. {$IFDEF DYNAMIC_LINK}
  1480. var
  1481.   _RegOpenKeyA: Pointer;
  1483. function RegOpenKeyA;
  1484. begin
  1485.   GetProcedureAddress(_RegOpenKeyA, advapi32, 'RegOpenKeyA');
  1486.   asm
  1487.     mov esp, ebp
  1488.     pop ebp
  1489.     jmp [_RegOpenKeyA]
  1490.   end;
  1491. end;
  1492. {$ELSE}
  1493. function RegOpenKeyA; external advapi32 name 'RegOpenKeyA';
  1494. {$ENDIF DYNAMIC_LINK}
  1496. {$IFDEF DYNAMIC_LINK}
  1497. var
  1498.   _RegOpenKeyW: Pointer;
  1500. function RegOpenKeyW;
  1501. begin
  1502.   GetProcedureAddress(_RegOpenKeyW, advapi32, 'RegOpenKeyW');
  1503.   asm
  1504.     mov esp, ebp
  1505.     pop ebp
  1506.     jmp [_RegOpenKeyW]
  1507.   end;
  1508. end;
  1509. {$ELSE}
  1510. function RegOpenKeyW; external advapi32 name 'RegOpenKeyW';
  1511. {$ENDIF DYNAMIC_LINK}
  1512. {$IFDEF UNICODE}
  1514. {$IFDEF DYNAMIC_LINK}
  1515. var
  1516.   _RegOpenKey: Pointer;
  1518. function RegOpenKey;
  1519. begin
  1520.   GetProcedureAddress(_RegOpenKey, advapi32, 'RegOpenKeyW');
  1521.   asm
  1522.     mov esp, ebp
  1523.     pop ebp
  1524.     jmp [_RegOpenKey]
  1525.   end;
  1526. end;
  1527. {$ELSE}
  1528. function RegOpenKey; external advapi32 name 'RegOpenKeyW';
  1529. {$ENDIF DYNAMIC_LINK}
  1530. {$ELSE}
  1532. {$IFDEF DYNAMIC_LINK}
  1533. var
  1534.   _RegOpenKey: Pointer;
  1536. function RegOpenKey;
  1537. begin
  1538.   GetProcedureAddress(_RegOpenKey, advapi32, 'RegOpenKeyA');
  1539.   asm
  1540.     mov esp, ebp
  1541.     pop ebp
  1542.     jmp [_RegOpenKey]
  1543.   end;
  1544. end;
  1545. {$ELSE}
  1546. function RegOpenKey; external advapi32 name 'RegOpenKeyA';
  1547. {$ENDIF DYNAMIC_LINK}
  1548. {$ENDIF}
  1550. {$IFDEF DYNAMIC_LINK}
  1551. var
  1552.   _RegOpenKeyExA: Pointer;
  1554. function RegOpenKeyExA;
  1555. begin
  1556.   GetProcedureAddress(_RegOpenKeyExA, advapi32, 'RegOpenKeyExA');
  1557.   asm
  1558.     mov esp, ebp
  1559.     pop ebp
  1560.     jmp [_RegOpenKeyExA]
  1561.   end;
  1562. end;
  1563. {$ELSE}
  1564. function RegOpenKeyExA; external advapi32 name 'RegOpenKeyExA';
  1565. {$ENDIF DYNAMIC_LINK}
  1567. {$IFDEF DYNAMIC_LINK}
  1568. var
  1569.   _RegOpenKeyExW: Pointer;
  1571. function RegOpenKeyExW;
  1572. begin
  1573.   GetProcedureAddress(_RegOpenKeyExW, advapi32, 'RegOpenKeyExW');
  1574.   asm
  1575.     mov esp, ebp
  1576.     pop ebp
  1577.     jmp [_RegOpenKeyExW]
  1578.   end;
  1579. end;
  1580. {$ELSE}
  1581. function RegOpenKeyExW; external advapi32 name 'RegOpenKeyExW';
  1582. {$ENDIF DYNAMIC_LINK}
  1583. {$IFDEF UNICODE}
  1585. {$IFDEF DYNAMIC_LINK}
  1586. var
  1587.   _RegOpenKeyEx: Pointer;
  1589. function RegOpenKeyEx;
  1590. begin
  1591.   GetProcedureAddress(_RegOpenKeyEx, advapi32, 'RegOpenKeyExW');
  1592.   asm
  1593.     mov esp, ebp
  1594.     pop ebp
  1595.     jmp [_RegOpenKeyEx]
  1596.   end;
  1597. end;
  1598. {$ELSE}
  1599. function RegOpenKeyEx; external advapi32 name 'RegOpenKeyExW';
  1600. {$ENDIF DYNAMIC_LINK}
  1601. {$ELSE}
  1603. {$IFDEF DYNAMIC_LINK}
  1604. var
  1605.   _RegOpenKeyEx: Pointer;
  1607. function RegOpenKeyEx;
  1608. begin
  1609.   GetProcedureAddress(_RegOpenKeyEx, advapi32, 'RegOpenKeyExA');
  1610.   asm
  1611.     mov esp, ebp
  1612.     pop ebp
  1613.     jmp [_RegOpenKeyEx]
  1614.   end;
  1615. end;
  1616. {$ELSE}
  1617. function RegOpenKeyEx; external advapi32 name 'RegOpenKeyExA';
  1618. {$ENDIF DYNAMIC_LINK}
  1619. {$ENDIF}
  1621. {$IFDEF DYNAMIC_LINK}
  1622. var
  1623.   _RegQueryInfoKeyA: Pointer;
  1625. function RegQueryInfoKeyA;
  1626. begin
  1627.   GetProcedureAddress(_RegQueryInfoKeyA, advapi32, 'RegQueryInfoKeyA');
  1628.   asm
  1629.     mov esp, ebp
  1630.     pop ebp
  1631.     jmp [_RegQueryInfoKeyA]
  1632.   end;
  1633. end;
  1634. {$ELSE}
  1635. function RegQueryInfoKeyA; external advapi32 name 'RegQueryInfoKeyA';
  1636. {$ENDIF DYNAMIC_LINK}
  1638. {$IFDEF DYNAMIC_LINK}
  1639. var
  1640.   _RegQueryInfoKeyW: Pointer;
  1642. function RegQueryInfoKeyW;
  1643. begin
  1644.   GetProcedureAddress(_RegQueryInfoKeyW, advapi32, 'RegQueryInfoKeyW');
  1645.   asm
  1646.     mov esp, ebp
  1647.     pop ebp
  1648.     jmp [_RegQueryInfoKeyW]
  1649.   end;
  1650. end;
  1651. {$ELSE}
  1652. function RegQueryInfoKeyW; external advapi32 name 'RegQueryInfoKeyW';
  1653. {$ENDIF DYNAMIC_LINK}
  1654. {$IFDEF UNICODE}
  1656. {$IFDEF DYNAMIC_LINK}
  1657. var
  1658.   _RegQueryInfoKey: Pointer;
  1660. function RegQueryInfoKey;
  1661. begin
  1662.   GetProcedureAddress(_RegQueryInfoKey, advapi32, 'RegQueryInfoKeyW');
  1663.   asm
  1664.     mov esp, ebp
  1665.     pop ebp
  1666.     jmp [_RegQueryInfoKey]
  1667.   end;
  1668. end;
  1669. {$ELSE}
  1670. function RegQueryInfoKey; external advapi32 name 'RegQueryInfoKeyW';
  1671. {$ENDIF DYNAMIC_LINK}
  1672. {$ELSE}
  1674. {$IFDEF DYNAMIC_LINK}
  1675. var
  1676.   _RegQueryInfoKey: Pointer;
  1678. function RegQueryInfoKey;
  1679. begin
  1680.   GetProcedureAddress(_RegQueryInfoKey, advapi32, 'RegQueryInfoKeyA');
  1681.   asm
  1682.     mov esp, ebp
  1683.     pop ebp
  1684.     jmp [_RegQueryInfoKey]
  1685.   end;
  1686. end;
  1687. {$ELSE}
  1688. function RegQueryInfoKey; external advapi32 name 'RegQueryInfoKeyA';
  1689. {$ENDIF DYNAMIC_LINK}
  1690. {$ENDIF}
  1692. {$IFDEF DYNAMIC_LINK}
  1693. var
  1694.   _RegQueryValueA: Pointer;
  1696. function RegQueryValueA;
  1697. begin
  1698.   GetProcedureAddress(_RegQueryValueA, advapi32, 'RegQueryValueA');
  1699.   asm
  1700.     mov esp, ebp
  1701.     pop ebp
  1702.     jmp [_RegQueryValueA]
  1703.   end;
  1704. end;
  1705. {$ELSE}
  1706. function RegQueryValueA; external advapi32 name 'RegQueryValueA';
  1707. {$ENDIF DYNAMIC_LINK}
  1709. {$IFDEF DYNAMIC_LINK}
  1710. var
  1711.   _RegQueryValueW: Pointer;
  1713. function RegQueryValueW;
  1714. begin
  1715.   GetProcedureAddress(_RegQueryValueW, advapi32, 'RegQueryValueW');
  1716.   asm
  1717.     mov esp, ebp
  1718.     pop ebp
  1719.     jmp [_RegQueryValueW]
  1720.   end;
  1721. end;
  1722. {$ELSE}
  1723. function RegQueryValueW; external advapi32 name 'RegQueryValueW';
  1724. {$ENDIF DYNAMIC_LINK}
  1725. {$IFDEF UNICODE}
  1727. {$IFDEF DYNAMIC_LINK}
  1728. var
  1729.   _RegQueryValue: Pointer;
  1731. function RegQueryValue;
  1732. begin
  1733.   GetProcedureAddress(_RegQueryValue, advapi32, 'RegQueryValueW');
  1734.   asm
  1735.     mov esp, ebp
  1736.     pop ebp
  1737.     jmp [_RegQueryValue]
  1738.   end;
  1739. end;
  1740. {$ELSE}
  1741. function RegQueryValue; external advapi32 name 'RegQueryValueW';
  1742. {$ENDIF DYNAMIC_LINK}
  1743. {$ELSE}
  1745. {$IFDEF DYNAMIC_LINK}
  1746. var
  1747.   _RegQueryValue: Pointer;
  1749. function RegQueryValue;
  1750. begin
  1751.   GetProcedureAddress(_RegQueryValue, advapi32, 'RegQueryValueA');
  1752.   asm
  1753.     mov esp, ebp
  1754.     pop ebp
  1755.     jmp [_RegQueryValue]
  1756.   end;
  1757. end;
  1758. {$ELSE}
  1759. function RegQueryValue; external advapi32 name 'RegQueryValueA';
  1760. {$ENDIF DYNAMIC_LINK}
  1761. {$ENDIF}
  1763. {$IFDEF DYNAMIC_LINK}
  1764. var
  1765.   _RegQueryMultipleValuesA: Pointer;
  1767. function RegQueryMultipleValuesA;
  1768. begin
  1769.   GetProcedureAddress(_RegQueryMultipleValuesA, advapi32, 'RegQueryMultipleValuesA');
  1770.   asm
  1771.     mov esp, ebp
  1772.     pop ebp
  1773.     jmp [_RegQueryMultipleValuesA]
  1774.   end;
  1775. end;
  1776. {$ELSE}
  1777. function RegQueryMultipleValuesA; external advapi32 name 'RegQueryMultipleValuesA';
  1778. {$ENDIF DYNAMIC_LINK}
  1780. {$IFDEF DYNAMIC_LINK}
  1781. var
  1782.   _RegQueryMultipleValuesW: Pointer;
  1784. function RegQueryMultipleValuesW;
  1785. begin
  1786.   GetProcedureAddress(_RegQueryMultipleValuesW, advapi32, 'RegQueryMultipleValuesW');
  1787.   asm
  1788.     mov esp, ebp
  1789.     pop ebp
  1790.     jmp [_RegQueryMultipleValuesW]
  1791.   end;
  1792. end;
  1793. {$ELSE}
  1794. function RegQueryMultipleValuesW; external advapi32 name 'RegQueryMultipleValuesW';
  1795. {$ENDIF DYNAMIC_LINK}
  1796. {$IFDEF UNICODE}
  1798. {$IFDEF DYNAMIC_LINK}
  1799. var
  1800.   _RegQueryMultipleValues: Pointer;
  1802. function RegQueryMultipleValues;
  1803. begin
  1804.   GetProcedureAddress(_RegQueryMultipleValues, advapi32, 'RegQueryMultipleValuesW');
  1805.   asm
  1806.     mov esp, ebp
  1807.     pop ebp
  1808.     jmp [_RegQueryMultipleValues]
  1809.   end;
  1810. end;
  1811. {$ELSE}
  1812. function RegQueryMultipleValues; external advapi32 name 'RegQueryMultipleValuesW';
  1813. {$ENDIF DYNAMIC_LINK}
  1814. {$ELSE}
  1816. {$IFDEF DYNAMIC_LINK}
  1817. var
  1818.   _RegQueryMultipleValues: Pointer;
  1820. function RegQueryMultipleValues;
  1821. begin
  1822.   GetProcedureAddress(_RegQueryMultipleValues, advapi32, 'RegQueryMultipleValuesA');
  1823.   asm
  1824.     mov esp, ebp
  1825.     pop ebp
  1826.     jmp [_RegQueryMultipleValues]
  1827.   end;
  1828. end;
  1829. {$ELSE}
  1830. function RegQueryMultipleValues; external advapi32 name 'RegQueryMultipleValuesA';
  1831. {$ENDIF DYNAMIC_LINK}
  1832. {$ENDIF}
  1834. {$IFDEF DYNAMIC_LINK}
  1835. var
  1836.   _RegQueryValueExA: Pointer;
  1838. function RegQueryValueExA;
  1839. begin
  1840.   GetProcedureAddress(_RegQueryValueExA, advapi32, 'RegQueryValueExA');
  1841.   asm
  1842.     mov esp, ebp
  1843.     pop ebp
  1844.     jmp [_RegQueryValueExA]
  1845.   end;
  1846. end;
  1847. {$ELSE}
  1848. function RegQueryValueExA; external advapi32 name 'RegQueryValueExA';
  1849. {$ENDIF DYNAMIC_LINK}
  1851. {$IFDEF DYNAMIC_LINK}
  1852. var
  1853.   _RegQueryValueExW: Pointer;
  1855. function RegQueryValueExW;
  1856. begin
  1857.   GetProcedureAddress(_RegQueryValueExW, advapi32, 'RegQueryValueExW');
  1858.   asm
  1859.     mov esp, ebp
  1860.     pop ebp
  1861.     jmp [_RegQueryValueExW]
  1862.   end;
  1863. end;
  1864. {$ELSE}
  1865. function RegQueryValueExW; external advapi32 name 'RegQueryValueExW';
  1866. {$ENDIF DYNAMIC_LINK}
  1867. {$IFDEF UNICODE}
  1869. {$IFDEF DYNAMIC_LINK}
  1870. var
  1871.   _RegQueryValueEx: Pointer;
  1873. function RegQueryValueEx;
  1874. begin
  1875.   GetProcedureAddress(_RegQueryValueEx, advapi32, 'RegQueryValueExW');
  1876.   asm
  1877.     mov esp, ebp
  1878.     pop ebp
  1879.     jmp [_RegQueryValueEx]
  1880.   end;
  1881. end;
  1882. {$ELSE}
  1883. function RegQueryValueEx; external advapi32 name 'RegQueryValueExW';
  1884. {$ENDIF DYNAMIC_LINK}
  1885. {$ELSE}
  1887. {$IFDEF DYNAMIC_LINK}
  1888. var
  1889.   _RegQueryValueEx: Pointer;
  1891. function RegQueryValueEx;
  1892. begin
  1893.   GetProcedureAddress(_RegQueryValueEx, advapi32, 'RegQueryValueExA');
  1894.   asm
  1895.     mov esp, ebp
  1896.     pop ebp
  1897.     jmp [_RegQueryValueEx]
  1898.   end;
  1899. end;
  1900. {$ELSE}
  1901. function RegQueryValueEx; external advapi32 name 'RegQueryValueExA';
  1902. {$ENDIF DYNAMIC_LINK}
  1903. {$ENDIF}
  1905. {$IFDEF DYNAMIC_LINK}
  1906. var
  1907.   _RegReplaceKeyA: Pointer;
  1909. function RegReplaceKeyA;
  1910. begin
  1911.   GetProcedureAddress(_RegReplaceKeyA, advapi32, 'RegReplaceKeyA');
  1912.   asm
  1913.     mov esp, ebp
  1914.     pop ebp
  1915.     jmp [_RegReplaceKeyA]
  1916.   end;
  1917. end;
  1918. {$ELSE}
  1919. function RegReplaceKeyA; external advapi32 name 'RegReplaceKeyA';
  1920. {$ENDIF DYNAMIC_LINK}
  1922. {$IFDEF DYNAMIC_LINK}
  1923. var
  1924.   _RegReplaceKeyW: Pointer;
  1926. function RegReplaceKeyW;
  1927. begin
  1928.   GetProcedureAddress(_RegReplaceKeyW, advapi32, 'RegReplaceKeyW');
  1929.   asm
  1930.     mov esp, ebp
  1931.     pop ebp
  1932.     jmp [_RegReplaceKeyW]
  1933.   end;
  1934. end;
  1935. {$ELSE}
  1936. function RegReplaceKeyW; external advapi32 name 'RegReplaceKeyW';
  1937. {$ENDIF DYNAMIC_LINK}
  1938. {$IFDEF UNICODE}
  1940. {$IFDEF DYNAMIC_LINK}
  1941. var
  1942.   _RegReplaceKey: Pointer;
  1944. function RegReplaceKey;
  1945. begin
  1946.   GetProcedureAddress(_RegReplaceKey, advapi32, 'RegReplaceKeyW');
  1947.   asm
  1948.     mov esp, ebp
  1949.     pop ebp
  1950.     jmp [_RegReplaceKey]
  1951.   end;
  1952. end;
  1953. {$ELSE}
  1954. function RegReplaceKey; external advapi32 name 'RegReplaceKeyW';
  1955. {$ENDIF DYNAMIC_LINK}
  1956. {$ELSE}
  1958. {$IFDEF DYNAMIC_LINK}
  1959. var
  1960.   _RegReplaceKey: Pointer;
  1962. function RegReplaceKey;
  1963. begin
  1964.   GetProcedureAddress(_RegReplaceKey, advapi32, 'RegReplaceKeyA');
  1965.   asm
  1966.     mov esp, ebp
  1967.     pop ebp
  1968.     jmp [_RegReplaceKey]
  1969.   end;
  1970. end;
  1971. {$ELSE}
  1972. function RegReplaceKey; external advapi32 name 'RegReplaceKeyA';
  1973. {$ENDIF DYNAMIC_LINK}
  1974. {$ENDIF}
  1976. {$IFDEF DYNAMIC_LINK}
  1977. var
  1978.   _RegRestoreKeyA: Pointer;
  1980. function RegRestoreKeyA;
  1981. begin
  1982.   GetProcedureAddress(_RegRestoreKeyA, advapi32, 'RegRestoreKeyA');
  1983.   asm
  1984.     mov esp, ebp
  1985.     pop ebp
  1986.     jmp [_RegRestoreKeyA]
  1987.   end;
  1988. end;
  1989. {$ELSE}
  1990. function RegRestoreKeyA; external advapi32 name 'RegRestoreKeyA';
  1991. {$ENDIF DYNAMIC_LINK}
  1993. {$IFDEF DYNAMIC_LINK}
  1994. var
  1995.   _RegRestoreKeyW: Pointer;
  1997. function RegRestoreKeyW;
  1998. begin
  1999.   GetProcedureAddress(_RegRestoreKeyW, advapi32, 'RegRestoreKeyW');
  2000.   asm
  2001.     mov esp, ebp
  2002.     pop ebp
  2003.     jmp [_RegRestoreKeyW]
  2004.   end;
  2005. end;
  2006. {$ELSE}
  2007. function RegRestoreKeyW; external advapi32 name 'RegRestoreKeyW';
  2008. {$ENDIF DYNAMIC_LINK}
  2009. {$IFDEF UNICODE}
  2011. {$IFDEF DYNAMIC_LINK}
  2012. var
  2013.   _RegRestoreKey: Pointer;
  2015. function RegRestoreKey;
  2016. begin
  2017.   GetProcedureAddress(_RegRestoreKey, advapi32, 'RegRestoreKeyW');
  2018.   asm
  2019.     mov esp, ebp
  2020.     pop ebp
  2021.     jmp [_RegRestoreKey]
  2022.   end;
  2023. end;
  2024. {$ELSE}
  2025. function RegRestoreKey; external advapi32 name 'RegRestoreKeyW';
  2026. {$ENDIF DYNAMIC_LINK}
  2027. {$ELSE}
  2029. {$IFDEF DYNAMIC_LINK}
  2030. var
  2031.   _RegRestoreKey: Pointer;
  2033. function RegRestoreKey;
  2034. begin
  2035.   GetProcedureAddress(_RegRestoreKey, advapi32, 'RegRestoreKeyA');
  2036.   asm
  2037.     mov esp, ebp
  2038.     pop ebp
  2039.     jmp [_RegRestoreKey]
  2040.   end;
  2041. end;
  2042. {$ELSE}
  2043. function RegRestoreKey; external advapi32 name 'RegRestoreKeyA';
  2044. {$ENDIF DYNAMIC_LINK}
  2045. {$ENDIF}
  2047. {$IFDEF DYNAMIC_LINK}
  2048. var
  2049.   _RegSaveKeyA: Pointer;
  2051. function RegSaveKeyA;
  2052. begin
  2053.   GetProcedureAddress(_RegSaveKeyA, advapi32, 'RegSaveKeyA');
  2054.   asm
  2055.     mov esp, ebp
  2056.     pop ebp
  2057.     jmp [_RegSaveKeyA]
  2058.   end;
  2059. end;
  2060. {$ELSE}
  2061. function RegSaveKeyA; external advapi32 name 'RegSaveKeyA';
  2062. {$ENDIF DYNAMIC_LINK}
  2064. {$IFDEF DYNAMIC_LINK}
  2065. var
  2066.   _RegSaveKeyW: Pointer;
  2068. function RegSaveKeyW;
  2069. begin
  2070.   GetProcedureAddress(_RegSaveKeyW, advapi32, 'RegSaveKeyW');
  2071.   asm
  2072.     mov esp, ebp
  2073.     pop ebp
  2074.     jmp [_RegSaveKeyW]
  2075.   end;
  2076. end;
  2077. {$ELSE}
  2078. function RegSaveKeyW; external advapi32 name 'RegSaveKeyW';
  2079. {$ENDIF DYNAMIC_LINK}
  2080. {$IFDEF UNICODE}
  2082. {$IFDEF DYNAMIC_LINK}
  2083. var
  2084.   _RegSaveKey: Pointer;
  2086. function RegSaveKey;
  2087. begin
  2088.   GetProcedureAddress(_RegSaveKey, advapi32, 'RegSaveKeyW');
  2089.   asm
  2090.     mov esp, ebp
  2091.     pop ebp
  2092.     jmp [_RegSaveKey]
  2093.   end;
  2094. end;
  2095. {$ELSE}
  2096. function RegSaveKey; external advapi32 name 'RegSaveKeyW';
  2097. {$ENDIF DYNAMIC_LINK}
  2098. {$ELSE}
  2100. {$IFDEF DYNAMIC_LINK}
  2101. var
  2102.   _RegSaveKey: Pointer;
  2104. function RegSaveKey;
  2105. begin
  2106.   GetProcedureAddress(_RegSaveKey, advapi32, 'RegSaveKeyA');
  2107.   asm
  2108.     mov esp, ebp
  2109.     pop ebp
  2110.     jmp [_RegSaveKey]
  2111.   end;
  2112. end;
  2113. {$ELSE}
  2114. function RegSaveKey; external advapi32 name 'RegSaveKeyA';
  2115. {$ENDIF DYNAMIC_LINK}
  2116. {$ENDIF}
  2118. {$IFDEF DYNAMIC_LINK}
  2119. var
  2120.   _RegSetKeySecurity: Pointer;
  2122. function RegSetKeySecurity;
  2123. begin
  2124.   GetProcedureAddress(_RegSetKeySecurity, advapi32, 'RegSetKeySecurity');
  2125.   asm
  2126.     mov esp, ebp
  2127.     pop ebp
  2128.     jmp [_RegSetKeySecurity]
  2129.   end;
  2130. end;
  2131. {$ELSE}
  2132. function RegSetKeySecurity; external advapi32 name 'RegSetKeySecurity';
  2133. {$ENDIF DYNAMIC_LINK}
  2135. {$IFDEF DYNAMIC_LINK}
  2136. var
  2137.   _RegSetValueA: Pointer;
  2139. function RegSetValueA;
  2140. begin
  2141.   GetProcedureAddress(_RegSetValueA, advapi32, 'RegSetValueA');
  2142.   asm
  2143.     mov esp, ebp
  2144.     pop ebp
  2145.     jmp [_RegSetValueA]
  2146.   end;
  2147. end;
  2148. {$ELSE}
  2149. function RegSetValueA; external advapi32 name 'RegSetValueA';
  2150. {$ENDIF DYNAMIC_LINK}
  2152. {$IFDEF DYNAMIC_LINK}
  2153. var
  2154.   _RegSetValueW: Pointer;
  2156. function RegSetValueW;
  2157. begin
  2158.   GetProcedureAddress(_RegSetValueW, advapi32, 'RegSetValueW');
  2159.   asm
  2160.     mov esp, ebp
  2161.     pop ebp
  2162.     jmp [_RegSetValueW]
  2163.   end;
  2164. end;
  2165. {$ELSE}
  2166. function RegSetValueW; external advapi32 name 'RegSetValueW';
  2167. {$ENDIF DYNAMIC_LINK}
  2168. {$IFDEF UNICODE}
  2170. {$IFDEF DYNAMIC_LINK}
  2171. var
  2172.   _RegSetValue: Pointer;
  2174. function RegSetValue;
  2175. begin
  2176.   GetProcedureAddress(_RegSetValue, advapi32, 'RegSetValueW');
  2177.   asm
  2178.     mov esp, ebp
  2179.     pop ebp
  2180.     jmp [_RegSetValue]
  2181.   end;
  2182. end;
  2183. {$ELSE}
  2184. function RegSetValue; external advapi32 name 'RegSetValueW';
  2185. {$ENDIF DYNAMIC_LINK}
  2186. {$ELSE}
  2188. {$IFDEF DYNAMIC_LINK}
  2189. var
  2190.   _RegSetValue: Pointer;
  2192. function RegSetValue;
  2193. begin
  2194.   GetProcedureAddress(_RegSetValue, advapi32, 'RegSetValueA');
  2195.   asm
  2196.     mov esp, ebp
  2197.     pop ebp
  2198.     jmp [_RegSetValue]
  2199.   end;
  2200. end;
  2201. {$ELSE}
  2202. function RegSetValue; external advapi32 name 'RegSetValueA';
  2203. {$ENDIF DYNAMIC_LINK}
  2204. {$ENDIF}
  2206. {$IFDEF DYNAMIC_LINK}
  2207. var
  2208.   _RegSetValueExA: Pointer;
  2210. function RegSetValueExA;
  2211. begin
  2212.   GetProcedureAddress(_RegSetValueExA, advapi32, 'RegSetValueExA');
  2213.   asm
  2214.     mov esp, ebp
  2215.     pop ebp
  2216.     jmp [_RegSetValueExA]
  2217.   end;
  2218. end;
  2219. {$ELSE}
  2220. function RegSetValueExA; external advapi32 name 'RegSetValueExA';
  2221. {$ENDIF DYNAMIC_LINK}
  2223. {$IFDEF DYNAMIC_LINK}
  2224. var
  2225.   _RegSetValueExW: Pointer;
  2227. function RegSetValueExW;
  2228. begin
  2229.   GetProcedureAddress(_RegSetValueExW, advapi32, 'RegSetValueExW');
  2230.   asm
  2231.     mov esp, ebp
  2232.     pop ebp
  2233.     jmp [_RegSetValueExW]
  2234.   end;
  2235. end;
  2236. {$ELSE}
  2237. function RegSetValueExW; external advapi32 name 'RegSetValueExW';
  2238. {$ENDIF DYNAMIC_LINK}
  2239. {$IFDEF UNICODE}
  2241. {$IFDEF DYNAMIC_LINK}
  2242. var
  2243.   _RegSetValueEx: Pointer;
  2245. function RegSetValueEx;
  2246. begin
  2247.   GetProcedureAddress(_RegSetValueEx, advapi32, 'RegSetValueExW');
  2248.   asm
  2249.     mov esp, ebp
  2250.     pop ebp
  2251.     jmp [_RegSetValueEx]
  2252.   end;
  2253. end;
  2254. {$ELSE}
  2255. function RegSetValueEx; external advapi32 name 'RegSetValueExW';
  2256. {$ENDIF DYNAMIC_LINK}
  2257. {$ELSE}
  2259. {$IFDEF DYNAMIC_LINK}
  2260. var
  2261.   _RegSetValueEx: Pointer;
  2263. function RegSetValueEx;
  2264. begin
  2265.   GetProcedureAddress(_RegSetValueEx, advapi32, 'RegSetValueExA');
  2266.   asm
  2267.     mov esp, ebp
  2268.     pop ebp
  2269.     jmp [_RegSetValueEx]
  2270.   end;
  2271. end;
  2272. {$ELSE}
  2273. function RegSetValueEx; external advapi32 name 'RegSetValueExA';
  2274. {$ENDIF DYNAMIC_LINK}
  2275. {$ENDIF}
  2277. {$IFDEF DYNAMIC_LINK}
  2278. var
  2279.   _RegUnLoadKeyA: Pointer;
  2281. function RegUnLoadKeyA;
  2282. begin
  2283.   GetProcedureAddress(_RegUnLoadKeyA, advapi32, 'RegUnLoadKeyA');
  2284.   asm
  2285.     mov esp, ebp
  2286.     pop ebp
  2287.     jmp [_RegUnLoadKeyA]
  2288.   end;
  2289. end;
  2290. {$ELSE}
  2291. function RegUnLoadKeyA; external advapi32 name 'RegUnLoadKeyA';
  2292. {$ENDIF DYNAMIC_LINK}
  2294. {$IFDEF DYNAMIC_LINK}
  2295. var
  2296.   _RegUnLoadKeyW: Pointer;
  2298. function RegUnLoadKeyW;
  2299. begin
  2300.   GetProcedureAddress(_RegUnLoadKeyW, advapi32, 'RegUnLoadKeyW');
  2301.   asm
  2302.     mov esp, ebp
  2303.     pop ebp
  2304.     jmp [_RegUnLoadKeyW]
  2305.   end;
  2306. end;
  2307. {$ELSE}
  2308. function RegUnLoadKeyW; external advapi32 name 'RegUnLoadKeyW';
  2309. {$ENDIF DYNAMIC_LINK}
  2310. {$IFDEF UNICODE}
  2312. {$IFDEF DYNAMIC_LINK}
  2313. var
  2314.   _RegUnLoadKey: Pointer;
  2316. function RegUnLoadKey;
  2317. begin
  2318.   GetProcedureAddress(_RegUnLoadKey, advapi32, 'RegUnLoadKeyW');
  2319.   asm
  2320.     mov esp, ebp
  2321.     pop ebp
  2322.     jmp [_RegUnLoadKey]
  2323.   end;
  2324. end;
  2325. {$ELSE}
  2326. function RegUnLoadKey; external advapi32 name 'RegUnLoadKeyW';
  2327. {$ENDIF DYNAMIC_LINK}
  2328. {$ELSE}
  2330. {$IFDEF DYNAMIC_LINK}
  2331. var
  2332.   _RegUnLoadKey: Pointer;
  2334. function RegUnLoadKey;
  2335. begin
  2336.   GetProcedureAddress(_RegUnLoadKey, advapi32, 'RegUnLoadKeyA');
  2337.   asm
  2338.     mov esp, ebp
  2339.     pop ebp
  2340.     jmp [_RegUnLoadKey]
  2341.   end;
  2342. end;
  2343. {$ELSE}
  2344. function RegUnLoadKey; external advapi32 name 'RegUnLoadKeyA';
  2345. {$ENDIF DYNAMIC_LINK}
  2346. {$ENDIF}
  2348. {$IFDEF DYNAMIC_LINK}
  2349. var
  2350.   _InitiateSystemShutdownA: Pointer;
  2352. function InitiateSystemShutdownA;
  2353. begin
  2354.   GetProcedureAddress(_InitiateSystemShutdownA, advapi32, 'InitiateSystemShutdownA');
  2355.   asm
  2356.     mov esp, ebp
  2357.     pop ebp
  2358.     jmp [_InitiateSystemShutdownA]
  2359.   end;
  2360. end;
  2361. {$ELSE}
  2362. function InitiateSystemShutdownA; external advapi32 name 'InitiateSystemShutdownA';
  2363. {$ENDIF DYNAMIC_LINK}
  2365. {$IFDEF DYNAMIC_LINK}
  2366. var
  2367.   _InitiateSystemShutdownW: Pointer;
  2369. function InitiateSystemShutdownW;
  2370. begin
  2371.   GetProcedureAddress(_InitiateSystemShutdownW, advapi32, 'InitiateSystemShutdownW');
  2372.   asm
  2373.     mov esp, ebp
  2374.     pop ebp
  2375.     jmp [_InitiateSystemShutdownW]
  2376.   end;
  2377. end;
  2378. {$ELSE}
  2379. function InitiateSystemShutdownW; external advapi32 name 'InitiateSystemShutdownW';
  2380. {$ENDIF DYNAMIC_LINK}
  2381. {$IFDEF UNICODE}
  2383. {$IFDEF DYNAMIC_LINK}
  2384. var
  2385.   _InitiateSystemShutdown: Pointer;
  2387. function InitiateSystemShutdown;
  2388. begin
  2389.   GetProcedureAddress(_InitiateSystemShutdown, advapi32, 'InitiateSystemShutdownW');
  2390.   asm
  2391.     mov esp, ebp
  2392.     pop ebp
  2393.     jmp [_InitiateSystemShutdown]
  2394.   end;
  2395. end;
  2396. {$ELSE}
  2397. function InitiateSystemShutdown; external advapi32 name 'InitiateSystemShutdownW';
  2398. {$ENDIF DYNAMIC_LINK}
  2399. {$ELSE}
  2401. {$IFDEF DYNAMIC_LINK}
  2402. var
  2403.   _InitiateSystemShutdown: Pointer;
  2405. function InitiateSystemShutdown;
  2406. begin
  2407.   GetProcedureAddress(_InitiateSystemShutdown, advapi32, 'InitiateSystemShutdownA');
  2408.   asm
  2409.     mov esp, ebp
  2410.     pop ebp
  2411.     jmp [_InitiateSystemShutdown]
  2412.   end;
  2413. end;
  2414. {$ELSE}
  2415. function InitiateSystemShutdown; external advapi32 name 'InitiateSystemShutdownA';
  2416. {$ENDIF DYNAMIC_LINK}
  2417. {$ENDIF}
  2419. {$IFDEF DYNAMIC_LINK}
  2420. var
  2421.   _AbortSystemShutdownA: Pointer;
  2423. function AbortSystemShutdownA;
  2424. begin
  2425.   GetProcedureAddress(_AbortSystemShutdownA, advapi32, 'AbortSystemShutdownA');
  2426.   asm
  2427.     mov esp, ebp
  2428.     pop ebp
  2429.     jmp [_AbortSystemShutdownA]
  2430.   end;
  2431. end;
  2432. {$ELSE}
  2433. function AbortSystemShutdownA; external advapi32 name 'AbortSystemShutdownA';
  2434. {$ENDIF DYNAMIC_LINK}
  2436. {$IFDEF DYNAMIC_LINK}
  2437. var
  2438.   _AbortSystemShutdownW: Pointer;
  2440. function AbortSystemShutdownW;
  2441. begin
  2442.   GetProcedureAddress(_AbortSystemShutdownW, advapi32, 'AbortSystemShutdownW');
  2443.   asm
  2444.     mov esp, ebp
  2445.     pop ebp
  2446.     jmp [_AbortSystemShutdownW]
  2447.   end;
  2448. end;
  2449. {$ELSE}
  2450. function AbortSystemShutdownW; external advapi32 name 'AbortSystemShutdownW';
  2451. {$ENDIF DYNAMIC_LINK}
  2452. {$IFDEF UNICODE}
  2454. {$IFDEF DYNAMIC_LINK}
  2455. var
  2456.   _AbortSystemShutdown: Pointer;
  2458. function AbortSystemShutdown;
  2459. begin
  2460.   GetProcedureAddress(_AbortSystemShutdown, advapi32, 'AbortSystemShutdownW');
  2461.   asm
  2462.     mov esp, ebp
  2463.     pop ebp
  2464.     jmp [_AbortSystemShutdown]
  2465.   end;
  2466. end;
  2467. {$ELSE}
  2468. function AbortSystemShutdown; external advapi32 name 'AbortSystemShutdownW';
  2469. {$ENDIF DYNAMIC_LINK}
  2470. {$ELSE}
  2472. {$IFDEF DYNAMIC_LINK}
  2473. var
  2474.   _AbortSystemShutdown: Pointer;
  2476. function AbortSystemShutdown;
  2477. begin
  2478.   GetProcedureAddress(_AbortSystemShutdown, advapi32, 'AbortSystemShutdownA');
  2479.   asm
  2480.     mov esp, ebp
  2481.     pop ebp
  2482.     jmp [_AbortSystemShutdown]
  2483.   end;
  2484. end;
  2485. {$ELSE}
  2486. function AbortSystemShutdown; external advapi32 name 'AbortSystemShutdownA';
  2487. {$ENDIF DYNAMIC_LINK}
  2488. {$ENDIF}
  2490. {$IFDEF DYNAMIC_LINK}
  2491. var
  2492.   _InitiateSystemShutdownExA: Pointer;
  2494. function InitiateSystemShutdownExA;
  2495. begin
  2496.   GetProcedureAddress(_InitiateSystemShutdownExA, advapi32, 'InitiateSystemShutdownExA');
  2497.   asm
  2498.     mov esp, ebp
  2499.     pop ebp
  2500.     jmp [_InitiateSystemShutdownExA]
  2501.   end;
  2502. end;
  2503. {$ELSE}
  2504. function InitiateSystemShutdownExA; external advapi32 name 'InitiateSystemShutdownExA';
  2505. {$ENDIF DYNAMIC_LINK}
  2507. {$IFDEF DYNAMIC_LINK}
  2508. var
  2509.   _InitiateSystemShutdownExW: Pointer;
  2511. function InitiateSystemShutdownExW;
  2512. begin
  2513.   GetProcedureAddress(_InitiateSystemShutdownExW, advapi32, 'InitiateSystemShutdownExW');
  2514.   asm
  2515.     mov esp, ebp
  2516.     pop ebp
  2517.     jmp [_InitiateSystemShutdownExW]
  2518.   end;
  2519. end;
  2520. {$ELSE}
  2521. function InitiateSystemShutdownExW; external advapi32 name 'InitiateSystemShutdownExW';
  2522. {$ENDIF DYNAMIC_LINK}
  2523. {$IFDEF UNICODE}
  2525. {$IFDEF DYNAMIC_LINK}
  2526. var
  2527.   _InitiateSystemShutdownEx: Pointer;
  2529. function InitiateSystemShutdownEx;
  2530. begin
  2531.   GetProcedureAddress(_InitiateSystemShutdownEx, advapi32, 'InitiateSystemShutdownExW');
  2532.   asm
  2533.     mov esp, ebp
  2534.     pop ebp
  2535.     jmp [_InitiateSystemShutdownEx]
  2536.   end;
  2537. end;
  2538. {$ELSE}
  2539. function InitiateSystemShutdownEx; external advapi32 name 'InitiateSystemShutdownExW';
  2540. {$ENDIF DYNAMIC_LINK}
  2541. {$ELSE}
  2543. {$IFDEF DYNAMIC_LINK}
  2544. var
  2545.   _InitiateSystemShutdownEx: Pointer;
  2547. function InitiateSystemShutdownEx;
  2548. begin
  2549.   GetProcedureAddress(_InitiateSystemShutdownEx, advapi32, 'InitiateSystemShutdownExA');
  2550.   asm
  2551.     mov esp, ebp
  2552.     pop ebp
  2553.     jmp [_InitiateSystemShutdownEx]
  2554.   end;
  2555. end;
  2556. {$ELSE}
  2557. function InitiateSystemShutdownEx; external advapi32 name 'InitiateSystemShutdownExA';
  2558. {$ENDIF DYNAMIC_LINK}
  2559. {$ENDIF}
  2561. {$IFDEF DYNAMIC_LINK}
  2562. var
  2563.   _RegSaveKeyExA: Pointer;
  2565. function RegSaveKeyExA;
  2566. begin
  2567.   GetProcedureAddress(_RegSaveKeyExA, advapi32, 'RegSaveKeyExA');
  2568.   asm
  2569.     mov esp, ebp
  2570.     pop ebp
  2571.     jmp [_RegSaveKeyExA]
  2572.   end;
  2573. end;
  2574. {$ELSE}
  2575. function RegSaveKeyExA; external advapi32 name 'RegSaveKeyExA';
  2576. {$ENDIF DYNAMIC_LINK}
  2578. {$IFDEF DYNAMIC_LINK}
  2579. var
  2580.   _RegSaveKeyExW: Pointer;
  2582. function RegSaveKeyExW;
  2583. begin
  2584.   GetProcedureAddress(_RegSaveKeyExW, advapi32, 'RegSaveKeyExW');
  2585.   asm
  2586.     mov esp, ebp
  2587.     pop ebp
  2588.     jmp [_RegSaveKeyExW]
  2589.   end;
  2590. end;
  2591. {$ELSE}
  2592. function RegSaveKeyExW; external advapi32 name 'RegSaveKeyExW';
  2593. {$ENDIF DYNAMIC_LINK}
  2594. {$IFDEF UNICODE}
  2596. {$IFDEF DYNAMIC_LINK}
  2597. var
  2598.   _RegSaveKeyEx: Pointer;
  2600. function RegSaveKeyEx;
  2601. begin
  2602.   GetProcedureAddress(_RegSaveKeyEx, advapi32, 'RegSaveKeyExW');
  2603.   asm
  2604.     mov esp, ebp
  2605.     pop ebp
  2606.     jmp [_RegSaveKeyEx]
  2607.   end;
  2608. end;
  2609. {$ELSE}
  2610. function RegSaveKeyEx; external advapi32 name 'RegSaveKeyExW';
  2611. {$ENDIF DYNAMIC_LINK}
  2612. {$ELSE}
  2614. {$IFDEF DYNAMIC_LINK}
  2615. var
  2616.   _RegSaveKeyEx: Pointer;
  2618. function RegSaveKeyEx;
  2619. begin
  2620.   GetProcedureAddress(_RegSaveKeyEx, advapi32, 'RegSaveKeyExA');
  2621.   asm
  2622.     mov esp, ebp
  2623.     pop ebp
  2624.     jmp [_RegSaveKeyEx]
  2625.   end;
  2626. end;
  2627. {$ELSE}
  2628. function RegSaveKeyEx; external advapi32 name 'RegSaveKeyExA';
  2629. {$ENDIF DYNAMIC_LINK}
  2630. {$ENDIF}
  2632. {$IFDEF DYNAMIC_LINK}
  2633. var
  2634.   _Wow64Win32ApiEntry: Pointer;
  2636. function Wow64Win32ApiEntry;
  2637. begin
  2638.   GetProcedureAddress(_Wow64Win32ApiEntry, advapi32, 'Wow64Win32ApiEntry');
  2639.   asm
  2640.     mov esp, ebp
  2641.     pop ebp
  2642.     jmp [_Wow64Win32ApiEntry]
  2643.   end;
  2644. end;
  2645. {$ELSE}
  2646. function Wow64Win32ApiEntry; external advapi32 name 'Wow64Win32ApiEntry';
  2647. {$ENDIF DYNAMIC_LINK}
  2649. end.