JwaMsi.pas
上传用户:davidchvip
上传日期:2009-07-28
资源大小:1749k
文件大小:161k
源码类别:

Windows编程

开发平台:

Delphi

  1. begin
  2.   GetProcedureAddress(_MsiGetUserInfoW, msilib, 'MsiGetUserInfoW');
  3.   asm
  4.     mov esp, ebp
  5.     pop ebp
  6.     jmp [_MsiGetUserInfoW]
  7.   end;
  8. end;
  9. {$ELSE}
  10. function MsiGetUserInfoW; external msilib name 'MsiGetUserInfoW';
  11. {$ENDIF DYNAMIC_LINK}
  12. {$IFDEF UNICODE}
  13. {$IFDEF DYNAMIC_LINK}
  14. var
  15.   _MsiGetUserInfo: Pointer;
  16. function MsiGetUserInfo;
  17. begin
  18.   GetProcedureAddress(_MsiGetUserInfo, msilib, 'MsiGetUserInfoW');
  19.   asm
  20.     mov esp, ebp
  21.     pop ebp
  22.     jmp [_MsiGetUserInfo]
  23.   end;
  24. end;
  25. {$ELSE}
  26. function MsiGetUserInfo; external msilib name 'MsiGetUserInfoW';
  27. {$ENDIF DYNAMIC_LINK}
  28. {$ELSE}
  29. {$IFDEF DYNAMIC_LINK}
  30. var
  31.   _MsiGetUserInfo: Pointer;
  32. function MsiGetUserInfo;
  33. begin
  34.   GetProcedureAddress(_MsiGetUserInfo, msilib, 'MsiGetUserInfoA');
  35.   asm
  36.     mov esp, ebp
  37.     pop ebp
  38.     jmp [_MsiGetUserInfo]
  39.   end;
  40. end;
  41. {$ELSE}
  42. function MsiGetUserInfo; external msilib name 'MsiGetUserInfoA';
  43. {$ENDIF DYNAMIC_LINK}
  44. {$ENDIF}
  45. {$IFDEF DYNAMIC_LINK}
  46. var
  47.   _MsiCollectUserInfoA: Pointer;
  48. function MsiCollectUserInfoA;
  49. begin
  50.   GetProcedureAddress(_MsiCollectUserInfoA, msilib, 'MsiCollectUserInfoA');
  51.   asm
  52.     mov esp, ebp
  53.     pop ebp
  54.     jmp [_MsiCollectUserInfoA]
  55.   end;
  56. end;
  57. {$ELSE}
  58. function MsiCollectUserInfoA; external msilib name 'MsiCollectUserInfoA';
  59. {$ENDIF DYNAMIC_LINK}
  60. {$IFDEF DYNAMIC_LINK}
  61. var
  62.   _MsiCollectUserInfoW: Pointer;
  63. function MsiCollectUserInfoW;
  64. begin
  65.   GetProcedureAddress(_MsiCollectUserInfoW, msilib, 'MsiCollectUserInfoW');
  66.   asm
  67.     mov esp, ebp
  68.     pop ebp
  69.     jmp [_MsiCollectUserInfoW]
  70.   end;
  71. end;
  72. {$ELSE}
  73. function MsiCollectUserInfoW; external msilib name 'MsiCollectUserInfoW';
  74. {$ENDIF DYNAMIC_LINK}
  75. {$IFDEF UNICODE}
  76. {$IFDEF DYNAMIC_LINK}
  77. var
  78.   _MsiCollectUserInfo: Pointer;
  79. function MsiCollectUserInfo;
  80. begin
  81.   GetProcedureAddress(_MsiCollectUserInfo, msilib, 'MsiCollectUserInfoW');
  82.   asm
  83.     mov esp, ebp
  84.     pop ebp
  85.     jmp [_MsiCollectUserInfo]
  86.   end;
  87. end;
  88. {$ELSE}
  89. function MsiCollectUserInfo; external msilib name 'MsiCollectUserInfoW';
  90. {$ENDIF DYNAMIC_LINK}
  91. {$ELSE}
  92. {$IFDEF DYNAMIC_LINK}
  93. var
  94.   _MsiCollectUserInfo: Pointer;
  95. function MsiCollectUserInfo;
  96. begin
  97.   GetProcedureAddress(_MsiCollectUserInfo, msilib, 'MsiCollectUserInfoA');
  98.   asm
  99.     mov esp, ebp
  100.     pop ebp
  101.     jmp [_MsiCollectUserInfo]
  102.   end;
  103. end;
  104. {$ELSE}
  105. function MsiCollectUserInfo; external msilib name 'MsiCollectUserInfoA';
  106. {$ENDIF DYNAMIC_LINK}
  107. {$ENDIF}
  108. {$IFDEF DYNAMIC_LINK}
  109. var
  110.   _MsiApplyPatchA: Pointer;
  111. function MsiApplyPatchA;
  112. begin
  113.   GetProcedureAddress(_MsiApplyPatchA, msilib, 'MsiApplyPatchA');
  114.   asm
  115.     mov esp, ebp
  116.     pop ebp
  117.     jmp [_MsiApplyPatchA]
  118.   end;
  119. end;
  120. {$ELSE}
  121. function MsiApplyPatchA; external msilib name 'MsiApplyPatchA';
  122. {$ENDIF DYNAMIC_LINK}
  123. {$IFDEF DYNAMIC_LINK}
  124. var
  125.   _MsiApplyPatchW: Pointer;
  126. function MsiApplyPatchW;
  127. begin
  128.   GetProcedureAddress(_MsiApplyPatchW, msilib, 'MsiApplyPatchW');
  129.   asm
  130.     mov esp, ebp
  131.     pop ebp
  132.     jmp [_MsiApplyPatchW]
  133.   end;
  134. end;
  135. {$ELSE}
  136. function MsiApplyPatchW; external msilib name 'MsiApplyPatchW';
  137. {$ENDIF DYNAMIC_LINK}
  138. {$IFDEF UNICODE}
  139. {$IFDEF DYNAMIC_LINK}
  140. var
  141.   _MsiApplyPatch: Pointer;
  142. function MsiApplyPatch;
  143. begin
  144.   GetProcedureAddress(_MsiApplyPatch, msilib, 'MsiApplyPatchW');
  145.   asm
  146.     mov esp, ebp
  147.     pop ebp
  148.     jmp [_MsiApplyPatch]
  149.   end;
  150. end;
  151. {$ELSE}
  152. function MsiApplyPatch; external msilib name 'MsiApplyPatchW';
  153. {$ENDIF DYNAMIC_LINK}
  154. {$ELSE}
  155. {$IFDEF DYNAMIC_LINK}
  156. var
  157.   _MsiApplyPatch: Pointer;
  158. function MsiApplyPatch;
  159. begin
  160.   GetProcedureAddress(_MsiApplyPatch, msilib, 'MsiApplyPatchA');
  161.   asm
  162.     mov esp, ebp
  163.     pop ebp
  164.     jmp [_MsiApplyPatch]
  165.   end;
  166. end;
  167. {$ELSE}
  168. function MsiApplyPatch; external msilib name 'MsiApplyPatchA';
  169. {$ENDIF DYNAMIC_LINK}
  170. {$ENDIF}
  171. {$IFDEF DYNAMIC_LINK}
  172. var
  173.   _MsiGetPatchInfoA: Pointer;
  174. function MsiGetPatchInfoA;
  175. begin
  176.   GetProcedureAddress(_MsiGetPatchInfoA, msilib, 'MsiGetPatchInfoA');
  177.   asm
  178.     mov esp, ebp
  179.     pop ebp
  180.     jmp [_MsiGetPatchInfoA]
  181.   end;
  182. end;
  183. {$ELSE}
  184. function MsiGetPatchInfoA; external msilib name 'MsiGetPatchInfoA';
  185. {$ENDIF DYNAMIC_LINK}
  186. {$IFDEF DYNAMIC_LINK}
  187. var
  188.   _MsiGetPatchInfoW: Pointer;
  189. function MsiGetPatchInfoW;
  190. begin
  191.   GetProcedureAddress(_MsiGetPatchInfoW, msilib, 'MsiGetPatchInfoW');
  192.   asm
  193.     mov esp, ebp
  194.     pop ebp
  195.     jmp [_MsiGetPatchInfoW]
  196.   end;
  197. end;
  198. {$ELSE}
  199. function MsiGetPatchInfoW; external msilib name 'MsiGetPatchInfoW';
  200. {$ENDIF DYNAMIC_LINK}
  201. {$IFDEF UNICODE}
  202. {$IFDEF DYNAMIC_LINK}
  203. var
  204.   _MsiGetPatchInfo: Pointer;
  205. function MsiGetPatchInfo;
  206. begin
  207.   GetProcedureAddress(_MsiGetPatchInfo, msilib, 'MsiGetPatchInfoW');
  208.   asm
  209.     mov esp, ebp
  210.     pop ebp
  211.     jmp [_MsiGetPatchInfo]
  212.   end;
  213. end;
  214. {$ELSE}
  215. function MsiGetPatchInfo; external msilib name 'MsiGetPatchInfoW';
  216. {$ENDIF DYNAMIC_LINK}
  217. {$ELSE}
  218. {$IFDEF DYNAMIC_LINK}
  219. var
  220.   _MsiGetPatchInfo: Pointer;
  221. function MsiGetPatchInfo;
  222. begin
  223.   GetProcedureAddress(_MsiGetPatchInfo, msilib, 'MsiGetPatchInfoA');
  224.   asm
  225.     mov esp, ebp
  226.     pop ebp
  227.     jmp [_MsiGetPatchInfo]
  228.   end;
  229. end;
  230. {$ELSE}
  231. function MsiGetPatchInfo; external msilib name 'MsiGetPatchInfoA';
  232. {$ENDIF DYNAMIC_LINK}
  233. {$ENDIF}
  234. {$IFDEF DYNAMIC_LINK}
  235. var
  236.   _MsiEnumPatchesA: Pointer;
  237. function MsiEnumPatchesA;
  238. begin
  239.   GetProcedureAddress(_MsiEnumPatchesA, msilib, 'MsiEnumPatchesA');
  240.   asm
  241.     mov esp, ebp
  242.     pop ebp
  243.     jmp [_MsiEnumPatchesA]
  244.   end;
  245. end;
  246. {$ELSE}
  247. function MsiEnumPatchesA; external msilib name 'MsiEnumPatchesA';
  248. {$ENDIF DYNAMIC_LINK}
  249. {$IFDEF DYNAMIC_LINK}
  250. var
  251.   _MsiEnumPatchesW: Pointer;
  252. function MsiEnumPatchesW;
  253. begin
  254.   GetProcedureAddress(_MsiEnumPatchesW, msilib, 'MsiEnumPatchesW');
  255.   asm
  256.     mov esp, ebp
  257.     pop ebp
  258.     jmp [_MsiEnumPatchesW]
  259.   end;
  260. end;
  261. {$ELSE}
  262. function MsiEnumPatchesW; external msilib name 'MsiEnumPatchesW';
  263. {$ENDIF DYNAMIC_LINK}
  264. {$IFDEF UNICODE}
  265. {$IFDEF DYNAMIC_LINK}
  266. var
  267.   _MsiEnumPatches: Pointer;
  268. function MsiEnumPatches;
  269. begin
  270.   GetProcedureAddress(_MsiEnumPatches, msilib, 'MsiEnumPatchesW');
  271.   asm
  272.     mov esp, ebp
  273.     pop ebp
  274.     jmp [_MsiEnumPatches]
  275.   end;
  276. end;
  277. {$ELSE}
  278. function MsiEnumPatches; external msilib name 'MsiEnumPatchesW';
  279. {$ENDIF DYNAMIC_LINK}
  280. {$ELSE}
  281. {$IFDEF DYNAMIC_LINK}
  282. var
  283.   _MsiEnumPatches: Pointer;
  284. function MsiEnumPatches;
  285. begin
  286.   GetProcedureAddress(_MsiEnumPatches, msilib, 'MsiEnumPatchesA');
  287.   asm
  288.     mov esp, ebp
  289.     pop ebp
  290.     jmp [_MsiEnumPatches]
  291.   end;
  292. end;
  293. {$ELSE}
  294. function MsiEnumPatches; external msilib name 'MsiEnumPatchesA';
  295. {$ENDIF DYNAMIC_LINK}
  296. {$ENDIF}
  297. {$IFDEF DYNAMIC_LINK}
  298. var
  299.   _MsiQueryFeatureStateA: Pointer;
  300. function MsiQueryFeatureStateA;
  301. begin
  302.   GetProcedureAddress(_MsiQueryFeatureStateA, msilib, 'MsiQueryFeatureStateA');
  303.   asm
  304.     mov esp, ebp
  305.     pop ebp
  306.     jmp [_MsiQueryFeatureStateA]
  307.   end;
  308. end;
  309. {$ELSE}
  310. function MsiQueryFeatureStateA; external msilib name 'MsiQueryFeatureStateA';
  311. {$ENDIF DYNAMIC_LINK}
  312. {$IFDEF DYNAMIC_LINK}
  313. var
  314.   _MsiQueryFeatureStateW: Pointer;
  315. function MsiQueryFeatureStateW;
  316. begin
  317.   GetProcedureAddress(_MsiQueryFeatureStateW, msilib, 'MsiQueryFeatureStateW');
  318.   asm
  319.     mov esp, ebp
  320.     pop ebp
  321.     jmp [_MsiQueryFeatureStateW]
  322.   end;
  323. end;
  324. {$ELSE}
  325. function MsiQueryFeatureStateW; external msilib name 'MsiQueryFeatureStateW';
  326. {$ENDIF DYNAMIC_LINK}
  327. {$IFDEF UNICODE}
  328. {$IFDEF DYNAMIC_LINK}
  329. var
  330.   _MsiQueryFeatureState: Pointer;
  331. function MsiQueryFeatureState;
  332. begin
  333.   GetProcedureAddress(_MsiQueryFeatureState, msilib, 'MsiQueryFeatureStateW');
  334.   asm
  335.     mov esp, ebp
  336.     pop ebp
  337.     jmp [_MsiQueryFeatureState]
  338.   end;
  339. end;
  340. {$ELSE}
  341. function MsiQueryFeatureState; external msilib name 'MsiQueryFeatureStateW';
  342. {$ENDIF DYNAMIC_LINK}
  343. {$ELSE}
  344. {$IFDEF DYNAMIC_LINK}
  345. var
  346.   _MsiQueryFeatureState: Pointer;
  347. function MsiQueryFeatureState;
  348. begin
  349.   GetProcedureAddress(_MsiQueryFeatureState, msilib, 'MsiQueryFeatureStateA');
  350.   asm
  351.     mov esp, ebp
  352.     pop ebp
  353.     jmp [_MsiQueryFeatureState]
  354.   end;
  355. end;
  356. {$ELSE}
  357. function MsiQueryFeatureState; external msilib name 'MsiQueryFeatureStateA';
  358. {$ENDIF DYNAMIC_LINK}
  359. {$ENDIF}
  360. {$IFDEF DYNAMIC_LINK}
  361. var
  362.   _MsiUseFeatureA: Pointer;
  363. function MsiUseFeatureA;
  364. begin
  365.   GetProcedureAddress(_MsiUseFeatureA, msilib, 'MsiUseFeatureA');
  366.   asm
  367.     mov esp, ebp
  368.     pop ebp
  369.     jmp [_MsiUseFeatureA]
  370.   end;
  371. end;
  372. {$ELSE}
  373. function MsiUseFeatureA; external msilib name 'MsiUseFeatureA';
  374. {$ENDIF DYNAMIC_LINK}
  375. {$IFDEF DYNAMIC_LINK}
  376. var
  377.   _MsiUseFeatureW: Pointer;
  378. function MsiUseFeatureW;
  379. begin
  380.   GetProcedureAddress(_MsiUseFeatureW, msilib, 'MsiUseFeatureW');
  381.   asm
  382.     mov esp, ebp
  383.     pop ebp
  384.     jmp [_MsiUseFeatureW]
  385.   end;
  386. end;
  387. {$ELSE}
  388. function MsiUseFeatureW; external msilib name 'MsiUseFeatureW';
  389. {$ENDIF DYNAMIC_LINK}
  390. {$IFDEF UNICODE}
  391. {$IFDEF DYNAMIC_LINK}
  392. var
  393.   _MsiUseFeature: Pointer;
  394. function MsiUseFeature;
  395. begin
  396.   GetProcedureAddress(_MsiUseFeature, msilib, 'MsiUseFeatureW');
  397.   asm
  398.     mov esp, ebp
  399.     pop ebp
  400.     jmp [_MsiUseFeature]
  401.   end;
  402. end;
  403. {$ELSE}
  404. function MsiUseFeature; external msilib name 'MsiUseFeatureW';
  405. {$ENDIF DYNAMIC_LINK}
  406. {$ELSE}
  407. {$IFDEF DYNAMIC_LINK}
  408. var
  409.   _MsiUseFeature: Pointer;
  410. function MsiUseFeature;
  411. begin
  412.   GetProcedureAddress(_MsiUseFeature, msilib, 'MsiUseFeatureA');
  413.   asm
  414.     mov esp, ebp
  415.     pop ebp
  416.     jmp [_MsiUseFeature]
  417.   end;
  418. end;
  419. {$ELSE}
  420. function MsiUseFeature; external msilib name 'MsiUseFeatureA';
  421. {$ENDIF DYNAMIC_LINK}
  422. {$ENDIF}
  423. {$IFDEF DYNAMIC_LINK}
  424. var
  425.   _MsiUseFeatureExA: Pointer;
  426. function MsiUseFeatureExA;
  427. begin
  428.   GetProcedureAddress(_MsiUseFeatureExA, msilib, 'MsiUseFeatureExA');
  429.   asm
  430.     mov esp, ebp
  431.     pop ebp
  432.     jmp [_MsiUseFeatureExA]
  433.   end;
  434. end;
  435. {$ELSE}
  436. function MsiUseFeatureExA; external msilib name 'MsiUseFeatureExA';
  437. {$ENDIF DYNAMIC_LINK}
  438. {$IFDEF DYNAMIC_LINK}
  439. var
  440.   _MsiUseFeatureExW: Pointer;
  441. function MsiUseFeatureExW;
  442. begin
  443.   GetProcedureAddress(_MsiUseFeatureExW, msilib, 'MsiUseFeatureExW');
  444.   asm
  445.     mov esp, ebp
  446.     pop ebp
  447.     jmp [_MsiUseFeatureExW]
  448.   end;
  449. end;
  450. {$ELSE}
  451. function MsiUseFeatureExW; external msilib name 'MsiUseFeatureExW';
  452. {$ENDIF DYNAMIC_LINK}
  453. {$IFDEF UNICODE}
  454. {$IFDEF DYNAMIC_LINK}
  455. var
  456.   _MsiUseFeatureEx: Pointer;
  457. function MsiUseFeatureEx;
  458. begin
  459.   GetProcedureAddress(_MsiUseFeatureEx, msilib, 'MsiUseFeatureExW');
  460.   asm
  461.     mov esp, ebp
  462.     pop ebp
  463.     jmp [_MsiUseFeatureEx]
  464.   end;
  465. end;
  466. {$ELSE}
  467. function MsiUseFeatureEx; external msilib name 'MsiUseFeatureExW';
  468. {$ENDIF DYNAMIC_LINK}
  469. {$ELSE}
  470. {$IFDEF DYNAMIC_LINK}
  471. var
  472.   _MsiUseFeatureEx: Pointer;
  473. function MsiUseFeatureEx;
  474. begin
  475.   GetProcedureAddress(_MsiUseFeatureEx, msilib, 'MsiUseFeatureExA');
  476.   asm
  477.     mov esp, ebp
  478.     pop ebp
  479.     jmp [_MsiUseFeatureEx]
  480.   end;
  481. end;
  482. {$ELSE}
  483. function MsiUseFeatureEx; external msilib name 'MsiUseFeatureExA';
  484. {$ENDIF DYNAMIC_LINK}
  485. {$ENDIF}
  486. {$IFDEF DYNAMIC_LINK}
  487. var
  488.   _MsiGetFeatureUsageA: Pointer;
  489. function MsiGetFeatureUsageA;
  490. begin
  491.   GetProcedureAddress(_MsiGetFeatureUsageA, msilib, 'MsiGetFeatureUsageA');
  492.   asm
  493.     mov esp, ebp
  494.     pop ebp
  495.     jmp [_MsiGetFeatureUsageA]
  496.   end;
  497. end;
  498. {$ELSE}
  499. function MsiGetFeatureUsageA; external msilib name 'MsiGetFeatureUsageA';
  500. {$ENDIF DYNAMIC_LINK}
  501. {$IFDEF DYNAMIC_LINK}
  502. var
  503.   _MsiGetFeatureUsageW: Pointer;
  504. function MsiGetFeatureUsageW;
  505. begin
  506.   GetProcedureAddress(_MsiGetFeatureUsageW, msilib, 'MsiGetFeatureUsageW');
  507.   asm
  508.     mov esp, ebp
  509.     pop ebp
  510.     jmp [_MsiGetFeatureUsageW]
  511.   end;
  512. end;
  513. {$ELSE}
  514. function MsiGetFeatureUsageW; external msilib name 'MsiGetFeatureUsageW';
  515. {$ENDIF DYNAMIC_LINK}
  516. {$IFDEF UNICODE}
  517. {$IFDEF DYNAMIC_LINK}
  518. var
  519.   _MsiGetFeatureUsage: Pointer;
  520. function MsiGetFeatureUsage;
  521. begin
  522.   GetProcedureAddress(_MsiGetFeatureUsage, msilib, 'MsiGetFeatureUsageW');
  523.   asm
  524.     mov esp, ebp
  525.     pop ebp
  526.     jmp [_MsiGetFeatureUsage]
  527.   end;
  528. end;
  529. {$ELSE}
  530. function MsiGetFeatureUsage; external msilib name 'MsiGetFeatureUsageW';
  531. {$ENDIF DYNAMIC_LINK}
  532. {$ELSE}
  533. {$IFDEF DYNAMIC_LINK}
  534. var
  535.   _MsiGetFeatureUsage: Pointer;
  536. function MsiGetFeatureUsage;
  537. begin
  538.   GetProcedureAddress(_MsiGetFeatureUsage, msilib, 'MsiGetFeatureUsageA');
  539.   asm
  540.     mov esp, ebp
  541.     pop ebp
  542.     jmp [_MsiGetFeatureUsage]
  543.   end;
  544. end;
  545. {$ELSE}
  546. function MsiGetFeatureUsage; external msilib name 'MsiGetFeatureUsageA';
  547. {$ENDIF DYNAMIC_LINK}
  548. {$ENDIF}
  549. {$IFDEF DYNAMIC_LINK}
  550. var
  551.   _MsiConfigureFeatureA: Pointer;
  552. function MsiConfigureFeatureA;
  553. begin
  554.   GetProcedureAddress(_MsiConfigureFeatureA, msilib, 'MsiConfigureFeatureA');
  555.   asm
  556.     mov esp, ebp
  557.     pop ebp
  558.     jmp [_MsiConfigureFeatureA]
  559.   end;
  560. end;
  561. {$ELSE}
  562. function MsiConfigureFeatureA; external msilib name 'MsiConfigureFeatureA';
  563. {$ENDIF DYNAMIC_LINK}
  564. {$IFDEF DYNAMIC_LINK}
  565. var
  566.   _MsiConfigureFeatureW: Pointer;
  567. function MsiConfigureFeatureW;
  568. begin
  569.   GetProcedureAddress(_MsiConfigureFeatureW, msilib, 'MsiConfigureFeatureW');
  570.   asm
  571.     mov esp, ebp
  572.     pop ebp
  573.     jmp [_MsiConfigureFeatureW]
  574.   end;
  575. end;
  576. {$ELSE}
  577. function MsiConfigureFeatureW; external msilib name 'MsiConfigureFeatureW';
  578. {$ENDIF DYNAMIC_LINK}
  579. {$IFDEF UNICODE}
  580. {$IFDEF DYNAMIC_LINK}
  581. var
  582.   _MsiConfigureFeature: Pointer;
  583. function MsiConfigureFeature;
  584. begin
  585.   GetProcedureAddress(_MsiConfigureFeature, msilib, 'MsiConfigureFeatureW');
  586.   asm
  587.     mov esp, ebp
  588.     pop ebp
  589.     jmp [_MsiConfigureFeature]
  590.   end;
  591. end;
  592. {$ELSE}
  593. function MsiConfigureFeature; external msilib name 'MsiConfigureFeatureW';
  594. {$ENDIF DYNAMIC_LINK}
  595. {$ELSE}
  596. {$IFDEF DYNAMIC_LINK}
  597. var
  598.   _MsiConfigureFeature: Pointer;
  599. function MsiConfigureFeature;
  600. begin
  601.   GetProcedureAddress(_MsiConfigureFeature, msilib, 'MsiConfigureFeatureA');
  602.   asm
  603.     mov esp, ebp
  604.     pop ebp
  605.     jmp [_MsiConfigureFeature]
  606.   end;
  607. end;
  608. {$ELSE}
  609. function MsiConfigureFeature; external msilib name 'MsiConfigureFeatureA';
  610. {$ENDIF DYNAMIC_LINK}
  611. {$ENDIF}
  612. {$IFDEF DYNAMIC_LINK}
  613. var
  614.   _MsiReinstallFeatureA: Pointer;
  615. function MsiReinstallFeatureA;
  616. begin
  617.   GetProcedureAddress(_MsiReinstallFeatureA, msilib, 'MsiReinstallFeatureA');
  618.   asm
  619.     mov esp, ebp
  620.     pop ebp
  621.     jmp [_MsiReinstallFeatureA]
  622.   end;
  623. end;
  624. {$ELSE}
  625. function MsiReinstallFeatureA; external msilib name 'MsiReinstallFeatureA';
  626. {$ENDIF DYNAMIC_LINK}
  627. {$IFDEF DYNAMIC_LINK}
  628. var
  629.   _MsiReinstallFeatureW: Pointer;
  630. function MsiReinstallFeatureW;
  631. begin
  632.   GetProcedureAddress(_MsiReinstallFeatureW, msilib, 'MsiReinstallFeatureW');
  633.   asm
  634.     mov esp, ebp
  635.     pop ebp
  636.     jmp [_MsiReinstallFeatureW]
  637.   end;
  638. end;
  639. {$ELSE}
  640. function MsiReinstallFeatureW; external msilib name 'MsiReinstallFeatureW';
  641. {$ENDIF DYNAMIC_LINK}
  642. {$IFDEF UNICODE}
  643. {$IFDEF DYNAMIC_LINK}
  644. var
  645.   _MsiReinstallFeature: Pointer;
  646. function MsiReinstallFeature;
  647. begin
  648.   GetProcedureAddress(_MsiReinstallFeature, msilib, 'MsiReinstallFeatureW');
  649.   asm
  650.     mov esp, ebp
  651.     pop ebp
  652.     jmp [_MsiReinstallFeature]
  653.   end;
  654. end;
  655. {$ELSE}
  656. function MsiReinstallFeature; external msilib name 'MsiReinstallFeatureW';
  657. {$ENDIF DYNAMIC_LINK}
  658. {$ELSE}
  659. {$IFDEF DYNAMIC_LINK}
  660. var
  661.   _MsiReinstallFeature: Pointer;
  662. function MsiReinstallFeature;
  663. begin
  664.   GetProcedureAddress(_MsiReinstallFeature, msilib, 'MsiReinstallFeatureA');
  665.   asm
  666.     mov esp, ebp
  667.     pop ebp
  668.     jmp [_MsiReinstallFeature]
  669.   end;
  670. end;
  671. {$ELSE}
  672. function MsiReinstallFeature; external msilib name 'MsiReinstallFeatureA';
  673. {$ENDIF DYNAMIC_LINK}
  674. {$ENDIF}
  675. {$IFDEF DYNAMIC_LINK}
  676. var
  677.   _MsiProvideComponentA: Pointer;
  678. function MsiProvideComponentA;
  679. begin
  680.   GetProcedureAddress(_MsiProvideComponentA, msilib, 'MsiProvideComponentA');
  681.   asm
  682.     mov esp, ebp
  683.     pop ebp
  684.     jmp [_MsiProvideComponentA]
  685.   end;
  686. end;
  687. {$ELSE}
  688. function MsiProvideComponentA; external msilib name 'MsiProvideComponentA';
  689. {$ENDIF DYNAMIC_LINK}
  690. {$IFDEF DYNAMIC_LINK}
  691. var
  692.   _MsiProvideComponentW: Pointer;
  693. function MsiProvideComponentW;
  694. begin
  695.   GetProcedureAddress(_MsiProvideComponentW, msilib, 'MsiProvideComponentW');
  696.   asm
  697.     mov esp, ebp
  698.     pop ebp
  699.     jmp [_MsiProvideComponentW]
  700.   end;
  701. end;
  702. {$ELSE}
  703. function MsiProvideComponentW; external msilib name 'MsiProvideComponentW';
  704. {$ENDIF DYNAMIC_LINK}
  705. {$IFDEF UNICODE}
  706. {$IFDEF DYNAMIC_LINK}
  707. var
  708.   _MsiProvideComponent: Pointer;
  709. function MsiProvideComponent;
  710. begin
  711.   GetProcedureAddress(_MsiProvideComponent, msilib, 'MsiProvideComponentW');
  712.   asm
  713.     mov esp, ebp
  714.     pop ebp
  715.     jmp [_MsiProvideComponent]
  716.   end;
  717. end;
  718. {$ELSE}
  719. function MsiProvideComponent; external msilib name 'MsiProvideComponentW';
  720. {$ENDIF DYNAMIC_LINK}
  721. {$ELSE}
  722. {$IFDEF DYNAMIC_LINK}
  723. var
  724.   _MsiProvideComponent: Pointer;
  725. function MsiProvideComponent;
  726. begin
  727.   GetProcedureAddress(_MsiProvideComponent, msilib, 'MsiProvideComponentA');
  728.   asm
  729.     mov esp, ebp
  730.     pop ebp
  731.     jmp [_MsiProvideComponent]
  732.   end;
  733. end;
  734. {$ELSE}
  735. function MsiProvideComponent; external msilib name 'MsiProvideComponentA';
  736. {$ENDIF DYNAMIC_LINK}
  737. {$ENDIF}
  738. {$IFDEF DYNAMIC_LINK}
  739. var
  740.   _MsiProvideQualifiedComponentA: Pointer;
  741. function MsiProvideQualifiedComponentA;
  742. begin
  743.   GetProcedureAddress(_MsiProvideQualifiedComponentA, msilib, 'MsiProvideQualifiedComponentA');
  744.   asm
  745.     mov esp, ebp
  746.     pop ebp
  747.     jmp [_MsiProvideQualifiedComponentA]
  748.   end;
  749. end;
  750. {$ELSE}
  751. function MsiProvideQualifiedComponentA; external msilib name 'MsiProvideQualifiedComponentA';
  752. {$ENDIF DYNAMIC_LINK}
  753. {$IFDEF DYNAMIC_LINK}
  754. var
  755.   _MsiProvideQualifiedComponentW: Pointer;
  756. function MsiProvideQualifiedComponentW;
  757. begin
  758.   GetProcedureAddress(_MsiProvideQualifiedComponentW, msilib, 'MsiProvideQualifiedComponentW');
  759.   asm
  760.     mov esp, ebp
  761.     pop ebp
  762.     jmp [_MsiProvideQualifiedComponentW]
  763.   end;
  764. end;
  765. {$ELSE}
  766. function MsiProvideQualifiedComponentW; external msilib name 'MsiProvideQualifiedComponentW';
  767. {$ENDIF DYNAMIC_LINK}
  768. {$IFDEF UNICODE}
  769. {$IFDEF DYNAMIC_LINK}
  770. var
  771.   _MsiProvideQualifiedComponent: Pointer;
  772. function MsiProvideQualifiedComponent;
  773. begin
  774.   GetProcedureAddress(_MsiProvideQualifiedComponent, msilib, 'MsiProvideQualifiedComponentW');
  775.   asm
  776.     mov esp, ebp
  777.     pop ebp
  778.     jmp [_MsiProvideQualifiedComponent]
  779.   end;
  780. end;
  781. {$ELSE}
  782. function MsiProvideQualifiedComponent; external msilib name 'MsiProvideQualifiedComponentW';
  783. {$ENDIF DYNAMIC_LINK}
  784. {$ELSE}
  785. {$IFDEF DYNAMIC_LINK}
  786. var
  787.   _MsiProvideQualifiedComponent: Pointer;
  788. function MsiProvideQualifiedComponent;
  789. begin
  790.   GetProcedureAddress(_MsiProvideQualifiedComponent, msilib, 'MsiProvideQualifiedComponentA');
  791.   asm
  792.     mov esp, ebp
  793.     pop ebp
  794.     jmp [_MsiProvideQualifiedComponent]
  795.   end;
  796. end;
  797. {$ELSE}
  798. function MsiProvideQualifiedComponent; external msilib name 'MsiProvideQualifiedComponentA';
  799. {$ENDIF DYNAMIC_LINK}
  800. {$ENDIF}
  801. {$IFDEF DYNAMIC_LINK}
  802. var
  803.   _MsiProvideQualifiedComponentExA: Pointer;
  804. function MsiProvideQualifiedComponentExA;
  805. begin
  806.   GetProcedureAddress(_MsiProvideQualifiedComponentExA, msilib, 'MsiProvideQualifiedComponentExA');
  807.   asm
  808.     mov esp, ebp
  809.     pop ebp
  810.     jmp [_MsiProvideQualifiedComponentExA]
  811.   end;
  812. end;
  813. {$ELSE}
  814. function MsiProvideQualifiedComponentExA; external msilib name 'MsiProvideQualifiedComponentExA';
  815. {$ENDIF DYNAMIC_LINK}
  816. {$IFDEF DYNAMIC_LINK}
  817. var
  818.   _MsiProvideQualifiedComponentExW: Pointer;
  819. function MsiProvideQualifiedComponentExW;
  820. begin
  821.   GetProcedureAddress(_MsiProvideQualifiedComponentExW, msilib, 'MsiProvideQualifiedComponentExW');
  822.   asm
  823.     mov esp, ebp
  824.     pop ebp
  825.     jmp [_MsiProvideQualifiedComponentExW]
  826.   end;
  827. end;
  828. {$ELSE}
  829. function MsiProvideQualifiedComponentExW; external msilib name 'MsiProvideQualifiedComponentExW';
  830. {$ENDIF DYNAMIC_LINK}
  831. {$IFDEF UNICODE}
  832. {$IFDEF DYNAMIC_LINK}
  833. var
  834.   _MsiProvideQualifiedComponentEx: Pointer;
  835. function MsiProvideQualifiedComponentEx;
  836. begin
  837.   GetProcedureAddress(_MsiProvideQualifiedComponentEx, msilib, 'MsiProvideQualifiedComponentExW');
  838.   asm
  839.     mov esp, ebp
  840.     pop ebp
  841.     jmp [_MsiProvideQualifiedComponentEx]
  842.   end;
  843. end;
  844. {$ELSE}
  845. function MsiProvideQualifiedComponentEx; external msilib name 'MsiProvideQualifiedComponentExW';
  846. {$ENDIF DYNAMIC_LINK}
  847. {$ELSE}
  848. {$IFDEF DYNAMIC_LINK}
  849. var
  850.   _MsiProvideQualifiedComponentEx: Pointer;
  851. function MsiProvideQualifiedComponentEx;
  852. begin
  853.   GetProcedureAddress(_MsiProvideQualifiedComponentEx, msilib, 'MsiProvideQualifiedComponentExA');
  854.   asm
  855.     mov esp, ebp
  856.     pop ebp
  857.     jmp [_MsiProvideQualifiedComponentEx]
  858.   end;
  859. end;
  860. {$ELSE}
  861. function MsiProvideQualifiedComponentEx; external msilib name 'MsiProvideQualifiedComponentExA';
  862. {$ENDIF DYNAMIC_LINK}
  863. {$ENDIF}
  864. {$IFDEF DYNAMIC_LINK}
  865. var
  866.   _MsiGetComponentPathA: Pointer;
  867. function MsiGetComponentPathA;
  868. begin
  869.   GetProcedureAddress(_MsiGetComponentPathA, msilib, 'MsiGetComponentPathA');
  870.   asm
  871.     mov esp, ebp
  872.     pop ebp
  873.     jmp [_MsiGetComponentPathA]
  874.   end;
  875. end;
  876. {$ELSE}
  877. function MsiGetComponentPathA; external msilib name 'MsiGetComponentPathA';
  878. {$ENDIF DYNAMIC_LINK}
  879. {$IFDEF DYNAMIC_LINK}
  880. var
  881.   _MsiGetComponentPathW: Pointer;
  882. function MsiGetComponentPathW;
  883. begin
  884.   GetProcedureAddress(_MsiGetComponentPathW, msilib, 'MsiGetComponentPathW');
  885.   asm
  886.     mov esp, ebp
  887.     pop ebp
  888.     jmp [_MsiGetComponentPathW]
  889.   end;
  890. end;
  891. {$ELSE}
  892. function MsiGetComponentPathW; external msilib name 'MsiGetComponentPathW';
  893. {$ENDIF DYNAMIC_LINK}
  894. {$IFDEF UNICODE}
  895. {$IFDEF DYNAMIC_LINK}
  896. var
  897.   _MsiGetComponentPath: Pointer;
  898. function MsiGetComponentPath;
  899. begin
  900.   GetProcedureAddress(_MsiGetComponentPath, msilib, 'MsiGetComponentPathW');
  901.   asm
  902.     mov esp, ebp
  903.     pop ebp
  904.     jmp [_MsiGetComponentPath]
  905.   end;
  906. end;
  907. {$ELSE}
  908. function MsiGetComponentPath; external msilib name 'MsiGetComponentPathW';
  909. {$ENDIF DYNAMIC_LINK}
  910. {$ELSE}
  911. {$IFDEF DYNAMIC_LINK}
  912. var
  913.   _MsiGetComponentPath: Pointer;
  914. function MsiGetComponentPath;
  915. begin
  916.   GetProcedureAddress(_MsiGetComponentPath, msilib, 'MsiGetComponentPathA');
  917.   asm
  918.     mov esp, ebp
  919.     pop ebp
  920.     jmp [_MsiGetComponentPath]
  921.   end;
  922. end;
  923. {$ELSE}
  924. function MsiGetComponentPath; external msilib name 'MsiGetComponentPathA';
  925. {$ENDIF DYNAMIC_LINK}
  926. {$ENDIF}
  927. {$IFDEF DYNAMIC_LINK}
  928. var
  929.   _MsiProvideAssemblyA: Pointer;
  930. function MsiProvideAssemblyA;
  931. begin
  932.   GetProcedureAddress(_MsiProvideAssemblyA, msilib, 'MsiProvideAssemblyA');
  933.   asm
  934.     mov esp, ebp
  935.     pop ebp
  936.     jmp [_MsiProvideAssemblyA]
  937.   end;
  938. end;
  939. {$ELSE}
  940. function MsiProvideAssemblyA; external msilib name 'MsiProvideAssemblyA';
  941. {$ENDIF DYNAMIC_LINK}
  942. {$IFDEF DYNAMIC_LINK}
  943. var
  944.   _MsiProvideAssemblyW: Pointer;
  945. function MsiProvideAssemblyW;
  946. begin
  947.   GetProcedureAddress(_MsiProvideAssemblyW, msilib, 'MsiProvideAssemblyW');
  948.   asm
  949.     mov esp, ebp
  950.     pop ebp
  951.     jmp [_MsiProvideAssemblyW]
  952.   end;
  953. end;
  954. {$ELSE}
  955. function MsiProvideAssemblyW; external msilib name 'MsiProvideAssemblyW';
  956. {$ENDIF DYNAMIC_LINK}
  957. {$IFDEF UNICODE}
  958. {$IFDEF DYNAMIC_LINK}
  959. var
  960.   _MsiProvideAssembly: Pointer;
  961. function MsiProvideAssembly;
  962. begin
  963.   GetProcedureAddress(_MsiProvideAssembly, msilib, 'MsiProvideAssemblyW');
  964.   asm
  965.     mov esp, ebp
  966.     pop ebp
  967.     jmp [_MsiProvideAssembly]
  968.   end;
  969. end;
  970. {$ELSE}
  971. function MsiProvideAssembly; external msilib name 'MsiProvideAssemblyW';
  972. {$ENDIF DYNAMIC_LINK}
  973. {$ELSE}
  974. {$IFDEF DYNAMIC_LINK}
  975. var
  976.   _MsiProvideAssembly: Pointer;
  977. function MsiProvideAssembly;
  978. begin
  979.   GetProcedureAddress(_MsiProvideAssembly, msilib, 'MsiProvideAssemblyA');
  980.   asm
  981.     mov esp, ebp
  982.     pop ebp
  983.     jmp [_MsiProvideAssembly]
  984.   end;
  985. end;
  986. {$ELSE}
  987. function MsiProvideAssembly; external msilib name 'MsiProvideAssemblyA';
  988. {$ENDIF DYNAMIC_LINK}
  989. {$ENDIF}
  990. {$IFDEF DYNAMIC_LINK}
  991. var
  992.   _MsiEnumProductsA: Pointer;
  993. function MsiEnumProductsA;
  994. begin
  995.   GetProcedureAddress(_MsiEnumProductsA, msilib, 'MsiEnumProductsA');
  996.   asm
  997.     mov esp, ebp
  998.     pop ebp
  999.     jmp [_MsiEnumProductsA]
  1000.   end;
  1001. end;
  1002. {$ELSE}
  1003. function MsiEnumProductsA; external msilib name 'MsiEnumProductsA';
  1004. {$ENDIF DYNAMIC_LINK}
  1005. {$IFDEF DYNAMIC_LINK}
  1006. var
  1007.   _MsiEnumProductsW: Pointer;
  1008. function MsiEnumProductsW;
  1009. begin
  1010.   GetProcedureAddress(_MsiEnumProductsW, msilib, 'MsiEnumProductsW');
  1011.   asm
  1012.     mov esp, ebp
  1013.     pop ebp
  1014.     jmp [_MsiEnumProductsW]
  1015.   end;
  1016. end;
  1017. {$ELSE}
  1018. function MsiEnumProductsW; external msilib name 'MsiEnumProductsW';
  1019. {$ENDIF DYNAMIC_LINK}
  1020. {$IFDEF UNICODE}
  1021. {$IFDEF DYNAMIC_LINK}
  1022. var
  1023.   _MsiEnumProducts: Pointer;
  1024. function MsiEnumProducts;
  1025. begin
  1026.   GetProcedureAddress(_MsiEnumProducts, msilib, 'MsiEnumProductsW');
  1027.   asm
  1028.     mov esp, ebp
  1029.     pop ebp
  1030.     jmp [_MsiEnumProducts]
  1031.   end;
  1032. end;
  1033. {$ELSE}
  1034. function MsiEnumProducts; external msilib name 'MsiEnumProductsW';
  1035. {$ENDIF DYNAMIC_LINK}
  1036. {$ELSE}
  1037. {$IFDEF DYNAMIC_LINK}
  1038. var
  1039.   _MsiEnumProducts: Pointer;
  1040. function MsiEnumProducts;
  1041. begin
  1042.   GetProcedureAddress(_MsiEnumProducts, msilib, 'MsiEnumProductsA');
  1043.   asm
  1044.     mov esp, ebp
  1045.     pop ebp
  1046.     jmp [_MsiEnumProducts]
  1047.   end;
  1048. end;
  1049. {$ELSE}
  1050. function MsiEnumProducts; external msilib name 'MsiEnumProductsA';
  1051. {$ENDIF DYNAMIC_LINK}
  1052. {$ENDIF}
  1053. {$IFDEF WIN32_MSI_110}
  1054. {$IFDEF DYNAMIC_LINK}
  1055. var
  1056.   _MsiEnumRelatedProductsA: Pointer;
  1057. function MsiEnumRelatedProductsA;
  1058. begin
  1059.   GetProcedureAddress(_MsiEnumRelatedProductsA, msilib, 'MsiEnumRelatedProductsA');
  1060.   asm
  1061.     mov esp, ebp
  1062.     pop ebp
  1063.     jmp [_MsiEnumRelatedProductsA]
  1064.   end;
  1065. end;
  1066. {$ELSE}
  1067. function MsiEnumRelatedProductsA; external msilib name 'MsiEnumRelatedProductsA';
  1068. {$ENDIF DYNAMIC_LINK}
  1069. {$IFDEF DYNAMIC_LINK}
  1070. var
  1071.   _MsiEnumRelatedProductsW: Pointer;
  1072. function MsiEnumRelatedProductsW;
  1073. begin
  1074.   GetProcedureAddress(_MsiEnumRelatedProductsW, msilib, 'MsiEnumRelatedProductsW');
  1075.   asm
  1076.     mov esp, ebp
  1077.     pop ebp
  1078.     jmp [_MsiEnumRelatedProductsW]
  1079.   end;
  1080. end;
  1081. {$ELSE}
  1082. function MsiEnumRelatedProductsW; external msilib name 'MsiEnumRelatedProductsW';
  1083. {$ENDIF DYNAMIC_LINK}
  1084. {$IFDEF UNICODE}
  1085. {$IFDEF DYNAMIC_LINK}
  1086. var
  1087.   _MsiEnumRelatedProducts: Pointer;
  1088. function MsiEnumRelatedProducts;
  1089. begin
  1090.   GetProcedureAddress(_MsiEnumRelatedProducts, msilib, 'MsiEnumRelatedProductsW');
  1091.   asm
  1092.     mov esp, ebp
  1093.     pop ebp
  1094.     jmp [_MsiEnumRelatedProducts]
  1095.   end;
  1096. end;
  1097. {$ELSE}
  1098. function MsiEnumRelatedProducts; external msilib name 'MsiEnumRelatedProductsW';
  1099. {$ENDIF DYNAMIC_LINK}
  1100. {$ELSE}
  1101. {$IFDEF DYNAMIC_LINK}
  1102. var
  1103.   _MsiEnumRelatedProducts: Pointer;
  1104. function MsiEnumRelatedProducts;
  1105. begin
  1106.   GetProcedureAddress(_MsiEnumRelatedProducts, msilib, 'MsiEnumRelatedProductsA');
  1107.   asm
  1108.     mov esp, ebp
  1109.     pop ebp
  1110.     jmp [_MsiEnumRelatedProducts]
  1111.   end;
  1112. end;
  1113. {$ELSE}
  1114. function MsiEnumRelatedProducts; external msilib name 'MsiEnumRelatedProductsA';
  1115. {$ENDIF DYNAMIC_LINK}
  1116. {$ENDIF}
  1117. {$ENDIF WIN32_MSI_110}
  1118. {$IFDEF DYNAMIC_LINK}
  1119. var
  1120.   _MsiEnumFeaturesA: Pointer;
  1121. function MsiEnumFeaturesA;
  1122. begin
  1123.   GetProcedureAddress(_MsiEnumFeaturesA, msilib, 'MsiEnumFeaturesA');
  1124.   asm
  1125.     mov esp, ebp
  1126.     pop ebp
  1127.     jmp [_MsiEnumFeaturesA]
  1128.   end;
  1129. end;
  1130. {$ELSE}
  1131. function MsiEnumFeaturesA; external msilib name 'MsiEnumFeaturesA';
  1132. {$ENDIF DYNAMIC_LINK}
  1133. {$IFDEF DYNAMIC_LINK}
  1134. var
  1135.   _MsiEnumFeaturesW: Pointer;
  1136. function MsiEnumFeaturesW;
  1137. begin
  1138.   GetProcedureAddress(_MsiEnumFeaturesW, msilib, 'MsiEnumFeaturesW');
  1139.   asm
  1140.     mov esp, ebp
  1141.     pop ebp
  1142.     jmp [_MsiEnumFeaturesW]
  1143.   end;
  1144. end;
  1145. {$ELSE}
  1146. function MsiEnumFeaturesW; external msilib name 'MsiEnumFeaturesW';
  1147. {$ENDIF DYNAMIC_LINK}
  1148. {$IFDEF UNICODE}
  1149. {$IFDEF DYNAMIC_LINK}
  1150. var
  1151.   _MsiEnumFeatures: Pointer;
  1152. function MsiEnumFeatures;
  1153. begin
  1154.   GetProcedureAddress(_MsiEnumFeatures, msilib, 'MsiEnumFeaturesW');
  1155.   asm
  1156.     mov esp, ebp
  1157.     pop ebp
  1158.     jmp [_MsiEnumFeatures]
  1159.   end;
  1160. end;
  1161. {$ELSE}
  1162. function MsiEnumFeatures; external msilib name 'MsiEnumFeaturesW';
  1163. {$ENDIF DYNAMIC_LINK}
  1164. {$ELSE}
  1165. {$IFDEF DYNAMIC_LINK}
  1166. var
  1167.   _MsiEnumFeatures: Pointer;
  1168. function MsiEnumFeatures;
  1169. begin
  1170.   GetProcedureAddress(_MsiEnumFeatures, msilib, 'MsiEnumFeaturesA');
  1171.   asm
  1172.     mov esp, ebp
  1173.     pop ebp
  1174.     jmp [_MsiEnumFeatures]
  1175.   end;
  1176. end;
  1177. {$ELSE}
  1178. function MsiEnumFeatures; external msilib name 'MsiEnumFeaturesA';
  1179. {$ENDIF DYNAMIC_LINK}
  1180. {$ENDIF}
  1181. {$IFDEF DYNAMIC_LINK}
  1182. var
  1183.   _MsiEnumComponentsA: Pointer;
  1184. function MsiEnumComponentsA;
  1185. begin
  1186.   GetProcedureAddress(_MsiEnumComponentsA, msilib, 'MsiEnumComponentsA');
  1187.   asm
  1188.     mov esp, ebp
  1189.     pop ebp
  1190.     jmp [_MsiEnumComponentsA]
  1191.   end;
  1192. end;
  1193. {$ELSE}
  1194. function MsiEnumComponentsA; external msilib name 'MsiEnumComponentsA';
  1195. {$ENDIF DYNAMIC_LINK}
  1196. {$IFDEF DYNAMIC_LINK}
  1197. var
  1198.   _MsiEnumComponentsW: Pointer;
  1199. function MsiEnumComponentsW;
  1200. begin
  1201.   GetProcedureAddress(_MsiEnumComponentsW, msilib, 'MsiEnumComponentsW');
  1202.   asm
  1203.     mov esp, ebp
  1204.     pop ebp
  1205.     jmp [_MsiEnumComponentsW]
  1206.   end;
  1207. end;
  1208. {$ELSE}
  1209. function MsiEnumComponentsW; external msilib name 'MsiEnumComponentsW';
  1210. {$ENDIF DYNAMIC_LINK}
  1211. {$IFDEF UNICODE}
  1212. {$IFDEF DYNAMIC_LINK}
  1213. var
  1214.   _MsiEnumComponents: Pointer;
  1215. function MsiEnumComponents;
  1216. begin
  1217.   GetProcedureAddress(_MsiEnumComponents, msilib, 'MsiEnumComponentsW');
  1218.   asm
  1219.     mov esp, ebp
  1220.     pop ebp
  1221.     jmp [_MsiEnumComponents]
  1222.   end;
  1223. end;
  1224. {$ELSE}
  1225. function MsiEnumComponents; external msilib name 'MsiEnumComponentsW';
  1226. {$ENDIF DYNAMIC_LINK}
  1227. {$ELSE}
  1228. {$IFDEF DYNAMIC_LINK}
  1229. var
  1230.   _MsiEnumComponents: Pointer;
  1231. function MsiEnumComponents;
  1232. begin
  1233.   GetProcedureAddress(_MsiEnumComponents, msilib, 'MsiEnumComponentsA');
  1234.   asm
  1235.     mov esp, ebp
  1236.     pop ebp
  1237.     jmp [_MsiEnumComponents]
  1238.   end;
  1239. end;
  1240. {$ELSE}
  1241. function MsiEnumComponents; external msilib name 'MsiEnumComponentsA';
  1242. {$ENDIF DYNAMIC_LINK}
  1243. {$ENDIF}
  1244. {$IFDEF DYNAMIC_LINK}
  1245. var
  1246.   _MsiEnumClientsA: Pointer;
  1247. function MsiEnumClientsA;
  1248. begin
  1249.   GetProcedureAddress(_MsiEnumClientsA, msilib, 'MsiEnumClientsA');
  1250.   asm
  1251.     mov esp, ebp
  1252.     pop ebp
  1253.     jmp [_MsiEnumClientsA]
  1254.   end;
  1255. end;
  1256. {$ELSE}
  1257. function MsiEnumClientsA; external msilib name 'MsiEnumClientsA';
  1258. {$ENDIF DYNAMIC_LINK}
  1259. {$IFDEF DYNAMIC_LINK}
  1260. var
  1261.   _MsiEnumClientsW: Pointer;
  1262. function MsiEnumClientsW;
  1263. begin
  1264.   GetProcedureAddress(_MsiEnumClientsW, msilib, 'MsiEnumClientsW');
  1265.   asm
  1266.     mov esp, ebp
  1267.     pop ebp
  1268.     jmp [_MsiEnumClientsW]
  1269.   end;
  1270. end;
  1271. {$ELSE}
  1272. function MsiEnumClientsW; external msilib name 'MsiEnumClientsW';
  1273. {$ENDIF DYNAMIC_LINK}
  1274. {$IFDEF UNICODE}
  1275. {$IFDEF DYNAMIC_LINK}
  1276. var
  1277.   _MsiEnumClients: Pointer;
  1278. function MsiEnumClients;
  1279. begin
  1280.   GetProcedureAddress(_MsiEnumClients, msilib, 'MsiEnumClientsW');
  1281.   asm
  1282.     mov esp, ebp
  1283.     pop ebp
  1284.     jmp [_MsiEnumClients]
  1285.   end;
  1286. end;
  1287. {$ELSE}
  1288. function MsiEnumClients; external msilib name 'MsiEnumClientsW';
  1289. {$ENDIF DYNAMIC_LINK}
  1290. {$ELSE}
  1291. {$IFDEF DYNAMIC_LINK}
  1292. var
  1293.   _MsiEnumClients: Pointer;
  1294. function MsiEnumClients;
  1295. begin
  1296.   GetProcedureAddress(_MsiEnumClients, msilib, 'MsiEnumClientsA');
  1297.   asm
  1298.     mov esp, ebp
  1299.     pop ebp
  1300.     jmp [_MsiEnumClients]
  1301.   end;
  1302. end;
  1303. {$ELSE}
  1304. function MsiEnumClients; external msilib name 'MsiEnumClientsA';
  1305. {$ENDIF DYNAMIC_LINK}
  1306. {$ENDIF}
  1307. {$IFDEF DYNAMIC_LINK}
  1308. var
  1309.   _MsiEnumComponentQualifiersA: Pointer;
  1310. function MsiEnumComponentQualifiersA;
  1311. begin
  1312.   GetProcedureAddress(_MsiEnumComponentQualifiersA, msilib, 'MsiEnumComponentQualifiersA');
  1313.   asm
  1314.     mov esp, ebp
  1315.     pop ebp
  1316.     jmp [_MsiEnumComponentQualifiersA]
  1317.   end;
  1318. end;
  1319. {$ELSE}
  1320. function MsiEnumComponentQualifiersA; external msilib name 'MsiEnumComponentQualifiersA';
  1321. {$ENDIF DYNAMIC_LINK}
  1322. {$IFDEF DYNAMIC_LINK}
  1323. var
  1324.   _MsiEnumComponentQualifiersW: Pointer;
  1325. function MsiEnumComponentQualifiersW;
  1326. begin
  1327.   GetProcedureAddress(_MsiEnumComponentQualifiersW, msilib, 'MsiEnumComponentQualifiersW');
  1328.   asm
  1329.     mov esp, ebp
  1330.     pop ebp
  1331.     jmp [_MsiEnumComponentQualifiersW]
  1332.   end;
  1333. end;
  1334. {$ELSE}
  1335. function MsiEnumComponentQualifiersW; external msilib name 'MsiEnumComponentQualifiersW';
  1336. {$ENDIF DYNAMIC_LINK}
  1337. {$IFDEF UNICODE}
  1338. {$IFDEF DYNAMIC_LINK}
  1339. var
  1340.   _MsiEnumComponentQualifiers: Pointer;
  1341. function MsiEnumComponentQualifiers;
  1342. begin
  1343.   GetProcedureAddress(_MsiEnumComponentQualifiers, msilib, 'MsiEnumComponentQualifiersW');
  1344.   asm
  1345.     mov esp, ebp
  1346.     pop ebp
  1347.     jmp [_MsiEnumComponentQualifiers]
  1348.   end;
  1349. end;
  1350. {$ELSE}
  1351. function MsiEnumComponentQualifiers; external msilib name 'MsiEnumComponentQualifiersW';
  1352. {$ENDIF DYNAMIC_LINK}
  1353. {$ELSE}
  1354. {$IFDEF DYNAMIC_LINK}
  1355. var
  1356.   _MsiEnumComponentQualifiers: Pointer;
  1357. function MsiEnumComponentQualifiers;
  1358. begin
  1359.   GetProcedureAddress(_MsiEnumComponentQualifiers, msilib, 'MsiEnumComponentQualifiersA');
  1360.   asm
  1361.     mov esp, ebp
  1362.     pop ebp
  1363.     jmp [_MsiEnumComponentQualifiers]
  1364.   end;
  1365. end;
  1366. {$ELSE}
  1367. function MsiEnumComponentQualifiers; external msilib name 'MsiEnumComponentQualifiersA';
  1368. {$ENDIF DYNAMIC_LINK}
  1369. {$ENDIF}
  1370. {$IFDEF DYNAMIC_LINK}
  1371. var
  1372.   _MsiOpenProductA: Pointer;
  1373. function MsiOpenProductA;
  1374. begin
  1375.   GetProcedureAddress(_MsiOpenProductA, msilib, 'MsiOpenProductA');
  1376.   asm
  1377.     mov esp, ebp
  1378.     pop ebp
  1379.     jmp [_MsiOpenProductA]
  1380.   end;
  1381. end;
  1382. {$ELSE}
  1383. function MsiOpenProductA; external msilib name 'MsiOpenProductA';
  1384. {$ENDIF DYNAMIC_LINK}
  1385. {$IFDEF DYNAMIC_LINK}
  1386. var
  1387.   _MsiOpenProductW: Pointer;
  1388. function MsiOpenProductW;
  1389. begin
  1390.   GetProcedureAddress(_MsiOpenProductW, msilib, 'MsiOpenProductW');
  1391.   asm
  1392.     mov esp, ebp
  1393.     pop ebp
  1394.     jmp [_MsiOpenProductW]
  1395.   end;
  1396. end;
  1397. {$ELSE}
  1398. function MsiOpenProductW; external msilib name 'MsiOpenProductW';
  1399. {$ENDIF DYNAMIC_LINK}
  1400. {$IFDEF UNICODE}
  1401. {$IFDEF DYNAMIC_LINK}
  1402. var
  1403.   _MsiOpenProduct: Pointer;
  1404. function MsiOpenProduct;
  1405. begin
  1406.   GetProcedureAddress(_MsiOpenProduct, msilib, 'MsiOpenProductW');
  1407.   asm
  1408.     mov esp, ebp
  1409.     pop ebp
  1410.     jmp [_MsiOpenProduct]
  1411.   end;
  1412. end;
  1413. {$ELSE}
  1414. function MsiOpenProduct; external msilib name 'MsiOpenProductW';
  1415. {$ENDIF DYNAMIC_LINK}
  1416. {$ELSE}
  1417. {$IFDEF DYNAMIC_LINK}
  1418. var
  1419.   _MsiOpenProduct: Pointer;
  1420. function MsiOpenProduct;
  1421. begin
  1422.   GetProcedureAddress(_MsiOpenProduct, msilib, 'MsiOpenProductA');
  1423.   asm
  1424.     mov esp, ebp
  1425.     pop ebp
  1426.     jmp [_MsiOpenProduct]
  1427.   end;
  1428. end;
  1429. {$ELSE}
  1430. function MsiOpenProduct; external msilib name 'MsiOpenProductA';
  1431. {$ENDIF DYNAMIC_LINK}
  1432. {$ENDIF}
  1433. {$IFDEF DYNAMIC_LINK}
  1434. var
  1435.   _MsiOpenPackageA: Pointer;
  1436. function MsiOpenPackageA;
  1437. begin
  1438.   GetProcedureAddress(_MsiOpenPackageA, msilib, 'MsiOpenPackageA');
  1439.   asm
  1440.     mov esp, ebp
  1441.     pop ebp
  1442.     jmp [_MsiOpenPackageA]
  1443.   end;
  1444. end;
  1445. {$ELSE}
  1446. function MsiOpenPackageA; external msilib name 'MsiOpenPackageA';
  1447. {$ENDIF DYNAMIC_LINK}
  1448. {$IFDEF DYNAMIC_LINK}
  1449. var
  1450.   _MsiOpenPackageW: Pointer;
  1451. function MsiOpenPackageW;
  1452. begin
  1453.   GetProcedureAddress(_MsiOpenPackageW, msilib, 'MsiOpenPackageW');
  1454.   asm
  1455.     mov esp, ebp
  1456.     pop ebp
  1457.     jmp [_MsiOpenPackageW]
  1458.   end;
  1459. end;
  1460. {$ELSE}
  1461. function MsiOpenPackageW; external msilib name 'MsiOpenPackageW';
  1462. {$ENDIF DYNAMIC_LINK}
  1463. {$IFDEF UNICODE}
  1464. {$IFDEF DYNAMIC_LINK}
  1465. var
  1466.   _MsiOpenPackage: Pointer;
  1467. function MsiOpenPackage;
  1468. begin
  1469.   GetProcedureAddress(_MsiOpenPackage, msilib, 'MsiOpenPackageW');
  1470.   asm
  1471.     mov esp, ebp
  1472.     pop ebp
  1473.     jmp [_MsiOpenPackage]
  1474.   end;
  1475. end;
  1476. {$ELSE}
  1477. function MsiOpenPackage; external msilib name 'MsiOpenPackageW';
  1478. {$ENDIF DYNAMIC_LINK}
  1479. {$ELSE}
  1480. {$IFDEF DYNAMIC_LINK}
  1481. var
  1482.   _MsiOpenPackage: Pointer;
  1483. function MsiOpenPackage;
  1484. begin
  1485.   GetProcedureAddress(_MsiOpenPackage, msilib, 'MsiOpenPackageA');
  1486.   asm
  1487.     mov esp, ebp
  1488.     pop ebp
  1489.     jmp [_MsiOpenPackage]
  1490.   end;
  1491. end;
  1492. {$ELSE}
  1493. function MsiOpenPackage; external msilib name 'MsiOpenPackageA';
  1494. {$ENDIF DYNAMIC_LINK}
  1495. {$ENDIF}
  1496. {$IFDEF DYNAMIC_LINK}
  1497. var
  1498.   _MsiOpenPackageExA: Pointer;
  1499. function MsiOpenPackageExA;
  1500. begin
  1501.   GetProcedureAddress(_MsiOpenPackageExA, msilib, 'MsiOpenPackageExA');
  1502.   asm
  1503.     mov esp, ebp
  1504.     pop ebp
  1505.     jmp [_MsiOpenPackageExA]
  1506.   end;
  1507. end;
  1508. {$ELSE}
  1509. function MsiOpenPackageExA; external msilib name 'MsiOpenPackageExA';
  1510. {$ENDIF DYNAMIC_LINK}
  1511. {$IFDEF DYNAMIC_LINK}
  1512. var
  1513.   _MsiOpenPackageExW: Pointer;
  1514. function MsiOpenPackageExW;
  1515. begin
  1516.   GetProcedureAddress(_MsiOpenPackageExW, msilib, 'MsiOpenPackageExW');
  1517.   asm
  1518.     mov esp, ebp
  1519.     pop ebp
  1520.     jmp [_MsiOpenPackageExW]
  1521.   end;
  1522. end;
  1523. {$ELSE}
  1524. function MsiOpenPackageExW; external msilib name 'MsiOpenPackageExW';
  1525. {$ENDIF DYNAMIC_LINK}
  1526. {$IFDEF UNICODE}
  1527. {$IFDEF DYNAMIC_LINK}
  1528. var
  1529.   _MsiOpenPackageEx: Pointer;
  1530. function MsiOpenPackageEx;
  1531. begin
  1532.   GetProcedureAddress(_MsiOpenPackageEx, msilib, 'MsiOpenPackageExW');
  1533.   asm
  1534.     mov esp, ebp
  1535.     pop ebp
  1536.     jmp [_MsiOpenPackageEx]
  1537.   end;
  1538. end;
  1539. {$ELSE}
  1540. function MsiOpenPackageEx; external msilib name 'MsiOpenPackageExW';
  1541. {$ENDIF DYNAMIC_LINK}
  1542. {$ELSE}
  1543. {$IFDEF DYNAMIC_LINK}
  1544. var
  1545.   _MsiOpenPackageEx: Pointer;
  1546. function MsiOpenPackageEx;
  1547. begin
  1548.   GetProcedureAddress(_MsiOpenPackageEx, msilib, 'MsiOpenPackageExA');
  1549.   asm
  1550.     mov esp, ebp
  1551.     pop ebp
  1552.     jmp [_MsiOpenPackageEx]
  1553.   end;
  1554. end;
  1555. {$ELSE}
  1556. function MsiOpenPackageEx; external msilib name 'MsiOpenPackageExA';
  1557. {$ENDIF DYNAMIC_LINK}
  1558. {$ENDIF}
  1559. {$IFDEF DYNAMIC_LINK}
  1560. var
  1561.   _MsiGetProductPropertyA: Pointer;
  1562. function MsiGetProductPropertyA;
  1563. begin
  1564.   GetProcedureAddress(_MsiGetProductPropertyA, msilib, 'MsiGetProductPropertyA');
  1565.   asm
  1566.     mov esp, ebp
  1567.     pop ebp
  1568.     jmp [_MsiGetProductPropertyA]
  1569.   end;
  1570. end;
  1571. {$ELSE}
  1572. function MsiGetProductPropertyA; external msilib name 'MsiGetProductPropertyA';
  1573. {$ENDIF DYNAMIC_LINK}
  1574. {$IFDEF DYNAMIC_LINK}
  1575. var
  1576.   _MsiGetProductPropertyW: Pointer;
  1577. function MsiGetProductPropertyW;
  1578. begin
  1579.   GetProcedureAddress(_MsiGetProductPropertyW, msilib, 'MsiGetProductPropertyW');
  1580.   asm
  1581.     mov esp, ebp
  1582.     pop ebp
  1583.     jmp [_MsiGetProductPropertyW]
  1584.   end;
  1585. end;
  1586. {$ELSE}
  1587. function MsiGetProductPropertyW; external msilib name 'MsiGetProductPropertyW';
  1588. {$ENDIF DYNAMIC_LINK}
  1589. {$IFDEF UNICODE}
  1590. {$IFDEF DYNAMIC_LINK}
  1591. var
  1592.   _MsiGetProductProperty: Pointer;
  1593. function MsiGetProductProperty;
  1594. begin
  1595.   GetProcedureAddress(_MsiGetProductProperty, msilib, 'MsiGetProductPropertyW');
  1596.   asm
  1597.     mov esp, ebp
  1598.     pop ebp
  1599.     jmp [_MsiGetProductProperty]
  1600.   end;
  1601. end;
  1602. {$ELSE}
  1603. function MsiGetProductProperty; external msilib name 'MsiGetProductPropertyW';
  1604. {$ENDIF DYNAMIC_LINK}
  1605. {$ELSE}
  1606. {$IFDEF DYNAMIC_LINK}
  1607. var
  1608.   _MsiGetProductProperty: Pointer;
  1609. function MsiGetProductProperty;
  1610. begin
  1611.   GetProcedureAddress(_MsiGetProductProperty, msilib, 'MsiGetProductPropertyA');
  1612.   asm
  1613.     mov esp, ebp
  1614.     pop ebp
  1615.     jmp [_MsiGetProductProperty]
  1616.   end;
  1617. end;
  1618. {$ELSE}
  1619. function MsiGetProductProperty; external msilib name 'MsiGetProductPropertyA';
  1620. {$ENDIF DYNAMIC_LINK}
  1621. {$ENDIF}
  1622. {$IFDEF DYNAMIC_LINK}
  1623. var
  1624.   _MsiVerifyPackageA: Pointer;
  1625. function MsiVerifyPackageA;
  1626. begin
  1627.   GetProcedureAddress(_MsiVerifyPackageA, msilib, 'MsiVerifyPackageA');
  1628.   asm
  1629.     mov esp, ebp
  1630.     pop ebp
  1631.     jmp [_MsiVerifyPackageA]
  1632.   end;
  1633. end;
  1634. {$ELSE}
  1635. function MsiVerifyPackageA; external msilib name 'MsiVerifyPackageA';
  1636. {$ENDIF DYNAMIC_LINK}
  1637. {$IFDEF DYNAMIC_LINK}
  1638. var
  1639.   _MsiVerifyPackageW: Pointer;
  1640. function MsiVerifyPackageW;
  1641. begin
  1642.   GetProcedureAddress(_MsiVerifyPackageW, msilib, 'MsiVerifyPackageW');
  1643.   asm
  1644.     mov esp, ebp
  1645.     pop ebp
  1646.     jmp [_MsiVerifyPackageW]
  1647.   end;
  1648. end;
  1649. {$ELSE}
  1650. function MsiVerifyPackageW; external msilib name 'MsiVerifyPackageW';
  1651. {$ENDIF DYNAMIC_LINK}
  1652. {$IFDEF UNICODE}
  1653. {$IFDEF DYNAMIC_LINK}
  1654. var
  1655.   _MsiVerifyPackage: Pointer;
  1656. function MsiVerifyPackage;
  1657. begin
  1658.   GetProcedureAddress(_MsiVerifyPackage, msilib, 'MsiVerifyPackageW');
  1659.   asm
  1660.     mov esp, ebp
  1661.     pop ebp
  1662.     jmp [_MsiVerifyPackage]
  1663.   end;
  1664. end;
  1665. {$ELSE}
  1666. function MsiVerifyPackage; external msilib name 'MsiVerifyPackageW';
  1667. {$ENDIF DYNAMIC_LINK}
  1668. {$ELSE}
  1669. {$IFDEF DYNAMIC_LINK}
  1670. var
  1671.   _MsiVerifyPackage: Pointer;
  1672. function MsiVerifyPackage;
  1673. begin
  1674.   GetProcedureAddress(_MsiVerifyPackage, msilib, 'MsiVerifyPackageA');
  1675.   asm
  1676.     mov esp, ebp
  1677.     pop ebp
  1678.     jmp [_MsiVerifyPackage]
  1679.   end;
  1680. end;
  1681. {$ELSE}
  1682. function MsiVerifyPackage; external msilib name 'MsiVerifyPackageA';
  1683. {$ENDIF DYNAMIC_LINK}
  1684. {$ENDIF}
  1685. {$IFDEF DYNAMIC_LINK}
  1686. var
  1687.   _MsiGetFeatureInfoA: Pointer;
  1688. function MsiGetFeatureInfoA;
  1689. begin
  1690.   GetProcedureAddress(_MsiGetFeatureInfoA, msilib, 'MsiGetFeatureInfoA');
  1691.   asm
  1692.     mov esp, ebp
  1693.     pop ebp
  1694.     jmp [_MsiGetFeatureInfoA]
  1695.   end;
  1696. end;
  1697. {$ELSE}
  1698. function MsiGetFeatureInfoA; external msilib name 'MsiGetFeatureInfoA';
  1699. {$ENDIF DYNAMIC_LINK}
  1700. {$IFDEF DYNAMIC_LINK}
  1701. var
  1702.   _MsiGetFeatureInfoW: Pointer;
  1703. function MsiGetFeatureInfoW;
  1704. begin
  1705.   GetProcedureAddress(_MsiGetFeatureInfoW, msilib, 'MsiGetFeatureInfoW');
  1706.   asm
  1707.     mov esp, ebp
  1708.     pop ebp
  1709.     jmp [_MsiGetFeatureInfoW]
  1710.   end;
  1711. end;
  1712. {$ELSE}
  1713. function MsiGetFeatureInfoW; external msilib name 'MsiGetFeatureInfoW';
  1714. {$ENDIF DYNAMIC_LINK}
  1715. {$IFDEF UNICODE}
  1716. {$IFDEF DYNAMIC_LINK}
  1717. var
  1718.   _MsiGetFeatureInfo: Pointer;
  1719. function MsiGetFeatureInfo;
  1720. begin
  1721.   GetProcedureAddress(_MsiGetFeatureInfo, msilib, 'MsiGetFeatureInfoW');
  1722.   asm
  1723.     mov esp, ebp
  1724.     pop ebp
  1725.     jmp [_MsiGetFeatureInfo]
  1726.   end;
  1727. end;
  1728. {$ELSE}
  1729. function MsiGetFeatureInfo; external msilib name 'MsiGetFeatureInfoW';
  1730. {$ENDIF DYNAMIC_LINK}
  1731. {$ELSE}
  1732. {$IFDEF DYNAMIC_LINK}
  1733. var
  1734.   _MsiGetFeatureInfo: Pointer;
  1735. function MsiGetFeatureInfo;
  1736. begin
  1737.   GetProcedureAddress(_MsiGetFeatureInfo, msilib, 'MsiGetFeatureInfoA');
  1738.   asm
  1739.     mov esp, ebp
  1740.     pop ebp
  1741.     jmp [_MsiGetFeatureInfo]
  1742.   end;
  1743. end;
  1744. {$ELSE}
  1745. function MsiGetFeatureInfo; external msilib name 'MsiGetFeatureInfoA';
  1746. {$ENDIF DYNAMIC_LINK}
  1747. {$ENDIF}
  1748. {$IFDEF DYNAMIC_LINK}
  1749. var
  1750.   _MsiInstallMissingComponentA: Pointer;
  1751. function MsiInstallMissingComponentA;
  1752. begin
  1753.   GetProcedureAddress(_MsiInstallMissingComponentA, msilib, 'MsiInstallMissingComponentA');
  1754.   asm
  1755.     mov esp, ebp
  1756.     pop ebp
  1757.     jmp [_MsiInstallMissingComponentA]
  1758.   end;
  1759. end;
  1760. {$ELSE}
  1761. function MsiInstallMissingComponentA; external msilib name 'MsiInstallMissingComponentA';
  1762. {$ENDIF DYNAMIC_LINK}
  1763. {$IFDEF DYNAMIC_LINK}
  1764. var
  1765.   _MsiInstallMissingComponentW: Pointer;
  1766. function MsiInstallMissingComponentW;
  1767. begin
  1768.   GetProcedureAddress(_MsiInstallMissingComponentW, msilib, 'MsiInstallMissingComponentW');
  1769.   asm
  1770.     mov esp, ebp
  1771.     pop ebp
  1772.     jmp [_MsiInstallMissingComponentW]
  1773.   end;
  1774. end;
  1775. {$ELSE}
  1776. function MsiInstallMissingComponentW; external msilib name 'MsiInstallMissingComponentW';
  1777. {$ENDIF DYNAMIC_LINK}
  1778. {$IFDEF UNICODE}
  1779. {$IFDEF DYNAMIC_LINK}
  1780. var
  1781.   _MsiInstallMissingComponent: Pointer;
  1782. function MsiInstallMissingComponent;
  1783. begin
  1784.   GetProcedureAddress(_MsiInstallMissingComponent, msilib, 'MsiInstallMissingComponentW');
  1785.   asm
  1786.     mov esp, ebp
  1787.     pop ebp
  1788.     jmp [_MsiInstallMissingComponent]
  1789.   end;
  1790. end;
  1791. {$ELSE}
  1792. function MsiInstallMissingComponent; external msilib name 'MsiInstallMissingComponentW';
  1793. {$ENDIF DYNAMIC_LINK}
  1794. {$ELSE}
  1795. {$IFDEF DYNAMIC_LINK}
  1796. var
  1797.   _MsiInstallMissingComponent: Pointer;
  1798. function MsiInstallMissingComponent;
  1799. begin
  1800.   GetProcedureAddress(_MsiInstallMissingComponent, msilib, 'MsiInstallMissingComponentA');
  1801.   asm
  1802.     mov esp, ebp
  1803.     pop ebp
  1804.     jmp [_MsiInstallMissingComponent]
  1805.   end;
  1806. end;
  1807. {$ELSE}
  1808. function MsiInstallMissingComponent; external msilib name 'MsiInstallMissingComponentA';
  1809. {$ENDIF DYNAMIC_LINK}
  1810. {$ENDIF}
  1811. {$IFDEF DYNAMIC_LINK}
  1812. var
  1813.   _MsiInstallMissingFileA: Pointer;
  1814. function MsiInstallMissingFileA;
  1815. begin
  1816.   GetProcedureAddress(_MsiInstallMissingFileA, msilib, 'MsiInstallMissingFileA');
  1817.   asm
  1818.     mov esp, ebp
  1819.     pop ebp
  1820.     jmp [_MsiInstallMissingFileA]
  1821.   end;
  1822. end;
  1823. {$ELSE}
  1824. function MsiInstallMissingFileA; external msilib name 'MsiInstallMissingFileA';
  1825. {$ENDIF DYNAMIC_LINK}
  1826. {$IFDEF DYNAMIC_LINK}
  1827. var
  1828.   _MsiInstallMissingFileW: Pointer;
  1829. function MsiInstallMissingFileW;
  1830. begin
  1831.   GetProcedureAddress(_MsiInstallMissingFileW, msilib, 'MsiInstallMissingFileW');
  1832.   asm
  1833.     mov esp, ebp
  1834.     pop ebp
  1835.     jmp [_MsiInstallMissingFileW]
  1836.   end;
  1837. end;
  1838. {$ELSE}
  1839. function MsiInstallMissingFileW; external msilib name 'MsiInstallMissingFileW';
  1840. {$ENDIF DYNAMIC_LINK}
  1841. {$IFDEF UNICODE}
  1842. {$IFDEF DYNAMIC_LINK}
  1843. var
  1844.   _MsiInstallMissingFile: Pointer;
  1845. function MsiInstallMissingFile;
  1846. begin
  1847.   GetProcedureAddress(_MsiInstallMissingFile, msilib, 'MsiInstallMissingFileW');
  1848.   asm
  1849.     mov esp, ebp
  1850.     pop ebp
  1851.     jmp [_MsiInstallMissingFile]
  1852.   end;
  1853. end;
  1854. {$ELSE}
  1855. function MsiInstallMissingFile; external msilib name 'MsiInstallMissingFileW';
  1856. {$ENDIF DYNAMIC_LINK}
  1857. {$ELSE}
  1858. {$IFDEF DYNAMIC_LINK}
  1859. var
  1860.   _MsiInstallMissingFile: Pointer;
  1861. function MsiInstallMissingFile;
  1862. begin
  1863.   GetProcedureAddress(_MsiInstallMissingFile, msilib, 'MsiInstallMissingFileA');
  1864.   asm
  1865.     mov esp, ebp
  1866.     pop ebp
  1867.     jmp [_MsiInstallMissingFile]
  1868.   end;
  1869. end;
  1870. {$ELSE}
  1871. function MsiInstallMissingFile; external msilib name 'MsiInstallMissingFileA';
  1872. {$ENDIF DYNAMIC_LINK}
  1873. {$ENDIF}
  1874. {$IFDEF DYNAMIC_LINK}
  1875. var
  1876.   _MsiLocateComponentA: Pointer;
  1877. function MsiLocateComponentA;
  1878. begin
  1879.   GetProcedureAddress(_MsiLocateComponentA, msilib, 'MsiLocateComponentA');
  1880.   asm
  1881.     mov esp, ebp
  1882.     pop ebp
  1883.     jmp [_MsiLocateComponentA]
  1884.   end;
  1885. end;
  1886. {$ELSE}
  1887. function MsiLocateComponentA; external msilib name 'MsiLocateComponentA';
  1888. {$ENDIF DYNAMIC_LINK}
  1889. {$IFDEF DYNAMIC_LINK}
  1890. var
  1891.   _MsiLocateComponentW: Pointer;
  1892. function MsiLocateComponentW;
  1893. begin
  1894.   GetProcedureAddress(_MsiLocateComponentW, msilib, 'MsiLocateComponentW');
  1895.   asm
  1896.     mov esp, ebp
  1897.     pop ebp
  1898.     jmp [_MsiLocateComponentW]
  1899.   end;
  1900. end;
  1901. {$ELSE}
  1902. function MsiLocateComponentW; external msilib name 'MsiLocateComponentW';
  1903. {$ENDIF DYNAMIC_LINK}
  1904. {$IFDEF UNICODE}
  1905. {$IFDEF DYNAMIC_LINK}
  1906. var
  1907.   _MsiLocateComponent: Pointer;
  1908. function MsiLocateComponent;
  1909. begin
  1910.   GetProcedureAddress(_MsiLocateComponent, msilib, 'MsiLocateComponentW');
  1911.   asm
  1912.     mov esp, ebp
  1913.     pop ebp
  1914.     jmp [_MsiLocateComponent]
  1915.   end;
  1916. end;
  1917. {$ELSE}
  1918. function MsiLocateComponent; external msilib name 'MsiLocateComponentW';
  1919. {$ENDIF DYNAMIC_LINK}
  1920. {$ELSE}
  1921. {$IFDEF DYNAMIC_LINK}
  1922. var
  1923.   _MsiLocateComponent: Pointer;
  1924. function MsiLocateComponent;
  1925. begin
  1926.   GetProcedureAddress(_MsiLocateComponent, msilib, 'MsiLocateComponentA');
  1927.   asm
  1928.     mov esp, ebp
  1929.     pop ebp
  1930.     jmp [_MsiLocateComponent]
  1931.   end;
  1932. end;
  1933. {$ELSE}
  1934. function MsiLocateComponent; external msilib name 'MsiLocateComponentA';
  1935. {$ENDIF DYNAMIC_LINK}
  1936. {$ENDIF}
  1937. {$IFDEF WIN32_MSI_110}
  1938. {$IFDEF DYNAMIC_LINK}
  1939. var
  1940.   _MsiSourceListClearAllA: Pointer;
  1941. function MsiSourceListClearAllA;
  1942. begin
  1943.   GetProcedureAddress(_MsiSourceListClearAllA, msilib, 'MsiSourceListClearAllA');
  1944.   asm
  1945.     mov esp, ebp
  1946.     pop ebp
  1947.     jmp [_MsiSourceListClearAllA]
  1948.   end;
  1949. end;
  1950. {$ELSE}
  1951. function MsiSourceListClearAllA; external msilib name 'MsiSourceListClearAllA';
  1952. {$ENDIF DYNAMIC_LINK}
  1953. {$IFDEF DYNAMIC_LINK}
  1954. var
  1955.   _MsiSourceListClearAllW: Pointer;
  1956. function MsiSourceListClearAllW;
  1957. begin
  1958.   GetProcedureAddress(_MsiSourceListClearAllW, msilib, 'MsiSourceListClearAllW');
  1959.   asm
  1960.     mov esp, ebp
  1961.     pop ebp
  1962.     jmp [_MsiSourceListClearAllW]
  1963.   end;
  1964. end;
  1965. {$ELSE}
  1966. function MsiSourceListClearAllW; external msilib name 'MsiSourceListClearAllW';
  1967. {$ENDIF DYNAMIC_LINK}
  1968. {$IFDEF UNICODE}
  1969. {$IFDEF DYNAMIC_LINK}
  1970. var
  1971.   _MsiSourceListClearAll: Pointer;
  1972. function MsiSourceListClearAll;
  1973. begin
  1974.   GetProcedureAddress(_MsiSourceListClearAll, msilib, 'MsiSourceListClearAllW');
  1975.   asm
  1976.     mov esp, ebp
  1977.     pop ebp
  1978.     jmp [_MsiSourceListClearAll]
  1979.   end;
  1980. end;
  1981. {$ELSE}
  1982. function MsiSourceListClearAll; external msilib name 'MsiSourceListClearAllW';
  1983. {$ENDIF DYNAMIC_LINK}
  1984. {$ELSE}
  1985. {$IFDEF DYNAMIC_LINK}
  1986. var
  1987.   _MsiSourceListClearAll: Pointer;
  1988. function MsiSourceListClearAll;
  1989. begin
  1990.   GetProcedureAddress(_MsiSourceListClearAll, msilib, 'MsiSourceListClearAllA');
  1991.   asm
  1992.     mov esp, ebp
  1993.     pop ebp
  1994.     jmp [_MsiSourceListClearAll]
  1995.   end;
  1996. end;
  1997. {$ELSE}
  1998. function MsiSourceListClearAll; external msilib name 'MsiSourceListClearAllA';
  1999. {$ENDIF DYNAMIC_LINK}
  2000. {$ENDIF}
  2001. {$IFDEF DYNAMIC_LINK}
  2002. var
  2003.   _MsiSourceListAddSourceA: Pointer;
  2004. function MsiSourceListAddSourceA;
  2005. begin
  2006.   GetProcedureAddress(_MsiSourceListAddSourceA, msilib, 'MsiSourceListAddSourceA');
  2007.   asm
  2008.     mov esp, ebp
  2009.     pop ebp
  2010.     jmp [_MsiSourceListAddSourceA]
  2011.   end;
  2012. end;
  2013. {$ELSE}
  2014. function MsiSourceListAddSourceA; external msilib name 'MsiSourceListAddSourceA';
  2015. {$ENDIF DYNAMIC_LINK}
  2016. {$IFDEF DYNAMIC_LINK}
  2017. var
  2018.   _MsiSourceListAddSourceW: Pointer;
  2019. function MsiSourceListAddSourceW;
  2020. begin
  2021.   GetProcedureAddress(_MsiSourceListAddSourceW, msilib, 'MsiSourceListAddSourceW');
  2022.   asm
  2023.     mov esp, ebp
  2024.     pop ebp
  2025.     jmp [_MsiSourceListAddSourceW]
  2026.   end;
  2027. end;
  2028. {$ELSE}
  2029. function MsiSourceListAddSourceW; external msilib name 'MsiSourceListAddSourceW';
  2030. {$ENDIF DYNAMIC_LINK}
  2031. {$IFDEF UNICODE}
  2032. {$IFDEF DYNAMIC_LINK}
  2033. var
  2034.   _MsiSourceListAddSource: Pointer;
  2035. function MsiSourceListAddSource;
  2036. begin
  2037.   GetProcedureAddress(_MsiSourceListAddSource, msilib, 'MsiSourceListAddSourceW');
  2038.   asm
  2039.     mov esp, ebp
  2040.     pop ebp
  2041.     jmp [_MsiSourceListAddSource]
  2042.   end;
  2043. end;
  2044. {$ELSE}
  2045. function MsiSourceListAddSource; external msilib name 'MsiSourceListAddSourceW';
  2046. {$ENDIF DYNAMIC_LINK}
  2047. {$ELSE}
  2048. {$IFDEF DYNAMIC_LINK}
  2049. var
  2050.   _MsiSourceListAddSource: Pointer;
  2051. function MsiSourceListAddSource;
  2052. begin
  2053.   GetProcedureAddress(_MsiSourceListAddSource, msilib, 'MsiSourceListAddSourceA');
  2054.   asm
  2055.     mov esp, ebp
  2056.     pop ebp
  2057.     jmp [_MsiSourceListAddSource]
  2058.   end;
  2059. end;
  2060. {$ELSE}
  2061. function MsiSourceListAddSource; external msilib name 'MsiSourceListAddSourceA';
  2062. {$ENDIF DYNAMIC_LINK}
  2063. {$ENDIF}
  2064. {$IFDEF DYNAMIC_LINK}
  2065. var
  2066.   _MsiSourceListForceResolutionA: Pointer;
  2067. function MsiSourceListForceResolutionA;
  2068. begin
  2069.   GetProcedureAddress(_MsiSourceListForceResolutionA, msilib, 'MsiSourceListForceResolutionA');
  2070.   asm
  2071.     mov esp, ebp
  2072.     pop ebp
  2073.     jmp [_MsiSourceListForceResolutionA]
  2074.   end;
  2075. end;
  2076. {$ELSE}
  2077. function MsiSourceListForceResolutionA; external msilib name 'MsiSourceListForceResolutionA';
  2078. {$ENDIF DYNAMIC_LINK}
  2079. {$IFDEF DYNAMIC_LINK}
  2080. var
  2081.   _MsiSourceListForceResolutionW: Pointer;
  2082. function MsiSourceListForceResolutionW;
  2083. begin
  2084.   GetProcedureAddress(_MsiSourceListForceResolutionW, msilib, 'MsiSourceListForceResolutionW');
  2085.   asm
  2086.     mov esp, ebp
  2087.     pop ebp
  2088.     jmp [_MsiSourceListForceResolutionW]
  2089.   end;
  2090. end;
  2091. {$ELSE}
  2092. function MsiSourceListForceResolutionW; external msilib name 'MsiSourceListForceResolutionW';
  2093. {$ENDIF DYNAMIC_LINK}
  2094. {$IFDEF UNICODE}
  2095. {$IFDEF DYNAMIC_LINK}
  2096. var
  2097.   _MsiSourceListForceResolution: Pointer;
  2098. function MsiSourceListForceResolution;
  2099. begin
  2100.   GetProcedureAddress(_MsiSourceListForceResolution, msilib, 'MsiSourceListForceResolutionW');
  2101.   asm
  2102.     mov esp, ebp
  2103.     pop ebp
  2104.     jmp [_MsiSourceListForceResolution]
  2105.   end;
  2106. end;
  2107. {$ELSE}
  2108. function MsiSourceListForceResolution; external msilib name 'MsiSourceListForceResolutionW';
  2109. {$ENDIF DYNAMIC_LINK}
  2110. {$ELSE}
  2111. {$IFDEF DYNAMIC_LINK}
  2112. var
  2113.   _MsiSourceListForceResolution: Pointer;
  2114. function MsiSourceListForceResolution;
  2115. begin
  2116.   GetProcedureAddress(_MsiSourceListForceResolution, msilib, 'MsiSourceListForceResolutionA');
  2117.   asm
  2118.     mov esp, ebp
  2119.     pop ebp
  2120.     jmp [_MsiSourceListForceResolution]
  2121.   end;
  2122. end;
  2123. {$ELSE}
  2124. function MsiSourceListForceResolution; external msilib name 'MsiSourceListForceResolutionA';
  2125. {$ENDIF DYNAMIC_LINK}
  2126. {$ENDIF}
  2127. {$ENDIF WIN32_MSI_110}
  2128. {$IFDEF DYNAMIC_LINK}
  2129. var
  2130.   _MsiGetFileVersionA: Pointer;
  2131. function MsiGetFileVersionA;
  2132. begin
  2133.   GetProcedureAddress(_MsiGetFileVersionA, msilib, 'MsiGetFileVersionA');
  2134.   asm
  2135.     mov esp, ebp
  2136.     pop ebp
  2137.     jmp [_MsiGetFileVersionA]
  2138.   end;
  2139. end;
  2140. {$ELSE}
  2141. function MsiGetFileVersionA; external msilib name 'MsiGetFileVersionA';
  2142. {$ENDIF DYNAMIC_LINK}
  2143. {$IFDEF DYNAMIC_LINK}
  2144. var
  2145.   _MsiGetFileVersionW: Pointer;
  2146. function MsiGetFileVersionW;
  2147. begin
  2148.   GetProcedureAddress(_MsiGetFileVersionW, msilib, 'MsiGetFileVersionW');
  2149.   asm
  2150.     mov esp, ebp
  2151.     pop ebp
  2152.     jmp [_MsiGetFileVersionW]
  2153.   end;
  2154. end;
  2155. {$ELSE}
  2156. function MsiGetFileVersionW; external msilib name 'MsiGetFileVersionW';
  2157. {$ENDIF DYNAMIC_LINK}
  2158. {$IFDEF UNICODE}
  2159. {$IFDEF DYNAMIC_LINK}
  2160. var
  2161.   _MsiGetFileVersion: Pointer;
  2162. function MsiGetFileVersion;
  2163. begin
  2164.   GetProcedureAddress(_MsiGetFileVersion, msilib, 'MsiGetFileVersionW');
  2165.   asm
  2166.     mov esp, ebp
  2167.     pop ebp
  2168.     jmp [_MsiGetFileVersion]
  2169.   end;
  2170. end;
  2171. {$ELSE}
  2172. function MsiGetFileVersion; external msilib name 'MsiGetFileVersionW';
  2173. {$ENDIF DYNAMIC_LINK}
  2174. {$ELSE}
  2175. {$IFDEF DYNAMIC_LINK}
  2176. var
  2177.   _MsiGetFileVersion: Pointer;
  2178. function MsiGetFileVersion;
  2179. begin
  2180.   GetProcedureAddress(_MsiGetFileVersion, msilib, 'MsiGetFileVersionA');
  2181.   asm
  2182.     mov esp, ebp
  2183.     pop ebp
  2184.     jmp [_MsiGetFileVersion]
  2185.   end;
  2186. end;
  2187. {$ELSE}
  2188. function MsiGetFileVersion; external msilib name 'MsiGetFileVersionA';
  2189. {$ENDIF DYNAMIC_LINK}
  2190. {$ENDIF}
  2191. {$IFDEF DYNAMIC_LINK}
  2192. var
  2193.   _MsiGetFileHashA: Pointer;
  2194. function MsiGetFileHashA;
  2195. begin
  2196.   GetProcedureAddress(_MsiGetFileHashA, msilib, 'MsiGetFileHashA');
  2197.   asm
  2198.     mov esp, ebp
  2199.     pop ebp
  2200.     jmp [_MsiGetFileHashA]
  2201.   end;
  2202. end;
  2203. {$ELSE}
  2204. function MsiGetFileHashA; external msilib name 'MsiGetFileHashA';
  2205. {$ENDIF DYNAMIC_LINK}
  2206. {$IFDEF DYNAMIC_LINK}
  2207. var
  2208.   _MsiGetFileHashW: Pointer;
  2209. function MsiGetFileHashW;
  2210. begin
  2211.   GetProcedureAddress(_MsiGetFileHashW, msilib, 'MsiGetFileHashW');
  2212.   asm
  2213.     mov esp, ebp
  2214.     pop ebp
  2215.     jmp [_MsiGetFileHashW]
  2216.   end;
  2217. end;
  2218. {$ELSE}
  2219. function MsiGetFileHashW; external msilib name 'MsiGetFileHashW';
  2220. {$ENDIF DYNAMIC_LINK}
  2221. {$IFDEF UNICODE}
  2222. {$IFDEF DYNAMIC_LINK}
  2223. var
  2224.   _MsiGetFileHash: Pointer;
  2225. function MsiGetFileHash;
  2226. begin
  2227.   GetProcedureAddress(_MsiGetFileHash, msilib, 'MsiGetFileHashW');
  2228.   asm
  2229.     mov esp, ebp
  2230.     pop ebp
  2231.     jmp [_MsiGetFileHash]
  2232.   end;
  2233. end;
  2234. {$ELSE}
  2235. function MsiGetFileHash; external msilib name 'MsiGetFileHashW';
  2236. {$ENDIF DYNAMIC_LINK}
  2237. {$ELSE}
  2238. {$IFDEF DYNAMIC_LINK}
  2239. var
  2240.   _MsiGetFileHash: Pointer;
  2241. function MsiGetFileHash;
  2242. begin
  2243.   GetProcedureAddress(_MsiGetFileHash, msilib, 'MsiGetFileHashA');
  2244.   asm
  2245.     mov esp, ebp
  2246.     pop ebp
  2247.     jmp [_MsiGetFileHash]
  2248.   end;
  2249. end;
  2250. {$ELSE}
  2251. function MsiGetFileHash; external msilib name 'MsiGetFileHashA';
  2252. {$ENDIF DYNAMIC_LINK}
  2253. {$ENDIF}
  2254. {$IFDEF DYNAMIC_LINK}
  2255. var
  2256.   _MsiGetFileSignatureInformationA: Pointer;
  2257. function MsiGetFileSignatureInformationA;
  2258. begin
  2259.   GetProcedureAddress(_MsiGetFileSignatureInformationA, msilib, 'MsiGetFileSignatureInformationA');
  2260.   asm
  2261.     mov esp, ebp
  2262.     pop ebp
  2263.     jmp [_MsiGetFileSignatureInformationA]
  2264.   end;
  2265. end;
  2266. {$ELSE}
  2267. function MsiGetFileSignatureInformationA; external msilib name 'MsiGetFileSignatureInformationA';
  2268. {$ENDIF DYNAMIC_LINK}
  2269. {$IFDEF DYNAMIC_LINK}
  2270. var
  2271.   _MsiGetFileSignatureInformationW: Pointer;
  2272. function MsiGetFileSignatureInformationW;
  2273. begin
  2274.   GetProcedureAddress(_MsiGetFileSignatureInformationW, msilib, 'MsiGetFileSignatureInformationW');
  2275.   asm
  2276.     mov esp, ebp
  2277.     pop ebp
  2278.     jmp [_MsiGetFileSignatureInformationW]
  2279.   end;
  2280. end;
  2281. {$ELSE}
  2282. function MsiGetFileSignatureInformationW; external msilib name 'MsiGetFileSignatureInformationW';
  2283. {$ENDIF DYNAMIC_LINK}
  2284. {$IFDEF UNICODE}
  2285. {$IFDEF DYNAMIC_LINK}
  2286. var
  2287.   _MsiGetFileSignatureInformation: Pointer;
  2288. function MsiGetFileSignatureInformation;
  2289. begin
  2290.   GetProcedureAddress(_MsiGetFileSignatureInformation, msilib, 'MsiGetFileSignatureInformationW');
  2291.   asm
  2292.     mov esp, ebp
  2293.     pop ebp
  2294.     jmp [_MsiGetFileSignatureInformation]
  2295.   end;
  2296. end;
  2297. {$ELSE}
  2298. function MsiGetFileSignatureInformation; external msilib name 'MsiGetFileSignatureInformationW';
  2299. {$ENDIF DYNAMIC_LINK}
  2300. {$ELSE}
  2301. {$IFDEF DYNAMIC_LINK}
  2302. var
  2303.   _MsiGetFileSignatureInformation: Pointer;
  2304. function MsiGetFileSignatureInformation;
  2305. begin
  2306.   GetProcedureAddress(_MsiGetFileSignatureInformation, msilib, 'MsiGetFileSignatureInformationA');
  2307.   asm
  2308.     mov esp, ebp
  2309.     pop ebp
  2310.     jmp [_MsiGetFileSignatureInformation]
  2311.   end;
  2312. end;
  2313. {$ELSE}
  2314. function MsiGetFileSignatureInformation; external msilib name 'MsiGetFileSignatureInformationA';
  2315. {$ENDIF DYNAMIC_LINK}
  2316. {$ENDIF}
  2317. {$IFDEF WIN32_MSI_110}
  2318. {$IFDEF DYNAMIC_LINK}
  2319. var
  2320.   _MsiGetShortcutTargetA: Pointer;
  2321. function MsiGetShortcutTargetA;
  2322. begin
  2323.   GetProcedureAddress(_MsiGetShortcutTargetA, msilib, 'MsiGetShortcutTargetA');
  2324.   asm
  2325.     mov esp, ebp
  2326.     pop ebp
  2327.     jmp [_MsiGetShortcutTargetA]
  2328.   end;
  2329. end;
  2330. {$ELSE}
  2331. function MsiGetShortcutTargetA; external msilib name 'MsiGetShortcutTargetA';
  2332. {$ENDIF DYNAMIC_LINK}
  2333. {$IFDEF DYNAMIC_LINK}
  2334. var
  2335.   _MsiGetShortcutTargetW: Pointer;
  2336. function MsiGetShortcutTargetW;
  2337. begin
  2338.   GetProcedureAddress(_MsiGetShortcutTargetW, msilib, 'MsiGetShortcutTargetW');
  2339.   asm
  2340.     mov esp, ebp
  2341.     pop ebp
  2342.     jmp [_MsiGetShortcutTargetW]
  2343.   end;
  2344. end;
  2345. {$ELSE}
  2346. function MsiGetShortcutTargetW; external msilib name 'MsiGetShortcutTargetW';
  2347. {$ENDIF DYNAMIC_LINK}
  2348. {$IFDEF UNICODE}
  2349. {$IFDEF DYNAMIC_LINK}
  2350. var
  2351.   _MsiGetShortcutTarget: Pointer;
  2352. function MsiGetShortcutTarget;
  2353. begin
  2354.   GetProcedureAddress(_MsiGetShortcutTarget, msilib, 'MsiGetShortcutTargetW');
  2355.   asm
  2356.     mov esp, ebp
  2357.     pop ebp
  2358.     jmp [_MsiGetShortcutTarget]
  2359.   end;
  2360. end;
  2361. {$ELSE}
  2362. function MsiGetShortcutTarget; external msilib name 'MsiGetShortcutTargetW';
  2363. {$ENDIF DYNAMIC_LINK}
  2364. {$ELSE}
  2365. {$IFDEF DYNAMIC_LINK}
  2366. var
  2367.   _MsiGetShortcutTarget: Pointer;
  2368. function MsiGetShortcutTarget;
  2369. begin
  2370.   GetProcedureAddress(_MsiGetShortcutTarget, msilib, 'MsiGetShortcutTargetA');
  2371.   asm
  2372.     mov esp, ebp
  2373.     pop ebp
  2374.     jmp [_MsiGetShortcutTarget]
  2375.   end;
  2376. end;
  2377. {$ELSE}
  2378. function MsiGetShortcutTarget; external msilib name 'MsiGetShortcutTargetA';
  2379. {$ENDIF DYNAMIC_LINK}
  2380. {$ENDIF}
  2381. {$ENDIF}
  2382. {$IFDEF DYNAMIC_LINK}
  2383. var
  2384.   _MsiIsProductElevatedA: Pointer;
  2385. function MsiIsProductElevatedA;
  2386. begin
  2387.   GetProcedureAddress(_MsiIsProductElevatedA, msilib, 'MsiIsProductElevatedA');
  2388.   asm
  2389.     mov esp, ebp
  2390.     pop ebp
  2391.     jmp [_MsiIsProductElevatedA]
  2392.   end;
  2393. end;
  2394. {$ELSE}
  2395. function MsiIsProductElevatedA; external msilib name 'MsiIsProductElevatedA';
  2396. {$ENDIF DYNAMIC_LINK}
  2397. {$IFDEF DYNAMIC_LINK}
  2398. var
  2399.   _MsiIsProductElevatedW: Pointer;
  2400. function MsiIsProductElevatedW;
  2401. begin
  2402.   GetProcedureAddress(_MsiIsProductElevatedW, msilib, 'MsiIsProductElevatedW');
  2403.   asm
  2404.     mov esp, ebp
  2405.     pop ebp
  2406.     jmp [_MsiIsProductElevatedW]
  2407.   end;
  2408. end;
  2409. {$ELSE}
  2410. function MsiIsProductElevatedW; external msilib name 'MsiIsProductElevatedW';
  2411. {$ENDIF DYNAMIC_LINK}
  2412. {$IFDEF UNICODE}
  2413. {$IFDEF DYNAMIC_LINK}
  2414. var
  2415.   _MsiIsProductElevated: Pointer;
  2416. function MsiIsProductElevated;
  2417. begin
  2418.   GetProcedureAddress(_MsiIsProductElevated, msilib, 'MsiIsProductElevatedW');
  2419.   asm
  2420.     mov esp, ebp
  2421.     pop ebp
  2422.     jmp [_MsiIsProductElevated]
  2423.   end;
  2424. end;
  2425. {$ELSE}
  2426. function MsiIsProductElevated; external msilib name 'MsiIsProductElevatedW';
  2427. {$ENDIF DYNAMIC_LINK}
  2428. {$ELSE}
  2429. {$IFDEF DYNAMIC_LINK}
  2430. var
  2431.   _MsiIsProductElevated: Pointer;
  2432. function MsiIsProductElevated;
  2433. begin
  2434.   GetProcedureAddress(_MsiIsProductElevated, msilib, 'MsiIsProductElevatedA');
  2435.   asm
  2436.     mov esp, ebp
  2437.     pop ebp
  2438.     jmp [_MsiIsProductElevated]
  2439.   end;
  2440. end;
  2441. {$ELSE}
  2442. function MsiIsProductElevated; external msilib name 'MsiIsProductElevatedA';
  2443. {$ENDIF DYNAMIC_LINK}
  2444. {$ENDIF}
  2445. end.