Why Gemfury?
Push, build, and install
RubyGems
npm packages
Python packages
Maven artifacts
PHP packages
Go Modules
Debian packages
RPM packages
NuGet packages
Repository URL to install this package:
|
Version:
3.0.0 ▾
|
{******************************************************************************}
{ }
{ Windows Installer API interface Unit for Object Pascal }
{ }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
{ Corporation. All Rights Reserved. }
{ }
{ The original file is: msiquery.h, released June 2000. The original Pascal }
{ code is: MsiQuery.pas, released June 2001. The initial developer of the }
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
{ }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
{ Marcel van Brakel. All Rights Reserved. }
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ }
{ You may retrieve the latest version of this file at the Project JEDI }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{******************************************************************************}
// $Id: JwaMsiQuery.pas,v 1.11 2007/09/05 11:58:51 dezipaitor Exp $
{$IFNDEF JWA_OMIT_SECTIONS}
unit JwaMsiQuery;
{$WEAKPACKAGEUNIT}
{$ENDIF JWA_OMIT_SECTIONS}
{$HPPEMIT ''}
{$HPPEMIT '#include "msiquery.h"'}
{$HPPEMIT ''}
{$IFNDEF JWA_OMIT_SECTIONS}
{$I jediapilib.inc}
interface
uses
JwaMsi, JwaWinBase, JwaWinType;
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_IMPLEMENTATIONSECTION}
(*****************************************************************************\
* *
* MsiQuery.h - Interface to running installer for custom actions and tools *
* *
* Version 1.0 - 1.2 *
* *
* NOTES: All buffers sizes are TCHAR count, null included only on input *
* Return argument pointers may be null if not interested in value *
* Returned handles of all types must be closed: MsiCloseHandle(h) *
* Functions with UINT return type return a system error code *
* Designated functions will set or clear the last error record, *
* which is then accessible with MsiGetLastErrorRecord. However, *
* the following argument errors do not register an error record: *
* ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, ERROR_MORE_DATA. *
* *
* Copyright (c) 1999-2000, Microsoft Corp. All rights reserved. *
* *
\*****************************************************************************)
const
MSI_NULL_INTEGER = DWORD($80000000); // integer value reserved for null
{$EXTERNALSYM MSI_NULL_INTEGER}
// MsiOpenDatabase persist predefine values, otherwise output database path is used
MSIDBOPEN_READONLY = LPCTSTR(0); // database open read-only, no persistent changes
{$EXTERNALSYM MSIDBOPEN_READONLY}
MSIDBOPEN_TRANSACT = LPCTSTR(1); // database read/write in transaction mode
{$EXTERNALSYM MSIDBOPEN_TRANSACT}
MSIDBOPEN_DIRECT = LPCTSTR(2); // database direct read/write without transaction
{$EXTERNALSYM MSIDBOPEN_DIRECT}
MSIDBOPEN_CREATE = LPCTSTR(3); // create new database, transact mode read/write
{$EXTERNALSYM MSIDBOPEN_CREATE}
MSIDBOPEN_CREATEDIRECT = LPCTSTR(4); // create new database, direct mode read/write
{$EXTERNALSYM MSIDBOPEN_CREATEDIRECT}
MSIDBOPEN_PATCHFILE = 32 div SizeOf(TCHAR); // add flag to indicate patch file
MSIDBSTATE_ERROR = DWORD(-1); // invalid database handle
{$EXTERNALSYM MSIDBSTATE_ERROR}
MSIDBSTATE_READ = 0; // database open read-only, no persistent changes
{$EXTERNALSYM MSIDBSTATE_READ}
MSIDBSTATE_WRITE = 1; // database readable and updatable
{$EXTERNALSYM MSIDBSTATE_WRITE}
type
MSIDBSTATE = DWORD;
{$EXTERNALSYM MSIDBSTATE}
TMsiDbState = MSIDBSTATE;
const
MSIMODIFY_SEEK = DWORD(-1); // reposition to current record primary key
{$EXTERNALSYM MSIMODIFY_SEEK}
MSIMODIFY_REFRESH = 0; // refetch current record data
{$EXTERNALSYM MSIMODIFY_REFRESH}
MSIMODIFY_INSERT = 1; // insert new record, fails if matching key exists
{$EXTERNALSYM MSIMODIFY_INSERT}
MSIMODIFY_UPDATE = 2; // update existing non-key data of fetched record
{$EXTERNALSYM MSIMODIFY_UPDATE}
MSIMODIFY_ASSIGN = 3; // insert record, replacing any existing record
{$EXTERNALSYM MSIMODIFY_ASSIGN}
MSIMODIFY_REPLACE = 4; // update record, delete old if primary key edit
{$EXTERNALSYM MSIMODIFY_REPLACE}
MSIMODIFY_MERGE = 5; // fails if record with duplicate key not identical
{$EXTERNALSYM MSIMODIFY_MERGE}
MSIMODIFY_DELETE = 6; // remove row referenced by this record from table
{$EXTERNALSYM MSIMODIFY_DELETE}
MSIMODIFY_INSERT_TEMPORARY = 7; // insert a temporary record
{$EXTERNALSYM MSIMODIFY_INSERT_TEMPORARY}
MSIMODIFY_VALIDATE = 8; // validate a fetched record
{$EXTERNALSYM MSIMODIFY_VALIDATE}
MSIMODIFY_VALIDATE_NEW = 9; // validate a new record
{$EXTERNALSYM MSIMODIFY_VALIDATE_NEW}
MSIMODIFY_VALIDATE_FIELD = 10; // validate field(s) of an incomplete record
{$EXTERNALSYM MSIMODIFY_VALIDATE_FIELD}
MSIMODIFY_VALIDATE_DELETE = 11; // validate before deleting record
{$EXTERNALSYM MSIMODIFY_VALIDATE_DELETE}
type
MSIMODIFY = DWORD;
{$EXTERNALSYM MSIMODIFY}
TMsiModify = MSIMODIFY;
const
MSICOLINFO_NAMES = 0; // return column names
{$EXTERNALSYM MSICOLINFO_NAMES}
MSICOLINFO_TYPES = 1; // return column definitions, datatype code followed by width
{$EXTERNALSYM MSICOLINFO_TYPES}
type
MSICOLINFO = DWORD;
{$EXTERNALSYM MSICOLINFO}
TMsiColInfo = MSICOLINFO;
const
MSICONDITION_FALSE = 0; // expression evaluates to False
{$EXTERNALSYM MSICONDITION_FALSE}
MSICONDITION_TRUE = 1; // expression evaluates to True
{$EXTERNALSYM MSICONDITION_TRUE}
MSICONDITION_NONE = 2; // no expression present
{$EXTERNALSYM MSICONDITION_NONE}
MSICONDITION_ERROR = 3; // syntax error in expression
{$EXTERNALSYM MSICONDITION_ERROR}
type
MSICONDITION = DWORD;
{$EXTERNALSYM MSICONDITION}
TMsiCondition = MSICONDITION;
const
MSICOSTTREE_SELFONLY = 0;
{$EXTERNALSYM MSICOSTTREE_SELFONLY}
MSICOSTTREE_CHILDREN = 1;
{$EXTERNALSYM MSICOSTTREE_CHILDREN}
MSICOSTTREE_PARENTS = 2;
{$EXTERNALSYM MSICOSTTREE_PARENTS}
MSICOSTTREE_RESERVED = 3; // Reserved for future use
{$EXTERNALSYM MSICOSTTREE_RESERVED}
type
MSICOSTTREE = DWORD;
{$EXTERNALSYM MSICOSTTREE}
TMsiCostTree = MSICOSTTREE;
const
MSIDBERROR_INVALIDARG = DWORD(-3); // invalid argument
{$EXTERNALSYM MSIDBERROR_INVALIDARG}
MSIDBERROR_MOREDATA = DWORD(-2); // buffer too small
{$EXTERNALSYM MSIDBERROR_MOREDATA}
MSIDBERROR_FUNCTIONERROR = DWORD(-1); // function error
{$EXTERNALSYM MSIDBERROR_FUNCTIONERROR}
MSIDBERROR_NOERROR = 0; // no error
{$EXTERNALSYM MSIDBERROR_NOERROR}
MSIDBERROR_DUPLICATEKEY = 1; // new record duplicates primary keys of existing record in table
{$EXTERNALSYM MSIDBERROR_DUPLICATEKEY}
MSIDBERROR_REQUIRED = 2; // non-nullable column, no null values allowed
{$EXTERNALSYM MSIDBERROR_REQUIRED}
MSIDBERROR_BADLINK = 3; // corresponding record in foreign table not found
{$EXTERNALSYM MSIDBERROR_BADLINK}
MSIDBERROR_OVERFLOW = 4; // data greater than maximum value allowed
{$EXTERNALSYM MSIDBERROR_OVERFLOW}
MSIDBERROR_UNDERFLOW = 5; // data less than minimum value allowed
{$EXTERNALSYM MSIDBERROR_UNDERFLOW}
MSIDBERROR_NOTINSET = 6; // data not a member of the values permitted in the set
{$EXTERNALSYM MSIDBERROR_NOTINSET}
MSIDBERROR_BADVERSION = 7; // invalid version string
{$EXTERNALSYM MSIDBERROR_BADVERSION}
MSIDBERROR_BADCASE = 8; // invalid case, must be all upper-case or all lower-case
{$EXTERNALSYM MSIDBERROR_BADCASE}
MSIDBERROR_BADGUID = 9; // invalid GUID
{$EXTERNALSYM MSIDBERROR_BADGUID}
MSIDBERROR_BADWILDCARD = 10; // invalid wildcardfilename or use of wildcards
{$EXTERNALSYM MSIDBERROR_BADWILDCARD}
MSIDBERROR_BADIDENTIFIER = 11; // bad identifier
{$EXTERNALSYM MSIDBERROR_BADIDENTIFIER}
MSIDBERROR_BADLANGUAGE = 12; // bad language Id(s)
{$EXTERNALSYM MSIDBERROR_BADLANGUAGE}
MSIDBERROR_BADFILENAME = 13; // bad filename
{$EXTERNALSYM MSIDBERROR_BADFILENAME}
MSIDBERROR_BADPATH = 14; // bad path
{$EXTERNALSYM MSIDBERROR_BADPATH}
MSIDBERROR_BADCONDITION = 15; // bad conditional statement
{$EXTERNALSYM MSIDBERROR_BADCONDITION}
MSIDBERROR_BADFORMATTED = 16; // bad format string
{$EXTERNALSYM MSIDBERROR_BADFORMATTED}
MSIDBERROR_BADTEMPLATE = 17; // bad template string
{$EXTERNALSYM MSIDBERROR_BADTEMPLATE}
MSIDBERROR_BADDEFAULTDIR = 18; // bad string in DefaultDir column of Directory table
{$EXTERNALSYM MSIDBERROR_BADDEFAULTDIR}
MSIDBERROR_BADREGPATH = 19; // bad registry path string
{$EXTERNALSYM MSIDBERROR_BADREGPATH}
MSIDBERROR_BADCUSTOMSOURCE = 20; // bad string in CustomSource column of CustomAction table
{$EXTERNALSYM MSIDBERROR_BADCUSTOMSOURCE}
MSIDBERROR_BADPROPERTY = 21; // bad property string
{$EXTERNALSYM MSIDBERROR_BADPROPERTY}
MSIDBERROR_MISSINGDATA = 22; // _Validation table missing reference to column
{$EXTERNALSYM MSIDBERROR_MISSINGDATA}
MSIDBERROR_BADCATEGORY = 23; // Category column of _Validation table for column is invalid
{$EXTERNALSYM MSIDBERROR_BADCATEGORY}
MSIDBERROR_BADKEYTABLE = 24; // table in KeyTable column of _Validation table could not be found/loaded
{$EXTERNALSYM MSIDBERROR_BADKEYTABLE}
MSIDBERROR_BADMAXMINVALUES = 25; // value in MaxValue column of _Validation table is less than value in MinValue column
{$EXTERNALSYM MSIDBERROR_BADMAXMINVALUES}
MSIDBERROR_BADCABINET = 26; // bad cabinet name
{$EXTERNALSYM MSIDBERROR_BADCABINET}
MSIDBERROR_BADSHORTCUT = 27; // bad shortcut target
{$EXTERNALSYM MSIDBERROR_BADSHORTCUT}
MSIDBERROR_STRINGOVERFLOW = 28; // string overflow (greater than length allowed in column def)
{$EXTERNALSYM MSIDBERROR_STRINGOVERFLOW}
MSIDBERROR_BADLOCALIZEATTRIB = 29; // invalid localization attribute (primary keys cannot be localized)
{$EXTERNALSYM MSIDBERROR_BADLOCALIZEATTRIB}
type
MSIDBERROR = DWORD;
{$EXTERNALSYM MSIDBERROR}
TMsiDbError = MSIDBERROR;
const
MSIRUNMODE_ADMIN = 0; // admin mode install, else product install
{$EXTERNALSYM MSIRUNMODE_ADMIN}
MSIRUNMODE_ADVERTISE = 1; // installing advertisements, else installing or updating product
{$EXTERNALSYM MSIRUNMODE_ADVERTISE}
MSIRUNMODE_MAINTENANCE = 2; // modifying an existing installation, else new installation
{$EXTERNALSYM MSIRUNMODE_MAINTENANCE}
MSIRUNMODE_ROLLBACKENABLED = 3; // rollback is enabled
{$EXTERNALSYM MSIRUNMODE_ROLLBACKENABLED}
MSIRUNMODE_LOGENABLED = 4; // log file active, enabled prior to install session
{$EXTERNALSYM MSIRUNMODE_LOGENABLED}
MSIRUNMODE_OPERATIONS = 5; // spooling execute operations, else in determination phase
{$EXTERNALSYM MSIRUNMODE_OPERATIONS}
MSIRUNMODE_REBOOTATEND = 6; // reboot needed after successful installation (settable)
{$EXTERNALSYM MSIRUNMODE_REBOOTATEND}
MSIRUNMODE_REBOOTNOW = 7; // reboot needed to continue installation (settable)
{$EXTERNALSYM MSIRUNMODE_REBOOTNOW}
MSIRUNMODE_CABINET = 8; // installing files from cabinets and files using Media table
{$EXTERNALSYM MSIRUNMODE_CABINET}
MSIRUNMODE_SOURCESHORTNAMES= 9; // source LongFileNames suppressed via PID_MSISOURCE summary property
{$EXTERNALSYM MSIRUNMODE_SOURCESHORTNAMES}
MSIRUNMODE_TARGETSHORTNAMES= 10; // target LongFileNames suppressed via SHORTFILENAMES property
{$EXTERNALSYM MSIRUNMODE_TARGETSHORTNAMES}
MSIRUNMODE_RESERVED11 = 11; // future use
{$EXTERNALSYM MSIRUNMODE_RESERVED11}
MSIRUNMODE_WINDOWS9X = 12; // operating systems is Windows9?, else Windows NT
{$EXTERNALSYM MSIRUNMODE_WINDOWS9X}
MSIRUNMODE_ZAWENABLED = 13; // operating system supports demand installation
{$EXTERNALSYM MSIRUNMODE_ZAWENABLED}
MSIRUNMODE_RESERVED14 = 14; // future use
{$EXTERNALSYM MSIRUNMODE_RESERVED14}
MSIRUNMODE_RESERVED15 = 15; // future use
{$EXTERNALSYM MSIRUNMODE_RESERVED15}
MSIRUNMODE_SCHEDULED = 16; // custom action call from install script execution
{$EXTERNALSYM MSIRUNMODE_SCHEDULED}
MSIRUNMODE_ROLLBACK = 17; // custom action call from rollback execution script
{$EXTERNALSYM MSIRUNMODE_ROLLBACK}
MSIRUNMODE_COMMIT = 18; // custom action call from commit execution script
{$EXTERNALSYM MSIRUNMODE_COMMIT}
type
MSIRUNMODE = DWORD;
{$EXTERNALSYM MSIRUNMODE}
TMsiRunMode = MSIRUNMODE;
const
INSTALLMESSAGE_TYPEMASK = DWORD($FF000000); // mask for type code
{$EXTERNALSYM INSTALLMESSAGE_TYPEMASK}
// Note: INSTALLMESSAGE_ERROR, INSTALLMESSAGE_WARNING, INSTALLMESSAGE_USER are to or'd
// with a message box style to indicate the buttons to display and return:
// MB_OK,MB_OKCANCEL,MB_ABORTRETRYIGNORE,MB_YESNOCANCEL,MB_YESNO,MB_RETRYCANCEL
// the default button (MB_DEFBUTTON1 is normal default):
// MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3
// and optionally an icon style:
// MB_ICONERROR, MB_ICONQUESTION, MB_ICONWARNING, MB_ICONINFORMATION
const
MSITRANSFORM_ERROR_ADDEXISTINGROW = $00000001;
{$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGROW}
MSITRANSFORM_ERROR_DELMISSINGROW = $00000002;
{$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGROW}
MSITRANSFORM_ERROR_ADDEXISTINGTABLE = $00000004;
{$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGTABLE}
MSITRANSFORM_ERROR_DELMISSINGTABLE = $00000008;
{$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGTABLE}
MSITRANSFORM_ERROR_UPDATEMISSINGROW = $00000010;
{$EXTERNALSYM MSITRANSFORM_ERROR_UPDATEMISSINGROW}
MSITRANSFORM_ERROR_CHANGECODEPAGE = $00000020;
{$EXTERNALSYM MSITRANSFORM_ERROR_CHANGECODEPAGE}
MSITRANSFORM_ERROR_VIEWTRANSFORM = $00000100;
{$EXTERNALSYM MSITRANSFORM_ERROR_VIEWTRANSFORM}
type
MSITRANSFORM_ERROR = DWORD;
{$EXTERNALSYM MSITRANSFORM_ERROR}
TMsiTransformError = MSITRANSFORM_ERROR;
const
MSITRANSFORM_VALIDATE_LANGUAGE = $00000001;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_LANGUAGE}
MSITRANSFORM_VALIDATE_PRODUCT = $00000002;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_PRODUCT}
MSITRANSFORM_VALIDATE_PLATFORM = $00000004;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_PLATFORM}
MSITRANSFORM_VALIDATE_MAJORVERSION = $00000008;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_MAJORVERSION}
MSITRANSFORM_VALIDATE_MINORVERSION = $00000010;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_MINORVERSION}
MSITRANSFORM_VALIDATE_UPDATEVERSION = $00000020;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_UPDATEVERSION}
MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION = $00000040;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION}
MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION = $00000080;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION}
MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION = $00000100;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION}
MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION = $00000200;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION}
MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION = $00000400;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION}
MSITRANSFORM_VALIDATE_UPGRADECODE = $00000800;
{$EXTERNALSYM MSITRANSFORM_VALIDATE_UPGRADECODE}
type
MSITRANSFORM_VALIDATE = DWORD;
{$EXTERNALSYM MSITRANSFORM_VALIDATE}
TMsiTransformValidate = MSITRANSFORM_VALIDATE;
// -----------------------------------------------------------------------------
// Installer database access functions
// -----------------------------------------------------------------------------
// Prepare a database query, creating a view object
// Returns ERROR_SUCCESS if successful, and the view handle is returned,
// else ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_BAD_QUERY_SYNTAX, ERROR_GEN_FAILURE
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiDatabaseOpenViewA(hDatabase: MSIHANDLE; szQuery: LPCSTR; var phView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseOpenViewA}
function MsiDatabaseOpenViewW(hDatabase: MSIHANDLE; szQuery: LPCWSTR; var phView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseOpenViewW}
function MsiDatabaseOpenView(hDatabase: MSIHANDLE; szQuery: LPCTSTR; var phView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseOpenView}
// Returns the MSIDBERROR enum and name of the column corresponding to the error
// Similar to a GetLastError function, but for the view. NOT the same as MsiGetLastErrorRecord
// Returns errors of MsiViewModify.
function MsiViewGetErrorA(hView: MSIHANDLE; szColumnNameBuffer: LPSTR;
var pcchBuf: DWORD): MSIDBERROR; stdcall;
{$EXTERNALSYM MsiViewGetErrorA}
function MsiViewGetErrorW(hView: MSIHANDLE; szColumnNameBuffer: LPWSTR;
var pcchBuf: DWORD): MSIDBERROR; stdcall;
{$EXTERNALSYM MsiViewGetErrorW}
function MsiViewGetError(hView: MSIHANDLE; szColumnNameBuffer: LPTSTR;
var pcchBuf: DWORD): MSIDBERROR; stdcall;
{$EXTERNALSYM MsiViewGetError}
// Exectute the view query, supplying parameters as required
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiViewExecute(hView: MSIHANDLE; hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewExecute}
// Fetch the next sequential record from the view
// Result is ERROR_SUCCESS if a row is found, and its handle is returned
// else ERROR_NO_MORE_ITEMS if no records remain, and a null handle is returned
// else result is error: ERROR_INVALID_HANDLE_STATE, ERROR_INVALID_HANDLE, ERROR_GEN_FAILURE
function MsiViewFetch(hView: MSIHANDLE; var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewFetch}
// Modify a database record, parameters must match types in query columns
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE, ERROR_ACCESS_DENIED
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiViewModify(hView: MSIHANDLE; eModifyMode: MSIMODIFY; hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewModify}
// Return the column names or specifications for the current view
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, or ERROR_INVALID_HANDLE_STATE
function MsiViewGetColumnInfo(hView: MSIHANDLE; eColumnInfo: MSICOLINFO;
var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewGetColumnInfo}
// Release the result set for an executed view, to allow re-execution
// Only needs to be called if not all records have been fetched
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE
function MsiViewClose(hView: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiViewClose}
// Return a record containing the names of all primary key columns for a given table
// Returns an MSIHANDLE for a record containing the name of each column.
// The field count of the record corresponds to the number of primary key columns.
// Field [0] of the record contains the table name.
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_TABLE
function MsiDatabaseGetPrimaryKeysA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGetPrimaryKeysA}
function MsiDatabaseGetPrimaryKeysW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGetPrimaryKeysW}
function MsiDatabaseGetPrimaryKeys(hDatabase: MSIHANDLE; szTableName: LPCTSTR;
var phRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGetPrimaryKeys}
// Return an enum defining the state of the table (temporary, unknown, or persistent).
// Returns MSICONDITION_ERROR, MSICONDITION_FALSE, MSICONDITION_TRUE, MSICONDITION_NONE
function MsiDatabaseIsTablePersistentA(hDatabase: MSIHANDLE; szTableName: LPCSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiDatabaseIsTablePersistentA}
function MsiDatabaseIsTablePersistentW(hDatabase: MSIHANDLE; szTableName: LPCWSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiDatabaseIsTablePersistentW}
function MsiDatabaseIsTablePersistent(hDatabase: MSIHANDLE; szTableName: LPCTSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiDatabaseIsTablePersistent}
// --------------------------------------------------------------------------
// Summary information stream management functions
// --------------------------------------------------------------------------
// Integer Property IDs: 1, 14, 15, 16, 19
// DateTime Property IDs: 10, 11, 12, 13
// Text Property IDs: 2, 3, 4, 5, 6, 7, 8, 9, 18
// Unsupported Propery IDs: 0 (PID_DICTIONARY), 17 (PID_THUMBNAIL)
// Obtain a handle for the _SummaryInformation stream for an MSI database
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiGetSummaryInformationA(hDatabase: MSIHANDLE; szDatabasePath: LPCSTR;
uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiGetSummaryInformationA}
function MsiGetSummaryInformationW(hDatabase: MSIHANDLE; szDatabasePath: LPCWSTR;
uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiGetSummaryInformationW}
function MsiGetSummaryInformation(hDatabase: MSIHANDLE; szDatabasePath: LPCTSTR;
uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiGetSummaryInformation}
// Obtain the number of existing properties in the SummaryInformation stream
function MsiSummaryInfoGetPropertyCount(hSummaryInfo: MSIHANDLE; var puiPropertyCount: UINT): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetPropertyCount}
// Set a single summary information property
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY
function MsiSummaryInfoSetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoSetPropertyA}
function MsiSummaryInfoSetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoSetPropertyW}
function MsiSummaryInfoSetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoSetProperty}
// Get a single property from the summary information
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY
function MsiSummaryInfoGetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetPropertyA}
function MsiSummaryInfoGetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPWSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetPropertyW}
function MsiSummaryInfoGetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPTSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoGetProperty}
// Write back changed information to summary information stream
function MsiSummaryInfoPersist(hSummaryInfo: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiSummaryInfoPersist}
// --------------------------------------------------------------------------
// Installer database management functions - not used by custom actions
// --------------------------------------------------------------------------
// Open an installer database, specifying the persistance mode, which is a pointer.
// Predefined persist values are reserved pointer values, requiring pointer arithmetic.
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiOpenDatabaseA(szDatabasePath: LPCSTR; szPersist: LPCSTR;
var phDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiOpenDatabaseA}
function MsiOpenDatabaseW(szDatabasePath: LPCWSTR; szPersist: LPCWSTR;
var phDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiOpenDatabaseW}
function MsiOpenDatabase(szDatabasePath: LPCTSTR; szPersist: LPCTSTR;
var phDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiOpenDatabase}
// Import an MSI text archive table into an open database
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiDatabaseImportA(hDatabase: MSIHANDLE; szFolderPath: LPCSTR;
szFileName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseImportA}
function MsiDatabaseImportW(hDatabase: MSIHANDLE; szFolderPath: LPCWSTR;
szFileName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseImportW}
function MsiDatabaseImport(hDatabase: MSIHANDLE; szFolderPath: LPCTSTR;
szFileName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseImport}
// Export an MSI table from an open database to a text archive file
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiDatabaseExportA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
szFolderPath: LPCSTR; szFileName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseExportA}
function MsiDatabaseExportW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
szFolderPath: LPCWSTR; szFileName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseExportW}
function MsiDatabaseExport(hDatabase: MSIHANDLE; szTableName: LPCTSTR;
szFolderPath: LPCTSTR; szFileName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseExport}
// Merge two database together, allowing duplicate rows
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiDatabaseMergeA(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
szTableName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseMergeA}
function MsiDatabaseMergeW(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
szTableName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseMergeW}
function MsiDatabaseMerge(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
szTableName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseMerge}
// Generate a transform file of differences between two databases
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiDatabaseGenerateTransformA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
szTransformFile: LPCSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGenerateTransformA}
function MsiDatabaseGenerateTransformW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
szTransformFile: LPCWSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGenerateTransformW}
function MsiDatabaseGenerateTransform(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
szTransformFile: LPCTSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseGenerateTransform}
// Apply a transform file containing database difference
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiDatabaseApplyTransformA(hDatabase: MSIHANDLE; szTransformFile: LPCSTR;
iErrorConditions: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseApplyTransformA}
function MsiDatabaseApplyTransformW(hDatabase: MSIHANDLE; szTransformFile: LPCWSTR;
iErrorConditions: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseApplyTransformW}
function MsiDatabaseApplyTransform(hDatabase: MSIHANDLE; szTransformFile: LPCTSTR;
iErrorConditions: Integer): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseApplyTransform}
// Create summary information of existing transform to include validation and error conditions
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiCreateTransformSummaryInfoA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
szTransformFile: LPCSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
{$EXTERNALSYM MsiCreateTransformSummaryInfoA}
function MsiCreateTransformSummaryInfoW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
szTransformFile: LPCWSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
{$EXTERNALSYM MsiCreateTransformSummaryInfoW}
function MsiCreateTransformSummaryInfo(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
szTransformFile: LPCTSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
{$EXTERNALSYM MsiCreateTransformSummaryInfo}
// Write out all persistent table data, ignored if database opened read-only
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiDatabaseCommit(hDatabase: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiDatabaseCommit}
// Return the update state of a database
function MsiGetDatabaseState(hDatabase: MSIHANDLE): MSIDBSTATE; stdcall;
{$EXTERNALSYM MsiGetDatabaseState}
// --------------------------------------------------------------------------
// Record object functions
// --------------------------------------------------------------------------
// Create a new record object with the requested number of fields
// Field 0, not included in count, is used for format strings and op codes
// All fields are initialized to null
// Returns a handle to the created record, or 0 if memory could not be allocated
function MsiCreateRecord(cParams: UINT): MSIHANDLE; stdcall;
{$EXTERNALSYM MsiCreateRecord}
// Report whether a record field is NULL
// Returns TRUE if the field is null or does not exist
// Returns FALSE if the field contains data, or the handle is invalid
function MsiRecordIsNull(hRecord: MSIHANDLE; iField: UINT): BOOL; stdcall;
{$EXTERNALSYM MsiRecordIsNull}
// Return the length of a record field
// Returns 0 if field is NULL or non-existent
// Returns sizeof(Integer) if integer data
// Returns character count if string data (not counting null terminator)
// Returns bytes count if stream data
function MsiRecordDataSize(hRecord: MSIHANDLE; iField: UINT): UINT; stdcall;
{$EXTERNALSYM MsiRecordDataSize}
// Set a record field to an integer value
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD
function MsiRecordSetInteger(hRecord: MSIHANDLE; iField: UINT; iValue: Integer): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetInteger}
// Copy a string into the designated field
// A null string pointer and an empty string both set the field to null
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD
function MsiRecordSetStringA(hRecord: MSIHANDLE; iField: UINT; szValue: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStringA}
function MsiRecordSetStringW(hRecord: MSIHANDLE; iField: UINT; szValue: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStringW}
function MsiRecordSetString(hRecord: MSIHANDLE; iField: UINT; szValue: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetString}
// Return the integer value from a record field
// Returns the value MSI_NULL_INTEGER if the field is null
// or if the field is a string that cannot be converted to an integer
function MsiRecordGetInteger(hRecord: MSIHANDLE; iField: UINT): Integer; stdcall;
{$EXTERNALSYM MsiRecordGetInteger}
// Return the string value of a record field
// Integer fields will be converted to a string
// Null and non-existent fields will report a value of 0
// Fields containing stream data will return ERROR_INVALID_DATATYPE
// Returns ERROR_SUCCESS, ERROR_MORE_DATA,
// ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD, ERROR_BAD_ARGUMENTS
function MsiRecordGetStringA(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetStringA}
function MsiRecordGetStringW(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPWSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetStringW}
function MsiRecordGetString(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPTSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetString}
// Returns the number of fields allocated in the record
// Does not count field 0, used for formatting and op codes
function MsiRecordGetFieldCount(hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiRecordGetFieldCount}
// Set a record stream field from a file
// The contents of the specified file will be read into a stream object
// The stream will be persisted if the record is inserted into the database
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiRecordSetStreamA(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStreamA}
function MsiRecordSetStreamW(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStreamW}
function MsiRecordSetStream(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiRecordSetStream}
// Read bytes from a record stream field into a buffer
// Must set the in/out argument to the requested byte count to read
// The number of bytes transferred is returned through the argument
// If no more bytes are available, ERROR_SUCCESS is still returned
function MsiRecordReadStream(hRecord: MSIHANDLE; iField: UINT; szDataBuf: PChar;
var pcbDataBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiRecordReadStream}
// Clears all data fields in a record to NULL
function MsiRecordClearData(hRecord: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiRecordClearData}
// --------------------------------------------------------------------------
// Functions to access a running installation, called from custom actions
// The install handle is the single argument passed to custom actions
// --------------------------------------------------------------------------
// Return a handle to the database currently in use by this installer instance
function MsiGetActiveDatabase(hInstall: MSIHANDLE): MSIHANDLE; stdcall;
{$EXTERNALSYM MsiGetActiveDatabase}
// Set the value for an installer property
// If the property is not defined, it will be created
// If the value is null or an empty string, the property will be removed
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS
function MsiSetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValue: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetPropertyA}
function MsiSetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValue: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetPropertyW}
function MsiSetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValue: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetProperty}
// Get the value for an installer property
// If the property is not defined, it is equivalent to a 0-length value, not error
// Returns ERROR_SUCCESS, ERROR_MORE_DATA, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS
function MsiGetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValueBuf: LPSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetPropertyA}
function MsiGetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValueBuf: LPWSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetPropertyW}
function MsiGetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValueBuf: LPTSTR;
var pcchValueBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetProperty}
// Return the numeric language for the currently running install
// Returns 0 if an install not running
function MsiGetLanguage(hInstall: MSIHANDLE): LANGID; stdcall;
{$EXTERNALSYM MsiGetLanguage}
// Return one of the boolean internal installer states
// Returns FALSE if the handle is not active or if the mode is not implemented
function MsiGetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE): BOOL; stdcall;
{$EXTERNALSYM MsiGetMode}
// Set an internal install session boolean mode - Note: most modes are read-only
// Returns ERROR_SUCCESS if the mode can be set to the desired state
// Returns ERROR_ACCESS_DENIED if the mode is not settable
// Returns ERROR_INVALID_HANDLE if the handle is not an active install session
function MsiSetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE; fState: BOOL): UINT; stdcall;
{$EXTERNALSYM MsiSetMode}
// Format record data using a format string containing field markers and/or properties
// Record field 0 must contain the format string
// Other fields must contain data that may be referenced by the format string.
function MsiFormatRecordA(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPSTR;
var pcchResultBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiFormatRecordA}
function MsiFormatRecordW(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPWSTR;
var pcchResultBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiFormatRecordW}
function MsiFormatRecord(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPTSTR;
var pcchResultBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiFormatRecord}
// Execute another action, either built-in, custom, or UI wizard
// Returns ERROR_FUNCTION_NOT_CALLED if action not found
// Returns ERROR_SUCCESS if action completed succesfully
// Returns ERROR_INSTALL_USEREXIT if user cancelled during action
// Returns ERROR_INSTALL_FAILURE if action failed
// Returns ERROR_INSTALL_SUSPEND if user suspended installation
// Returns ERROR_MORE_DATA if action wishes to skip remaining actions
// Returns ERROR_INVALID_HANDLE_STATE if install session not active
// Returns ERROR_INVALID_DATA if failure calling custom action
// Returns ERROR_INVALID_HANDLE or ERROR_INVALID_PARAMETER if arguments invalid
function MsiDoActionA(hInstall: MSIHANDLE; szAction: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiDoActionA}
function MsiDoActionW(hInstall: MSIHANDLE; szAction: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiDoActionW}
function MsiDoAction(hInstall: MSIHANDLE; szAction: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiDoAction}
// Execute another action sequence, as descibed in the specified table
// Returns the same error codes as MsiDoAction
function MsiSequenceA(hInstall: MSIHANDLE; szTable: LPCSTR; iSequenceMode: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSequenceA}
function MsiSequenceW(hInstall: MSIHANDLE; szTable: LPCWSTR; iSequenceMode: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSequenceW}
function MsiSequence(hInstall: MSIHANDLE; szTable: LPCTSTR; iSequenceMode: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSequence}
// Send an error record to the installer for processing.
// If field 0 (template) is not set, field 1 must be set to the error code,
// corresponding the the error message in the Error database table,
// and the message will be formatted using the template from the Error table
// before passing it to the UI handler for display.
// Returns Win32 button codes: IDOK IDCANCEL IDABORT IDRETRY IDIGNORE IDYES IDNO
// or 0 if no action taken, or -1 if invalid argument or handle
function MsiProcessMessage(hInstall: MSIHANDLE; eMessageType: INSTALLMESSAGE;
hRecord: MSIHANDLE): Integer; stdcall;
{$EXTERNALSYM MsiProcessMessage}
// Evaluate a conditional expression containing property names and values
function MsiEvaluateConditionA(hInstall: MSIHANDLE; szCondition: LPCSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiEvaluateConditionA}
function MsiEvaluateConditionW(hInstall: MSIHANDLE; szCondition: LPCWSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiEvaluateConditionW}
function MsiEvaluateCondition(hInstall: MSIHANDLE; szCondition: LPCTSTR): MSICONDITION; stdcall;
{$EXTERNALSYM MsiEvaluateCondition}
// Get the installed state and requested action state of a feature
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiGetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureStateA}
function MsiGetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureStateW}
function MsiGetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR;
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureState}
// Request a feature to be set to a specified state
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiSetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureStateA}
function MsiSetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureStateW}
function MsiSetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR;
iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureState}
// Set the attribute bits of a specified feature at runtime.
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiSetFeatureAttributesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
dwAttributes: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureAttributesA}
function MsiSetFeatureAttributesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
dwAttributes: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureAttributesW}
function MsiSetFeatureAttributes(hInstall: MSIHANDLE; szFeature: LPCTSTR;
dwAttributes: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiSetFeatureAttributes}
// Get the installed state and requested action state of a component
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiGetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetComponentStateA}
function MsiGetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetComponentStateW}
function MsiGetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR;
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiGetComponentState}
// Request a component to be set to a specified state
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiSetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetComponentStateA}
function MsiSetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetComponentStateW}
function MsiSetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR;
iState: INSTALLSTATE): UINT; stdcall;
{$EXTERNALSYM MsiSetComponentState}
// Return the disk cost for a feature and related features
// Can specify either current feature state or proposed state
// Can specify extent of related features to cost
// Note that adding costs for several features may produce an
// excessively large cost due to shared components and parents.
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiGetFeatureCostA(hInstall: MSIHANDLE; szFeature: LPCSTR;
iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureCostA}
function MsiGetFeatureCostW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureCostW}
function MsiGetFeatureCost(hInstall: MSIHANDLE; szFeature: LPCTSTR;
iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureCost}
// Enumerates the costs and temporary costs per drives for
// szComponent. If szComponent is set to NULL, it enumerates
// the above costs for the engine, per drives.
//
// The enumeration is 0-based, i.e. it returns the data for
// the first drive when called w/ dwIndex set to 0.
//
// Can specify either current feature state or proposed state.
//
// Execution of this function sets the error record, accessible
// via MsiGetLastErrorRecord.
function MsiEnumComponentCostsA(hInstall: MSIHANDLE; szComponent: LPCSTR; dwIndex: DWORD; iState: INSTALLSTATE;
szDriveBuf: LPSTR; var pcchDriveBuf: DWORD; var piCost: INT; piTempCost: INT): UINT; stdcall;
{$EXTERNALSYM MsiEnumComponentCostsA}
function MsiEnumComponentCostsW(hInstall: MSIHANDLE; szComponent: LPCWSTR; dwIndex: DWORD; iState: INSTALLSTATE;
szDriveBuf: LPWSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
{$EXTERNALSYM MsiEnumComponentCostsW}
function MsiEnumComponentCosts(hInstall: MSIHANDLE; szComponent: LPCTSTR; dwIndex: DWORD; iState: INSTALLSTATE;
szDriveBuf: LPTSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
{$EXTERNALSYM MsiEnumComponentCosts}
// Set the install level for a full product installation (not a feature request)
// Setting the value to 0 initialized components and features to the default level
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiSetInstallLevel(hInstall: MSIHANDLE; iInstallLevel: Integer): UINT; stdcall;
{$EXTERNALSYM MsiSetInstallLevel}
// Get the valid install states for a feature, represented by bit flags
// For each valid install state, a bit is set of value: (1 << INSTALLSTATE)
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiGetFeatureValidStatesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
var dwInstallStates: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureValidStatesA}
function MsiGetFeatureValidStatesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
var dwInstallStates: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureValidStatesW}
function MsiGetFeatureValidStates(hInstall: MSIHANDLE; szFeature: LPCTSTR;
var dwInstallStates: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetFeatureValidStates}
// Return the full source path for a folder in the Directory table
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiGetSourcePathA(hInstall: MSIHANDLE; szFolder: LPCSTR; szPathBuf: LPSTR;
var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetSourcePathA}
function MsiGetSourcePathW(hInstall: MSIHANDLE; szFolder: LPCWSTR; szPathBuf: LPWSTR;
var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetSourcePathW}
function MsiGetSourcePath(hInstall: MSIHANDLE; szFolder: LPCTSTR; szPathBuf: LPTSTR;
var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetSourcePath}
// Return the full target path for a folder in the Directory table
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiGetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
szPathBuf: LPSTR; var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetTargetPathA}
function MsiGetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
szPathBuf: LPWSTR; var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetTargetPathW}
function MsiGetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR;
szPathBuf: LPTSTR; var pcchPathBuf: DWORD): UINT; stdcall;
{$EXTERNALSYM MsiGetTargetPath}
// Set the full target path for a folder in the Directory table
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
function MsiSetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
szFolderPath: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetTargetPathA}
function MsiSetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
szFolderPath: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetTargetPathW}
function MsiSetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR;
szFolderPath: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiSetTargetPath}
// Check to see if sufficent disk space is present for the current installation
// Returns ERROR_SUCCESS, ERROR_DISK_FULL, ERROR_INVALID_HANDLE_STATE, or ERROR_INVALID_HANDLE
function MsiVerifyDiskSpace(hInstall: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiVerifyDiskSpace}
// --------------------------------------------------------------------------
// Functions for rendering UI dialogs from the database representations.
// Purpose is for product development, not for use during installation.
// --------------------------------------------------------------------------
// Enable UI in preview mode to facilitate authoring of UI dialogs.
// The preview mode will end when the handle is closed.
function MsiEnableUIPreview(hDatabase: MSIHANDLE; var phPreview: MSIHANDLE): UINT; stdcall;
{$EXTERNALSYM MsiEnableUIPreview}
// Display any UI dialog as modeless and inactive.
// Supplying a null name will remove any current dialog.
function MsiPreviewDialogA(hPreview: MSIHANDLE; szDialogName: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewDialogA}
function MsiPreviewDialogW(hPreview: MSIHANDLE; szDialogName: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewDialogW}
function MsiPreviewDialog(hPreview: MSIHANDLE; szDialogName: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewDialog}
// Display a billboard within a host control in the displayed dialog.
// Supplying a null billboard name will remove any billboard displayed.
function MsiPreviewBillboardA(hPreview: MSIHANDLE; szControlName: LPCSTR;
szBillboard: LPCSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewBillboardA}
function MsiPreviewBillboardW(hPreview: MSIHANDLE; szControlName: LPCWSTR;
szBillboard: LPCWSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewBillboardW}
function MsiPreviewBillboard(hPreview: MSIHANDLE; szControlName: LPCTSTR;
szBillboard: LPCTSTR): UINT; stdcall;
{$EXTERNALSYM MsiPreviewBillboard}
// --------------------------------------------------------------------------
// Error handling not associated with any particular object
// --------------------------------------------------------------------------
// Return a record handle to the last function that generated an error record
// Only specified functions will set the error record, or clear it if success
// Field 1 of the record will contain the internal MSI error code
// Other fields will contain data specific to the particular error
// The error record is released internally after this function is executed
function MsiGetLastErrorRecord: MSIHANDLE; stdcall;
{$EXTERNALSYM MsiGetLastErrorRecord}
{$ENDIF JWA_IMPLEMENTATIONSECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
implementation
//uses ...
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_INTERFACESECTION}
{$IFNDEF JWA_INCLUDEMODE}
const
msilib = 'msi.dll';
{$IFDEF UNICODE}
AWSuffix = 'W';
{$ELSE}
AWSuffix = 'A';
{$ENDIF UNICODE}
{$ENDIF JWA_INCLUDEMODE}
{$IFDEF DYNAMIC_LINK}
var
_MsiDatabaseOpenViewA: Pointer;
function MsiDatabaseOpenViewA;
begin
GetProcedureAddress(_MsiDatabaseOpenViewA, msilib, 'MsiDatabaseOpenViewA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseOpenViewA]
end;
end;
var
_MsiDatabaseOpenViewW: Pointer;
function MsiDatabaseOpenViewW;
begin
GetProcedureAddress(_MsiDatabaseOpenViewW, msilib, 'MsiDatabaseOpenViewW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseOpenViewW]
end;
end;
var
_MsiDatabaseOpenView: Pointer;
function MsiDatabaseOpenView;
begin
GetProcedureAddress(_MsiDatabaseOpenView, msilib, 'MsiDatabaseOpenView' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseOpenView]
end;
end;
var
_MsiViewGetErrorA: Pointer;
function MsiViewGetErrorA;
begin
GetProcedureAddress(_MsiViewGetErrorA, msilib, 'MsiViewGetErrorA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewGetErrorA]
end;
end;
var
_MsiViewGetErrorW: Pointer;
function MsiViewGetErrorW;
begin
GetProcedureAddress(_MsiViewGetErrorW, msilib, 'MsiViewGetErrorW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewGetErrorW]
end;
end;
var
_MsiViewGetError: Pointer;
function MsiViewGetError;
begin
GetProcedureAddress(_MsiViewGetError, msilib, 'MsiViewGetError' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewGetError]
end;
end;
var
_MsiViewExecute: Pointer;
function MsiViewExecute;
begin
GetProcedureAddress(_MsiViewExecute, msilib, 'MsiViewExecute');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewExecute]
end;
end;
var
_MsiViewFetch: Pointer;
function MsiViewFetch;
begin
GetProcedureAddress(_MsiViewFetch, msilib, 'MsiViewFetch');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewFetch]
end;
end;
var
_MsiViewModify: Pointer;
function MsiViewModify;
begin
GetProcedureAddress(_MsiViewModify, msilib, 'MsiViewModify');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewModify]
end;
end;
var
_MsiViewGetColumnInfo: Pointer;
function MsiViewGetColumnInfo;
begin
GetProcedureAddress(_MsiViewGetColumnInfo, msilib, 'MsiViewGetColumnInfo');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewGetColumnInfo]
end;
end;
var
_MsiViewClose: Pointer;
function MsiViewClose;
begin
GetProcedureAddress(_MsiViewClose, msilib, 'MsiViewClose');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiViewClose]
end;
end;
var
_MsiDatabaseGetPrimaryKeysA: Pointer;
function MsiDatabaseGetPrimaryKeysA;
begin
GetProcedureAddress(_MsiDatabaseGetPrimaryKeysA, msilib, 'MsiDatabaseGetPrimaryKeysA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseGetPrimaryKeysA]
end;
end;
var
_MsiDatabaseGetPrimaryKeysW: Pointer;
function MsiDatabaseGetPrimaryKeysW;
begin
GetProcedureAddress(_MsiDatabaseGetPrimaryKeysW, msilib, 'MsiDatabaseGetPrimaryKeysW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseGetPrimaryKeysW]
end;
end;
var
_MsiDatabaseGetPrimaryKeys: Pointer;
function MsiDatabaseGetPrimaryKeys;
begin
GetProcedureAddress(_MsiDatabaseGetPrimaryKeys, msilib, 'MsiDatabaseGetPrimaryKeys' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseGetPrimaryKeys]
end;
end;
var
_MsiDatabaseIsTablePersistentA: Pointer;
function MsiDatabaseIsTablePersistentA;
begin
GetProcedureAddress(_MsiDatabaseIsTablePersistentA, msilib, 'MsiDatabaseIsTablePersistentA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseIsTablePersistentA]
end;
end;
var
_MsiDatabaseIsTablePersistentW: Pointer;
function MsiDatabaseIsTablePersistentW;
begin
GetProcedureAddress(_MsiDatabaseIsTablePersistentW, msilib, 'MsiDatabaseIsTablePersistentW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseIsTablePersistentW]
end;
end;
var
_MsiDatabaseIsTablePersistent: Pointer;
function MsiDatabaseIsTablePersistent;
begin
GetProcedureAddress(_MsiDatabaseIsTablePersistent, msilib, 'MsiDatabaseIsTablePersistent' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseIsTablePersistent]
end;
end;
var
_MsiGetSummaryInformationA: Pointer;
function MsiGetSummaryInformationA;
begin
GetProcedureAddress(_MsiGetSummaryInformationA, msilib, 'MsiGetSummaryInformationA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetSummaryInformationA]
end;
end;
var
_MsiGetSummaryInformationW: Pointer;
function MsiGetSummaryInformationW;
begin
GetProcedureAddress(_MsiGetSummaryInformationW, msilib, 'MsiGetSummaryInformationW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetSummaryInformationW]
end;
end;
var
_MsiGetSummaryInformation: Pointer;
function MsiGetSummaryInformation;
begin
GetProcedureAddress(_MsiGetSummaryInformation, msilib, 'MsiGetSummaryInformation' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetSummaryInformation]
end;
end;
var
_MsiSummaryInfoGetPropertyCount: Pointer;
function MsiSummaryInfoGetPropertyCount;
begin
GetProcedureAddress(_MsiSummaryInfoGetPropertyCount, msilib, 'MsiSummaryInfoGetPropertyCount');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoGetPropertyCount]
end;
end;
var
_MsiSummaryInfoSetPropertyA: Pointer;
function MsiSummaryInfoSetPropertyA;
begin
GetProcedureAddress(_MsiSummaryInfoSetPropertyA, msilib, 'MsiSummaryInfoSetPropertyA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoSetPropertyA]
end;
end;
var
_MsiSummaryInfoSetPropertyW: Pointer;
function MsiSummaryInfoSetPropertyW;
begin
GetProcedureAddress(_MsiSummaryInfoSetPropertyW, msilib, 'MsiSummaryInfoSetPropertyW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoSetPropertyW]
end;
end;
var
_MsiSummaryInfoSetProperty: Pointer;
function MsiSummaryInfoSetProperty;
begin
GetProcedureAddress(_MsiSummaryInfoSetProperty, msilib, 'MsiSummaryInfoSetProperty' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoSetProperty]
end;
end;
var
_MsiSummaryInfoGetPropertyA: Pointer;
function MsiSummaryInfoGetPropertyA;
begin
GetProcedureAddress(_MsiSummaryInfoGetPropertyA, msilib, 'MsiSummaryInfoGetPropertyA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoGetPropertyA]
end;
end;
var
_MsiSummaryInfoGetPropertyW: Pointer;
function MsiSummaryInfoGetPropertyW;
begin
GetProcedureAddress(_MsiSummaryInfoGetPropertyW, msilib, 'MsiSummaryInfoGetPropertyW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoGetPropertyW]
end;
end;
var
_MsiSummaryInfoGetProperty: Pointer;
function MsiSummaryInfoGetProperty;
begin
GetProcedureAddress(_MsiSummaryInfoGetProperty, msilib, 'MsiSummaryInfoGetProperty' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoGetProperty]
end;
end;
var
_MsiSummaryInfoPersist: Pointer;
function MsiSummaryInfoPersist;
begin
GetProcedureAddress(_MsiSummaryInfoPersist, msilib, 'MsiSummaryInfoPersist');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSummaryInfoPersist]
end;
end;
var
_MsiOpenDatabaseA: Pointer;
function MsiOpenDatabaseA;
begin
GetProcedureAddress(_MsiOpenDatabaseA, msilib, 'MsiOpenDatabaseA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiOpenDatabaseA]
end;
end;
var
_MsiOpenDatabaseW: Pointer;
function MsiOpenDatabaseW;
begin
GetProcedureAddress(_MsiOpenDatabaseW, msilib, 'MsiOpenDatabaseW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiOpenDatabaseW]
end;
end;
var
_MsiOpenDatabase: Pointer;
function MsiOpenDatabase;
begin
GetProcedureAddress(_MsiOpenDatabase, msilib, 'MsiOpenDatabase' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiOpenDatabase]
end;
end;
var
_MsiDatabaseImportA: Pointer;
function MsiDatabaseImportA;
begin
GetProcedureAddress(_MsiDatabaseImportA, msilib, 'MsiDatabaseImportA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseImportA]
end;
end;
var
_MsiDatabaseImportW: Pointer;
function MsiDatabaseImportW;
begin
GetProcedureAddress(_MsiDatabaseImportW, msilib, 'MsiDatabaseImportW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseImportW]
end;
end;
var
_MsiDatabaseImport: Pointer;
function MsiDatabaseImport;
begin
GetProcedureAddress(_MsiDatabaseImport, msilib, 'MsiDatabaseImport' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseImport]
end;
end;
var
_MsiDatabaseExportA: Pointer;
function MsiDatabaseExportA;
begin
GetProcedureAddress(_MsiDatabaseExportA, msilib, 'MsiDatabaseExportA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseExportA]
end;
end;
var
_MsiDatabaseExportW: Pointer;
function MsiDatabaseExportW;
begin
GetProcedureAddress(_MsiDatabaseExportW, msilib, 'MsiDatabaseExportW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseExportW]
end;
end;
var
_MsiDatabaseExport: Pointer;
function MsiDatabaseExport;
begin
GetProcedureAddress(_MsiDatabaseExport, msilib, 'MsiDatabaseExport' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseExport]
end;
end;
var
_MsiDatabaseMergeA: Pointer;
function MsiDatabaseMergeA;
begin
GetProcedureAddress(_MsiDatabaseMergeA, msilib, 'MsiDatabaseMergeA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseMergeA]
end;
end;
var
_MsiDatabaseMergeW: Pointer;
function MsiDatabaseMergeW;
begin
GetProcedureAddress(_MsiDatabaseMergeW, msilib, 'MsiDatabaseMergeW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseMergeW]
end;
end;
var
_MsiDatabaseMerge: Pointer;
function MsiDatabaseMerge;
begin
GetProcedureAddress(_MsiDatabaseMerge, msilib, 'MsiDatabaseMerge' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseMerge]
end;
end;
var
_MsiDatabaseGenerateTransformA: Pointer;
function MsiDatabaseGenerateTransformA;
begin
GetProcedureAddress(_MsiDatabaseGenerateTransformA, msilib, 'MsiDatabaseGenerateTransformA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseGenerateTransformA]
end;
end;
var
_MsiDatabaseGenerateTransformW: Pointer;
function MsiDatabaseGenerateTransformW;
begin
GetProcedureAddress(_MsiDatabaseGenerateTransformW, msilib, 'MsiDatabaseGenerateTransformW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseGenerateTransformW]
end;
end;
var
_MsiDatabaseGenerateTransform: Pointer;
function MsiDatabaseGenerateTransform;
begin
GetProcedureAddress(_MsiDatabaseGenerateTransform, msilib, 'MsiDatabaseGenerateTransform' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseGenerateTransform]
end;
end;
var
_MsiDatabaseApplyTransformA: Pointer;
function MsiDatabaseApplyTransformA;
begin
GetProcedureAddress(_MsiDatabaseApplyTransformA, msilib, 'MsiDatabaseApplyTransformA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseApplyTransformA]
end;
end;
var
_MsiDatabaseApplyTransformW: Pointer;
function MsiDatabaseApplyTransformW;
begin
GetProcedureAddress(_MsiDatabaseApplyTransformW, msilib, 'MsiDatabaseApplyTransformW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseApplyTransformW]
end;
end;
var
_MsiDatabaseApplyTransform: Pointer;
function MsiDatabaseApplyTransform;
begin
GetProcedureAddress(_MsiDatabaseApplyTransform, msilib, 'MsiDatabaseApplyTransform' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseApplyTransform]
end;
end;
var
_MsiCreateTransformSummaryInfoA: Pointer;
function MsiCreateTransformSummaryInfoA;
begin
GetProcedureAddress(_MsiCreateTransformSummaryInfoA, msilib, 'MsiCreateTransformSummaryInfoA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiCreateTransformSummaryInfoA]
end;
end;
var
_MsiCreateTransformSummaryInfoW: Pointer;
function MsiCreateTransformSummaryInfoW;
begin
GetProcedureAddress(_MsiCreateTransformSummaryInfoW, msilib, 'MsiCreateTransformSummaryInfoW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiCreateTransformSummaryInfoW]
end;
end;
var
_MsiCreateTransformSummaryInfo: Pointer;
function MsiCreateTransformSummaryInfo;
begin
GetProcedureAddress(_MsiCreateTransformSummaryInfo, msilib, 'MsiCreateTransformSummaryInfo' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiCreateTransformSummaryInfo]
end;
end;
var
_MsiDatabaseCommit: Pointer;
function MsiDatabaseCommit;
begin
GetProcedureAddress(_MsiDatabaseCommit, msilib, 'MsiDatabaseCommit');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDatabaseCommit]
end;
end;
var
_MsiGetDatabaseState: Pointer;
function MsiGetDatabaseState;
begin
GetProcedureAddress(_MsiGetDatabaseState, msilib, 'MsiGetDatabaseState');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetDatabaseState]
end;
end;
var
_MsiCreateRecord: Pointer;
function MsiCreateRecord;
begin
GetProcedureAddress(_MsiCreateRecord, msilib, 'MsiCreateRecord');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiCreateRecord]
end;
end;
var
_MsiRecordIsNull: Pointer;
function MsiRecordIsNull;
begin
GetProcedureAddress(_MsiRecordIsNull, msilib, 'MsiRecordIsNull');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordIsNull]
end;
end;
var
_MsiRecordDataSize: Pointer;
function MsiRecordDataSize;
begin
GetProcedureAddress(_MsiRecordDataSize, msilib, 'MsiRecordDataSize');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordDataSize]
end;
end;
var
_MsiRecordSetInteger: Pointer;
function MsiRecordSetInteger;
begin
GetProcedureAddress(_MsiRecordSetInteger, msilib, 'MsiRecordSetInteger');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordSetInteger]
end;
end;
var
_MsiRecordSetStringA: Pointer;
function MsiRecordSetStringA;
begin
GetProcedureAddress(_MsiRecordSetStringA, msilib, 'MsiRecordSetStringA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordSetStringA]
end;
end;
var
_MsiRecordSetStringW: Pointer;
function MsiRecordSetStringW;
begin
GetProcedureAddress(_MsiRecordSetStringW, msilib, 'MsiRecordSetStringW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordSetStringW]
end;
end;
var
_MsiRecordSetString: Pointer;
function MsiRecordSetString;
begin
GetProcedureAddress(_MsiRecordSetString, msilib, 'MsiRecordSetString' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordSetString]
end;
end;
var
_MsiRecordGetInteger: Pointer;
function MsiRecordGetInteger;
begin
GetProcedureAddress(_MsiRecordGetInteger, msilib, 'MsiRecordGetInteger');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordGetInteger]
end;
end;
var
_MsiRecordGetStringA: Pointer;
function MsiRecordGetStringA;
begin
GetProcedureAddress(_MsiRecordGetStringA, msilib, 'MsiRecordGetStringA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordGetStringA]
end;
end;
var
_MsiRecordGetStringW: Pointer;
function MsiRecordGetStringW;
begin
GetProcedureAddress(_MsiRecordGetStringW, msilib, 'MsiRecordGetStringW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordGetStringW]
end;
end;
var
_MsiRecordGetString: Pointer;
function MsiRecordGetString;
begin
GetProcedureAddress(_MsiRecordGetString, msilib, 'MsiRecordGetString' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordGetString]
end;
end;
var
_MsiRecordGetFieldCount: Pointer;
function MsiRecordGetFieldCount;
begin
GetProcedureAddress(_MsiRecordGetFieldCount, msilib, 'MsiRecordGetFieldCount');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordGetFieldCount]
end;
end;
var
_MsiRecordSetStreamA: Pointer;
function MsiRecordSetStreamA;
begin
GetProcedureAddress(_MsiRecordSetStreamA, msilib, 'MsiRecordSetStreamA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordSetStreamA]
end;
end;
var
_MsiRecordSetStreamW: Pointer;
function MsiRecordSetStreamW;
begin
GetProcedureAddress(_MsiRecordSetStreamW, msilib, 'MsiRecordSetStreamW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordSetStreamW]
end;
end;
var
_MsiRecordSetStream: Pointer;
function MsiRecordSetStream;
begin
GetProcedureAddress(_MsiRecordSetStream, msilib, 'MsiRecordSetStream' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordSetStream]
end;
end;
var
_MsiRecordReadStream: Pointer;
function MsiRecordReadStream;
begin
GetProcedureAddress(_MsiRecordReadStream, msilib, 'MsiRecordReadStream');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordReadStream]
end;
end;
var
_MsiRecordClearData: Pointer;
function MsiRecordClearData;
begin
GetProcedureAddress(_MsiRecordClearData, msilib, 'MsiRecordClearData');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiRecordClearData]
end;
end;
var
_MsiGetActiveDatabase: Pointer;
function MsiGetActiveDatabase;
begin
GetProcedureAddress(_MsiGetActiveDatabase, msilib, 'MsiGetActiveDatabase');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetActiveDatabase]
end;
end;
var
_MsiSetPropertyA: Pointer;
function MsiSetPropertyA;
begin
GetProcedureAddress(_MsiSetPropertyA, msilib, 'MsiSetPropertyA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetPropertyA]
end;
end;
var
_MsiSetPropertyW: Pointer;
function MsiSetPropertyW;
begin
GetProcedureAddress(_MsiSetPropertyW, msilib, 'MsiSetPropertyW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetPropertyW]
end;
end;
var
_MsiSetProperty: Pointer;
function MsiSetProperty;
begin
GetProcedureAddress(_MsiSetProperty, msilib, 'MsiSetProperty' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetProperty]
end;
end;
var
_MsiGetPropertyA: Pointer;
function MsiGetPropertyA;
begin
GetProcedureAddress(_MsiGetPropertyA, msilib, 'MsiGetPropertyA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetPropertyA]
end;
end;
var
_MsiGetPropertyW: Pointer;
function MsiGetPropertyW;
begin
GetProcedureAddress(_MsiGetPropertyW, msilib, 'MsiGetPropertyW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetPropertyW]
end;
end;
var
_MsiGetProperty: Pointer;
function MsiGetProperty;
begin
GetProcedureAddress(_MsiGetProperty, msilib, 'MsiGetProperty' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetProperty]
end;
end;
var
_MsiGetLanguage: Pointer;
function MsiGetLanguage;
begin
GetProcedureAddress(_MsiGetLanguage, msilib, 'MsiGetLanguage');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetLanguage]
end;
end;
var
_MsiGetMode: Pointer;
function MsiGetMode;
begin
GetProcedureAddress(_MsiGetMode, msilib, 'MsiGetMode');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetMode]
end;
end;
var
_MsiSetMode: Pointer;
function MsiSetMode;
begin
GetProcedureAddress(_MsiSetMode, msilib, 'MsiSetMode');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetMode]
end;
end;
var
_MsiFormatRecordA: Pointer;
function MsiFormatRecordA;
begin
GetProcedureAddress(_MsiFormatRecordA, msilib, 'MsiFormatRecordA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiFormatRecordA]
end;
end;
var
_MsiFormatRecordW: Pointer;
function MsiFormatRecordW;
begin
GetProcedureAddress(_MsiFormatRecordW, msilib, 'MsiFormatRecordW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiFormatRecordW]
end;
end;
var
_MsiFormatRecord: Pointer;
function MsiFormatRecord;
begin
GetProcedureAddress(_MsiFormatRecord, msilib, 'MsiFormatRecord' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiFormatRecord]
end;
end;
var
_MsiDoActionA: Pointer;
function MsiDoActionA;
begin
GetProcedureAddress(_MsiDoActionA, msilib, 'MsiDoActionA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDoActionA]
end;
end;
var
_MsiDoActionW: Pointer;
function MsiDoActionW;
begin
GetProcedureAddress(_MsiDoActionW, msilib, 'MsiDoActionW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDoActionW]
end;
end;
var
_MsiDoAction: Pointer;
function MsiDoAction;
begin
GetProcedureAddress(_MsiDoAction, msilib, 'MsiDoAction' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiDoAction]
end;
end;
var
_MsiSequenceA: Pointer;
function MsiSequenceA;
begin
GetProcedureAddress(_MsiSequenceA, msilib, 'MsiSequenceA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSequenceA]
end;
end;
var
_MsiSequenceW: Pointer;
function MsiSequenceW;
begin
GetProcedureAddress(_MsiSequenceW, msilib, 'MsiSequenceW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSequenceW]
end;
end;
var
_MsiSequence: Pointer;
function MsiSequence;
begin
GetProcedureAddress(_MsiSequence, msilib, 'MsiSequence' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSequence]
end;
end;
var
_MsiProcessMessage: Pointer;
function MsiProcessMessage;
begin
GetProcedureAddress(_MsiProcessMessage, msilib, 'MsiProcessMessage');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiProcessMessage]
end;
end;
var
_MsiEvaluateConditionA: Pointer;
function MsiEvaluateConditionA;
begin
GetProcedureAddress(_MsiEvaluateConditionA, msilib, 'MsiEvaluateConditionA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiEvaluateConditionA]
end;
end;
var
_MsiEvaluateConditionW: Pointer;
function MsiEvaluateConditionW;
begin
GetProcedureAddress(_MsiEvaluateConditionW, msilib, 'MsiEvaluateConditionW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiEvaluateConditionW]
end;
end;
var
_MsiEvaluateCondition: Pointer;
function MsiEvaluateCondition;
begin
GetProcedureAddress(_MsiEvaluateCondition, msilib, 'MsiEvaluateCondition' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiEvaluateCondition]
end;
end;
var
_MsiGetFeatureStateA: Pointer;
function MsiGetFeatureStateA;
begin
GetProcedureAddress(_MsiGetFeatureStateA, msilib, 'MsiGetFeatureStateA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureStateA]
end;
end;
var
_MsiGetFeatureStateW: Pointer;
function MsiGetFeatureStateW;
begin
GetProcedureAddress(_MsiGetFeatureStateW, msilib, 'MsiGetFeatureStateW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureStateW]
end;
end;
var
_MsiGetFeatureState: Pointer;
function MsiGetFeatureState;
begin
GetProcedureAddress(_MsiGetFeatureState, msilib, 'MsiGetFeatureState' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureState]
end;
end;
var
_MsiSetFeatureStateA: Pointer;
function MsiSetFeatureStateA;
begin
GetProcedureAddress(_MsiSetFeatureStateA, msilib, 'MsiSetFeatureStateA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetFeatureStateA]
end;
end;
var
_MsiSetFeatureStateW: Pointer;
function MsiSetFeatureStateW;
begin
GetProcedureAddress(_MsiSetFeatureStateW, msilib, 'MsiSetFeatureStateW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetFeatureStateW]
end;
end;
var
_MsiSetFeatureState: Pointer;
function MsiSetFeatureState;
begin
GetProcedureAddress(_MsiSetFeatureState, msilib, 'MsiSetFeatureState' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetFeatureState]
end;
end;
var
_MsiSetFeatureAttributesA: Pointer;
function MsiSetFeatureAttributesA;
begin
GetProcedureAddress(_MsiSetFeatureAttributesA, msilib, 'MsiSetFeatureAttributesA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetFeatureAttributesA]
end;
end;
var
_MsiSetFeatureAttributesW: Pointer;
function MsiSetFeatureAttributesW;
begin
GetProcedureAddress(_MsiSetFeatureAttributesW, msilib, 'MsiSetFeatureAttributesW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetFeatureAttributesW]
end;
end;
var
_MsiSetFeatureAttributes: Pointer;
function MsiSetFeatureAttributes;
begin
GetProcedureAddress(_MsiSetFeatureAttributes, msilib, 'MsiSetFeatureAttributes' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetFeatureAttributes]
end;
end;
var
_MsiGetComponentStateA: Pointer;
function MsiGetComponentStateA;
begin
GetProcedureAddress(_MsiGetComponentStateA, msilib, 'MsiGetComponentStateA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetComponentStateA]
end;
end;
var
_MsiGetComponentStateW: Pointer;
function MsiGetComponentStateW;
begin
GetProcedureAddress(_MsiGetComponentStateW, msilib, 'MsiGetComponentStateW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetComponentStateW]
end;
end;
var
_MsiGetComponentState: Pointer;
function MsiGetComponentState;
begin
GetProcedureAddress(_MsiGetComponentState, msilib, 'MsiGetComponentState' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetComponentState]
end;
end;
var
_MsiSetComponentStateA: Pointer;
function MsiSetComponentStateA;
begin
GetProcedureAddress(_MsiSetComponentStateA, msilib, 'MsiSetComponentStateA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetComponentStateA]
end;
end;
var
_MsiSetComponentStateW: Pointer;
function MsiSetComponentStateW;
begin
GetProcedureAddress(_MsiSetComponentStateW, msilib, 'MsiSetComponentStateW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetComponentStateW]
end;
end;
var
_MsiSetComponentState: Pointer;
function MsiSetComponentState;
begin
GetProcedureAddress(_MsiSetComponentState, msilib, 'MsiSetComponentState' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetComponentState]
end;
end;
var
_MsiGetFeatureCostA: Pointer;
function MsiGetFeatureCostA;
begin
GetProcedureAddress(_MsiGetFeatureCostA, msilib, 'MsiGetFeatureCostA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureCostA]
end;
end;
var
_MsiGetFeatureCostW: Pointer;
function MsiGetFeatureCostW;
begin
GetProcedureAddress(_MsiGetFeatureCostW, msilib, 'MsiGetFeatureCostW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureCostW]
end;
end;
var
_MsiGetFeatureCost: Pointer;
function MsiGetFeatureCost;
begin
GetProcedureAddress(_MsiGetFeatureCost, msilib, 'MsiGetFeatureCost' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureCost]
end;
end;
var
_MsiEnumComponentCostsA: Pointer;
function MsiEnumComponentCostsA;
begin
GetProcedureAddress(_MsiEnumComponentCostsA, msilib, 'MsiEnumComponentCostsA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiEnumComponentCostsA]
end;
end;
var
_MsiEnumComponentCostsW: Pointer;
function MsiEnumComponentCostsW;
begin
GetProcedureAddress(_MsiEnumComponentCostsW, msilib, 'MsiEnumComponentCostsW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiEnumComponentCostsW]
end;
end;
var
_MsiEnumComponentCosts: Pointer;
function MsiEnumComponentCosts;
begin
GetProcedureAddress(_MsiEnumComponentCosts, msilib, 'MsiEnumComponentCosts' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiEnumComponentCosts]
end;
end;
var
_MsiSetInstallLevel: Pointer;
function MsiSetInstallLevel;
begin
GetProcedureAddress(_MsiSetInstallLevel, msilib, 'MsiSetInstallLevel');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetInstallLevel]
end;
end;
var
_MsiGetFeatureValidStatesA: Pointer;
function MsiGetFeatureValidStatesA;
begin
GetProcedureAddress(_MsiGetFeatureValidStatesA, msilib, 'MsiGetFeatureValidStatesA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureValidStatesA]
end;
end;
var
_MsiGetFeatureValidStatesW: Pointer;
function MsiGetFeatureValidStatesW;
begin
GetProcedureAddress(_MsiGetFeatureValidStatesW, msilib, 'MsiGetFeatureValidStatesW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureValidStatesW]
end;
end;
var
_MsiGetFeatureValidStates: Pointer;
function MsiGetFeatureValidStates;
begin
GetProcedureAddress(_MsiGetFeatureValidStates, msilib, 'MsiGetFeatureValidStates' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetFeatureValidStates]
end;
end;
var
_MsiGetSourcePathA: Pointer;
function MsiGetSourcePathA;
begin
GetProcedureAddress(_MsiGetSourcePathA, msilib, 'MsiGetSourcePathA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetSourcePathA]
end;
end;
var
_MsiGetSourcePathW: Pointer;
function MsiGetSourcePathW;
begin
GetProcedureAddress(_MsiGetSourcePathW, msilib, 'MsiGetSourcePathW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetSourcePathW]
end;
end;
var
_MsiGetSourcePath: Pointer;
function MsiGetSourcePath;
begin
GetProcedureAddress(_MsiGetSourcePath, msilib, 'MsiGetSourcePath' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetSourcePath]
end;
end;
var
_MsiGetTargetPathA: Pointer;
function MsiGetTargetPathA;
begin
GetProcedureAddress(_MsiGetTargetPathA, msilib, 'MsiGetTargetPathA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetTargetPathA]
end;
end;
var
_MsiGetTargetPathW: Pointer;
function MsiGetTargetPathW;
begin
GetProcedureAddress(_MsiGetTargetPathW, msilib, 'MsiGetTargetPathW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetTargetPathW]
end;
end;
var
_MsiGetTargetPath: Pointer;
function MsiGetTargetPath;
begin
GetProcedureAddress(_MsiGetTargetPath, msilib, 'MsiGetTargetPath' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetTargetPath]
end;
end;
var
_MsiSetTargetPathA: Pointer;
function MsiSetTargetPathA;
begin
GetProcedureAddress(_MsiSetTargetPathA, msilib, 'MsiSetTargetPathA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetTargetPathA]
end;
end;
var
_MsiSetTargetPathW: Pointer;
function MsiSetTargetPathW;
begin
GetProcedureAddress(_MsiSetTargetPathW, msilib, 'MsiSetTargetPathW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetTargetPathW]
end;
end;
var
_MsiSetTargetPath: Pointer;
function MsiSetTargetPath;
begin
GetProcedureAddress(_MsiSetTargetPath, msilib, 'MsiSetTargetPath' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiSetTargetPath]
end;
end;
var
_MsiVerifyDiskSpace: Pointer;
function MsiVerifyDiskSpace;
begin
GetProcedureAddress(_MsiVerifyDiskSpace, msilib, 'MsiVerifyDiskSpace');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiVerifyDiskSpace]
end;
end;
var
_MsiEnableUIPreview: Pointer;
function MsiEnableUIPreview;
begin
GetProcedureAddress(_MsiEnableUIPreview, msilib, 'MsiEnableUIPreview');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiEnableUIPreview]
end;
end;
var
_MsiPreviewDialogA: Pointer;
function MsiPreviewDialogA;
begin
GetProcedureAddress(_MsiPreviewDialogA, msilib, 'MsiPreviewDialogA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiPreviewDialogA]
end;
end;
var
_MsiPreviewDialogW: Pointer;
function MsiPreviewDialogW;
begin
GetProcedureAddress(_MsiPreviewDialogW, msilib, 'MsiPreviewDialogW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiPreviewDialogW]
end;
end;
var
_MsiPreviewDialog: Pointer;
function MsiPreviewDialog;
begin
GetProcedureAddress(_MsiPreviewDialog, msilib, 'MsiPreviewDialog' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiPreviewDialog]
end;
end;
var
_MsiPreviewBillboardA: Pointer;
function MsiPreviewBillboardA;
begin
GetProcedureAddress(_MsiPreviewBillboardA, msilib, 'MsiPreviewBillboardA');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiPreviewBillboardA]
end;
end;
var
_MsiPreviewBillboardW: Pointer;
function MsiPreviewBillboardW;
begin
GetProcedureAddress(_MsiPreviewBillboardW, msilib, 'MsiPreviewBillboardW');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiPreviewBillboardW]
end;
end;
var
_MsiPreviewBillboard: Pointer;
function MsiPreviewBillboard;
begin
GetProcedureAddress(_MsiPreviewBillboard, msilib, 'MsiPreviewBillboard' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_MsiPreviewBillboard]
end;
end;
var
_MsiGetLastErrorRecord: Pointer;
function MsiGetLastErrorRecord;
begin
GetProcedureAddress(_MsiGetLastErrorRecord, msilib, 'MsiGetLastErrorRecord');
asm
MOV ESP, EBP
POP EBP
JMP [_MsiGetLastErrorRecord]
end;
end;
{$ELSE}
function MsiDatabaseOpenViewA; external msilib name 'MsiDatabaseOpenViewA';
function MsiDatabaseOpenViewW; external msilib name 'MsiDatabaseOpenViewW';
function MsiDatabaseOpenView; external msilib name 'MsiDatabaseOpenView' + AWSuffix;
function MsiViewGetErrorA; external msilib name 'MsiViewGetErrorA';
function MsiViewGetErrorW; external msilib name 'MsiViewGetErrorW';
function MsiViewGetError; external msilib name 'MsiViewGetError' + AWSuffix;
function MsiViewExecute; external msilib name 'MsiViewExecute';
function MsiViewFetch; external msilib name 'MsiViewFetch';
function MsiViewModify; external msilib name 'MsiViewModify';
function MsiViewGetColumnInfo; external msilib name 'MsiViewGetColumnInfo';
function MsiViewClose; external msilib name 'MsiViewClose';
function MsiDatabaseGetPrimaryKeysA; external msilib name 'MsiDatabaseGetPrimaryKeysA';
function MsiDatabaseGetPrimaryKeysW; external msilib name 'MsiDatabaseGetPrimaryKeysW';
function MsiDatabaseGetPrimaryKeys; external msilib name 'MsiDatabaseGetPrimaryKeys' + AWSuffix;
function MsiDatabaseIsTablePersistentA; external msilib name 'MsiDatabaseIsTablePersistentA';
function MsiDatabaseIsTablePersistentW; external msilib name 'MsiDatabaseIsTablePersistentW';
function MsiDatabaseIsTablePersistent; external msilib name 'MsiDatabaseIsTablePersistent' + AWSuffix;
function MsiGetSummaryInformationA; external msilib name 'MsiGetSummaryInformationA';
function MsiGetSummaryInformationW; external msilib name 'MsiGetSummaryInformationW';
function MsiGetSummaryInformation; external msilib name 'MsiGetSummaryInformation' + AWSuffix;
function MsiSummaryInfoGetPropertyCount; external msilib name 'MsiSummaryInfoGetPropertyCount';
function MsiSummaryInfoSetPropertyA; external msilib name 'MsiSummaryInfoSetPropertyA';
function MsiSummaryInfoSetPropertyW; external msilib name 'MsiSummaryInfoSetPropertyW';
function MsiSummaryInfoSetProperty; external msilib name 'MsiSummaryInfoSetProperty' + AWSuffix;
function MsiSummaryInfoGetPropertyA; external msilib name 'MsiSummaryInfoGetPropertyA';
function MsiSummaryInfoGetPropertyW; external msilib name 'MsiSummaryInfoGetPropertyW';
function MsiSummaryInfoGetProperty; external msilib name 'MsiSummaryInfoGetProperty' + AWSuffix;
function MsiSummaryInfoPersist; external msilib name 'MsiSummaryInfoPersist';
function MsiOpenDatabaseA; external msilib name 'MsiOpenDatabaseA';
function MsiOpenDatabaseW; external msilib name 'MsiOpenDatabaseW';
function MsiOpenDatabase; external msilib name 'MsiOpenDatabase' + AWSuffix;
function MsiDatabaseImportA; external msilib name 'MsiDatabaseImportA';
function MsiDatabaseImportW; external msilib name 'MsiDatabaseImportW';
function MsiDatabaseImport; external msilib name 'MsiDatabaseImport' + AWSuffix;
function MsiDatabaseExportA; external msilib name 'MsiDatabaseExportA';
function MsiDatabaseExportW; external msilib name 'MsiDatabaseExportW';
function MsiDatabaseExport; external msilib name 'MsiDatabaseExport' + AWSuffix;
function MsiDatabaseMergeA; external msilib name 'MsiDatabaseMergeA';
function MsiDatabaseMergeW; external msilib name 'MsiDatabaseMergeW';
function MsiDatabaseMerge; external msilib name 'MsiDatabaseMerge' + AWSuffix;
function MsiDatabaseGenerateTransformA; external msilib name 'MsiDatabaseGenerateTransformA';
function MsiDatabaseGenerateTransformW; external msilib name 'MsiDatabaseGenerateTransformW';
function MsiDatabaseGenerateTransform; external msilib name 'MsiDatabaseGenerateTransform' + AWSuffix;
function MsiDatabaseApplyTransformA; external msilib name 'MsiDatabaseApplyTransformA';
function MsiDatabaseApplyTransformW; external msilib name 'MsiDatabaseApplyTransformW';
function MsiDatabaseApplyTransform; external msilib name 'MsiDatabaseApplyTransform' + AWSuffix;
function MsiCreateTransformSummaryInfoA; external msilib name 'MsiCreateTransformSummaryInfoA';
function MsiCreateTransformSummaryInfoW; external msilib name 'MsiCreateTransformSummaryInfoW';
function MsiCreateTransformSummaryInfo; external msilib name 'MsiCreateTransformSummaryInfo' + AWSuffix;
function MsiDatabaseCommit; external msilib name 'MsiDatabaseCommit';
function MsiGetDatabaseState; external msilib name 'MsiGetDatabaseState';
function MsiCreateRecord; external msilib name 'MsiCreateRecord';
function MsiRecordIsNull; external msilib name 'MsiRecordIsNull';
function MsiRecordDataSize; external msilib name 'MsiRecordDataSize';
function MsiRecordSetInteger; external msilib name 'MsiRecordSetInteger';
function MsiRecordSetStringA; external msilib name 'MsiRecordSetStringA';
function MsiRecordSetStringW; external msilib name 'MsiRecordSetStringW';
function MsiRecordSetString; external msilib name 'MsiRecordSetString' + AWSuffix;
function MsiRecordGetInteger; external msilib name 'MsiRecordGetInteger';
function MsiRecordGetStringA; external msilib name 'MsiRecordGetStringA';
function MsiRecordGetStringW; external msilib name 'MsiRecordGetStringW';
function MsiRecordGetString; external msilib name 'MsiRecordGetString' + AWSuffix;
function MsiRecordGetFieldCount; external msilib name 'MsiRecordGetFieldCount';
function MsiRecordSetStreamA; external msilib name 'MsiRecordSetStreamA';
function MsiRecordSetStreamW; external msilib name 'MsiRecordSetStreamW';
function MsiRecordSetStream; external msilib name 'MsiRecordSetStream' + AWSuffix;
function MsiRecordReadStream; external msilib name 'MsiRecordReadStream';
function MsiRecordClearData; external msilib name 'MsiRecordClearData';
function MsiGetActiveDatabase; external msilib name 'MsiGetActiveDatabase';
function MsiSetPropertyA; external msilib name 'MsiSetPropertyA';
function MsiSetPropertyW; external msilib name 'MsiSetPropertyW';
function MsiSetProperty; external msilib name 'MsiSetProperty' + AWSuffix;
function MsiGetPropertyA; external msilib name 'MsiGetPropertyA';
function MsiGetPropertyW; external msilib name 'MsiGetPropertyW';
function MsiGetProperty; external msilib name 'MsiGetProperty' + AWSuffix;
function MsiGetLanguage; external msilib name 'MsiGetLanguage';
function MsiGetMode; external msilib name 'MsiGetMode';
function MsiSetMode; external msilib name 'MsiSetMode';
function MsiFormatRecordA; external msilib name 'MsiFormatRecordA';
function MsiFormatRecordW; external msilib name 'MsiFormatRecordW';
function MsiFormatRecord; external msilib name 'MsiFormatRecord' + AWSuffix;
function MsiDoActionA; external msilib name 'MsiDoActionA';
function MsiDoActionW; external msilib name 'MsiDoActionW';
function MsiDoAction; external msilib name 'MsiDoAction' + AWSuffix;
function MsiSequenceA; external msilib name 'MsiSequenceA';
function MsiSequenceW; external msilib name 'MsiSequenceW';
function MsiSequence; external msilib name 'MsiSequence' + AWSuffix;
function MsiProcessMessage; external msilib name 'MsiProcessMessage';
function MsiEvaluateConditionA; external msilib name 'MsiEvaluateConditionA';
function MsiEvaluateConditionW; external msilib name 'MsiEvaluateConditionW';
function MsiEvaluateCondition; external msilib name 'MsiEvaluateCondition' + AWSuffix;
function MsiGetFeatureStateA; external msilib name 'MsiGetFeatureStateA';
function MsiGetFeatureStateW; external msilib name 'MsiGetFeatureStateW';
function MsiGetFeatureState; external msilib name 'MsiGetFeatureState' + AWSuffix;
function MsiSetFeatureStateA; external msilib name 'MsiSetFeatureStateA';
function MsiSetFeatureStateW; external msilib name 'MsiSetFeatureStateW';
function MsiSetFeatureState; external msilib name 'MsiSetFeatureState' + AWSuffix;
function MsiSetFeatureAttributesA; external msilib name 'MsiSetFeatureAttributesA';
function MsiSetFeatureAttributesW; external msilib name 'MsiSetFeatureAttributesW';
function MsiSetFeatureAttributes; external msilib name 'MsiSetFeatureAttributes' + AWSuffix;
function MsiGetComponentStateA; external msilib name 'MsiGetComponentStateA';
function MsiGetComponentStateW; external msilib name 'MsiGetComponentStateW';
function MsiGetComponentState; external msilib name 'MsiGetComponentState' + AWSuffix;
function MsiSetComponentStateA; external msilib name 'MsiSetComponentStateA';
function MsiSetComponentStateW; external msilib name 'MsiSetComponentStateW';
function MsiSetComponentState; external msilib name 'MsiSetComponentState' + AWSuffix;
function MsiGetFeatureCostA; external msilib name 'MsiGetFeatureCostA';
function MsiGetFeatureCostW; external msilib name 'MsiGetFeatureCostW';
function MsiGetFeatureCost; external msilib name 'MsiGetFeatureCost' + AWSuffix;
function MsiEnumComponentCostsA; external msilib name 'MsiEnumComponentCostsA';
function MsiEnumComponentCostsW; external msilib name 'MsiEnumComponentCostsW';
function MsiEnumComponentCosts; external msilib name 'MsiEnumComponentCosts' + AWSuffix;
function MsiSetInstallLevel; external msilib name 'MsiSetInstallLevel';
function MsiGetFeatureValidStatesA; external msilib name 'MsiGetFeatureValidStatesA';
function MsiGetFeatureValidStatesW; external msilib name 'MsiGetFeatureValidStatesW';
function MsiGetFeatureValidStates; external msilib name 'MsiGetFeatureValidStates' + AWSuffix;
function MsiGetSourcePathA; external msilib name 'MsiGetSourcePathA';
function MsiGetSourcePathW; external msilib name 'MsiGetSourcePathW';
function MsiGetSourcePath; external msilib name 'MsiGetSourcePath' + AWSuffix;
function MsiGetTargetPathA; external msilib name 'MsiGetTargetPathA';
function MsiGetTargetPathW; external msilib name 'MsiGetTargetPathW';
function MsiGetTargetPath; external msilib name 'MsiGetTargetPath' + AWSuffix;
function MsiSetTargetPathA; external msilib name 'MsiSetTargetPathA';
function MsiSetTargetPathW; external msilib name 'MsiSetTargetPathW';
function MsiSetTargetPath; external msilib name 'MsiSetTargetPath' + AWSuffix;
function MsiVerifyDiskSpace; external msilib name 'MsiVerifyDiskSpace';
function MsiEnableUIPreview; external msilib name 'MsiEnableUIPreview';
function MsiPreviewDialogA; external msilib name 'MsiPreviewDialogA';
function MsiPreviewDialogW; external msilib name 'MsiPreviewDialogW';
function MsiPreviewDialog; external msilib name 'MsiPreviewDialog' + AWSuffix;
function MsiPreviewBillboardA; external msilib name 'MsiPreviewBillboardA';
function MsiPreviewBillboardW; external msilib name 'MsiPreviewBillboardW';
function MsiPreviewBillboard; external msilib name 'MsiPreviewBillboard' + AWSuffix;
function MsiGetLastErrorRecord; external msilib name 'MsiGetLastErrorRecord';
{$ENDIF DYNAMIC_LINK}
{$ENDIF JWA_INTERFACESECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
end.
{$ENDIF JWA_OMIT_SECTIONS}