← Back to branch summary

~ubuntu-branches/ubuntu/dapper/fpc/dapper

« back to all changes in this revision

Viewing changes to packages/extra/winunits/jwatlhelp32.pas

  • Committer: Bazaar Package Importer
  • Author(s): Carlos Laviola
  • Date: 2005-05-30 11:59:10 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050530115910-x5pbzm4qqta4i94h
Tags: 2.0.0-2
http://bugs.debian.org/310907
debian/fp-compiler.postinst.in: forgot to reapply the patch that
correctly creates the slave link to pc(1).  (Closes: #310907)

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/extra/winunits/jwatlhelp32.pas
 
1
{******************************************************************************}
 
2
{                                                                              }
 
3
{ ToolHelp 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: tlhelp32.h, released June 2000. The original Pascal    }
 
9
{ code is: TlHelp32.pas, released December 2000. 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: jwatlhelp32.pas,v 1.1 2005/04/04 07:56:10 marco Exp $
 
44
 
 
45
unit JwaTlHelp32;
 
46
 
 
47
{$WEAKPACKAGEUNIT}
 
48
 
 
49
{$HPPEMIT ''}
 
50
{$HPPEMIT '#include "tlhelp32.h"'}
 
51
{$HPPEMIT ''}
 
52
 
 
53
{$I jediapilib.inc}
 
54
 
 
55
interface
 
56
 
 
57
uses
 
58
  JwaWinType;
 
59
 
 
60
const
 
61
  MAX_MODULE_NAME32 = 255;
 
62
  {$EXTERNALSYM MAX_MODULE_NAME32}
 
63
 
 
64
// Snapshot function
 
65
 
 
66
function CreateToolhelp32Snapshot(dwFlags, th32ProcessID: DWORD): HANDLE; stdcall;
 
67
{$EXTERNALSYM CreateToolhelp32Snapshot}
 
68
 
 
69
//
 
70
// The th32ProcessID argument is only used if TH32CS_SNAPHEAPLIST or
 
71
// TH32CS_SNAPMODULE is specified. th32ProcessID == 0 means the current
 
72
// process.
 
73
//
 
74
// NOTE that all of the snapshots are global except for the heap and module
 
75
//      lists which are process specific. To enumerate the heap or module
 
76
//      state for all WIN32 processes call with TH32CS_SNAPALL and the
 
77
//      current process. Then for each process in the TH32CS_SNAPPROCESS
 
78
//      list that isn't the current process, do a call with just
 
79
//      TH32CS_SNAPHEAPLIST and/or TH32CS_SNAPMODULE.
 
80
//
 
81
// dwFlags
 
82
//
 
83
 
 
84
const
 
85
  TH32CS_SNAPHEAPLIST = $00000001;
 
86
  {$EXTERNALSYM TH32CS_SNAPHEAPLIST}
 
87
  TH32CS_SNAPPROCESS  = $00000002;
 
88
  {$EXTERNALSYM TH32CS_SNAPPROCESS}
 
89
  TH32CS_SNAPTHREAD   = $00000004;
 
90
  {$EXTERNALSYM TH32CS_SNAPTHREAD}
 
91
  TH32CS_SNAPMODULE   = $00000008;
 
92
  {$EXTERNALSYM TH32CS_SNAPMODULE}
 
93
  TH32CS_SNAPMODULE32 = $00000010;
 
94
  {$EXTERNALSYM TH32CS_SNAPMODULE32}
 
95
  TH32CS_SNAPALL      = TH32CS_SNAPHEAPLIST or TH32CS_SNAPPROCESS or
 
96
                        TH32CS_SNAPTHREAD or TH32CS_SNAPMODULE;
 
97
  {$EXTERNALSYM TH32CS_SNAPALL}
 
98
  TH32CS_INHERIT      = $80000000;
 
99
  {$EXTERNALSYM TH32CS_INHERIT}
 
100
 
 
101
//
 
102
// Use CloseHandle to destroy the snapshot
 
103
//
 
104
 
 
105
// Heap walking
 
106
 
 
107
type
 
108
  PHEAPLIST32 = ^HEAPLIST32;
 
109
  {$EXTERNALSYM PHEAPLIST32}
 
110
  tagHEAPLIST32 = record
 
111
    dwSize: SIZE_T;
 
112
    th32ProcessID: DWORD;   // owning process
 
113
    th32HeapID: ULONG_PTR;  // heap (in owning process's context!)
 
114
    dwFlags: DWORD;
 
115
  end;
 
116
  {$EXTERNALSYM tagHEAPLIST32}
 
117
  HEAPLIST32 = tagHEAPLIST32;
 
118
  {$EXTERNALSYM HEAPLIST32}
 
119
  LPHEAPLIST32 = ^HEAPLIST32;
 
120
  {$EXTERNALSYM LPHEAPLIST32}
 
121
  THeapList32 = HEAPLIST32;
 
122
 
 
123
//
 
124
// dwFlags
 
125
//
 
126
 
 
127
const
 
128
  HF32_DEFAULT    = 1;  // process's default heap
 
129
  {$EXTERNALSYM HF32_DEFAULT}
 
130
  HF32_SHARED     = 2;  // is shared heap
 
131
  {$EXTERNALSYM HF32_SHARED}
 
132
 
 
133
function Heap32ListFirst(hSnapshot: HANDLE; var lphl: HEAPLIST32): BOOL; stdcall;
 
134
{$EXTERNALSYM Heap32ListFirst}
 
135
function Heap32ListNext(hSnapshot: HANDLE; var lphl: HEAPLIST32): BOOL; stdcall;
 
136
{$EXTERNALSYM Heap32ListNext}
 
137
 
 
138
type
 
139
  PHEAPENTRY32 = ^HEAPENTRY32;
 
140
  {$EXTERNALSYM PHEAPENTRY32}
 
141
  tagHEAPENTRY32 = record
 
142
    dwSize: SIZE_T;
 
143
    hHandle: HANDLE;       // Handle of this heap block
 
144
    dwAddress: ULONG_PTR;  // Linear address of start of block
 
145
    dwBlockSize: SIZE_T;   // Size of block in bytes
 
146
    dwFlags: DWORD;
 
147
    dwLockCount: DWORD;
 
148
    dwResvd: DWORD;
 
149
    th32ProcessID: DWORD;  // owning process
 
150
    th32HeapID: ULONG_PTR; // heap block is in
 
151
  end;
 
152
  {$EXTERNALSYM tagHEAPENTRY32}
 
153
  HEAPENTRY32 = tagHEAPENTRY32;
 
154
  {$EXTERNALSYM HEAPENTRY32}
 
155
  LPHEAPENTRY32 = ^HEAPENTRY32;
 
156
  {$EXTERNALSYM LPHEAPENTRY32}
 
157
  THeapEntry32 = HEAPENTRY32;
 
158
 
 
159
//
 
160
// dwFlags
 
161
//
 
162
 
 
163
const
 
164
  LF32_FIXED    = $00000001;
 
165
  {$EXTERNALSYM LF32_FIXED}
 
166
  LF32_FREE     = $00000002;
 
167
  {$EXTERNALSYM LF32_FREE}
 
168
  LF32_MOVEABLE = $00000004;
 
169
  {$EXTERNALSYM LF32_MOVEABLE}
 
170
 
 
171
function Heap32First(var lphe: HEAPENTRY32; th32ProcessID: DWORD;
 
172
  th32HeapID: ULONG_PTR): BOOL; stdcall;
 
173
{$EXTERNALSYM Heap32First}
 
174
function Heap32Next(var lphe: HEAPENTRY32): BOOL; stdcall;
 
175
{$EXTERNALSYM Heap32Next}
 
176
 
 
177
function Toolhelp32ReadProcessMemory(th32ProcessID: DWORD; lpBaseAddress: LPCVOID;
 
178
  lpBuffer: LPVOID; cbRead: DWORD; lpNumberOfBytesRead: LPDWORD): BOOL; stdcall;
 
179
{$EXTERNALSYM Toolhelp32ReadProcessMemory}
 
180
 
 
181
// Process walking
 
182
 
 
183
type
 
184
  PPROCESSENTRY32W = ^PROCESSENTRY32W;
 
185
  {$EXTERNALSYM PPROCESSENTRY32W}
 
186
  tagPROCESSENTRY32W = record
 
187
    dwSize: DWORD;
 
188
    cntUsage: DWORD;
 
189
    th32ProcessID: DWORD;          // this process
 
190
    th32DefaultHeapID: ULONG_PTR;
 
191
    th32ModuleID:DWORD;            // associated exe
 
192
    cntThreads: DWORD;
 
193
    th32ParentProcessID: DWORD;    // this process's parent process
 
194
    pcPriClassBase: LONG;          // Base priority of process's threads
 
195
    dwFlags: DWORD;
 
196
    szExeFile: array [0..MAX_PATH - 1] of WCHAR;   // Path
 
197
  end;
 
198
  {$EXTERNALSYM tagPROCESSENTRY32W}
 
199
  PROCESSENTRY32W = tagPROCESSENTRY32W;
 
200
  {$EXTERNALSYM PROCESSENTRY32W}
 
201
  LPPROCESSENTRY32W = ^PROCESSENTRY32W;
 
202
  {$EXTERNALSYM LPPROCESSENTRY32W}
 
203
  TProcessEntry32W = PROCESSENTRY32W;
 
204
 
 
205
  {$IFDEF UNICODE}
 
206
 
 
207
  PROCESSENTRY32 = PROCESSENTRY32W;
 
208
  {$EXTERNALSYM PROCESSENTRY32}
 
209
  PPROCESSENTRY32 = PPROCESSENTRY32W;
 
210
  {$EXTERNALSYM PPROCESSENTRY32}
 
211
  LPPROCESSENTRY32 = LPPROCESSENTRY32W;
 
212
  {$EXTERNALSYM LPPROCESSENTRY32}
 
213
  TProcessEntry32 = TProcessEntry32W;
 
214
 
 
215
  {$ELSE}
 
216
 
 
217
  PPROCESSENTRY32 = ^PROCESSENTRY32;
 
218
  {$EXTERNALSYM PPROCESSENTRY32}
 
219
  tagPROCESSENTRY32 = record
 
220
    dwSize: DWORD;
 
221
    cntUsage: DWORD;
 
222
    th32ProcessID: DWORD;          // this process
 
223
    th32DefaultHeapID: ULONG_PTR;
 
224
    th32ModuleID: DWORD;           // associated exe
 
225
    cntThreads: DWORD;
 
226
    th32ParentProcessID: DWORD;    // this process's parent process
 
227
    pcPriClassBase: LONG;          // Base priority of process's threads
 
228
    dwFlags: DWORD;
 
229
    szExeFile: array [0..MAX_PATH - 1] of Char;    // Path
 
230
  end;
 
231
  {$EXTERNALSYM tagPROCESSENTRY32}
 
232
  PROCESSENTRY32 = tagPROCESSENTRY32;
 
233
  {$EXTERNALSYM PROCESSENTRY32}
 
234
  LPPROCESSENTRY32 = ^PROCESSENTRY32;
 
235
  {$EXTERNALSYM LPPROCESSENTRY32}
 
236
  TProcessEntry32 = PROCESSENTRY32;
 
237
 
 
238
  {$ENDIF UNICODE}
 
239
 
 
240
function Process32FirstW(hSnapshot: HANDLE; var lppe: PROCESSENTRY32W): BOOL; stdcall;
 
241
{$EXTERNALSYM Process32FirstW}
 
242
function Process32NextW(hSnapshot: HANDLE; var lppe: PROCESSENTRY32W): BOOL; stdcall;
 
243
{$EXTERNALSYM Process32NextW}
 
244
 
 
245
function Process32First(hSnapshot: HANDLE; var lppe: PROCESSENTRY32): BOOL; stdcall;
 
246
{$EXTERNALSYM Process32First}
 
247
function Process32Next(hSnapshot: HANDLE; var lppe: PROCESSENTRY32): BOOL; stdcall;
 
248
{$EXTERNALSYM Process32Next}
 
249
 
 
250
// Thread walking
 
251
 
 
252
type
 
253
  PTHREADENTRY32 = ^THREADENTRY32;
 
254
  {$EXTERNALSYM PTHREADENTRY32}
 
255
  tagTHREADENTRY32 = record
 
256
    dwSize: DWORD;
 
257
    cntUsage: DWORD;
 
258
    th32ThreadID: DWORD;       // this thread
 
259
    th32OwnerProcessID: DWORD; // Process this thread is associated with
 
260
    tpBasePri: LONG;
 
261
    tpDeltaPri: LONG;
 
262
    dwFlags: DWORD;
 
263
  end;
 
264
  {$EXTERNALSYM tagTHREADENTRY32}
 
265
  THREADENTRY32 = tagTHREADENTRY32;
 
266
  {$EXTERNALSYM THREADENTRY32}
 
267
  LPTHREADENTRY32 = ^THREADENTRY32;
 
268
  {$EXTERNALSYM LPTHREADENTRY32}
 
269
  TThreadEntry32 = THREADENTRY32;
 
270
 
 
271
function Thread32First(hSnapshot: HANDLE; var lpte: THREADENTRY32): BOOL; stdcall;
 
272
{$EXTERNALSYM Thread32First}
 
273
function Thread32Next(hSnapshot: HANDLE; var lpte: THREADENTRY32): BOOL; stdcall;
 
274
{$EXTERNALSYM Thread32Next}
 
275
 
 
276
// Module walking
 
277
 
 
278
type
 
279
  PMODULEENTRY32W = ^MODULEENTRY32W;
 
280
  {$EXTERNALSYM PMODULEENTRY32W}
 
281
  tagMODULEENTRY32W = record
 
282
    dwSize: DWORD;
 
283
    th32ModuleID: DWORD;       // This module
 
284
    th32ProcessID: DWORD;      // owning process
 
285
    GlblcntUsage: DWORD;       // Global usage count on the module
 
286
    ProccntUsage: DWORD;       // Module usage count in th32ProcessID's context
 
287
    modBaseAddr: LPBYTE;       // Base address of module in th32ProcessID's context
 
288
    modBaseSize: DWORD;        // Size in bytes of module starting at modBaseAddr
 
289
    hModule: HMODULE;          // The hModule of this module in th32ProcessID's context
 
290
    szModule: array [0..MAX_MODULE_NAME32] of WCHAR;
 
291
    szExePath: array [0..MAX_PATH - 1] of WCHAR;
 
292
  end;
 
293
  {$EXTERNALSYM tagMODULEENTRY32W}
 
294
  MODULEENTRY32W = tagMODULEENTRY32W;
 
295
  {$EXTERNALSYM MODULEENTRY32W}
 
296
  LPMODULEENTRY32W = ^MODULEENTRY32W;
 
297
  {$EXTERNALSYM LPMODULEENTRY32W}
 
298
  TModuleEntry32W = MODULEENTRY32W;
 
299
 
 
300
  {$IFDEF UNICODE}
 
301
 
 
302
  MODULEENTRY32 = MODULEENTRY32W;
 
303
  {$EXTERNALSYM MODULEENTRY32}
 
304
  PMODULEENTRY32 = PMODULEENTRY32W;
 
305
  {$EXTERNALSYM PMODULEENTRY32}
 
306
  LPMODULEENTRY32 = LPMODULEENTRY32W;
 
307
  {$EXTERNALSYM LPMODULEENTRY32}
 
308
  TModuleEntry32 = TModuleEntry32W;
 
309
 
 
310
  {$ELSE}
 
311
 
 
312
  PMODULEENTRY32 = ^MODULEENTRY32;
 
313
  {$EXTERNALSYM PMODULEENTRY32}
 
314
  tagMODULEENTRY32 = record
 
315
    dwSize: DWORD;
 
316
    th32ModuleID: DWORD;       // This module
 
317
    th32ProcessID: DWORD;      // owning process
 
318
    GlblcntUsage: DWORD;       // Global usage count on the module
 
319
    ProccntUsage: DWORD;       // Module usage count in th32ProcessID's context
 
320
    modBaseAddr: LPBYTE;       // Base address of module in th32ProcessID's context
 
321
    modBaseSize: DWORD;        // Size in bytes of module starting at modBaseAddr
 
322
    hModule: HMODULE;          // The hModule of this module in th32ProcessID's context
 
323
    szModule: array [0..MAX_MODULE_NAME32] of Char;
 
324
    szExePath: array [0..MAX_PATH - 1] of Char;
 
325
  end;
 
326
  {$EXTERNALSYM tagMODULEENTRY32}
 
327
  MODULEENTRY32 = tagMODULEENTRY32;
 
328
  {$EXTERNALSYM MODULEENTRY32}
 
329
  LPMODULEENTRY32 = ^MODULEENTRY32;
 
330
  {$EXTERNALSYM LPMODULEENTRY32}
 
331
  TModuleEntry32 = MODULEENTRY32;
 
332
 
 
333
  {$ENDIF UNICODE}
 
334
 
 
335
function Module32FirstW(hSnapshot: HANDLE; var lpme: MODULEENTRY32W): BOOL; stdcall;
 
336
{$EXTERNALSYM Module32FirstW}
 
337
function Module32NextW(hSnapshot: HANDLE; var lpme: MODULEENTRY32W): BOOL; stdcall;
 
338
{$EXTERNALSYM Module32NextW}
 
339
 
 
340
//
 
341
// NOTE CAREFULLY that the modBaseAddr and hModule fields are valid ONLY
 
342
// in th32ProcessID's process context.
 
343
//
 
344
function Module32First(hSnapshot: HANDLE; var lpme: MODULEENTRY32): BOOL; stdcall;
 
345
{$EXTERNALSYM Module32First}
 
346
function Module32Next(hSnapshot: HANDLE; var lpme: MODULEENTRY32): BOOL; stdcall;
 
347
{$EXTERNALSYM Module32Next}
 
348
 
 
349
implementation
 
350
 
 
351
const
 
352
  kernel32 = 'kernel32.dll';
 
353
  {$IFDEF UNICODE}
 
354
  AWSuffix = 'W';
 
355
  {$ELSE}
 
356
  AWSuffix = 'A';
 
357
  {$ENDIF UNICODE}
 
358
 
 
359
{$IFDEF DYNAMIC_LINK}
 
360
 
 
361
var
 
362
  _CreateToolhelp32Snapshot: Pointer;
 
363
 
 
364
function CreateToolhelp32Snapshot;
 
365
begin
 
366
  GetProcedureAddress(_CreateToolhelp32Snapshot, kernel32, 'CreateToolhelp32Snapshot');
 
367
  asm
 
368
        MOV     ESP, EBP
 
369
        POP     EBP
 
370
        JMP     [_CreateToolhelp32Snapshot]
 
371
  end;
 
372
end;
 
373
 
 
374
var
 
375
  _Heap32ListFirst: Pointer;
 
376
 
 
377
function Heap32ListFirst;
 
378
begin
 
379
  GetProcedureAddress(_Heap32ListFirst, kernel32, 'Heap32ListFirst');
 
380
  asm
 
381
        MOV     ESP, EBP
 
382
        POP     EBP
 
383
        JMP     [_Heap32ListFirst]
 
384
  end;
 
385
end;
 
386
 
 
387
var
 
388
  _Heap32ListNext: Pointer;
 
389
 
 
390
function Heap32ListNext;
 
391
begin
 
392
  GetProcedureAddress(_Heap32ListNext, kernel32, 'Heap32ListNext');
 
393
  asm
 
394
        MOV     ESP, EBP
 
395
        POP     EBP
 
396
        JMP     [_Heap32ListNext]
 
397
  end;
 
398
end;
 
399
 
 
400
var
 
401
  _Heap32First: Pointer;
 
402
 
 
403
function Heap32First;
 
404
begin
 
405
  GetProcedureAddress(_Heap32First, kernel32, 'Heap32First');
 
406
  asm
 
407
        MOV     ESP, EBP
 
408
        POP     EBP
 
409
        JMP     [_Heap32First]
 
410
  end;
 
411
end;
 
412
 
 
413
var
 
414
  _Heap32Next: Pointer;
 
415
 
 
416
function Heap32Next;
 
417
begin
 
418
  GetProcedureAddress(_Heap32Next, kernel32, 'Heap32Next');
 
419
  asm
 
420
        MOV     ESP, EBP
 
421
        POP     EBP
 
422
        JMP     [_Heap32Next]
 
423
  end;
 
424
end;
 
425
 
 
426
var
 
427
  _Toolhelp32ReadProcessMemory: Pointer;
 
428
 
 
429
function Toolhelp32ReadProcessMemory;
 
430
begin
 
431
  GetProcedureAddress(_Toolhelp32ReadProcessMemory, kernel32, 'Toolhelp32ReadProcessMemory');
 
432
  asm
 
433
        MOV     ESP, EBP
 
434
        POP     EBP
 
435
        JMP     [_Toolhelp32ReadProcessMemory]
 
436
  end;
 
437
end;
 
438
 
 
439
var
 
440
  _Process32FirstW: Pointer;
 
441
 
 
442
function Process32FirstW;
 
443
begin
 
444
  GetProcedureAddress(_Process32FirstW, kernel32, 'Process32FirstW');
 
445
  asm
 
446
        MOV     ESP, EBP
 
447
        POP     EBP
 
448
        JMP     [_Process32FirstW]
 
449
  end;
 
450
end;
 
451
 
 
452
var
 
453
  _Process32NextW: Pointer;
 
454
 
 
455
function Process32NextW;
 
456
begin
 
457
  GetProcedureAddress(_Process32NextW, kernel32, 'Process32NextW');
 
458
  asm
 
459
        MOV     ESP, EBP
 
460
        POP     EBP
 
461
        JMP     [_Process32NextW]
 
462
  end;
 
463
end;
 
464
 
 
465
var
 
466
  _Process32First: Pointer;
 
467
 
 
468
function Process32First;
 
469
begin
 
470
  GetProcedureAddress(_Process32First, kernel32, 'Process32First' + AWSuffix);
 
471
  asm
 
472
        MOV     ESP, EBP
 
473
        POP     EBP
 
474
        JMP     [_Process32First]
 
475
  end;
 
476
end;
 
477
 
 
478
var
 
479
  _Process32Next: Pointer;
 
480
 
 
481
function Process32Next;
 
482
begin
 
483
  GetProcedureAddress(_Process32Next, kernel32, 'Process32Next' + AWSuffix);
 
484
  asm
 
485
        MOV     ESP, EBP
 
486
        POP     EBP
 
487
        JMP     [_Process32Next]
 
488
  end;
 
489
end;
 
490
 
 
491
var
 
492
  _Thread32First: Pointer;
 
493
 
 
494
function Thread32First;
 
495
begin
 
496
  GetProcedureAddress(_Thread32First, kernel32, 'Thread32First');
 
497
  asm
 
498
        MOV     ESP, EBP
 
499
        POP     EBP
 
500
        JMP     [_Thread32First]
 
501
  end;
 
502
end;
 
503
 
 
504
var
 
505
  _Thread32Next: Pointer;
 
506
 
 
507
function Thread32Next;
 
508
begin
 
509
  GetProcedureAddress(_Thread32Next, kernel32, 'Thread32Next');
 
510
  asm
 
511
        MOV     ESP, EBP
 
512
        POP     EBP
 
513
        JMP     [_Thread32Next]
 
514
  end;
 
515
end;
 
516
 
 
517
var
 
518
  _Module32FirstW: Pointer;
 
519
 
 
520
function Module32FirstW;
 
521
begin
 
522
  GetProcedureAddress(_Module32FirstW, kernel32, 'Module32FirstW');
 
523
  asm
 
524
        MOV     ESP, EBP
 
525
        POP     EBP
 
526
        JMP     [_Module32FirstW]
 
527
  end;
 
528
end;
 
529
 
 
530
var
 
531
  _Module32NextW: Pointer;
 
532
 
 
533
function Module32NextW;
 
534
begin
 
535
  GetProcedureAddress(_Module32NextW, kernel32, 'Module32NextW');
 
536
  asm
 
537
        MOV     ESP, EBP
 
538
        POP     EBP
 
539
        JMP     [_Module32NextW]
 
540
  end;
 
541
end;
 
542
 
 
543
var
 
544
  _Module32First: Pointer;
 
545
 
 
546
function Module32First;
 
547
begin
 
548
  GetProcedureAddress(_Module32First, kernel32, 'Module32First' + AWSuffix);
 
549
  asm
 
550
        MOV     ESP, EBP
 
551
        POP     EBP
 
552
        JMP     [_Module32First]
 
553
  end;
 
554
end;
 
555
 
 
556
var
 
557
  _Module32Next: Pointer;
 
558
 
 
559
function Module32Next;
 
560
begin
 
561
  GetProcedureAddress(_Module32Next, kernel32, 'Module32Next' + AWSuffix);
 
562
  asm
 
563
        MOV     ESP, EBP
 
564
        POP     EBP
 
565
        JMP     [_Module32Next]
 
566
  end;
 
567
end;
 
568
 
 
569
{$ELSE}
 
570
 
 
571
function CreateToolhelp32Snapshot; external kernel32 name 'CreateToolhelp32Snapshot';
 
572
function Heap32ListFirst; external kernel32 name 'Heap32ListFirst';
 
573
function Heap32ListNext; external kernel32 name 'Heap32ListNext';
 
574
function Heap32First; external kernel32 name 'Heap32First';
 
575
function Heap32Next; external kernel32 name 'Heap32Next';
 
576
function Toolhelp32ReadProcessMemory; external kernel32 name 'Toolhelp32ReadProcessMemory';
 
577
function Process32FirstW; external kernel32 name 'Process32FirstW';
 
578
function Process32NextW; external kernel32 name 'Process32NextW';
 
579
function Process32First; external kernel32 name 'Process32First' + AWSuffix;
 
580
function Process32Next; external kernel32 name 'Process32Next' + AWSuffix;
 
581
function Thread32First; external kernel32 name 'Thread32First';
 
582
function Thread32Next; external kernel32 name 'Thread32Next';
 
583
function Module32FirstW; external kernel32 name 'Module32FirstW';
 
584
function Module32NextW; external kernel32 name 'Module32NextW';
 
585
function Module32First; external kernel32 name 'Module32First' + AWSuffix;
 
586
function Module32Next; external kernel32 name 'Module32Next' + AWSuffix;
 
587
 
 
588
{$ENDIF DYNAMIC_LINK}
 
589
 
 
590
end.