1 {******************************************************************************} 2 { } 3 { Windows Installer API interface Unit for Object Pascal } 4 { } 5 { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft } 6 { Corporation. All Rights Reserved. } 7 { } 8 { The original file is: msiquery.h, released June 2000. The original Pascal } 9 { code is: MsiQuery.pas, released June 2001. The initial developer of the } 10 { Pascal code is Marcel van Brakel (brakelm att chello dott nl). } 11 { } 12 { Portions created by Marcel van Brakel are Copyright (C) 1999-2001 } 13 { Marcel van Brakel. All Rights Reserved. } 14 { } 15 { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) } 16 { } 17 { You may retrieve the latest version of this file at the Project JEDI } 18 { APILIB home page, located at http://jedi-apilib.sourceforge.net } 19 { } 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 } 24 { } 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. } 28 { } 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. } 38 { } 39 { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html } 40 { } 41 {******************************************************************************} 42 43 // $Id: JwaMsiQuery.pas,v 1.11 2007/09/05 11:58:51 dezipaitor Exp $ 44 {$IFNDEF JWA_OMIT_SECTIONS} 45 unit JwaMsiQuery; 46 47 {$WEAKPACKAGEUNIT} 48 {$ENDIF JWA_OMIT_SECTIONS} 49 50 {$HPPEMIT ''} 51 {$HPPEMIT '#include "msiquery.h"'} 52 {$HPPEMIT ''} 53 54 {$IFNDEF JWA_OMIT_SECTIONS} 55 {$I jediapilib.inc} 56 57 interface 58 59 uses 60 JwaMsi, JwaWinBase, JwaWinType; 61 {$ENDIF JWA_OMIT_SECTIONS} 62 63 {$IFNDEF JWA_IMPLEMENTATIONSECTION} 64 (*****************************************************************************\ 65 * * 66 * MsiQuery.h - Interface to running installer for custom actions and tools * 67 * * 68 * Version 1.0 - 1.2 * 69 * * 70 * NOTES: All buffers sizes are TCHAR count, null included only on input * 71 * Return argument pointers may be null if not interested in value * 72 * Returned handles of all types must be closed: MsiCloseHandle(h) * 73 * Functions with UINT return type return a system error code * 74 * Designated functions will set or clear the last error record, * 75 * which is then accessible with MsiGetLastErrorRecord. However, * 76 * the following argument errors do not register an error record: * 77 * ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, ERROR_MORE_DATA. * 78 * * 79 * Copyright (c) 1999-2000, Microsoft Corp. All rights reserved. * 80 * * 81 \*****************************************************************************) 82 83 const 84 MSI_NULL_INTEGER = DWORD($80000000); // integer value reserved for null 85 {$EXTERNALSYM MSI_NULL_INTEGER} 86 87 // MsiOpenDatabase persist predefine values, otherwise output database path is used 88 89 MSIDBOPEN_READONLY = LPCTSTR(0); // database open read-only, no persistent changes 90 {$EXTERNALSYM MSIDBOPEN_READONLY} 91 MSIDBOPEN_TRANSACT = LPCTSTR(1); // database read/write in transaction mode 92 {$EXTERNALSYM MSIDBOPEN_TRANSACT} 93 MSIDBOPEN_DIRECT = LPCTSTR(2); // database direct read/write without transaction 94 {$EXTERNALSYM MSIDBOPEN_DIRECT} 95 MSIDBOPEN_CREATE = LPCTSTR(3); // create new database, transact mode read/write 96 {$EXTERNALSYM MSIDBOPEN_CREATE} 97 MSIDBOPEN_CREATEDIRECT = LPCTSTR(4); // create new database, direct mode read/write 98 {$EXTERNALSYM MSIDBOPEN_CREATEDIRECT} 99 100 MSIDBOPEN_PATCHFILE = 32 div SizeOf(TCHAR); // add flag to indicate patch file 101 102 MSIDBSTATE_ERROR = DWORD(-1); // invalid database handle 103 {$EXTERNALSYM MSIDBSTATE_ERROR} 104 MSIDBSTATE_READ = 0; // database open read-only, no persistent changes 105 {$EXTERNALSYM MSIDBSTATE_READ} 106 MSIDBSTATE_WRITE = 1; // database readable and updatable 107 {$EXTERNALSYM MSIDBSTATE_WRITE} 108 109 type 110 MSIDBSTATE = DWORD; 111 {$EXTERNALSYM MSIDBSTATE} 112 TMsiDbState = MSIDBSTATE; 113 114 const 115 MSIMODIFY_SEEK = DWORD(-1); // reposition to current record primary key 116 {$EXTERNALSYM MSIMODIFY_SEEK} 117 MSIMODIFY_REFRESH = 0; // refetch current record data 118 {$EXTERNALSYM MSIMODIFY_REFRESH} 119 MSIMODIFY_INSERT = 1; // insert new record, fails if matching key exists 120 {$EXTERNALSYM MSIMODIFY_INSERT} 121 MSIMODIFY_UPDATE = 2; // update existing non-key data of fetched record 122 {$EXTERNALSYM MSIMODIFY_UPDATE} 123 MSIMODIFY_ASSIGN = 3; // insert record, replacing any existing record 124 {$EXTERNALSYM MSIMODIFY_ASSIGN} 125 MSIMODIFY_REPLACE = 4; // update record, delete old if primary key edit 126 {$EXTERNALSYM MSIMODIFY_REPLACE} 127 MSIMODIFY_MERGE = 5; // fails if record with duplicate key not identical 128 {$EXTERNALSYM MSIMODIFY_MERGE} 129 MSIMODIFY_DELETE = 6; // remove row referenced by this record from table 130 {$EXTERNALSYM MSIMODIFY_DELETE} 131 MSIMODIFY_INSERT_TEMPORARY = 7; // insert a temporary record 132 {$EXTERNALSYM MSIMODIFY_INSERT_TEMPORARY} 133 MSIMODIFY_VALIDATE = 8; // validate a fetched record 134 {$EXTERNALSYM MSIMODIFY_VALIDATE} 135 MSIMODIFY_VALIDATE_NEW = 9; // validate a new record 136 {$EXTERNALSYM MSIMODIFY_VALIDATE_NEW} 137 MSIMODIFY_VALIDATE_FIELD = 10; // validate field(s) of an incomplete record 138 {$EXTERNALSYM MSIMODIFY_VALIDATE_FIELD} 139 MSIMODIFY_VALIDATE_DELETE = 11; // validate before deleting record 140 {$EXTERNALSYM MSIMODIFY_VALIDATE_DELETE} 141 142 type 143 MSIMODIFY = DWORD; 144 {$EXTERNALSYM MSIMODIFY} 145 TMsiModify = MSIMODIFY; 146 147 const 148 MSICOLINFO_NAMES = 0; // return column names 149 {$EXTERNALSYM MSICOLINFO_NAMES} 150 MSICOLINFO_TYPES = 1; // return column definitions, datatype code followed by width 151 {$EXTERNALSYM MSICOLINFO_TYPES} 152 153 type 154 MSICOLINFO = DWORD; 155 {$EXTERNALSYM MSICOLINFO} 156 TMsiColInfo = MSICOLINFO; 157 158 const 159 MSICONDITION_FALSE = 0; // expression evaluates to False 160 {$EXTERNALSYM MSICONDITION_FALSE} 161 MSICONDITION_TRUE = 1; // expression evaluates to True 162 {$EXTERNALSYM MSICONDITION_TRUE} 163 MSICONDITION_NONE = 2; // no expression present 164 {$EXTERNALSYM MSICONDITION_NONE} 165 MSICONDITION_ERROR = 3; // syntax error in expression 166 {$EXTERNALSYM MSICONDITION_ERROR} 167 168 type 169 MSICONDITION = DWORD; 170 {$EXTERNALSYM MSICONDITION} 171 TMsiCondition = MSICONDITION; 172 173 const 174 MSICOSTTREE_SELFONLY = 0; 175 {$EXTERNALSYM MSICOSTTREE_SELFONLY} 176 MSICOSTTREE_CHILDREN = 1; 177 {$EXTERNALSYM MSICOSTTREE_CHILDREN} 178 MSICOSTTREE_PARENTS = 2; 179 {$EXTERNALSYM MSICOSTTREE_PARENTS} 180 MSICOSTTREE_RESERVED = 3; // Reserved for future use 181 {$EXTERNALSYM MSICOSTTREE_RESERVED} 182 183 type 184 MSICOSTTREE = DWORD; 185 {$EXTERNALSYM MSICOSTTREE} 186 TMsiCostTree = MSICOSTTREE; 187 188 const 189 MSIDBERROR_INVALIDARG = DWORD(-3); // invalid argument 190 {$EXTERNALSYM MSIDBERROR_INVALIDARG} 191 MSIDBERROR_MOREDATA = DWORD(-2); // buffer too small 192 {$EXTERNALSYM MSIDBERROR_MOREDATA} errornull193 MSIDBERROR_FUNCTIONERROR = DWORD(-1); // function error 194 {$EXTERNALSYM MSIDBERROR_FUNCTIONERROR} 195 MSIDBERROR_NOERROR = 0; // no error 196 {$EXTERNALSYM MSIDBERROR_NOERROR} 197 MSIDBERROR_DUPLICATEKEY = 1; // new record duplicates primary keys of existing record in table 198 {$EXTERNALSYM MSIDBERROR_DUPLICATEKEY} 199 MSIDBERROR_REQUIRED = 2; // non-nullable column, no null values allowed 200 {$EXTERNALSYM MSIDBERROR_REQUIRED} 201 MSIDBERROR_BADLINK = 3; // corresponding record in foreign table not found 202 {$EXTERNALSYM MSIDBERROR_BADLINK} 203 MSIDBERROR_OVERFLOW = 4; // data greater than maximum value allowed 204 {$EXTERNALSYM MSIDBERROR_OVERFLOW} 205 MSIDBERROR_UNDERFLOW = 5; // data less than minimum value allowed 206 {$EXTERNALSYM MSIDBERROR_UNDERFLOW} 207 MSIDBERROR_NOTINSET = 6; // data not a member of the values permitted in the set 208 {$EXTERNALSYM MSIDBERROR_NOTINSET} 209 MSIDBERROR_BADVERSION = 7; // invalid version string 210 {$EXTERNALSYM MSIDBERROR_BADVERSION} 211 MSIDBERROR_BADCASE = 8; // invalid case, must be all upper-case or all lower-case 212 {$EXTERNALSYM MSIDBERROR_BADCASE} 213 MSIDBERROR_BADGUID = 9; // invalid GUID 214 {$EXTERNALSYM MSIDBERROR_BADGUID} 215 MSIDBERROR_BADWILDCARD = 10; // invalid wildcardfilename or use of wildcards 216 {$EXTERNALSYM MSIDBERROR_BADWILDCARD} 217 MSIDBERROR_BADIDENTIFIER = 11; // bad identifier 218 {$EXTERNALSYM MSIDBERROR_BADIDENTIFIER} 219 MSIDBERROR_BADLANGUAGE = 12; // bad language Id(s) 220 {$EXTERNALSYM MSIDBERROR_BADLANGUAGE} 221 MSIDBERROR_BADFILENAME = 13; // bad filename 222 {$EXTERNALSYM MSIDBERROR_BADFILENAME} 223 MSIDBERROR_BADPATH = 14; // bad path 224 {$EXTERNALSYM MSIDBERROR_BADPATH} 225 MSIDBERROR_BADCONDITION = 15; // bad conditional statement 226 {$EXTERNALSYM MSIDBERROR_BADCONDITION} 227 MSIDBERROR_BADFORMATTED = 16; // bad format string 228 {$EXTERNALSYM MSIDBERROR_BADFORMATTED} 229 MSIDBERROR_BADTEMPLATE = 17; // bad template string 230 {$EXTERNALSYM MSIDBERROR_BADTEMPLATE} 231 MSIDBERROR_BADDEFAULTDIR = 18; // bad string in DefaultDir column of Directory table 232 {$EXTERNALSYM MSIDBERROR_BADDEFAULTDIR} 233 MSIDBERROR_BADREGPATH = 19; // bad registry path string 234 {$EXTERNALSYM MSIDBERROR_BADREGPATH} 235 MSIDBERROR_BADCUSTOMSOURCE = 20; // bad string in CustomSource column of CustomAction table 236 {$EXTERNALSYM MSIDBERROR_BADCUSTOMSOURCE} 237 MSIDBERROR_BADPROPERTY = 21; // bad property string 238 {$EXTERNALSYM MSIDBERROR_BADPROPERTY} 239 MSIDBERROR_MISSINGDATA = 22; // _Validation table missing reference to column 240 {$EXTERNALSYM MSIDBERROR_MISSINGDATA} 241 MSIDBERROR_BADCATEGORY = 23; // Category column of _Validation table for column is invalid 242 {$EXTERNALSYM MSIDBERROR_BADCATEGORY} 243 MSIDBERROR_BADKEYTABLE = 24; // table in KeyTable column of _Validation table could not be found/loaded 244 {$EXTERNALSYM MSIDBERROR_BADKEYTABLE} 245 MSIDBERROR_BADMAXMINVALUES = 25; // value in MaxValue column of _Validation table is less than value in MinValue column 246 {$EXTERNALSYM MSIDBERROR_BADMAXMINVALUES} 247 MSIDBERROR_BADCABINET = 26; // bad cabinet name 248 {$EXTERNALSYM MSIDBERROR_BADCABINET} 249 MSIDBERROR_BADSHORTCUT = 27; // bad shortcut target 250 {$EXTERNALSYM MSIDBERROR_BADSHORTCUT} 251 MSIDBERROR_STRINGOVERFLOW = 28; // string overflow (greater than length allowed in column def) 252 {$EXTERNALSYM MSIDBERROR_STRINGOVERFLOW} 253 MSIDBERROR_BADLOCALIZEATTRIB = 29; // invalid localization attribute (primary keys cannot be localized) 254 {$EXTERNALSYM MSIDBERROR_BADLOCALIZEATTRIB} 255 256 type 257 MSIDBERROR = DWORD; 258 {$EXTERNALSYM MSIDBERROR} 259 TMsiDbError = MSIDBERROR; 260 261 const 262 MSIRUNMODE_ADMIN = 0; // admin mode install, else product install 263 {$EXTERNALSYM MSIRUNMODE_ADMIN} 264 MSIRUNMODE_ADVERTISE = 1; // installing advertisements, else installing or updating product 265 {$EXTERNALSYM MSIRUNMODE_ADVERTISE} 266 MSIRUNMODE_MAINTENANCE = 2; // modifying an existing installation, else new installation 267 {$EXTERNALSYM MSIRUNMODE_MAINTENANCE} 268 MSIRUNMODE_ROLLBACKENABLED = 3; // rollback is enabled 269 {$EXTERNALSYM MSIRUNMODE_ROLLBACKENABLED} 270 MSIRUNMODE_LOGENABLED = 4; // log file active, enabled prior to install session 271 {$EXTERNALSYM MSIRUNMODE_LOGENABLED} 272 MSIRUNMODE_OPERATIONS = 5; // spooling execute operations, else in determination phase 273 {$EXTERNALSYM MSIRUNMODE_OPERATIONS} 274 MSIRUNMODE_REBOOTATEND = 6; // reboot needed after successful installation (settable) 275 {$EXTERNALSYM MSIRUNMODE_REBOOTATEND} 276 MSIRUNMODE_REBOOTNOW = 7; // reboot needed to continue installation (settable) 277 {$EXTERNALSYM MSIRUNMODE_REBOOTNOW} 278 MSIRUNMODE_CABINET = 8; // installing files from cabinets and files using Media table 279 {$EXTERNALSYM MSIRUNMODE_CABINET} 280 MSIRUNMODE_SOURCESHORTNAMES= 9; // source LongFileNames suppressed via PID_MSISOURCE summary property 281 {$EXTERNALSYM MSIRUNMODE_SOURCESHORTNAMES} 282 MSIRUNMODE_TARGETSHORTNAMES= 10; // target LongFileNames suppressed via SHORTFILENAMES property 283 {$EXTERNALSYM MSIRUNMODE_TARGETSHORTNAMES} 284 MSIRUNMODE_RESERVED11 = 11; // future use 285 {$EXTERNALSYM MSIRUNMODE_RESERVED11} 286 MSIRUNMODE_WINDOWS9X = 12; // operating systems is Windows9?, else Windows NT 287 {$EXTERNALSYM MSIRUNMODE_WINDOWS9X} 288 MSIRUNMODE_ZAWENABLED = 13; // operating system supports demand installation 289 {$EXTERNALSYM MSIRUNMODE_ZAWENABLED} 290 MSIRUNMODE_RESERVED14 = 14; // future use 291 {$EXTERNALSYM MSIRUNMODE_RESERVED14} 292 MSIRUNMODE_RESERVED15 = 15; // future use 293 {$EXTERNALSYM MSIRUNMODE_RESERVED15} 294 MSIRUNMODE_SCHEDULED = 16; // custom action call from install script execution 295 {$EXTERNALSYM MSIRUNMODE_SCHEDULED} 296 MSIRUNMODE_ROLLBACK = 17; // custom action call from rollback execution script 297 {$EXTERNALSYM MSIRUNMODE_ROLLBACK} 298 MSIRUNMODE_COMMIT = 18; // custom action call from commit execution script 299 {$EXTERNALSYM MSIRUNMODE_COMMIT} 300 301 type 302 MSIRUNMODE = DWORD; 303 {$EXTERNALSYM MSIRUNMODE} 304 TMsiRunMode = MSIRUNMODE; 305 306 const 307 INSTALLMESSAGE_TYPEMASK = DWORD($FF000000); // mask for type code 308 {$EXTERNALSYM INSTALLMESSAGE_TYPEMASK} 309 310 // Note: INSTALLMESSAGE_ERROR, INSTALLMESSAGE_WARNING, INSTALLMESSAGE_USER are to or'd 311 // with a message box style to indicate the buttons to display and return: 312 // MB_OK,MB_OKCANCEL,MB_ABORTRETRYIGNORE,MB_YESNOCANCEL,MB_YESNO,MB_RETRYCANCEL 313 // the default button (MB_DEFBUTTON1 is normal default): 314 // MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3 315 // and optionally an icon style: 316 // MB_ICONERROR, MB_ICONQUESTION, MB_ICONWARNING, MB_ICONINFORMATION 317 318 const 319 MSITRANSFORM_ERROR_ADDEXISTINGROW = $00000001; 320 {$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGROW} 321 MSITRANSFORM_ERROR_DELMISSINGROW = $00000002; 322 {$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGROW} 323 MSITRANSFORM_ERROR_ADDEXISTINGTABLE = $00000004; 324 {$EXTERNALSYM MSITRANSFORM_ERROR_ADDEXISTINGTABLE} 325 MSITRANSFORM_ERROR_DELMISSINGTABLE = $00000008; 326 {$EXTERNALSYM MSITRANSFORM_ERROR_DELMISSINGTABLE} 327 MSITRANSFORM_ERROR_UPDATEMISSINGROW = $00000010; 328 {$EXTERNALSYM MSITRANSFORM_ERROR_UPDATEMISSINGROW} 329 MSITRANSFORM_ERROR_CHANGECODEPAGE = $00000020; 330 {$EXTERNALSYM MSITRANSFORM_ERROR_CHANGECODEPAGE} 331 MSITRANSFORM_ERROR_VIEWTRANSFORM = $00000100; 332 {$EXTERNALSYM MSITRANSFORM_ERROR_VIEWTRANSFORM} 333 334 type 335 MSITRANSFORM_ERROR = DWORD; 336 {$EXTERNALSYM MSITRANSFORM_ERROR} 337 TMsiTransformError = MSITRANSFORM_ERROR; 338 339 const 340 MSITRANSFORM_VALIDATE_LANGUAGE = $00000001; 341 {$EXTERNALSYM MSITRANSFORM_VALIDATE_LANGUAGE} 342 MSITRANSFORM_VALIDATE_PRODUCT = $00000002; 343 {$EXTERNALSYM MSITRANSFORM_VALIDATE_PRODUCT} 344 MSITRANSFORM_VALIDATE_PLATFORM = $00000004; 345 {$EXTERNALSYM MSITRANSFORM_VALIDATE_PLATFORM} 346 MSITRANSFORM_VALIDATE_MAJORVERSION = $00000008; 347 {$EXTERNALSYM MSITRANSFORM_VALIDATE_MAJORVERSION} 348 MSITRANSFORM_VALIDATE_MINORVERSION = $00000010; 349 {$EXTERNALSYM MSITRANSFORM_VALIDATE_MINORVERSION} 350 MSITRANSFORM_VALIDATE_UPDATEVERSION = $00000020; 351 {$EXTERNALSYM MSITRANSFORM_VALIDATE_UPDATEVERSION} 352 MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION = $00000040; 353 {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION} 354 MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION = $00000080; 355 {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION} 356 MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION = $00000100; 357 {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION} 358 MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION = $00000200; 359 {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION} 360 MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION = $00000400; 361 {$EXTERNALSYM MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION} 362 MSITRANSFORM_VALIDATE_UPGRADECODE = $00000800; 363 {$EXTERNALSYM MSITRANSFORM_VALIDATE_UPGRADECODE} 364 365 type 366 MSITRANSFORM_VALIDATE = DWORD; 367 {$EXTERNALSYM MSITRANSFORM_VALIDATE} 368 TMsiTransformValidate = MSITRANSFORM_VALIDATE; 369 370 // ----------------------------------------------------------------------------- 371 // Installer database access functions 372 // ----------------------------------------------------------------------------- 373 374 // Prepare a database query, creating a view object 375 // Returns ERROR_SUCCESS if successful, and the view handle is returned, 376 // else ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_BAD_QUERY_SYNTAX, ERROR_GEN_FAILURE 377 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 378 379 function MsiDatabaseOpenViewA(hDatabase: MSIHANDLE; szQuery: LPCSTR; var phView: MSIHANDLE): UINT; stdcall; 380 {$EXTERNALSYM MsiDatabaseOpenViewA} 381 function MsiDatabaseOpenViewW(hDatabase: MSIHANDLE; szQuery: LPCWSTR; var phView: MSIHANDLE): UINT; stdcall; 382 {$EXTERNALSYM MsiDatabaseOpenViewW} 383 function MsiDatabaseOpenView(hDatabase: MSIHANDLE; szQuery: LPCTSTR; var phView: MSIHANDLE): UINT; stdcall; 384 {$EXTERNALSYM MsiDatabaseOpenView} 385 386 // Returns the MSIDBERROR enum and name of the column corresponding to the error 387 // Similar to a GetLastError function, but for the view. NOT the same as MsiGetLastErrorRecord 388 // Returns errors of MsiViewModify. 389 390 function MsiViewGetErrorA(hView: MSIHANDLE; szColumnNameBuffer: LPSTR; 391 var pcchBuf: DWORD): MSIDBERROR; stdcall; 392 {$EXTERNALSYM MsiViewGetErrorA} 393 function MsiViewGetErrorW(hView: MSIHANDLE; szColumnNameBuffer: LPWSTR; 394 var pcchBuf: DWORD): MSIDBERROR; stdcall; 395 {$EXTERNALSYM MsiViewGetErrorW} 396 function MsiViewGetError(hView: MSIHANDLE; szColumnNameBuffer: LPTSTR; 397 var pcchBuf: DWORD): MSIDBERROR; stdcall; 398 {$EXTERNALSYM MsiViewGetError} 399 400 // Exectute the view query, supplying parameters as required 401 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE 402 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 403 404 function MsiViewExecute(hView: MSIHANDLE; hRecord: MSIHANDLE): UINT; stdcall; 405 {$EXTERNALSYM MsiViewExecute} 406 407 // Fetch the next sequential record from the view 408 // Result is ERROR_SUCCESS if a row is found, and its handle is returned 409 // else ERROR_NO_MORE_ITEMS if no records remain, and a null handle is returned 410 // else result is error: ERROR_INVALID_HANDLE_STATE, ERROR_INVALID_HANDLE, ERROR_GEN_FAILURE 411 412 function MsiViewFetch(hView: MSIHANDLE; var phRecord: MSIHANDLE): UINT; stdcall; 413 {$EXTERNALSYM MsiViewFetch} 414 415 // Modify a database record, parameters must match types in query columns 416 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE, ERROR_GEN_FAILURE, ERROR_ACCESS_DENIED 417 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 418 419 function MsiViewModify(hView: MSIHANDLE; eModifyMode: MSIMODIFY; hRecord: MSIHANDLE): UINT; stdcall; 420 {$EXTERNALSYM MsiViewModify} 421 422 // Return the column names or specifications for the current view 423 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER, or ERROR_INVALID_HANDLE_STATE 424 425 function MsiViewGetColumnInfo(hView: MSIHANDLE; eColumnInfo: MSICOLINFO; 426 var phRecord: MSIHANDLE): UINT; stdcall; 427 {$EXTERNALSYM MsiViewGetColumnInfo} 428 429 // Release the result set for an executed view, to allow re-execution 430 // Only needs to be called if not all records have been fetched 431 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_HANDLE_STATE 432 433 function MsiViewClose(hView: MSIHANDLE): UINT; stdcall; 434 {$EXTERNALSYM MsiViewClose} 435 436 // Return a record containing the names of all primary key columns for a given table 437 // Returns an MSIHANDLE for a record containing the name of each column. 438 // The field count of the record corresponds to the number of primary key columns. 439 // Field [0] of the record contains the table name. 440 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_TABLE 441 442 function MsiDatabaseGetPrimaryKeysA(hDatabase: MSIHANDLE; szTableName: LPCSTR; 443 var phRecord: MSIHANDLE): UINT; stdcall; 444 {$EXTERNALSYM MsiDatabaseGetPrimaryKeysA} 445 function MsiDatabaseGetPrimaryKeysW(hDatabase: MSIHANDLE; szTableName: LPCWSTR; 446 var phRecord: MSIHANDLE): UINT; stdcall; 447 {$EXTERNALSYM MsiDatabaseGetPrimaryKeysW} 448 function MsiDatabaseGetPrimaryKeys(hDatabase: MSIHANDLE; szTableName: LPCTSTR; 449 var phRecord: MSIHANDLE): UINT; stdcall; 450 {$EXTERNALSYM MsiDatabaseGetPrimaryKeys} 451 452 // Return an enum defining the state of the table (temporary, unknown, or persistent). 453 // Returns MSICONDITION_ERROR, MSICONDITION_FALSE, MSICONDITION_TRUE, MSICONDITION_NONE 454 455 function MsiDatabaseIsTablePersistentA(hDatabase: MSIHANDLE; szTableName: LPCSTR): MSICONDITION; stdcall; 456 {$EXTERNALSYM MsiDatabaseIsTablePersistentA} 457 function MsiDatabaseIsTablePersistentW(hDatabase: MSIHANDLE; szTableName: LPCWSTR): MSICONDITION; stdcall; 458 {$EXTERNALSYM MsiDatabaseIsTablePersistentW} 459 function MsiDatabaseIsTablePersistent(hDatabase: MSIHANDLE; szTableName: LPCTSTR): MSICONDITION; stdcall; 460 {$EXTERNALSYM MsiDatabaseIsTablePersistent} 461 462 // -------------------------------------------------------------------------- 463 // Summary information stream management functions 464 // -------------------------------------------------------------------------- 465 466 // Integer Property IDs: 1, 14, 15, 16, 19 467 // DateTime Property IDs: 10, 11, 12, 13 468 // Text Property IDs: 2, 3, 4, 5, 6, 7, 8, 9, 18 469 // Unsupported Propery IDs: 0 (PID_DICTIONARY), 17 (PID_THUMBNAIL) 470 471 // Obtain a handle for the _SummaryInformation stream for an MSI database 472 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 473 474 function MsiGetSummaryInformationA(hDatabase: MSIHANDLE; szDatabasePath: LPCSTR; 475 uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall; 476 {$EXTERNALSYM MsiGetSummaryInformationA} 477 function MsiGetSummaryInformationW(hDatabase: MSIHANDLE; szDatabasePath: LPCWSTR; 478 uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall; 479 {$EXTERNALSYM MsiGetSummaryInformationW} 480 function MsiGetSummaryInformation(hDatabase: MSIHANDLE; szDatabasePath: LPCTSTR; 481 uiUpdateCount: UINT; var phSummaryInfo: MSIHANDLE): UINT; stdcall; 482 {$EXTERNALSYM MsiGetSummaryInformation} 483 484 // Obtain the number of existing properties in the SummaryInformation stream 485 486 function MsiSummaryInfoGetPropertyCount(hSummaryInfo: MSIHANDLE; var puiPropertyCount: UINT): UINT; stdcall; 487 {$EXTERNALSYM MsiSummaryInfoGetPropertyCount} 488 489 // Set a single summary information property 490 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY 491 492 function MsiSummaryInfoSetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT; 493 uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCSTR): UINT; stdcall; 494 {$EXTERNALSYM MsiSummaryInfoSetPropertyA} 495 function MsiSummaryInfoSetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT; 496 uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCWSTR): UINT; stdcall; 497 {$EXTERNALSYM MsiSummaryInfoSetPropertyW} 498 function MsiSummaryInfoSetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT; 499 uiDataType: UINT; iValue: Integer; const pftValue: FILETIME; szValue: LPCTSTR): UINT; stdcall; 500 {$EXTERNALSYM MsiSummaryInfoSetProperty} 501 502 // Get a single property from the summary information 503 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_UNKNOWN_PROPERTY 504 505 function MsiSummaryInfoGetPropertyA(hSummaryInfo: MSIHANDLE; uiProperty: UINT; 506 var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPSTR; 507 var pcchValueBuf: DWORD): UINT; stdcall; 508 {$EXTERNALSYM MsiSummaryInfoGetPropertyA} 509 function MsiSummaryInfoGetPropertyW(hSummaryInfo: MSIHANDLE; uiProperty: UINT; 510 var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPWSTR; 511 var pcchValueBuf: DWORD): UINT; stdcall; 512 {$EXTERNALSYM MsiSummaryInfoGetPropertyW} 513 function MsiSummaryInfoGetProperty(hSummaryInfo: MSIHANDLE; uiProperty: UINT; 514 var puiDataType: UINT; var piValue: Integer; var pftValue: FILETIME; szValueBuf: LPTSTR; 515 var pcchValueBuf: DWORD): UINT; stdcall; 516 {$EXTERNALSYM MsiSummaryInfoGetProperty} 517 518 // Write back changed information to summary information stream 519 520 function MsiSummaryInfoPersist(hSummaryInfo: MSIHANDLE): UINT; stdcall; 521 {$EXTERNALSYM MsiSummaryInfoPersist} 522 523 // -------------------------------------------------------------------------- 524 // Installer database management functions - not used by custom actions 525 // -------------------------------------------------------------------------- 526 527 // Open an installer database, specifying the persistance mode, which is a pointer. 528 // Predefined persist values are reserved pointer values, requiring pointer arithmetic. 529 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 530 531 function MsiOpenDatabaseA(szDatabasePath: LPCSTR; szPersist: LPCSTR; 532 var phDatabase: MSIHANDLE): UINT; stdcall; 533 {$EXTERNALSYM MsiOpenDatabaseA} 534 function MsiOpenDatabaseW(szDatabasePath: LPCWSTR; szPersist: LPCWSTR; 535 var phDatabase: MSIHANDLE): UINT; stdcall; 536 {$EXTERNALSYM MsiOpenDatabaseW} 537 function MsiOpenDatabase(szDatabasePath: LPCTSTR; szPersist: LPCTSTR; 538 var phDatabase: MSIHANDLE): UINT; stdcall; 539 {$EXTERNALSYM MsiOpenDatabase} 540 541 // Import an MSI text archive table into an open database 542 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 543 544 function MsiDatabaseImportA(hDatabase: MSIHANDLE; szFolderPath: LPCSTR; 545 szFileName: LPCSTR): UINT; stdcall; 546 {$EXTERNALSYM MsiDatabaseImportA} 547 function MsiDatabaseImportW(hDatabase: MSIHANDLE; szFolderPath: LPCWSTR; 548 szFileName: LPCWSTR): UINT; stdcall; 549 {$EXTERNALSYM MsiDatabaseImportW} 550 function MsiDatabaseImport(hDatabase: MSIHANDLE; szFolderPath: LPCTSTR; 551 szFileName: LPCTSTR): UINT; stdcall; 552 {$EXTERNALSYM MsiDatabaseImport} 553 554 // Export an MSI table from an open database to a text archive file 555 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 556 557 function MsiDatabaseExportA(hDatabase: MSIHANDLE; szTableName: LPCSTR; 558 szFolderPath: LPCSTR; szFileName: LPCSTR): UINT; stdcall; 559 {$EXTERNALSYM MsiDatabaseExportA} 560 function MsiDatabaseExportW(hDatabase: MSIHANDLE; szTableName: LPCWSTR; 561 szFolderPath: LPCWSTR; szFileName: LPCWSTR): UINT; stdcall; 562 {$EXTERNALSYM MsiDatabaseExportW} 563 function MsiDatabaseExport(hDatabase: MSIHANDLE; szTableName: LPCTSTR; 564 szFolderPath: LPCTSTR; szFileName: LPCTSTR): UINT; stdcall; 565 {$EXTERNALSYM MsiDatabaseExport} 566 567 // Merge two database together, allowing duplicate rows 568 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 569 570 function MsiDatabaseMergeA(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE; 571 szTableName: LPCSTR): UINT; stdcall; 572 {$EXTERNALSYM MsiDatabaseMergeA} 573 function MsiDatabaseMergeW(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE; 574 szTableName: LPCWSTR): UINT; stdcall; 575 {$EXTERNALSYM MsiDatabaseMergeW} 576 function MsiDatabaseMerge(hDatabase: MSIHANDLE; hDatabaseMerge: MSIHANDLE; 577 szTableName: LPCTSTR): UINT; stdcall; 578 {$EXTERNALSYM MsiDatabaseMerge} 579 580 // Generate a transform file of differences between two databases 581 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 582 583 function MsiDatabaseGenerateTransformA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE; 584 szTransformFile: LPCSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall; 585 {$EXTERNALSYM MsiDatabaseGenerateTransformA} 586 function MsiDatabaseGenerateTransformW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE; 587 szTransformFile: LPCWSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall; 588 {$EXTERNALSYM MsiDatabaseGenerateTransformW} 589 function MsiDatabaseGenerateTransform(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE; 590 szTransformFile: LPCTSTR; iReserved1: Integer; iReserved2: Integer): UINT; stdcall; 591 {$EXTERNALSYM MsiDatabaseGenerateTransform} 592 593 // Apply a transform file containing database difference 594 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 595 596 function MsiDatabaseApplyTransformA(hDatabase: MSIHANDLE; szTransformFile: LPCSTR; 597 iErrorConditions: Integer): UINT; stdcall; 598 {$EXTERNALSYM MsiDatabaseApplyTransformA} 599 function MsiDatabaseApplyTransformW(hDatabase: MSIHANDLE; szTransformFile: LPCWSTR; 600 iErrorConditions: Integer): UINT; stdcall; 601 {$EXTERNALSYM MsiDatabaseApplyTransformW} 602 function MsiDatabaseApplyTransform(hDatabase: MSIHANDLE; szTransformFile: LPCTSTR; 603 iErrorConditions: Integer): UINT; stdcall; 604 {$EXTERNALSYM MsiDatabaseApplyTransform} 605 606 // Create summary information of existing transform to include validation and error conditions 607 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 608 609 function MsiCreateTransformSummaryInfoA(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE; 610 szTransformFile: LPCSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall; 611 {$EXTERNALSYM MsiCreateTransformSummaryInfoA} 612 function MsiCreateTransformSummaryInfoW(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE; 613 szTransformFile: LPCWSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall; 614 {$EXTERNALSYM MsiCreateTransformSummaryInfoW} 615 function MsiCreateTransformSummaryInfo(hDatabase: MSIHANDLE; hDatabaseReference: MSIHANDLE; 616 szTransformFile: LPCTSTR; iErrorConditions: Integer; iValidation: Integer): UINT; stdcall; 617 {$EXTERNALSYM MsiCreateTransformSummaryInfo} 618 619 // Write out all persistent table data, ignored if database opened read-only 620 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 621 622 function MsiDatabaseCommit(hDatabase: MSIHANDLE): UINT; stdcall; 623 {$EXTERNALSYM MsiDatabaseCommit} 624 625 // Return the update state of a database 626 627 function MsiGetDatabaseState(hDatabase: MSIHANDLE): MSIDBSTATE; stdcall; 628 {$EXTERNALSYM MsiGetDatabaseState} 629 630 // -------------------------------------------------------------------------- 631 // Record object functions 632 // -------------------------------------------------------------------------- 633 634 // Create a new record object with the requested number of fields 635 // Field 0, not included in count, is used for format strings and op codes 636 // All fields are initialized to null 637 // Returns a handle to the created record, or 0 if memory could not be allocated 638 639 function MsiCreateRecord(cParams: UINT): MSIHANDLE; stdcall; 640 {$EXTERNALSYM MsiCreateRecord} 641 642 // Report whether a record field is NULL 643 // Returns TRUE if the field is null or does not exist 644 // Returns FALSE if the field contains data, or the handle is invalid 645 646 function MsiRecordIsNull(hRecord: MSIHANDLE; iField: UINT): BOOL; stdcall; 647 {$EXTERNALSYM MsiRecordIsNull} 648 649 // Return the length of a record field 650 // Returns 0 if field is NULL or non-existent 651 // Returns sizeof(Integer) if integer data 652 // Returns character count if string data (not counting null terminator) 653 // Returns bytes count if stream data 654 655 function MsiRecordDataSize(hRecord: MSIHANDLE; iField: UINT): UINT; stdcall; 656 {$EXTERNALSYM MsiRecordDataSize} 657 658 // Set a record field to an integer value 659 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD 660 661 function MsiRecordSetInteger(hRecord: MSIHANDLE; iField: UINT; iValue: Integer): UINT; stdcall; 662 {$EXTERNALSYM MsiRecordSetInteger} 663 664 // Copy a string into the designated field 665 // A null string pointer and an empty string both set the field to null 666 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD 667 668 function MsiRecordSetStringA(hRecord: MSIHANDLE; iField: UINT; szValue: LPCSTR): UINT; stdcall; 669 {$EXTERNALSYM MsiRecordSetStringA} 670 function MsiRecordSetStringW(hRecord: MSIHANDLE; iField: UINT; szValue: LPCWSTR): UINT; stdcall; 671 {$EXTERNALSYM MsiRecordSetStringW} 672 function MsiRecordSetString(hRecord: MSIHANDLE; iField: UINT; szValue: LPCTSTR): UINT; stdcall; 673 {$EXTERNALSYM MsiRecordSetString} 674 675 // Return the integer value from a record field 676 // Returns the value MSI_NULL_INTEGER if the field is null 677 // or if the field is a string that cannot be converted to an integer 678 679 function MsiRecordGetInteger(hRecord: MSIHANDLE; iField: UINT): Integer; stdcall; 680 {$EXTERNALSYM MsiRecordGetInteger} 681 682 // Return the string value of a record field 683 // Integer fields will be converted to a string 684 // Null and non-existent fields will report a value of 0 685 // Fields containing stream data will return ERROR_INVALID_DATATYPE 686 // Returns ERROR_SUCCESS, ERROR_MORE_DATA, 687 // ERROR_INVALID_HANDLE, ERROR_INVALID_FIELD, ERROR_BAD_ARGUMENTS 688 689 function MsiRecordGetStringA(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPSTR; 690 var pcchValueBuf: DWORD): UINT; stdcall; 691 {$EXTERNALSYM MsiRecordGetStringA} 692 function MsiRecordGetStringW(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPWSTR; 693 var pcchValueBuf: DWORD): UINT; stdcall; 694 {$EXTERNALSYM MsiRecordGetStringW} 695 function MsiRecordGetString(hRecord: MSIHANDLE; iField: UINT; szValueBuf: LPTSTR; 696 var pcchValueBuf: DWORD): UINT; stdcall; 697 {$EXTERNALSYM MsiRecordGetString} 698 699 // Returns the number of fields allocated in the record 700 // Does not count field 0, used for formatting and op codes 701 702 function MsiRecordGetFieldCount(hRecord: MSIHANDLE): UINT; stdcall; 703 {$EXTERNALSYM MsiRecordGetFieldCount} 704 705 // Set a record stream field from a file 706 // The contents of the specified file will be read into a stream object 707 // The stream will be persisted if the record is inserted into the database 708 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 709 710 function MsiRecordSetStreamA(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCSTR): UINT; stdcall; 711 {$EXTERNALSYM MsiRecordSetStreamA} 712 function MsiRecordSetStreamW(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCWSTR): UINT; stdcall; 713 {$EXTERNALSYM MsiRecordSetStreamW} 714 function MsiRecordSetStream(hRecord: MSIHANDLE; iField: UINT; szFilePath: LPCTSTR): UINT; stdcall; 715 {$EXTERNALSYM MsiRecordSetStream} 716 717 // Read bytes from a record stream field into a buffer 718 // Must set the in/out argument to the requested byte count to read 719 // The number of bytes transferred is returned through the argument 720 // If no more bytes are available, ERROR_SUCCESS is still returned 721 722 function MsiRecordReadStream(hRecord: MSIHANDLE; iField: UINT; szDataBuf: PChar; 723 var pcbDataBuf: DWORD): UINT; stdcall; 724 {$EXTERNALSYM MsiRecordReadStream} 725 726 // Clears all data fields in a record to NULL 727 728 function MsiRecordClearData(hRecord: MSIHANDLE): UINT; stdcall; 729 {$EXTERNALSYM MsiRecordClearData} 730 731 // -------------------------------------------------------------------------- 732 // Functions to access a running installation, called from custom actions 733 // The install handle is the single argument passed to custom actions 734 // -------------------------------------------------------------------------- 735 736 // Return a handle to the database currently in use by this installer instance 737 738 function MsiGetActiveDatabase(hInstall: MSIHANDLE): MSIHANDLE; stdcall; 739 {$EXTERNALSYM MsiGetActiveDatabase} 740 741 // Set the value for an installer property 742 // If the property is not defined, it will be created 743 // If the value is null or an empty string, the property will be removed 744 // Returns ERROR_SUCCESS, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS 745 746 function MsiSetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValue: LPCSTR): UINT; stdcall; 747 {$EXTERNALSYM MsiSetPropertyA} 748 function MsiSetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValue: LPCWSTR): UINT; stdcall; 749 {$EXTERNALSYM MsiSetPropertyW} 750 function MsiSetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValue: LPCTSTR): UINT; stdcall; 751 {$EXTERNALSYM MsiSetProperty} 752 753 // Get the value for an installer property 754 // If the property is not defined, it is equivalent to a 0-length value, not error 755 // Returns ERROR_SUCCESS, ERROR_MORE_DATA, ERROR_INVALID_HANDLE, ERROR_BAD_ARGUMENTS 756 757 function MsiGetPropertyA(hInstall: MSIHANDLE; szName: LPCSTR; szValueBuf: LPSTR; 758 var pcchValueBuf: DWORD): UINT; stdcall; 759 {$EXTERNALSYM MsiGetPropertyA} 760 function MsiGetPropertyW(hInstall: MSIHANDLE; szName: LPCWSTR; szValueBuf: LPWSTR; 761 var pcchValueBuf: DWORD): UINT; stdcall; 762 {$EXTERNALSYM MsiGetPropertyW} 763 function MsiGetProperty(hInstall: MSIHANDLE; szName: LPCTSTR; szValueBuf: LPTSTR; 764 var pcchValueBuf: DWORD): UINT; stdcall; 765 {$EXTERNALSYM MsiGetProperty} 766 767 // Return the numeric language for the currently running install 768 // Returns 0 if an install not running 769 770 function MsiGetLanguage(hInstall: MSIHANDLE): LANGID; stdcall; 771 {$EXTERNALSYM MsiGetLanguage} 772 773 // Return one of the boolean internal installer states 774 // Returns FALSE if the handle is not active or if the mode is not implemented 775 776 function MsiGetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE): BOOL; stdcall; 777 {$EXTERNALSYM MsiGetMode} 778 779 // Set an internal install session boolean mode - Note: most modes are read-only 780 // Returns ERROR_SUCCESS if the mode can be set to the desired state 781 // Returns ERROR_ACCESS_DENIED if the mode is not settable 782 // Returns ERROR_INVALID_HANDLE if the handle is not an active install session 783 784 function MsiSetMode(hInstall: MSIHANDLE; eRunMode: MSIRUNMODE; fState: BOOL): UINT; stdcall; 785 {$EXTERNALSYM MsiSetMode} 786 787 // Format record data using a format string containing field markers and/or properties 788 // Record field 0 must contain the format string 789 // Other fields must contain data that may be referenced by the format string. 790 791 function MsiFormatRecordA(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPSTR; 792 var pcchResultBuf: DWORD): UINT; stdcall; 793 {$EXTERNALSYM MsiFormatRecordA} 794 function MsiFormatRecordW(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPWSTR; 795 var pcchResultBuf: DWORD): UINT; stdcall; 796 {$EXTERNALSYM MsiFormatRecordW} 797 function MsiFormatRecord(hInstall: MSIHANDLE; hRecord: MSIHANDLE; szResultBuf: LPTSTR; 798 var pcchResultBuf: DWORD): UINT; stdcall; 799 {$EXTERNALSYM MsiFormatRecord} 800 801 // Execute another action, either built-in, custom, or UI wizard 802 // Returns ERROR_FUNCTION_NOT_CALLED if action not found 803 // Returns ERROR_SUCCESS if action completed succesfully 804 // Returns ERROR_INSTALL_USEREXIT if user cancelled during action 805 // Returns ERROR_INSTALL_FAILURE if action failed 806 // Returns ERROR_INSTALL_SUSPEND if user suspended installation 807 // Returns ERROR_MORE_DATA if action wishes to skip remaining actions 808 // Returns ERROR_INVALID_HANDLE_STATE if install session not active 809 // Returns ERROR_INVALID_DATA if failure calling custom action 810 // Returns ERROR_INVALID_HANDLE or ERROR_INVALID_PARAMETER if arguments invalid 811 812 function MsiDoActionA(hInstall: MSIHANDLE; szAction: LPCSTR): UINT; stdcall; 813 {$EXTERNALSYM MsiDoActionA} 814 function MsiDoActionW(hInstall: MSIHANDLE; szAction: LPCWSTR): UINT; stdcall; 815 {$EXTERNALSYM MsiDoActionW} 816 function MsiDoAction(hInstall: MSIHANDLE; szAction: LPCTSTR): UINT; stdcall; 817 {$EXTERNALSYM MsiDoAction} 818 819 // Execute another action sequence, as descibed in the specified table 820 // Returns the same error codes as MsiDoAction 821 822 function MsiSequenceA(hInstall: MSIHANDLE; szTable: LPCSTR; iSequenceMode: Integer): UINT; stdcall; 823 {$EXTERNALSYM MsiSequenceA} 824 function MsiSequenceW(hInstall: MSIHANDLE; szTable: LPCWSTR; iSequenceMode: Integer): UINT; stdcall; 825 {$EXTERNALSYM MsiSequenceW} 826 function MsiSequence(hInstall: MSIHANDLE; szTable: LPCTSTR; iSequenceMode: Integer): UINT; stdcall; 827 {$EXTERNALSYM MsiSequence} 828 829 // Send an error record to the installer for processing. 830 // If field 0 (template) is not set, field 1 must be set to the error code, 831 // corresponding the the error message in the Error database table, 832 // and the message will be formatted using the template from the Error table 833 // before passing it to the UI handler for display. 834 // Returns Win32 button codes: IDOK IDCANCEL IDABORT IDRETRY IDIGNORE IDYES IDNO 835 // or 0 if no action taken, or -1 if invalid argument or handle 836 837 function MsiProcessMessage(hInstall: MSIHANDLE; eMessageType: INSTALLMESSAGE; 838 hRecord: MSIHANDLE): Integer; stdcall; 839 {$EXTERNALSYM MsiProcessMessage} 840 841 // Evaluate a conditional expression containing property names and values 842 843 function MsiEvaluateConditionA(hInstall: MSIHANDLE; szCondition: LPCSTR): MSICONDITION; stdcall; 844 {$EXTERNALSYM MsiEvaluateConditionA} 845 function MsiEvaluateConditionW(hInstall: MSIHANDLE; szCondition: LPCWSTR): MSICONDITION; stdcall; 846 {$EXTERNALSYM MsiEvaluateConditionW} 847 function MsiEvaluateCondition(hInstall: MSIHANDLE; szCondition: LPCTSTR): MSICONDITION; stdcall; 848 {$EXTERNALSYM MsiEvaluateCondition} 849 850 // Get the installed state and requested action state of a feature 851 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 852 853 function MsiGetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR; 854 var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall; 855 {$EXTERNALSYM MsiGetFeatureStateA} 856 function MsiGetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR; 857 var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall; 858 {$EXTERNALSYM MsiGetFeatureStateW} 859 function MsiGetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR; 860 var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall; 861 {$EXTERNALSYM MsiGetFeatureState} 862 863 // Request a feature to be set to a specified state 864 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 865 866 function MsiSetFeatureStateA(hInstall: MSIHANDLE; szFeature: LPCSTR; 867 iState: INSTALLSTATE): UINT; stdcall; 868 {$EXTERNALSYM MsiSetFeatureStateA} 869 function MsiSetFeatureStateW(hInstall: MSIHANDLE; szFeature: LPCWSTR; 870 iState: INSTALLSTATE): UINT; stdcall; 871 {$EXTERNALSYM MsiSetFeatureStateW} 872 function MsiSetFeatureState(hInstall: MSIHANDLE; szFeature: LPCTSTR; 873 iState: INSTALLSTATE): UINT; stdcall; 874 {$EXTERNALSYM MsiSetFeatureState} 875 876 // Set the attribute bits of a specified feature at runtime. 877 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 878 879 function MsiSetFeatureAttributesA(hInstall: MSIHANDLE; szFeature: LPCSTR; 880 dwAttributes: DWORD): UINT; stdcall; 881 {$EXTERNALSYM MsiSetFeatureAttributesA} 882 function MsiSetFeatureAttributesW(hInstall: MSIHANDLE; szFeature: LPCWSTR; 883 dwAttributes: DWORD): UINT; stdcall; 884 {$EXTERNALSYM MsiSetFeatureAttributesW} 885 function MsiSetFeatureAttributes(hInstall: MSIHANDLE; szFeature: LPCTSTR; 886 dwAttributes: DWORD): UINT; stdcall; 887 {$EXTERNALSYM MsiSetFeatureAttributes} 888 889 // Get the installed state and requested action state of a component 890 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 891 892 function MsiGetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR; 893 var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall; 894 {$EXTERNALSYM MsiGetComponentStateA} 895 function MsiGetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR; 896 var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall; 897 {$EXTERNALSYM MsiGetComponentStateW} 898 function MsiGetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR; 899 var piInstalled: INSTALLSTATE; var piAction: INSTALLSTATE): UINT; stdcall; 900 {$EXTERNALSYM MsiGetComponentState} 901 902 // Request a component to be set to a specified state 903 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 904 905 function MsiSetComponentStateA(hInstall: MSIHANDLE; szComponent: LPCSTR; 906 iState: INSTALLSTATE): UINT; stdcall; 907 {$EXTERNALSYM MsiSetComponentStateA} 908 function MsiSetComponentStateW(hInstall: MSIHANDLE; szComponent: LPCWSTR; 909 iState: INSTALLSTATE): UINT; stdcall; 910 {$EXTERNALSYM MsiSetComponentStateW} 911 function MsiSetComponentState(hInstall: MSIHANDLE; szComponent: LPCTSTR; 912 iState: INSTALLSTATE): UINT; stdcall; 913 {$EXTERNALSYM MsiSetComponentState} 914 915 // Return the disk cost for a feature and related features 916 // Can specify either current feature state or proposed state 917 // Can specify extent of related features to cost 918 // Note that adding costs for several features may produce an 919 // excessively large cost due to shared components and parents. 920 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 921 922 function MsiGetFeatureCostA(hInstall: MSIHANDLE; szFeature: LPCSTR; 923 iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall; 924 {$EXTERNALSYM MsiGetFeatureCostA} 925 function MsiGetFeatureCostW(hInstall: MSIHANDLE; szFeature: LPCWSTR; 926 iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall; 927 {$EXTERNALSYM MsiGetFeatureCostW} 928 function MsiGetFeatureCost(hInstall: MSIHANDLE; szFeature: LPCTSTR; 929 iCostTree: MSICOSTTREE; iState: INSTALLSTATE; var piCost: Integer): UINT; stdcall; 930 {$EXTERNALSYM MsiGetFeatureCost} 931 932 // Enumerates the costs and temporary costs per drives for 933 // szComponent. If szComponent is set to NULL, it enumerates 934 // the above costs for the engine, per drives. 935 // 936 // The enumeration is 0-based, i.e. it returns the data for 937 // the first drive when called w/ dwIndex set to 0. 938 // 939 // Can specify either current feature state or proposed state. 940 // 941 // Execution of this function sets the error record, accessible 942 // via MsiGetLastErrorRecord. 943 944 function MsiEnumComponentCostsA(hInstall: MSIHANDLE; szComponent: LPCSTR; dwIndex: DWORD; iState: INSTALLSTATE; 945 szDriveBuf: LPSTR; var pcchDriveBuf: DWORD; var piCost: INT; piTempCost: INT): UINT; stdcall; 946 {$EXTERNALSYM MsiEnumComponentCostsA} 947 function MsiEnumComponentCostsW(hInstall: MSIHANDLE; szComponent: LPCWSTR; dwIndex: DWORD; iState: INSTALLSTATE; 948 szDriveBuf: LPWSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall; 949 {$EXTERNALSYM MsiEnumComponentCostsW} 950 function MsiEnumComponentCosts(hInstall: MSIHANDLE; szComponent: LPCTSTR; dwIndex: DWORD; iState: INSTALLSTATE; 951 szDriveBuf: LPTSTR; var pcchDriveBuf: DWORD; var piCost: INT; var piTempCost: INT): UINT; stdcall; 952 {$EXTERNALSYM MsiEnumComponentCosts} 953 954 // Set the install level for a full product installation (not a feature request) 955 // Setting the value to 0 initialized components and features to the default level 956 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 957 958 function MsiSetInstallLevel(hInstall: MSIHANDLE; iInstallLevel: Integer): UINT; stdcall; 959 {$EXTERNALSYM MsiSetInstallLevel} 960 961 // Get the valid install states for a feature, represented by bit flags 962 // For each valid install state, a bit is set of value: (1 << INSTALLSTATE) 963 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 964 965 function MsiGetFeatureValidStatesA(hInstall: MSIHANDLE; szFeature: LPCSTR; 966 var dwInstallStates: DWORD): UINT; stdcall; 967 {$EXTERNALSYM MsiGetFeatureValidStatesA} 968 function MsiGetFeatureValidStatesW(hInstall: MSIHANDLE; szFeature: LPCWSTR; 969 var dwInstallStates: DWORD): UINT; stdcall; 970 {$EXTERNALSYM MsiGetFeatureValidStatesW} 971 function MsiGetFeatureValidStates(hInstall: MSIHANDLE; szFeature: LPCTSTR; 972 var dwInstallStates: DWORD): UINT; stdcall; 973 {$EXTERNALSYM MsiGetFeatureValidStates} 974 975 // Return the full source path for a folder in the Directory table 976 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 977 978 function MsiGetSourcePathA(hInstall: MSIHANDLE; szFolder: LPCSTR; szPathBuf: LPSTR; 979 var pcchPathBuf: DWORD): UINT; stdcall; 980 {$EXTERNALSYM MsiGetSourcePathA} 981 function MsiGetSourcePathW(hInstall: MSIHANDLE; szFolder: LPCWSTR; szPathBuf: LPWSTR; 982 var pcchPathBuf: DWORD): UINT; stdcall; 983 {$EXTERNALSYM MsiGetSourcePathW} 984 function MsiGetSourcePath(hInstall: MSIHANDLE; szFolder: LPCTSTR; szPathBuf: LPTSTR; 985 var pcchPathBuf: DWORD): UINT; stdcall; 986 {$EXTERNALSYM MsiGetSourcePath} 987 988 // Return the full target path for a folder in the Directory table 989 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 990 991 function MsiGetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR; 992 szPathBuf: LPSTR; var pcchPathBuf: DWORD): UINT; stdcall; 993 {$EXTERNALSYM MsiGetTargetPathA} 994 function MsiGetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR; 995 szPathBuf: LPWSTR; var pcchPathBuf: DWORD): UINT; stdcall; 996 {$EXTERNALSYM MsiGetTargetPathW} 997 function MsiGetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR; 998 szPathBuf: LPTSTR; var pcchPathBuf: DWORD): UINT; stdcall; 999 {$EXTERNALSYM MsiGetTargetPath} 1000 1001 // Set the full target path for a folder in the Directory table 1002 // Execution of this function sets the error record, accessible via MsiGetLastErrorRecord 1003 1004 function MsiSetTargetPathA(hInstall: MSIHANDLE; szFolder: LPCSTR; 1005 szFolderPath: LPCSTR): UINT; stdcall; 1006 {$EXTERNALSYM MsiSetTargetPathA} 1007 function MsiSetTargetPathW(hInstall: MSIHANDLE; szFolder: LPCWSTR; 1008 szFolderPath: LPCWSTR): UINT; stdcall; 1009 {$EXTERNALSYM MsiSetTargetPathW} 1010 function MsiSetTargetPath(hInstall: MSIHANDLE; szFolder: LPCTSTR; 1011 szFolderPath: LPCTSTR): UINT; stdcall; 1012 {$EXTERNALSYM MsiSetTargetPath} 1013 1014 // Check to see if sufficent disk space is present for the current installation 1015 // Returns ERROR_SUCCESS, ERROR_DISK_FULL, ERROR_INVALID_HANDLE_STATE, or ERROR_INVALID_HANDLE 1016 1017 function MsiVerifyDiskSpace(hInstall: MSIHANDLE): UINT; stdcall; 1018 {$EXTERNALSYM MsiVerifyDiskSpace} 1019 1020 // -------------------------------------------------------------------------- 1021 // Functions for rendering UI dialogs from the database representations. 1022 // Purpose is for product development, not for use during installation. 1023 // -------------------------------------------------------------------------- 1024 1025 // Enable UI in preview mode to facilitate authoring of UI dialogs. 1026 // The preview mode will end when the handle is closed. 1027 1028 function MsiEnableUIPreview(hDatabase: MSIHANDLE; var phPreview: MSIHANDLE): UINT; stdcall; 1029 {$EXTERNALSYM MsiEnableUIPreview} 1030 1031 // Display any UI dialog as modeless and inactive. 1032 // Supplying a null name will remove any current dialog. 1033 1034 function MsiPreviewDialogA(hPreview: MSIHANDLE; szDialogName: LPCSTR): UINT; stdcall; 1035 {$EXTERNALSYM MsiPreviewDialogA} 1036 function MsiPreviewDialogW(hPreview: MSIHANDLE; szDialogName: LPCWSTR): UINT; stdcall; 1037 {$EXTERNALSYM MsiPreviewDialogW} 1038 function MsiPreviewDialog(hPreview: MSIHANDLE; szDialogName: LPCTSTR): UINT; stdcall; 1039 {$EXTERNALSYM MsiPreviewDialog} 1040 1041 // Display a billboard within a host control in the displayed dialog. 1042 // Supplying a null billboard name will remove any billboard displayed. 1043 1044 function MsiPreviewBillboardA(hPreview: MSIHANDLE; szControlName: LPCSTR; 1045 szBillboard: LPCSTR): UINT; stdcall; 1046 {$EXTERNALSYM MsiPreviewBillboardA} 1047 function MsiPreviewBillboardW(hPreview: MSIHANDLE; szControlName: LPCWSTR; 1048 szBillboard: LPCWSTR): UINT; stdcall; 1049 {$EXTERNALSYM MsiPreviewBillboardW} 1050 function MsiPreviewBillboard(hPreview: MSIHANDLE; szControlName: LPCTSTR; 1051 szBillboard: LPCTSTR): UINT; stdcall; 1052 {$EXTERNALSYM MsiPreviewBillboard} 1053 1054 // -------------------------------------------------------------------------- 1055 // Error handling not associated with any particular object 1056 // -------------------------------------------------------------------------- 1057 1058 // Return a record handle to the last function that generated an error record 1059 // Only specified functions will set the error record, or clear it if success 1060 // Field 1 of the record will contain the internal MSI error code 1061 // Other fields will contain data specific to the particular error 1062 // The error record is released internally after this function is executed 1063 1064 function MsiGetLastErrorRecord: MSIHANDLE; stdcall; 1065 {$EXTERNALSYM MsiGetLastErrorRecord} 1066 1067 {$ENDIF JWA_IMPLEMENTATIONSECTION} 1068 1069 {$IFNDEF JWA_OMIT_SECTIONS} 1070 implementation 1071 //uses ... 1072 {$ENDIF JWA_OMIT_SECTIONS} 1073 1074 {$IFNDEF JWA_INTERFACESECTION} 1075 1076 {$IFNDEF JWA_INCLUDEMODE} 1077 const 1078 msilib = 'msi.dll'; 1079 {$IFDEF UNICODE} 1080 AWSuffix = 'W'; 1081 {$ELSE} 1082 AWSuffix = 'A'; 1083 {$ENDIF UNICODE} 1084 {$ENDIF JWA_INCLUDEMODE} 1085 1086 1087 {$IFDEF DYNAMIC_LINK} 1088 1089 var 1090 _MsiDatabaseOpenViewA: Pointer; 1091 1092 function MsiDatabaseOpenViewA; 1093 begin 1094 GetProcedureAddress(_MsiDatabaseOpenViewA, msilib, 'MsiDatabaseOpenViewA'); 1095 asm 1096 MOV ESP, EBP 1097 POP EBP 1098 JMP [_MsiDatabaseOpenViewA] 1099 end; 1100 end; 1101 1102 var 1103 _MsiDatabaseOpenViewW: Pointer; 1104 1105 function MsiDatabaseOpenViewW; 1106 begin 1107 GetProcedureAddress(_MsiDatabaseOpenViewW, msilib, 'MsiDatabaseOpenViewW'); 1108 asm 1109 MOV ESP, EBP 1110 POP EBP 1111 JMP [_MsiDatabaseOpenViewW] 1112 end; 1113 end; 1114 1115 var 1116 _MsiDatabaseOpenView: Pointer; 1117 1118 function MsiDatabaseOpenView; 1119 begin 1120 GetProcedureAddress(_MsiDatabaseOpenView, msilib, 'MsiDatabaseOpenView' + AWSuffix); 1121 asm 1122 MOV ESP, EBP 1123 POP EBP 1124 JMP [_MsiDatabaseOpenView] 1125 end; 1126 end; 1127 1128 var 1129 _MsiViewGetErrorA: Pointer; 1130 1131 function MsiViewGetErrorA; 1132 begin 1133 GetProcedureAddress(_MsiViewGetErrorA, msilib, 'MsiViewGetErrorA'); 1134 asm 1135 MOV ESP, EBP 1136 POP EBP 1137 JMP [_MsiViewGetErrorA] 1138 end; 1139 end; 1140 1141 var 1142 _MsiViewGetErrorW: Pointer; 1143 1144 function MsiViewGetErrorW; 1145 begin 1146 GetProcedureAddress(_MsiViewGetErrorW, msilib, 'MsiViewGetErrorW'); 1147 asm 1148 MOV ESP, EBP 1149 POP EBP 1150 JMP [_MsiViewGetErrorW] 1151 end; 1152 end; 1153 1154 var 1155 _MsiViewGetError: Pointer; 1156 1157 function MsiViewGetError; 1158 begin 1159 GetProcedureAddress(_MsiViewGetError, msilib, 'MsiViewGetError' + AWSuffix); 1160 asm 1161 MOV ESP, EBP 1162 POP EBP 1163 JMP [_MsiViewGetError] 1164 end; 1165 end; 1166 1167 var 1168 _MsiViewExecute: Pointer; 1169 1170 function MsiViewExecute; 1171 begin 1172 GetProcedureAddress(_MsiViewExecute, msilib, 'MsiViewExecute'); 1173 asm 1174 MOV ESP, EBP 1175 POP EBP 1176 JMP [_MsiViewExecute] 1177 end; 1178 end; 1179 1180 var 1181 _MsiViewFetch: Pointer; 1182 1183 function MsiViewFetch; 1184 begin 1185 GetProcedureAddress(_MsiViewFetch, msilib, 'MsiViewFetch'); 1186 asm 1187 MOV ESP, EBP 1188 POP EBP 1189 JMP [_MsiViewFetch] 1190 end; 1191 end; 1192 1193 var 1194 _MsiViewModify: Pointer; 1195 1196 function MsiViewModify; 1197 begin 1198 GetProcedureAddress(_MsiViewModify, msilib, 'MsiViewModify'); 1199 asm 1200 MOV ESP, EBP 1201 POP EBP 1202 JMP [_MsiViewModify] 1203 end; 1204 end; 1205 1206 var 1207 _MsiViewGetColumnInfo: Pointer; 1208 1209 function MsiViewGetColumnInfo; 1210 begin 1211 GetProcedureAddress(_MsiViewGetColumnInfo, msilib, 'MsiViewGetColumnInfo'); 1212 asm 1213 MOV ESP, EBP 1214 POP EBP 1215 JMP [_MsiViewGetColumnInfo] 1216 end; 1217 end; 1218 1219 var 1220 _MsiViewClose: Pointer; 1221 1222 function MsiViewClose; 1223 begin 1224 GetProcedureAddress(_MsiViewClose, msilib, 'MsiViewClose'); 1225 asm 1226 MOV ESP, EBP 1227 POP EBP 1228 JMP [_MsiViewClose] 1229 end; 1230 end; 1231 1232 var 1233 _MsiDatabaseGetPrimaryKeysA: Pointer; 1234 1235 function MsiDatabaseGetPrimaryKeysA; 1236 begin 1237 GetProcedureAddress(_MsiDatabaseGetPrimaryKeysA, msilib, 'MsiDatabaseGetPrimaryKeysA'); 1238 asm 1239 MOV ESP, EBP 1240 POP EBP 1241 JMP [_MsiDatabaseGetPrimaryKeysA] 1242 end; 1243 end; 1244 1245 var 1246 _MsiDatabaseGetPrimaryKeysW: Pointer; 1247 1248 function MsiDatabaseGetPrimaryKeysW; 1249 begin 1250 GetProcedureAddress(_MsiDatabaseGetPrimaryKeysW, msilib, 'MsiDatabaseGetPrimaryKeysW'); 1251 asm 1252 MOV ESP, EBP 1253 POP EBP 1254 JMP [_MsiDatabaseGetPrimaryKeysW] 1255 end; 1256 end; 1257 1258 var 1259 _MsiDatabaseGetPrimaryKeys: Pointer; 1260 1261 function MsiDatabaseGetPrimaryKeys; 1262 begin 1263 GetProcedureAddress(_MsiDatabaseGetPrimaryKeys, msilib, 'MsiDatabaseGetPrimaryKeys' + AWSuffix); 1264 asm 1265 MOV ESP, EBP 1266 POP EBP 1267 JMP [_MsiDatabaseGetPrimaryKeys] 1268 end; 1269 end; 1270 1271 var 1272 _MsiDatabaseIsTablePersistentA: Pointer; 1273 1274 function MsiDatabaseIsTablePersistentA; 1275 begin 1276 GetProcedureAddress(_MsiDatabaseIsTablePersistentA, msilib, 'MsiDatabaseIsTablePersistentA'); 1277 asm 1278 MOV ESP, EBP 1279 POP EBP 1280 JMP [_MsiDatabaseIsTablePersistentA] 1281 end; 1282 end; 1283 1284 var 1285 _MsiDatabaseIsTablePersistentW: Pointer; 1286 1287 function MsiDatabaseIsTablePersistentW; 1288 begin 1289 GetProcedureAddress(_MsiDatabaseIsTablePersistentW, msilib, 'MsiDatabaseIsTablePersistentW'); 1290 asm 1291 MOV ESP, EBP 1292 POP EBP 1293 JMP [_MsiDatabaseIsTablePersistentW] 1294 end; 1295 end; 1296 1297 var 1298 _MsiDatabaseIsTablePersistent: Pointer; 1299 1300 function MsiDatabaseIsTablePersistent; 1301 begin 1302 GetProcedureAddress(_MsiDatabaseIsTablePersistent, msilib, 'MsiDatabaseIsTablePersistent' + AWSuffix); 1303 asm 1304 MOV ESP, EBP 1305 POP EBP 1306 JMP [_MsiDatabaseIsTablePersistent] 1307 end; 1308 end; 1309 1310 var 1311 _MsiGetSummaryInformationA: Pointer; 1312 1313 function MsiGetSummaryInformationA; 1314 begin 1315 GetProcedureAddress(_MsiGetSummaryInformationA, msilib, 'MsiGetSummaryInformationA'); 1316 asm 1317 MOV ESP, EBP 1318 POP EBP 1319 JMP [_MsiGetSummaryInformationA] 1320 end; 1321 end; 1322 1323 var 1324 _MsiGetSummaryInformationW: Pointer; 1325 1326 function MsiGetSummaryInformationW; 1327 begin 1328 GetProcedureAddress(_MsiGetSummaryInformationW, msilib, 'MsiGetSummaryInformationW'); 1329 asm 1330 MOV ESP, EBP 1331 POP EBP 1332 JMP [_MsiGetSummaryInformationW] 1333 end; 1334 end; 1335 1336 var 1337 _MsiGetSummaryInformation: Pointer; 1338 1339 function MsiGetSummaryInformation; 1340 begin 1341 GetProcedureAddress(_MsiGetSummaryInformation, msilib, 'MsiGetSummaryInformation' + AWSuffix); 1342 asm 1343 MOV ESP, EBP 1344 POP EBP 1345 JMP [_MsiGetSummaryInformation] 1346 end; 1347 end; 1348 1349 var 1350 _MsiSummaryInfoGetPropertyCount: Pointer; 1351 1352 function MsiSummaryInfoGetPropertyCount; 1353 begin 1354 GetProcedureAddress(_MsiSummaryInfoGetPropertyCount, msilib, 'MsiSummaryInfoGetPropertyCount'); 1355 asm 1356 MOV ESP, EBP 1357 POP EBP 1358 JMP [_MsiSummaryInfoGetPropertyCount] 1359 end; 1360 end; 1361 1362 var 1363 _MsiSummaryInfoSetPropertyA: Pointer; 1364 1365 function MsiSummaryInfoSetPropertyA; 1366 begin 1367 GetProcedureAddress(_MsiSummaryInfoSetPropertyA, msilib, 'MsiSummaryInfoSetPropertyA'); 1368 asm 1369 MOV ESP, EBP 1370 POP EBP 1371 JMP [_MsiSummaryInfoSetPropertyA] 1372 end; 1373 end; 1374 1375 var 1376 _MsiSummaryInfoSetPropertyW: Pointer; 1377 1378 function MsiSummaryInfoSetPropertyW; 1379 begin 1380 GetProcedureAddress(_MsiSummaryInfoSetPropertyW, msilib, 'MsiSummaryInfoSetPropertyW'); 1381 asm 1382 MOV ESP, EBP 1383 POP EBP 1384 JMP [_MsiSummaryInfoSetPropertyW] 1385 end; 1386 end; 1387 1388 var 1389 _MsiSummaryInfoSetProperty: Pointer; 1390 1391 function MsiSummaryInfoSetProperty; 1392 begin 1393 GetProcedureAddress(_MsiSummaryInfoSetProperty, msilib, 'MsiSummaryInfoSetProperty' + AWSuffix); 1394 asm 1395 MOV ESP, EBP 1396 POP EBP 1397 JMP [_MsiSummaryInfoSetProperty] 1398 end; 1399 end; 1400 1401 var 1402 _MsiSummaryInfoGetPropertyA: Pointer; 1403 1404 function MsiSummaryInfoGetPropertyA; 1405 begin 1406 GetProcedureAddress(_MsiSummaryInfoGetPropertyA, msilib, 'MsiSummaryInfoGetPropertyA'); 1407 asm 1408 MOV ESP, EBP 1409 POP EBP 1410 JMP [_MsiSummaryInfoGetPropertyA] 1411 end; 1412 end; 1413 1414 var 1415 _MsiSummaryInfoGetPropertyW: Pointer; 1416 1417 function MsiSummaryInfoGetPropertyW; 1418 begin 1419 GetProcedureAddress(_MsiSummaryInfoGetPropertyW, msilib, 'MsiSummaryInfoGetPropertyW'); 1420 asm 1421 MOV ESP, EBP 1422 POP EBP 1423 JMP [_MsiSummaryInfoGetPropertyW] 1424 end; 1425 end; 1426 1427 var 1428 _MsiSummaryInfoGetProperty: Pointer; 1429 1430 function MsiSummaryInfoGetProperty; 1431 begin 1432 GetProcedureAddress(_MsiSummaryInfoGetProperty, msilib, 'MsiSummaryInfoGetProperty' + AWSuffix); 1433 asm 1434 MOV ESP, EBP 1435 POP EBP 1436 JMP [_MsiSummaryInfoGetProperty] 1437 end; 1438 end; 1439 1440 var 1441 _MsiSummaryInfoPersist: Pointer; 1442 1443 function MsiSummaryInfoPersist; 1444 begin 1445 GetProcedureAddress(_MsiSummaryInfoPersist, msilib, 'MsiSummaryInfoPersist'); 1446 asm 1447 MOV ESP, EBP 1448 POP EBP 1449 JMP [_MsiSummaryInfoPersist] 1450 end; 1451 end; 1452 1453 var 1454 _MsiOpenDatabaseA: Pointer; 1455 1456 function MsiOpenDatabaseA; 1457 begin 1458 GetProcedureAddress(_MsiOpenDatabaseA, msilib, 'MsiOpenDatabaseA'); 1459 asm 1460 MOV ESP, EBP 1461 POP EBP 1462 JMP [_MsiOpenDatabaseA] 1463 end; 1464 end; 1465 1466 var 1467 _MsiOpenDatabaseW: Pointer; 1468 1469 function MsiOpenDatabaseW; 1470 begin 1471 GetProcedureAddress(_MsiOpenDatabaseW, msilib, 'MsiOpenDatabaseW'); 1472 asm 1473 MOV ESP, EBP 1474 POP EBP 1475 JMP [_MsiOpenDatabaseW] 1476 end; 1477 end; 1478 1479 var 1480 _MsiOpenDatabase: Pointer; 1481 1482 function MsiOpenDatabase; 1483 begin 1484 GetProcedureAddress(_MsiOpenDatabase, msilib, 'MsiOpenDatabase' + AWSuffix); 1485 asm 1486 MOV ESP, EBP 1487 POP EBP 1488 JMP [_MsiOpenDatabase] 1489 end; 1490 end; 1491 1492 var 1493 _MsiDatabaseImportA: Pointer; 1494 1495 function MsiDatabaseImportA; 1496 begin 1497 GetProcedureAddress(_MsiDatabaseImportA, msilib, 'MsiDatabaseImportA'); 1498 asm 1499 MOV ESP, EBP 1500 POP EBP 1501 JMP [_MsiDatabaseImportA] 1502 end; 1503 end; 1504 1505 var 1506 _MsiDatabaseImportW: Pointer; 1507 1508 function MsiDatabaseImportW; 1509 begin 1510 GetProcedureAddress(_MsiDatabaseImportW, msilib, 'MsiDatabaseImportW'); 1511 asm 1512 MOV ESP, EBP 1513 POP EBP 1514 JMP [_MsiDatabaseImportW] 1515 end; 1516 end; 1517 1518 var 1519 _MsiDatabaseImport: Pointer; 1520 1521 function MsiDatabaseImport; 1522 begin 1523 GetProcedureAddress(_MsiDatabaseImport, msilib, 'MsiDatabaseImport' + AWSuffix); 1524 asm 1525 MOV ESP, EBP 1526 POP EBP 1527 JMP [_MsiDatabaseImport] 1528 end; 1529 end; 1530 1531 var 1532 _MsiDatabaseExportA: Pointer; 1533 1534 function MsiDatabaseExportA; 1535 begin 1536 GetProcedureAddress(_MsiDatabaseExportA, msilib, 'MsiDatabaseExportA'); 1537 asm 1538 MOV ESP, EBP 1539 POP EBP 1540 JMP [_MsiDatabaseExportA] 1541 end; 1542 end; 1543 1544 var 1545 _MsiDatabaseExportW: Pointer; 1546 1547 function MsiDatabaseExportW; 1548 begin 1549 GetProcedureAddress(_MsiDatabaseExportW, msilib, 'MsiDatabaseExportW'); 1550 asm 1551 MOV ESP, EBP 1552 POP EBP 1553 JMP [_MsiDatabaseExportW] 1554 end; 1555 end; 1556 1557 var 1558 _MsiDatabaseExport: Pointer; 1559 1560 function MsiDatabaseExport; 1561 begin 1562 GetProcedureAddress(_MsiDatabaseExport, msilib, 'MsiDatabaseExport' + AWSuffix); 1563 asm 1564 MOV ESP, EBP 1565 POP EBP 1566 JMP [_MsiDatabaseExport] 1567 end; 1568 end; 1569 1570 var 1571 _MsiDatabaseMergeA: Pointer; 1572 1573 function MsiDatabaseMergeA; 1574 begin 1575 GetProcedureAddress(_MsiDatabaseMergeA, msilib, 'MsiDatabaseMergeA'); 1576 asm 1577 MOV ESP, EBP 1578 POP EBP 1579 JMP [_MsiDatabaseMergeA] 1580 end; 1581 end; 1582 1583 var 1584 _MsiDatabaseMergeW: Pointer; 1585 1586 function MsiDatabaseMergeW; 1587 begin 1588 GetProcedureAddress(_MsiDatabaseMergeW, msilib, 'MsiDatabaseMergeW'); 1589 asm 1590 MOV ESP, EBP 1591 POP EBP 1592 JMP [_MsiDatabaseMergeW] 1593 end; 1594 end; 1595 1596 var 1597 _MsiDatabaseMerge: Pointer; 1598 1599 function MsiDatabaseMerge; 1600 begin 1601 GetProcedureAddress(_MsiDatabaseMerge, msilib, 'MsiDatabaseMerge' + AWSuffix); 1602 asm 1603 MOV ESP, EBP 1604 POP EBP 1605 JMP [_MsiDatabaseMerge] 1606 end; 1607 end; 1608 1609 var 1610 _MsiDatabaseGenerateTransformA: Pointer; 1611 1612 function MsiDatabaseGenerateTransformA; 1613 begin 1614 GetProcedureAddress(_MsiDatabaseGenerateTransformA, msilib, 'MsiDatabaseGenerateTransformA'); 1615 asm 1616 MOV ESP, EBP 1617 POP EBP 1618 JMP [_MsiDatabaseGenerateTransformA] 1619 end; 1620 end; 1621 1622 var 1623 _MsiDatabaseGenerateTransformW: Pointer; 1624 1625 function MsiDatabaseGenerateTransformW; 1626 begin 1627 GetProcedureAddress(_MsiDatabaseGenerateTransformW, msilib, 'MsiDatabaseGenerateTransformW'); 1628 asm 1629 MOV ESP, EBP 1630 POP EBP 1631 JMP [_MsiDatabaseGenerateTransformW] 1632 end; 1633 end; 1634 1635 var 1636 _MsiDatabaseGenerateTransform: Pointer; 1637 1638 function MsiDatabaseGenerateTransform; 1639 begin 1640 GetProcedureAddress(_MsiDatabaseGenerateTransform, msilib, 'MsiDatabaseGenerateTransform' + AWSuffix); 1641 asm 1642 MOV ESP, EBP 1643 POP EBP 1644 JMP [_MsiDatabaseGenerateTransform] 1645 end; 1646 end; 1647 1648 var 1649 _MsiDatabaseApplyTransformA: Pointer; 1650 1651 function MsiDatabaseApplyTransformA; 1652 begin 1653 GetProcedureAddress(_MsiDatabaseApplyTransformA, msilib, 'MsiDatabaseApplyTransformA'); 1654 asm 1655 MOV ESP, EBP 1656 POP EBP 1657 JMP [_MsiDatabaseApplyTransformA] 1658 end; 1659 end; 1660 1661 var 1662 _MsiDatabaseApplyTransformW: Pointer; 1663 1664 function MsiDatabaseApplyTransformW; 1665 begin 1666 GetProcedureAddress(_MsiDatabaseApplyTransformW, msilib, 'MsiDatabaseApplyTransformW'); 1667 asm 1668 MOV ESP, EBP 1669 POP EBP 1670 JMP [_MsiDatabaseApplyTransformW] 1671 end; 1672 end; 1673 1674 var 1675 _MsiDatabaseApplyTransform: Pointer; 1676 1677 function MsiDatabaseApplyTransform; 1678 begin 1679 GetProcedureAddress(_MsiDatabaseApplyTransform, msilib, 'MsiDatabaseApplyTransform' + AWSuffix); 1680 asm 1681 MOV ESP, EBP 1682 POP EBP 1683 JMP [_MsiDatabaseApplyTransform] 1684 end; 1685 end; 1686 1687 var 1688 _MsiCreateTransformSummaryInfoA: Pointer; 1689 1690 function MsiCreateTransformSummaryInfoA; 1691 begin 1692 GetProcedureAddress(_MsiCreateTransformSummaryInfoA, msilib, 'MsiCreateTransformSummaryInfoA'); 1693 asm 1694 MOV ESP, EBP 1695 POP EBP 1696 JMP [_MsiCreateTransformSummaryInfoA] 1697 end; 1698 end; 1699 1700 var 1701 _MsiCreateTransformSummaryInfoW: Pointer; 1702 1703 function MsiCreateTransformSummaryInfoW; 1704 begin 1705 GetProcedureAddress(_MsiCreateTransformSummaryInfoW, msilib, 'MsiCreateTransformSummaryInfoW'); 1706 asm 1707 MOV ESP, EBP 1708 POP EBP 1709 JMP [_MsiCreateTransformSummaryInfoW] 1710 end; 1711 end; 1712 1713 var 1714 _MsiCreateTransformSummaryInfo: Pointer; 1715 1716 function MsiCreateTransformSummaryInfo; 1717 begin 1718 GetProcedureAddress(_MsiCreateTransformSummaryInfo, msilib, 'MsiCreateTransformSummaryInfo' + AWSuffix); 1719 asm 1720 MOV ESP, EBP 1721 POP EBP 1722 JMP [_MsiCreateTransformSummaryInfo] 1723 end; 1724 end; 1725 1726 var 1727 _MsiDatabaseCommit: Pointer; 1728 1729 function MsiDatabaseCommit; 1730 begin 1731 GetProcedureAddress(_MsiDatabaseCommit, msilib, 'MsiDatabaseCommit'); 1732 asm 1733 MOV ESP, EBP 1734 POP EBP 1735 JMP [_MsiDatabaseCommit] 1736 end; 1737 end; 1738 1739 var 1740 _MsiGetDatabaseState: Pointer; 1741 1742 function MsiGetDatabaseState; 1743 begin 1744 GetProcedureAddress(_MsiGetDatabaseState, msilib, 'MsiGetDatabaseState'); 1745 asm 1746 MOV ESP, EBP 1747 POP EBP 1748 JMP [_MsiGetDatabaseState] 1749 end; 1750 end; 1751 1752 var 1753 _MsiCreateRecord: Pointer; 1754 1755 function MsiCreateRecord; 1756 begin 1757 GetProcedureAddress(_MsiCreateRecord, msilib, 'MsiCreateRecord'); 1758 asm 1759 MOV ESP, EBP 1760 POP EBP 1761 JMP [_MsiCreateRecord] 1762 end; 1763 end; 1764 1765 var 1766 _MsiRecordIsNull: Pointer; 1767 1768 function MsiRecordIsNull; 1769 begin 1770 GetProcedureAddress(_MsiRecordIsNull, msilib, 'MsiRecordIsNull'); 1771 asm 1772 MOV ESP, EBP 1773 POP EBP 1774 JMP [_MsiRecordIsNull] 1775 end; 1776 end; 1777 1778 var 1779 _MsiRecordDataSize: Pointer; 1780 1781 function MsiRecordDataSize; 1782 begin 1783 GetProcedureAddress(_MsiRecordDataSize, msilib, 'MsiRecordDataSize'); 1784 asm 1785 MOV ESP, EBP 1786 POP EBP 1787 JMP [_MsiRecordDataSize] 1788 end; 1789 end; 1790 1791 var 1792 _MsiRecordSetInteger: Pointer; 1793 1794 function MsiRecordSetInteger; 1795 begin 1796 GetProcedureAddress(_MsiRecordSetInteger, msilib, 'MsiRecordSetInteger'); 1797 asm 1798 MOV ESP, EBP 1799 POP EBP 1800 JMP [_MsiRecordSetInteger] 1801 end; 1802 end; 1803 1804 var 1805 _MsiRecordSetStringA: Pointer; 1806 1807 function MsiRecordSetStringA; 1808 begin 1809 GetProcedureAddress(_MsiRecordSetStringA, msilib, 'MsiRecordSetStringA'); 1810 asm 1811 MOV ESP, EBP 1812 POP EBP 1813 JMP [_MsiRecordSetStringA] 1814 end; 1815 end; 1816 1817 var 1818 _MsiRecordSetStringW: Pointer; 1819 1820 function MsiRecordSetStringW; 1821 begin 1822 GetProcedureAddress(_MsiRecordSetStringW, msilib, 'MsiRecordSetStringW'); 1823 asm 1824 MOV ESP, EBP 1825 POP EBP 1826 JMP [_MsiRecordSetStringW] 1827 end; 1828 end; 1829 1830 var 1831 _MsiRecordSetString: Pointer; 1832 1833 function MsiRecordSetString; 1834 begin 1835 GetProcedureAddress(_MsiRecordSetString, msilib, 'MsiRecordSetString' + AWSuffix); 1836 asm 1837 MOV ESP, EBP 1838 POP EBP 1839 JMP [_MsiRecordSetString] 1840 end; 1841 end; 1842 1843 var 1844 _MsiRecordGetInteger: Pointer; 1845 1846 function MsiRecordGetInteger; 1847 begin 1848 GetProcedureAddress(_MsiRecordGetInteger, msilib, 'MsiRecordGetInteger'); 1849 asm 1850 MOV ESP, EBP 1851 POP EBP 1852 JMP [_MsiRecordGetInteger] 1853 end; 1854 end; 1855 1856 var 1857 _MsiRecordGetStringA: Pointer; 1858 1859 function MsiRecordGetStringA; 1860 begin 1861 GetProcedureAddress(_MsiRecordGetStringA, msilib, 'MsiRecordGetStringA'); 1862 asm 1863 MOV ESP, EBP 1864 POP EBP 1865 JMP [_MsiRecordGetStringA] 1866 end; 1867 end; 1868 1869 var 1870 _MsiRecordGetStringW: Pointer; 1871 1872 function MsiRecordGetStringW; 1873 begin 1874 GetProcedureAddress(_MsiRecordGetStringW, msilib, 'MsiRecordGetStringW'); 1875 asm 1876 MOV ESP, EBP 1877 POP EBP 1878 JMP [_MsiRecordGetStringW] 1879 end; 1880 end; 1881 1882 var 1883 _MsiRecordGetString: Pointer; 1884 1885 function MsiRecordGetString; 1886 begin 1887 GetProcedureAddress(_MsiRecordGetString, msilib, 'MsiRecordGetString' + AWSuffix); 1888 asm 1889 MOV ESP, EBP 1890 POP EBP 1891 JMP [_MsiRecordGetString] 1892 end; 1893 end; 1894 1895 var 1896 _MsiRecordGetFieldCount: Pointer; 1897 1898 function MsiRecordGetFieldCount; 1899 begin 1900 GetProcedureAddress(_MsiRecordGetFieldCount, msilib, 'MsiRecordGetFieldCount'); 1901 asm 1902 MOV ESP, EBP 1903 POP EBP 1904 JMP [_MsiRecordGetFieldCount] 1905 end; 1906 end; 1907 1908 var 1909 _MsiRecordSetStreamA: Pointer; 1910 1911 function MsiRecordSetStreamA; 1912 begin 1913 GetProcedureAddress(_MsiRecordSetStreamA, msilib, 'MsiRecordSetStreamA'); 1914 asm 1915 MOV ESP, EBP 1916 POP EBP 1917 JMP [_MsiRecordSetStreamA] 1918 end; 1919 end; 1920 1921 var 1922 _MsiRecordSetStreamW: Pointer; 1923 1924 function MsiRecordSetStreamW; 1925 begin 1926 GetProcedureAddress(_MsiRecordSetStreamW, msilib, 'MsiRecordSetStreamW'); 1927 asm 1928 MOV ESP, EBP 1929 POP EBP 1930 JMP [_MsiRecordSetStreamW] 1931 end; 1932 end; 1933 1934 var 1935 _MsiRecordSetStream: Pointer; 1936 1937 function MsiRecordSetStream; 1938 begin 1939 GetProcedureAddress(_MsiRecordSetStream, msilib, 'MsiRecordSetStream' + AWSuffix); 1940 asm 1941 MOV ESP, EBP 1942 POP EBP 1943 JMP [_MsiRecordSetStream] 1944 end; 1945 end; 1946 1947 var 1948 _MsiRecordReadStream: Pointer; 1949 1950 function MsiRecordReadStream; 1951 begin 1952 GetProcedureAddress(_MsiRecordReadStream, msilib, 'MsiRecordReadStream'); 1953 asm 1954 MOV ESP, EBP 1955 POP EBP 1956 JMP [_MsiRecordReadStream] 1957 end; 1958 end; 1959 1960 var 1961 _MsiRecordClearData: Pointer; 1962 1963 function MsiRecordClearData; 1964 begin 1965 GetProcedureAddress(_MsiRecordClearData, msilib, 'MsiRecordClearData'); 1966 asm 1967 MOV ESP, EBP 1968 POP EBP 1969 JMP [_MsiRecordClearData] 1970 end; 1971 end; 1972 1973 var 1974 _MsiGetActiveDatabase: Pointer; 1975 1976 function MsiGetActiveDatabase; 1977 begin 1978 GetProcedureAddress(_MsiGetActiveDatabase, msilib, 'MsiGetActiveDatabase'); 1979 asm 1980 MOV ESP, EBP 1981 POP EBP 1982 JMP [_MsiGetActiveDatabase] 1983 end; 1984 end; 1985 1986 var 1987 _MsiSetPropertyA: Pointer; 1988 1989 function MsiSetPropertyA; 1990 begin 1991 GetProcedureAddress(_MsiSetPropertyA, msilib, 'MsiSetPropertyA'); 1992 asm 1993 MOV ESP, EBP 1994 POP EBP 1995 JMP [_MsiSetPropertyA] 1996 end; 1997 end; 1998 1999 var 2000 _MsiSetPropertyW: Pointer; 2001 2002 function MsiSetPropertyW; 2003 begin 2004 GetProcedureAddress(_MsiSetPropertyW, msilib, 'MsiSetPropertyW'); 2005 asm 2006 MOV ESP, EBP 2007 POP EBP 2008 JMP [_MsiSetPropertyW] 2009 end; 2010 end; 2011 2012 var 2013 _MsiSetProperty: Pointer; 2014 2015 function MsiSetProperty; 2016 begin 2017 GetProcedureAddress(_MsiSetProperty, msilib, 'MsiSetProperty' + AWSuffix); 2018 asm 2019 MOV ESP, EBP 2020 POP EBP 2021 JMP [_MsiSetProperty] 2022 end; 2023 end; 2024 2025 var 2026 _MsiGetPropertyA: Pointer; 2027 2028 function MsiGetPropertyA; 2029 begin 2030 GetProcedureAddress(_MsiGetPropertyA, msilib, 'MsiGetPropertyA'); 2031 asm 2032 MOV ESP, EBP 2033 POP EBP 2034 JMP [_MsiGetPropertyA] 2035 end; 2036 end; 2037 2038 var 2039 _MsiGetPropertyW: Pointer; 2040 2041 function MsiGetPropertyW; 2042 begin 2043 GetProcedureAddress(_MsiGetPropertyW, msilib, 'MsiGetPropertyW'); 2044 asm 2045 MOV ESP, EBP 2046 POP EBP 2047 JMP [_MsiGetPropertyW] 2048 end; 2049 end; 2050 2051 var 2052 _MsiGetProperty: Pointer; 2053 2054 function MsiGetProperty; 2055 begin 2056 GetProcedureAddress(_MsiGetProperty, msilib, 'MsiGetProperty' + AWSuffix); 2057 asm 2058 MOV ESP, EBP 2059 POP EBP 2060 JMP [_MsiGetProperty] 2061 end; 2062 end; 2063 2064 var 2065 _MsiGetLanguage: Pointer; 2066 2067 function MsiGetLanguage; 2068 begin 2069 GetProcedureAddress(_MsiGetLanguage, msilib, 'MsiGetLanguage'); 2070 asm 2071 MOV ESP, EBP 2072 POP EBP 2073 JMP [_MsiGetLanguage] 2074 end; 2075 end; 2076 2077 var 2078 _MsiGetMode: Pointer; 2079 2080 function MsiGetMode; 2081 begin 2082 GetProcedureAddress(_MsiGetMode, msilib, 'MsiGetMode'); 2083 asm 2084 MOV ESP, EBP 2085 POP EBP 2086 JMP [_MsiGetMode] 2087 end; 2088 end; 2089 2090 var 2091 _MsiSetMode: Pointer; 2092 2093 function MsiSetMode; 2094 begin 2095 GetProcedureAddress(_MsiSetMode, msilib, 'MsiSetMode'); 2096 asm 2097 MOV ESP, EBP 2098 POP EBP 2099 JMP [_MsiSetMode] 2100 end; 2101 end; 2102 2103 var 2104 _MsiFormatRecordA: Pointer; 2105 2106 function MsiFormatRecordA; 2107 begin 2108 GetProcedureAddress(_MsiFormatRecordA, msilib, 'MsiFormatRecordA'); 2109 asm 2110 MOV ESP, EBP 2111 POP EBP 2112 JMP [_MsiFormatRecordA] 2113 end; 2114 end; 2115 2116 var 2117 _MsiFormatRecordW: Pointer; 2118 2119 function MsiFormatRecordW; 2120 begin 2121 GetProcedureAddress(_MsiFormatRecordW, msilib, 'MsiFormatRecordW'); 2122 asm 2123 MOV ESP, EBP 2124 POP EBP 2125 JMP [_MsiFormatRecordW] 2126 end; 2127 end; 2128 2129 var 2130 _MsiFormatRecord: Pointer; 2131 2132 function MsiFormatRecord; 2133 begin 2134 GetProcedureAddress(_MsiFormatRecord, msilib, 'MsiFormatRecord' + AWSuffix); 2135 asm 2136 MOV ESP, EBP 2137 POP EBP 2138 JMP [_MsiFormatRecord] 2139 end; 2140 end; 2141 2142 var 2143 _MsiDoActionA: Pointer; 2144 2145 function MsiDoActionA; 2146 begin 2147 GetProcedureAddress(_MsiDoActionA, msilib, 'MsiDoActionA'); 2148 asm 2149 MOV ESP, EBP 2150 POP EBP 2151 JMP [_MsiDoActionA] 2152 end; 2153 end; 2154 2155 var 2156 _MsiDoActionW: Pointer; 2157 2158 function MsiDoActionW; 2159 begin 2160 GetProcedureAddress(_MsiDoActionW, msilib, 'MsiDoActionW'); 2161 asm 2162 MOV ESP, EBP 2163 POP EBP 2164 JMP [_MsiDoActionW] 2165 end; 2166 end; 2167 2168 var 2169 _MsiDoAction: Pointer; 2170 2171 function MsiDoAction; 2172 begin 2173 GetProcedureAddress(_MsiDoAction, msilib, 'MsiDoAction' + AWSuffix); 2174 asm 2175 MOV ESP, EBP 2176 POP EBP 2177 JMP [_MsiDoAction] 2178 end; 2179 end; 2180 2181 var 2182 _MsiSequenceA: Pointer; 2183 2184 function MsiSequenceA; 2185 begin 2186 GetProcedureAddress(_MsiSequenceA, msilib, 'MsiSequenceA'); 2187 asm 2188 MOV ESP, EBP 2189 POP EBP 2190 JMP [_MsiSequenceA] 2191 end; 2192 end; 2193 2194 var 2195 _MsiSequenceW: Pointer; 2196 2197 function MsiSequenceW; 2198 begin 2199 GetProcedureAddress(_MsiSequenceW, msilib, 'MsiSequenceW'); 2200 asm 2201 MOV ESP, EBP 2202 POP EBP 2203 JMP [_MsiSequenceW] 2204 end; 2205 end; 2206 2207 var 2208 _MsiSequence: Pointer; 2209 2210 function MsiSequence; 2211 begin 2212 GetProcedureAddress(_MsiSequence, msilib, 'MsiSequence' + AWSuffix); 2213 asm 2214 MOV ESP, EBP 2215 POP EBP 2216 JMP [_MsiSequence] 2217 end; 2218 end; 2219 2220 var 2221 _MsiProcessMessage: Pointer; 2222 2223 function MsiProcessMessage; 2224 begin 2225 GetProcedureAddress(_MsiProcessMessage, msilib, 'MsiProcessMessage'); 2226 asm 2227 MOV ESP, EBP 2228 POP EBP 2229 JMP [_MsiProcessMessage] 2230 end; 2231 end; 2232 2233 var 2234 _MsiEvaluateConditionA: Pointer; 2235 2236 function MsiEvaluateConditionA; 2237 begin 2238 GetProcedureAddress(_MsiEvaluateConditionA, msilib, 'MsiEvaluateConditionA'); 2239 asm 2240 MOV ESP, EBP 2241 POP EBP 2242 JMP [_MsiEvaluateConditionA] 2243 end; 2244 end; 2245 2246 var 2247 _MsiEvaluateConditionW: Pointer; 2248 2249 function MsiEvaluateConditionW; 2250 begin 2251 GetProcedureAddress(_MsiEvaluateConditionW, msilib, 'MsiEvaluateConditionW'); 2252 asm 2253 MOV ESP, EBP 2254 POP EBP 2255 JMP [_MsiEvaluateConditionW] 2256 end; 2257 end; 2258 2259 var 2260 _MsiEvaluateCondition: Pointer; 2261 2262 function MsiEvaluateCondition; 2263 begin 2264 GetProcedureAddress(_MsiEvaluateCondition, msilib, 'MsiEvaluateCondition' + AWSuffix); 2265 asm 2266 MOV ESP, EBP 2267 POP EBP 2268 JMP [_MsiEvaluateCondition] 2269 end; 2270 end; 2271 2272 var 2273 _MsiGetFeatureStateA: Pointer; 2274 2275 function MsiGetFeatureStateA; 2276 begin 2277 GetProcedureAddress(_MsiGetFeatureStateA, msilib, 'MsiGetFeatureStateA'); 2278 asm 2279 MOV ESP, EBP 2280 POP EBP 2281 JMP [_MsiGetFeatureStateA] 2282 end; 2283 end; 2284 2285 var 2286 _MsiGetFeatureStateW: Pointer; 2287 2288 function MsiGetFeatureStateW; 2289 begin 2290 GetProcedureAddress(_MsiGetFeatureStateW, msilib, 'MsiGetFeatureStateW'); 2291 asm 2292 MOV ESP, EBP 2293 POP EBP 2294 JMP [_MsiGetFeatureStateW] 2295 end; 2296 end; 2297 2298 var 2299 _MsiGetFeatureState: Pointer; 2300 2301 function MsiGetFeatureState; 2302 begin 2303 GetProcedureAddress(_MsiGetFeatureState, msilib, 'MsiGetFeatureState' + AWSuffix); 2304 asm 2305 MOV ESP, EBP 2306 POP EBP 2307 JMP [_MsiGetFeatureState] 2308 end; 2309 end; 2310 2311 var 2312 _MsiSetFeatureStateA: Pointer; 2313 2314 function MsiSetFeatureStateA; 2315 begin 2316 GetProcedureAddress(_MsiSetFeatureStateA, msilib, 'MsiSetFeatureStateA'); 2317 asm 2318 MOV ESP, EBP 2319 POP EBP 2320 JMP [_MsiSetFeatureStateA] 2321 end; 2322 end; 2323 2324 var 2325 _MsiSetFeatureStateW: Pointer; 2326 2327 function MsiSetFeatureStateW; 2328 begin 2329 GetProcedureAddress(_MsiSetFeatureStateW, msilib, 'MsiSetFeatureStateW'); 2330 asm 2331 MOV ESP, EBP 2332 POP EBP 2333 JMP [_MsiSetFeatureStateW] 2334 end; 2335 end; 2336 2337 var 2338 _MsiSetFeatureState: Pointer; 2339 2340 function MsiSetFeatureState; 2341 begin 2342 GetProcedureAddress(_MsiSetFeatureState, msilib, 'MsiSetFeatureState' + AWSuffix); 2343 asm 2344 MOV ESP, EBP 2345 POP EBP 2346 JMP [_MsiSetFeatureState] 2347 end; 2348 end; 2349 2350 var 2351 _MsiSetFeatureAttributesA: Pointer; 2352 2353 function MsiSetFeatureAttributesA; 2354 begin 2355 GetProcedureAddress(_MsiSetFeatureAttributesA, msilib, 'MsiSetFeatureAttributesA'); 2356 asm 2357 MOV ESP, EBP 2358 POP EBP 2359 JMP [_MsiSetFeatureAttributesA] 2360 end; 2361 end; 2362 2363 var 2364 _MsiSetFeatureAttributesW: Pointer; 2365 2366 function MsiSetFeatureAttributesW; 2367 begin 2368 GetProcedureAddress(_MsiSetFeatureAttributesW, msilib, 'MsiSetFeatureAttributesW'); 2369 asm 2370 MOV ESP, EBP 2371 POP EBP 2372 JMP [_MsiSetFeatureAttributesW] 2373 end; 2374 end; 2375 2376 var 2377 _MsiSetFeatureAttributes: Pointer; 2378 2379 function MsiSetFeatureAttributes; 2380 begin 2381 GetProcedureAddress(_MsiSetFeatureAttributes, msilib, 'MsiSetFeatureAttributes' + AWSuffix); 2382 asm 2383 MOV ESP, EBP 2384 POP EBP 2385 JMP [_MsiSetFeatureAttributes] 2386 end; 2387 end; 2388 2389 var 2390 _MsiGetComponentStateA: Pointer; 2391 2392 function MsiGetComponentStateA; 2393 begin 2394 GetProcedureAddress(_MsiGetComponentStateA, msilib, 'MsiGetComponentStateA'); 2395 asm 2396 MOV ESP, EBP 2397 POP EBP 2398 JMP [_MsiGetComponentStateA] 2399 end; 2400 end; 2401 2402 var 2403 _MsiGetComponentStateW: Pointer; 2404 2405 function MsiGetComponentStateW; 2406 begin 2407 GetProcedureAddress(_MsiGetComponentStateW, msilib, 'MsiGetComponentStateW'); 2408 asm 2409 MOV ESP, EBP 2410 POP EBP 2411 JMP [_MsiGetComponentStateW] 2412 end; 2413 end; 2414 2415 var 2416 _MsiGetComponentState: Pointer; 2417 2418 function MsiGetComponentState; 2419 begin 2420 GetProcedureAddress(_MsiGetComponentState, msilib, 'MsiGetComponentState' + AWSuffix); 2421 asm 2422 MOV ESP, EBP 2423 POP EBP 2424 JMP [_MsiGetComponentState] 2425 end; 2426 end; 2427 2428 var 2429 _MsiSetComponentStateA: Pointer; 2430 2431 function MsiSetComponentStateA; 2432 begin 2433 GetProcedureAddress(_MsiSetComponentStateA, msilib, 'MsiSetComponentStateA'); 2434 asm 2435 MOV ESP, EBP 2436 POP EBP 2437 JMP [_MsiSetComponentStateA] 2438 end; 2439 end; 2440 2441 var 2442 _MsiSetComponentStateW: Pointer; 2443 2444 function MsiSetComponentStateW; 2445 begin 2446 GetProcedureAddress(_MsiSetComponentStateW, msilib, 'MsiSetComponentStateW'); 2447 asm 2448 MOV ESP, EBP 2449 POP EBP 2450 JMP [_MsiSetComponentStateW] 2451 end; 2452 end; 2453 2454 var 2455 _MsiSetComponentState: Pointer; 2456 2457 function MsiSetComponentState; 2458 begin 2459 GetProcedureAddress(_MsiSetComponentState, msilib, 'MsiSetComponentState' + AWSuffix); 2460 asm 2461 MOV ESP, EBP 2462 POP EBP 2463 JMP [_MsiSetComponentState] 2464 end; 2465 end; 2466 2467 var 2468 _MsiGetFeatureCostA: Pointer; 2469 2470 function MsiGetFeatureCostA; 2471 begin 2472 GetProcedureAddress(_MsiGetFeatureCostA, msilib, 'MsiGetFeatureCostA'); 2473 asm 2474 MOV ESP, EBP 2475 POP EBP 2476 JMP [_MsiGetFeatureCostA] 2477 end; 2478 end; 2479 2480 var 2481 _MsiGetFeatureCostW: Pointer; 2482 2483 function MsiGetFeatureCostW; 2484 begin 2485 GetProcedureAddress(_MsiGetFeatureCostW, msilib, 'MsiGetFeatureCostW'); 2486 asm 2487 MOV ESP, EBP 2488 POP EBP 2489 JMP [_MsiGetFeatureCostW] 2490 end; 2491 end; 2492 2493 var 2494 _MsiGetFeatureCost: Pointer; 2495 2496 function MsiGetFeatureCost; 2497 begin 2498 GetProcedureAddress(_MsiGetFeatureCost, msilib, 'MsiGetFeatureCost' + AWSuffix); 2499 asm 2500 MOV ESP, EBP 2501 POP EBP 2502 JMP [_MsiGetFeatureCost] 2503 end; 2504 end; 2505 2506 var 2507 _MsiEnumComponentCostsA: Pointer; 2508 2509 function MsiEnumComponentCostsA; 2510 begin 2511 GetProcedureAddress(_MsiEnumComponentCostsA, msilib, 'MsiEnumComponentCostsA'); 2512 asm 2513 MOV ESP, EBP 2514 POP EBP 2515 JMP [_MsiEnumComponentCostsA] 2516 end; 2517 end; 2518 2519 var 2520 _MsiEnumComponentCostsW: Pointer; 2521 2522 function MsiEnumComponentCostsW; 2523 begin 2524 GetProcedureAddress(_MsiEnumComponentCostsW, msilib, 'MsiEnumComponentCostsW'); 2525 asm 2526 MOV ESP, EBP 2527 POP EBP 2528 JMP [_MsiEnumComponentCostsW] 2529 end; 2530 end; 2531 2532 var 2533 _MsiEnumComponentCosts: Pointer; 2534 2535 function MsiEnumComponentCosts; 2536 begin 2537 GetProcedureAddress(_MsiEnumComponentCosts, msilib, 'MsiEnumComponentCosts' + AWSuffix); 2538 asm 2539 MOV ESP, EBP 2540 POP EBP 2541 JMP [_MsiEnumComponentCosts] 2542 end; 2543 end; 2544 2545 var 2546 _MsiSetInstallLevel: Pointer; 2547 2548 function MsiSetInstallLevel; 2549 begin 2550 GetProcedureAddress(_MsiSetInstallLevel, msilib, 'MsiSetInstallLevel'); 2551 asm 2552 MOV ESP, EBP 2553 POP EBP 2554 JMP [_MsiSetInstallLevel] 2555 end; 2556 end; 2557 2558 var 2559 _MsiGetFeatureValidStatesA: Pointer; 2560 2561 function MsiGetFeatureValidStatesA; 2562 begin 2563 GetProcedureAddress(_MsiGetFeatureValidStatesA, msilib, 'MsiGetFeatureValidStatesA'); 2564 asm 2565 MOV ESP, EBP 2566 POP EBP 2567 JMP [_MsiGetFeatureValidStatesA] 2568 end; 2569 end; 2570 2571 var 2572 _MsiGetFeatureValidStatesW: Pointer; 2573 2574 function MsiGetFeatureValidStatesW; 2575 begin 2576 GetProcedureAddress(_MsiGetFeatureValidStatesW, msilib, 'MsiGetFeatureValidStatesW'); 2577 asm 2578 MOV ESP, EBP 2579 POP EBP 2580 JMP [_MsiGetFeatureValidStatesW] 2581 end; 2582 end; 2583 2584 var 2585 _MsiGetFeatureValidStates: Pointer; 2586 2587 function MsiGetFeatureValidStates; 2588 begin 2589 GetProcedureAddress(_MsiGetFeatureValidStates, msilib, 'MsiGetFeatureValidStates' + AWSuffix); 2590 asm 2591 MOV ESP, EBP 2592 POP EBP 2593 JMP [_MsiGetFeatureValidStates] 2594 end; 2595 end; 2596 2597 var 2598 _MsiGetSourcePathA: Pointer; 2599 2600 function MsiGetSourcePathA; 2601 begin 2602 GetProcedureAddress(_MsiGetSourcePathA, msilib, 'MsiGetSourcePathA'); 2603 asm 2604 MOV ESP, EBP 2605 POP EBP 2606 JMP [_MsiGetSourcePathA] 2607 end; 2608 end; 2609 2610 var 2611 _MsiGetSourcePathW: Pointer; 2612 2613 function MsiGetSourcePathW; 2614 begin 2615 GetProcedureAddress(_MsiGetSourcePathW, msilib, 'MsiGetSourcePathW'); 2616 asm 2617 MOV ESP, EBP 2618 POP EBP 2619 JMP [_MsiGetSourcePathW] 2620 end; 2621 end; 2622 2623 var 2624 _MsiGetSourcePath: Pointer; 2625 2626 function MsiGetSourcePath; 2627 begin 2628 GetProcedureAddress(_MsiGetSourcePath, msilib, 'MsiGetSourcePath' + AWSuffix); 2629 asm 2630 MOV ESP, EBP 2631 POP EBP 2632 JMP [_MsiGetSourcePath] 2633 end; 2634 end; 2635 2636 var 2637 _MsiGetTargetPathA: Pointer; 2638 2639 function MsiGetTargetPathA; 2640 begin 2641 GetProcedureAddress(_MsiGetTargetPathA, msilib, 'MsiGetTargetPathA'); 2642 asm 2643 MOV ESP, EBP 2644 POP EBP 2645 JMP [_MsiGetTargetPathA] 2646 end; 2647 end; 2648 2649 var 2650 _MsiGetTargetPathW: Pointer; 2651 2652 function MsiGetTargetPathW; 2653 begin 2654 GetProcedureAddress(_MsiGetTargetPathW, msilib, 'MsiGetTargetPathW'); 2655 asm 2656 MOV ESP, EBP 2657 POP EBP 2658 JMP [_MsiGetTargetPathW] 2659 end; 2660 end; 2661 2662 var 2663 _MsiGetTargetPath: Pointer; 2664 2665 function MsiGetTargetPath; 2666 begin 2667 GetProcedureAddress(_MsiGetTargetPath, msilib, 'MsiGetTargetPath' + AWSuffix); 2668 asm 2669 MOV ESP, EBP 2670 POP EBP 2671 JMP [_MsiGetTargetPath] 2672 end; 2673 end; 2674 2675 var 2676 _MsiSetTargetPathA: Pointer; 2677 2678 function MsiSetTargetPathA; 2679 begin 2680 GetProcedureAddress(_MsiSetTargetPathA, msilib, 'MsiSetTargetPathA'); 2681 asm 2682 MOV ESP, EBP 2683 POP EBP 2684 JMP [_MsiSetTargetPathA] 2685 end; 2686 end; 2687 2688 var 2689 _MsiSetTargetPathW: Pointer; 2690 2691 function MsiSetTargetPathW; 2692 begin 2693 GetProcedureAddress(_MsiSetTargetPathW, msilib, 'MsiSetTargetPathW'); 2694 asm 2695 MOV ESP, EBP 2696 POP EBP 2697 JMP [_MsiSetTargetPathW] 2698 end; 2699 end; 2700 2701 var 2702 _MsiSetTargetPath: Pointer; 2703 2704 function MsiSetTargetPath; 2705 begin 2706 GetProcedureAddress(_MsiSetTargetPath, msilib, 'MsiSetTargetPath' + AWSuffix); 2707 asm 2708 MOV ESP, EBP 2709 POP EBP 2710 JMP [_MsiSetTargetPath] 2711 end; 2712 end; 2713 2714 var 2715 _MsiVerifyDiskSpace: Pointer; 2716 2717 function MsiVerifyDiskSpace; 2718 begin 2719 GetProcedureAddress(_MsiVerifyDiskSpace, msilib, 'MsiVerifyDiskSpace'); 2720 asm 2721 MOV ESP, EBP 2722 POP EBP 2723 JMP [_MsiVerifyDiskSpace] 2724 end; 2725 end; 2726 2727 var 2728 _MsiEnableUIPreview: Pointer; 2729 2730 function MsiEnableUIPreview; 2731 begin 2732 GetProcedureAddress(_MsiEnableUIPreview, msilib, 'MsiEnableUIPreview'); 2733 asm 2734 MOV ESP, EBP 2735 POP EBP 2736 JMP [_MsiEnableUIPreview] 2737 end; 2738 end; 2739 2740 var 2741 _MsiPreviewDialogA: Pointer; 2742 2743 function MsiPreviewDialogA; 2744 begin 2745 GetProcedureAddress(_MsiPreviewDialogA, msilib, 'MsiPreviewDialogA'); 2746 asm 2747 MOV ESP, EBP 2748 POP EBP 2749 JMP [_MsiPreviewDialogA] 2750 end; 2751 end; 2752 2753 var 2754 _MsiPreviewDialogW: Pointer; 2755 2756 function MsiPreviewDialogW; 2757 begin 2758 GetProcedureAddress(_MsiPreviewDialogW, msilib, 'MsiPreviewDialogW'); 2759 asm 2760 MOV ESP, EBP 2761 POP EBP 2762 JMP [_MsiPreviewDialogW] 2763 end; 2764 end; 2765 2766 var 2767 _MsiPreviewDialog: Pointer; 2768 2769 function MsiPreviewDialog; 2770 begin 2771 GetProcedureAddress(_MsiPreviewDialog, msilib, 'MsiPreviewDialog' + AWSuffix); 2772 asm 2773 MOV ESP, EBP 2774 POP EBP 2775 JMP [_MsiPreviewDialog] 2776 end; 2777 end; 2778 2779 var 2780 _MsiPreviewBillboardA: Pointer; 2781 2782 function MsiPreviewBillboardA; 2783 begin 2784 GetProcedureAddress(_MsiPreviewBillboardA, msilib, 'MsiPreviewBillboardA'); 2785 asm 2786 MOV ESP, EBP 2787 POP EBP 2788 JMP [_MsiPreviewBillboardA] 2789 end; 2790 end; 2791 2792 var 2793 _MsiPreviewBillboardW: Pointer; 2794 2795 function MsiPreviewBillboardW; 2796 begin 2797 GetProcedureAddress(_MsiPreviewBillboardW, msilib, 'MsiPreviewBillboardW'); 2798 asm 2799 MOV ESP, EBP 2800 POP EBP 2801 JMP [_MsiPreviewBillboardW] 2802 end; 2803 end; 2804 2805 var 2806 _MsiPreviewBillboard: Pointer; 2807 2808 function MsiPreviewBillboard; 2809 begin 2810 GetProcedureAddress(_MsiPreviewBillboard, msilib, 'MsiPreviewBillboard' + AWSuffix); 2811 asm 2812 MOV ESP, EBP 2813 POP EBP 2814 JMP [_MsiPreviewBillboard] 2815 end; 2816 end; 2817 2818 var 2819 _MsiGetLastErrorRecord: Pointer; 2820 2821 function MsiGetLastErrorRecord; 2822 begin 2823 GetProcedureAddress(_MsiGetLastErrorRecord, msilib, 'MsiGetLastErrorRecord'); 2824 asm 2825 MOV ESP, EBP 2826 POP EBP 2827 JMP [_MsiGetLastErrorRecord] 2828 end; 2829 end; 2830 2831 {$ELSE} 2832 2833 function MsiDatabaseOpenViewA; external msilib name 'MsiDatabaseOpenViewA'; 2834 function MsiDatabaseOpenViewW; external msilib name 'MsiDatabaseOpenViewW'; 2835 function MsiDatabaseOpenView; external msilib name 'MsiDatabaseOpenView' + AWSuffix; 2836 function MsiViewGetErrorA; external msilib name 'MsiViewGetErrorA'; 2837 function MsiViewGetErrorW; external msilib name 'MsiViewGetErrorW'; 2838 function MsiViewGetError; external msilib name 'MsiViewGetError' + AWSuffix; 2839 function MsiViewExecute; external msilib name 'MsiViewExecute'; 2840 function MsiViewFetch; external msilib name 'MsiViewFetch'; 2841 function MsiViewModify; external msilib name 'MsiViewModify'; 2842 function MsiViewGetColumnInfo; external msilib name 'MsiViewGetColumnInfo'; 2843 function MsiViewClose; external msilib name 'MsiViewClose'; 2844 function MsiDatabaseGetPrimaryKeysA; external msilib name 'MsiDatabaseGetPrimaryKeysA'; 2845 function MsiDatabaseGetPrimaryKeysW; external msilib name 'MsiDatabaseGetPrimaryKeysW'; 2846 function MsiDatabaseGetPrimaryKeys; external msilib name 'MsiDatabaseGetPrimaryKeys' + AWSuffix; 2847 function MsiDatabaseIsTablePersistentA; external msilib name 'MsiDatabaseIsTablePersistentA'; 2848 function MsiDatabaseIsTablePersistentW; external msilib name 'MsiDatabaseIsTablePersistentW'; 2849 function MsiDatabaseIsTablePersistent; external msilib name 'MsiDatabaseIsTablePersistent' + AWSuffix; 2850 function MsiGetSummaryInformationA; external msilib name 'MsiGetSummaryInformationA'; 2851 function MsiGetSummaryInformationW; external msilib name 'MsiGetSummaryInformationW'; 2852 function MsiGetSummaryInformation; external msilib name 'MsiGetSummaryInformation' + AWSuffix; 2853 function MsiSummaryInfoGetPropertyCount; external msilib name 'MsiSummaryInfoGetPropertyCount'; 2854 function MsiSummaryInfoSetPropertyA; external msilib name 'MsiSummaryInfoSetPropertyA'; 2855 function MsiSummaryInfoSetPropertyW; external msilib name 'MsiSummaryInfoSetPropertyW'; 2856 function MsiSummaryInfoSetProperty; external msilib name 'MsiSummaryInfoSetProperty' + AWSuffix; 2857 function MsiSummaryInfoGetPropertyA; external msilib name 'MsiSummaryInfoGetPropertyA'; 2858 function MsiSummaryInfoGetPropertyW; external msilib name 'MsiSummaryInfoGetPropertyW'; 2859 function MsiSummaryInfoGetProperty; external msilib name 'MsiSummaryInfoGetProperty' + AWSuffix; 2860 function MsiSummaryInfoPersist; external msilib name 'MsiSummaryInfoPersist'; 2861 function MsiOpenDatabaseA; external msilib name 'MsiOpenDatabaseA'; 2862 function MsiOpenDatabaseW; external msilib name 'MsiOpenDatabaseW'; 2863 function MsiOpenDatabase; external msilib name 'MsiOpenDatabase' + AWSuffix; 2864 function MsiDatabaseImportA; external msilib name 'MsiDatabaseImportA'; 2865 function MsiDatabaseImportW; external msilib name 'MsiDatabaseImportW'; 2866 function MsiDatabaseImport; external msilib name 'MsiDatabaseImport' + AWSuffix; 2867 function MsiDatabaseExportA; external msilib name 'MsiDatabaseExportA'; 2868 function MsiDatabaseExportW; external msilib name 'MsiDatabaseExportW'; 2869 function MsiDatabaseExport; external msilib name 'MsiDatabaseExport' + AWSuffix; 2870 function MsiDatabaseMergeA; external msilib name 'MsiDatabaseMergeA'; 2871 function MsiDatabaseMergeW; external msilib name 'MsiDatabaseMergeW'; 2872 function MsiDatabaseMerge; external msilib name 'MsiDatabaseMerge' + AWSuffix; 2873 function MsiDatabaseGenerateTransformA; external msilib name 'MsiDatabaseGenerateTransformA'; 2874 function MsiDatabaseGenerateTransformW; external msilib name 'MsiDatabaseGenerateTransformW'; 2875 function MsiDatabaseGenerateTransform; external msilib name 'MsiDatabaseGenerateTransform' + AWSuffix; 2876 function MsiDatabaseApplyTransformA; external msilib name 'MsiDatabaseApplyTransformA'; 2877 function MsiDatabaseApplyTransformW; external msilib name 'MsiDatabaseApplyTransformW'; 2878 function MsiDatabaseApplyTransform; external msilib name 'MsiDatabaseApplyTransform' + AWSuffix; 2879 function MsiCreateTransformSummaryInfoA; external msilib name 'MsiCreateTransformSummaryInfoA'; 2880 function MsiCreateTransformSummaryInfoW; external msilib name 'MsiCreateTransformSummaryInfoW'; 2881 function MsiCreateTransformSummaryInfo; external msilib name 'MsiCreateTransformSummaryInfo' + AWSuffix; 2882 function MsiDatabaseCommit; external msilib name 'MsiDatabaseCommit'; 2883 function MsiGetDatabaseState; external msilib name 'MsiGetDatabaseState'; 2884 function MsiCreateRecord; external msilib name 'MsiCreateRecord'; 2885 function MsiRecordIsNull; external msilib name 'MsiRecordIsNull'; 2886 function MsiRecordDataSize; external msilib name 'MsiRecordDataSize'; 2887 function MsiRecordSetInteger; external msilib name 'MsiRecordSetInteger'; 2888 function MsiRecordSetStringA; external msilib name 'MsiRecordSetStringA'; 2889 function MsiRecordSetStringW; external msilib name 'MsiRecordSetStringW'; 2890 function MsiRecordSetString; external msilib name 'MsiRecordSetString' + AWSuffix; 2891 function MsiRecordGetInteger; external msilib name 'MsiRecordGetInteger'; 2892 function MsiRecordGetStringA; external msilib name 'MsiRecordGetStringA'; 2893 function MsiRecordGetStringW; external msilib name 'MsiRecordGetStringW'; 2894 function MsiRecordGetString; external msilib name 'MsiRecordGetString' + AWSuffix; 2895 function MsiRecordGetFieldCount; external msilib name 'MsiRecordGetFieldCount'; 2896 function MsiRecordSetStreamA; external msilib name 'MsiRecordSetStreamA'; 2897 function MsiRecordSetStreamW; external msilib name 'MsiRecordSetStreamW'; 2898 function MsiRecordSetStream; external msilib name 'MsiRecordSetStream' + AWSuffix; 2899 function MsiRecordReadStream; external msilib name 'MsiRecordReadStream'; 2900 function MsiRecordClearData; external msilib name 'MsiRecordClearData'; 2901 function MsiGetActiveDatabase; external msilib name 'MsiGetActiveDatabase'; 2902 function MsiSetPropertyA; external msilib name 'MsiSetPropertyA'; 2903 function MsiSetPropertyW; external msilib name 'MsiSetPropertyW'; 2904 function MsiSetProperty; external msilib name 'MsiSetProperty' + AWSuffix; 2905 function MsiGetPropertyA; external msilib name 'MsiGetPropertyA'; 2906 function MsiGetPropertyW; external msilib name 'MsiGetPropertyW'; 2907 function MsiGetProperty; external msilib name 'MsiGetProperty' + AWSuffix; 2908 function MsiGetLanguage; external msilib name 'MsiGetLanguage'; 2909 function MsiGetMode; external msilib name 'MsiGetMode'; 2910 function MsiSetMode; external msilib name 'MsiSetMode'; 2911 function MsiFormatRecordA; external msilib name 'MsiFormatRecordA'; 2912 function MsiFormatRecordW; external msilib name 'MsiFormatRecordW'; 2913 function MsiFormatRecord; external msilib name 'MsiFormatRecord' + AWSuffix; 2914 function MsiDoActionA; external msilib name 'MsiDoActionA'; 2915 function MsiDoActionW; external msilib name 'MsiDoActionW'; 2916 function MsiDoAction; external msilib name 'MsiDoAction' + AWSuffix; 2917 function MsiSequenceA; external msilib name 'MsiSequenceA'; 2918 function MsiSequenceW; external msilib name 'MsiSequenceW'; 2919 function MsiSequence; external msilib name 'MsiSequence' + AWSuffix; 2920 function MsiProcessMessage; external msilib name 'MsiProcessMessage'; 2921 function MsiEvaluateConditionA; external msilib name 'MsiEvaluateConditionA'; 2922 function MsiEvaluateConditionW; external msilib name 'MsiEvaluateConditionW'; 2923 function MsiEvaluateCondition; external msilib name 'MsiEvaluateCondition' + AWSuffix; 2924 function MsiGetFeatureStateA; external msilib name 'MsiGetFeatureStateA'; 2925 function MsiGetFeatureStateW; external msilib name 'MsiGetFeatureStateW'; 2926 function MsiGetFeatureState; external msilib name 'MsiGetFeatureState' + AWSuffix; 2927 function MsiSetFeatureStateA; external msilib name 'MsiSetFeatureStateA'; 2928 function MsiSetFeatureStateW; external msilib name 'MsiSetFeatureStateW'; 2929 function MsiSetFeatureState; external msilib name 'MsiSetFeatureState' + AWSuffix; 2930 function MsiSetFeatureAttributesA; external msilib name 'MsiSetFeatureAttributesA'; 2931 function MsiSetFeatureAttributesW; external msilib name 'MsiSetFeatureAttributesW'; 2932 function MsiSetFeatureAttributes; external msilib name 'MsiSetFeatureAttributes' + AWSuffix; 2933 function MsiGetComponentStateA; external msilib name 'MsiGetComponentStateA'; 2934 function MsiGetComponentStateW; external msilib name 'MsiGetComponentStateW'; 2935 function MsiGetComponentState; external msilib name 'MsiGetComponentState' + AWSuffix; 2936 function MsiSetComponentStateA; external msilib name 'MsiSetComponentStateA'; 2937 function MsiSetComponentStateW; external msilib name 'MsiSetComponentStateW'; 2938 function MsiSetComponentState; external msilib name 'MsiSetComponentState' + AWSuffix; 2939 function MsiGetFeatureCostA; external msilib name 'MsiGetFeatureCostA'; 2940 function MsiGetFeatureCostW; external msilib name 'MsiGetFeatureCostW'; 2941 function MsiGetFeatureCost; external msilib name 'MsiGetFeatureCost' + AWSuffix; 2942 function MsiEnumComponentCostsA; external msilib name 'MsiEnumComponentCostsA'; 2943 function MsiEnumComponentCostsW; external msilib name 'MsiEnumComponentCostsW'; 2944 function MsiEnumComponentCosts; external msilib name 'MsiEnumComponentCosts' + AWSuffix; 2945 function MsiSetInstallLevel; external msilib name 'MsiSetInstallLevel'; 2946 function MsiGetFeatureValidStatesA; external msilib name 'MsiGetFeatureValidStatesA'; 2947 function MsiGetFeatureValidStatesW; external msilib name 'MsiGetFeatureValidStatesW'; 2948 function MsiGetFeatureValidStates; external msilib name 'MsiGetFeatureValidStates' + AWSuffix; 2949 function MsiGetSourcePathA; external msilib name 'MsiGetSourcePathA'; 2950 function MsiGetSourcePathW; external msilib name 'MsiGetSourcePathW'; 2951 function MsiGetSourcePath; external msilib name 'MsiGetSourcePath' + AWSuffix; 2952 function MsiGetTargetPathA; external msilib name 'MsiGetTargetPathA'; 2953 function MsiGetTargetPathW; external msilib name 'MsiGetTargetPathW'; 2954 function MsiGetTargetPath; external msilib name 'MsiGetTargetPath' + AWSuffix; 2955 function MsiSetTargetPathA; external msilib name 'MsiSetTargetPathA'; 2956 function MsiSetTargetPathW; external msilib name 'MsiSetTargetPathW'; 2957 function MsiSetTargetPath; external msilib name 'MsiSetTargetPath' + AWSuffix; 2958 function MsiVerifyDiskSpace; external msilib name 'MsiVerifyDiskSpace'; 2959 function MsiEnableUIPreview; external msilib name 'MsiEnableUIPreview'; 2960 function MsiPreviewDialogA; external msilib name 'MsiPreviewDialogA'; 2961 function MsiPreviewDialogW; external msilib name 'MsiPreviewDialogW'; 2962 function MsiPreviewDialog; external msilib name 'MsiPreviewDialog' + AWSuffix; 2963 function MsiPreviewBillboardA; external msilib name 'MsiPreviewBillboardA'; 2964 function MsiPreviewBillboardW; external msilib name 'MsiPreviewBillboardW'; 2965 function MsiPreviewBillboard; external msilib name 'MsiPreviewBillboard' + AWSuffix; 2966 function MsiGetLastErrorRecord; external msilib name 'MsiGetLastErrorRecord'; 2967 2968 {$ENDIF DYNAMIC_LINK} 2969 2970 {$ENDIF JWA_INTERFACESECTION} 2971 2972 2973 {$IFNDEF JWA_OMIT_SECTIONS} 2974 end. 2975 {$ENDIF JWA_OMIT_SECTIONS} 2976