← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to fpcsrc/packages/base/winunits/jwapatchapi.pas

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fpcsrc/packages/base/winunits/jwapatchapi.pas
 
1
{******************************************************************************}
 
2
{                                                                              }
 
3
{ Creating and applying patches to filesAPI 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: patchapi.h, released August 2001. The original Pascal  }
 
9
{ code is: PatchApi.pas, released December 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: JwaPatchApi.pas,v 1.10 2005/09/06 16:36:50 marquardt Exp $
 
44
 
 
45
unit JwaPatchApi;
 
46
 
 
47
{$WEAKPACKAGEUNIT}
 
48
 
 
49
{$HPPEMIT ''}
 
50
{$HPPEMIT '#include "patchapi.h"'}
 
51
{$HPPEMIT ''}
 
52
 
 
53
{$I jediapilib.inc}
 
54
 
 
55
interface
 
56
 
 
57
uses
 
58
  JwaWindows;
 
59
 
 
60
//
 
61
//  The following constants can be combined and used as the OptionFlags
 
62
//  parameter in the patch creation apis.
 
63
//
 
64
 
 
65
const
 
66
  PATCH_OPTION_USE_BEST = $00000000; // auto choose best (slower)
 
67
  {$EXTERNALSYM PATCH_OPTION_USE_BEST}
 
68
 
 
69
  PATCH_OPTION_USE_LZX_BEST  = $00000003; // auto choose best of LZX
 
70
  {$EXTERNALSYM PATCH_OPTION_USE_LZX_BEST}
 
71
  PATCH_OPTION_USE_LZX_A     = $00000001; // normal
 
72
  {$EXTERNALSYM PATCH_OPTION_USE_LZX_A}
 
73
  PATCH_OPTION_USE_LZX_B     = $00000002; // better on some x86 binaries
 
74
  {$EXTERNALSYM PATCH_OPTION_USE_LZX_B}
 
75
  PATCH_OPTION_USE_LZX_LARGE = $00000004; // better support for files >8MB
 
76
  {$EXTERNALSYM PATCH_OPTION_USE_LZX_LARGE}
 
77
 
 
78
  PATCH_OPTION_NO_BINDFIX        = $00010000; // PE bound imports
 
79
  {$EXTERNALSYM PATCH_OPTION_NO_BINDFIX}
 
80
  PATCH_OPTION_NO_LOCKFIX        = $00020000; // PE smashed locks
 
81
  {$EXTERNALSYM PATCH_OPTION_NO_LOCKFIX}
 
82
  PATCH_OPTION_NO_REBASE         = $00040000; // PE rebased image
 
83
  {$EXTERNALSYM PATCH_OPTION_NO_REBASE}
 
84
  PATCH_OPTION_FAIL_IF_SAME_FILE = $00080000; // don't create if same
 
85
  {$EXTERNALSYM PATCH_OPTION_FAIL_IF_SAME_FILE}
 
86
  PATCH_OPTION_FAIL_IF_BIGGER    = $00100000; // fail if patch is larger than simply compressing new file (slower)
 
87
  {$EXTERNALSYM PATCH_OPTION_FAIL_IF_BIGGER}
 
88
  PATCH_OPTION_NO_CHECKSUM       = $00200000; // PE checksum zero
 
89
  {$EXTERNALSYM PATCH_OPTION_NO_CHECKSUM}
 
90
  PATCH_OPTION_NO_RESTIMEFIX     = $00400000; // PE resource timestamps
 
91
  {$EXTERNALSYM PATCH_OPTION_NO_RESTIMEFIX}
 
92
  PATCH_OPTION_NO_TIMESTAMP      = $00800000; // don't store new file timestamp in patch
 
93
  {$EXTERNALSYM PATCH_OPTION_NO_TIMESTAMP}
 
94
  PATCH_OPTION_SIGNATURE_MD5     = $01000000; // use MD5 instead of CRC32
 
95
  {$EXTERNALSYM PATCH_OPTION_SIGNATURE_MD5}
 
96
  PATCH_OPTION_RESERVED1         = DWORD($80000000); // (used internally)
 
97
  {$EXTERNALSYM PATCH_OPTION_RESERVED1}
 
98
 
 
99
  PATCH_OPTION_VALID_FLAGS = DWORD($80FF0007);
 
100
  {$EXTERNALSYM PATCH_OPTION_VALID_FLAGS}
 
101
 
 
102
  PATCH_SYMBOL_NO_IMAGEHLP     = $00000001; // don't use imagehlp.dll
 
103
  {$EXTERNALSYM PATCH_SYMBOL_NO_IMAGEHLP}
 
104
  PATCH_SYMBOL_NO_FAILURES     = $00000002; // don't fail patch due to imagehlp failures
 
105
  {$EXTERNALSYM PATCH_SYMBOL_NO_FAILURES}
 
106
  PATCH_SYMBOL_UNDECORATED_TOO = $00000004; // after matching decorated symbols, try to match remaining by undecorated names
 
107
  {$EXTERNALSYM PATCH_SYMBOL_UNDECORATED_TOO}
 
108
  PATCH_SYMBOL_RESERVED1       = DWORD($80000000); // (used internally)
 
109
  {$EXTERNALSYM PATCH_SYMBOL_RESERVED1}
 
110
 
 
111
//
 
112
//  The following constants can be combined and used as the ApplyOptionFlags
 
113
//  parameter in the patch apply and test apis.
 
114
//
 
115
 
 
116
  APPLY_OPTION_FAIL_IF_EXACT = $00000001; // don't copy new file
 
117
  {$EXTERNALSYM APPLY_OPTION_FAIL_IF_EXACT}
 
118
  APPLY_OPTION_FAIL_IF_CLOSE = $00000002; // differ by rebase, bind
 
119
  {$EXTERNALSYM APPLY_OPTION_FAIL_IF_CLOSE}
 
120
  APPLY_OPTION_TEST_ONLY     = $00000004; // don't create new file
 
121
  {$EXTERNALSYM APPLY_OPTION_TEST_ONLY}
 
122
  APPLY_OPTION_VALID_FLAGS   = $00000007;
 
123
  {$EXTERNALSYM APPLY_OPTION_VALID_FLAGS}
 
124
 
 
125
//
 
126
//  In addition to standard Win32 error codes, the following error codes may
 
127
//  be returned via GetLastError() when one of the patch APIs fails.
 
128
//
 
129
 
 
130
  ERROR_PATCH_ENCODE_FAILURE         = DWORD($C00E3101); // create
 
131
  {$EXTERNALSYM ERROR_PATCH_ENCODE_FAILURE}
 
132
  ERROR_PATCH_INVALID_OPTIONS        = DWORD($C00E3102); // create
 
133
  {$EXTERNALSYM ERROR_PATCH_INVALID_OPTIONS}
 
134
  ERROR_PATCH_SAME_FILE              = DWORD($C00E3103); // create
 
135
  {$EXTERNALSYM ERROR_PATCH_SAME_FILE}
 
136
  ERROR_PATCH_RETAIN_RANGES_DIFFER   = DWORD($C00E3104); // create
 
137
  {$EXTERNALSYM ERROR_PATCH_RETAIN_RANGES_DIFFER}
 
138
  ERROR_PATCH_BIGGER_THAN_COMPRESSED = DWORD($C00E3105); // create
 
139
  {$EXTERNALSYM ERROR_PATCH_BIGGER_THAN_COMPRESSED}
 
140
  ERROR_PATCH_IMAGEHLP_FAILURE       = DWORD($C00E3106); // create
 
141
  {$EXTERNALSYM ERROR_PATCH_IMAGEHLP_FAILURE}
 
142
 
 
143
  ERROR_PATCH_DECODE_FAILURE = DWORD($C00E4101); // apply
 
144
  {$EXTERNALSYM ERROR_PATCH_DECODE_FAILURE}
 
145
  ERROR_PATCH_CORRUPT        = DWORD($C00E4102); // apply
 
146
  {$EXTERNALSYM ERROR_PATCH_CORRUPT}
 
147
  ERROR_PATCH_NEWER_FORMAT   = DWORD($C00E4103); // apply
 
148
  {$EXTERNALSYM ERROR_PATCH_NEWER_FORMAT}
 
149
  ERROR_PATCH_WRONG_FILE     = DWORD($C00E4104); // apply
 
150
  {$EXTERNALSYM ERROR_PATCH_WRONG_FILE}
 
151
  ERROR_PATCH_NOT_NECESSARY  = DWORD($C00E4105); // apply
 
152
  {$EXTERNALSYM ERROR_PATCH_NOT_NECESSARY}
 
153
  ERROR_PATCH_NOT_AVAILABLE  = DWORD($C00E4106); // apply
 
154
  {$EXTERNALSYM ERROR_PATCH_NOT_AVAILABLE}
 
155
 
 
156
type
 
157
  PATCH_PROGRESS_CALLBACK = function(CallbackContext: PVOID; CurrentPosition, MaximumPosition: ULONG): BOOL; stdcall;
 
158
  {$EXTERNALSYM PATCH_PROGRESS_CALLBACK}
 
159
  TPatchProgressCallback = PATCH_PROGRESS_CALLBACK;
 
160
 
 
161
  PPATCH_PROGRESS_CALLBACK = ^PATCH_PROGRESS_CALLBACK;
 
162
  {$EXTERNALSYM PPATCH_PROGRESS_CALLBACK}
 
163
  PPatchProgressCallback = PPATCH_PROGRESS_CALLBACK;
 
164
 
 
165
  PATCH_SYMLOAD_CALLBACK = function(WhichFile: ULONG; SymbolFileName: LPCSTR; SymType, SymbolFileCheckSum,
 
166
    SymbolFileTimeDate, ImageFileCheckSum, ImageFileTimeDate: ULONG; CallbackContext: PVOID): BOOL; stdcall;
 
167
  {$EXTERNALSYM PATCH_SYMLOAD_CALLBACK}
 
168
  TPatchSymLoadCallback = PATCH_SYMLOAD_CALLBACK;
 
169
 
 
170
  PPATCH_SYMLOAD_CALLBACK = ^PATCH_SYMLOAD_CALLBACK;
 
171
  {$EXTERNALSYM PPATCH_SYMLOAD_CALLBACK}
 
172
  PPatchSymLoadCallback = PPATCH_SYMLOAD_CALLBACK;
 
173
 
 
174
  PPATCH_IGNORE_RANGE = ^PATCH_IGNORE_RANGE;
 
175
  {$EXTERNALSYM PPATCH_IGNORE_RANGE}
 
176
  _PATCH_IGNORE_RANGE = record
 
177
    OffsetInOldFile: ULONG;
 
178
    LengthInBytes: ULONG;
 
179
  end;
 
180
  {$EXTERNALSYM _PATCH_IGNORE_RANGE}
 
181
  PATCH_IGNORE_RANGE = _PATCH_IGNORE_RANGE;
 
182
  {$EXTERNALSYM PATCH_IGNORE_RANGE}
 
183
  TPatchIgnoreRange = PATCH_IGNORE_RANGE;
 
184
  PPatchIgnoreRange = PPATCH_IGNORE_RANGE;
 
185
 
 
186
  PPATCH_RETAIN_RANGE = ^PATCH_RETAIN_RANGE;
 
187
  {$EXTERNALSYM PPATCH_RETAIN_RANGE}
 
188
  _PATCH_RETAIN_RANGE = record
 
189
    OffsetInOldFile: ULONG;
 
190
    LengthInBytes: ULONG;
 
191
    OffsetInNewFile: ULONG;
 
192
  end;
 
193
  {$EXTERNALSYM _PATCH_RETAIN_RANGE}
 
194
  PATCH_RETAIN_RANGE = _PATCH_RETAIN_RANGE;
 
195
  {$EXTERNALSYM PATCH_RETAIN_RANGE}
 
196
  TPatchRetainRange = PATCH_RETAIN_RANGE;
 
197
  PPatchRetainRange = PPATCH_RETAIN_RANGE;
 
198
 
 
199
  PPATCH_OLD_FILE_INFO_A = ^PATCH_OLD_FILE_INFO_A;
 
200
  {$EXTERNALSYM PPATCH_OLD_FILE_INFO_A}
 
201
  _PATCH_OLD_FILE_INFO_A = record
 
202
    SizeOfThisStruct: ULONG;
 
203
    OldFileName: LPCSTR;
 
204
    IgnoreRangeCount: ULONG; // maximum 255
 
205
    IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
206
    RetainRangeCount: ULONG; // maximum 255
 
207
    RetainRangeArray: PPATCH_RETAIN_RANGE;
 
208
  end;
 
209
  {$EXTERNALSYM _PATCH_OLD_FILE_INFO_A}
 
210
  PATCH_OLD_FILE_INFO_A = _PATCH_OLD_FILE_INFO_A;
 
211
  {$EXTERNALSYM PATCH_OLD_FILE_INFO_A}
 
212
  TPatchOldFileInfoA = PATCH_OLD_FILE_INFO_A;
 
213
  PPatchOldFileInfoA = PPATCH_OLD_FILE_INFO_A;
 
214
 
 
215
  PPATCH_OLD_FILE_INFO_W = ^PATCH_OLD_FILE_INFO_W;
 
216
  {$EXTERNALSYM PPATCH_OLD_FILE_INFO_W}
 
217
  _PATCH_OLD_FILE_INFO_W = record
 
218
    SizeOfThisStruct: ULONG;
 
219
    OldFileName: LPCWSTR;
 
220
    IgnoreRangeCount: ULONG; // maximum 255
 
221
    IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
222
    RetainRangeCount: ULONG; // maximum 255
 
223
    RetainRangeArray: PPATCH_RETAIN_RANGE;
 
224
  end;
 
225
  {$EXTERNALSYM _PATCH_OLD_FILE_INFO_W}
 
226
  PATCH_OLD_FILE_INFO_W = _PATCH_OLD_FILE_INFO_W;
 
227
  {$EXTERNALSYM PATCH_OLD_FILE_INFO_W}
 
228
  TPatchOldFileInfoW = PATCH_OLD_FILE_INFO_W;
 
229
  PPatchOldFileInfoW = PPATCH_OLD_FILE_INFO_W;
 
230
 
 
231
  PPATCH_OLD_FILE_INFO_H = ^PATCH_OLD_FILE_INFO_H;
 
232
  {$EXTERNALSYM PPATCH_OLD_FILE_INFO_H}
 
233
  _PATCH_OLD_FILE_INFO_H = record
 
234
    SizeOfThisStruct: ULONG;
 
235
    OldFileHandle: HANDLE;
 
236
    IgnoreRangeCount: ULONG; // maximum 255
 
237
    IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
238
    RetainRangeCount: ULONG; // maximum 255
 
239
    RetainRangeArray: PPATCH_RETAIN_RANGE;
 
240
  end;
 
241
  {$EXTERNALSYM _PATCH_OLD_FILE_INFO_H}
 
242
  PATCH_OLD_FILE_INFO_H = _PATCH_OLD_FILE_INFO_H;
 
243
  {$EXTERNALSYM PATCH_OLD_FILE_INFO_H}
 
244
  TPatchOldFileInfoH = PATCH_OLD_FILE_INFO_H;
 
245
  PPatchOldFileInfoH = PPATCH_OLD_FILE_INFO_H;
 
246
 
 
247
  PPATCH_OLD_FILE_INFO = ^PATCH_OLD_FILE_INFO;
 
248
  {$EXTERNALSYM PPATCH_OLD_FILE_INFO}
 
249
  _PATCH_OLD_FILE_INFO = record
 
250
    SizeOfThisStruct: ULONG;
 
251
    Union: record
 
252
    case Integer of
 
253
      0: (OldFileNameA: LPCSTR);
 
254
      1: (OldFileNameW: LPCWSTR);
 
255
      2: (OldFileHandle: HANDLE);
 
256
    end;
 
257
    IgnoreRangeCount: ULONG; // maximum 255
 
258
    IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
259
    RetainRangeCount: ULONG; // maximum 255
 
260
    RetainRangeArray: PPATCH_RETAIN_RANGE;
 
261
  end;
 
262
  {$EXTERNALSYM _PATCH_OLD_FILE_INFO}
 
263
  PATCH_OLD_FILE_INFO = _PATCH_OLD_FILE_INFO;
 
264
  {$EXTERNALSYM PATCH_OLD_FILE_INFO}
 
265
  TPatchOldFileInfo = PATCH_OLD_FILE_INFO;
 
266
  PPatchOldFileInfo = PPATCH_OLD_FILE_INFO;
 
267
 
 
268
  PPATCH_OPTION_DATA = ^PATCH_OPTION_DATA;
 
269
  {$EXTERNALSYM PPATCH_OPTION_DATA}
 
270
  _PATCH_OPTION_DATA = record
 
271
    SizeOfThisStruct: ULONG;
 
272
    SymbolOptionFlags: ULONG; // PATCH_SYMBOL_xxx flags
 
273
    NewFileSymbolPath: LPCSTR; // always ANSI, never Unicode
 
274
    OldFileSymbolPathArray: ^LPCSTR; // array[ OldFileCount ]
 
275
    ExtendedOptionFlags: ULONG;
 
276
    SymLoadCallback: PATCH_SYMLOAD_CALLBACK;
 
277
    SymLoadContext: PVOID;
 
278
  end;
 
279
  {$EXTERNALSYM _PATCH_OPTION_DATA}
 
280
  PATCH_OPTION_DATA = _PATCH_OPTION_DATA;
 
281
  {$EXTERNALSYM PATCH_OPTION_DATA}
 
282
  TPatchOptionData = PATCH_OPTION_DATA;
 
283
  PPatchOptionData = PPATCH_OPTION_DATA;
 
284
 
 
285
//
 
286
//  Note that PATCH_OPTION_DATA contains LPCSTR paths, and no LPCWSTR (Unicode)
 
287
//  path argument is available, even when used with one of the Unicode APIs
 
288
//  such as CreatePatchFileW.  This is because the underlying system services
 
289
//  for symbol file handling (IMAGEHLP.DLL) only support ANSI file/path names.
 
290
//
 
291
 
 
292
//
 
293
//  A note about PATCH_RETAIN_RANGE specifiers with multiple old files:
 
294
//
 
295
//  Each old version file must have the same RetainRangeCount, and the same
 
296
//  retain range LengthInBytes and OffsetInNewFile values in the same order.
 
297
//  Only the OffsetInOldFile values can differ between old files for retain
 
298
//  ranges.
 
299
//
 
300
 
 
301
//
 
302
//  The following prototypes are interface for creating patches from files.
 
303
//
 
304
 
 
305
function CreatePatchFileA(OldFileName: LPCSTR; NewFileName: LPCSTR; PatchFileName: LPCSTR; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
 
306
{$EXTERNALSYM CreatePatchFileA}
 
307
 
 
308
function CreatePatchFileW(OldFileName: LPCWSTR; NewFileName: LPCWSTR; PatchFileName: LPCWSTR; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
 
309
{$EXTERNALSYM CreatePatchFileW}
 
310
 
 
311
function CreatePatchFileByHandles(OldFileHandle: HANDLE; NewFileHandle: HANDLE; PatchFileHandle: HANDLE; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
 
312
{$EXTERNALSYM CreatePatchFileByHandles}
 
313
 
 
314
function CreatePatchFileExA(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_A; NewFileName: LPCSTR; PatchFileName: LPCSTR;
 
315
  OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
316
{$EXTERNALSYM CreatePatchFileExA}
 
317
 
 
318
function CreatePatchFileExW(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_W; NewFileName: LPCWSTR; PatchFileName: LPCWSTR;
 
319
  OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
320
{$EXTERNALSYM CreatePatchFileExW}
 
321
 
 
322
function CreatePatchFileByHandlesEx(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_H; NewFileHandle: HANDLE;
 
323
  PatchFileHandle: HANDLE; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
324
{$EXTERNALSYM CreatePatchFileByHandlesEx}
 
325
 
 
326
function ExtractPatchHeaderToFileA(PatchFileName: LPCSTR; PatchHeaderFileName: LPCSTR): BOOL; stdcall;
 
327
{$EXTERNALSYM ExtractPatchHeaderToFileA}
 
328
 
 
329
function ExtractPatchHeaderToFileW(PatchFileName: LPCWSTR; PatchHeaderFileName: LPCWSTR): BOOL; stdcall;
 
330
{$EXTERNALSYM ExtractPatchHeaderToFileW}
 
331
 
 
332
function ExtractPatchHeaderToFileByHandles(PatchFileHandle: HANDLE; PatchHeaderFileHandle: HANDLE): BOOL; stdcall;
 
333
{$EXTERNALSYM ExtractPatchHeaderToFileByHandles}
 
334
 
 
335
//
 
336
//  The following prototypes are interface for creating new file from old file
 
337
//  and patch file.  Note that it is possible for the TestApply API to succeed
 
338
//  but the actual Apply to fail since the TestApply only verifies that the
 
339
//  old file has the correct CRC without actually applying the patch.  The
 
340
//  TestApply API only requires the patch header portion of the patch file,
 
341
//  but its CRC must be fixed up.
 
342
//
 
343
 
 
344
function TestApplyPatchToFileA(PatchFileName: LPCSTR; OldFileName: LPCSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
345
{$EXTERNALSYM TestApplyPatchToFileA}
 
346
 
 
347
function TestApplyPatchToFileW(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
348
{$EXTERNALSYM TestApplyPatchToFileW}
 
349
 
 
350
function TestApplyPatchToFileByHandles(PatchFileHandle: HANDLE; OldFileHandle: HANDLE; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
351
{$EXTERNALSYM TestApplyPatchToFileByHandles}
 
352
 
 
353
function ApplyPatchToFileA(PatchFileName: LPCSTR; OldFileName: LPCSTR; NewFileName: LPCSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
354
{$EXTERNALSYM ApplyPatchToFileA}
 
355
 
 
356
function ApplyPatchToFileW(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; NewFileName: LPCWSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
357
{$EXTERNALSYM ApplyPatchToFileW}
 
358
 
 
359
function ApplyPatchToFileByHandles(PatchFileHandle: HANDLE; OldFileHandle: HANDLE; NewFileHandle: HANDLE; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
360
{$EXTERNALSYM ApplyPatchToFileByHandles}
 
361
 
 
362
function ApplyPatchToFileExA(PatchFileName: LPCSTR; OldFileName: LPCSTR; NewFileName: LPCSTR; ApplyOptionFlags: ULONG;
 
363
  ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
364
{$EXTERNALSYM ApplyPatchToFileExA}
 
365
 
 
366
function ApplyPatchToFileExW(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; NewFileName: LPCWSTR; ApplyOptionFlags: ULONG;
 
367
  ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
368
{$EXTERNALSYM ApplyPatchToFileExW}
 
369
 
 
370
function ApplyPatchToFileByHandlesEx(PatchFileHandle: HANDLE; OldFileHandle: HANDLE; NewFileHandle: HANDLE;
 
371
  ApplyOptionFlags: ULONG; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
372
{$EXTERNALSYM ApplyPatchToFileByHandlesEx}
 
373
 
 
374
//
 
375
//  The following prototypes provide a unique patch "signature" for a given
 
376
//  file.  Consider the case where you have a new foo.dll and the machines
 
377
//  to be updated with the new foo.dll may have one of three different old
 
378
//  foo.dll files.  Rather than creating a single large patch file that can
 
379
//  update any of the three older foo.dll files, three separate smaller patch
 
380
//  files can be created and "named" according to the patch signature of the
 
381
//  old file.  Then the patch applyer application can determine at runtime
 
382
//  which of the three foo.dll patch files is necessary given the specific
 
383
//  foo.dll to be updated.  If patch files are being downloaded over a slow
 
384
//  network connection (Internet over a modem), this signature scheme provides
 
385
//  a mechanism for choosing the correct single patch file to download at
 
386
//  application time thus decreasing total bytes necessary to download.
 
387
//
 
388
 
 
389
function GetFilePatchSignatureA(FileName: LPCSTR; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
390
  RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSize: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
 
391
{$EXTERNALSYM GetFilePatchSignatureA}
 
392
 
 
393
function GetFilePatchSignatureW(FileName: LPCWSTR; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
394
  RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSizeInBytes: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
 
395
{$EXTERNALSYM GetFilePatchSignatureW}
 
396
 
 
397
function GetFilePatchSignatureByHandle(FileHandle: HANDLE; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
398
  RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSize: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
 
399
{$EXTERNALSYM GetFilePatchSignatureByHandle}
 
400
 
 
401
//
 
402
//  Depending on whether UNICODE is defined, map the generic API names to the
 
403
//  appropriate Unicode or Ansi APIs.
 
404
//
 
405
 
 
406
function CreatePatchFile(OldFileName: LPCTSTR; NewFileName: LPCTSTR; PatchFileName: LPCTSTR; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
 
407
{$EXTERNALSYM CreatePatchFile}
 
408
function CreatePatchFileEx(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO; NewFileName: LPCTSTR; PatchFileName: LPCTSTR;
 
409
  OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
410
{$EXTERNALSYM CreatePatchFileEx}
 
411
function ExtractPatchHeaderToFile(PatchFileName: LPCTSTR; PatchHeaderFileName: LPCTSTR): BOOL; stdcall;
 
412
{$EXTERNALSYM ExtractPatchHeaderToFile}
 
413
function TestApplyPatchToFile(PatchFileName: LPCTSTR; OldFileName: LPCTSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
414
{$EXTERNALSYM TestApplyPatchToFile}
 
415
function ApplyPatchToFile(PatchFileName: LPCTSTR; OldFileName: LPCTSTR; NewFileName: LPCTSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
 
416
{$EXTERNALSYM ApplyPatchToFile}
 
417
function ApplyPatchToFileEx(PatchFileName: LPCTSTR; OldFileName: LPCTSTR; NewFileName: LPCTSTR; ApplyOptionFlags: ULONG; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
 
418
{$EXTERNALSYM ApplyPatchToFileEx}
 
419
function GetFilePatchSignature(FileName: LPCTSTR; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
 
420
  RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSizeInBytes: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
 
421
{$EXTERNALSYM GetFilePatchSignature}
 
422
 
 
423
implementation
 
424
 
 
425
uses
 
426
  JwaWinDLLNames;
 
427
 
 
428
{$IFDEF DYNAMIC_LINK}
 
429
 
 
430
var
 
431
  _CreatePatchFileA: Pointer;
 
432
 
 
433
function CreatePatchFileA;
 
434
begin
 
435
  GetProcedureAddress(_CreatePatchFileA, patchapi, 'CreatePatchFileA');
 
436
  asm
 
437
        MOV     ESP, EBP
 
438
        POP     EBP
 
439
        JMP     [_CreatePatchFileA]
 
440
  end;
 
441
end;
 
442
 
 
443
var
 
444
  _CreatePatchFileW: Pointer;
 
445
 
 
446
function CreatePatchFileW;
 
447
begin
 
448
  GetProcedureAddress(_CreatePatchFileW, patchapi, 'CreatePatchFileW');
 
449
  asm
 
450
        MOV     ESP, EBP
 
451
        POP     EBP
 
452
        JMP     [_CreatePatchFileW]
 
453
  end;
 
454
end;
 
455
 
 
456
var
 
457
  _CreatePatchFileByHandles: Pointer;
 
458
 
 
459
function CreatePatchFileByHandles;
 
460
begin
 
461
  GetProcedureAddress(_CreatePatchFileByHandles, patchapi, 'CreatePatchFileByHandles');
 
462
  asm
 
463
        MOV     ESP, EBP
 
464
        POP     EBP
 
465
        JMP     [_CreatePatchFileByHandles]
 
466
  end;
 
467
end;
 
468
 
 
469
var
 
470
  _CreatePatchFileExA: Pointer;
 
471
 
 
472
function CreatePatchFileExA;
 
473
begin
 
474
  GetProcedureAddress(_CreatePatchFileExA, patchapi, 'CreatePatchFileExA');
 
475
  asm
 
476
        MOV     ESP, EBP
 
477
        POP     EBP
 
478
        JMP     [_CreatePatchFileExA]
 
479
  end;
 
480
end;
 
481
 
 
482
var
 
483
  _CreatePatchFileExW: Pointer;
 
484
 
 
485
function CreatePatchFileExW;
 
486
begin
 
487
  GetProcedureAddress(_CreatePatchFileExW, patchapi, 'CreatePatchFileExW');
 
488
  asm
 
489
        MOV     ESP, EBP
 
490
        POP     EBP
 
491
        JMP     [_CreatePatchFileExW]
 
492
  end;
 
493
end;
 
494
 
 
495
var
 
496
  _CreatePatchFileByHandlesEx: Pointer;
 
497
 
 
498
function CreatePatchFileByHandlesEx;
 
499
begin
 
500
  GetProcedureAddress(_CreatePatchFileByHandlesEx, patchapi, 'CreatePatchFileByHandlesEx');
 
501
  asm
 
502
        MOV     ESP, EBP
 
503
        POP     EBP
 
504
        JMP     [_CreatePatchFileByHandlesEx]
 
505
  end;
 
506
end;
 
507
 
 
508
var
 
509
  _ExtractPatchHeaderToFileA: Pointer;
 
510
 
 
511
function ExtractPatchHeaderToFileA;
 
512
begin
 
513
  GetProcedureAddress(_ExtractPatchHeaderToFileA, patchapi, 'ExtractPatchHeaderToFileA');
 
514
  asm
 
515
        MOV     ESP, EBP
 
516
        POP     EBP
 
517
        JMP     [_ExtractPatchHeaderToFileA]
 
518
  end;
 
519
end;
 
520
 
 
521
var
 
522
  _ExtractPatchHeaderToFileW: Pointer;
 
523
 
 
524
function ExtractPatchHeaderToFileW;
 
525
begin
 
526
  GetProcedureAddress(_ExtractPatchHeaderToFileW, patchapi, 'ExtractPatchHeaderToFileW');
 
527
  asm
 
528
        MOV     ESP, EBP
 
529
        POP     EBP
 
530
        JMP     [_ExtractPatchHeaderToFileW]
 
531
  end;
 
532
end;
 
533
 
 
534
var
 
535
  _ExtrPatchHdrToFileByHandles: Pointer;
 
536
 
 
537
function ExtractPatchHeaderToFileByHandles;
 
538
begin
 
539
  GetProcedureAddress(_ExtrPatchHdrToFileByHandles, patchapi, 'ExtractPatchHeaderToFileByHandles');
 
540
  asm
 
541
        MOV     ESP, EBP
 
542
        POP     EBP
 
543
        JMP     [_ExtrPatchHdrToFileByHandles]
 
544
  end;
 
545
end;
 
546
 
 
547
var
 
548
  _TestApplyPatchToFileA: Pointer;
 
549
 
 
550
function TestApplyPatchToFileA;
 
551
begin
 
552
  GetProcedureAddress(_TestApplyPatchToFileA, patchapi, 'TestApplyPatchToFileA');
 
553
  asm
 
554
        MOV     ESP, EBP
 
555
        POP     EBP
 
556
        JMP     [_TestApplyPatchToFileA]
 
557
  end;
 
558
end;
 
559
 
 
560
var
 
561
  _TestApplyPatchToFileW: Pointer;
 
562
 
 
563
function TestApplyPatchToFileW;
 
564
begin
 
565
  GetProcedureAddress(_TestApplyPatchToFileW, patchapi, 'TestApplyPatchToFileW');
 
566
  asm
 
567
        MOV     ESP, EBP
 
568
        POP     EBP
 
569
        JMP     [_TestApplyPatchToFileW]
 
570
  end;
 
571
end;
 
572
 
 
573
var
 
574
  _TestApplyPatchToFileByHandles: Pointer;
 
575
 
 
576
function TestApplyPatchToFileByHandles;
 
577
begin
 
578
  GetProcedureAddress(_TestApplyPatchToFileByHandles, patchapi, 'TestApplyPatchToFileByHandles');
 
579
  asm
 
580
        MOV     ESP, EBP
 
581
        POP     EBP
 
582
        JMP     [_TestApplyPatchToFileByHandles]
 
583
  end;
 
584
end;
 
585
 
 
586
var
 
587
  _ApplyPatchToFileA: Pointer;
 
588
 
 
589
function ApplyPatchToFileA;
 
590
begin
 
591
  GetProcedureAddress(_ApplyPatchToFileA, patchapi, 'ApplyPatchToFileA');
 
592
  asm
 
593
        MOV     ESP, EBP
 
594
        POP     EBP
 
595
        JMP     [_ApplyPatchToFileA]
 
596
  end;
 
597
end;
 
598
 
 
599
var
 
600
  _ApplyPatchToFileW: Pointer;
 
601
 
 
602
function ApplyPatchToFileW;
 
603
begin
 
604
  GetProcedureAddress(_ApplyPatchToFileW, patchapi, 'ApplyPatchToFileW');
 
605
  asm
 
606
        MOV     ESP, EBP
 
607
        POP     EBP
 
608
        JMP     [_ApplyPatchToFileW]
 
609
  end;
 
610
end;
 
611
 
 
612
var
 
613
  _ApplyPatchToFileByHandles: Pointer;
 
614
 
 
615
function ApplyPatchToFileByHandles;
 
616
begin
 
617
  GetProcedureAddress(_ApplyPatchToFileByHandles, patchapi, 'ApplyPatchToFileByHandles');
 
618
  asm
 
619
        MOV     ESP, EBP
 
620
        POP     EBP
 
621
        JMP     [_ApplyPatchToFileByHandles]
 
622
  end;
 
623
end;
 
624
 
 
625
var
 
626
  _ApplyPatchToFileExA: Pointer;
 
627
 
 
628
function ApplyPatchToFileExA;
 
629
begin
 
630
  GetProcedureAddress(_ApplyPatchToFileExA, patchapi, 'ApplyPatchToFileExA');
 
631
  asm
 
632
        MOV     ESP, EBP
 
633
        POP     EBP
 
634
        JMP     [_ApplyPatchToFileExA]
 
635
  end;
 
636
end;
 
637
 
 
638
var
 
639
  _ApplyPatchToFileExW: Pointer;
 
640
 
 
641
function ApplyPatchToFileExW;
 
642
begin
 
643
  GetProcedureAddress(_ApplyPatchToFileExW, patchapi, 'ApplyPatchToFileExW');
 
644
  asm
 
645
        MOV     ESP, EBP
 
646
        POP     EBP
 
647
        JMP     [_ApplyPatchToFileExW]
 
648
  end;
 
649
end;
 
650
 
 
651
var
 
652
  _ApplyPatchToFileByHandlesEx: Pointer;
 
653
 
 
654
function ApplyPatchToFileByHandlesEx;
 
655
begin
 
656
  GetProcedureAddress(_ApplyPatchToFileByHandlesEx, patchapi, 'ApplyPatchToFileByHandlesEx');
 
657
  asm
 
658
        MOV     ESP, EBP
 
659
        POP     EBP
 
660
        JMP     [_ApplyPatchToFileByHandlesEx]
 
661
  end;
 
662
end;
 
663
 
 
664
var
 
665
  _GetFilePatchSignatureA: Pointer;
 
666
 
 
667
function GetFilePatchSignatureA;
 
668
begin
 
669
  GetProcedureAddress(_GetFilePatchSignatureA, patchapi, 'GetFilePatchSignatureA');
 
670
  asm
 
671
        MOV     ESP, EBP
 
672
        POP     EBP
 
673
        JMP     [_GetFilePatchSignatureA]
 
674
  end;
 
675
end;
 
676
 
 
677
var
 
678
  _GetFilePatchSignatureW: Pointer;
 
679
 
 
680
function GetFilePatchSignatureW;
 
681
begin
 
682
  GetProcedureAddress(_GetFilePatchSignatureW, patchapi, 'GetFilePatchSignatureW');
 
683
  asm
 
684
        MOV     ESP, EBP
 
685
        POP     EBP
 
686
        JMP     [_GetFilePatchSignatureW]
 
687
  end;
 
688
end;
 
689
 
 
690
var
 
691
  _GetFilePatchSignatureByHandle: Pointer;
 
692
 
 
693
function GetFilePatchSignatureByHandle;
 
694
begin
 
695
  GetProcedureAddress(_GetFilePatchSignatureByHandle, patchapi, 'GetFilePatchSignatureByHandle');
 
696
  asm
 
697
        MOV     ESP, EBP
 
698
        POP     EBP
 
699
        JMP     [_GetFilePatchSignatureByHandle]
 
700
  end;
 
701
end;
 
702
 
 
703
var
 
704
  _CreatePatchFile: Pointer;
 
705
 
 
706
function CreatePatchFile;
 
707
begin
 
708
  GetProcedureAddress(_CreatePatchFile, patchapi, 'CreatePatchFile' + AWSuffix);
 
709
  asm
 
710
        MOV     ESP, EBP
 
711
        POP     EBP
 
712
        JMP     [_CreatePatchFile]
 
713
  end;
 
714
end;
 
715
 
 
716
var
 
717
  _CreatePatchFileEx: Pointer;
 
718
 
 
719
function CreatePatchFileEx;
 
720
begin
 
721
  GetProcedureAddress(_CreatePatchFileEx, patchapi, 'CreatePatchFileEx' + AWSuffix);
 
722
  asm
 
723
        MOV     ESP, EBP
 
724
        POP     EBP
 
725
        JMP     [_CreatePatchFileEx]
 
726
  end;
 
727
end;
 
728
 
 
729
var
 
730
  _ExtractPatchHeaderToFile: Pointer;
 
731
 
 
732
function ExtractPatchHeaderToFile;
 
733
begin
 
734
  GetProcedureAddress(_ExtractPatchHeaderToFile, patchapi, 'ExtractPatchHeaderToFile' + AWSuffix);
 
735
  asm
 
736
        MOV     ESP, EBP
 
737
        POP     EBP
 
738
        JMP     [_ExtractPatchHeaderToFile]
 
739
  end;
 
740
end;
 
741
 
 
742
var
 
743
  _TestApplyPatchToFile: Pointer;
 
744
 
 
745
function TestApplyPatchToFile;
 
746
begin
 
747
  GetProcedureAddress(_TestApplyPatchToFile, patchapi, 'TestApplyPatchToFile' + AWSuffix);
 
748
  asm
 
749
        MOV     ESP, EBP
 
750
        POP     EBP
 
751
        JMP     [_TestApplyPatchToFile]
 
752
  end;
 
753
end;
 
754
 
 
755
var
 
756
  _ApplyPatchToFile: Pointer;
 
757
 
 
758
function ApplyPatchToFile;
 
759
begin
 
760
  GetProcedureAddress(_ApplyPatchToFile, patchapi, 'ApplyPatchToFile' + AWSuffix);
 
761
  asm
 
762
        MOV     ESP, EBP
 
763
        POP     EBP
 
764
        JMP     [_ApplyPatchToFile]
 
765
  end;
 
766
end;
 
767
 
 
768
var
 
769
  _ApplyPatchToFileEx: Pointer;
 
770
 
 
771
function ApplyPatchToFileEx;
 
772
begin
 
773
  GetProcedureAddress(_ApplyPatchToFileEx, patchapi, 'ApplyPatchToFileEx' + AWSuffix);
 
774
  asm
 
775
        MOV     ESP, EBP
 
776
        POP     EBP
 
777
        JMP     [_ApplyPatchToFileEx]
 
778
  end;
 
779
end;
 
780
 
 
781
var
 
782
  _GetFilePatchSignature: Pointer;
 
783
 
 
784
function GetFilePatchSignature;
 
785
begin
 
786
  GetProcedureAddress(_GetFilePatchSignature, patchapi, 'GetFilePatchSignature' + AWSuffix);
 
787
  asm
 
788
        MOV     ESP, EBP
 
789
        POP     EBP
 
790
        JMP     [_GetFilePatchSignature]
 
791
  end;
 
792
end;
 
793
 
 
794
{$ELSE}
 
795
 
 
796
function CreatePatchFileA; external patchapi name 'CreatePatchFileA';
 
797
function CreatePatchFileW; external patchapi name 'CreatePatchFileW';
 
798
function CreatePatchFileByHandles; external patchapi name 'CreatePatchFileByHandles';
 
799
function CreatePatchFileExA; external patchapi name 'CreatePatchFileExA';
 
800
function CreatePatchFileExW; external patchapi name 'CreatePatchFileExW';
 
801
function CreatePatchFileByHandlesEx; external patchapi name 'CreatePatchFileByHandlesEx';
 
802
function ExtractPatchHeaderToFileA; external patchapi name 'ExtractPatchHeaderToFileA';
 
803
function ExtractPatchHeaderToFileW; external patchapi name 'ExtractPatchHeaderToFileW';
 
804
function ExtractPatchHeaderToFileByHandles; external patchapi name 'ExtractPatchHeaderToFileByHandles';
 
805
function TestApplyPatchToFileA; external patchapi name 'TestApplyPatchToFileA';
 
806
function TestApplyPatchToFileW; external patchapi name 'TestApplyPatchToFileW';
 
807
function TestApplyPatchToFileByHandles; external patchapi name 'TestApplyPatchToFileByHandles';
 
808
function ApplyPatchToFileA; external patchapi name 'ApplyPatchToFileA';
 
809
function ApplyPatchToFileW; external patchapi name 'ApplyPatchToFileW';
 
810
function ApplyPatchToFileByHandles; external patchapi name 'ApplyPatchToFileByHandles';
 
811
function ApplyPatchToFileExA; external patchapi name 'ApplyPatchToFileExA';
 
812
function ApplyPatchToFileExW; external patchapi name 'ApplyPatchToFileExW';
 
813
function ApplyPatchToFileByHandlesEx; external patchapi name 'ApplyPatchToFileByHandlesEx';
 
814
function GetFilePatchSignatureA; external patchapi name 'GetFilePatchSignatureA';
 
815
function GetFilePatchSignatureW; external patchapi name 'GetFilePatchSignatureW';
 
816
function GetFilePatchSignatureByHandle; external patchapi name 'GetFilePatchSignatureByHandle';
 
817
function CreatePatchFile; external patchapi name 'CreatePatchFile' + AWSuffix;
 
818
function CreatePatchFileEx; external patchapi name 'CreatePatchFileEx' + AWSuffix;
 
819
function ExtractPatchHeaderToFile; external patchapi name 'ExtractPatchHeaderToFile' + AWSuffix;
 
820
function TestApplyPatchToFile; external patchapi name 'TestApplyPatchToFile' + AWSuffix;
 
821
function ApplyPatchToFile; external patchapi name 'ApplyPatchToFile' + AWSuffix;
 
822
function ApplyPatchToFileEx; external patchapi name 'ApplyPatchToFileEx' + AWSuffix;
 
823
function GetFilePatchSignature; external patchapi name 'GetFilePatchSignature' + AWSuffix;
 
824
 
 
825
{$ENDIF DYNAMIC_LINK}
 
826
 
 
827
end.