1
{******************************************************************************}
3
{ Windows Installer API interface Unit for Object Pascal }
5
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
6
{ Corporation. All Rights Reserved. }
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 att chello dott nl). }
12
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
13
{ Marcel van Brakel. All Rights Reserved. }
15
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
17
{ You may retrieve the latest version of this file at the Project JEDI }
18
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
20
{ The contents of this file are used with permission, subject to the Mozilla }
21
{ Public License Version 1.1 (the "License"); you may not use this file except }
22
{ in compliance with the License. You may obtain a copy of the License at }
23
{ http://www.mozilla.org/MPL/MPL-1.1.html }
25
{ Software distributed under the License is distributed on an "AS IS" basis, }
26
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27
{ the specific language governing rights and limitations under the License. }
29
{ Alternatively, the contents of this file may be used under the terms of the }
30
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
31
{ provisions of the LGPL License are applicable instead of those above. }
32
{ If you wish to allow use of your version of this file only under the terms }
33
{ of the LGPL License and not to allow others to use your version of this file }
34
{ under the MPL, indicate your decision by deleting the provisions above and }
35
{ replace them with the notice and other provisions required by the LGPL }
36
{ License. If you do not delete the provisions above, a recipient may use }
37
{ your version of this file under either the MPL or the LGPL License. }
39
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
41
{******************************************************************************}
43
// $Id: JwaMsiQuery.pas,v 1.9 2005/09/06 16:36:50 marquardt Exp $
50
{$HPPEMIT '#include "msiquery.h"'}
60
(*****************************************************************************\
62
* MsiQuery.h - Interface to running installer for custom actions and tools *
66
* NOTES: All buffers sizes are TCHAR count, null included only on input *
67
* Return argument pointers may be null if not interested in value *
68
* Returned handles of all types must be closed: MsiCloseHandle(h) *
69
* Functions with UINT return type return a system error code *
70
* Designated functions will set or clear the last error record, *
71
* which is then accessible with MsiGetLastErrorRecord. However, *
72
* the following argument errors do not register an error record: *
73
* ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, ERROR_MORE_DATA. *
75
* Copyright (c) 1999-2000, Microsoft Corp. All rights reserved. *
77
\*****************************************************************************)
80
MSI_NULL_INTEGER = DWORD($80000000); // integer value reserved for null
81
{$EXTERNALSYM MSI_NULL_INTEGER}
83
// MsiOpenDatabase persist predefine values, otherwise output database path is used
85
MSIDBOPEN_READONLY = LPCTSTR(0); // database open read-only, no persistent changes
86
{$EXTERNALSYM MSIDBOPEN_READONLY}
87
MSIDBOPEN_TRANSACT = LPCTSTR(1); // database read/write in transaction mode
88
{$EXTERNALSYM MSIDBOPEN_TRANSACT}
89
MSIDBOPEN_DIRECT = LPCTSTR(2); // database direct read/write without transaction
90
{$EXTERNALSYM MSIDBOPEN_DIRECT}
91
MSIDBOPEN_CREATE = LPCTSTR(3); // create new database, transact mode read/write
92
{$EXTERNALSYM MSIDBOPEN_CREATE}
93
MSIDBOPEN_CREATEDIRECT = LPCTSTR(4); // create new database, direct mode read/write
94
{$EXTERNALSYM MSIDBOPEN_CREATEDIRECT}
96
MSIDBOPEN_PATCHFILE = 32 div SizeOf(TCHAR); // add flag to indicate patch file
98
MSIDBSTATE_ERROR = DWORD(-1); // invalid database handle
99
{$EXTERNALSYM MSIDBSTATE_ERROR}
100
MSIDBSTATE_READ = 0; // database open read-only, no persistent changes
101
{$EXTERNALSYM MSIDBSTATE_READ}
102
MSIDBSTATE_WRITE = 1; // database readable and updatable
103
{$EXTERNALSYM MSIDBSTATE_WRITE}
107
{$EXTERNALSYM MSIDBSTATE}
108
TMsiDbState = MSIDBSTATE;
111
MSIMODIFY_SEEK = DWORD(-1); // reposition to current record primary key
112
{$EXTERNALSYM MSIMODIFY_SEEK}
113
MSIMODIFY_REFRESH = 0; // refetch current record data
114
{$EXTERNALSYM MSIMODIFY_REFRESH}
115
MSIMODIFY_INSERT = 1; // insert new record, fails if matching key exists
116
{$EXTERNALSYM MSIMODIFY_INSERT}
117
MSIMODIFY_UPDATE = 2; // update existing non-key data of fetched record
118
{$EXTERNALSYM MSIMODIFY_UPDATE}
119
MSIMODIFY_ASSIGN = 3; // insert record, replacing any existing record
120
{$EXTERNALSYM MSIMODIFY_ASSIGN}
121
MSIMODIFY_REPLACE = 4; // update record, delete old if primary key edit
122
{$EXTERNALSYM MSIMODIFY_REPLACE}
123
MSIMODIFY_MERGE = 5; // fails if record with duplicate key not identical
124
{$EXTERNALSYM MSIMODIFY_MERGE}
125
MSIMODIFY_DELETE = 6; // remove row referenced by this record from table
126
{$EXTERNALSYM MSIMODIFY_DELETE}
127
MSIMODIFY_INSERT_TEMPORARY = 7; // insert a temporary record
128
{$EXTERNALSYM MSIMODIFY_INSERT_TEMPORARY}
129
MSIMODIFY_VALIDATE = 8; // validate a fetched record
130
{$EXTERNALSYM MSIMODIFY_VALIDATE}
131
MSIMODIFY_VALIDATE_NEW = 9; // validate a new record
132
{$EXTERNALSYM MSIMODIFY_VALIDATE_NEW}
133
MSIMODIFY_VALIDATE_FIELD = 10; // validate field(s) of an incomplete record
134
{$EXTERNALSYM MSIMODIFY_VALIDATE_FIELD}
135
MSIMODIFY_VALIDATE_DELETE = 11; // validate before deleting record
136
{$EXTERNALSYM MSIMODIFY_VALIDATE_DELETE}
140
{$EXTERNALSYM MSIMODIFY}
141
TMsiModify = MSIMODIFY;
144
MSICOLINFO_NAMES = 0; // return column names
145
{$EXTERNALSYM MSICOLINFO_NAMES}
146
MSICOLINFO_TYPES = 1; // return column definitions, datatype code followed by width
147
{$EXTERNALSYM MSICOLINFO_TYPES}
151
{$EXTERNALSYM MSICOLINFO}
152
TMsiColInfo = MSICOLINFO;
155
MSICONDITION_FALSE = 0; // expression evaluates to False
156
{$EXTERNALSYM MSICONDITION_FALSE}
157
MSICONDITION_TRUE = 1; // expression evaluates to True
158
{$EXTERNALSYM MSICONDITION_TRUE}
159
MSICONDITION_NONE = 2; // no expression present
160
{$EXTERNALSYM MSICONDITION_NONE}
161
MSICONDITION_ERROR = 3; // syntax error in expression
162
{$EXTERNALSYM MSICONDITION_ERROR}
165
MSICONDITION = DWORD;
166
{$EXTERNALSYM MSICONDITION}
167
TMsiCondition = MSICONDITION;
170
MSICOSTTREE_SELFONLY = 0;
171
{$EXTERNALSYM MSICOSTTREE_SELFONLY}
172
MSICOSTTREE_CHILDREN = 1;
173
{$EXTERNALSYM MSICOSTTREE_CHILDREN}
174
MSICOSTTREE_PARENTS = 2;
175
{$EXTERNALSYM MSICOSTTREE_PARENTS}
176
MSICOSTTREE_RESERVED = 3; // Reserved for future use
177
{$EXTERNALSYM MSICOSTTREE_RESERVED}
181
{$EXTERNALSYM MSICOSTTREE}
182
TMsiCostTree = MSICOSTTREE;
185
MSIDBERROR_INVALIDARG = DWORD(-3); // invalid argument
186
{$EXTERNALSYM MSIDBERROR_INVALIDARG}
187
MSIDBERROR_MOREDATA = DWORD(-2); // buffer too small
188
{$EXTERNALSYM MSIDBERROR_MOREDATA}
189
MSIDBERROR_FUNCTIONERROR = DWORD(-1); // function error
190
{$EXTERNALSYM MSIDBERROR_FUNCTIONERROR}
191
MSIDBERROR_NOERROR = 0; // no error
192
{$EXTERNALSYM MSIDBERROR_NOERROR}
193
MSIDBERROR_DUPLICATEKEY = 1; // new record duplicates primary keys of existing record in table
194
{$EXTERNALSYM MSIDBERROR_DUPLICATEKEY}
195
MSIDBERROR_REQUIRED = 2; // non-nullable column, no null values allowed
196
{$EXTERNALSYM MSIDBERROR_REQUIRED}
197
MSIDBERROR_BADLINK = 3; // corresponding record in foreign table not found
198
{$EXTERNALSYM MSIDBERROR_BADLINK}
199
MSIDBERROR_OVERFLOW = 4; // data greater than maximum value allowed
200
{$EXTERNALSYM MSIDBERROR_OVERFLOW}
201
MSIDBERROR_UNDERFLOW = 5; // data less than minimum value allowed
202
{$EXTERNALSYM MSIDBERROR_UNDERFLOW}
203
MSIDBERROR_NOTINSET = 6; // data not a member of the values permitted in the set
204
{$EXTERNALSYM MSIDBERROR_NOTINSET}
205
MSIDBERROR_BADVERSION = 7; // invalid version string
206
{$EXTERNALSYM MSIDBERROR_BADVERSION}
207
MSIDBERROR_BADCASE = 8; // invalid case, must be all upper-case or all lower-case
208
{$EXTERNALSYM MSIDBERROR_BADCASE}
209
MSIDBERROR_BADGUID = 9; // invalid GUID
210
{$EXTERNALSYM MSIDBERROR_BADGUID}
211
MSIDBERROR_BADWILDCARD = 10; // invalid wildcardfilename or use of wildcards
212
{$EXTERNALSYM MSIDBERROR_BADWILDCARD}
213
MSIDBERROR_BADIDENTIFIER = 11; // bad identifier
214
{$EXTERNALSYM MSIDBERROR_BADIDENTIFIER}
215
MSIDBERROR_BADLANGUAGE = 12; // bad language Id(s)
216
{$EXTERNALSYM MSIDBERROR_BADLANGUAGE}
217
MSIDBERROR_BADFILENAME = 13; // bad filename
218
{$EXTERNALSYM MSIDBERROR_BADFILENAME}
219
MSIDBERROR_BADPATH = 14; // bad path
220
{$EXTERNALSYM MSIDBERROR_BADPATH}
221
MSIDBERROR_BADCONDITION = 15; // bad conditional statement
222
{$EXTERNALSYM MSIDBERROR_BADCONDITION}
223
MSIDBERROR_BADFORMATTED = 16; // bad format string
224
{$EXTERNALSYM MSIDBERROR_BADFORMATTED}
225
MSIDBERROR_BADTEMPLATE = 17; // bad template string
226
{$EXTERNALSYM MSIDBERROR_BADTEMPLATE}
227
MSIDBERROR_BADDEFAULTDIR = 18; // bad string in DefaultDir column of Directory table
228
{$EXTERNALSYM MSIDBERROR_BADDEFAULTDIR}
229
MSIDBERROR_BADREGPATH = 19; // bad registry path string
230
{$EXTERNALSYM MSIDBERROR_BADREGPATH}
231
MSIDBERROR_BADCUSTOMSOURCE = 20; // bad string in CustomSource column of CustomAction table
232
{$EXTERNALSYM MSIDBERROR_BADCUSTOMSOURCE}
233
MSIDBERROR_BADPROPERTY = 21; // bad property string
234
{$EXTERNALSYM MSIDBERROR_BADPROPERTY}
235
MSIDBERROR_MISSINGDATA = 22; // _Validation table missing reference to column
236
{$EXTERNALSYM MSIDBERROR_MISSINGDATA}
237
MSIDBERROR_BADCATEGORY = 23; // Category column of _Validation table for column is invalid
238
{$EXTERNALSYM MSIDBERROR_BADCATEGORY}
239
MSIDBERROR_BADKEYTABLE = 24; // table in KeyTable column of _Validation table could not be found/loaded
240
{$EXTERNALSYM MSIDBERROR_BADKEYTABLE}
241
MSIDBERROR_BADMAXMINVALUES = 25; // value in MaxValue column of _Validation table is less than value in MinValue column
242
{$EXTERNALSYM MSIDBERROR_BADMAXMINVALUES}
243
MSIDBERROR_BADCABINET = 26; // bad cabinet name
244
{$EXTERNALSYM MSIDBERROR_BADCABINET}
245
MSIDBERROR_BADSHORTCUT = 27; // bad shortcut target
246
{$EXTERNALSYM MSIDBERROR_BADSHORTCUT}
247
MSIDBERROR_STRINGOVERFLOW = 28; // string overflow (greater than length allowed in column def)
248
{$EXTERNALSYM MSIDBERROR_STRINGOVERFLOW}
249
MSIDBERROR_BADLOCALIZEATTRIB = 29; // invalid localization attribute (primary keys cannot be localized)
250
{$EXTERNALSYM MSIDBERROR_BADLOCALIZEATTRIB}
254
{$EXTERNALSYM MSIDBERROR}
255
TMsiDbError = MSIDBERROR;
258
MSIRUNMODE_ADMIN = 0; // admin mode install, else product install
259
{$EXTERNALSYM MSIRUNMODE_ADMIN}
260
MSIRUNMODE_ADVERTISE = 1; // installing advertisements, else installing or updating product
261
{$EXTERNALSYM MSIRUNMODE_ADVERTISE}
262
MSIRUNMODE_MAINTENANCE = 2; // modifying an existing installation, else new installation
263
{$EXTERNALSYM MSIRUNMODE_MAINTENANCE}
264
MSIRUNMODE_ROLLBACKENABLED = 3; // rollback is enabled
265
{$EXTERNALSYM MSIRUNMODE_ROLLBACKENABLED}
266
MSIRUNMODE_LOGENABLED = 4; // log file active, enabled prior to install session
267
{$EXTERNALSYM MSIRUNMODE_LOGENABLED}
268
MSIRUNMODE_OPERATIONS = 5; // spooling execute operations, else in determination phase
269
{$EXTERNALSYM MSIRUNMODE_OPERATIONS}
270
MSIRUNMODE_REBOOTATEND = 6; // reboot needed after successful installation (settable)
271
{$EXTERNALSYM MSIRUNMODE_REBOOTATEND}
272
MSIRUNMODE_REBOOTNOW = 7; // reboot needed to continue installation (settable)
273
{$EXTERNALSYM MSIRUNMODE_REBOOTNOW}
274
MSIRUNMODE_CABINET = 8; // installing files from cabinets and files using Media table
275
{$EXTERNALSYM MSIRUNMODE_CABINET}
276
MSIRUNMODE_SOURCESHORTNAMES= 9; // source LongFileNames suppressed via PID_MSISOURCE summary property
277
{$EXTERNALSYM MSIRUNMODE_SOURCESHORTNAMES}
278
MSIRUNMODE_TARGETSHORTNAMES= 10; // target LongFileNames suppressed via SHORTFILENAMES property
279
{$EXTERNALSYM MSIRUNMODE_TARGETSHORTNAMES}
280
MSIRUNMODE_RESERVED11 = 11; // future use
281
{$EXTERNALSYM MSIRUNMODE_RESERVED11}
282
MSIRUNMODE_WINDOWS9X = 12; // operating systems is Windows9?, else Windows NT
283
{$EXTERNALSYM MSIRUNMODE_WINDOWS9X}
284
MSIRUNMODE_ZAWENABLED = 13; // operating system supports demand installation
285
{$EXTERNALSYM MSIRUNMODE_ZAWENABLED}
286
MSIRUNMODE_RESERVED14 = 14; // future use
287
{$EXTERNALSYM MSIRUNMODE_RESERVED14}
288
MSIRUNMODE_RESERVED15 = 15; // future use
289
{$EXTERNALSYM MSIRUNMODE_RESERVED15}
290
MSIRUNMODE_SCHEDULED = 16; // custom action call from install script execution
291
{$EXTERNALSYM MSIRUNMODE_SCHEDULED}
292
MSIRUNMODE_ROLLBACK = 17; // custom action call from rollback execution script
293
{$EXTERNALSYM MSIRUNMODE_ROLLBACK}
294
MSIRUNMODE_COMMIT = 18; // custom action call from commit execution script
295
{$EXTERNALSYM MSIRUNMODE_COMMIT}
299
{$EXTERNALSYM MSIRUNMODE}
300
TMsiRunMode = MSIRUNMODE;
303
INSTALLMESSAGE_TYPEMASK = DWORD($FF000000); // mask for type code
304
{$EXTERNALSYM INSTALLMESSAGE_TYPEMASK}
306
// Note: INSTALLMESSAGE_ERROR, INSTALLMESSAGE_WARNING, INSTALLMESSAGE_USER are to or'd
307
// with a message box style to indicate the buttons to display and return:
308
// MB_OK,MB_OKCANCEL,MB_ABORTRETRYIGNORE,MB_YESNOCANCEL,MB_YESNO,MB_RETRYCANCEL
309
// the default button (MB_DEFBUTTON1 is normal default):
310
// MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3
311
// and optionally an icon style:
312
// MB_ICONERROR, MB_ICONQUESTION, MB_ICONWARNING, MB_ICONINFORMATION
315
MSITRANSFORM_ERROR_ADDEXISTINGROW = $00000001;
316
{$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGROW}
317
MSITRANSFORM_ERROR_DELMISSINGROW = $00000002;
318
{$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGROW}
319
MSITRANSFORM_ERROR_ADDEXISTINGTABLE = $00000004;
320
{$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGTABLE}
321
MSITRANSFORM_ERROR_DELMISSINGTABLE = $00000008;
322
{$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGTABLE}
323
MSITRANSFORM_ERROR_UPDATEMISSINGROW = $00000010;
324
{$EXTERNALSYM MSITRANSFORM_ERROR_UPDATEMISSINGROW}
325
MSITRANSFORM_ERROR_CHANGECODEPAGE = $00000020;
326
{$EXTERNALSYM MSITRANSFORM_ERROR_CHANGECODEPAGE}
327
MSITRANSFORM_ERROR_VIEWTRANSFORM = $00000100;
328
{$EXTERNALSYM MSITRANSFORM_ERROR_VIEWTRANSFORM}
331
MSITRANSFORM_ERROR = DWORD;
332
{$EXTERNALSYM MSITRANSFORM_ERROR}
333
TMsiTransformError = MSITRANSFORM_ERROR;
336
MSITRANSFORM_VALIDATE_LANGUAGE = $00000001;
337
{$EXTERNALSYM MSITRANSFORM_VALIDATE_LANGUAGE}
338
MSITRANSFORM_VALIDATE_PRODUCT = $00000002;
339
{$EXTERNALSYM MSITRANSFORM_VALIDATE_PRODUCT}
340
MSITRANSFORM_VALIDATE_PLATFORM = $00000004;
341
{$EXTERNALSYM MSITRANSFORM_VALIDATE_PLATFORM}
342
MSITRANSFORM_VALIDATE_MAJORVERSION = $00000008;
343
{$EXTERNALSYM MSITRANSFORM_VALIDATE_MAJORVERSION}
344
MSITRANSFORM_VALIDATE_MINORVERSION = $00000010;
345
{$EXTERNALSYM MSITRANSFORM_VALIDATE_MINORVERSION}
346
MSITRANSFORM_VALIDATE_UPDATEVERSION = $00000020;
347
{$EXTERNALSYM MSITRANSFORM_VALIDATE_UPDATEVERSION}
348
MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION = $00000040;
349
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION}
350
MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION = $00000080;
351
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION}
352
MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION = $00000100;
353
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION}
354
MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION = $00000200;
355
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION}
356
MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION = $00000400;
357
{$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION}
358
MSITRANSFORM_VALIDATE_UPGRADECODE = $00000800;
359
{$EXTERNALSYM MSITRANSFORM_VALIDATE_UPGRADECODE}
362
MSITRANSFORM_VALIDATE = DWORD;
363
{$EXTERNALSYM MSITRANSFORM_VALIDATE}
364
TMsiTransformValidate = MSITRANSFORM_VALIDATE;
366
// -----------------------------------------------------------------------------
367
// Installer database access functions
368
// -----------------------------------------------------------------------------
370
// Prepare a database query, creating a view object
371
// Returns ERROR_SUCCESS if successful, and the view handle is returned,
372
// else ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_BAD_QUERY_SYNTAX, ERROR_GEN_FAILURE
373
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
375
function MsiDatabaseOpenViewA(hDatabase: MSIHANDLE; szQuery: LPCSTR; var phView: MSIHANDLE): UINT; stdcall;
376
{$EXTERNALSYM MsiDatabaseOpenViewA}
377
function MsiDatabaseOpenViewW(hDatabase: MSIHANDLE; szQuery: LPCWSTR; var phView: MSIHANDLE): UINT; stdcall;
378
{$EXTERNALSYM MsiDatabaseOpenViewW}
379
function MsiDatabaseOpenView(hDatabase: MSIHANDLE; szQuery: LPCTSTR; var phView: MSIHANDLE): UINT; stdcall;
380
{$EXTERNALSYM MsiDatabaseOpenView}
382
// Returns the MSIDBERROR enum and name of the column corresponding to the error
383
// Similar to a GetLastError function, but for the view. NOT the same as MsiGetLastErrorRecord
384
// Returns errors of MsiViewModify.
386
function MsiViewGetErrorA(hView: MSIHANDLE; szColumnNameBuffer: LPSTR;
387
var pcchBuf: DWORD): MSIDBERROR; stdcall;
388
{$EXTERNALSYM MsiViewGetErrorA}
389
function MsiViewGetErrorW(hView: MSIHANDLE; szColumnNameBuffer: LPWSTR;
390
var pcchBuf: DWORD): MSIDBERROR; stdcall;
391
{$EXTERNALSYM MsiViewGetErrorW}
392
function MsiViewGetError(hView: MSIHANDLE; szColumnNameBuffer: LPTSTR;
393
var pcchBuf: DWORD): MSIDBERROR; stdcall;
394
{$EXTERNALSYM MsiViewGetError}
396
// Exectute the view query, supplying parameters as required
397
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE
398
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
400
function MsiViewExecute(hView: MSIHANDLE; hRecord: MSIHANDLE): UINT; stdcall;
401
{$EXTERNALSYM MsiViewExecute}
403
// Fetch the next sequential record from the view
404
// Result is ERROR_SUCCESS if a row is found, and its handle is returned
405
// else ERROR_NO_MORE_ITEMS if no records remain, and a null handle is returned
406
// else result is error: ERROR_INVALID_HANDLE_STATE, ERROR_INVALID_HANDLE, ERROR_GEN_FAILURE
408
function MsiViewFetch(hView: MSIHANDLE; var phRecord: MSIHANDLE): UINT; stdcall;
409
{$EXTERNALSYM MsiViewFetch}
411
// Modify a database record, parameters must match types in query columns
412
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE, ERROR_ACCESS_DENIED
413
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
415
function MsiViewModify(hView: MSIHANDLE; eModifyMode: MSIMODIFY; hRecord: MSIHANDLE): UINT; stdcall;
416
{$EXTERNALSYM MsiViewModify}
418
// Return the column names or specifications for the current view
419
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, or ERROR_INVALID_HANDLE_STATE
421
function MsiViewGetColumnInfo(hView: MSIHANDLE; eColumnInfo: MSICOLINFO;
422
var phRecord: MSIHANDLE): UINT; stdcall;
423
{$EXTERNALSYM MsiViewGetColumnInfo}
425
// Release the result set for an executed view, to allow re-execution
426
// Only needs to be called if not all records have been fetched
427
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE
429
function MsiViewClose(hView: MSIHANDLE): UINT; stdcall;
430
{$EXTERNALSYM MsiViewClose}
432
// Return a record containing the names of all primary key columns for a given table
433
// Returns an MSIHANDLE for a record containing the name of each column.
434
// The field count of the record corresponds to the number of primary key columns.
435
// Field [0] of the record contains the table name.
436
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_TABLE
438
function MsiDatabaseGetPrimaryKeysA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
439
var phRecord: MSIHANDLE): UINT; stdcall;
440
{$EXTERNALSYM MsiDatabaseGetPrimaryKeysA}
441
function MsiDatabaseGetPrimaryKeysW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
442
var phRecord: MSIHANDLE): UINT; stdcall;
443
{$EXTERNALSYM MsiDatabaseGetPrimaryKeysW}
444
function MsiDatabaseGetPrimaryKeys(hDatabase: MSIHANDLE; szTableName: LPCTSTR;
445
var phRecord: MSIHANDLE): UINT; stdcall;
446
{$EXTERNALSYM MsiDatabaseGetPrimaryKeys}
448
// Return an enum defining the state of the table (temporary, unknown, or persistent).
449
// Returns MSICONDITION_ERROR, MSICONDITION_FALSE, MSICONDITION_TRUE, MSICONDITION_NONE
451
function MsiDatabaseIsTablePersistentA(hDatabase: MSIHANDLE; szTableName: LPCSTR): MSICONDITION; stdcall;
452
{$EXTERNALSYM MsiDatabaseIsTablePersistentA}
453
function MsiDatabaseIsTablePersistentW(hDatabase: MSIHANDLE; szTableName: LPCWSTR): MSICONDITION; stdcall;
454
{$EXTERNALSYM MsiDatabaseIsTablePersistentW}
455
function MsiDatabaseIsTablePersistent(hDatabase: MSIHANDLE; szTableName: LPCTSTR): MSICONDITION; stdcall;
456
{$EXTERNALSYM MsiDatabaseIsTablePersistent}
458
// --------------------------------------------------------------------------
459
// Summary information stream management functions
460
// --------------------------------------------------------------------------
462
// Integer Property IDs: 1, 14, 15, 16, 19
463
// DateTime Property IDs: 10, 11, 12, 13
464
// Text Property IDs: 2, 3, 4, 5, 6, 7, 8, 9, 18
465
// Unsupported Propery IDs: 0 (PID_DICTIONARY), 17 (PID_THUMBNAIL)
467
// Obtain a handle for the _SummaryInformation stream for an MSI database
468
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
470
function MsiGetSummaryInformationA(hDatabase: MSIHANDLE; szDatabasePath: LPCSTR;
471
uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
472
{$EXTERNALSYM MsiGetSummaryInformationA}
473
function MsiGetSummaryInformationW(hDatabase: MSIHANDLE; szDatabasePath: LPCWSTR;
474
uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
475
{$EXTERNALSYM MsiGetSummaryInformationW}
476
function MsiGetSummaryInformation(hDatabase: MSIHANDLE; szDatabasePath: LPCTSTR;
477
uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall;
478
{$EXTERNALSYM MsiGetSummaryInformation}
480
// Obtain the number of existing properties in the SummaryInformation stream
482
function MsiSummaryInfoGetPropertyCount(hSummaryInfo: MSIHANDLE; var puiPropertyCount: UINT): UINT; stdcall;
483
{$EXTERNALSYM MsiSummaryInfoGetPropertyCount}
485
// Set a single summary information property
486
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY
488
function MsiSummaryInfoSetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
489
uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCSTR): UINT; stdcall;
490
{$EXTERNALSYM MsiSummaryInfoSetPropertyA}
491
function MsiSummaryInfoSetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
492
uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCWSTR): UINT; stdcall;
493
{$EXTERNALSYM MsiSummaryInfoSetPropertyW}
494
function MsiSummaryInfoSetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
495
uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCTSTR): UINT; stdcall;
496
{$EXTERNALSYM MsiSummaryInfoSetProperty}
498
// Get a single property from the summary information
499
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY
501
function MsiSummaryInfoGetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
502
var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPSTR;
503
var pcchValueBuf: DWORD): UINT; stdcall;
504
{$EXTERNALSYM MsiSummaryInfoGetPropertyA}
505
function MsiSummaryInfoGetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
506
var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPWSTR;
507
var pcchValueBuf: DWORD): UINT; stdcall;
508
{$EXTERNALSYM MsiSummaryInfoGetPropertyW}
509
function MsiSummaryInfoGetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT;
510
var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPTSTR;
511
var pcchValueBuf: DWORD): UINT; stdcall;
512
{$EXTERNALSYM MsiSummaryInfoGetProperty}
514
// Write back changed information to summary information stream
516
function MsiSummaryInfoPersist(hSummaryInfo: MSIHANDLE): UINT; stdcall;
517
{$EXTERNALSYM MsiSummaryInfoPersist}
519
// --------------------------------------------------------------------------
520
// Installer database management functions - not used by custom actions
521
// --------------------------------------------------------------------------
523
// Open an installer database, specifying the persistance mode, which is a pointer.
524
// Predefined persist values are reserved pointer values, requiring pointer arithmetic.
525
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
527
function MsiOpenDatabaseA(szDatabasePath: LPCSTR; szPersist: LPCSTR;
528
var phDatabase: MSIHANDLE): UINT; stdcall;
529
{$EXTERNALSYM MsiOpenDatabaseA}
530
function MsiOpenDatabaseW(szDatabasePath: LPCWSTR; szPersist: LPCWSTR;
531
var phDatabase: MSIHANDLE): UINT; stdcall;
532
{$EXTERNALSYM MsiOpenDatabaseW}
533
function MsiOpenDatabase(szDatabasePath: LPCTSTR; szPersist: LPCTSTR;
534
var phDatabase: MSIHANDLE): UINT; stdcall;
535
{$EXTERNALSYM MsiOpenDatabase}
537
// Import an MSI text archive table into an open database
538
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
540
function MsiDatabaseImportA(hDatabase: MSIHANDLE; szFolderPath: LPCSTR;
541
szFileName: LPCSTR): UINT; stdcall;
542
{$EXTERNALSYM MsiDatabaseImportA}
543
function MsiDatabaseImportW(hDatabase: MSIHANDLE; szFolderPath: LPCWSTR;
544
szFileName: LPCWSTR): UINT; stdcall;
545
{$EXTERNALSYM MsiDatabaseImportW}
546
function MsiDatabaseImport(hDatabase: MSIHANDLE; szFolderPath: LPCTSTR;
547
szFileName: LPCTSTR): UINT; stdcall;
548
{$EXTERNALSYM MsiDatabaseImport}
550
// Export an MSI table from an open database to a text archive file
551
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
553
function MsiDatabaseExportA(hDatabase: MSIHANDLE; szTableName: LPCSTR;
554
szFolderPath: LPCSTR; szFileName: LPCSTR): UINT; stdcall;
555
{$EXTERNALSYM MsiDatabaseExportA}
556
function MsiDatabaseExportW(hDatabase: MSIHANDLE; szTableName: LPCWSTR;
557
szFolderPath: LPCWSTR; szFileName: LPCWSTR): UINT; stdcall;
558
{$EXTERNALSYM MsiDatabaseExportW}
559
function MsiDatabaseExport(hDatabase: MSIHANDLE; szTableName: LPCTSTR;
560
szFolderPath: LPCTSTR; szFileName: LPCTSTR): UINT; stdcall;
561
{$EXTERNALSYM MsiDatabaseExport}
563
// Merge two database together, allowing duplicate rows
564
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
566
function MsiDatabaseMergeA(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
567
szTableName: LPCSTR): UINT; stdcall;
568
{$EXTERNALSYM MsiDatabaseMergeA}
569
function MsiDatabaseMergeW(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
570
szTableName: LPCWSTR): UINT; stdcall;
571
{$EXTERNALSYM MsiDatabaseMergeW}
572
function MsiDatabaseMerge(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE;
573
szTableName: LPCTSTR): UINT; stdcall;
574
{$EXTERNALSYM MsiDatabaseMerge}
576
// Generate a transform file of differences between two databases
577
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
579
function MsiDatabaseGenerateTransformA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
580
szTransformFile: LPCSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
581
{$EXTERNALSYM MsiDatabaseGenerateTransformA}
582
function MsiDatabaseGenerateTransformW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
583
szTransformFile: LPCWSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
584
{$EXTERNALSYM MsiDatabaseGenerateTransformW}
585
function MsiDatabaseGenerateTransform(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
586
szTransformFile: LPCTSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall;
587
{$EXTERNALSYM MsiDatabaseGenerateTransform}
589
// Apply a transform file containing database difference
590
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
592
function MsiDatabaseApplyTransformA(hDatabase: MSIHANDLE; szTransformFile: LPCSTR;
593
iErrorConditions: Integer): UINT; stdcall;
594
{$EXTERNALSYM MsiDatabaseApplyTransformA}
595
function MsiDatabaseApplyTransformW(hDatabase: MSIHANDLE; szTransformFile: LPCWSTR;
596
iErrorConditions: Integer): UINT; stdcall;
597
{$EXTERNALSYM MsiDatabaseApplyTransformW}
598
function MsiDatabaseApplyTransform(hDatabase: MSIHANDLE; szTransformFile: LPCTSTR;
599
iErrorConditions: Integer): UINT; stdcall;
600
{$EXTERNALSYM MsiDatabaseApplyTransform}
602
// Create summary information of existing transform to include validation and error conditions
603
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
605
function MsiCreateTransformSummaryInfoA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
606
szTransformFile: LPCSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
607
{$EXTERNALSYM MsiCreateTransformSummaryInfoA}
608
function MsiCreateTransformSummaryInfoW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
609
szTransformFile: LPCWSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
610
{$EXTERNALSYM MsiCreateTransformSummaryInfoW}
611
function MsiCreateTransformSummaryInfo(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE;
612
szTransformFile: LPCTSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall;
613
{$EXTERNALSYM MsiCreateTransformSummaryInfo}
615
// Write out all persistent table data, ignored if database opened read-only
616
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
618
function MsiDatabaseCommit(hDatabase: MSIHANDLE): UINT; stdcall;
619
{$EXTERNALSYM MsiDatabaseCommit}
621
// Return the update state of a database
623
function MsiGetDatabaseState(hDatabase: MSIHANDLE): MSIDBSTATE; stdcall;
624
{$EXTERNALSYM MsiGetDatabaseState}
626
// --------------------------------------------------------------------------
627
// Record object functions
628
// --------------------------------------------------------------------------
630
// Create a new record object with the requested number of fields
631
// Field 0, not included in count, is used for format strings and op codes
632
// All fields are initialized to null
633
// Returns a handle to the created record, or 0 if memory could not be allocated
635
function MsiCreateRecord(cParams: UINT): MSIHANDLE; stdcall;
636
{$EXTERNALSYM MsiCreateRecord}
638
// Report whether a record field is NULL
639
// Returns TRUE if the field is null or does not exist
640
// Returns FALSE if the field contains data, or the handle is invalid
642
function MsiRecordIsNull(hRecord: MSIHANDLE; iField: UINT): BOOL; stdcall;
643
{$EXTERNALSYM MsiRecordIsNull}
645
// Return the length of a record field
646
// Returns 0 if field is NULL or non-existent
647
// Returns sizeof(Integer) if integer data
648
// Returns character count if string data (not counting null terminator)
649
// Returns bytes count if stream data
651
function MsiRecordDataSize(hRecord: MSIHANDLE; iField: UINT): UINT; stdcall;
652
{$EXTERNALSYM MsiRecordDataSize}
654
// Set a record field to an integer value
655
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD
657
function MsiRecordSetInteger(hRecord: MSIHANDLE; iField: UINT; iValue: Integer): UINT; stdcall;
658
{$EXTERNALSYM MsiRecordSetInteger}
660
// Copy a string into the designated field
661
// A null string pointer and an empty string both set the field to null
662
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD
664
function MsiRecordSetStringA(hRecord: MSIHANDLE; iField: UINT; szValue: LPCSTR): UINT; stdcall;
665
{$EXTERNALSYM MsiRecordSetStringA}
666
function MsiRecordSetStringW(hRecord: MSIHANDLE; iField: UINT; szValue: LPCWSTR): UINT; stdcall;
667
{$EXTERNALSYM MsiRecordSetStringW}
668
function MsiRecordSetString(hRecord: MSIHANDLE; iField: UINT; szValue: LPCTSTR): UINT; stdcall;
669
{$EXTERNALSYM MsiRecordSetString}
671
// Return the integer value from a record field
672
// Returns the value MSI_NULL_INTEGER if the field is null
673
// or if the field is a string that cannot be converted to an integer
675
function MsiRecordGetInteger(hRecord: MSIHANDLE; iField: UINT): Integer; stdcall;
676
{$EXTERNALSYM MsiRecordGetInteger}
678
// Return the string value of a record field
679
// Integer fields will be converted to a string
680
// Null and non-existent fields will report a value of 0
681
// Fields containing stream data will return ERROR_INVALID_DATATYPE
682
// Returns ERROR_SUCCESS, ERROR_MORE_DATA,
683
// ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD, ERROR_BAD_ARGUMENTS
685
function MsiRecordGetStringA(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPSTR;
686
var pcchValueBuf: DWORD): UINT; stdcall;
687
{$EXTERNALSYM MsiRecordGetStringA}
688
function MsiRecordGetStringW(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPWSTR;
689
var pcchValueBuf: DWORD): UINT; stdcall;
690
{$EXTERNALSYM MsiRecordGetStringW}
691
function MsiRecordGetString(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPTSTR;
692
var pcchValueBuf: DWORD): UINT; stdcall;
693
{$EXTERNALSYM MsiRecordGetString}
695
// Returns the number of fields allocated in the record
696
// Does not count field 0, used for formatting and op codes
698
function MsiRecordGetFieldCount(hRecord: MSIHANDLE): UINT; stdcall;
699
{$EXTERNALSYM MsiRecordGetFieldCount}
701
// Set a record stream field from a file
702
// The contents of the specified file will be read into a stream object
703
// The stream will be persisted if the record is inserted into the database
704
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
706
function MsiRecordSetStreamA(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCSTR): UINT; stdcall;
707
{$EXTERNALSYM MsiRecordSetStreamA}
708
function MsiRecordSetStreamW(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCWSTR): UINT; stdcall;
709
{$EXTERNALSYM MsiRecordSetStreamW}
710
function MsiRecordSetStream(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCTSTR): UINT; stdcall;
711
{$EXTERNALSYM MsiRecordSetStream}
713
// Read bytes from a record stream field into a buffer
714
// Must set the in/out argument to the requested byte count to read
715
// The number of bytes transferred is returned through the argument
716
// If no more bytes are available, ERROR_SUCCESS is still returned
718
function MsiRecordReadStream(hRecord: MSIHANDLE; iField: UINT; szDataBuf: PChar;
719
var pcbDataBuf: DWORD): UINT; stdcall;
720
{$EXTERNALSYM MsiRecordReadStream}
722
// Clears all data fields in a record to NULL
724
function MsiRecordClearData(hRecord: MSIHANDLE): UINT; stdcall;
725
{$EXTERNALSYM MsiRecordClearData}
727
// --------------------------------------------------------------------------
728
// Functions to access a running installation, called from custom actions
729
// The install handle is the single argument passed to custom actions
730
// --------------------------------------------------------------------------
732
// Return a handle to the database currently in use by this installer instance
734
function MsiGetActiveDatabase(hInstall: MSIHANDLE): MSIHANDLE; stdcall;
735
{$EXTERNALSYM MsiGetActiveDatabase}
737
// Set the value for an installer property
738
// If the property is not defined, it will be created
739
// If the value is null or an empty string, the property will be removed
740
// Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS
742
function MsiSetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValue: LPCSTR): UINT; stdcall;
743
{$EXTERNALSYM MsiSetPropertyA}
744
function MsiSetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValue: LPCWSTR): UINT; stdcall;
745
{$EXTERNALSYM MsiSetPropertyW}
746
function MsiSetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValue: LPCTSTR): UINT; stdcall;
747
{$EXTERNALSYM MsiSetProperty}
749
// Get the value for an installer property
750
// If the property is not defined, it is equivalent to a 0-length value, not error
751
// Returns ERROR_SUCCESS, ERROR_MORE_DATA, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS
753
function MsiGetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValueBuf: LPSTR;
754
var pcchValueBuf: DWORD): UINT; stdcall;
755
{$EXTERNALSYM MsiGetPropertyA}
756
function MsiGetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValueBuf: LPWSTR;
757
var pcchValueBuf: DWORD): UINT; stdcall;
758
{$EXTERNALSYM MsiGetPropertyW}
759
function MsiGetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValueBuf: LPTSTR;
760
var pcchValueBuf: DWORD): UINT; stdcall;
761
{$EXTERNALSYM MsiGetProperty}
763
// Return the numeric language for the currently running install
764
// Returns 0 if an install not running
766
function MsiGetLanguage(hInstall: MSIHANDLE): LANGID; stdcall;
767
{$EXTERNALSYM MsiGetLanguage}
769
// Return one of the boolean internal installer states
770
// Returns FALSE if the handle is not active or if the mode is not implemented
772
function MsiGetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE): BOOL; stdcall;
773
{$EXTERNALSYM MsiGetMode}
775
// Set an internal install session boolean mode - Note: most modes are read-only
776
// Returns ERROR_SUCCESS if the mode can be set to the desired state
777
// Returns ERROR_ACCESS_DENIED if the mode is not settable
778
// Returns ERROR_INVALID_HANDLE if the handle is not an active install session
780
function MsiSetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE; fState: BOOL): UINT; stdcall;
781
{$EXTERNALSYM MsiSetMode}
783
// Format record data using a format string containing field markers and/or properties
784
// Record field 0 must contain the format string
785
// Other fields must contain data that may be referenced by the format string.
787
function MsiFormatRecordA(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPSTR;
788
var pcchResultBuf: DWORD): UINT; stdcall;
789
{$EXTERNALSYM MsiFormatRecordA}
790
function MsiFormatRecordW(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPWSTR;
791
var pcchResultBuf: DWORD): UINT; stdcall;
792
{$EXTERNALSYM MsiFormatRecordW}
793
function MsiFormatRecord(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPTSTR;
794
var pcchResultBuf: DWORD): UINT; stdcall;
795
{$EXTERNALSYM MsiFormatRecord}
797
// Execute another action, either built-in, custom, or UI wizard
798
// Returns ERROR_FUNCTION_NOT_CALLED if action not found
799
// Returns ERROR_SUCCESS if action completed succesfully
800
// Returns ERROR_INSTALL_USEREXIT if user cancelled during action
801
// Returns ERROR_INSTALL_FAILURE if action failed
802
// Returns ERROR_INSTALL_SUSPEND if user suspended installation
803
// Returns ERROR_MORE_DATA if action wishes to skip remaining actions
804
// Returns ERROR_INVALID_HANDLE_STATE if install session not active
805
// Returns ERROR_INVALID_DATA if failure calling custom action
806
// Returns ERROR_INVALID_HANDLE or ERROR_INVALID_PARAMETER if arguments invalid
808
function MsiDoActionA(hInstall: MSIHANDLE; szAction: LPCSTR): UINT; stdcall;
809
{$EXTERNALSYM MsiDoActionA}
810
function MsiDoActionW(hInstall: MSIHANDLE; szAction: LPCWSTR): UINT; stdcall;
811
{$EXTERNALSYM MsiDoActionW}
812
function MsiDoAction(hInstall: MSIHANDLE; szAction: LPCTSTR): UINT; stdcall;
813
{$EXTERNALSYM MsiDoAction}
815
// Execute another action sequence, as descibed in the specified table
816
// Returns the same error codes as MsiDoAction
818
function MsiSequenceA(hInstall: MSIHANDLE; szTable: LPCSTR; iSequenceMode: Integer): UINT; stdcall;
819
{$EXTERNALSYM MsiSequenceA}
820
function MsiSequenceW(hInstall: MSIHANDLE; szTable: LPCWSTR; iSequenceMode: Integer): UINT; stdcall;
821
{$EXTERNALSYM MsiSequenceW}
822
function MsiSequence(hInstall: MSIHANDLE; szTable: LPCTSTR; iSequenceMode: Integer): UINT; stdcall;
823
{$EXTERNALSYM MsiSequence}
825
// Send an error record to the installer for processing.
826
// If field 0 (template) is not set, field 1 must be set to the error code,
827
// corresponding the the error message in the Error database table,
828
// and the message will be formatted using the template from the Error table
829
// before passing it to the UI handler for display.
830
// Returns Win32 button codes: IDOK IDCANCEL IDABORT IDRETRY IDIGNORE IDYES IDNO
831
// or 0 if no action taken, or -1 if invalid argument or handle
833
function MsiProcessMessage(hInstall: MSIHANDLE; eMessageType: INSTALLMESSAGE;
834
hRecord: MSIHANDLE): Integer; stdcall;
835
{$EXTERNALSYM MsiProcessMessage}
837
// Evaluate a conditional expression containing property names and values
839
function MsiEvaluateConditionA(hInstall: MSIHANDLE; szCondition: LPCSTR): MSICONDITION; stdcall;
840
{$EXTERNALSYM MsiEvaluateConditionA}
841
function MsiEvaluateConditionW(hInstall: MSIHANDLE; szCondition: LPCWSTR): MSICONDITION; stdcall;
842
{$EXTERNALSYM MsiEvaluateConditionW}
843
function MsiEvaluateCondition(hInstall: MSIHANDLE; szCondition: LPCTSTR): MSICONDITION; stdcall;
844
{$EXTERNALSYM MsiEvaluateCondition}
846
// Get the installed state and requested action state of a feature
847
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
849
function MsiGetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
850
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
851
{$EXTERNALSYM MsiGetFeatureStateA}
852
function MsiGetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
853
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
854
{$EXTERNALSYM MsiGetFeatureStateW}
855
function MsiGetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR;
856
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
857
{$EXTERNALSYM MsiGetFeatureState}
859
// Request a feature to be set to a specified state
860
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
862
function MsiSetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR;
863
iState: INSTALLSTATE): UINT; stdcall;
864
{$EXTERNALSYM MsiSetFeatureStateA}
865
function MsiSetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
866
iState: INSTALLSTATE): UINT; stdcall;
867
{$EXTERNALSYM MsiSetFeatureStateW}
868
function MsiSetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR;
869
iState: INSTALLSTATE): UINT; stdcall;
870
{$EXTERNALSYM MsiSetFeatureState}
872
// Set the attribute bits of a specified feature at runtime.
873
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
875
function MsiSetFeatureAttributesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
876
dwAttributes: DWORD): UINT; stdcall;
877
{$EXTERNALSYM MsiSetFeatureAttributesA}
878
function MsiSetFeatureAttributesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
879
dwAttributes: DWORD): UINT; stdcall;
880
{$EXTERNALSYM MsiSetFeatureAttributesW}
881
function MsiSetFeatureAttributes(hInstall: MSIHANDLE; szFeature: LPCTSTR;
882
dwAttributes: DWORD): UINT; stdcall;
883
{$EXTERNALSYM MsiSetFeatureAttributes}
885
// Get the installed state and requested action state of a component
886
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
888
function MsiGetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
889
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
890
{$EXTERNALSYM MsiGetComponentStateA}
891
function MsiGetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
892
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
893
{$EXTERNALSYM MsiGetComponentStateW}
894
function MsiGetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR;
895
var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall;
896
{$EXTERNALSYM MsiGetComponentState}
898
// Request a component to be set to a specified state
899
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
901
function MsiSetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR;
902
iState: INSTALLSTATE): UINT; stdcall;
903
{$EXTERNALSYM MsiSetComponentStateA}
904
function MsiSetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR;
905
iState: INSTALLSTATE): UINT; stdcall;
906
{$EXTERNALSYM MsiSetComponentStateW}
907
function MsiSetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR;
908
iState: INSTALLSTATE): UINT; stdcall;
909
{$EXTERNALSYM MsiSetComponentState}
911
// Return the disk cost for a feature and related features
912
// Can specify either current feature state or proposed state
913
// Can specify extent of related features to cost
914
// Note that adding costs for several features may produce an
915
// excessively large cost due to shared components and parents.
916
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
918
function MsiGetFeatureCostA(hInstall: MSIHANDLE; szFeature: LPCSTR;
919
iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
920
{$EXTERNALSYM MsiGetFeatureCostA}
921
function MsiGetFeatureCostW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
922
iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
923
{$EXTERNALSYM MsiGetFeatureCostW}
924
function MsiGetFeatureCost(hInstall: MSIHANDLE; szFeature: LPCTSTR;
925
iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall;
926
{$EXTERNALSYM MsiGetFeatureCost}
928
// Enumerates the costs and temporary costs per drives for
929
// szComponent. If szComponent is set to NULL, it enumerates
930
// the above costs for the engine, per drives.
932
// The enumeration is 0-based, i.e. it returns the data for
933
// the first drive when called w/ dwIndex set to 0.
935
// Can specify either current feature state or proposed state.
937
// Execution of this function sets the error record, accessible
938
// via MsiGetLastErrorRecord.
940
function MsiEnumComponentCostsA(hInstall: MSIHANDLE; szComponent: LPCSTR; dwIndex: DWORD; iState: INSTALLSTATE;
941
szDriveBuf: LPSTR; var pcchDriveBuf: DWORD; var piCost: INT; piTempCost: INT): UINT; stdcall;
942
{$EXTERNALSYM MsiEnumComponentCostsA}
943
function MsiEnumComponentCostsW(hInstall: MSIHANDLE; szComponent: LPCWSTR; dwIndex: DWORD; iState: INSTALLSTATE;
944
szDriveBuf: LPWSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
945
{$EXTERNALSYM MsiEnumComponentCostsW}
946
function MsiEnumComponentCosts(hInstall: MSIHANDLE; szComponent: LPCTSTR; dwIndex: DWORD; iState: INSTALLSTATE;
947
szDriveBuf: LPTSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall;
948
{$EXTERNALSYM MsiEnumComponentCosts}
950
// Set the install level for a full product installation (not a feature request)
951
// Setting the value to 0 initialized components and features to the default level
952
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
954
function MsiSetInstallLevel(hInstall: MSIHANDLE; iInstallLevel: Integer): UINT; stdcall;
955
{$EXTERNALSYM MsiSetInstallLevel}
957
// Get the valid install states for a feature, represented by bit flags
958
// For each valid install state, a bit is set of value: (1 << INSTALLSTATE)
959
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
961
function MsiGetFeatureValidStatesA(hInstall: MSIHANDLE; szFeature: LPCSTR;
962
var dwInstallStates: DWORD): UINT; stdcall;
963
{$EXTERNALSYM MsiGetFeatureValidStatesA}
964
function MsiGetFeatureValidStatesW(hInstall: MSIHANDLE; szFeature: LPCWSTR;
965
var dwInstallStates: DWORD): UINT; stdcall;
966
{$EXTERNALSYM MsiGetFeatureValidStatesW}
967
function MsiGetFeatureValidStates(hInstall: MSIHANDLE; szFeature: LPCTSTR;
968
var dwInstallStates: DWORD): UINT; stdcall;
969
{$EXTERNALSYM MsiGetFeatureValidStates}
971
// Return the full source path for a folder in the Directory table
972
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
974
function MsiGetSourcePathA(hInstall: MSIHANDLE; szFolder: LPCSTR; szPathBuf: LPSTR;
975
var pcchPathBuf: DWORD): UINT; stdcall;
976
{$EXTERNALSYM MsiGetSourcePathA}
977
function MsiGetSourcePathW(hInstall: MSIHANDLE; szFolder: LPCWSTR; szPathBuf: LPWSTR;
978
var pcchPathBuf: DWORD): UINT; stdcall;
979
{$EXTERNALSYM MsiGetSourcePathW}
980
function MsiGetSourcePath(hInstall: MSIHANDLE; szFolder: LPCTSTR; szPathBuf: LPTSTR;
981
var pcchPathBuf: DWORD): UINT; stdcall;
982
{$EXTERNALSYM MsiGetSourcePath}
984
// Return the full target path for a folder in the Directory table
985
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
987
function MsiGetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
988
szPathBuf: LPSTR; var pcchPathBuf: DWORD): UINT; stdcall;
989
{$EXTERNALSYM MsiGetTargetPathA}
990
function MsiGetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
991
szPathBuf: LPWSTR; var pcchPathBuf: DWORD): UINT; stdcall;
992
{$EXTERNALSYM MsiGetTargetPathW}
993
function MsiGetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR;
994
szPathBuf: LPTSTR; var pcchPathBuf: DWORD): UINT; stdcall;
995
{$EXTERNALSYM MsiGetTargetPath}
997
// Set the full target path for a folder in the Directory table
998
// Execution of this function sets the error record, accessible via MsiGetLastErrorRecord
1000
function MsiSetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR;
1001
szFolderPath: LPCSTR): UINT; stdcall;
1002
{$EXTERNALSYM MsiSetTargetPathA}
1003
function MsiSetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR;
1004
szFolderPath: LPCWSTR): UINT; stdcall;
1005
{$EXTERNALSYM MsiSetTargetPathW}
1006
function MsiSetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR;
1007
szFolderPath: LPCTSTR): UINT; stdcall;
1008
{$EXTERNALSYM MsiSetTargetPath}
1010
// Check to see if sufficent disk space is present for the current installation
1011
// Returns ERROR_SUCCESS, ERROR_DISK_FULL, ERROR_INVALID_HANDLE_STATE, or ERROR_INVALID_HANDLE
1013
function MsiVerifyDiskSpace(hInstall: MSIHANDLE): UINT; stdcall;
1014
{$EXTERNALSYM MsiVerifyDiskSpace}
1016
// --------------------------------------------------------------------------
1017
// Functions for rendering UI dialogs from the database representations.
1018
// Purpose is for product development, not for use during installation.
1019
// --------------------------------------------------------------------------
1021
// Enable UI in preview mode to facilitate authoring of UI dialogs.
1022
// The preview mode will end when the handle is closed.
1024
function MsiEnableUIPreview(hDatabase: MSIHANDLE; var phPreview: MSIHANDLE): UINT; stdcall;
1025
{$EXTERNALSYM MsiEnableUIPreview}
1027
// Display any UI dialog as modeless and inactive.
1028
// Supplying a null name will remove any current dialog.
1030
function MsiPreviewDialogA(hPreview: MSIHANDLE; szDialogName: LPCSTR): UINT; stdcall;
1031
{$EXTERNALSYM MsiPreviewDialogA}
1032
function MsiPreviewDialogW(hPreview: MSIHANDLE; szDialogName: LPCWSTR): UINT; stdcall;
1033
{$EXTERNALSYM MsiPreviewDialogW}
1034
function MsiPreviewDialog(hPreview: MSIHANDLE; szDialogName: LPCTSTR): UINT; stdcall;
1035
{$EXTERNALSYM MsiPreviewDialog}
1037
// Display a billboard within a host control in the displayed dialog.
1038
// Supplying a null billboard name will remove any billboard displayed.
1040
function MsiPreviewBillboardA(hPreview: MSIHANDLE; szControlName: LPCSTR;
1041
szBillboard: LPCSTR): UINT; stdcall;
1042
{$EXTERNALSYM MsiPreviewBillboardA}
1043
function MsiPreviewBillboardW(hPreview: MSIHANDLE; szControlName: LPCWSTR;
1044
szBillboard: LPCWSTR): UINT; stdcall;
1045
{$EXTERNALSYM MsiPreviewBillboardW}
1046
function MsiPreviewBillboard(hPreview: MSIHANDLE; szControlName: LPCTSTR;
1047
szBillboard: LPCTSTR): UINT; stdcall;
1048
{$EXTERNALSYM MsiPreviewBillboard}
1050
// --------------------------------------------------------------------------
1051
// Error handling not associated with any particular object
1052
// --------------------------------------------------------------------------
1054
// Return a record handle to the last function that generated an error record
1055
// Only specified functions will set the error record, or clear it if success
1056
// Field 1 of the record will contain the internal MSI error code
1057
// Other fields will contain data specific to the particular error
1058
// The error record is released internally after this function is executed
1060
function MsiGetLastErrorRecord: MSIHANDLE; stdcall;
1061
{$EXTERNALSYM MsiGetLastErrorRecord}
1068
{$IFDEF DYNAMIC_LINK}
1071
_MsiDatabaseOpenViewA: Pointer;
1073
function MsiDatabaseOpenViewA;
1075
GetProcedureAddress(_MsiDatabaseOpenViewA, msilib, 'MsiDatabaseOpenViewA');
1079
JMP [_MsiDatabaseOpenViewA]
1084
_MsiDatabaseOpenViewW: Pointer;
1086
function MsiDatabaseOpenViewW;
1088
GetProcedureAddress(_MsiDatabaseOpenViewW, msilib, 'MsiDatabaseOpenViewW');
1092
JMP [_MsiDatabaseOpenViewW]
1097
_MsiDatabaseOpenView: Pointer;
1099
function MsiDatabaseOpenView;
1101
GetProcedureAddress(_MsiDatabaseOpenView, msilib, 'MsiDatabaseOpenView' + AWSuffix);
1105
JMP [_MsiDatabaseOpenView]
1110
_MsiViewGetErrorA: Pointer;
1112
function MsiViewGetErrorA;
1114
GetProcedureAddress(_MsiViewGetErrorA, msilib, 'MsiViewGetErrorA');
1118
JMP [_MsiViewGetErrorA]
1123
_MsiViewGetErrorW: Pointer;
1125
function MsiViewGetErrorW;
1127
GetProcedureAddress(_MsiViewGetErrorW, msilib, 'MsiViewGetErrorW');
1131
JMP [_MsiViewGetErrorW]
1136
_MsiViewGetError: Pointer;
1138
function MsiViewGetError;
1140
GetProcedureAddress(_MsiViewGetError, msilib, 'MsiViewGetError' + AWSuffix);
1144
JMP [_MsiViewGetError]
1149
_MsiViewExecute: Pointer;
1151
function MsiViewExecute;
1153
GetProcedureAddress(_MsiViewExecute, msilib, 'MsiViewExecute');
1157
JMP [_MsiViewExecute]
1162
_MsiViewFetch: Pointer;
1164
function MsiViewFetch;
1166
GetProcedureAddress(_MsiViewFetch, msilib, 'MsiViewFetch');
1175
_MsiViewModify: Pointer;
1177
function MsiViewModify;
1179
GetProcedureAddress(_MsiViewModify, msilib, 'MsiViewModify');
1183
JMP [_MsiViewModify]
1188
_MsiViewGetColumnInfo: Pointer;
1190
function MsiViewGetColumnInfo;
1192
GetProcedureAddress(_MsiViewGetColumnInfo, msilib, 'MsiViewGetColumnInfo');
1196
JMP [_MsiViewGetColumnInfo]
1201
_MsiViewClose: Pointer;
1203
function MsiViewClose;
1205
GetProcedureAddress(_MsiViewClose, msilib, 'MsiViewClose');
1214
_MsiDatabaseGetPrimaryKeysA: Pointer;
1216
function MsiDatabaseGetPrimaryKeysA;
1218
GetProcedureAddress(_MsiDatabaseGetPrimaryKeysA, msilib, 'MsiDatabaseGetPrimaryKeysA');
1222
JMP [_MsiDatabaseGetPrimaryKeysA]
1227
_MsiDatabaseGetPrimaryKeysW: Pointer;
1229
function MsiDatabaseGetPrimaryKeysW;
1231
GetProcedureAddress(_MsiDatabaseGetPrimaryKeysW, msilib, 'MsiDatabaseGetPrimaryKeysW');
1235
JMP [_MsiDatabaseGetPrimaryKeysW]
1240
_MsiDatabaseGetPrimaryKeys: Pointer;
1242
function MsiDatabaseGetPrimaryKeys;
1244
GetProcedureAddress(_MsiDatabaseGetPrimaryKeys, msilib, 'MsiDatabaseGetPrimaryKeys' + AWSuffix);
1248
JMP [_MsiDatabaseGetPrimaryKeys]
1253
_MsiDatabaseIsTablePersistentA: Pointer;
1255
function MsiDatabaseIsTablePersistentA;
1257
GetProcedureAddress(_MsiDatabaseIsTablePersistentA, msilib, 'MsiDatabaseIsTablePersistentA');
1261
JMP [_MsiDatabaseIsTablePersistentA]
1266
_MsiDatabaseIsTablePersistentW: Pointer;
1268
function MsiDatabaseIsTablePersistentW;
1270
GetProcedureAddress(_MsiDatabaseIsTablePersistentW, msilib, 'MsiDatabaseIsTablePersistentW');
1274
JMP [_MsiDatabaseIsTablePersistentW]
1279
_MsiDatabaseIsTablePersistent: Pointer;
1281
function MsiDatabaseIsTablePersistent;
1283
GetProcedureAddress(_MsiDatabaseIsTablePersistent, msilib, 'MsiDatabaseIsTablePersistent' + AWSuffix);
1287
JMP [_MsiDatabaseIsTablePersistent]
1292
_MsiGetSummaryInformationA: Pointer;
1294
function MsiGetSummaryInformationA;
1296
GetProcedureAddress(_MsiGetSummaryInformationA, msilib, 'MsiGetSummaryInformationA');
1300
JMP [_MsiGetSummaryInformationA]
1305
_MsiGetSummaryInformationW: Pointer;
1307
function MsiGetSummaryInformationW;
1309
GetProcedureAddress(_MsiGetSummaryInformationW, msilib, 'MsiGetSummaryInformationW');
1313
JMP [_MsiGetSummaryInformationW]
1318
_MsiGetSummaryInformation: Pointer;
1320
function MsiGetSummaryInformation;
1322
GetProcedureAddress(_MsiGetSummaryInformation, msilib, 'MsiGetSummaryInformation' + AWSuffix);
1326
JMP [_MsiGetSummaryInformation]
1331
_MsiSummaryInfoGetPropertyCount: Pointer;
1333
function MsiSummaryInfoGetPropertyCount;
1335
GetProcedureAddress(_MsiSummaryInfoGetPropertyCount, msilib, 'MsiSummaryInfoGetPropertyCount');
1339
JMP [_MsiSummaryInfoGetPropertyCount]
1344
_MsiSummaryInfoSetPropertyA: Pointer;
1346
function MsiSummaryInfoSetPropertyA;
1348
GetProcedureAddress(_MsiSummaryInfoSetPropertyA, msilib, 'MsiSummaryInfoSetPropertyA');
1352
JMP [_MsiSummaryInfoSetPropertyA]
1357
_MsiSummaryInfoSetPropertyW: Pointer;
1359
function MsiSummaryInfoSetPropertyW;
1361
GetProcedureAddress(_MsiSummaryInfoSetPropertyW, msilib, 'MsiSummaryInfoSetPropertyW');
1365
JMP [_MsiSummaryInfoSetPropertyW]
1370
_MsiSummaryInfoSetProperty: Pointer;
1372
function MsiSummaryInfoSetProperty;
1374
GetProcedureAddress(_MsiSummaryInfoSetProperty, msilib, 'MsiSummaryInfoSetProperty' + AWSuffix);
1378
JMP [_MsiSummaryInfoSetProperty]
1383
_MsiSummaryInfoGetPropertyA: Pointer;
1385
function MsiSummaryInfoGetPropertyA;
1387
GetProcedureAddress(_MsiSummaryInfoGetPropertyA, msilib, 'MsiSummaryInfoGetPropertyA');
1391
JMP [_MsiSummaryInfoGetPropertyA]
1396
_MsiSummaryInfoGetPropertyW: Pointer;
1398
function MsiSummaryInfoGetPropertyW;
1400
GetProcedureAddress(_MsiSummaryInfoGetPropertyW, msilib, 'MsiSummaryInfoGetPropertyW');
1404
JMP [_MsiSummaryInfoGetPropertyW]
1409
_MsiSummaryInfoGetProperty: Pointer;
1411
function MsiSummaryInfoGetProperty;
1413
GetProcedureAddress(_MsiSummaryInfoGetProperty, msilib, 'MsiSummaryInfoGetProperty' + AWSuffix);
1417
JMP [_MsiSummaryInfoGetProperty]
1422
_MsiSummaryInfoPersist: Pointer;
1424
function MsiSummaryInfoPersist;
1426
GetProcedureAddress(_MsiSummaryInfoPersist, msilib, 'MsiSummaryInfoPersist');
1430
JMP [_MsiSummaryInfoPersist]
1435
_MsiOpenDatabaseA: Pointer;
1437
function MsiOpenDatabaseA;
1439
GetProcedureAddress(_MsiOpenDatabaseA, msilib, 'MsiOpenDatabaseA');
1443
JMP [_MsiOpenDatabaseA]
1448
_MsiOpenDatabaseW: Pointer;
1450
function MsiOpenDatabaseW;
1452
GetProcedureAddress(_MsiOpenDatabaseW, msilib, 'MsiOpenDatabaseW');
1456
JMP [_MsiOpenDatabaseW]
1461
_MsiOpenDatabase: Pointer;
1463
function MsiOpenDatabase;
1465
GetProcedureAddress(_MsiOpenDatabase, msilib, 'MsiOpenDatabase' + AWSuffix);
1469
JMP [_MsiOpenDatabase]
1474
_MsiDatabaseImportA: Pointer;
1476
function MsiDatabaseImportA;
1478
GetProcedureAddress(_MsiDatabaseImportA, msilib, 'MsiDatabaseImportA');
1482
JMP [_MsiDatabaseImportA]
1487
_MsiDatabaseImportW: Pointer;
1489
function MsiDatabaseImportW;
1491
GetProcedureAddress(_MsiDatabaseImportW, msilib, 'MsiDatabaseImportW');
1495
JMP [_MsiDatabaseImportW]
1500
_MsiDatabaseImport: Pointer;
1502
function MsiDatabaseImport;
1504
GetProcedureAddress(_MsiDatabaseImport, msilib, 'MsiDatabaseImport' + AWSuffix);
1508
JMP [_MsiDatabaseImport]
1513
_MsiDatabaseExportA: Pointer;
1515
function MsiDatabaseExportA;
1517
GetProcedureAddress(_MsiDatabaseExportA, msilib, 'MsiDatabaseExportA');
1521
JMP [_MsiDatabaseExportA]
1526
_MsiDatabaseExportW: Pointer;
1528
function MsiDatabaseExportW;
1530
GetProcedureAddress(_MsiDatabaseExportW, msilib, 'MsiDatabaseExportW');
1534
JMP [_MsiDatabaseExportW]
1539
_MsiDatabaseExport: Pointer;
1541
function MsiDatabaseExport;
1543
GetProcedureAddress(_MsiDatabaseExport, msilib, 'MsiDatabaseExport' + AWSuffix);
1547
JMP [_MsiDatabaseExport]
1552
_MsiDatabaseMergeA: Pointer;
1554
function MsiDatabaseMergeA;
1556
GetProcedureAddress(_MsiDatabaseMergeA, msilib, 'MsiDatabaseMergeA');
1560
JMP [_MsiDatabaseMergeA]
1565
_MsiDatabaseMergeW: Pointer;
1567
function MsiDatabaseMergeW;
1569
GetProcedureAddress(_MsiDatabaseMergeW, msilib, 'MsiDatabaseMergeW');
1573
JMP [_MsiDatabaseMergeW]
1578
_MsiDatabaseMerge: Pointer;
1580
function MsiDatabaseMerge;
1582
GetProcedureAddress(_MsiDatabaseMerge, msilib, 'MsiDatabaseMerge' + AWSuffix);
1586
JMP [_MsiDatabaseMerge]
1591
_MsiDatabaseGenerateTransformA: Pointer;
1593
function MsiDatabaseGenerateTransformA;
1595
GetProcedureAddress(_MsiDatabaseGenerateTransformA, msilib, 'MsiDatabaseGenerateTransformA');
1599
JMP [_MsiDatabaseGenerateTransformA]
1604
_MsiDatabaseGenerateTransformW: Pointer;
1606
function MsiDatabaseGenerateTransformW;
1608
GetProcedureAddress(_MsiDatabaseGenerateTransformW, msilib, 'MsiDatabaseGenerateTransformW');
1612
JMP [_MsiDatabaseGenerateTransformW]
1617
_MsiDatabaseGenerateTransform: Pointer;
1619
function MsiDatabaseGenerateTransform;
1621
GetProcedureAddress(_MsiDatabaseGenerateTransform, msilib, 'MsiDatabaseGenerateTransform' + AWSuffix);
1625
JMP [_MsiDatabaseGenerateTransform]
1630
_MsiDatabaseApplyTransformA: Pointer;
1632
function MsiDatabaseApplyTransformA;
1634
GetProcedureAddress(_MsiDatabaseApplyTransformA, msilib, 'MsiDatabaseApplyTransformA');
1638
JMP [_MsiDatabaseApplyTransformA]
1643
_MsiDatabaseApplyTransformW: Pointer;
1645
function MsiDatabaseApplyTransformW;
1647
GetProcedureAddress(_MsiDatabaseApplyTransformW, msilib, 'MsiDatabaseApplyTransformW');
1651
JMP [_MsiDatabaseApplyTransformW]
1656
_MsiDatabaseApplyTransform: Pointer;
1658
function MsiDatabaseApplyTransform;
1660
GetProcedureAddress(_MsiDatabaseApplyTransform, msilib, 'MsiDatabaseApplyTransform' + AWSuffix);
1664
JMP [_MsiDatabaseApplyTransform]
1669
_MsiCreateTransformSummaryInfoA: Pointer;
1671
function MsiCreateTransformSummaryInfoA;
1673
GetProcedureAddress(_MsiCreateTransformSummaryInfoA, msilib, 'MsiCreateTransformSummaryInfoA');
1677
JMP [_MsiCreateTransformSummaryInfoA]
1682
_MsiCreateTransformSummaryInfoW: Pointer;
1684
function MsiCreateTransformSummaryInfoW;
1686
GetProcedureAddress(_MsiCreateTransformSummaryInfoW, msilib, 'MsiCreateTransformSummaryInfoW');
1690
JMP [_MsiCreateTransformSummaryInfoW]
1695
_MsiCreateTransformSummaryInfo: Pointer;
1697
function MsiCreateTransformSummaryInfo;
1699
GetProcedureAddress(_MsiCreateTransformSummaryInfo, msilib, 'MsiCreateTransformSummaryInfo' + AWSuffix);
1703
JMP [_MsiCreateTransformSummaryInfo]
1708
_MsiDatabaseCommit: Pointer;
1710
function MsiDatabaseCommit;
1712
GetProcedureAddress(_MsiDatabaseCommit, msilib, 'MsiDatabaseCommit');
1716
JMP [_MsiDatabaseCommit]
1721
_MsiGetDatabaseState: Pointer;
1723
function MsiGetDatabaseState;
1725
GetProcedureAddress(_MsiGetDatabaseState, msilib, 'MsiGetDatabaseState');
1729
JMP [_MsiGetDatabaseState]
1734
_MsiCreateRecord: Pointer;
1736
function MsiCreateRecord;
1738
GetProcedureAddress(_MsiCreateRecord, msilib, 'MsiCreateRecord');
1742
JMP [_MsiCreateRecord]
1747
_MsiRecordIsNull: Pointer;
1749
function MsiRecordIsNull;
1751
GetProcedureAddress(_MsiRecordIsNull, msilib, 'MsiRecordIsNull');
1755
JMP [_MsiRecordIsNull]
1760
_MsiRecordDataSize: Pointer;
1762
function MsiRecordDataSize;
1764
GetProcedureAddress(_MsiRecordDataSize, msilib, 'MsiRecordDataSize');
1768
JMP [_MsiRecordDataSize]
1773
_MsiRecordSetInteger: Pointer;
1775
function MsiRecordSetInteger;
1777
GetProcedureAddress(_MsiRecordSetInteger, msilib, 'MsiRecordSetInteger');
1781
JMP [_MsiRecordSetInteger]
1786
_MsiRecordSetStringA: Pointer;
1788
function MsiRecordSetStringA;
1790
GetProcedureAddress(_MsiRecordSetStringA, msilib, 'MsiRecordSetStringA');
1794
JMP [_MsiRecordSetStringA]
1799
_MsiRecordSetStringW: Pointer;
1801
function MsiRecordSetStringW;
1803
GetProcedureAddress(_MsiRecordSetStringW, msilib, 'MsiRecordSetStringW');
1807
JMP [_MsiRecordSetStringW]
1812
_MsiRecordSetString: Pointer;
1814
function MsiRecordSetString;
1816
GetProcedureAddress(_MsiRecordSetString, msilib, 'MsiRecordSetString' + AWSuffix);
1820
JMP [_MsiRecordSetString]
1825
_MsiRecordGetInteger: Pointer;
1827
function MsiRecordGetInteger;
1829
GetProcedureAddress(_MsiRecordGetInteger, msilib, 'MsiRecordGetInteger');
1833
JMP [_MsiRecordGetInteger]
1838
_MsiRecordGetStringA: Pointer;
1840
function MsiRecordGetStringA;
1842
GetProcedureAddress(_MsiRecordGetStringA, msilib, 'MsiRecordGetStringA');
1846
JMP [_MsiRecordGetStringA]
1851
_MsiRecordGetStringW: Pointer;
1853
function MsiRecordGetStringW;
1855
GetProcedureAddress(_MsiRecordGetStringW, msilib, 'MsiRecordGetStringW');
1859
JMP [_MsiRecordGetStringW]
1864
_MsiRecordGetString: Pointer;
1866
function MsiRecordGetString;
1868
GetProcedureAddress(_MsiRecordGetString, msilib, 'MsiRecordGetString' + AWSuffix);
1872
JMP [_MsiRecordGetString]
1877
_MsiRecordGetFieldCount: Pointer;
1879
function MsiRecordGetFieldCount;
1881
GetProcedureAddress(_MsiRecordGetFieldCount, msilib, 'MsiRecordGetFieldCount');
1885
JMP [_MsiRecordGetFieldCount]
1890
_MsiRecordSetStreamA: Pointer;
1892
function MsiRecordSetStreamA;
1894
GetProcedureAddress(_MsiRecordSetStreamA, msilib, 'MsiRecordSetStreamA');
1898
JMP [_MsiRecordSetStreamA]
1903
_MsiRecordSetStreamW: Pointer;
1905
function MsiRecordSetStreamW;
1907
GetProcedureAddress(_MsiRecordSetStreamW, msilib, 'MsiRecordSetStreamW');
1911
JMP [_MsiRecordSetStreamW]
1916
_MsiRecordSetStream: Pointer;
1918
function MsiRecordSetStream;
1920
GetProcedureAddress(_MsiRecordSetStream, msilib, 'MsiRecordSetStream' + AWSuffix);
1924
JMP [_MsiRecordSetStream]
1929
_MsiRecordReadStream: Pointer;
1931
function MsiRecordReadStream;
1933
GetProcedureAddress(_MsiRecordReadStream, msilib, 'MsiRecordReadStream');
1937
JMP [_MsiRecordReadStream]
1942
_MsiRecordClearData: Pointer;
1944
function MsiRecordClearData;
1946
GetProcedureAddress(_MsiRecordClearData, msilib, 'MsiRecordClearData');
1950
JMP [_MsiRecordClearData]
1955
_MsiGetActiveDatabase: Pointer;
1957
function MsiGetActiveDatabase;
1959
GetProcedureAddress(_MsiGetActiveDatabase, msilib, 'MsiGetActiveDatabase');
1963
JMP [_MsiGetActiveDatabase]
1968
_MsiSetPropertyA: Pointer;
1970
function MsiSetPropertyA;
1972
GetProcedureAddress(_MsiSetPropertyA, msilib, 'MsiSetPropertyA');
1976
JMP [_MsiSetPropertyA]
1981
_MsiSetPropertyW: Pointer;
1983
function MsiSetPropertyW;
1985
GetProcedureAddress(_MsiSetPropertyW, msilib, 'MsiSetPropertyW');
1989
JMP [_MsiSetPropertyW]
1994
_MsiSetProperty: Pointer;
1996
function MsiSetProperty;
1998
GetProcedureAddress(_MsiSetProperty, msilib, 'MsiSetProperty' + AWSuffix);
2002
JMP [_MsiSetProperty]
2007
_MsiGetPropertyA: Pointer;
2009
function MsiGetPropertyA;
2011
GetProcedureAddress(_MsiGetPropertyA, msilib, 'MsiGetPropertyA');
2015
JMP [_MsiGetPropertyA]
2020
_MsiGetPropertyW: Pointer;
2022
function MsiGetPropertyW;
2024
GetProcedureAddress(_MsiGetPropertyW, msilib, 'MsiGetPropertyW');
2028
JMP [_MsiGetPropertyW]
2033
_MsiGetProperty: Pointer;
2035
function MsiGetProperty;
2037
GetProcedureAddress(_MsiGetProperty, msilib, 'MsiGetProperty' + AWSuffix);
2041
JMP [_MsiGetProperty]
2046
_MsiGetLanguage: Pointer;
2048
function MsiGetLanguage;
2050
GetProcedureAddress(_MsiGetLanguage, msilib, 'MsiGetLanguage');
2054
JMP [_MsiGetLanguage]
2059
_MsiGetMode: Pointer;
2061
function MsiGetMode;
2063
GetProcedureAddress(_MsiGetMode, msilib, 'MsiGetMode');
2072
_MsiSetMode: Pointer;
2074
function MsiSetMode;
2076
GetProcedureAddress(_MsiSetMode, msilib, 'MsiSetMode');
2085
_MsiFormatRecordA: Pointer;
2087
function MsiFormatRecordA;
2089
GetProcedureAddress(_MsiFormatRecordA, msilib, 'MsiFormatRecordA');
2093
JMP [_MsiFormatRecordA]
2098
_MsiFormatRecordW: Pointer;
2100
function MsiFormatRecordW;
2102
GetProcedureAddress(_MsiFormatRecordW, msilib, 'MsiFormatRecordW');
2106
JMP [_MsiFormatRecordW]
2111
_MsiFormatRecord: Pointer;
2113
function MsiFormatRecord;
2115
GetProcedureAddress(_MsiFormatRecord, msilib, 'MsiFormatRecord' + AWSuffix);
2119
JMP [_MsiFormatRecord]
2124
_MsiDoActionA: Pointer;
2126
function MsiDoActionA;
2128
GetProcedureAddress(_MsiDoActionA, msilib, 'MsiDoActionA');
2137
_MsiDoActionW: Pointer;
2139
function MsiDoActionW;
2141
GetProcedureAddress(_MsiDoActionW, msilib, 'MsiDoActionW');
2150
_MsiDoAction: Pointer;
2152
function MsiDoAction;
2154
GetProcedureAddress(_MsiDoAction, msilib, 'MsiDoAction' + AWSuffix);
2163
_MsiSequenceA: Pointer;
2165
function MsiSequenceA;
2167
GetProcedureAddress(_MsiSequenceA, msilib, 'MsiSequenceA');
2176
_MsiSequenceW: Pointer;
2178
function MsiSequenceW;
2180
GetProcedureAddress(_MsiSequenceW, msilib, 'MsiSequenceW');
2189
_MsiSequence: Pointer;
2191
function MsiSequence;
2193
GetProcedureAddress(_MsiSequence, msilib, 'MsiSequence' + AWSuffix);
2202
_MsiProcessMessage: Pointer;
2204
function MsiProcessMessage;
2206
GetProcedureAddress(_MsiProcessMessage, msilib, 'MsiProcessMessage');
2210
JMP [_MsiProcessMessage]
2215
_MsiEvaluateConditionA: Pointer;
2217
function MsiEvaluateConditionA;
2219
GetProcedureAddress(_MsiEvaluateConditionA, msilib, 'MsiEvaluateConditionA');
2223
JMP [_MsiEvaluateConditionA]
2228
_MsiEvaluateConditionW: Pointer;
2230
function MsiEvaluateConditionW;
2232
GetProcedureAddress(_MsiEvaluateConditionW, msilib, 'MsiEvaluateConditionW');
2236
JMP [_MsiEvaluateConditionW]
2241
_MsiEvaluateCondition: Pointer;
2243
function MsiEvaluateCondition;
2245
GetProcedureAddress(_MsiEvaluateCondition, msilib, 'MsiEvaluateCondition' + AWSuffix);
2249
JMP [_MsiEvaluateCondition]
2254
_MsiGetFeatureStateA: Pointer;
2256
function MsiGetFeatureStateA;
2258
GetProcedureAddress(_MsiGetFeatureStateA, msilib, 'MsiGetFeatureStateA');
2262
JMP [_MsiGetFeatureStateA]
2267
_MsiGetFeatureStateW: Pointer;
2269
function MsiGetFeatureStateW;
2271
GetProcedureAddress(_MsiGetFeatureStateW, msilib, 'MsiGetFeatureStateW');
2275
JMP [_MsiGetFeatureStateW]
2280
_MsiGetFeatureState: Pointer;
2282
function MsiGetFeatureState;
2284
GetProcedureAddress(_MsiGetFeatureState, msilib, 'MsiGetFeatureState' + AWSuffix);
2288
JMP [_MsiGetFeatureState]
2293
_MsiSetFeatureStateA: Pointer;
2295
function MsiSetFeatureStateA;
2297
GetProcedureAddress(_MsiSetFeatureStateA, msilib, 'MsiSetFeatureStateA');
2301
JMP [_MsiSetFeatureStateA]
2306
_MsiSetFeatureStateW: Pointer;
2308
function MsiSetFeatureStateW;
2310
GetProcedureAddress(_MsiSetFeatureStateW, msilib, 'MsiSetFeatureStateW');
2314
JMP [_MsiSetFeatureStateW]
2319
_MsiSetFeatureState: Pointer;
2321
function MsiSetFeatureState;
2323
GetProcedureAddress(_MsiSetFeatureState, msilib, 'MsiSetFeatureState' + AWSuffix);
2327
JMP [_MsiSetFeatureState]
2332
_MsiSetFeatureAttributesA: Pointer;
2334
function MsiSetFeatureAttributesA;
2336
GetProcedureAddress(_MsiSetFeatureAttributesA, msilib, 'MsiSetFeatureAttributesA');
2340
JMP [_MsiSetFeatureAttributesA]
2345
_MsiSetFeatureAttributesW: Pointer;
2347
function MsiSetFeatureAttributesW;
2349
GetProcedureAddress(_MsiSetFeatureAttributesW, msilib, 'MsiSetFeatureAttributesW');
2353
JMP [_MsiSetFeatureAttributesW]
2358
_MsiSetFeatureAttributes: Pointer;
2360
function MsiSetFeatureAttributes;
2362
GetProcedureAddress(_MsiSetFeatureAttributes, msilib, 'MsiSetFeatureAttributes' + AWSuffix);
2366
JMP [_MsiSetFeatureAttributes]
2371
_MsiGetComponentStateA: Pointer;
2373
function MsiGetComponentStateA;
2375
GetProcedureAddress(_MsiGetComponentStateA, msilib, 'MsiGetComponentStateA');
2379
JMP [_MsiGetComponentStateA]
2384
_MsiGetComponentStateW: Pointer;
2386
function MsiGetComponentStateW;
2388
GetProcedureAddress(_MsiGetComponentStateW, msilib, 'MsiGetComponentStateW');
2392
JMP [_MsiGetComponentStateW]
2397
_MsiGetComponentState: Pointer;
2399
function MsiGetComponentState;
2401
GetProcedureAddress(_MsiGetComponentState, msilib, 'MsiGetComponentState' + AWSuffix);
2405
JMP [_MsiGetComponentState]
2410
_MsiSetComponentStateA: Pointer;
2412
function MsiSetComponentStateA;
2414
GetProcedureAddress(_MsiSetComponentStateA, msilib, 'MsiSetComponentStateA');
2418
JMP [_MsiSetComponentStateA]
2423
_MsiSetComponentStateW: Pointer;
2425
function MsiSetComponentStateW;
2427
GetProcedureAddress(_MsiSetComponentStateW, msilib, 'MsiSetComponentStateW');
2431
JMP [_MsiSetComponentStateW]
2436
_MsiSetComponentState: Pointer;
2438
function MsiSetComponentState;
2440
GetProcedureAddress(_MsiSetComponentState, msilib, 'MsiSetComponentState' + AWSuffix);
2444
JMP [_MsiSetComponentState]
2449
_MsiGetFeatureCostA: Pointer;
2451
function MsiGetFeatureCostA;
2453
GetProcedureAddress(_MsiGetFeatureCostA, msilib, 'MsiGetFeatureCostA');
2457
JMP [_MsiGetFeatureCostA]
2462
_MsiGetFeatureCostW: Pointer;
2464
function MsiGetFeatureCostW;
2466
GetProcedureAddress(_MsiGetFeatureCostW, msilib, 'MsiGetFeatureCostW');
2470
JMP [_MsiGetFeatureCostW]
2475
_MsiGetFeatureCost: Pointer;
2477
function MsiGetFeatureCost;
2479
GetProcedureAddress(_MsiGetFeatureCost, msilib, 'MsiGetFeatureCost' + AWSuffix);
2483
JMP [_MsiGetFeatureCost]
2488
_MsiEnumComponentCostsA: Pointer;
2490
function MsiEnumComponentCostsA;
2492
GetProcedureAddress(_MsiEnumComponentCostsA, msilib, 'MsiEnumComponentCostsA');
2496
JMP [_MsiEnumComponentCostsA]
2501
_MsiEnumComponentCostsW: Pointer;
2503
function MsiEnumComponentCostsW;
2505
GetProcedureAddress(_MsiEnumComponentCostsW, msilib, 'MsiEnumComponentCostsW');
2509
JMP [_MsiEnumComponentCostsW]
2514
_MsiEnumComponentCosts: Pointer;
2516
function MsiEnumComponentCosts;
2518
GetProcedureAddress(_MsiEnumComponentCosts, msilib, 'MsiEnumComponentCosts' + AWSuffix);
2522
JMP [_MsiEnumComponentCosts]
2527
_MsiSetInstallLevel: Pointer;
2529
function MsiSetInstallLevel;
2531
GetProcedureAddress(_MsiSetInstallLevel, msilib, 'MsiSetInstallLevel');
2535
JMP [_MsiSetInstallLevel]
2540
_MsiGetFeatureValidStatesA: Pointer;
2542
function MsiGetFeatureValidStatesA;
2544
GetProcedureAddress(_MsiGetFeatureValidStatesA, msilib, 'MsiGetFeatureValidStatesA');
2548
JMP [_MsiGetFeatureValidStatesA]
2553
_MsiGetFeatureValidStatesW: Pointer;
2555
function MsiGetFeatureValidStatesW;
2557
GetProcedureAddress(_MsiGetFeatureValidStatesW, msilib, 'MsiGetFeatureValidStatesW');
2561
JMP [_MsiGetFeatureValidStatesW]
2566
_MsiGetFeatureValidStates: Pointer;
2568
function MsiGetFeatureValidStates;
2570
GetProcedureAddress(_MsiGetFeatureValidStates, msilib, 'MsiGetFeatureValidStates' + AWSuffix);
2574
JMP [_MsiGetFeatureValidStates]
2579
_MsiGetSourcePathA: Pointer;
2581
function MsiGetSourcePathA;
2583
GetProcedureAddress(_MsiGetSourcePathA, msilib, 'MsiGetSourcePathA');
2587
JMP [_MsiGetSourcePathA]
2592
_MsiGetSourcePathW: Pointer;
2594
function MsiGetSourcePathW;
2596
GetProcedureAddress(_MsiGetSourcePathW, msilib, 'MsiGetSourcePathW');
2600
JMP [_MsiGetSourcePathW]
2605
_MsiGetSourcePath: Pointer;
2607
function MsiGetSourcePath;
2609
GetProcedureAddress(_MsiGetSourcePath, msilib, 'MsiGetSourcePath' + AWSuffix);
2613
JMP [_MsiGetSourcePath]
2618
_MsiGetTargetPathA: Pointer;
2620
function MsiGetTargetPathA;
2622
GetProcedureAddress(_MsiGetTargetPathA, msilib, 'MsiGetTargetPathA');
2626
JMP [_MsiGetTargetPathA]
2631
_MsiGetTargetPathW: Pointer;
2633
function MsiGetTargetPathW;
2635
GetProcedureAddress(_MsiGetTargetPathW, msilib, 'MsiGetTargetPathW');
2639
JMP [_MsiGetTargetPathW]
2644
_MsiGetTargetPath: Pointer;
2646
function MsiGetTargetPath;
2648
GetProcedureAddress(_MsiGetTargetPath, msilib, 'MsiGetTargetPath' + AWSuffix);
2652
JMP [_MsiGetTargetPath]
2657
_MsiSetTargetPathA: Pointer;
2659
function MsiSetTargetPathA;
2661
GetProcedureAddress(_MsiSetTargetPathA, msilib, 'MsiSetTargetPathA');
2665
JMP [_MsiSetTargetPathA]
2670
_MsiSetTargetPathW: Pointer;
2672
function MsiSetTargetPathW;
2674
GetProcedureAddress(_MsiSetTargetPathW, msilib, 'MsiSetTargetPathW');
2678
JMP [_MsiSetTargetPathW]
2683
_MsiSetTargetPath: Pointer;
2685
function MsiSetTargetPath;
2687
GetProcedureAddress(_MsiSetTargetPath, msilib, 'MsiSetTargetPath' + AWSuffix);
2691
JMP [_MsiSetTargetPath]
2696
_MsiVerifyDiskSpace: Pointer;
2698
function MsiVerifyDiskSpace;
2700
GetProcedureAddress(_MsiVerifyDiskSpace, msilib, 'MsiVerifyDiskSpace');
2704
JMP [_MsiVerifyDiskSpace]
2709
_MsiEnableUIPreview: Pointer;
2711
function MsiEnableUIPreview;
2713
GetProcedureAddress(_MsiEnableUIPreview, msilib, 'MsiEnableUIPreview');
2717
JMP [_MsiEnableUIPreview]
2722
_MsiPreviewDialogA: Pointer;
2724
function MsiPreviewDialogA;
2726
GetProcedureAddress(_MsiPreviewDialogA, msilib, 'MsiPreviewDialogA');
2730
JMP [_MsiPreviewDialogA]
2735
_MsiPreviewDialogW: Pointer;
2737
function MsiPreviewDialogW;
2739
GetProcedureAddress(_MsiPreviewDialogW, msilib, 'MsiPreviewDialogW');
2743
JMP [_MsiPreviewDialogW]
2748
_MsiPreviewDialog: Pointer;
2750
function MsiPreviewDialog;
2752
GetProcedureAddress(_MsiPreviewDialog, msilib, 'MsiPreviewDialog' + AWSuffix);
2756
JMP [_MsiPreviewDialog]
2761
_MsiPreviewBillboardA: Pointer;
2763
function MsiPreviewBillboardA;
2765
GetProcedureAddress(_MsiPreviewBillboardA, msilib, 'MsiPreviewBillboardA');
2769
JMP [_MsiPreviewBillboardA]
2774
_MsiPreviewBillboardW: Pointer;
2776
function MsiPreviewBillboardW;
2778
GetProcedureAddress(_MsiPreviewBillboardW, msilib, 'MsiPreviewBillboardW');
2782
JMP [_MsiPreviewBillboardW]
2787
_MsiPreviewBillboard: Pointer;
2789
function MsiPreviewBillboard;
2791
GetProcedureAddress(_MsiPreviewBillboard, msilib, 'MsiPreviewBillboard' + AWSuffix);
2795
JMP [_MsiPreviewBillboard]
2800
_MsiGetLastErrorRecord: Pointer;
2802
function MsiGetLastErrorRecord;
2804
GetProcedureAddress(_MsiGetLastErrorRecord, msilib, 'MsiGetLastErrorRecord');
2808
JMP [_MsiGetLastErrorRecord]
2814
function MsiDatabaseOpenViewA; external msilib name 'MsiDatabaseOpenViewA';
2815
function MsiDatabaseOpenViewW; external msilib name 'MsiDatabaseOpenViewW';
2816
function MsiDatabaseOpenView; external msilib name 'MsiDatabaseOpenView' + AWSuffix;
2817
function MsiViewGetErrorA; external msilib name 'MsiViewGetErrorA';
2818
function MsiViewGetErrorW; external msilib name 'MsiViewGetErrorW';
2819
function MsiViewGetError; external msilib name 'MsiViewGetError' + AWSuffix;
2820
function MsiViewExecute; external msilib name 'MsiViewExecute';
2821
function MsiViewFetch; external msilib name 'MsiViewFetch';
2822
function MsiViewModify; external msilib name 'MsiViewModify';
2823
function MsiViewGetColumnInfo; external msilib name 'MsiViewGetColumnInfo';
2824
function MsiViewClose; external msilib name 'MsiViewClose';
2825
function MsiDatabaseGetPrimaryKeysA; external msilib name 'MsiDatabaseGetPrimaryKeysA';
2826
function MsiDatabaseGetPrimaryKeysW; external msilib name 'MsiDatabaseGetPrimaryKeysW';
2827
function MsiDatabaseGetPrimaryKeys; external msilib name 'MsiDatabaseGetPrimaryKeys' + AWSuffix;
2828
function MsiDatabaseIsTablePersistentA; external msilib name 'MsiDatabaseIsTablePersistentA';
2829
function MsiDatabaseIsTablePersistentW; external msilib name 'MsiDatabaseIsTablePersistentW';
2830
function MsiDatabaseIsTablePersistent; external msilib name 'MsiDatabaseIsTablePersistent' + AWSuffix;
2831
function MsiGetSummaryInformationA; external msilib name 'MsiGetSummaryInformationA';
2832
function MsiGetSummaryInformationW; external msilib name 'MsiGetSummaryInformationW';
2833
function MsiGetSummaryInformation; external msilib name 'MsiGetSummaryInformation' + AWSuffix;
2834
function MsiSummaryInfoGetPropertyCount; external msilib name 'MsiSummaryInfoGetPropertyCount';
2835
function MsiSummaryInfoSetPropertyA; external msilib name 'MsiSummaryInfoSetPropertyA';
2836
function MsiSummaryInfoSetPropertyW; external msilib name 'MsiSummaryInfoSetPropertyW';
2837
function MsiSummaryInfoSetProperty; external msilib name 'MsiSummaryInfoSetProperty' + AWSuffix;
2838
function MsiSummaryInfoGetPropertyA; external msilib name 'MsiSummaryInfoGetPropertyA';
2839
function MsiSummaryInfoGetPropertyW; external msilib name 'MsiSummaryInfoGetPropertyW';
2840
function MsiSummaryInfoGetProperty; external msilib name 'MsiSummaryInfoGetProperty' + AWSuffix;
2841
function MsiSummaryInfoPersist; external msilib name 'MsiSummaryInfoPersist';
2842
function MsiOpenDatabaseA; external msilib name 'MsiOpenDatabaseA';
2843
function MsiOpenDatabaseW; external msilib name 'MsiOpenDatabaseW';
2844
function MsiOpenDatabase; external msilib name 'MsiOpenDatabase' + AWSuffix;
2845
function MsiDatabaseImportA; external msilib name 'MsiDatabaseImportA';
2846
function MsiDatabaseImportW; external msilib name 'MsiDatabaseImportW';
2847
function MsiDatabaseImport; external msilib name 'MsiDatabaseImport' + AWSuffix;
2848
function MsiDatabaseExportA; external msilib name 'MsiDatabaseExportA';
2849
function MsiDatabaseExportW; external msilib name 'MsiDatabaseExportW';
2850
function MsiDatabaseExport; external msilib name 'MsiDatabaseExport' + AWSuffix;
2851
function MsiDatabaseMergeA; external msilib name 'MsiDatabaseMergeA';
2852
function MsiDatabaseMergeW; external msilib name 'MsiDatabaseMergeW';
2853
function MsiDatabaseMerge; external msilib name 'MsiDatabaseMerge' + AWSuffix;
2854
function MsiDatabaseGenerateTransformA; external msilib name 'MsiDatabaseGenerateTransformA';
2855
function MsiDatabaseGenerateTransformW; external msilib name 'MsiDatabaseGenerateTransformW';
2856
function MsiDatabaseGenerateTransform; external msilib name 'MsiDatabaseGenerateTransform' + AWSuffix;
2857
function MsiDatabaseApplyTransformA; external msilib name 'MsiDatabaseApplyTransformA';
2858
function MsiDatabaseApplyTransformW; external msilib name 'MsiDatabaseApplyTransformW';
2859
function MsiDatabaseApplyTransform; external msilib name 'MsiDatabaseApplyTransform' + AWSuffix;
2860
function MsiCreateTransformSummaryInfoA; external msilib name 'MsiCreateTransformSummaryInfoA';
2861
function MsiCreateTransformSummaryInfoW; external msilib name 'MsiCreateTransformSummaryInfoW';
2862
function MsiCreateTransformSummaryInfo; external msilib name 'MsiCreateTransformSummaryInfo' + AWSuffix;
2863
function MsiDatabaseCommit; external msilib name 'MsiDatabaseCommit';
2864
function MsiGetDatabaseState; external msilib name 'MsiGetDatabaseState';
2865
function MsiCreateRecord; external msilib name 'MsiCreateRecord';
2866
function MsiRecordIsNull; external msilib name 'MsiRecordIsNull';
2867
function MsiRecordDataSize; external msilib name 'MsiRecordDataSize';
2868
function MsiRecordSetInteger; external msilib name 'MsiRecordSetInteger';
2869
function MsiRecordSetStringA; external msilib name 'MsiRecordSetStringA';
2870
function MsiRecordSetStringW; external msilib name 'MsiRecordSetStringW';
2871
function MsiRecordSetString; external msilib name 'MsiRecordSetString' + AWSuffix;
2872
function MsiRecordGetInteger; external msilib name 'MsiRecordGetInteger';
2873
function MsiRecordGetStringA; external msilib name 'MsiRecordGetStringA';
2874
function MsiRecordGetStringW; external msilib name 'MsiRecordGetStringW';
2875
function MsiRecordGetString; external msilib name 'MsiRecordGetString' + AWSuffix;
2876
function MsiRecordGetFieldCount; external msilib name 'MsiRecordGetFieldCount';
2877
function MsiRecordSetStreamA; external msilib name 'MsiRecordSetStreamA';
2878
function MsiRecordSetStreamW; external msilib name 'MsiRecordSetStreamW';
2879
function MsiRecordSetStream; external msilib name 'MsiRecordSetStream' + AWSuffix;
2880
function MsiRecordReadStream; external msilib name 'MsiRecordReadStream';
2881
function MsiRecordClearData; external msilib name 'MsiRecordClearData';
2882
function MsiGetActiveDatabase; external msilib name 'MsiGetActiveDatabase';
2883
function MsiSetPropertyA; external msilib name 'MsiSetPropertyA';
2884
function MsiSetPropertyW; external msilib name 'MsiSetPropertyW';
2885
function MsiSetProperty; external msilib name 'MsiSetProperty' + AWSuffix;
2886
function MsiGetPropertyA; external msilib name 'MsiGetPropertyA';
2887
function MsiGetPropertyW; external msilib name 'MsiGetPropertyW';
2888
function MsiGetProperty; external msilib name 'MsiGetProperty' + AWSuffix;
2889
function MsiGetLanguage; external msilib name 'MsiGetLanguage';
2890
function MsiGetMode; external msilib name 'MsiGetMode';
2891
function MsiSetMode; external msilib name 'MsiSetMode';
2892
function MsiFormatRecordA; external msilib name 'MsiFormatRecordA';
2893
function MsiFormatRecordW; external msilib name 'MsiFormatRecordW';
2894
function MsiFormatRecord; external msilib name 'MsiFormatRecord' + AWSuffix;
2895
function MsiDoActionA; external msilib name 'MsiDoActionA';
2896
function MsiDoActionW; external msilib name 'MsiDoActionW';
2897
function MsiDoAction; external msilib name 'MsiDoAction' + AWSuffix;
2898
function MsiSequenceA; external msilib name 'MsiSequenceA';
2899
function MsiSequenceW; external msilib name 'MsiSequenceW';
2900
function MsiSequence; external msilib name 'MsiSequence' + AWSuffix;
2901
function MsiProcessMessage; external msilib name 'MsiProcessMessage';
2902
function MsiEvaluateConditionA; external msilib name 'MsiEvaluateConditionA';
2903
function MsiEvaluateConditionW; external msilib name 'MsiEvaluateConditionW';
2904
function MsiEvaluateCondition; external msilib name 'MsiEvaluateCondition' + AWSuffix;
2905
function MsiGetFeatureStateA; external msilib name 'MsiGetFeatureStateA';
2906
function MsiGetFeatureStateW; external msilib name 'MsiGetFeatureStateW';
2907
function MsiGetFeatureState; external msilib name 'MsiGetFeatureState' + AWSuffix;
2908
function MsiSetFeatureStateA; external msilib name 'MsiSetFeatureStateA';
2909
function MsiSetFeatureStateW; external msilib name 'MsiSetFeatureStateW';
2910
function MsiSetFeatureState; external msilib name 'MsiSetFeatureState' + AWSuffix;
2911
function MsiSetFeatureAttributesA; external msilib name 'MsiSetFeatureAttributesA';
2912
function MsiSetFeatureAttributesW; external msilib name 'MsiSetFeatureAttributesW';
2913
function MsiSetFeatureAttributes; external msilib name 'MsiSetFeatureAttributes' + AWSuffix;
2914
function MsiGetComponentStateA; external msilib name 'MsiGetComponentStateA';
2915
function MsiGetComponentStateW; external msilib name 'MsiGetComponentStateW';
2916
function MsiGetComponentState; external msilib name 'MsiGetComponentState' + AWSuffix;
2917
function MsiSetComponentStateA; external msilib name 'MsiSetComponentStateA';
2918
function MsiSetComponentStateW; external msilib name 'MsiSetComponentStateW';
2919
function MsiSetComponentState; external msilib name 'MsiSetComponentState' + AWSuffix;
2920
function MsiGetFeatureCostA; external msilib name 'MsiGetFeatureCostA';
2921
function MsiGetFeatureCostW; external msilib name 'MsiGetFeatureCostW';
2922
function MsiGetFeatureCost; external msilib name 'MsiGetFeatureCost' + AWSuffix;
2923
function MsiEnumComponentCostsA; external msilib name 'MsiEnumComponentCostsA';
2924
function MsiEnumComponentCostsW; external msilib name 'MsiEnumComponentCostsW';
2925
function MsiEnumComponentCosts; external msilib name 'MsiEnumComponentCosts' + AWSuffix;
2926
function MsiSetInstallLevel; external msilib name 'MsiSetInstallLevel';
2927
function MsiGetFeatureValidStatesA; external msilib name 'MsiGetFeatureValidStatesA';
2928
function MsiGetFeatureValidStatesW; external msilib name 'MsiGetFeatureValidStatesW';
2929
function MsiGetFeatureValidStates; external msilib name 'MsiGetFeatureValidStates' + AWSuffix;
2930
function MsiGetSourcePathA; external msilib name 'MsiGetSourcePathA';
2931
function MsiGetSourcePathW; external msilib name 'MsiGetSourcePathW';
2932
function MsiGetSourcePath; external msilib name 'MsiGetSourcePath' + AWSuffix;
2933
function MsiGetTargetPathA; external msilib name 'MsiGetTargetPathA';
2934
function MsiGetTargetPathW; external msilib name 'MsiGetTargetPathW';
2935
function MsiGetTargetPath; external msilib name 'MsiGetTargetPath' + AWSuffix;
2936
function MsiSetTargetPathA; external msilib name 'MsiSetTargetPathA';
2937
function MsiSetTargetPathW; external msilib name 'MsiSetTargetPathW';
2938
function MsiSetTargetPath; external msilib name 'MsiSetTargetPath' + AWSuffix;
2939
function MsiVerifyDiskSpace; external msilib name 'MsiVerifyDiskSpace';
2940
function MsiEnableUIPreview; external msilib name 'MsiEnableUIPreview';
2941
function MsiPreviewDialogA; external msilib name 'MsiPreviewDialogA';
2942
function MsiPreviewDialogW; external msilib name 'MsiPreviewDialogW';
2943
function MsiPreviewDialog; external msilib name 'MsiPreviewDialog' + AWSuffix;
2944
function MsiPreviewBillboardA; external msilib name 'MsiPreviewBillboardA';
2945
function MsiPreviewBillboardW; external msilib name 'MsiPreviewBillboardW';
2946
function MsiPreviewBillboard; external msilib name 'MsiPreviewBillboard' + AWSuffix;
2947
function MsiGetLastErrorRecord; external msilib name 'MsiGetLastErrorRecord';
2949
{$ENDIF DYNAMIC_LINK}
added
removed
fpcsrc/packages/base/winunits/jwamsiquery.pas
