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

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

Windows编程

开发平台：

Delphi

JwaMsiQuery.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Windows Installer 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: msiquery.h, released June 2000. The original Pascal    }
  9. { code is: MsiQuery.pas, released June 2001. 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 JwaMsiQuery;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "msiquery.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaMsi, JwaWinBase, JwaWinType;
  59. (*****************************************************************************
  60. *                                                                             *
  61. * MsiQuery.h - Interface to running installer for custom actions and tools    *
  62. *                                                                             *
  63. * Version 1.0 - 1.2                                                           *
  64. *                                                                             *
  65. * NOTES:  All buffers sizes are TCHAR count, null included only on input      *
  66. *         Return argument pointers may be null if not interested in value     *
  67. *         Returned handles of all types must be closed: MsiCloseHandle(h)     *
  68. *         Functions with UINT return type return a system error code          *
  69. *         Designated functions will set or clear the last error record,       *
  70. *         which is then accessible with MsiGetLastErrorRecord. However,       *
  71. *         the following argument errors do not register an error record:      *
  72. *         ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, ERROR_MORE_DATA.     *
  73. *                                                                             *
  74. * Copyright (c) 1999-2000, Microsoft Corp.      All rights reserved.          *
  75. *                                                                             *
  76. *****************************************************************************)
  78. const
  79.   MSI_NULL_INTEGER = DWORD($80000000);  // integer value reserved for null
  80.   {$EXTERNALSYM MSI_NULL_INTEGER}
  82. // MsiOpenDatabase persist predefine values, otherwise output database path is used
  84.   MSIDBOPEN_READONLY     = LPCTSTR(0);  // database open read-only, no persistent changes
  85.   {$EXTERNALSYM MSIDBOPEN_READONLY}
  86.   MSIDBOPEN_TRANSACT     = LPCTSTR(1);  // database read/write in transaction mode
  87.   {$EXTERNALSYM MSIDBOPEN_TRANSACT}
  88.   MSIDBOPEN_DIRECT       = LPCTSTR(2);  // database direct read/write without transaction
  89.   {$EXTERNALSYM MSIDBOPEN_DIRECT}
  90.   MSIDBOPEN_CREATE       = LPCTSTR(3);  // create new database, transact mode read/write
  91.   {$EXTERNALSYM MSIDBOPEN_CREATE}
  92.   MSIDBOPEN_CREATEDIRECT = LPCTSTR(4);  // create new database, direct mode read/write
  93.   {$EXTERNALSYM MSIDBOPEN_CREATEDIRECT}
  95.   {$IFDEF UNICODE}
  96.   MSIDBOPEN_PATCHFILE    = 32 div SizeOf(WideChar); // add flag to indicate patch file
  97.   {$ELSE}
  98.   MSIDBOPEN_PATCHFILE    = 32 div SizeOf(AnsiChar); // add flag to indicate patch file  
  99.   {$ENDIF}
  101.   MSIDBSTATE_ERROR    = DWORD(-1);  // invalid database handle
  102.   {$EXTERNALSYM MSIDBSTATE_ERROR}
  103.   MSIDBSTATE_READ     =  0;  // database open read-only, no persistent changes
  104.   {$EXTERNALSYM MSIDBSTATE_READ}
  105.   MSIDBSTATE_WRITE    =  1;  // database readable and updatable
  106.   {$EXTERNALSYM MSIDBSTATE_WRITE}
  108. type
  109.   MSIDBSTATE = DWORD;
  110.   {$EXTERNALSYM MSIDBSTATE}
  111.   TMsiDbState = MSIDBSTATE;
  113. const
  114.   MSIMODIFY_SEEK             = DWORD(-1);  // reposition to current record primary key
  115.   {$EXTERNALSYM MSIMODIFY_SEEK}
  116.   MSIMODIFY_REFRESH          = 0;  // refetch current record data
  117.   {$EXTERNALSYM MSIMODIFY_REFRESH}
  118.   MSIMODIFY_INSERT           = 1;  // insert new record, fails if matching key exists
  119.   {$EXTERNALSYM MSIMODIFY_INSERT}
  120.   MSIMODIFY_UPDATE           = 2;  // update existing non-key data of fetched record
  121.   {$EXTERNALSYM MSIMODIFY_UPDATE}
  122.   MSIMODIFY_ASSIGN           = 3;  // insert record, replacing any existing record
  123.   {$EXTERNALSYM MSIMODIFY_ASSIGN}
  124.   MSIMODIFY_REPLACE          = 4;  // update record, delete old if primary key edit
  125.   {$EXTERNALSYM MSIMODIFY_REPLACE}
  126.   MSIMODIFY_MERGE            = 5;  // fails if record with duplicate key not identical
  127.   {$EXTERNALSYM MSIMODIFY_MERGE}
  128.   MSIMODIFY_DELETE           = 6;  // remove row referenced by this record from table
  129.   {$EXTERNALSYM MSIMODIFY_DELETE}
  130.   MSIMODIFY_INSERT_TEMPORARY = 7;  // insert a temporary record
  131.   {$EXTERNALSYM MSIMODIFY_INSERT_TEMPORARY}
  132.   MSIMODIFY_VALIDATE         = 8;  // validate a fetched record
  133.   {$EXTERNALSYM MSIMODIFY_VALIDATE}
  134.   MSIMODIFY_VALIDATE_NEW     = 9;  // validate a new record
  135.   {$EXTERNALSYM MSIMODIFY_VALIDATE_NEW}
  136.   MSIMODIFY_VALIDATE_FIELD   = 10; // validate field(s) of an incomplete record
  137.   {$EXTERNALSYM MSIMODIFY_VALIDATE_FIELD}
  138.   MSIMODIFY_VALIDATE_DELETE  = 11; // validate before deleting record
  139.   {$EXTERNALSYM MSIMODIFY_VALIDATE_DELETE}
  141. type
  142.   MSIMODIFY = DWORD;
  143.   {$EXTERNALSYM MSIMODIFY}
  144.   TMsiModify = MSIMODIFY;
  146. const
  147.   MSICOLINFO_NAMES = 0;  // return column names
  148.   {$EXTERNALSYM MSICOLINFO_NAMES}
  149.   MSICOLINFO_TYPES = 1;  // return column definitions, datatype code followed by width
  150.   {$EXTERNALSYM MSICOLINFO_TYPES}
  152. type
  153.   MSICOLINFO = DWORD;
  154.   {$EXTERNALSYM MSICOLINFO}
  155.   TMsiColInfo = MSICOLINFO;
  157. const
  158.   MSICONDITION_FALSE = 0;  // expression evaluates to False
  159.   {$EXTERNALSYM MSICONDITION_FALSE}
  160.   MSICONDITION_TRUE  = 1;  // expression evaluates to True
  161.   {$EXTERNALSYM MSICONDITION_TRUE}
  162.   MSICONDITION_NONE  = 2;  // no expression present
  163.   {$EXTERNALSYM MSICONDITION_NONE}
  164.   MSICONDITION_ERROR = 3;  // syntax error in expression
  165.   {$EXTERNALSYM MSICONDITION_ERROR}
  167. type
  168.   MSICONDITION = DWORD;
  169.   {$EXTERNALSYM MSICONDITION}
  170.   TMsiCondition = MSICONDITION;
  172. const
  173.   MSICOSTTREE_SELFONLY = 0;
  174.   {$EXTERNALSYM MSICOSTTREE_SELFONLY}
  175.   MSICOSTTREE_CHILDREN = 1;
  176.   {$EXTERNALSYM MSICOSTTREE_CHILDREN}
  177.   MSICOSTTREE_PARENTS  = 2;
  178.   {$EXTERNALSYM MSICOSTTREE_PARENTS}
  179.   MSICOSTTREE_RESERVED = 3; // Reserved for future use
  180.   {$EXTERNALSYM MSICOSTTREE_RESERVED}
  182. type
  183.   MSICOSTTREE = DWORD;
  184.   {$EXTERNALSYM MSICOSTTREE}
  185.   TMsiCostTree = MSICOSTTREE;
  187. const
  188.   MSIDBERROR_INVALIDARG        = DWORD(-3); //  invalid argument
  189.   {$EXTERNALSYM MSIDBERROR_INVALIDARG}
  190.   MSIDBERROR_MOREDATA          = DWORD(-2); //  buffer too small
  191.   {$EXTERNALSYM MSIDBERROR_MOREDATA}
  192.   MSIDBERROR_FUNCTIONERROR     = DWORD(-1); //  function error
  193.   {$EXTERNALSYM MSIDBERROR_FUNCTIONERROR}
  194.   MSIDBERROR_NOERROR           = 0;  //  no error
  195.   {$EXTERNALSYM MSIDBERROR_NOERROR}
  196.   MSIDBERROR_DUPLICATEKEY      = 1;  //  new record duplicates primary keys of existing record in table
  197.   {$EXTERNALSYM MSIDBERROR_DUPLICATEKEY}
  198.   MSIDBERROR_REQUIRED          = 2;  //  non-nullable column, no null values allowed
  199.   {$EXTERNALSYM MSIDBERROR_REQUIRED}
  200.   MSIDBERROR_BADLINK           = 3;  //  corresponding record in foreign table not found
  201.   {$EXTERNALSYM MSIDBERROR_BADLINK}
  202.   MSIDBERROR_OVERFLOW          = 4;  //  data greater than maximum value allowed
  203.   {$EXTERNALSYM MSIDBERROR_OVERFLOW}
  204.   MSIDBERROR_UNDERFLOW         = 5;  //  data less than minimum value allowed
  205.   {$EXTERNALSYM MSIDBERROR_UNDERFLOW}
  206.   MSIDBERROR_NOTINSET          = 6;  //  data not a member of the values permitted in the set
  207.   {$EXTERNALSYM MSIDBERROR_NOTINSET}
  208.   MSIDBERROR_BADVERSION        = 7;  //  invalid version string
  209.   {$EXTERNALSYM MSIDBERROR_BADVERSION}
  210.   MSIDBERROR_BADCASE           = 8;  //  invalid case, must be all upper-case or all lower-case
  211.   {$EXTERNALSYM MSIDBERROR_BADCASE}
  212.   MSIDBERROR_BADGUID           = 9;  //  invalid GUID
  213.   {$EXTERNALSYM MSIDBERROR_BADGUID}
  214.   MSIDBERROR_BADWILDCARD       = 10; //  invalid wildcardfilename or use of wildcards
  215.   {$EXTERNALSYM MSIDBERROR_BADWILDCARD}
  216.   MSIDBERROR_BADIDENTIFIER     = 11; //  bad identifier
  217.   {$EXTERNALSYM MSIDBERROR_BADIDENTIFIER}
  218.   MSIDBERROR_BADLANGUAGE       = 12; //  bad language Id(s)
  219.   {$EXTERNALSYM MSIDBERROR_BADLANGUAGE}
  220.   MSIDBERROR_BADFILENAME       = 13; //  bad filename
  221.   {$EXTERNALSYM MSIDBERROR_BADFILENAME}
  222.   MSIDBERROR_BADPATH           = 14; //  bad path
  223.   {$EXTERNALSYM MSIDBERROR_BADPATH}
  224.   MSIDBERROR_BADCONDITION      = 15; //  bad conditional statement
  225.   {$EXTERNALSYM MSIDBERROR_BADCONDITION}
  226.   MSIDBERROR_BADFORMATTED      = 16; //  bad format string
  227.   {$EXTERNALSYM MSIDBERROR_BADFORMATTED}
  228.   MSIDBERROR_BADTEMPLATE       = 17; //  bad template string
  229.   {$EXTERNALSYM MSIDBERROR_BADTEMPLATE}
  230.   MSIDBERROR_BADDEFAULTDIR     = 18; //  bad string in DefaultDir column of Directory table
  231.   {$EXTERNALSYM MSIDBERROR_BADDEFAULTDIR}
  232.   MSIDBERROR_BADREGPATH        = 19; //  bad registry path string
  233.   {$EXTERNALSYM MSIDBERROR_BADREGPATH}
  234.   MSIDBERROR_BADCUSTOMSOURCE   = 20; //  bad string in CustomSource column of CustomAction table
  235.   {$EXTERNALSYM MSIDBERROR_BADCUSTOMSOURCE}
  236.   MSIDBERROR_BADPROPERTY       = 21; //  bad property string
  237.   {$EXTERNALSYM MSIDBERROR_BADPROPERTY}
  238.   MSIDBERROR_MISSINGDATA       = 22; //  _Validation table missing reference to column
  239.   {$EXTERNALSYM MSIDBERROR_MISSINGDATA}
  240.   MSIDBERROR_BADCATEGORY       = 23; //  Category column of _Validation table for column is invalid
  241.   {$EXTERNALSYM MSIDBERROR_BADCATEGORY}
  242.   MSIDBERROR_BADKEYTABLE       = 24; //  table in KeyTable column of _Validation table could not be found/loaded
  243.   {$EXTERNALSYM MSIDBERROR_BADKEYTABLE}
  244.   MSIDBERROR_BADMAXMINVALUES   = 25; //  value in MaxValue column of _Validation table is less than value in MinValue column
  245.   {$EXTERNALSYM MSIDBERROR_BADMAXMINVALUES}
  246.   MSIDBERROR_BADCABINET        = 26; //  bad cabinet name
  247.   {$EXTERNALSYM MSIDBERROR_BADCABINET}
  248.   MSIDBERROR_BADSHORTCUT       = 27; //  bad shortcut target
  249.   {$EXTERNALSYM MSIDBERROR_BADSHORTCUT}
  250.   MSIDBERROR_STRINGOVERFLOW    = 28; //  string overflow (greater than length allowed in column def)
  251.   {$EXTERNALSYM MSIDBERROR_STRINGOVERFLOW}
  252.   MSIDBERROR_BADLOCALIZEATTRIB = 29; //  invalid localization attribute (primary keys cannot be localized)
  253.   {$EXTERNALSYM MSIDBERROR_BADLOCALIZEATTRIB}
  255. type
  256.   MSIDBERROR = DWORD;
  257.   {$EXTERNALSYM MSIDBERROR}
  258.   TMsiDbError = MSIDBERROR;
  260. const
  261.   MSIRUNMODE_ADMIN           =  0; // admin mode install, else product install
  262.   {$EXTERNALSYM MSIRUNMODE_ADMIN}
  263.   MSIRUNMODE_ADVERTISE       =  1; // installing advertisements, else installing or updating product
  264.   {$EXTERNALSYM MSIRUNMODE_ADVERTISE}
  265.   MSIRUNMODE_MAINTENANCE     =  2; // modifying an existing installation, else new installation
  266.   {$EXTERNALSYM MSIRUNMODE_MAINTENANCE}
  267.   MSIRUNMODE_ROLLBACKENABLED =  3; // rollback is enabled
  268.   {$EXTERNALSYM MSIRUNMODE_ROLLBACKENABLED}
  269.   MSIRUNMODE_LOGENABLED      =  4; // log file active, enabled prior to install session
  270.   {$EXTERNALSYM MSIRUNMODE_LOGENABLED}
  271.   MSIRUNMODE_OPERATIONS      =  5; // spooling execute operations, else in determination phase
  272.   {$EXTERNALSYM MSIRUNMODE_OPERATIONS}
  273.   MSIRUNMODE_REBOOTATEND     =  6; // reboot needed after successful installation (settable)
  274.   {$EXTERNALSYM MSIRUNMODE_REBOOTATEND}
  275.   MSIRUNMODE_REBOOTNOW       =  7; // reboot needed to continue installation (settable)
  276.   {$EXTERNALSYM MSIRUNMODE_REBOOTNOW}
  277.   MSIRUNMODE_CABINET         =  8; // installing files from cabinets and files using Media table
  278.   {$EXTERNALSYM MSIRUNMODE_CABINET}
  279.   MSIRUNMODE_SOURCESHORTNAMES=  9; // source LongFileNames suppressed via PID_MSISOURCE summary property
  280.   {$EXTERNALSYM MSIRUNMODE_SOURCESHORTNAMES}
  281.   MSIRUNMODE_TARGETSHORTNAMES= 10; // target LongFileNames suppressed via SHORTFILENAMES property
  282.   {$EXTERNALSYM MSIRUNMODE_TARGETSHORTNAMES}
  283.   MSIRUNMODE_RESERVED11      = 11; // future use
  284.   {$EXTERNALSYM MSIRUNMODE_RESERVED11}
  285.   MSIRUNMODE_WINDOWS9X       = 12; // operating systems is Windows9?, else Windows NT
  286.   {$EXTERNALSYM MSIRUNMODE_WINDOWS9X}
  287.   MSIRUNMODE_ZAWENABLED      = 13; // operating system supports demand installation
  288.   {$EXTERNALSYM MSIRUNMODE_ZAWENABLED}
  289.   MSIRUNMODE_RESERVED14      = 14; // future use
  290.   {$EXTERNALSYM MSIRUNMODE_RESERVED14}
  291.   MSIRUNMODE_RESERVED15      = 15; // future use
  292.   {$EXTERNALSYM MSIRUNMODE_RESERVED15}
  293.   MSIRUNMODE_SCHEDULED       = 16; // custom action call from install script execution
  294.   {$EXTERNALSYM MSIRUNMODE_SCHEDULED}
  295.   MSIRUNMODE_ROLLBACK        = 17; // custom action call from rollback execution script
  296.   {$EXTERNALSYM MSIRUNMODE_ROLLBACK}
  297.   MSIRUNMODE_COMMIT          = 18; // custom action call from commit execution script
  298.   {$EXTERNALSYM MSIRUNMODE_COMMIT}
  300. type
  301.   MSIRUNMODE = DWORD;
  302.   {$EXTERNALSYM MSIRUNMODE}
  303.   TMsiRunMode = MSIRUNMODE;
  305. const
  306.   INSTALLMESSAGE_TYPEMASK = DWORD($FF000000);  // mask for type code
  307.   {$EXTERNALSYM INSTALLMESSAGE_TYPEMASK}
  309. // Note: INSTALLMESSAGE_ERROR, INSTALLMESSAGE_WARNING, INSTALLMESSAGE_USER are to or'd
  310. // with a message box style to indicate the buttons to display and return:
  311. // MB_OK,MB_OKCANCEL,MB_ABORTRETRYIGNORE,MB_YESNOCANCEL,MB_YESNO,MB_RETRYCANCEL
  312. // the default button (MB_DEFBUTTON1 is normal default):
  313. // MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3
  314. // and optionally an icon style:
  315. // MB_ICONERROR, MB_ICONQUESTION, MB_ICONWARNING, MB_ICONINFORMATION
  317. const
  318.   MSITRANSFORM_ERROR_ADDEXISTINGROW   = $00000001;
  319.   {$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGROW}
  320.   MSITRANSFORM_ERROR_DELMISSINGROW    = $00000002;
  321.   {$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGROW}
  322.   MSITRANSFORM_ERROR_ADDEXISTINGTABLE = $00000004;
  323.   {$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGTABLE}
  324.   MSITRANSFORM_ERROR_DELMISSINGTABLE  = $00000008;
  325.   {$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGTABLE}
  326.   MSITRANSFORM_ERROR_UPDATEMISSINGROW = $00000010;
  327.   {$EXTERNALSYM MSITRANSFORM_ERROR_UPDATEMISSINGROW}
  328.   MSITRANSFORM_ERROR_CHANGECODEPAGE   = $00000020;
  329.   {$EXTERNALSYM MSITRANSFORM_ERROR_CHANGECODEPAGE}
  330.   MSITRANSFORM_ERROR_VIEWTRANSFORM    = $00000100;
  331.   {$EXTERNALSYM MSITRANSFORM_ERROR_VIEWTRANSFORM}
  333. type
  334.   MSITRANSFORM_ERROR = DWORD;
  335.   {$EXTERNALSYM MSITRANSFORM_ERROR}
  336.   TMsiTransformError = MSITRANSFORM_ERROR;
  338. const
  339.   MSITRANSFORM_VALIDATE_LANGUAGE                   = $00000001;
  340.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_LANGUAGE}
  341.   MSITRANSFORM_VALIDATE_PRODUCT                    = $00000002;
  342.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_PRODUCT}
  343.   MSITRANSFORM_VALIDATE_PLATFORM                   = $00000004;
  344.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_PLATFORM}
  345.   MSITRANSFORM_VALIDATE_MAJORVERSION               = $00000008;
  346.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_MAJORVERSION}
  347.   MSITRANSFORM_VALIDATE_MINORVERSION               = $00000010;
  348.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_MINORVERSION}
  349.   MSITRANSFORM_VALIDATE_UPDATEVERSION              = $00000020;
  350.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_UPDATEVERSION}
  351.   MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION         = $00000040;
  352.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION}
  353.   MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION    = $00000080;
  354.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION}
  355.   MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION        = $00000100;
  356.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION}
  357.   MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION = $00000200;
  358.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION}
  359.   MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION      = $00000400;
  360.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION}
  361.   MSITRANSFORM_VALIDATE_UPGRADECODE                = $00000800;
  362.   {$EXTERNALSYM MSITRANSFORM_VALIDATE_UPGRADECODE}
  364. type
  365.   MSITRANSFORM_VALIDATE = DWORD;
  366.   {$EXTERNALSYM MSITRANSFORM_VALIDATE}
  367.   TMsiTransformValidate = MSITRANSFORM_VALIDATE;
  369. // -----------------------------------------------------------------------------
  370. // Installer database access functions
  371. // -----------------------------------------------------------------------------
  373. // Prepare a database query, creating a view object
  374. // Returns ERROR_SUCCESS if successful, and the view handle is returned,
  375. // else ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_BAD_QUERY_SYNTAX, ERROR_GEN_FAILURE
  376. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  378. function MsiDatabaseOpenViewA(hDatabase: MSIHANDLE; szQuery: LPCSTR; var phView: MSIHANDLE): UINT; stdcall;
  379. {$EXTERNALSYM MsiDatabaseOpenViewA}
  380. function MsiDatabaseOpenViewW(hDatabase: MSIHANDLE; szQuery: LPCWSTR; var phView: MSIHANDLE): UINT; stdcall;
  381. {$EXTERNALSYM MsiDatabaseOpenViewW}
  383. {$IFDEF UNICODE}
  384. function MsiDatabaseOpenView(hDatabase: MSIHANDLE; szQuery: LPCWSTR; var phView: MSIHANDLE): UINT; stdcall;
  385. {$EXTERNALSYM MsiDatabaseOpenView}
  386. {$ELSE}
  387. function MsiDatabaseOpenView(hDatabase: MSIHANDLE; szQuery: LPCSTR; var phView: MSIHANDLE): UINT; stdcall;
  388. {$EXTERNALSYM MsiDatabaseOpenView}
  389. {$ENDIF}
  391. // Returns the MSIDBERROR enum and name of the column corresponding to the error
  392. // Similar to a GetLastError function, but for the view. NOT the same as MsiGetLastErrorRecord
  393. // Returns errors of MsiViewModify.
  395. function MsiViewGetErrorA(hView: MSIHANDLE; szColumnNameBuffer: LPSTR;
  396.   var pcchBuf: DWORD): MSIDBERROR; stdcall;
  397. {$EXTERNALSYM MsiViewGetErrorA}
  398. function MsiViewGetErrorW(hView: MSIHANDLE; szColumnNameBuffer: LPWSTR;
  399.   var pcchBuf: DWORD): MSIDBERROR; stdcall;
  400. {$EXTERNALSYM MsiViewGetErrorW}
  402. {$IFDEF UNICODE}
  403. function MsiViewGetError(hView: MSIHANDLE; szColumnNameBuffer: LPWSTR;
  404.   var pcchBuf: DWORD): MSIDBERROR; stdcall;
  405. {$EXTERNALSYM MsiViewGetError}
  406. {$ELSE}
  407. function MsiViewGetError(hView: MSIHANDLE; szColumnNameBuffer: LPSTR;
  408.   var pcchBuf: DWORD): MSIDBERROR; stdcall;
  409. {$EXTERNALSYM MsiViewGetError}
  410. {$ENDIF}
  412. // Exectute the view query, supplying parameters as required
  413. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE
  414. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  416. function MsiViewExecute(hView: MSIHANDLE; hRecord: MSIHANDLE): UINT; stdcall;
  417. {$EXTERNALSYM MsiViewExecute}
  419. // Fetch the next sequential record from the view
  420. // Result is ERROR_SUCCESS if a row is found, and its handle is returned
  421. // else ERROR_NO_MORE_ITEMS if no records remain, and a null handle is returned
  422. // else result is error: ERROR_INVALID_HANDLE_STATE, ERROR_INVALID_HANDLE, ERROR_GEN_FAILURE
  424. function MsiViewFetch(hView: MSIHANDLE; var phRecord: MSIHANDLE): UINT; stdcall;
  425. {$EXTERNALSYM MsiViewFetch}
  427. // Modify a database record, parameters must match types in query columns
  428. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE, ERROR_ACCESS_DENIED
  429. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  431. function MsiViewModify(hView: MSIHANDLE; eModifyMode: MSIMODIFY; hRecord: MSIHANDLE): UINT; stdcall;
  432. {$EXTERNALSYM MsiViewModify}
  434. // Return the column names or specifications for the current view
  435. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, or ERROR_INVALID_HANDLE_STATE
  437. function MsiViewGetColumnInfo(hView: MSIHANDLE; eColumnInfo: MSICOLINFO;
  438.   var phRecord: MSIHANDLE): UINT; stdcall;
  439. {$EXTERNALSYM MsiViewGetColumnInfo}
  441. // Release the result set for an executed view, to allow re-execution
  442. // Only needs to be called if not all records have been fetched
  443. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE
  445. function MsiViewClose(hView: MSIHANDLE): UINT; stdcall;
  446. {$EXTERNALSYM MsiViewClose}
  448. // Return a record containing the names of all primary key columns for a given table
  449. // Returns an MSIHANDLE for a record containing the name of each column.
  450. // The field count of the record corresponds to the number of primary key columns.
  451. // Field [0] of the record contains the table name.
  452. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_TABLE
  454. function MsiDatabaseGetPrimaryKeysA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
  455.   var phRecord: MSIHANDLE): UINT; stdcall;
  456. {$EXTERNALSYM MsiDatabaseGetPrimaryKeysA}
  457. function MsiDatabaseGetPrimaryKeysW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
  458.   var phRecord: MSIHANDLE): UINT; stdcall;
  459. {$EXTERNALSYM MsiDatabaseGetPrimaryKeysW}
  461. {$IFDEF UNICODE}
  462. function MsiDatabaseGetPrimaryKeys(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
  463.   var phRecord: MSIHANDLE): UINT; stdcall;
  464. {$EXTERNALSYM MsiDatabaseGetPrimaryKeys}
  465. {$ELSE}
  466. function MsiDatabaseGetPrimaryKeys(hDatabase: MSIHANDLE; szTableName: LPCSTR;
  467.   var phRecord: MSIHANDLE): UINT; stdcall;
  468. {$EXTERNALSYM MsiDatabaseGetPrimaryKeys}
  469. {$ENDIF}
  471. // Return an enum defining the state of the table (temporary, unknown, or persistent).
  472. // Returns MSICONDITION_ERROR, MSICONDITION_FALSE, MSICONDITION_TRUE, MSICONDITION_NONE
  474. function MsiDatabaseIsTablePersistentA(hDatabase: MSIHANDLE; szTableName: LPCSTR): MSICONDITION; stdcall;
  475. {$EXTERNALSYM MsiDatabaseIsTablePersistentA}
  476. function MsiDatabaseIsTablePersistentW(hDatabase: MSIHANDLE; szTableName: LPCWSTR): MSICONDITION; stdcall;
  477. {$EXTERNALSYM MsiDatabaseIsTablePersistentW}
  479. {$IFDEF UNICODE}
  480. function MsiDatabaseIsTablePersistent(hDatabase: MSIHANDLE; szTableName: LPCWSTR): MSICONDITION; stdcall;
  481. {$EXTERNALSYM MsiDatabaseIsTablePersistent}
  482. {$ELSE}
  483. function MsiDatabaseIsTablePersistent(hDatabase: MSIHANDLE; szTableName: LPCSTR): MSICONDITION; stdcall;
  484. {$EXTERNALSYM MsiDatabaseIsTablePersistent}
  485. {$ENDIF}
  487. // --------------------------------------------------------------------------
  488. // Summary information stream management functions
  489. // --------------------------------------------------------------------------
  491. // Integer Property IDs:    1, 14, 15, 16, 19
  492. // DateTime Property IDs:   10, 11, 12, 13
  493. // Text Property IDs:       2, 3, 4, 5, 6, 7, 8, 9, 18
  494. // Unsupported Propery IDs: 0 (PID_DICTIONARY), 17 (PID_THUMBNAIL)
  496. // Obtain a handle for the _SummaryInformation stream for an MSI database
  497. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  499. function MsiGetSummaryInformationA(hDatabase: MSIHANDLE; szDatabasePath: LPCSTR;
  500.   uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
  501. {$EXTERNALSYM MsiGetSummaryInformationA}
  502. function MsiGetSummaryInformationW(hDatabase: MSIHANDLE; szDatabasePath: LPCWSTR;
  503.   uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
  504. {$EXTERNALSYM MsiGetSummaryInformationW}
  506. {$IFDEF UNICODE}
  507. function MsiGetSummaryInformation(hDatabase: MSIHANDLE; szDatabasePath: LPCWSTR;
  508.   uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
  509. {$EXTERNALSYM MsiGetSummaryInformation}
  510. {$ELSE}
  511. function MsiGetSummaryInformation(hDatabase: MSIHANDLE; szDatabasePath: LPCSTR;
  512.   uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
  513. {$EXTERNALSYM MsiGetSummaryInformation}
  514. {$ENDIF}
  516. // Obtain the number of existing properties in the SummaryInformation stream
  518. function MsiSummaryInfoGetPropertyCount(hSummaryInfo: MSIHANDLE; var puiPropertyCount: UINT): UINT; stdcall;
  519. {$EXTERNALSYM MsiSummaryInfoGetPropertyCount}
  521. // Set a single summary information property
  522. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY
  524. function MsiSummaryInfoSetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  525.   uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCSTR): UINT; stdcall;
  526. {$EXTERNALSYM MsiSummaryInfoSetPropertyA}
  527. function MsiSummaryInfoSetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  528.   uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCWSTR): UINT; stdcall;
  529. {$EXTERNALSYM MsiSummaryInfoSetPropertyW}
  531. {$IFDEF UNICODE}
  532. function MsiSummaryInfoSetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  533.   uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCWSTR): UINT; stdcall;
  534. {$EXTERNALSYM MsiSummaryInfoSetProperty}
  535. {$ELSE}
  536. function MsiSummaryInfoSetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  537.   uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCSTR): UINT; stdcall;
  538. {$EXTERNALSYM MsiSummaryInfoSetProperty}
  539. {$ENDIF}
  541. // Get a single property from the summary information
  542. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY
  544. function MsiSummaryInfoGetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  545.   var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPSTR;
  546.   var pcchValueBuf: DWORD): UINT; stdcall;
  547. {$EXTERNALSYM MsiSummaryInfoGetPropertyA}
  548. function MsiSummaryInfoGetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  549.   var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPWSTR;
  550.   var pcchValueBuf: DWORD): UINT; stdcall;
  551. {$EXTERNALSYM MsiSummaryInfoGetPropertyW}
  553. {$IFDEF UNICODE}
  554. function MsiSummaryInfoGetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  555.   var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPWSTR;
  556.   var pcchValueBuf: DWORD): UINT; stdcall;
  557. {$EXTERNALSYM MsiSummaryInfoGetProperty}
  558. {$ELSE}
  559. function MsiSummaryInfoGetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
  560.   var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPSTR;
  561.   var pcchValueBuf: DWORD): UINT; stdcall;
  562. {$EXTERNALSYM MsiSummaryInfoGetProperty}
  563. {$ENDIF}
  565. // Write back changed information to summary information stream
  567. function MsiSummaryInfoPersist(hSummaryInfo: MSIHANDLE): UINT; stdcall;
  568. {$EXTERNALSYM MsiSummaryInfoPersist}
  570. // --------------------------------------------------------------------------
  571. // Installer database management functions - not used by custom actions
  572. // --------------------------------------------------------------------------
  574. // Open an installer database, specifying the persistance mode, which is a pointer.
  575. // Predefined persist values are reserved pointer values, requiring pointer arithmetic.
  576. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  578. function MsiOpenDatabaseA(szDatabasePath: LPCSTR; szPersist: LPCSTR;
  579.   var phDatabase: MSIHANDLE): UINT; stdcall;
  580. {$EXTERNALSYM MsiOpenDatabaseA}
  581. function MsiOpenDatabaseW(szDatabasePath: LPCWSTR; szPersist: LPCWSTR;
  582.   var phDatabase: MSIHANDLE): UINT; stdcall;
  583. {$EXTERNALSYM MsiOpenDatabaseW}
  585. {$IFDEF UNICODE}
  586. function MsiOpenDatabase(szDatabasePath: LPCWSTR; szPersist: LPCWSTR;
  587.   var phDatabase: MSIHANDLE): UINT; stdcall;
  588. {$EXTERNALSYM MsiOpenDatabase}
  589. {$ELSE}
  590. function MsiOpenDatabase(szDatabasePath: LPCSTR; szPersist: LPCSTR;
  591.   var phDatabase: MSIHANDLE): UINT; stdcall;
  592. {$EXTERNALSYM MsiOpenDatabase}
  593. {$ENDIF}
  595. // Import an MSI text archive table into an open database
  596. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  598. function MsiDatabaseImportA(hDatabase: MSIHANDLE; szFolderPath: LPCSTR;
  599.   szFileName: LPCSTR): UINT; stdcall;
  600. {$EXTERNALSYM MsiDatabaseImportA}
  601. function MsiDatabaseImportW(hDatabase: MSIHANDLE; szFolderPath: LPCWSTR;
  602.   szFileName: LPCWSTR): UINT; stdcall;
  603. {$EXTERNALSYM MsiDatabaseImportW}
  605. {$IFDEF UNICODE}
  606. function MsiDatabaseImport(hDatabase: MSIHANDLE; szFolderPath: LPCWSTR;
  607.   szFileName: LPCWSTR): UINT; stdcall;
  608. {$EXTERNALSYM MsiDatabaseImport}
  609. {$ELSE}
  610. function MsiDatabaseImport(hDatabase: MSIHANDLE; szFolderPath: LPCSTR;
  611.   szFileName: LPCSTR): UINT; stdcall;
  612. {$EXTERNALSYM MsiDatabaseImport}
  613. {$ENDIF}
  615. // Export an MSI table from an open database to a text archive file
  616. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  618. function MsiDatabaseExportA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
  619.   szFolderPath: LPCSTR; szFileName: LPCSTR): UINT; stdcall;
  620. {$EXTERNALSYM MsiDatabaseExportA}
  621. function MsiDatabaseExportW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
  622.   szFolderPath: LPCWSTR; szFileName: LPCWSTR): UINT; stdcall;
  623. {$EXTERNALSYM MsiDatabaseExportW}
  625. {$IFDEF UNICODE}
  626. function MsiDatabaseExport(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
  627.   szFolderPath: LPCWSTR; szFileName: LPCWSTR): UINT; stdcall;
  628. {$EXTERNALSYM MsiDatabaseExport}
  629. {$ELSE}
  630. function MsiDatabaseExport(hDatabase: MSIHANDLE; szTableName: LPCSTR;
  631.   szFolderPath: LPCSTR; szFileName: LPCSTR): UINT; stdcall;
  632. {$EXTERNALSYM MsiDatabaseExport}
  633. {$ENDIF}
  635. // Merge two database together, allowing duplicate rows
  636. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  638. function MsiDatabaseMergeA(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
  639.   szTableName: LPCSTR): UINT; stdcall;
  640. {$EXTERNALSYM MsiDatabaseMergeA}
  641. function MsiDatabaseMergeW(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
  642.   szTableName: LPCWSTR): UINT; stdcall;
  643. {$EXTERNALSYM MsiDatabaseMergeW}
  645. {$IFDEF UNICODE}
  646. function MsiDatabaseMerge(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
  647.   szTableName: LPCWSTR): UINT; stdcall;
  648. {$EXTERNALSYM MsiDatabaseMerge}
  649. {$ELSE}
  650. function MsiDatabaseMerge(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
  651.   szTableName: LPCSTR): UINT; stdcall;
  652. {$EXTERNALSYM MsiDatabaseMerge}
  653. {$ENDIF}
  655. // Generate a transform file of differences between two databases
  656. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  658. function MsiDatabaseGenerateTransformA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  659.   szTransformFile: LPCSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
  660. {$EXTERNALSYM MsiDatabaseGenerateTransformA}
  661. function MsiDatabaseGenerateTransformW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  662.   szTransformFile: LPCWSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
  663. {$EXTERNALSYM MsiDatabaseGenerateTransformW}
  665. {$IFDEF UNICODE}
  666. function MsiDatabaseGenerateTransform(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  667.   szTransformFile: LPCWSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
  668. {$EXTERNALSYM MsiDatabaseGenerateTransform}
  669. {$ELSE}
  670. function MsiDatabaseGenerateTransform(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  671.   szTransformFile: LPCSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
  672. {$EXTERNALSYM MsiDatabaseGenerateTransform}
  673. {$ENDIF}
  675. // Apply a transform file containing database difference
  676. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  678. function MsiDatabaseApplyTransformA(hDatabase: MSIHANDLE; szTransformFile: LPCSTR;
  679.   iErrorConditions: Integer): UINT; stdcall;
  680. {$EXTERNALSYM MsiDatabaseApplyTransformA}
  681. function MsiDatabaseApplyTransformW(hDatabase: MSIHANDLE; szTransformFile: LPCWSTR;
  682.   iErrorConditions: Integer): UINT; stdcall;
  683. {$EXTERNALSYM MsiDatabaseApplyTransformW}
  685. {$IFDEF UNICODE}
  686. function MsiDatabaseApplyTransform(hDatabase: MSIHANDLE; szTransformFile: LPCWSTR;
  687.   iErrorConditions: Integer): UINT; stdcall;
  688. {$EXTERNALSYM MsiDatabaseApplyTransform}
  689. {$ELSE}
  690. function MsiDatabaseApplyTransform(hDatabase: MSIHANDLE; szTransformFile: LPCSTR;
  691.   iErrorConditions: Integer): UINT; stdcall;
  692. {$EXTERNALSYM MsiDatabaseApplyTransform}
  693. {$ENDIF}
  695. // Create summary information of existing transform to include validation and error conditions
  696. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  698. function MsiCreateTransformSummaryInfoA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  699.   szTransformFile: LPCSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
  700. {$EXTERNALSYM MsiCreateTransformSummaryInfoA}
  701. function MsiCreateTransformSummaryInfoW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  702.   szTransformFile: LPCWSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
  703. {$EXTERNALSYM MsiCreateTransformSummaryInfoW}
  705. {$IFDEF UNICODE}
  706. function MsiCreateTransformSummaryInfo(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  707.   szTransformFile: LPCWSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
  708. {$EXTERNALSYM MsiCreateTransformSummaryInfo}
  709. {$ELSE}
  710. function MsiCreateTransformSummaryInfo(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
  711.   szTransformFile: LPCSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
  712. {$EXTERNALSYM MsiCreateTransformSummaryInfo}
  713. {$ENDIF}
  715. // Write out all persistent table data, ignored if database opened read-only
  716. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  718. function MsiDatabaseCommit(hDatabase: MSIHANDLE): UINT; stdcall;
  719. {$EXTERNALSYM MsiDatabaseCommit}
  721. // Return the update state of a database
  723. function MsiGetDatabaseState(hDatabase: MSIHANDLE): MSIDBSTATE; stdcall;
  724. {$EXTERNALSYM MsiGetDatabaseState}
  726. // --------------------------------------------------------------------------
  727. // Record object functions
  728. // --------------------------------------------------------------------------
  730. // Create a new record object with the requested number of fields
  731. // Field 0, not included in count, is used for format strings and op codes
  732. // All fields are initialized to null
  733. // Returns a handle to the created record, or 0 if memory could not be allocated
  735. function MsiCreateRecord(cParams: UINT): MSIHANDLE; stdcall;
  736. {$EXTERNALSYM MsiCreateRecord}
  738. // Report whether a record field is NULL
  739. // Returns TRUE if the field is null or does not exist
  740. // Returns FALSE if the field contains data, or the handle is invalid
  742. function MsiRecordIsNull(hRecord: MSIHANDLE; iField: UINT): BOOL; stdcall;
  743. {$EXTERNALSYM MsiRecordIsNull}
  745. // Return the length of a record field
  746. // Returns 0 if field is NULL or non-existent
  747. // Returns sizeof(Integer) if integer data
  748. // Returns character count if string data (not counting null terminator)
  749. // Returns bytes count if stream data
  751. function MsiRecordDataSize(hRecord: MSIHANDLE; iField: UINT): UINT; stdcall;
  752. {$EXTERNALSYM MsiRecordDataSize}
  754. // Set a record field to an integer value
  755. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD
  757. function MsiRecordSetInteger(hRecord: MSIHANDLE; iField: UINT; iValue: Integer): UINT; stdcall;
  758. {$EXTERNALSYM MsiRecordSetInteger}
  760. // Copy a string into the designated field
  761. // A null string pointer and an empty string both set the field to null
  762. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD
  764. function MsiRecordSetStringA(hRecord: MSIHANDLE; iField: UINT; szValue: LPCSTR): UINT; stdcall;
  765. {$EXTERNALSYM MsiRecordSetStringA}
  766. function MsiRecordSetStringW(hRecord: MSIHANDLE; iField: UINT; szValue: LPCWSTR): UINT; stdcall;
  767. {$EXTERNALSYM MsiRecordSetStringW}
  769. {$IFDEF UNICODE}
  770. function MsiRecordSetString(hRecord: MSIHANDLE; iField: UINT; szValue: LPCWSTR): UINT; stdcall;
  771. {$EXTERNALSYM MsiRecordSetString}
  772. {$ELSE}
  773. function MsiRecordSetString(hRecord: MSIHANDLE; iField: UINT; szValue: LPCSTR): UINT; stdcall;
  774. {$EXTERNALSYM MsiRecordSetString}
  775. {$ENDIF}
  777. // Return the integer value from a record field
  778. // Returns the value MSI_NULL_INTEGER if the field is null
  779. // or if the field is a string that cannot be converted to an integer
  781. function MsiRecordGetInteger(hRecord: MSIHANDLE; iField: UINT): Integer; stdcall;
  782. {$EXTERNALSYM MsiRecordGetInteger}
  784. // Return the string value of a record field
  785. // Integer fields will be converted to a string
  786. // Null and non-existent fields will report a value of 0
  787. // Fields containing stream data will return ERROR_INVALID_DATATYPE
  788. // Returns ERROR_SUCCESS, ERROR_MORE_DATA,
  789. //         ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD, ERROR_BAD_ARGUMENTS
  791. function MsiRecordGetStringA(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPSTR;
  792.   var pcchValueBuf: DWORD): UINT; stdcall;
  793. {$EXTERNALSYM MsiRecordGetStringA}
  794. function MsiRecordGetStringW(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPWSTR;
  795.   var pcchValueBuf: DWORD): UINT; stdcall;
  796. {$EXTERNALSYM MsiRecordGetStringW}
  798. {$IFDEF UNICODE}
  799. function MsiRecordGetString(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPWSTR;
  800.   var pcchValueBuf: DWORD): UINT; stdcall;
  801. {$EXTERNALSYM MsiRecordGetString}
  802. {$ELSE}
  803. function MsiRecordGetString(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPSTR;
  804.   var pcchValueBuf: DWORD): UINT; stdcall;
  805. {$EXTERNALSYM MsiRecordGetString}
  806. {$ENDIF}
  808. // Returns the number of fields allocated in the record
  809. // Does not count field 0, used for formatting and op codes
  811. function MsiRecordGetFieldCount(hRecord: MSIHANDLE): UINT; stdcall;
  812. {$EXTERNALSYM MsiRecordGetFieldCount}
  814. // Set a record stream field from a file
  815. // The contents of the specified file will be read into a stream object
  816. // The stream will be persisted if the record is inserted into the database
  817. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  819. function MsiRecordSetStreamA(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCSTR): UINT; stdcall;
  820. {$EXTERNALSYM MsiRecordSetStreamA}
  821. function MsiRecordSetStreamW(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCWSTR): UINT; stdcall;
  822. {$EXTERNALSYM MsiRecordSetStreamW}
  824. {$IFDEF UNICODE}
  825. function MsiRecordSetStream(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCWSTR): UINT; stdcall;
  826. {$EXTERNALSYM MsiRecordSetStream}
  827. {$ELSE}
  828. function MsiRecordSetStream(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCSTR): UINT; stdcall;
  829. {$EXTERNALSYM MsiRecordSetStream}
  830. {$ENDIF}
  832. // Read bytes from a record stream field into a buffer
  833. // Must set the in/out argument to the requested byte count to read
  834. // The number of bytes transferred is returned through the argument
  835. // If no more bytes are available, ERROR_SUCCESS is still returned
  837. function MsiRecordReadStream(hRecord: MSIHANDLE; iField: UINT; szDataBuf: PChar;
  838.   var pcbDataBuf: DWORD): UINT; stdcall;
  839. {$EXTERNALSYM MsiRecordReadStream}
  841. // Clears all data fields in a record to NULL
  843. function MsiRecordClearData(hRecord: MSIHANDLE): UINT; stdcall;
  844. {$EXTERNALSYM MsiRecordClearData}
  846. // --------------------------------------------------------------------------
  847. // Functions to access a running installation, called from custom actions
  848. // The install handle is the single argument passed to custom actions
  849. // --------------------------------------------------------------------------
  851. // Return a handle to the database currently in use by this installer instance
  853. function MsiGetActiveDatabase(hInstall: MSIHANDLE): MSIHANDLE; stdcall;
  854. {$EXTERNALSYM MsiGetActiveDatabase}
  856. // Set the value for an installer property
  857. // If the property is not defined, it will be created
  858. // If the value is null or an empty string, the property will be removed
  859. // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS
  861. function MsiSetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValue: LPCSTR): UINT; stdcall;
  862. {$EXTERNALSYM MsiSetPropertyA}
  863. function MsiSetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValue: LPCWSTR): UINT; stdcall;
  864. {$EXTERNALSYM MsiSetPropertyW}
  866. {$IFDEF UNICODE}
  867. function MsiSetProperty(hInstall: MSIHANDLE; szName: LPCWSTR; szValue: LPCWSTR): UINT; stdcall;
  868. {$EXTERNALSYM MsiSetProperty}
  869. {$ELSE}
  870. function MsiSetProperty(hInstall: MSIHANDLE; szName: LPCSTR; szValue: LPCSTR): UINT; stdcall;
  871. {$EXTERNALSYM MsiSetProperty}
  872. {$ENDIF}
  874. // Get the value for an installer property
  875. // If the property is not defined, it is equivalent to a 0-length value, not error
  876. // Returns ERROR_SUCCESS, ERROR_MORE_DATA, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS
  878. function MsiGetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValueBuf: LPSTR;
  879.   var pcchValueBuf: DWORD): UINT; stdcall;
  880. {$EXTERNALSYM MsiGetPropertyA}
  881. function MsiGetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValueBuf: LPWSTR;
  882.   var pcchValueBuf: DWORD): UINT; stdcall;
  883. {$EXTERNALSYM MsiGetPropertyW}
  885. {$IFDEF UNICODE}
  886. function MsiGetProperty(hInstall: MSIHANDLE; szName: LPCWSTR; szValueBuf: LPWSTR;
  887.   var pcchValueBuf: DWORD): UINT; stdcall;
  888. {$EXTERNALSYM MsiGetProperty}
  889. {$ELSE}
  890. function MsiGetProperty(hInstall: MSIHANDLE; szName: LPCSTR; szValueBuf: LPSTR;
  891.   var pcchValueBuf: DWORD): UINT; stdcall;
  892. {$EXTERNALSYM MsiGetProperty}
  893. {$ENDIF}
  895. // Return the numeric language for the currently running install
  896. // Returns 0 if an install not running
  898. function MsiGetLanguage(hInstall: MSIHANDLE): LANGID; stdcall;
  899. {$EXTERNALSYM MsiGetLanguage}
  901. // Return one of the boolean internal installer states
  902. // Returns FALSE if the handle is not active or if the mode is not implemented
  904. function MsiGetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE): BOOL; stdcall;
  905. {$EXTERNALSYM MsiGetMode}
  907. // Set an internal install session boolean mode - Note: most modes are read-only
  908. // Returns ERROR_SUCCESS if the mode can be set to the desired state
  909. // Returns ERROR_ACCESS_DENIED if the mode is not settable
  910. // Returns ERROR_INVALID_HANDLE if the handle is not an active install session
  912. function MsiSetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE; fState: BOOL): UINT; stdcall;
  913. {$EXTERNALSYM MsiSetMode}
  915. // Format record data using a format string containing field markers and/or properties
  916. // Record field 0 must contain the format string
  917. // Other fields must contain data that may be referenced by the format string.
  919. function MsiFormatRecordA(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPSTR;
  920.   var pcchResultBuf: DWORD): UINT; stdcall;
  921. {$EXTERNALSYM MsiFormatRecordA}
  922. function MsiFormatRecordW(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPWSTR;
  923.   var pcchResultBuf: DWORD): UINT; stdcall;
  924. {$EXTERNALSYM MsiFormatRecordW}
  926. {$IFDEF UNICODE}
  927. function MsiFormatRecord(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPWSTR;
  928.   var pcchResultBuf: DWORD): UINT; stdcall;
  929. {$EXTERNALSYM MsiFormatRecord}
  930. {$ELSE}
  931. function MsiFormatRecord(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPSTR;
  932.   var pcchResultBuf: DWORD): UINT; stdcall;
  933. {$EXTERNALSYM MsiFormatRecord}
  934. {$ENDIF}
  936. // Execute another action, either built-in, custom, or UI wizard
  937. // Returns ERROR_FUNCTION_NOT_CALLED if action not found
  938. // Returns ERROR_SUCCESS if action completed succesfully
  939. // Returns ERROR_INSTALL_USEREXIT if user cancelled during action
  940. // Returns ERROR_INSTALL_FAILURE if action failed
  941. // Returns ERROR_INSTALL_SUSPEND if user suspended installation
  942. // Returns ERROR_MORE_DATA if action wishes to skip remaining actions
  943. // Returns ERROR_INVALID_HANDLE_STATE if install session not active
  944. // Returns ERROR_INVALID_DATA if failure calling custom action
  945. // Returns ERROR_INVALID_HANDLE or ERROR_INVALID_PARAMETER if arguments invalid
  947. function MsiDoActionA(hInstall: MSIHANDLE; szAction: LPCSTR): UINT; stdcall;
  948. {$EXTERNALSYM MsiDoActionA}
  949. function MsiDoActionW(hInstall: MSIHANDLE; szAction: LPCWSTR): UINT; stdcall;
  950. {$EXTERNALSYM MsiDoActionW}
  952. {$IFDEF UNICODE}
  953. function MsiDoAction(hInstall: MSIHANDLE; szAction: LPCWSTR): UINT; stdcall;
  954. {$EXTERNALSYM MsiDoAction}
  955. {$ELSE}
  956. function MsiDoAction(hInstall: MSIHANDLE; szAction: LPCSTR): UINT; stdcall;
  957. {$EXTERNALSYM MsiDoAction}
  958. {$ENDIF}
  960. // Execute another action sequence, as descibed in the specified table
  961. // Returns the same error codes as MsiDoAction
  963. function MsiSequenceA(hInstall: MSIHANDLE; szTable: LPCSTR; iSequenceMode: Integer): UINT; stdcall;
  964. {$EXTERNALSYM MsiSequenceA}
  965. function MsiSequenceW(hInstall: MSIHANDLE; szTable: LPCWSTR; iSequenceMode: Integer): UINT; stdcall;
  966. {$EXTERNALSYM MsiSequenceW}
  968. {$IFDEF UNICODE}
  969. function MsiSequence(hInstall: MSIHANDLE; szTable: LPCWSTR; iSequenceMode: Integer): UINT; stdcall;
  970. {$EXTERNALSYM MsiSequence}
  971. {$ELSE}
  972. function MsiSequence(hInstall: MSIHANDLE; szTable: LPCSTR; iSequenceMode: Integer): UINT; stdcall;
  973. {$EXTERNALSYM MsiSequence}
  974. {$ENDIF}
  976. // Send an error record to the installer for processing.
  977. // If field 0 (template) is not set, field 1 must be set to the error code,
  978. //   corresponding the the error message in the Error database table,
  979. //   and the message will be formatted using the template from the Error table
  980. //   before passing it to the UI handler for display.
  981. // Returns Win32 button codes: IDOK IDCANCEL IDABORT IDRETRY IDIGNORE IDYES IDNO
  982. //   or 0 if no action taken, or -1 if invalid argument or handle
  984. function MsiProcessMessage(hInstall: MSIHANDLE; eMessageType: INSTALLMESSAGE;
  985.   hRecord: MSIHANDLE): Integer; stdcall;
  986. {$EXTERNALSYM MsiProcessMessage}
  988. // Evaluate a conditional expression containing property names and values
  990. function MsiEvaluateConditionA(hInstall: MSIHANDLE; szCondition: LPCSTR): MSICONDITION; stdcall;
  991. {$EXTERNALSYM MsiEvaluateConditionA}
  992. function MsiEvaluateConditionW(hInstall: MSIHANDLE; szCondition: LPCWSTR): MSICONDITION; stdcall;
  993. {$EXTERNALSYM MsiEvaluateConditionW}
  995. {$IFDEF UNICODE}
  996. function MsiEvaluateCondition(hInstall: MSIHANDLE; szCondition: LPCWSTR): MSICONDITION; stdcall;
  997. {$EXTERNALSYM MsiEvaluateCondition}
  998. {$ELSE}
  999. function MsiEvaluateCondition(hInstall: MSIHANDLE; szCondition: LPCSTR): MSICONDITION; stdcall;
  1000. {$EXTERNALSYM MsiEvaluateCondition}
  1001. {$ENDIF}
  1003. // Get the installed state and requested action state of a feature
  1004. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1006. function MsiGetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1007.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1008. {$EXTERNALSYM MsiGetFeatureStateA}
  1009. function MsiGetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1010.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1011. {$EXTERNALSYM MsiGetFeatureStateW}
  1013. {$IFDEF UNICODE}
  1014. function MsiGetFeatureState(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1015.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1016. {$EXTERNALSYM MsiGetFeatureState}
  1017. {$ELSE}
  1018. function MsiGetFeatureState(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1019.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1020. {$EXTERNALSYM MsiGetFeatureState}
  1021. {$ENDIF}
  1023. // Request a feature to be set to a specified state
  1024. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1026. function MsiSetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1027.   iState: INSTALLSTATE): UINT; stdcall;
  1028. {$EXTERNALSYM MsiSetFeatureStateA}
  1029. function MsiSetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1030.   iState: INSTALLSTATE): UINT; stdcall;
  1031. {$EXTERNALSYM MsiSetFeatureStateW}
  1033. {$IFDEF UNICODE}
  1034. function MsiSetFeatureState(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1035.   iState: INSTALLSTATE): UINT; stdcall;
  1036. {$EXTERNALSYM MsiSetFeatureState}
  1037. {$ELSE}
  1038. function MsiSetFeatureState(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1039.   iState: INSTALLSTATE): UINT; stdcall;
  1040. {$EXTERNALSYM MsiSetFeatureState}
  1041. {$ENDIF}
  1043. // Set the attribute bits of a specified feature at runtime.
  1044. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1046. function MsiSetFeatureAttributesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1047.   dwAttributes: DWORD): UINT; stdcall;
  1048. {$EXTERNALSYM MsiSetFeatureAttributesA}
  1049. function MsiSetFeatureAttributesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1050.   dwAttributes: DWORD): UINT; stdcall;
  1051. {$EXTERNALSYM MsiSetFeatureAttributesW}
  1053. {$IFDEF UNICODE}
  1054. function MsiSetFeatureAttributes(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1055.   dwAttributes: DWORD): UINT; stdcall;
  1056. {$EXTERNALSYM MsiSetFeatureAttributes}
  1057. {$ELSE}
  1058. function MsiSetFeatureAttributes(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1059.   dwAttributes: DWORD): UINT; stdcall;
  1060. {$EXTERNALSYM MsiSetFeatureAttributes}
  1061. {$ENDIF}
  1063. // Get the installed state and requested action state of a component
  1064. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1066. function MsiGetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
  1067.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1068. {$EXTERNALSYM MsiGetComponentStateA}
  1069. function MsiGetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
  1070.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1071. {$EXTERNALSYM MsiGetComponentStateW}
  1073. {$IFDEF UNICODE}
  1074. function MsiGetComponentState(hInstall: MSIHANDLE; szComponent: LPCWSTR;
  1075.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1076. {$EXTERNALSYM MsiGetComponentState}
  1077. {$ELSE}
  1078. function MsiGetComponentState(hInstall: MSIHANDLE; szComponent: LPCSTR;
  1079.   var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
  1080. {$EXTERNALSYM MsiGetComponentState}
  1081. {$ENDIF}
  1083. // Request a component to be set to a specified state
  1084. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1086. function MsiSetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
  1087.   iState: INSTALLSTATE): UINT; stdcall;
  1088. {$EXTERNALSYM MsiSetComponentStateA}
  1089. function MsiSetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
  1090.   iState: INSTALLSTATE): UINT; stdcall;
  1091. {$EXTERNALSYM MsiSetComponentStateW}
  1093. {$IFDEF UNICODE}
  1094. function MsiSetComponentState(hInstall: MSIHANDLE; szComponent: LPCWSTR;
  1095.   iState: INSTALLSTATE): UINT; stdcall;
  1096. {$EXTERNALSYM MsiSetComponentState}
  1097. {$ELSE}
  1098. function MsiSetComponentState(hInstall: MSIHANDLE; szComponent: LPCSTR;
  1099.   iState: INSTALLSTATE): UINT; stdcall;
  1100. {$EXTERNALSYM MsiSetComponentState}
  1101. {$ENDIF}
  1103. // Return the disk cost for a feature and related features
  1104. // Can specify either current feature state or proposed state
  1105. // Can specify extent of related features to cost
  1106. // Note that adding costs for several features may produce an
  1107. // excessively large cost due to shared components and parents.
  1108. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1110. function MsiGetFeatureCostA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1111.   iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
  1112. {$EXTERNALSYM MsiGetFeatureCostA}
  1113. function MsiGetFeatureCostW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1114.   iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
  1115. {$EXTERNALSYM MsiGetFeatureCostW}
  1117. {$IFDEF UNICODE}
  1118. function MsiGetFeatureCost(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1119.   iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
  1120. {$EXTERNALSYM MsiGetFeatureCost}
  1121. {$ELSE}
  1122. function MsiGetFeatureCost(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1123.   iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
  1124. {$EXTERNALSYM MsiGetFeatureCost}
  1125. {$ENDIF}
  1127. // Enumerates the costs and temporary costs per drives for
  1128. // szComponent. If szComponent is set to NULL, it enumerates
  1129. // the above costs for the engine, per drives.
  1130. //
  1131. // The enumeration is 0-based, i.e. it returns the data for
  1132. // the first drive when called w/ dwIndex set to 0.
  1133. //
  1134. // Can specify either current feature state or proposed state.
  1135. //
  1136. // Execution of this function sets the error record, accessible
  1137. // via MsiGetLastErrorRecord.
  1139. function MsiEnumComponentCostsA(hInstall: MSIHANDLE; szComponent: LPCSTR; dwIndex: DWORD; iState: INSTALLSTATE;
  1140.   szDriveBuf: LPSTR; var pcchDriveBuf: DWORD; var piCost: INT; piTempCost: INT): UINT; stdcall;
  1141. {$EXTERNALSYM MsiEnumComponentCostsA}
  1142. function MsiEnumComponentCostsW(hInstall: MSIHANDLE; szComponent: LPCWSTR; dwIndex: DWORD; iState: INSTALLSTATE;
  1143.   szDriveBuf: LPWSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
  1144. {$EXTERNALSYM MsiEnumComponentCostsW}
  1146. {$IFDEF UNICODE}
  1147. function MsiEnumComponentCosts(hInstall: MSIHANDLE; szComponent: LPCWSTR; dwIndex: DWORD; iState: INSTALLSTATE;
  1148.   szDriveBuf: LPWSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
  1149. {$EXTERNALSYM MsiEnumComponentCosts}
  1150. {$ELSE}
  1151. function MsiEnumComponentCosts(hInstall: MSIHANDLE; szComponent: LPCSTR; dwIndex: DWORD; iState: INSTALLSTATE;
  1152.   szDriveBuf: LPSTR; var pcchDriveBuf: DWORD; var piCost: INT; piTempCost: INT): UINT; stdcall;
  1153. {$EXTERNALSYM MsiEnumComponentCosts}
  1154. {$ENDIF}
  1156. // Set the install level for a full product installation (not a feature request)
  1157. // Setting the value to 0 initialized components and features to the default level
  1158. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1160. function MsiSetInstallLevel(hInstall: MSIHANDLE; iInstallLevel: Integer): UINT; stdcall;
  1161. {$EXTERNALSYM MsiSetInstallLevel}
  1163. // Get the valid install states for a feature, represented by bit flags
  1164. // For each valid install state, a bit is set of value: (1 << INSTALLSTATE)
  1165. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1167. function MsiGetFeatureValidStatesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1168.   var dwInstallStates: DWORD): UINT; stdcall;
  1169. {$EXTERNALSYM MsiGetFeatureValidStatesA}
  1170. function MsiGetFeatureValidStatesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1171.   var dwInstallStates: DWORD): UINT; stdcall;
  1172. {$EXTERNALSYM MsiGetFeatureValidStatesW}
  1174. {$IFDEF UNICODE}
  1175. function MsiGetFeatureValidStates(hInstall: MSIHANDLE; szFeature: LPCWSTR;
  1176.   var dwInstallStates: DWORD): UINT; stdcall;
  1177. {$EXTERNALSYM MsiGetFeatureValidStates}
  1178. {$ELSE}
  1179. function MsiGetFeatureValidStates(hInstall: MSIHANDLE; szFeature: LPCSTR;
  1180.   var dwInstallStates: DWORD): UINT; stdcall;
  1181. {$EXTERNALSYM MsiGetFeatureValidStates}
  1182. {$ENDIF}
  1184. // Return the full source path for a folder in the Directory table
  1185. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1187. function MsiGetSourcePathA(hInstall: MSIHANDLE; szFolder: LPCSTR; szPathBuf: LPSTR;
  1188.   var pcchPathBuf: DWORD): UINT; stdcall;
  1189. {$EXTERNALSYM MsiGetSourcePathA}
  1190. function MsiGetSourcePathW(hInstall: MSIHANDLE; szFolder: LPCWSTR; szPathBuf: LPWSTR;
  1191.   var pcchPathBuf: DWORD): UINT; stdcall;
  1192. {$EXTERNALSYM MsiGetSourcePathW}
  1194. {$IFDEF UNICODE}
  1195. function MsiGetSourcePath(hInstall: MSIHANDLE; szFolder: LPCWSTR; szPathBuf: LPWSTR;
  1196.   var pcchPathBuf: DWORD): UINT; stdcall;
  1197. {$EXTERNALSYM MsiGetSourcePath}
  1198. {$ELSE}
  1199. function MsiGetSourcePath(hInstall: MSIHANDLE; szFolder: LPCSTR; szPathBuf: LPSTR;
  1200.   var pcchPathBuf: DWORD): UINT; stdcall;
  1201. {$EXTERNALSYM MsiGetSourcePath}
  1202. {$ENDIF}
  1204. // Return the full target path for a folder in the Directory table
  1205. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1207. function MsiGetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
  1208.   szPathBuf: LPSTR; var pcchPathBuf: DWORD): UINT; stdcall;
  1209. {$EXTERNALSYM MsiGetTargetPathA}
  1210. function MsiGetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
  1211.   szPathBuf: LPWSTR; var pcchPathBuf: DWORD): UINT; stdcall;
  1212. {$EXTERNALSYM MsiGetTargetPathW}
  1214. {$IFDEF UNICODE}
  1215. function MsiGetTargetPath(hInstall: MSIHANDLE; szFolder: LPCWSTR;
  1216.   szPathBuf: LPWSTR; var pcchPathBuf: DWORD): UINT; stdcall;
  1217. {$EXTERNALSYM MsiGetTargetPath}
  1218. {$ELSE}
  1219. function MsiGetTargetPath(hInstall: MSIHANDLE; szFolder: LPCSTR;
  1220.   szPathBuf: LPSTR; var pcchPathBuf: DWORD): UINT; stdcall;
  1221. {$EXTERNALSYM MsiGetTargetPath}
  1222. {$ENDIF}
  1224. // Set the full target path for a folder in the Directory table
  1225. // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
  1227. function MsiSetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
  1228.   szFolderPath: LPCSTR): UINT; stdcall;
  1229. {$EXTERNALSYM MsiSetTargetPathA}
  1230. function MsiSetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
  1231.   szFolderPath: LPCWSTR): UINT; stdcall;
  1232. {$EXTERNALSYM MsiSetTargetPathW}
  1234. {$IFDEF UNICODE}
  1235. function MsiSetTargetPath(hInstall: MSIHANDLE; szFolder: LPCWSTR;
  1236.   szFolderPath: LPCWSTR): UINT; stdcall;
  1237. {$EXTERNALSYM MsiSetTargetPath}
  1238. {$ELSE}
  1239. function MsiSetTargetPath(hInstall: MSIHANDLE; szFolder: LPCSTR;
  1240.   szFolderPath: LPCSTR): UINT; stdcall;
  1241. {$EXTERNALSYM MsiSetTargetPath}
  1242. {$ENDIF}
  1244. // Check to see if sufficent disk space is present for the current installation
  1245. // Returns ERROR_SUCCESS, ERROR_DISK_FULL, ERROR_INVALID_HANDLE_STATE, or ERROR_INVALID_HANDLE
  1247. function MsiVerifyDiskSpace(hInstall: MSIHANDLE): UINT; stdcall;
  1248. {$EXTERNALSYM MsiVerifyDiskSpace}
  1250. // --------------------------------------------------------------------------
  1251. // Functions for rendering UI dialogs from the database representations.
  1252. // Purpose is for product development, not for use during installation.
  1253. // --------------------------------------------------------------------------
  1255. // Enable UI in preview mode to facilitate authoring of UI dialogs.
  1256. // The preview mode will end when the handle is closed.
  1258. function MsiEnableUIPreview(hDatabase: MSIHANDLE; var phPreview: MSIHANDLE): UINT; stdcall;
  1259. {$EXTERNALSYM MsiEnableUIPreview}
  1261. // Display any UI dialog as modeless and inactive.
  1262. // Supplying a null name will remove any current dialog.
  1264. function MsiPreviewDialogA(hPreview: MSIHANDLE; szDialogName: LPCSTR): UINT; stdcall;
  1265. {$EXTERNALSYM MsiPreviewDialogA}
  1266. function MsiPreviewDialogW(hPreview: MSIHANDLE; szDialogName: LPCWSTR): UINT; stdcall;
  1267. {$EXTERNALSYM MsiPreviewDialogW}
  1269. {$IFDEF UNICODE}
  1270. function MsiPreviewDialog(hPreview: MSIHANDLE; szDialogName: LPCWSTR): UINT; stdcall;
  1271. {$EXTERNALSYM MsiPreviewDialog}
  1272. {$ELSE}
  1273. function MsiPreviewDialog(hPreview: MSIHANDLE; szDialogName: LPCSTR): UINT; stdcall;
  1274. {$EXTERNALSYM MsiPreviewDialog}
  1275. {$ENDIF}
  1277. // Display a billboard within a host control in the displayed dialog.
  1278. // Supplying a null billboard name will remove any billboard displayed.
  1280. function MsiPreviewBillboardA(hPreview: MSIHANDLE; szControlName: LPCSTR;
  1281.   szBillboard: LPCSTR): UINT; stdcall;
  1282. {$EXTERNALSYM MsiPreviewBillboardA}
  1283. function MsiPreviewBillboardW(hPreview: MSIHANDLE; szControlName: LPCWSTR;
  1284.   szBillboard: LPCWSTR): UINT; stdcall;
  1285. {$EXTERNALSYM MsiPreviewBillboardW}
  1287. {$IFDEF UNICODE}
  1288. function MsiPreviewBillboard(hPreview: MSIHANDLE; szControlName: LPCWSTR;
  1289.   szBillboard: LPCWSTR): UINT; stdcall;
  1290. {$EXTERNALSYM MsiPreviewBillboard}
  1291. {$ELSE}
  1292. function MsiPreviewBillboard(hPreview: MSIHANDLE; szControlName: LPCSTR;
  1293.   szBillboard: LPCSTR): UINT; stdcall;
  1294. {$EXTERNALSYM MsiPreviewBillboard}
  1295. {$ENDIF}
  1297. // --------------------------------------------------------------------------
  1298. // Error handling not associated with any particular object
  1299. // --------------------------------------------------------------------------
  1301. // Return a record handle to the last function that generated an error record
  1302. // Only specified functions will set the error record, or clear it if success
  1303. // Field 1 of the record will contain the internal MSI error code
  1304. // Other fields will contain data specific to the particular error
  1305. // The error record is released internally after this function is executed
  1307. function MsiGetLastErrorRecord: MSIHANDLE; stdcall;
  1308. {$EXTERNALSYM MsiGetLastErrorRecord}
  1310. implementation
  1312. const
  1313.   msilib = 'msi.dll';
  1316. {$IFDEF DYNAMIC_LINK}
  1317. var
  1318.   _MsiDatabaseOpenViewA: Pointer;
  1320. function MsiDatabaseOpenViewA;
  1321. begin
  1322.   GetProcedureAddress(_MsiDatabaseOpenViewA, msilib, 'MsiDatabaseOpenViewA');
  1323.   asm
  1324.     mov esp, ebp
  1325.     pop ebp
  1326.     jmp [_MsiDatabaseOpenViewA]
  1327.   end;
  1328. end;
  1329. {$ELSE}
  1330. function MsiDatabaseOpenViewA; external msilib name 'MsiDatabaseOpenViewA';
  1331. {$ENDIF DYNAMIC_LINK}
  1333. {$IFDEF DYNAMIC_LINK}
  1334. var
  1335.   _MsiDatabaseOpenViewW: Pointer;
  1337. function MsiDatabaseOpenViewW;
  1338. begin
  1339.   GetProcedureAddress(_MsiDatabaseOpenViewW, msilib, 'MsiDatabaseOpenViewW');
  1340.   asm
  1341.     mov esp, ebp
  1342.     pop ebp
  1343.     jmp [_MsiDatabaseOpenViewW]
  1344.   end;
  1345. end;
  1346. {$ELSE}
  1347. function MsiDatabaseOpenViewW; external msilib name 'MsiDatabaseOpenViewW';
  1348. {$ENDIF DYNAMIC_LINK}
  1349. {$IFDEF UNICODE}
  1351. {$IFDEF DYNAMIC_LINK}
  1352. var
  1353.   _MsiDatabaseOpenView: Pointer;
  1355. function MsiDatabaseOpenView;
  1356. begin
  1357.   GetProcedureAddress(_MsiDatabaseOpenView, msilib, 'MsiDatabaseOpenViewW');
  1358.   asm
  1359.     mov esp, ebp
  1360.     pop ebp
  1361.     jmp [_MsiDatabaseOpenView]
  1362.   end;
  1363. end;
  1364. {$ELSE}
  1365. function MsiDatabaseOpenView; external msilib name 'MsiDatabaseOpenViewW';
  1366. {$ENDIF DYNAMIC_LINK}
  1367. {$ELSE}
  1369. {$IFDEF DYNAMIC_LINK}
  1370. var
  1371.   _MsiDatabaseOpenView: Pointer;
  1373. function MsiDatabaseOpenView;
  1374. begin
  1375.   GetProcedureAddress(_MsiDatabaseOpenView, msilib, 'MsiDatabaseOpenViewA');
  1376.   asm
  1377.     mov esp, ebp
  1378.     pop ebp
  1379.     jmp [_MsiDatabaseOpenView]
  1380.   end;
  1381. end;
  1382. {$ELSE}
  1383. function MsiDatabaseOpenView; external msilib name 'MsiDatabaseOpenViewA';
  1384. {$ENDIF DYNAMIC_LINK}
  1385. {$ENDIF}
  1387. {$IFDEF DYNAMIC_LINK}
  1388. var
  1389.   _MsiViewGetErrorA: Pointer;
  1391. function MsiViewGetErrorA;
  1392. begin
  1393.   GetProcedureAddress(_MsiViewGetErrorA, msilib, 'MsiViewGetErrorA');
  1394.   asm
  1395.     mov esp, ebp
  1396.     pop ebp
  1397.     jmp [_MsiViewGetErrorA]
  1398.   end;
  1399. end;
  1400. {$ELSE}
  1401. function MsiViewGetErrorA; external msilib name 'MsiViewGetErrorA';
  1402. {$ENDIF DYNAMIC_LINK}
  1404. {$IFDEF DYNAMIC_LINK}
  1405. var
  1406.   _MsiViewGetErrorW: Pointer;
  1408. function MsiViewGetErrorW;
  1409. begin
  1410.   GetProcedureAddress(_MsiViewGetErrorW, msilib, 'MsiViewGetErrorW');
  1411.   asm
  1412.     mov esp, ebp
  1413.     pop ebp
  1414.     jmp [_MsiViewGetErrorW]
  1415.   end;
  1416. end;
  1417. {$ELSE}
  1418. function MsiViewGetErrorW; external msilib name 'MsiViewGetErrorW';
  1419. {$ENDIF DYNAMIC_LINK}
  1420. {$IFDEF UNICODE}
  1422. {$IFDEF DYNAMIC_LINK}
  1423. var
  1424.   _MsiViewGetError: Pointer;
  1426. function MsiViewGetError;
  1427. begin
  1428.   GetProcedureAddress(_MsiViewGetError, msilib, 'MsiViewGetErrorW');
  1429.   asm
  1430.     mov esp, ebp
  1431.     pop ebp
  1432.     jmp [_MsiViewGetError]
  1433.   end;
  1434. end;
  1435. {$ELSE}
  1436. function MsiViewGetError; external msilib name 'MsiViewGetErrorW';
  1437. {$ENDIF DYNAMIC_LINK}
  1438. {$ELSE}
  1440. {$IFDEF DYNAMIC_LINK}
  1441. var
  1442.   _MsiViewGetError: Pointer;
  1444. function MsiViewGetError;
  1445. begin
  1446.   GetProcedureAddress(_MsiViewGetError, msilib, 'MsiViewGetErrorA');
  1447.   asm
  1448.     mov esp, ebp
  1449.     pop ebp
  1450.     jmp [_MsiViewGetError]
  1451.   end;
  1452. end;
  1453. {$ELSE}
  1454. function MsiViewGetError; external msilib name 'MsiViewGetErrorA';
  1455. {$ENDIF DYNAMIC_LINK}
  1456. {$ENDIF}
  1458. {$IFDEF DYNAMIC_LINK}
  1459. var
  1460.   _MsiViewExecute: Pointer;
  1462. function MsiViewExecute;
  1463. begin
  1464.   GetProcedureAddress(_MsiViewExecute, msilib, 'MsiViewExecute');
  1465.   asm
  1466.     mov esp, ebp
  1467.     pop ebp
  1468.     jmp [_MsiViewExecute]
  1469.   end;
  1470. end;
  1471. {$ELSE}
  1472. function MsiViewExecute; external msilib name 'MsiViewExecute';
  1473. {$ENDIF DYNAMIC_LINK}
  1475. {$IFDEF DYNAMIC_LINK}
  1476. var
  1477.   _MsiViewFetch: Pointer;
  1479. function MsiViewFetch;
  1480. begin
  1481.   GetProcedureAddress(_MsiViewFetch, msilib, 'MsiViewFetch');
  1482.   asm
  1483.     mov esp, ebp
  1484.     pop ebp
  1485.     jmp [_MsiViewFetch]
  1486.   end;
  1487. end;
  1488. {$ELSE}
  1489. function MsiViewFetch; external msilib name 'MsiViewFetch';
  1490. {$ENDIF DYNAMIC_LINK}
  1492. {$IFDEF DYNAMIC_LINK}
  1493. var
  1494.   _MsiViewModify: Pointer;
  1496. function MsiViewModify;
  1497. begin
  1498.   GetProcedureAddress(_MsiViewModify, msilib, 'MsiViewModify');
  1499.   asm
  1500.     mov esp, ebp
  1501.     pop ebp
  1502.     jmp [_MsiViewModify]
  1503.   end;
  1504. end;
  1505. {$ELSE}
  1506. function MsiViewModify; external msilib name 'MsiViewModify';
  1507. {$ENDIF DYNAMIC_LINK}
  1509. {$IFDEF DYNAMIC_LINK}
  1510. var
  1511.   _MsiViewGetColumnInfo: Pointer;
  1513. function MsiViewGetColumnInfo;
  1514. begin
  1515.   GetProcedureAddress(_MsiViewGetColumnInfo, msilib, 'MsiViewGetColumnInfo');
  1516.   asm
  1517.     mov esp, ebp
  1518.     pop ebp
  1519.     jmp [_MsiViewGetColumnInfo]
  1520.   end;
  1521. end;
  1522. {$ELSE}
  1523. function MsiViewGetColumnInfo; external msilib name 'MsiViewGetColumnInfo';
  1524. {$ENDIF DYNAMIC_LINK}
  1526. {$IFDEF DYNAMIC_LINK}
  1527. var
  1528.   _MsiViewClose: Pointer;
  1530. function MsiViewClose;
  1531. begin
  1532.   GetProcedureAddress(_MsiViewClose, msilib, 'MsiViewClose');
  1533.   asm
  1534.     mov esp, ebp
  1535.     pop ebp
  1536.     jmp [_MsiViewClose]
  1537.   end;
  1538. end;
  1539. {$ELSE}
  1540. function MsiViewClose; external msilib name 'MsiViewClose';
  1541. {$ENDIF DYNAMIC_LINK}
  1543. {$IFDEF DYNAMIC_LINK}
  1544. var
  1545.   _MsiDatabaseGetPrimaryKeysA: Pointer;
  1547. function MsiDatabaseGetPrimaryKeysA;
  1548. begin
  1549.   GetProcedureAddress(_MsiDatabaseGetPrimaryKeysA, msilib, 'MsiDatabaseGetPrimaryKeysA');
  1550.   asm
  1551.     mov esp, ebp
  1552.     pop ebp
  1553.     jmp [_MsiDatabaseGetPrimaryKeysA]
  1554.   end;
  1555. end;
  1556. {$ELSE}
  1557. function MsiDatabaseGetPrimaryKeysA; external msilib name 'MsiDatabaseGetPrimaryKeysA';
  1558. {$ENDIF DYNAMIC_LINK}
  1560. {$IFDEF DYNAMIC_LINK}
  1561. var
  1562.   _MsiDatabaseGetPrimaryKeysW: Pointer;
  1564. function MsiDatabaseGetPrimaryKeysW;
  1565. begin
  1566.   GetProcedureAddress(_MsiDatabaseGetPrimaryKeysW, msilib, 'MsiDatabaseGetPrimaryKeysW');
  1567.   asm
  1568.     mov esp, ebp
  1569.     pop ebp
  1570.     jmp [_MsiDatabaseGetPrimaryKeysW]
  1571.   end;
  1572. end;
  1573. {$ELSE}
  1574. function MsiDatabaseGetPrimaryKeysW; external msilib name 'MsiDatabaseGetPrimaryKeysW';
  1575. {$ENDIF DYNAMIC_LINK}
  1576. {$IFDEF UNICODE}
  1578. {$IFDEF DYNAMIC_LINK}
  1579. var
  1580.   _MsiDatabaseGetPrimaryKeys: Pointer;
  1582. function MsiDatabaseGetPrimaryKeys;
  1583. begin
  1584.   GetProcedureAddress(_MsiDatabaseGetPrimaryKeys, msilib, 'MsiDatabaseGetPrimaryKeysW');
  1585.   asm
  1586.     mov esp, ebp
  1587.     pop ebp
  1588.     jmp [_MsiDatabaseGetPrimaryKeys]
  1589.   end;
  1590. end;
  1591. {$ELSE}
  1592. function MsiDatabaseGetPrimaryKeys; external msilib name 'MsiDatabaseGetPrimaryKeysW';
  1593. {$ENDIF DYNAMIC_LINK}
  1594. {$ELSE}
  1596. {$IFDEF DYNAMIC_LINK}
  1597. var
  1598.   _MsiDatabaseGetPrimaryKeys: Pointer;
  1600. function MsiDatabaseGetPrimaryKeys;
  1601. begin
  1602.   GetProcedureAddress(_MsiDatabaseGetPrimaryKeys, msilib, 'MsiDatabaseGetPrimaryKeysA');
  1603.   asm
  1604.     mov esp, ebp
  1605.     pop ebp
  1606.     jmp [_MsiDatabaseGetPrimaryKeys]
  1607.   end;
  1608. end;
  1609. {$ELSE}
  1610. function MsiDatabaseGetPrimaryKeys; external msilib name 'MsiDatabaseGetPrimaryKeysA';
  1611. {$ENDIF DYNAMIC_LINK}
  1612. {$ENDIF}
  1614. {$IFDEF DYNAMIC_LINK}
  1615. var
  1616.   _MsiDatabaseIsTablePersistentA: Pointer;
  1618. function MsiDatabaseIsTablePersistentA;
  1619. begin
  1620.   GetProcedureAddress(_MsiDatabaseIsTablePersistentA, msilib, 'MsiDatabaseIsTablePersistentA');
  1621.   asm
  1622.     mov esp, ebp
  1623.     pop ebp
  1624.     jmp [_MsiDatabaseIsTablePersistentA]
  1625.   end;
  1626. end;
  1627. {$ELSE}
  1628. function MsiDatabaseIsTablePersistentA; external msilib name 'MsiDatabaseIsTablePersistentA';
  1629. {$ENDIF DYNAMIC_LINK}
  1631. {$IFDEF DYNAMIC_LINK}
  1632. var
  1633.   _MsiDatabaseIsTablePersistentW: Pointer;
  1635. function MsiDatabaseIsTablePersistentW;
  1636. begin
  1637.   GetProcedureAddress(_MsiDatabaseIsTablePersistentW, msilib, 'MsiDatabaseIsTablePersistentW');
  1638.   asm
  1639.     mov esp, ebp
  1640.     pop ebp
  1641.     jmp [_MsiDatabaseIsTablePersistentW]
  1642.   end;
  1643. end;
  1644. {$ELSE}
  1645. function MsiDatabaseIsTablePersistentW; external msilib name 'MsiDatabaseIsTablePersistentW';
  1646. {$ENDIF DYNAMIC_LINK}
  1647. {$IFDEF UNICODE}
  1649. {$IFDEF DYNAMIC_LINK}
  1650. var
  1651.   _MsiDatabaseIsTablePersistent: Pointer;
  1653. function MsiDatabaseIsTablePersistent;
  1654. begin
  1655.   GetProcedureAddress(_MsiDatabaseIsTablePersistent, msilib, 'MsiDatabaseIsTablePersistentW');
  1656.   asm
  1657.     mov esp, ebp
  1658.     pop ebp
  1659.     jmp [_MsiDatabaseIsTablePersistent]
  1660.   end;
  1661. end;
  1662. {$ELSE}
  1663. function MsiDatabaseIsTablePersistent; external msilib name 'MsiDatabaseIsTablePersistentW';
  1664. {$ENDIF DYNAMIC_LINK}
  1665. {$ELSE}
  1667. {$IFDEF DYNAMIC_LINK}
  1668. var
  1669.   _MsiDatabaseIsTablePersistent: Pointer;
  1671. function MsiDatabaseIsTablePersistent;
  1672. begin
  1673.   GetProcedureAddress(_MsiDatabaseIsTablePersistent, msilib, 'MsiDatabaseIsTablePersistentA');
  1674.   asm
  1675.     mov esp, ebp
  1676.     pop ebp
  1677.     jmp [_MsiDatabaseIsTablePersistent]
  1678.   end;
  1679. end;
  1680. {$ELSE}
  1681. function MsiDatabaseIsTablePersistent; external msilib name 'MsiDatabaseIsTablePersistentA';
  1682. {$ENDIF DYNAMIC_LINK}
  1683. {$ENDIF}
  1685. {$IFDEF DYNAMIC_LINK}
  1686. var
  1687.   _MsiGetSummaryInformationA: Pointer;
  1689. function MsiGetSummaryInformationA;
  1690. begin
  1691.   GetProcedureAddress(_MsiGetSummaryInformationA, msilib, 'MsiGetSummaryInformationA');
  1692.   asm
  1693.     mov esp, ebp
  1694.     pop ebp
  1695.     jmp [_MsiGetSummaryInformationA]
  1696.   end;
  1697. end;
  1698. {$ELSE}
  1699. function MsiGetSummaryInformationA; external msilib name 'MsiGetSummaryInformationA';
  1700. {$ENDIF DYNAMIC_LINK}
  1702. {$IFDEF DYNAMIC_LINK}
  1703. var
  1704.   _MsiGetSummaryInformationW: Pointer;
  1706. function MsiGetSummaryInformationW;
  1707. begin
  1708.   GetProcedureAddress(_MsiGetSummaryInformationW, msilib, 'MsiGetSummaryInformationW');
  1709.   asm
  1710.     mov esp, ebp
  1711.     pop ebp
  1712.     jmp [_MsiGetSummaryInformationW]
  1713.   end;
  1714. end;
  1715. {$ELSE}
  1716. function MsiGetSummaryInformationW; external msilib name 'MsiGetSummaryInformationW';
  1717. {$ENDIF DYNAMIC_LINK}
  1718. {$IFDEF UNICODE}
  1720. {$IFDEF DYNAMIC_LINK}
  1721. var
  1722.   _MsiGetSummaryInformation: Pointer;
  1724. function MsiGetSummaryInformation;
  1725. begin
  1726.   GetProcedureAddress(_MsiGetSummaryInformation, msilib, 'MsiGetSummaryInformationW');
  1727.   asm
  1728.     mov esp, ebp
  1729.     pop ebp
  1730.     jmp [_MsiGetSummaryInformation]
  1731.   end;
  1732. end;
  1733. {$ELSE}
  1734. function MsiGetSummaryInformation; external msilib name 'MsiGetSummaryInformationW';
  1735. {$ENDIF DYNAMIC_LINK}
  1736. {$ELSE}
  1738. {$IFDEF DYNAMIC_LINK}
  1739. var
  1740.   _MsiGetSummaryInformation: Pointer;
  1742. function MsiGetSummaryInformation;
  1743. begin
  1744.   GetProcedureAddress(_MsiGetSummaryInformation, msilib, 'MsiGetSummaryInformationA');
  1745.   asm
  1746.     mov esp, ebp
  1747.     pop ebp
  1748.     jmp [_MsiGetSummaryInformation]
  1749.   end;
  1750. end;
  1751. {$ELSE}
  1752. function MsiGetSummaryInformation; external msilib name 'MsiGetSummaryInformationA';
  1753. {$ENDIF DYNAMIC_LINK}
  1754. {$ENDIF}
  1756. {$IFDEF DYNAMIC_LINK}
  1757. var
  1758.   _MsiSummaryInfoGetPropertyCount: Pointer;
  1760. function MsiSummaryInfoGetPropertyCount;
  1761. begin
  1762.   GetProcedureAddress(_MsiSummaryInfoGetPropertyCount, msilib, 'MsiSummaryInfoGetPropertyCount');
  1763.   asm
  1764.     mov esp, ebp
  1765.     pop ebp
  1766.     jmp [_MsiSummaryInfoGetPropertyCount]
  1767.   end;
  1768. end;
  1769. {$ELSE}
  1770. function MsiSummaryInfoGetPropertyCount; external msilib name 'MsiSummaryInfoGetPropertyCount';
  1771. {$ENDIF DYNAMIC_LINK}
  1773. {$IFDEF DYNAMIC_LINK}
  1774. var
  1775.   _MsiSummaryInfoSetPropertyA: Pointer;
  1777. function MsiSummaryInfoSetPropertyA;
  1778. begin
  1779.   GetProcedureAddress(_MsiSummaryInfoSetPropertyA, msilib, 'MsiSummaryInfoSetPropertyA');
  1780.   asm
  1781.     mov esp, ebp
  1782.     pop ebp
  1783.     jmp [_MsiSummaryInfoSetPropertyA]
  1784.   end;
  1785. end;
  1786. {$ELSE}
  1787. function MsiSummaryInfoSetPropertyA; external msilib name 'MsiSummaryInfoSetPropertyA';
  1788. {$ENDIF DYNAMIC_LINK}
  1790. {$IFDEF DYNAMIC_LINK}
  1791. var
  1792.   _MsiSummaryInfoSetPropertyW: Pointer;
  1794. function MsiSummaryInfoSetPropertyW;
  1795. begin
  1796.   GetProcedureAddress(_MsiSummaryInfoSetPropertyW, msilib, 'MsiSummaryInfoSetPropertyW');
  1797.   asm
  1798.     mov esp, ebp
  1799.     pop ebp
  1800.     jmp [_MsiSummaryInfoSetPropertyW]
  1801.   end;
  1802. end;
  1803. {$ELSE}
  1804. function MsiSummaryInfoSetPropertyW; external msilib name 'MsiSummaryInfoSetPropertyW';
  1805. {$ENDIF DYNAMIC_LINK}
  1806. {$IFDEF UNICODE}
  1808. {$IFDEF DYNAMIC_LINK}
  1809. var
  1810.   _MsiSummaryInfoSetProperty: Pointer;
  1812. function MsiSummaryInfoSetProperty;
  1813. begin
  1814.   GetProcedureAddress(_MsiSummaryInfoSetProperty, msilib, 'MsiSummaryInfoSetPropertyW');
  1815.   asm
  1816.     mov esp, ebp
  1817.     pop ebp
  1818.     jmp [_MsiSummaryInfoSetProperty]
  1819.   end;
  1820. end;
  1821. {$ELSE}
  1822. function MsiSummaryInfoSetProperty; external msilib name 'MsiSummaryInfoSetPropertyW';
  1823. {$ENDIF DYNAMIC_LINK}
  1824. {$ELSE}
  1826. {$IFDEF DYNAMIC_LINK}
  1827. var
  1828.   _MsiSummaryInfoSetProperty: Pointer;
  1830. function MsiSummaryInfoSetProperty;
  1831. begin
  1832.   GetProcedureAddress(_MsiSummaryInfoSetProperty, msilib, 'MsiSummaryInfoSetPropertyA');
  1833.   asm
  1834.     mov esp, ebp
  1835.     pop ebp
  1836.     jmp [_MsiSummaryInfoSetProperty]
  1837.   end;
  1838. end;
  1839. {$ELSE}
  1840. function MsiSummaryInfoSetProperty; external msilib name 'MsiSummaryInfoSetPropertyA';
  1841. {$ENDIF DYNAMIC_LINK}
  1842. {$ENDIF}
  1844. {$IFDEF DYNAMIC_LINK}
  1845. var
  1846.   _MsiSummaryInfoGetPropertyA: Pointer;
  1848. function MsiSummaryInfoGetPropertyA;
  1849. begin
  1850.   GetProcedureAddress(_MsiSummaryInfoGetPropertyA, msilib, 'MsiSummaryInfoGetPropertyA');
  1851.   asm
  1852.     mov esp, ebp
  1853.     pop ebp
  1854.     jmp [_MsiSummaryInfoGetPropertyA]
  1855.   end;
  1856. end;
  1857. {$ELSE}
  1858. function MsiSummaryInfoGetPropertyA; external msilib name 'MsiSummaryInfoGetPropertyA';
  1859. {$ENDIF DYNAMIC_LINK}
  1861. {$IFDEF DYNAMIC_LINK}
  1862. var
  1863.   _MsiSummaryInfoGetPropertyW: Pointer;
  1865. function MsiSummaryInfoGetPropertyW;
  1866. begin
  1867.   GetProcedureAddress(_MsiSummaryInfoGetPropertyW, msilib, 'MsiSummaryInfoGetPropertyW');
  1868.   asm
  1869.     mov esp, ebp
  1870.     pop ebp
  1871.     jmp [_MsiSummaryInfoGetPropertyW]
  1872.   end;
  1873. end;
  1874. {$ELSE}
  1875. function MsiSummaryInfoGetPropertyW; external msilib name 'MsiSummaryInfoGetPropertyW';
  1876. {$ENDIF DYNAMIC_LINK}
  1877. {$IFDEF UNICODE}
  1879. {$IFDEF DYNAMIC_LINK}
  1880. var
  1881.   _MsiSummaryInfoGetProperty: Pointer;
  1883. function MsiSummaryInfoGetProperty;
  1884. begin
  1885.   GetProcedureAddress(_MsiSummaryInfoGetProperty, msilib, 'MsiSummaryInfoGetPropertyW');
  1886.   asm
  1887.     mov esp, ebp
  1888.     pop ebp
  1889.     jmp [_MsiSummaryInfoGetProperty]
  1890.   end;
  1891. end;
  1892. {$ELSE}
  1893. function MsiSummaryInfoGetProperty; external msilib name 'MsiSummaryInfoGetPropertyW';
  1894. {$ENDIF DYNAMIC_LINK}
  1895. {$ELSE}
  1897. {$IFDEF DYNAMIC_LINK}
  1898. var
  1899.   _MsiSummaryInfoGetProperty: Pointer;
  1901. function MsiSummaryInfoGetProperty;
  1902. begin
  1903.   GetProcedureAddress(_MsiSummaryInfoGetProperty, msilib, 'MsiSummaryInfoGetPropertyA');
  1904.   asm
  1905.     mov esp, ebp
  1906.     pop ebp
  1907.     jmp [_MsiSummaryInfoGetProperty]
  1908.   end;
  1909. end;
  1910. {$ELSE}
  1911. function MsiSummaryInfoGetProperty; external msilib name 'MsiSummaryInfoGetPropertyA';
  1912. {$ENDIF DYNAMIC_LINK}
  1913. {$ENDIF}
  1915. {$IFDEF DYNAMIC_LINK}
  1916. var
  1917.   _MsiSummaryInfoPersist: Pointer;
  1919. function MsiSummaryInfoPersist;
  1920. begin
  1921.   GetProcedureAddress(_MsiSummaryInfoPersist, msilib, 'MsiSummaryInfoPersist');
  1922.   asm
  1923.     mov esp, ebp
  1924.     pop ebp
  1925.     jmp [_MsiSummaryInfoPersist]
  1926.   end;
  1927. end;
  1928. {$ELSE}
  1929. function MsiSummaryInfoPersist; external msilib name 'MsiSummaryInfoPersist';
  1930. {$ENDIF DYNAMIC_LINK}
  1932. {$IFDEF DYNAMIC_LINK}
  1933. var
  1934.   _MsiOpenDatabaseA: Pointer;
  1936. function MsiOpenDatabaseA;
  1937. begin
  1938.   GetProcedureAddress(_MsiOpenDatabaseA, msilib, 'MsiOpenDatabaseA');
  1939.   asm
  1940.     mov esp, ebp
  1941.     pop ebp
  1942.     jmp [_MsiOpenDatabaseA]
  1943.   end;
  1944. end;
  1945. {$ELSE}
  1946. function MsiOpenDatabaseA; external msilib name 'MsiOpenDatabaseA';
  1947. {$ENDIF DYNAMIC_LINK}
  1949. {$IFDEF DYNAMIC_LINK}
  1950. var
  1951.   _MsiOpenDatabaseW: Pointer;
  1953. function MsiOpenDatabaseW;
  1954. begin
  1955.   GetProcedureAddress(_MsiOpenDatabaseW, msilib, 'MsiOpenDatabaseW');
  1956.   asm
  1957.     mov esp, ebp
  1958.     pop ebp
  1959.     jmp [_MsiOpenDatabaseW]
  1960.   end;
  1961. end;
  1962. {$ELSE}
  1963. function MsiOpenDatabaseW; external msilib name 'MsiOpenDatabaseW';
  1964. {$ENDIF DYNAMIC_LINK}
  1965. {$IFDEF UNICODE}
  1967. {$IFDEF DYNAMIC_LINK}
  1968. var
  1969.   _MsiOpenDatabase: Pointer;
  1971. function MsiOpenDatabase;
  1972. begin
  1973.   GetProcedureAddress(_MsiOpenDatabase, msilib, 'MsiOpenDatabaseW');
  1974.   asm
  1975.     mov esp, ebp
  1976.     pop ebp
  1977.     jmp [_MsiOpenDatabase]
  1978.   end;
  1979. end;
  1980. {$ELSE}
  1981. function MsiOpenDatabase; external msilib name 'MsiOpenDatabaseW';
  1982. {$ENDIF DYNAMIC_LINK}
  1983. {$ELSE}
  1985. {$IFDEF DYNAMIC_LINK}
  1986. var
  1987.   _MsiOpenDatabase: Pointer;
  1989. function MsiOpenDatabase;
  1990. begin
  1991.   GetProcedureAddress(_MsiOpenDatabase, msilib, 'MsiOpenDatabaseA');
  1992.   asm
  1993.     mov esp, ebp
  1994.     pop ebp
  1995.     jmp [_MsiOpenDatabase]
  1996.   end;
  1997. end;
  1998. {$ELSE}
  1999. function MsiOpenDatabase; external msilib name 'MsiOpenDatabaseA';
  2000. {$ENDIF DYNAMIC_LINK}
  2001. {$ENDIF}
  2003. {$IFDEF DYNAMIC_LINK}
  2004. var
  2005.   _MsiDatabaseImportA: Pointer;
  2007. function MsiDatabaseImportA;
  2008. begin
  2009.   GetProcedureAddress(_MsiDatabaseImportA, msilib, 'MsiDatabaseImportA');
  2010.   asm
  2011.     mov esp, ebp
  2012.     pop ebp
  2013.     jmp [_MsiDatabaseImportA]
  2014.   end;
  2015. end;
  2016. {$ELSE}
  2017. function MsiDatabaseImportA; external msilib name 'MsiDatabaseImportA';
  2018. {$ENDIF DYNAMIC_LINK}
  2020. {$IFDEF DYNAMIC_LINK}
  2021. var
  2022.   _MsiDatabaseImportW: Pointer;
  2024. function MsiDatabaseImportW;
  2025. begin
  2026.   GetProcedureAddress(_MsiDatabaseImportW, msilib, 'MsiDatabaseImportW');
  2027.   asm
  2028.     mov esp, ebp
  2029.     pop ebp
  2030.     jmp [_MsiDatabaseImportW]
  2031.   end;
  2032. end;
  2033. {$ELSE}
  2034. function MsiDatabaseImportW; external msilib name 'MsiDatabaseImportW';
  2035. {$ENDIF DYNAMIC_LINK}
  2036. {$IFDEF UNICODE}
  2038. {$IFDEF DYNAMIC_LINK}
  2039. var
  2040.   _MsiDatabaseImport: Pointer;
  2042. function MsiDatabaseImport;
  2043. begin
  2044.   GetProcedureAddress(_MsiDatabaseImport, msilib, 'MsiDatabaseImportW');
  2045.   asm
  2046.     mov esp, ebp
  2047.     pop ebp
  2048.     jmp [_MsiDatabaseImport]
  2049.   end;
  2050. end;
  2051. {$ELSE}
  2052. function MsiDatabaseImport; external msilib name 'MsiDatabaseImportW';
  2053. {$ENDIF DYNAMIC_LINK}
  2054. {$ELSE}
  2056. {$IFDEF DYNAMIC_LINK}
  2057. var
  2058.   _MsiDatabaseImport: Pointer;
  2060. function MsiDatabaseImport;
  2061. begin
  2062.   GetProcedureAddress(_MsiDatabaseImport, msilib, 'MsiDatabaseImportA');
  2063.   asm
  2064.     mov esp, ebp
  2065.     pop ebp
  2066.     jmp [_MsiDatabaseImport]
  2067.   end;
  2068. end;
  2069. {$ELSE}
  2070. function MsiDatabaseImport; external msilib name 'MsiDatabaseImportA';
  2071. {$ENDIF DYNAMIC_LINK}
  2072. {$ENDIF}
  2074. {$IFDEF DYNAMIC_LINK}
  2075. var
  2076.   _MsiDatabaseExportA: Pointer;
  2078. function MsiDatabaseExportA;
  2079. begin
  2080.   GetProcedureAddress(_MsiDatabaseExportA, msilib, 'MsiDatabaseExportA');
  2081.   asm
  2082.     mov esp, ebp
  2083.     pop ebp
  2084.     jmp [_MsiDatabaseExportA]
  2085.   end;
  2086. end;
  2087. {$ELSE}
  2088. function MsiDatabaseExportA; external msilib name 'MsiDatabaseExportA';
  2089. {$ENDIF DYNAMIC_LINK}
  2091. {$IFDEF DYNAMIC_LINK}
  2092. var
  2093.   _MsiDatabaseExportW: Pointer;
  2095. function MsiDatabaseExportW;
  2096. begin
  2097.   GetProcedureAddress(_MsiDatabaseExportW, msilib, 'MsiDatabaseExportW');
  2098.   asm
  2099.     mov esp, ebp
  2100.     pop ebp
  2101.     jmp [_MsiDatabaseExportW]
  2102.   end;
  2103. end;
  2104. {$ELSE}
  2105. function MsiDatabaseExportW; external msilib name 'MsiDatabaseExportW';
  2106. {$ENDIF DYNAMIC_LINK}
  2107. {$IFDEF UNICODE}
  2109. {$IFDEF DYNAMIC_LINK}
  2110. var
  2111.   _MsiDatabaseExport: Pointer;
  2113. function MsiDatabaseExport;
  2114. begin
  2115.   GetProcedureAddress(_MsiDatabaseExport, msilib, 'MsiDatabaseExportW');
  2116.   asm
  2117.     mov esp, ebp
  2118.     pop ebp
  2119.     jmp [_MsiDatabaseExport]
  2120.   end;
  2121. end;
  2122. {$ELSE}
  2123. function MsiDatabaseExport; external msilib name 'MsiDatabaseExportW';
  2124. {$ENDIF DYNAMIC_LINK}
  2125. {$ELSE}
  2127. {$IFDEF DYNAMIC_LINK}
  2128. var
  2129.   _MsiDatabaseExport: Pointer;
  2131. function MsiDatabaseExport;
  2132. begin
  2133.   GetProcedureAddress(_MsiDatabaseExport, msilib, 'MsiDatabaseExportA');
  2134.   asm
  2135.     mov esp, ebp
  2136.     pop ebp
  2137.     jmp [_MsiDatabaseExport]
  2138.   end;
  2139. end;
  2140. {$ELSE}
  2141. function MsiDatabaseExport; external msilib name 'MsiDatabaseExportA';
  2142. {$ENDIF DYNAMIC_LINK}
  2143. {$ENDIF}
  2145. {$IFDEF DYNAMIC_LINK}
  2146. var
  2147.   _MsiDatabaseMergeA: Pointer;
  2149. function MsiDatabaseMergeA;
  2150. begin
  2151.   GetProcedureAddress(_MsiDatabaseMergeA, msilib, 'MsiDatabaseMergeA');
  2152.   asm
  2153.     mov esp, ebp
  2154.     pop ebp
  2155.     jmp [_MsiDatabaseMergeA]
  2156.   end;
  2157. end;
  2158. {$ELSE}
  2159. function MsiDatabaseMergeA; external msilib name 'MsiDatabaseMergeA';
  2160. {$ENDIF DYNAMIC_LINK}
  2162. {$IFDEF DYNAMIC_LINK}
  2163. var
  2164.   _MsiDatabaseMergeW: Pointer;
  2166. function MsiDatabaseMergeW;
  2167. begin
  2168.   GetProcedureAddress(_MsiDatabaseMergeW, msilib, 'MsiDatabaseMergeW');
  2169.   asm
  2170.     mov esp, ebp
  2171.     pop ebp
  2172.     jmp [_MsiDatabaseMergeW]
  2173.   end;
  2174. end;
  2175. {$ELSE}
  2176. function MsiDatabaseMergeW; external msilib name 'MsiDatabaseMergeW';
  2177. {$ENDIF DYNAMIC_LINK}
  2178. {$IFDEF UNICODE}
  2180. {$IFDEF DYNAMIC_LINK}
  2181. var
  2182.   _MsiDatabaseMerge: Pointer;
  2184. function MsiDatabaseMerge;
  2185. begin
  2186.   GetProcedureAddress(_MsiDatabaseMerge, msilib, 'MsiDatabaseMergeW');
  2187.   asm
  2188.     mov esp, ebp
  2189.     pop ebp
  2190.     jmp [_MsiDatabaseMerge]
  2191.   end;
  2192. end;
  2193. {$ELSE}
  2194. function MsiDatabaseMerge; external msilib name 'MsiDatabaseMergeW';
  2195. {$ENDIF DYNAMIC_LINK}
  2196. {$ELSE}
  2198. {$IFDEF DYNAMIC_LINK}
  2199. var
  2200.   _MsiDatabaseMerge: Pointer;
  2202. function MsiDatabaseMerge;
  2203. begin
  2204.   GetProcedureAddress(_MsiDatabaseMerge, msilib, 'MsiDatabaseMergeA');
  2205.   asm
  2206.     mov esp, ebp
  2207.     pop ebp
  2208.     jmp [_MsiDatabaseMerge]
  2209.   end;
  2210. end;
  2211. {$ELSE}
  2212. function MsiDatabaseMerge; external msilib name 'MsiDatabaseMergeA';
  2213. {$ENDIF DYNAMIC_LINK}
  2214. {$ENDIF}
  2216. {$IFDEF DYNAMIC_LINK}
  2217. var
  2218.   _MsiDatabaseGenerateTransformA: Pointer;
  2220. function MsiDatabaseGenerateTransformA;
  2221. begin
  2222.   GetProcedureAddress(_MsiDatabaseGenerateTransformA, msilib, 'MsiDatabaseGenerateTransformA');
  2223.   asm
  2224.     mov esp, ebp
  2225.     pop ebp
  2226.     jmp [_MsiDatabaseGenerateTransformA]
  2227.   end;
  2228. end;
  2229. {$ELSE}
  2230. function MsiDatabaseGenerateTransformA; external msilib name 'MsiDatabaseGenerateTransformA';
  2231. {$ENDIF DYNAMIC_LINK}
  2233. {$IFDEF DYNAMIC_LINK}
  2234. var
  2235.   _MsiDatabaseGenerateTransformW: Pointer;
  2237. function MsiDatabaseGenerateTransformW;
  2238. begin
  2239.   GetProcedureAddress(_MsiDatabaseGenerateTransformW, msilib, 'MsiDatabaseGenerateTransformW');
  2240.   asm
  2241.     mov esp, ebp
  2242.     pop ebp
  2243.     jmp [_MsiDatabaseGenerateTransformW]
  2244.   end;
  2245. end;
  2246. {$ELSE}
  2247. function MsiDatabaseGenerateTransformW; external msilib name 'MsiDatabaseGenerateTransformW';
  2248. {$ENDIF DYNAMIC_LINK}
  2249. {$IFDEF UNICODE}
  2251. {$IFDEF DYNAMIC_LINK}
  2252. var
  2253.   _MsiDatabaseGenerateTransform: Pointer;
  2255. function MsiDatabaseGenerateTransform;
  2256. begin
  2257.   GetProcedureAddress(_MsiDatabaseGenerateTransform, msilib, 'MsiDatabaseGenerateTransformW');
  2258.   asm
  2259.     mov esp, ebp
  2260.     pop ebp
  2261.     jmp [_MsiDatabaseGenerateTransform]
  2262.   end;
  2263. end;
  2264. {$ELSE}
  2265. function MsiDatabaseGenerateTransform; external msilib name 'MsiDatabaseGenerateTransformW';
  2266. {$ENDIF DYNAMIC_LINK}
  2267. {$ELSE}
  2269. {$IFDEF DYNAMIC_LINK}
  2270. var
  2271.   _MsiDatabaseGenerateTransform: Pointer;
  2273. function MsiDatabaseGenerateTransform;
  2274. begin
  2275.   GetProcedureAddress(_MsiDatabaseGenerateTransform, msilib, 'MsiDatabaseGenerateTransformA');
  2276.   asm
  2277.     mov esp, ebp
  2278.     pop ebp
  2279.     jmp [_MsiDatabaseGenerateTransform]
  2280.   end;
  2281. end;
  2282. {$ELSE}
  2283. function MsiDatabaseGenerateTransform; external msilib name 'MsiDatabaseGenerateTransformA';
  2284. {$ENDIF DYNAMIC_LINK}
  2285. {$ENDIF}
  2287. {$IFDEF DYNAMIC_LINK}
  2288. var
  2289.   _MsiDatabaseApplyTransformA: Pointer;
  2291. function MsiDatabaseApplyTransformA;
  2292. begin
  2293.   GetProcedureAddress(_MsiDatabaseApplyTransformA, msilib, 'MsiDatabaseApplyTransformA');
  2294.   asm
  2295.     mov esp, ebp
  2296.     pop ebp
  2297.     jmp [_MsiDatabaseApplyTransformA]
  2298.   end;
  2299. end;
  2300. {$ELSE}
  2301. function MsiDatabaseApplyTransformA; external msilib name 'MsiDatabaseApplyTransformA';
  2302. {$ENDIF DYNAMIC_LINK}
  2304. {$IFDEF DYNAMIC_LINK}
  2305. var
  2306.   _MsiDatabaseApplyTransformW: Pointer;
  2308. function MsiDatabaseApplyTransformW;
  2309. begin
  2310.   GetProcedureAddress(_MsiDatabaseApplyTransformW, msilib, 'MsiDatabaseApplyTransformW');
  2311.   asm
  2312.     mov esp, ebp
  2313.     pop ebp
  2314.     jmp [_MsiDatabaseApplyTransformW]
  2315.   end;
  2316. end;
  2317. {$ELSE}
  2318. function MsiDatabaseApplyTransformW; external msilib name 'MsiDatabaseApplyTransformW';
  2319. {$ENDIF DYNAMIC_LINK}
  2320. {$IFDEF UNICODE}
  2322. {$IFDEF DYNAMIC_LINK}
  2323. var
  2324.   _MsiDatabaseApplyTransform: Pointer;
  2326. function MsiDatabaseApplyTransform;
  2327. begin
  2328.   GetProcedureAddress(_MsiDatabaseApplyTransform, msilib, 'MsiDatabaseApplyTransformW');
  2329.   asm
  2330.     mov esp, ebp
  2331.     pop ebp
  2332.     jmp [_MsiDatabaseApplyTransform]
  2333.   end;
  2334. end;
  2335. {$ELSE}
  2336. function MsiDatabaseApplyTransform; external msilib name 'MsiDatabaseApplyTransformW';
  2337. {$ENDIF DYNAMIC_LINK}
  2338. {$ELSE}
  2340. {$IFDEF DYNAMIC_LINK}
  2341. var
  2342.   _MsiDatabaseApplyTransform: Pointer;
  2344. function MsiDatabaseApplyTransform;
  2345. begin
  2346.   GetProcedureAddress(_MsiDatabaseApplyTransform, msilib, 'MsiDatabaseApplyTransformA');
  2347.   asm
  2348.     mov esp, ebp
  2349.     pop ebp
  2350.     jmp [_MsiDatabaseApplyTransform]
  2351.   end;
  2352. end;
  2353. {$ELSE}
  2354. function MsiDatabaseApplyTransform; external msilib name 'MsiDatabaseApplyTransformA';
  2355. {$ENDIF DYNAMIC_LINK}
  2356. {$ENDIF}
  2358. {$IFDEF DYNAMIC_LINK}
  2359. var
  2360.   _MsiCreateTransformSummaryInfoA: Pointer;
  2362. function MsiCreateTransformSummaryInfoA;
  2363. begin
  2364.   GetProcedureAddress(_MsiCreateTransformSummaryInfoA, msilib, 'MsiCreateTransformSummaryInfoA');
  2365.   asm
  2366.     mov esp, ebp
  2367.     pop ebp
  2368.     jmp [_MsiCreateTransformSummaryInfoA]
  2369.   end;
  2370. end;
  2371. {$ELSE}
  2372. function MsiCreateTransformSummaryInfoA; external msilib name 'MsiCreateTransformSummaryInfoA';
  2373. {$ENDIF DYNAMIC_LINK}
  2375. {$IFDEF DYNAMIC_LINK}
  2376. var
  2377.   _MsiCreateTransformSummaryInfoW: Pointer;
  2379. function MsiCreateTransformSummaryInfoW;
  2380. begin
  2381.   GetProcedureAddress(_MsiCreateTransformSummaryInfoW, msilib, 'MsiCreateTransformSummaryInfoW');
  2382.   asm
  2383.     mov esp, ebp
  2384.     pop ebp
  2385.     jmp [_MsiCreateTransformSummaryInfoW]
  2386.   end;
  2387. end;
  2388. {$ELSE}
  2389. function MsiCreateTransformSummaryInfoW; external msilib name 'MsiCreateTransformSummaryInfoW';
  2390. {$ENDIF DYNAMIC_LINK}
  2391. {$IFDEF UNICODE}
  2393. {$IFDEF DYNAMIC_LINK}
  2394. var
  2395.   _MsiCreateTransformSummaryInfo: Pointer;
  2397. function MsiCreateTransformSummaryInfo;
  2398. begin
  2399.   GetProcedureAddress(_MsiCreateTransformSummaryInfo, msilib, 'MsiCreateTransformSummaryInfoW');
  2400.   asm
  2401.     mov esp, ebp
  2402.     pop ebp
  2403.     jmp [_MsiCreateTransformSummaryInfo]
  2404.   end;
  2405. end;
  2406. {$ELSE}
  2407. function MsiCreateTransformSummaryInfo; external msilib name 'MsiCreateTransformSummaryInfoW';
  2408. {$ENDIF DYNAMIC_LINK}
  2409. {$ELSE}
  2411. {$IFDEF DYNAMIC_LINK}
  2412. var
  2413.   _MsiCreateTransformSummaryInfo: Pointer;
  2415. function MsiCreateTransformSummaryInfo;
  2416. begin
  2417.   GetProcedureAddress(_MsiCreateTransformSummaryInfo, msilib, 'MsiCreateTransformSummaryInfoA');
  2418.   asm
  2419.     mov esp, ebp
  2420.     pop ebp
  2421.     jmp [_MsiCreateTransformSummaryInfo]
  2422.   end;
  2423. end;
  2424. {$ELSE}
  2425. function MsiCreateTransformSummaryInfo; external msilib name 'MsiCreateTransformSummaryInfoA';
  2426. {$ENDIF DYNAMIC_LINK}
  2427. {$ENDIF}
  2429. {$IFDEF DYNAMIC_LINK}
  2430. var
  2431.   _MsiDatabaseCommit: Pointer;
  2433. function MsiDatabaseCommit;
  2434. begin
  2435.   GetProcedureAddress(_MsiDatabaseCommit, msilib, 'MsiDatabaseCommit');
  2436.   asm
  2437.     mov esp, ebp
  2438.     pop ebp
  2439.     jmp [_MsiDatabaseCommit]
  2440.   end;
  2441. end;
  2442. {$ELSE}
  2443. function MsiDatabaseCommit; external msilib name 'MsiDatabaseCommit';
  2444. {$ENDIF DYNAMIC_LINK}
  2446. {$IFDEF DYNAMIC_LINK}
  2447. var
  2448.   _MsiGetDatabaseState: Pointer;
  2450. function MsiGetDatabaseState;
  2451. begin
  2452.   GetProcedureAddress(_MsiGetDatabaseState, msilib, 'MsiGetDatabaseState');
  2453.   asm
  2454.     mov esp, ebp
  2455.     pop ebp
  2456.     jmp [_MsiGetDatabaseState]
  2457.   end;
  2458. end;
  2459. {$ELSE}
  2460. function MsiGetDatabaseState; external msilib name 'MsiGetDatabaseState';
  2461. {$ENDIF DYNAMIC_LINK}
  2463. {$IFDEF DYNAMIC_LINK}
  2464. var
  2465.   _MsiCreateRecord: Pointer;
  2467. function MsiCreateRecord;
  2468. begin
  2469.   GetProcedureAddress(_MsiCreateRecord, msilib, 'MsiCreateRecord');
  2470.   asm
  2471.     mov esp, ebp
  2472.     pop ebp
  2473.     jmp [_MsiCreateRecord]
  2474.   end;
  2475. end;
  2476. {$ELSE}
  2477. function MsiCreateRecord; external msilib name 'MsiCreateRecord';
  2478. {$ENDIF DYNAMIC_LINK}
  2480. {$IFDEF DYNAMIC_LINK}
  2481. var
  2482.   _MsiRecordIsNull: Pointer;
  2484. function MsiRecordIsNull;
  2485. begin
  2486.   GetProcedureAddress(_MsiRecordIsNull, msilib, 'MsiRecordIsNull');
  2487.   asm
  2488.     mov esp, ebp
  2489.     pop ebp
  2490.     jmp [_MsiRecordIsNull]
  2491.   end;
  2492. end;
  2493. {$ELSE}
  2494. function MsiRecordIsNull; external msilib name 'MsiRecordIsNull';
  2495. {$ENDIF DYNAMIC_LINK}
  2497. {$IFDEF DYNAMIC_LINK}
  2498. var
  2499.   _MsiRecordDataSize: Pointer;
  2501. function MsiRecordDataSize;
  2502. begin
  2503.   GetProcedureAddress(_MsiRecordDataSize, msilib, 'MsiRecordDataSize');
  2504.   asm
  2505.     mov esp, ebp
  2506.     pop ebp
  2507.     jmp [_MsiRecordDataSize]
  2508.   end;
  2509. end;
  2510. {$ELSE}
  2511. function MsiRecordDataSize; external msilib name 'MsiRecordDataSize';
  2512. {$ENDIF DYNAMIC_LINK}
  2514. {$IFDEF DYNAMIC_LINK}
  2515. var
  2516.   _MsiRecordSetInteger: Pointer;
  2518. function MsiRecordSetInteger;
  2519. begin
  2520.   GetProcedureAddress(_MsiRecordSetInteger, msilib, 'MsiRecordSetInteger');
  2521.   asm
  2522.     mov esp, ebp
  2523.     pop ebp
  2524.     jmp [_MsiRecordSetInteger]
  2525.   end;
  2526. end;
  2527. {$ELSE}
  2528. function MsiRecordSetInteger; external msilib name 'MsiRecordSetInteger';
  2529. {$ENDIF DYNAMIC_LINK}
  2531. {$IFDEF DYNAMIC_LINK}
  2532. var
  2533.   _MsiRecordSetStringA: Pointer;
  2535. function MsiRecordSetStringA;
  2536. begin
  2537.   GetProcedureAddress(_MsiRecordSetStringA, msilib, 'MsiRecordSetStringA');
  2538.   asm
  2539.     mov esp, ebp
  2540.     pop ebp
  2541.     jmp [_MsiRecordSetStringA]
  2542.   end;
  2543. end;
  2544. {$ELSE}
  2545. function MsiRecordSetStringA; external msilib name 'MsiRecordSetStringA';
  2546. {$ENDIF DYNAMIC_LINK}
  2548. {$IFDEF DYNAMIC_LINK}
  2549. var
  2550.   _MsiRecordSetStringW: Pointer;
  2552. function MsiRecordSetStringW;
  2553. begin
  2554.   GetProcedureAddress(_MsiRecordSetStringW, msilib, 'MsiRecordSetStringW');
  2555.   asm
  2556.     mov esp, ebp
  2557.     pop ebp
  2558.     jmp [_MsiRecordSetStringW]
  2559.   end;
  2560. end;
  2561. {$ELSE}
  2562. function MsiRecordSetStringW; external msilib name 'MsiRecordSetStringW';
  2563. {$ENDIF DYNAMIC_LINK}
  2564. {$IFDEF UNICODE}
  2566. {$IFDEF DYNAMIC_LINK}
  2567. var
  2568.   _MsiRecordSetString: Pointer;
  2570. function MsiRecordSetString;
  2571. begin
  2572.   GetProcedureAddress(_MsiRecordSetString, msilib, 'MsiRecordSetStringW');
  2573.   asm
  2574.     mov esp, ebp
  2575.     pop ebp
  2576.     jmp [_MsiRecordSetString]
  2577.   end;
  2578. end;
  2579. {$ELSE}
  2580. function MsiRecordSetString; external msilib name 'MsiRecordSetStringW';
  2581. {$ENDIF DYNAMIC_LINK}
  2582. {$ELSE}
  2584. {$IFDEF DYNAMIC_LINK}
  2585. var
  2586.   _MsiRecordSetString: Pointer;
  2588. function MsiRecordSetString;
  2589. begin
  2590.   GetProcedureAddress(_MsiRecordSetString, msilib, 'MsiRecordSetStringA');
  2591.   asm
  2592.     mov esp, ebp
  2593.     pop ebp
  2594.     jmp [_MsiRecordSetString]
  2595.   end;
  2596. end;
  2597. {$ELSE}
  2598. function MsiRecordSetString; external msilib name 'MsiRecordSetStringA';
  2599. {$ENDIF DYNAMIC_LINK}
  2600. {$ENDIF}
  2602. {$IFDEF DYNAMIC_LINK}
  2603. var
  2604.   _MsiRecordGetInteger: Pointer;
  2606. function MsiRecordGetInteger;
  2607. begin
  2608.   GetProcedureAddress(_MsiRecordGetInteger, msilib, 'MsiRecordGetInteger');
  2609.   asm
  2610.     mov esp, ebp
  2611.     pop ebp
  2612.     jmp [_MsiRecordGetInteger]
  2613.   end;
  2614. end;
  2615. {$ELSE}
  2616. function MsiRecordGetInteger; external msilib name 'MsiRecordGetInteger';
  2617. {$ENDIF DYNAMIC_LINK}
  2619. {$IFDEF DYNAMIC_LINK}
  2620. var
  2621.   _MsiRecordGetStringA: Pointer;
  2623. function MsiRecordGetStringA;
  2624. begin
  2625.   GetProcedureAddress(_MsiRecordGetStringA, msilib, 'MsiRecordGetStringA');
  2626.   asm
  2627.     mov esp, ebp
  2628.     pop ebp
  2629.     jmp [_MsiRecordGetStringA]
  2630.   end;
  2631. end;
  2632. {$ELSE}
  2633. function MsiRecordGetStringA; external msilib name 'MsiRecordGetStringA';
  2634. {$ENDIF DYNAMIC_LINK}
  2636. {$IFDEF DYNAMIC_LINK}
  2637. var
  2638.   _MsiRecordGetStringW: Pointer;
  2640. function MsiRecordGetStringW;
  2641. begin
  2642.   GetProcedureAddress(_MsiRecordGetStringW, msilib, 'MsiRecordGetStringW');
  2643.   asm
  2644.     mov esp, ebp
  2645.     pop ebp
  2646.     jmp [_MsiRecordGetStringW]
  2647.   end;
  2648. end;
  2649. {$ELSE}
  2650. function MsiRecordGetStringW; external msilib name 'MsiRecordGetStringW';
  2651. {$ENDIF DYNAMIC_LINK}
  2652. {$IFDEF UNICODE}
  2654. {$IFDEF DYNAMIC_LINK}
  2655. var
  2656.   _MsiRecordGetString: Pointer;
  2658. function MsiRecordGetString;
  2659. begin
  2660.   GetProcedureAddress(_MsiRecordGetString, msilib, 'MsiRecordGetStringW');
  2661.   asm
  2662.     mov esp, ebp
  2663.     pop ebp
  2664.     jmp [_MsiRecordGetString]
  2665.   end;
  2666. end;
  2667. {$ELSE}
  2668. function MsiRecordGetString; external msilib name 'MsiRecordGetStringW';
  2669. {$ENDIF DYNAMIC_LINK}
  2670. {$ELSE}
  2672. {$IFDEF DYNAMIC_LINK}
  2673. var
  2674.   _MsiRecordGetString: Pointer;
  2676. function MsiRecordGetString;
  2677. begin
  2678.   GetProcedureAddress(_MsiRecordGetString, msilib, 'MsiRecordGetStringA');
  2679.   asm
  2680.     mov esp, ebp
  2681.     pop ebp
  2682.     jmp [_MsiRecordGetString]
  2683.   end;
  2684. end;
  2685. {$ELSE}
  2686. function MsiRecordGetString; external msilib name 'MsiRecordGetStringA';
  2687. {$ENDIF DYNAMIC_LINK}
  2688. {$ENDIF}
  2690. {$IFDEF DYNAMIC_LINK}
  2691. var
  2692.   _MsiRecordGetFieldCount: Pointer;
  2694. function MsiRecordGetFieldCount;
  2695. begin
  2696.   GetProcedureAddress(_MsiRecordGetFieldCount, msilib, 'MsiRecordGetFieldCount');
  2697.   asm
  2698.     mov esp, ebp
  2699.     pop ebp
  2700.     jmp [_MsiRecordGetFieldCount]
  2701.   end;
  2702. end;
  2703. {$ELSE}
  2704. function MsiRecordGetFieldCount; external msilib name 'MsiRecordGetFieldCount';
  2705. {$ENDIF DYNAMIC_LINK}
  2707. {$IFDEF DYNAMIC_LINK}
  2708. var
  2709.   _MsiRecordSetStreamA: Pointer;
  2711. function MsiRecordSetStreamA;
  2712. begin
  2713.   GetProcedureAddress(_MsiRecordSetStreamA, msilib, 'MsiRecordSetStreamA');
  2714.   asm
  2715.     mov esp, ebp
  2716.     pop ebp
  2717.     jmp [_MsiRecordSetStreamA]
  2718.   end;
  2719. end;
  2720. {$ELSE}
  2721. function MsiRecordSetStreamA; external msilib name 'MsiRecordSetStreamA';
  2722. {$ENDIF DYNAMIC_LINK}
  2724. {$IFDEF DYNAMIC_LINK}
  2725. var
  2726.   _MsiRecordSetStreamW: Pointer;
  2728. function MsiRecordSetStreamW;
  2729. begin
  2730.   GetProcedureAddress(_MsiRecordSetStreamW, msilib, 'MsiRecordSetStreamW');
  2731.   asm
  2732.     mov esp, ebp
  2733.     pop ebp
  2734.     jmp [_MsiRecordSetStreamW]
  2735.   end;
  2736. end;
  2737. {$ELSE}
  2738. function MsiRecordSetStreamW; external msilib name 'MsiRecordSetStreamW';
  2739. {$ENDIF DYNAMIC_LINK}
  2740. {$IFDEF UNICODE}
  2742. {$IFDEF DYNAMIC_LINK}
  2743. var
  2744.   _MsiRecordSetStream: Pointer;
  2746. function MsiRecordSetStream;
  2747. begin
  2748.   GetProcedureAddress(_MsiRecordSetStream, msilib, 'MsiRecordSetStreamW');
  2749.   asm
  2750.     mov esp, ebp
  2751.     pop ebp
  2752.     jmp [_MsiRecordSetStream]
  2753.   end;
  2754. end;
  2755. {$ELSE}
  2756. function MsiRecordSetStream; external msilib name 'MsiRecordSetStreamW';
  2757. {$ENDIF DYNAMIC_LINK}
  2758. {$ELSE}
  2760. {$IFDEF DYNAMIC_LINK}
  2761. var
  2762.   _MsiRecordSetStream: Pointer;
  2764. function MsiRecordSetStream;
  2765. begin
  2766.   GetProcedureAddress(_MsiRecordSetStream, msilib, 'MsiRecordSetStreamA');
  2767.   asm
  2768.     mov esp, ebp
  2769.     pop ebp
  2770.     jmp [_MsiRecordSetStream]
  2771.   end;
  2772. end;
  2773. {$ELSE}
  2774. function MsiRecordSetStream; external msilib name 'MsiRecordSetStreamA';
  2775. {$ENDIF DYNAMIC_LINK}
  2776. {$ENDIF}
  2778. {$IFDEF DYNAMIC_LINK}
  2779. var
  2780.   _MsiRecordReadStream: Pointer;
  2782. function MsiRecordReadStream;
  2783. begin
  2784.   GetProcedureAddress(_MsiRecordReadStream, msilib, 'MsiRecordReadStream');
  2785.   asm
  2786.     mov esp, ebp
  2787.     pop ebp
  2788.     jmp [_MsiRecordReadStream]
  2789.   end;
  2790. end;
  2791. {$ELSE}
  2792. function MsiRecordReadStream; external msilib name 'MsiRecordReadStream';
  2793. {$ENDIF DYNAMIC_LINK}
  2795. {$IFDEF DYNAMIC_LINK}
  2796. var
  2797.   _MsiRecordClearData: Pointer;
  2799. function MsiRecordClearData;
  2800. begin
  2801.   GetProcedureAddress(_MsiRecordClearData, msilib, 'MsiRecordClearData');
  2802.   asm
  2803.     mov esp, ebp
  2804.     pop ebp
  2805.     jmp [_MsiRecordClearData]
  2806.   end;
  2807. end;
  2808. {$ELSE}
  2809. function MsiRecordClearData; external msilib name 'MsiRecordClearData';
  2810. {$ENDIF DYNAMIC_LINK}
  2812. {$IFDEF DYNAMIC_LINK}
  2813. var
  2814.   _MsiGetActiveDatabase: Pointer;
  2816. function MsiGetActiveDatabase;
  2817. begin
  2818.   GetProcedureAddress(_MsiGetActiveDatabase, msilib, 'MsiGetActiveDatabase');
  2819.   asm
  2820.     mov esp, ebp
  2821.     pop ebp
  2822.     jmp [_MsiGetActiveDatabase]
  2823.   end;
  2824. end;
  2825. {$ELSE}
  2826. function MsiGetActiveDatabase; external msilib name 'MsiGetActiveDatabase';
  2827. {$ENDIF DYNAMIC_LINK}
  2829. {$IFDEF DYNAMIC_LINK}
  2830. var
  2831.   _MsiSetPropertyA: Pointer;
  2833. function MsiSetPropertyA;
  2834. begin
  2835.   GetProcedureAddress(_MsiSetPropertyA, msilib, 'MsiSetPropertyA');
  2836.   asm
  2837.     mov esp, ebp
  2838.     pop ebp
  2839.     jmp [_MsiSetPropertyA]
  2840.   end;
  2841. end;
  2842. {$ELSE}
  2843. function MsiSetPropertyA; external msilib name 'MsiSetPropertyA';
  2844. {$ENDIF DYNAMIC_LINK}
  2846. {$IFDEF DYNAMIC_LINK}
  2847. var
  2848.   _MsiSetPropertyW: Pointer;
  2850. function MsiSetPropertyW;
  2851. begin
  2852.   GetProcedureAddress(_MsiSetPropertyW, msilib, 'MsiSetPropertyW');
  2853.   asm
  2854.     mov esp, ebp
  2855.     pop ebp
  2856.     jmp [_MsiSetPropertyW]
  2857.   end;
  2858. end;
  2859. {$ELSE}
  2860. function MsiSetPropertyW; external msilib name 'MsiSetPropertyW';
  2861. {$ENDIF DYNAMIC_LINK}
  2862. {$IFDEF UNICODE}
  2864. {$IFDEF DYNAMIC_LINK}
  2865. var
  2866.   _MsiSetProperty: Pointer;
  2868. function MsiSetProperty;
  2869. begin
  2870.   GetProcedureAddress(_MsiSetProperty, msilib, 'MsiSetPropertyW');
  2871.   asm
  2872.     mov esp, ebp
  2873.     pop ebp
  2874.     jmp [_MsiSetProperty]
  2875.   end;
  2876. end;
  2877. {$ELSE}
  2878. function MsiSetProperty; external msilib name 'MsiSetPropertyW';
  2879. {$ENDIF DYNAMIC_LINK}
  2880. {$ELSE}
  2882. {$IFDEF DYNAMIC_LINK}
  2883. var
  2884.   _MsiSetProperty: Pointer;
  2886. function MsiSetProperty;
  2887. begin
  2888.   GetProcedureAddress(_MsiSetProperty, msilib, 'MsiSetPropertyA');
  2889.   asm
  2890.     mov esp, ebp
  2891.     pop ebp
  2892.     jmp [_MsiSetProperty]
  2893.   end;
  2894. end;
  2895. {$ELSE}
  2896. function MsiSetProperty; external msilib name 'MsiSetPropertyA';
  2897. {$ENDIF DYNAMIC_LINK}
  2898. {$ENDIF}
  2900. {$IFDEF DYNAMIC_LINK}
  2901. var
  2902.   _MsiGetPropertyA: Pointer;
  2904. function MsiGetPropertyA;
  2905. begin
  2906.   GetProcedureAddress(_MsiGetPropertyA, msilib, 'MsiGetPropertyA');
  2907.   asm
  2908.     mov esp, ebp
  2909.     pop ebp
  2910.     jmp [_MsiGetPropertyA]
  2911.   end;
  2912. end;
  2913. {$ELSE}
  2914. function MsiGetPropertyA; external msilib name 'MsiGetPropertyA';
  2915. {$ENDIF DYNAMIC_LINK}
  2917. {$IFDEF DYNAMIC_LINK}
  2918. var
  2919.   _MsiGetPropertyW: Pointer;
  2921. function MsiGetPropertyW;
  2922. begin
  2923.   GetProcedureAddress(_MsiGetPropertyW, msilib, 'MsiGetPropertyW');
  2924.   asm
  2925.     mov esp, ebp
  2926.     pop ebp
  2927.     jmp [_MsiGetPropertyW]
  2928.   end;
  2929. end;
  2930. {$ELSE}
  2931. function MsiGetPropertyW; external msilib name 'MsiGetPropertyW';
  2932. {$ENDIF DYNAMIC_LINK}
  2933. {$IFDEF UNICODE}
  2935. {$IFDEF DYNAMIC_LINK}
  2936. var
  2937.   _MsiGetProperty: Pointer;
  2939. function MsiGetProperty;
  2940. begin
  2941.   GetProcedureAddress(_MsiGetProperty, msilib, 'MsiGetPropertyW');
  2942.   asm
  2943.     mov esp, ebp
  2944.     pop ebp
  2945.     jmp [_MsiGetProperty]
  2946.   end;
  2947. end;
  2948. {$ELSE}
  2949. function MsiGetProperty; external msilib name 'MsiGetPropertyW';
  2950. {$ENDIF DYNAMIC_LINK}
  2951. {$ELSE}
  2953. {$IFDEF DYNAMIC_LINK}
  2954. var
  2955.   _MsiGetProperty: Pointer;
  2957. function MsiGetProperty;
  2958. begin
  2959.   GetProcedureAddress(_MsiGetProperty, msilib, 'MsiGetPropertyA');
  2960.   asm
  2961.     mov esp, ebp
  2962.     pop ebp
  2963.     jmp [_MsiGetProperty]
  2964.   end;
  2965. end;
  2966. {$ELSE}
  2967. function MsiGetProperty; external msilib name 'MsiGetPropertyA';
  2968. {$ENDIF DYNAMIC_LINK}
  2969. {$ENDIF}
  2971. {$IFDEF DYNAMIC_LINK}
  2972. var
  2973.   _MsiGetLanguage: Pointer;
  2975. function MsiGetLanguage;
  2976. begin
  2977.   GetProcedureAddress(_MsiGetLanguage, msilib, 'MsiGetLanguage');
  2978.   asm
  2979.     mov esp, ebp
  2980.     pop ebp
  2981.     jmp [_MsiGetLanguage]
  2982.   end;
  2983. end;
  2984. {$ELSE}
  2985. function MsiGetLanguage; external msilib name 'MsiGetLanguage';
  2986. {$ENDIF DYNAMIC_LINK}
  2988. {$IFDEF DYNAMIC_LINK}
  2989. var
  2990.   _MsiGetMode: Pointer;
  2992. function MsiGetMode;
  2993. begin
  2994.   GetProcedureAddress(_MsiGetMode, msilib, 'MsiGetMode');
  2995.   asm
  2996.     mov esp, ebp
  2997.     pop ebp
  2998.     jmp [_MsiGetMode]
  2999.   end;
  3000. end;
  3001. {$ELSE}
  3002. function MsiGetMode; external msilib name 'MsiGetMode';
  3003. {$ENDIF DYNAMIC_LINK}
  3005. {$IFDEF DYNAMIC_LINK}
  3006. var
  3007.   _MsiSetMode: Pointer;
  3009. function MsiSetMode;
  3010. begin
  3011.   GetProcedureAddress(_MsiSetMode, msilib, 'MsiSetMode');
  3012.   asm
  3013.     mov esp, ebp
  3014.     pop ebp
  3015.     jmp [_MsiSetMode]
  3016.   end;
  3017. end;
  3018. {$ELSE}
  3019. function MsiSetMode; external msilib name 'MsiSetMode';
  3020. {$ENDIF DYNAMIC_LINK}
  3022. {$IFDEF DYNAMIC_LINK}
  3023. var
  3024.   _MsiFormatRecordA: Pointer;
  3026. function MsiFormatRecordA;
  3027. begin
  3028.   GetProcedureAddress(_MsiFormatRecordA, msilib, 'MsiFormatRecordA');
  3029.   asm
  3030.     mov esp, ebp
  3031.     pop ebp
  3032.     jmp [_MsiFormatRecordA]
  3033.   end;
  3034. end;
  3035. {$ELSE}
  3036. function MsiFormatRecordA; external msilib name 'MsiFormatRecordA';
  3037. {$ENDIF DYNAMIC_LINK}
  3039. {$IFDEF DYNAMIC_LINK}
  3040. var
  3041.   _MsiFormatRecordW: Pointer;
  3043. function MsiFormatRecordW;
  3044. begin
  3045.   GetProcedureAddress(_MsiFormatRecordW, msilib, 'MsiFormatRecordW');
  3046.   asm
  3047.     mov esp, ebp
  3048.     pop ebp
  3049.     jmp [_MsiFormatRecordW]
  3050.   end;
  3051. end;
  3052. {$ELSE}
  3053. function MsiFormatRecordW; external msilib name 'MsiFormatRecordW';
  3054. {$ENDIF DYNAMIC_LINK}
  3055. {$IFDEF UNICODE}
  3057. {$IFDEF DYNAMIC_LINK}
  3058. var
  3059.   _MsiFormatRecord: Pointer;
  3061. function MsiFormatRecord;
  3062. begin
  3063.   GetProcedureAddress(_MsiFormatRecord, msilib, 'MsiFormatRecordW');
  3064.   asm
  3065.     mov esp, ebp
  3066.     pop ebp
  3067.     jmp [_MsiFormatRecord]
  3068.   end;
  3069. end;
  3070. {$ELSE}
  3071. function MsiFormatRecord; external msilib name 'MsiFormatRecordW';
  3072. {$ENDIF DYNAMIC_LINK}
  3073. {$ELSE}
  3075. {$IFDEF DYNAMIC_LINK}
  3076. var
  3077.   _MsiFormatRecord: Pointer;
  3079. function MsiFormatRecord;
  3080. begin
  3081.   GetProcedureAddress(_MsiFormatRecord, msilib, 'MsiFormatRecordA');
  3082.   asm
  3083.     mov esp, ebp
  3084.     pop ebp
  3085.     jmp [_MsiFormatRecord]
  3086.   end;
  3087. end;
  3088. {$ELSE}
  3089. function MsiFormatRecord; external msilib name 'MsiFormatRecordA';
  3090. {$ENDIF DYNAMIC_LINK}
  3091. {$ENDIF}
  3093. {$IFDEF DYNAMIC_LINK}
  3094. var
  3095.   _MsiDoActionA: Pointer;
  3097. function MsiDoActionA;
  3098. begin
  3099.   GetProcedureAddress(_MsiDoActionA, msilib, 'MsiDoActionA');
  3100.   asm
  3101.     mov esp, ebp
  3102.     pop ebp
  3103.     jmp [_MsiDoActionA]
  3104.   end;
  3105. end;
  3106. {$ELSE}
  3107. function MsiDoActionA; external msilib name 'MsiDoActionA';
  3108. {$ENDIF DYNAMIC_LINK}
  3110. {$IFDEF DYNAMIC_LINK}
  3111. var
  3112.   _MsiDoActionW: Pointer;
  3114. function MsiDoActionW;
  3115. begin
  3116.   GetProcedureAddress(_MsiDoActionW, msilib, 'MsiDoActionW');
  3117.   asm
  3118.     mov esp, ebp
  3119.     pop ebp
  3120.     jmp [_MsiDoActionW]
  3121.   end;
  3122. end;
  3123. {$ELSE}
  3124. function MsiDoActionW; external msilib name 'MsiDoActionW';
  3125. {$ENDIF DYNAMIC_LINK}
  3126. {$IFDEF UNICODE}
  3128. {$IFDEF DYNAMIC_LINK}
  3129. var
  3130.   _MsiDoAction: Pointer;
  3132. function MsiDoAction;
  3133. begin
  3134.   GetProcedureAddress(_MsiDoAction, msilib, 'MsiDoActionW');
  3135.   asm
  3136.     mov esp, ebp
  3137.     pop ebp
  3138.     jmp [_MsiDoAction]
  3139.   end;
  3140. end;
  3141. {$ELSE}
  3142. function MsiDoAction; external msilib name 'MsiDoActionW';
  3143. {$ENDIF DYNAMIC_LINK}
  3144. {$ELSE}
  3146. {$IFDEF DYNAMIC_LINK}
  3147. var
  3148.   _MsiDoAction: Pointer;
  3150. function MsiDoAction;
  3151. begin
  3152.   GetProcedureAddress(_MsiDoAction, msilib, 'MsiDoActionA');
  3153.   asm
  3154.     mov esp, ebp
  3155.     pop ebp
  3156.     jmp [_MsiDoAction]
  3157.   end;
  3158. end;
  3159. {$ELSE}
  3160. function MsiDoAction; external msilib name 'MsiDoActionA';
  3161. {$ENDIF DYNAMIC_LINK}
  3162. {$ENDIF}
  3164. {$IFDEF DYNAMIC_LINK}
  3165. var
  3166.   _MsiSequenceA: Pointer;
  3168. function MsiSequenceA;
  3169. begin
  3170.   GetProcedureAddress(_MsiSequenceA, msilib, 'MsiSequenceA');
  3171.   asm
  3172.     mov esp, ebp
  3173.     pop ebp
  3174.     jmp [_MsiSequenceA]
  3175.   end;
  3176. end;
  3177. {$ELSE}
  3178. function MsiSequenceA; external msilib name 'MsiSequenceA';
  3179. {$ENDIF DYNAMIC_LINK}
  3181. {$IFDEF DYNAMIC_LINK}
  3182. var
  3183.   _MsiSequenceW: Pointer;
  3185. function MsiSequenceW;
  3186. begin
  3187.   GetProcedureAddress(_MsiSequenceW, msilib, 'MsiSequenceW');
  3188.   asm
  3189.     mov esp, ebp
  3190.     pop ebp
  3191.     jmp [_MsiSequenceW]
  3192.   end;
  3193. end;
  3194. {$ELSE}
  3195. function MsiSequenceW; external msilib name 'MsiSequenceW';
  3196. {$ENDIF DYNAMIC_LINK}
  3197. {$IFDEF UNICODE}
  3199. {$IFDEF DYNAMIC_LINK}
  3200. var
  3201.   _MsiSequence: Pointer;
  3203. function MsiSequence;
  3204. begin
  3205.   GetProcedureAddress(_MsiSequence, msilib, 'MsiSequenceW');
  3206.   asm
  3207.     mov esp, ebp
  3208.     pop ebp
  3209.     jmp [_MsiSequence]
  3210.   end;
  3211. end;
  3212. {$ELSE}
  3213. function MsiSequence; external msilib name 'MsiSequenceW';
  3214. {$ENDIF DYNAMIC_LINK}
  3215. {$ELSE}
  3217. {$IFDEF DYNAMIC_LINK}
  3218. var
  3219.   _MsiSequence: Pointer;
  3221. function MsiSequence;
  3222. begin
  3223.   GetProcedureAddress(_MsiSequence, msilib, 'MsiSequenceA');
  3224.   asm
  3225.     mov esp, ebp
  3226.     pop ebp
  3227.     jmp [_MsiSequence]
  3228.   end;
  3229. end;
  3230. {$ELSE}
  3231. function MsiSequence; external msilib name 'MsiSequenceA';
  3232. {$ENDIF DYNAMIC_LINK}
  3233. {$ENDIF}
  3235. {$IFDEF DYNAMIC_LINK}
  3236. var
  3237.   _MsiProcessMessage: Pointer;
  3239. function MsiProcessMessage;
  3240. begin
  3241.   GetProcedureAddress(_MsiProcessMessage, msilib, 'MsiProcessMessage');
  3242.   asm
  3243.     mov esp, ebp
  3244.     pop ebp
  3245.     jmp [_MsiProcessMessage]
  3246.   end;
  3247. end;
  3248. {$ELSE}
  3249. function MsiProcessMessage; external msilib name 'MsiProcessMessage';
  3250. {$ENDIF DYNAMIC_LINK}
  3252. {$IFDEF DYNAMIC_LINK}
  3253. var
  3254.   _MsiEvaluateConditionA: Pointer;
  3256. function MsiEvaluateConditionA;
  3257. begin
  3258.   GetProcedureAddress(_MsiEvaluateConditionA, msilib, 'MsiEvaluateConditionA');
  3259.   asm
  3260.     mov esp, ebp
  3261.     pop ebp
  3262.     jmp [_MsiEvaluateConditionA]
  3263.   end;
  3264. end;
  3265. {$ELSE}
  3266. function MsiEvaluateConditionA; external msilib name 'MsiEvaluateConditionA';
  3267. {$ENDIF DYNAMIC_LINK}
  3269. {$IFDEF DYNAMIC_LINK}
  3270. var
  3271.   _MsiEvaluateConditionW: Pointer;
  3273. function MsiEvaluateConditionW;
  3274. begin
  3275.   GetProcedureAddress(_MsiEvaluateConditionW, msilib, 'MsiEvaluateConditionW');
  3276.   asm
  3277.     mov esp, ebp
  3278.     pop ebp
  3279.     jmp [_MsiEvaluateConditionW]
  3280.   end;
  3281. end;
  3282. {$ELSE}
  3283. function MsiEvaluateConditionW; external msilib name 'MsiEvaluateConditionW';
  3284. {$ENDIF DYNAMIC_LINK}
  3285. {$IFDEF UNICODE}
  3287. {$IFDEF DYNAMIC_LINK}
  3288. var
  3289.   _MsiEvaluateCondition: Pointer;
  3291. function MsiEvaluateCondition;
  3292. begin
  3293.   GetProcedureAddress(_MsiEvaluateCondition, msilib, 'MsiEvaluateConditionW');
  3294.   asm
  3295.     mov esp, ebp
  3296.     pop ebp
  3297.     jmp [_MsiEvaluateCondition]
  3298.   end;
  3299. end;
  3300. {$ELSE}
  3301. function MsiEvaluateCondition; external msilib name 'MsiEvaluateConditionW';
  3302. {$ENDIF DYNAMIC_LINK}
  3303. {$ELSE}
  3305. {$IFDEF DYNAMIC_LINK}
  3306. var
  3307.   _MsiEvaluateCondition: Pointer;
  3309. function MsiEvaluateCondition;
  3310. begin
  3311.   GetProcedureAddress(_MsiEvaluateCondition, msilib, 'MsiEvaluateConditionA');
  3312.   asm
  3313.     mov esp, ebp
  3314.     pop ebp
  3315.     jmp [_MsiEvaluateCondition]
  3316.   end;
  3317. end;
  3318. {$ELSE}
  3319. function MsiEvaluateCondition; external msilib name 'MsiEvaluateConditionA';
  3320. {$ENDIF DYNAMIC_LINK}
  3321. {$ENDIF}
  3323. {$IFDEF DYNAMIC_LINK}
  3324. var
  3325.   _MsiGetFeatureStateA: Pointer;
  3327. function MsiGetFeatureStateA;
  3328. begin
  3329.   GetProcedureAddress(_MsiGetFeatureStateA, msilib, 'MsiGetFeatureStateA');
  3330.   asm
  3331.     mov esp, ebp
  3332.     pop ebp
  3333.     jmp [_MsiGetFeatureStateA]
  3334.   end;
  3335. end;
  3336. {$ELSE}
  3337. function MsiGetFeatureStateA; external msilib name 'MsiGetFeatureStateA';
  3338. {$ENDIF DYNAMIC_LINK}
  3340. {$IFDEF DYNAMIC_LINK}
  3341. var
  3342.   _MsiGetFeatureStateW: Pointer;
  3344. function MsiGetFeatureStateW;
  3345. begin
  3346.   GetProcedureAddress(_MsiGetFeatureStateW, msilib, 'MsiGetFeatureStateW');
  3347.   asm
  3348.     mov esp, ebp
  3349.     pop ebp
  3350.     jmp [_MsiGetFeatureStateW]
  3351.   end;
  3352. end;
  3353. {$ELSE}
  3354. function MsiGetFeatureStateW; external msilib name 'MsiGetFeatureStateW';
  3355. {$ENDIF DYNAMIC_LINK}
  3356. {$IFDEF UNICODE}
  3358. {$IFDEF DYNAMIC_LINK}
  3359. var
  3360.   _MsiGetFeatureState: Pointer;
  3362. function MsiGetFeatureState;
  3363. begin
  3364.   GetProcedureAddress(_MsiGetFeatureState, msilib, 'MsiGetFeatureStateW');
  3365.   asm
  3366.     mov esp, ebp
  3367.     pop ebp
  3368.     jmp [_MsiGetFeatureState]
  3369.   end;
  3370. end;
  3371. {$ELSE}
  3372. function MsiGetFeatureState; external msilib name 'MsiGetFeatureStateW';
  3373. {$ENDIF DYNAMIC_LINK}
  3374. {$ELSE}
  3376. {$IFDEF DYNAMIC_LINK}
  3377. var
  3378.   _MsiGetFeatureState: Pointer;
  3380. function MsiGetFeatureState;
  3381. begin
  3382.   GetProcedureAddress(_MsiGetFeatureState, msilib, 'MsiGetFeatureStateA');
  3383.   asm
  3384.     mov esp, ebp
  3385.     pop ebp
  3386.     jmp [_MsiGetFeatureState]
  3387.   end;
  3388. end;
  3389. {$ELSE}
  3390. function MsiGetFeatureState; external msilib name 'MsiGetFeatureStateA';
  3391. {$ENDIF DYNAMIC_LINK}
  3392. {$ENDIF}
  3394. {$IFDEF DYNAMIC_LINK}
  3395. var
  3396.   _MsiSetFeatureStateA: Pointer;
  3398. function MsiSetFeatureStateA;
  3399. begin
  3400.   GetProcedureAddress(_MsiSetFeatureStateA, msilib, 'MsiSetFeatureStateA');
  3401.   asm
  3402.     mov esp, ebp
  3403.     pop ebp
  3404.     jmp [_MsiSetFeatureStateA]
  3405.   end;
  3406. end;
  3407. {$ELSE}
  3408. function MsiSetFeatureStateA; external msilib name 'MsiSetFeatureStateA';
  3409. {$ENDIF DYNAMIC_LINK}
  3411. {$IFDEF DYNAMIC_LINK}
  3412. var
  3413.   _MsiSetFeatureStateW: Pointer;
  3415. function MsiSetFeatureStateW;
  3416. begin
  3417.   GetProcedureAddress(_MsiSetFeatureStateW, msilib, 'MsiSetFeatureStateW');
  3418.   asm
  3419.     mov esp, ebp
  3420.     pop ebp
  3421.     jmp [_MsiSetFeatureStateW]
  3422.   end;
  3423. end;
  3424. {$ELSE}
  3425. function MsiSetFeatureStateW; external msilib name 'MsiSetFeatureStateW';
  3426. {$ENDIF DYNAMIC_LINK}
  3427. {$IFDEF UNICODE}
  3429. {$IFDEF DYNAMIC_LINK}
  3430. var
  3431.   _MsiSetFeatureState: Pointer;
  3433. function MsiSetFeatureState;
  3434. begin
  3435.   GetProcedureAddress(_MsiSetFeatureState, msilib, 'MsiSetFeatureStateW');
  3436.   asm
  3437.     mov esp, ebp
  3438.     pop ebp
  3439.     jmp [_MsiSetFeatureState]
  3440.   end;
  3441. end;
  3442. {$ELSE}
  3443. function MsiSetFeatureState; external msilib name 'MsiSetFeatureStateW';
  3444. {$ENDIF DYNAMIC_LINK}
  3445. {$ELSE}
  3447. {$IFDEF DYNAMIC_LINK}
  3448. var
  3449.   _MsiSetFeatureState: Pointer;
  3451. function MsiSetFeatureState;
  3452. begin
  3453.   GetProcedureAddress(_MsiSetFeatureState, msilib, 'MsiSetFeatureStateA');
  3454.   asm
  3455.     mov esp, ebp
  3456.     pop ebp
  3457.     jmp [_MsiSetFeatureState]
  3458.   end;
  3459. end;
  3460. {$ELSE}
  3461. function MsiSetFeatureState; external msilib name 'MsiSetFeatureStateA';
  3462. {$ENDIF DYNAMIC_LINK}
  3463. {$ENDIF}
  3465. {$IFDEF DYNAMIC_LINK}
  3466. var
  3467.   _MsiSetFeatureAttributesA: Pointer;
  3469. function MsiSetFeatureAttributesA;
  3470. begin
  3471.   GetProcedureAddress(_MsiSetFeatureAttributesA, msilib, 'MsiSetFeatureAttributesA');
  3472.   asm
  3473.     mov esp, ebp
  3474.     pop ebp
  3475.     jmp [_MsiSetFeatureAttributesA]
  3476.   end;
  3477. end;
  3478. {$ELSE}
  3479. function MsiSetFeatureAttributesA; external msilib name 'MsiSetFeatureAttributesA';
  3480. {$ENDIF DYNAMIC_LINK}
  3482. {$IFDEF DYNAMIC_LINK}
  3483. var
  3484.   _MsiSetFeatureAttributesW: Pointer;
  3486. function MsiSetFeatureAttributesW;
  3487. begin
  3488.   GetProcedureAddress(_MsiSetFeatureAttributesW, msilib, 'MsiSetFeatureAttributesW');
  3489.   asm
  3490.     mov esp, ebp
  3491.     pop ebp
  3492.     jmp [_MsiSetFeatureAttributesW]
  3493.   end;
  3494. end;
  3495. {$ELSE}
  3496. function MsiSetFeatureAttributesW; external msilib name 'MsiSetFeatureAttributesW';
  3497. {$ENDIF DYNAMIC_LINK}
  3498. {$IFDEF UNICODE}
  3500. {$IFDEF DYNAMIC_LINK}
  3501. var
  3502.   _MsiSetFeatureAttributes: Pointer;
  3504. function MsiSetFeatureAttributes;
  3505. begin
  3506.   GetProcedureAddress(_MsiSetFeatureAttributes, msilib, 'MsiSetFeatureAttributesW');
  3507.   asm
  3508.     mov esp, ebp
  3509.     pop ebp
  3510.     jmp [_MsiSetFeatureAttributes]
  3511.   end;
  3512. end;
  3513. {$ELSE}
  3514. function MsiSetFeatureAttributes; external msilib name 'MsiSetFeatureAttributesW';
  3515. {$ENDIF DYNAMIC_LINK}
  3516. {$ELSE}
  3518. {$IFDEF DYNAMIC_LINK}
  3519. var
  3520.   _MsiSetFeatureAttributes: Pointer;
  3522. function MsiSetFeatureAttributes;
  3523. begin
  3524.   GetProcedureAddress(_MsiSetFeatureAttributes, msilib, 'MsiSetFeatureAttributesA');
  3525.   asm
  3526.     mov esp, ebp
  3527.     pop ebp
  3528.     jmp [_MsiSetFeatureAttributes]
  3529.   end;
  3530. end;
  3531. {$ELSE}
  3532. function MsiSetFeatureAttributes; external msilib name 'MsiSetFeatureAttributesA';
  3533. {$ENDIF DYNAMIC_LINK}
  3534. {$ENDIF}
  3536. {$IFDEF DYNAMIC_LINK}
  3537. var
  3538.   _MsiGetComponentStateA: Pointer;
  3540. function MsiGetComponentStateA;
  3541. begin
  3542.   GetProcedureAddress(_MsiGetComponentStateA, msilib, 'MsiGetComponentStateA');
  3543.   asm
  3544.     mov esp, ebp
  3545.     pop ebp
  3546.     jmp [_MsiGetComponentStateA]
  3547.   end;
  3548. end;
  3549. {$ELSE}
  3550. function MsiGetComponentStateA; external msilib name 'MsiGetComponentStateA';
  3551. {$ENDIF DYNAMIC_LINK}
  3553. {$IFDEF DYNAMIC_LINK}
  3554. var
  3555.   _MsiGetComponentStateW: Pointer;
  3557. function MsiGetComponentStateW;
  3558. begin
  3559.   GetProcedureAddress(_MsiGetComponentStateW, msilib, 'MsiGetComponentStateW');
  3560.   asm
  3561.     mov esp, ebp
  3562.     pop ebp
  3563.     jmp [_MsiGetComponentStateW]
  3564.   end;
  3565. end;
  3566. {$ELSE}
  3567. function MsiGetComponentStateW; external msilib name 'MsiGetComponentStateW';
  3568. {$ENDIF DYNAMIC_LINK}
  3569. {$IFDEF UNICODE}
  3571. {$IFDEF DYNAMIC_LINK}
  3572. var
  3573.   _MsiGetComponentState: Pointer;
  3575. function MsiGetComponentState;
  3576. begin
  3577.   GetProcedureAddress(_MsiGetComponentState, msilib, 'MsiGetComponentStateW');
  3578.   asm
  3579.     mov esp, ebp
  3580.     pop ebp
  3581.     jmp [_MsiGetComponentState]
  3582.   end;
  3583. end;
  3584. {$ELSE}
  3585. function MsiGetComponentState; external msilib name 'MsiGetComponentStateW';
  3586. {$ENDIF DYNAMIC_LINK}
  3587. {$ELSE}
  3589. {$IFDEF DYNAMIC_LINK}
  3590. var
  3591.   _MsiGetComponentState: Pointer;
  3593. function MsiGetComponentState;
  3594. begin
  3595.   GetProcedureAddress(_MsiGetComponentState, msilib, 'MsiGetComponentStateA');
  3596.   asm
  3597.     mov esp, ebp
  3598.     pop ebp
  3599.     jmp [_MsiGetComponentState]
  3600.   end;
  3601. end;
  3602. {$ELSE}
  3603. function MsiGetComponentState; external msilib name 'MsiGetComponentStateA';
  3604. {$ENDIF DYNAMIC_LINK}
  3605. {$ENDIF}
  3607. {$IFDEF DYNAMIC_LINK}
  3608. var
  3609.   _MsiSetComponentStateA: Pointer;
  3611. function MsiSetComponentStateA;
  3612. begin
  3613.   GetProcedureAddress(_MsiSetComponentStateA, msilib, 'MsiSetComponentStateA');
  3614.   asm
  3615.     mov esp, ebp
  3616.     pop ebp
  3617.     jmp [_MsiSetComponentStateA]
  3618.   end;
  3619. end;
  3620. {$ELSE}
  3621. function MsiSetComponentStateA; external msilib name 'MsiSetComponentStateA';
  3622. {$ENDIF DYNAMIC_LINK}
  3624. {$IFDEF DYNAMIC_LINK}
  3625. var
  3626.   _MsiSetComponentStateW: Pointer;
  3628. function MsiSetComponentStateW;
  3629. begin
  3630.   GetProcedureAddress(_MsiSetComponentStateW, msilib, 'MsiSetComponentStateW');
  3631.   asm
  3632.     mov esp, ebp
  3633.     pop ebp
  3634.     jmp [_MsiSetComponentStateW]
  3635.   end;
  3636. end;
  3637. {$ELSE}
  3638. function MsiSetComponentStateW; external msilib name 'MsiSetComponentStateW';
  3639. {$ENDIF DYNAMIC_LINK}
  3640. {$IFDEF UNICODE}
  3642. {$IFDEF DYNAMIC_LINK}
  3643. var
  3644.   _MsiSetComponentState: Pointer;
  3646. function MsiSetComponentState;
  3647. begin
  3648.   GetProcedureAddress(_MsiSetComponentState, msilib, 'MsiSetComponentStateW');
  3649.   asm
  3650.     mov esp, ebp
  3651.     pop ebp
  3652.     jmp [_MsiSetComponentState]
  3653.   end;
  3654. end;
  3655. {$ELSE}
  3656. function MsiSetComponentState; external msilib name 'MsiSetComponentStateW';
  3657. {$ENDIF DYNAMIC_LINK}
  3658. {$ELSE}
  3660. {$IFDEF DYNAMIC_LINK}
  3661. var
  3662.   _MsiSetComponentState: Pointer;
  3664. function MsiSetComponentState;
  3665. begin
  3666.   GetProcedureAddress(_MsiSetComponentState, msilib, 'MsiSetComponentStateA');
  3667.   asm
  3668.     mov esp, ebp
  3669.     pop ebp
  3670.     jmp [_MsiSetComponentState]
  3671.   end;
  3672. end;
  3673. {$ELSE}
  3674. function MsiSetComponentState; external msilib name 'MsiSetComponentStateA';
  3675. {$ENDIF DYNAMIC_LINK}
  3676. {$ENDIF}
  3678. {$IFDEF DYNAMIC_LINK}
  3679. var
  3680.   _MsiGetFeatureCostA: Pointer;
  3682. function MsiGetFeatureCostA;
  3683. begin
  3684.   GetProcedureAddress(_MsiGetFeatureCostA, msilib, 'MsiGetFeatureCostA');
  3685.   asm
  3686.     mov esp, ebp
  3687.     pop ebp
  3688.     jmp [_MsiGetFeatureCostA]
  3689.   end;
  3690. end;
  3691. {$ELSE}
  3692. function MsiGetFeatureCostA; external msilib name 'MsiGetFeatureCostA';
  3693. {$ENDIF DYNAMIC_LINK}
  3695. {$IFDEF DYNAMIC_LINK}
  3696. var
  3697.   _MsiGetFeatureCostW: Pointer;
  3699. function MsiGetFeatureCostW;
  3700. begin
  3701.   GetProcedureAddress(_MsiGetFeatureCostW, msilib, 'MsiGetFeatureCostW');
  3702.   asm
  3703.     mov esp, ebp
  3704.     pop ebp
  3705.     jmp [_MsiGetFeatureCostW]
  3706.   end;
  3707. end;
  3708. {$ELSE}
  3709. function MsiGetFeatureCostW; external msilib name 'MsiGetFeatureCostW';
  3710. {$ENDIF DYNAMIC_LINK}
  3711. {$IFDEF UNICODE}
  3713. {$IFDEF DYNAMIC_LINK}
  3714. var
  3715.   _MsiGetFeatureCost: Pointer;
  3717. function MsiGetFeatureCost;
  3718. begin
  3719.   GetProcedureAddress(_MsiGetFeatureCost, msilib, 'MsiGetFeatureCostW');
  3720.   asm
  3721.     mov esp, ebp
  3722.     pop ebp
  3723.     jmp [_MsiGetFeatureCost]
  3724.   end;
  3725. end;
  3726. {$ELSE}
  3727. function MsiGetFeatureCost; external msilib name 'MsiGetFeatureCostW';
  3728. {$ENDIF DYNAMIC_LINK}
  3729. {$ELSE}
  3731. {$IFDEF DYNAMIC_LINK}
  3732. var
  3733.   _MsiGetFeatureCost: Pointer;
  3735. function MsiGetFeatureCost;
  3736. begin
  3737.   GetProcedureAddress(_MsiGetFeatureCost, msilib, 'MsiGetFeatureCostA');
  3738.   asm
  3739.     mov esp, ebp
  3740.     pop ebp
  3741.     jmp [_MsiGetFeatureCost]
  3742.   end;
  3743. end;
  3744. {$ELSE}
  3745. function MsiGetFeatureCost; external msilib name 'MsiGetFeatureCostA';
  3746. {$ENDIF DYNAMIC_LINK}
  3747. {$ENDIF}
  3749. {$IFDEF DYNAMIC_LINK}
  3750. var
  3751.   _MsiEnumComponentCostsA: Pointer;
  3753. function MsiEnumComponentCostsA;
  3754. begin
  3755.   GetProcedureAddress(_MsiEnumComponentCostsA, msilib, 'MsiEnumComponentCostsA');
  3756.   asm
  3757.     mov esp, ebp
  3758.     pop ebp
  3759.     jmp [_MsiEnumComponentCostsA]
  3760.   end;
  3761. end;
  3762. {$ELSE}
  3763. function MsiEnumComponentCostsA; external msilib name 'MsiEnumComponentCostsA';
  3764. {$ENDIF DYNAMIC_LINK}
  3766. {$IFDEF DYNAMIC_LINK}
  3767. var
  3768.   _MsiEnumComponentCostsW: Pointer;
  3770. function MsiEnumComponentCostsW;
  3771. begin
  3772.   GetProcedureAddress(_MsiEnumComponentCostsW, msilib, 'MsiEnumComponentCostsW');
  3773.   asm
  3774.     mov esp, ebp
  3775.     pop ebp
  3776.     jmp [_MsiEnumComponentCostsW]
  3777.   end;
  3778. end;
  3779. {$ELSE}
  3780. function MsiEnumComponentCostsW; external msilib name 'MsiEnumComponentCostsW';
  3781. {$ENDIF DYNAMIC_LINK}
  3782. {$IFDEF UNICODE}
  3784. {$IFDEF DYNAMIC_LINK}
  3785. var
  3786.   _MsiEnumComponentCosts: Pointer;
  3788. function MsiEnumComponentCosts;
  3789. begin
  3790.   GetProcedureAddress(_MsiEnumComponentCosts, msilib, 'MsiEnumComponentCostsW');
  3791.   asm
  3792.     mov esp, ebp
  3793.     pop ebp
  3794.     jmp [_MsiEnumComponentCosts]
  3795.   end;
  3796. end;
  3797. {$ELSE}
  3798. function MsiEnumComponentCosts; external msilib name 'MsiEnumComponentCostsW';
  3799. {$ENDIF DYNAMIC_LINK}
  3800. {$ELSE}
  3802. {$IFDEF DYNAMIC_LINK}
  3803. var
  3804.   _MsiEnumComponentCosts: Pointer;
  3806. function MsiEnumComponentCosts;
  3807. begin
  3808.   GetProcedureAddress(_MsiEnumComponentCosts, msilib, 'MsiEnumComponentCostsA');
  3809.   asm
  3810.     mov esp, ebp
  3811.     pop ebp
  3812.     jmp [_MsiEnumComponentCosts]
  3813.   end;
  3814. end;
  3815. {$ELSE}
  3816. function MsiEnumComponentCosts; external msilib name 'MsiEnumComponentCostsA';
  3817. {$ENDIF DYNAMIC_LINK}
  3818. {$ENDIF}
  3820. {$IFDEF DYNAMIC_LINK}
  3821. var
  3822.   _MsiSetInstallLevel: Pointer;
  3824. function MsiSetInstallLevel;
  3825. begin
  3826.   GetProcedureAddress(_MsiSetInstallLevel, msilib, 'MsiSetInstallLevel');
  3827.   asm
  3828.     mov esp, ebp
  3829.     pop ebp
  3830.     jmp [_MsiSetInstallLevel]
  3831.   end;
  3832. end;
  3833. {$ELSE}
  3834. function MsiSetInstallLevel; external msilib name 'MsiSetInstallLevel';
  3835. {$ENDIF DYNAMIC_LINK}
  3837. {$IFDEF DYNAMIC_LINK}
  3838. var
  3839.   _MsiGetFeatureValidStatesA: Pointer;
  3841. function MsiGetFeatureValidStatesA;
  3842. begin
  3843.   GetProcedureAddress(_MsiGetFeatureValidStatesA, msilib, 'MsiGetFeatureValidStatesA');
  3844.   asm
  3845.     mov esp, ebp
  3846.     pop ebp
  3847.     jmp [_MsiGetFeatureValidStatesA]
  3848.   end;
  3849. end;
  3850. {$ELSE}
  3851. function MsiGetFeatureValidStatesA; external msilib name 'MsiGetFeatureValidStatesA';
  3852. {$ENDIF DYNAMIC_LINK}
  3854. {$IFDEF DYNAMIC_LINK}
  3855. var
  3856.   _MsiGetFeatureValidStatesW: Pointer;
  3858. function MsiGetFeatureValidStatesW;
  3859. begin
  3860.   GetProcedureAddress(_MsiGetFeatureValidStatesW, msilib, 'MsiGetFeatureValidStatesW');
  3861.   asm
  3862.     mov esp, ebp
  3863.     pop ebp
  3864.     jmp [_MsiGetFeatureValidStatesW]
  3865.   end;
  3866. end;
  3867. {$ELSE}
  3868. function MsiGetFeatureValidStatesW; external msilib name 'MsiGetFeatureValidStatesW';
  3869. {$ENDIF DYNAMIC_LINK}
  3870. {$IFDEF UNICODE}
  3872. {$IFDEF DYNAMIC_LINK}
  3873. var
  3874.   _MsiGetFeatureValidStates: Pointer;
  3876. function MsiGetFeatureValidStates;
  3877. begin
  3878.   GetProcedureAddress(_MsiGetFeatureValidStates, msilib, 'MsiGetFeatureValidStatesW');
  3879.   asm
  3880.     mov esp, ebp
  3881.     pop ebp
  3882.     jmp [_MsiGetFeatureValidStates]
  3883.   end;
  3884. end;
  3885. {$ELSE}
  3886. function MsiGetFeatureValidStates; external msilib name 'MsiGetFeatureValidStatesW';
  3887. {$ENDIF DYNAMIC_LINK}
  3888. {$ELSE}
  3890. {$IFDEF DYNAMIC_LINK}
  3891. var
  3892.   _MsiGetFeatureValidStates: Pointer;
  3894. function MsiGetFeatureValidStates;
  3895. begin
  3896.   GetProcedureAddress(_MsiGetFeatureValidStates, msilib, 'MsiGetFeatureValidStatesA');
  3897.   asm
  3898.     mov esp, ebp
  3899.     pop ebp
  3900.     jmp [_MsiGetFeatureValidStates]
  3901.   end;
  3902. end;
  3903. {$ELSE}
  3904. function MsiGetFeatureValidStates; external msilib name 'MsiGetFeatureValidStatesA';
  3905. {$ENDIF DYNAMIC_LINK}
  3906. {$ENDIF}
  3908. {$IFDEF DYNAMIC_LINK}
  3909. var
  3910.   _MsiGetSourcePathA: Pointer;
  3912. function MsiGetSourcePathA;
  3913. begin
  3914.   GetProcedureAddress(_MsiGetSourcePathA, msilib, 'MsiGetSourcePathA');
  3915.   asm
  3916.     mov esp, ebp
  3917.     pop ebp
  3918.     jmp [_MsiGetSourcePathA]
  3919.   end;
  3920. end;
  3921. {$ELSE}
  3922. function MsiGetSourcePathA; external msilib name 'MsiGetSourcePathA';
  3923. {$ENDIF DYNAMIC_LINK}
  3925. {$IFDEF DYNAMIC_LINK}
  3926. var
  3927.   _MsiGetSourcePathW: Pointer;
  3929. function MsiGetSourcePathW;
  3930. begin
  3931.   GetProcedureAddress(_MsiGetSourcePathW, msilib, 'MsiGetSourcePathW');
  3932.   asm
  3933.     mov esp, ebp
  3934.     pop ebp
  3935.     jmp [_MsiGetSourcePathW]
  3936.   end;
  3937. end;
  3938. {$ELSE}
  3939. function MsiGetSourcePathW; external msilib name 'MsiGetSourcePathW';
  3940. {$ENDIF DYNAMIC_LINK}
  3941. {$IFDEF UNICODE}
  3943. {$IFDEF DYNAMIC_LINK}
  3944. var
  3945.   _MsiGetSourcePath: Pointer;
  3947. function MsiGetSourcePath;
  3948. begin
  3949.   GetProcedureAddress(_MsiGetSourcePath, msilib, 'MsiGetSourcePathW');
  3950.   asm
  3951.     mov esp, ebp
  3952.     pop ebp
  3953.     jmp [_MsiGetSourcePath]
  3954.   end;
  3955. end;
  3956. {$ELSE}
  3957. function MsiGetSourcePath; external msilib name 'MsiGetSourcePathW';
  3958. {$ENDIF DYNAMIC_LINK}
  3959. {$ELSE}
  3961. {$IFDEF DYNAMIC_LINK}
  3962. var
  3963.   _MsiGetSourcePath: Pointer;
  3965. function MsiGetSourcePath;
  3966. begin
  3967.   GetProcedureAddress(_MsiGetSourcePath, msilib, 'MsiGetSourcePathA');
  3968.   asm
  3969.     mov esp, ebp
  3970.     pop ebp
  3971.     jmp [_MsiGetSourcePath]
  3972.   end;
  3973. end;
  3974. {$ELSE}
  3975. function MsiGetSourcePath; external msilib name 'MsiGetSourcePathA';
  3976. {$ENDIF DYNAMIC_LINK}
  3977. {$ENDIF}
  3979. {$IFDEF DYNAMIC_LINK}
  3980. var
  3981.   _MsiGetTargetPathA: Pointer;
  3983. function MsiGetTargetPathA;
  3984. begin
  3985.   GetProcedureAddress(_MsiGetTargetPathA, msilib, 'MsiGetTargetPathA');
  3986.   asm
  3987.     mov esp, ebp
  3988.     pop ebp
  3989.     jmp [_MsiGetTargetPathA]
  3990.   end;
  3991. end;
  3992. {$ELSE}
  3993. function MsiGetTargetPathA; external msilib name 'MsiGetTargetPathA';
  3994. {$ENDIF DYNAMIC_LINK}
  3996. {$IFDEF DYNAMIC_LINK}
  3997. var
  3998.   _MsiGetTargetPathW: Pointer;
  4000. function MsiGetTargetPathW;
  4001. begin
  4002.   GetProcedureAddress(_MsiGetTargetPathW, msilib, 'MsiGetTargetPathW');
  4003.   asm
  4004.     mov esp, ebp
  4005.     pop ebp
  4006.     jmp [_MsiGetTargetPathW]
  4007.   end;
  4008. end;
  4009. {$ELSE}
  4010. function MsiGetTargetPathW; external msilib name 'MsiGetTargetPathW';
  4011. {$ENDIF DYNAMIC_LINK}
  4012. {$IFDEF UNICODE}
  4014. {$IFDEF DYNAMIC_LINK}
  4015. var
  4016.   _MsiGetTargetPath: Pointer;
  4018. function MsiGetTargetPath;
  4019. begin
  4020.   GetProcedureAddress(_MsiGetTargetPath, msilib, 'MsiGetTargetPathW');
  4021.   asm
  4022.     mov esp, ebp
  4023.     pop ebp
  4024.     jmp [_MsiGetTargetPath]
  4025.   end;
  4026. end;
  4027. {$ELSE}
  4028. function MsiGetTargetPath; external msilib name 'MsiGetTargetPathW';
  4029. {$ENDIF DYNAMIC_LINK}
  4030. {$ELSE}
  4032. {$IFDEF DYNAMIC_LINK}
  4033. var
  4034.   _MsiGetTargetPath: Pointer;
  4036. function MsiGetTargetPath;
  4037. begin
  4038.   GetProcedureAddress(_MsiGetTargetPath, msilib, 'MsiGetTargetPathA');
  4039.   asm
  4040.     mov esp, ebp
  4041.     pop ebp
  4042.     jmp [_MsiGetTargetPath]
  4043.   end;
  4044. end;
  4045. {$ELSE}
  4046. function MsiGetTargetPath; external msilib name 'MsiGetTargetPathA';
  4047. {$ENDIF DYNAMIC_LINK}
  4048. {$ENDIF}
  4050. {$IFDEF DYNAMIC_LINK}
  4051. var
  4052.   _MsiSetTargetPathA: Pointer;
  4054. function MsiSetTargetPathA;
  4055. begin
  4056.   GetProcedureAddress(_MsiSetTargetPathA, msilib, 'MsiSetTargetPathA');
  4057.   asm
  4058.     mov esp, ebp
  4059.     pop ebp
  4060.     jmp [_MsiSetTargetPathA]
  4061.   end;
  4062. end;
  4063. {$ELSE}
  4064. function MsiSetTargetPathA; external msilib name 'MsiSetTargetPathA';
  4065. {$ENDIF DYNAMIC_LINK}
  4067. {$IFDEF DYNAMIC_LINK}
  4068. var
  4069.   _MsiSetTargetPathW: Pointer;
  4071. function MsiSetTargetPathW;
  4072. begin
  4073.   GetProcedureAddress(_MsiSetTargetPathW, msilib, 'MsiSetTargetPathW');
  4074.   asm
  4075.     mov esp, ebp
  4076.     pop ebp
  4077.     jmp [_MsiSetTargetPathW]
  4078.   end;
  4079. end;
  4080. {$ELSE}
  4081. function MsiSetTargetPathW; external msilib name 'MsiSetTargetPathW';
  4082. {$ENDIF DYNAMIC_LINK}
  4083. {$IFDEF UNICODE}
  4085. {$IFDEF DYNAMIC_LINK}
  4086. var
  4087.   _MsiSetTargetPath: Pointer;
  4089. function MsiSetTargetPath;
  4090. begin
  4091.   GetProcedureAddress(_MsiSetTargetPath, msilib, 'MsiSetTargetPathW');
  4092.   asm
  4093.     mov esp, ebp
  4094.     pop ebp
  4095.     jmp [_MsiSetTargetPath]
  4096.   end;
  4097. end;
  4098. {$ELSE}
  4099. function MsiSetTargetPath; external msilib name 'MsiSetTargetPathW';
  4100. {$ENDIF DYNAMIC_LINK}
  4101. {$ELSE}
  4103. {$IFDEF DYNAMIC_LINK}
  4104. var
  4105.   _MsiSetTargetPath: Pointer;
  4107. function MsiSetTargetPath;
  4108. begin
  4109.   GetProcedureAddress(_MsiSetTargetPath, msilib, 'MsiSetTargetPathA');
  4110.   asm
  4111.     mov esp, ebp
  4112.     pop ebp
  4113.     jmp [_MsiSetTargetPath]
  4114.   end;
  4115. end;
  4116. {$ELSE}
  4117. function MsiSetTargetPath; external msilib name 'MsiSetTargetPathA';
  4118. {$ENDIF DYNAMIC_LINK}
  4119. {$ENDIF}
  4121. {$IFDEF DYNAMIC_LINK}
  4122. var
  4123.   _MsiVerifyDiskSpace: Pointer;
  4125. function MsiVerifyDiskSpace;
  4126. begin
  4127.   GetProcedureAddress(_MsiVerifyDiskSpace, msilib, 'MsiVerifyDiskSpace');
  4128.   asm
  4129.     mov esp, ebp
  4130.     pop ebp
  4131.     jmp [_MsiVerifyDiskSpace]
  4132.   end;
  4133. end;
  4134. {$ELSE}
  4135. function MsiVerifyDiskSpace; external msilib name 'MsiVerifyDiskSpace';
  4136. {$ENDIF DYNAMIC_LINK}
  4138. {$IFDEF DYNAMIC_LINK}
  4139. var
  4140.   _MsiEnableUIPreview: Pointer;
  4142. function MsiEnableUIPreview;
  4143. begin
  4144.   GetProcedureAddress(_MsiEnableUIPreview, msilib, 'MsiEnableUIPreview');
  4145.   asm
  4146.     mov esp, ebp
  4147.     pop ebp
  4148.     jmp [_MsiEnableUIPreview]
  4149.   end;
  4150. end;
  4151. {$ELSE}
  4152. function MsiEnableUIPreview; external msilib name 'MsiEnableUIPreview';
  4153. {$ENDIF DYNAMIC_LINK}
  4155. {$IFDEF DYNAMIC_LINK}
  4156. var
  4157.   _MsiPreviewDialogA: Pointer;
  4159. function MsiPreviewDialogA;
  4160. begin
  4161.   GetProcedureAddress(_MsiPreviewDialogA, msilib, 'MsiPreviewDialogA');
  4162.   asm
  4163.     mov esp, ebp
  4164.     pop ebp
  4165.     jmp [_MsiPreviewDialogA]
  4166.   end;
  4167. end;
  4168. {$ELSE}
  4169. function MsiPreviewDialogA; external msilib name 'MsiPreviewDialogA';
  4170. {$ENDIF DYNAMIC_LINK}
  4172. {$IFDEF DYNAMIC_LINK}
  4173. var
  4174.   _MsiPreviewDialogW: Pointer;
  4176. function MsiPreviewDialogW;
  4177. begin
  4178.   GetProcedureAddress(_MsiPreviewDialogW, msilib, 'MsiPreviewDialogW');
  4179.   asm
  4180.     mov esp, ebp
  4181.     pop ebp
  4182.     jmp [_MsiPreviewDialogW]
  4183.   end;
  4184. end;
  4185. {$ELSE}
  4186. function MsiPreviewDialogW; external msilib name 'MsiPreviewDialogW';
  4187. {$ENDIF DYNAMIC_LINK}
  4188. {$IFDEF UNICODE}
  4190. {$IFDEF DYNAMIC_LINK}
  4191. var
  4192.   _MsiPreviewDialog: Pointer;
  4194. function MsiPreviewDialog;
  4195. begin
  4196.   GetProcedureAddress(_MsiPreviewDialog, msilib, 'MsiPreviewDialogW');
  4197.   asm
  4198.     mov esp, ebp
  4199.     pop ebp
  4200.     jmp [_MsiPreviewDialog]
  4201.   end;
  4202. end;
  4203. {$ELSE}
  4204. function MsiPreviewDialog; external msilib name 'MsiPreviewDialogW';
  4205. {$ENDIF DYNAMIC_LINK}
  4206. {$ELSE}
  4208. {$IFDEF DYNAMIC_LINK}
  4209. var
  4210.   _MsiPreviewDialog: Pointer;
  4212. function MsiPreviewDialog;
  4213. begin
  4214.   GetProcedureAddress(_MsiPreviewDialog, msilib, 'MsiPreviewDialogA');
  4215.   asm
  4216.     mov esp, ebp
  4217.     pop ebp
  4218.     jmp [_MsiPreviewDialog]
  4219.   end;
  4220. end;
  4221. {$ELSE}
  4222. function MsiPreviewDialog; external msilib name 'MsiPreviewDialogA';
  4223. {$ENDIF DYNAMIC_LINK}
  4224. {$ENDIF}
  4226. {$IFDEF DYNAMIC_LINK}
  4227. var
  4228.   _MsiPreviewBillboardA: Pointer;
  4230. function MsiPreviewBillboardA;
  4231. begin
  4232.   GetProcedureAddress(_MsiPreviewBillboardA, msilib, 'MsiPreviewBillboardA');
  4233.   asm
  4234.     mov esp, ebp
  4235.     pop ebp
  4236.     jmp [_MsiPreviewBillboardA]
  4237.   end;
  4238. end;
  4239. {$ELSE}
  4240. function MsiPreviewBillboardA; external msilib name 'MsiPreviewBillboardA';
  4241. {$ENDIF DYNAMIC_LINK}
  4243. {$IFDEF DYNAMIC_LINK}
  4244. var
  4245.   _MsiPreviewBillboardW: Pointer;
  4247. function MsiPreviewBillboardW;
  4248. begin
  4249.   GetProcedureAddress(_MsiPreviewBillboardW, msilib, 'MsiPreviewBillboardW');
  4250.   asm
  4251.     mov esp, ebp
  4252.     pop ebp
  4253.     jmp [_MsiPreviewBillboardW]
  4254.   end;
  4255. end;
  4256. {$ELSE}
  4257. function MsiPreviewBillboardW; external msilib name 'MsiPreviewBillboardW';
  4258. {$ENDIF DYNAMIC_LINK}
  4259. {$IFDEF UNICODE}
  4261. {$IFDEF DYNAMIC_LINK}
  4262. var
  4263.   _MsiPreviewBillboard: Pointer;
  4265. function MsiPreviewBillboard;
  4266. begin
  4267.   GetProcedureAddress(_MsiPreviewBillboard, msilib, 'MsiPreviewBillboardW');
  4268.   asm
  4269.     mov esp, ebp
  4270.     pop ebp
  4271.     jmp [_MsiPreviewBillboard]
  4272.   end;
  4273. end;
  4274. {$ELSE}
  4275. function MsiPreviewBillboard; external msilib name 'MsiPreviewBillboardW';
  4276. {$ENDIF DYNAMIC_LINK}
  4277. {$ELSE}
  4279. {$IFDEF DYNAMIC_LINK}
  4280. var
  4281.   _MsiPreviewBillboard: Pointer;
  4283. function MsiPreviewBillboard;
  4284. begin
  4285.   GetProcedureAddress(_MsiPreviewBillboard, msilib, 'MsiPreviewBillboardA');
  4286.   asm
  4287.     mov esp, ebp
  4288.     pop ebp
  4289.     jmp [_MsiPreviewBillboard]
  4290.   end;
  4291. end;
  4292. {$ELSE}
  4293. function MsiPreviewBillboard; external msilib name 'MsiPreviewBillboardA';
  4294. {$ENDIF DYNAMIC_LINK}
  4295. {$ENDIF}
  4297. {$IFDEF DYNAMIC_LINK}
  4298. var
  4299.   _MsiGetLastErrorRecord: Pointer;
  4301. function MsiGetLastErrorRecord;
  4302. begin
  4303.   GetProcedureAddress(_MsiGetLastErrorRecord, msilib, 'MsiGetLastErrorRecord');
  4304.   asm
  4305.     mov esp, ebp
  4306.     pop ebp
  4307.     jmp [_MsiGetLastErrorRecord]
  4308.   end;
  4309. end;
  4310. {$ELSE}
  4311. function MsiGetLastErrorRecord; external msilib name 'MsiGetLastErrorRecord';
  4312. {$ENDIF DYNAMIC_LINK}
  4314. end.