paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-12-05 00:47:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

help headers for wince from bug #17574

Browse Source 
git-svn-id: trunk@16195 -
This commit is contained in:
sekelsenmat 2010-10-21 15:37:16 +00:00
parent 497518c6a3
commit b0b708f308
4 changed files with 242 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -5877,6 +5877,7 @@ packages/winceunits/src/sipapi.pp svneol=native#text/plain
packages/winceunits/src/sms.pp svneol=native#text/plain
packages/winceunits/src/storemgr.pas svneol=native#text/plain
packages/winceunits/src/tapi.pp svneol=native#text/plain
packages/winceunits/src/tlhelp32.pas svneol=native#text/pascal
packages/winceunits/src/todaycmn.pp svneol=native#text/plain
packages/winceunits/src/tsp.pp svneol=native#text/plain
packages/winceunits/src/wap.pp svneol=native#text/plain

2
packages/winceunits/Makefile.fpc
View File

@ -13,7 +13,7 @@ implicitunits_wince=aygshell commctrl commdlg iphlpapi notify oleauto power shel
sipapi cpl bt_api bt_sdp bthapi bthutil pimstore ril sms ws2bth keybd nled \
phone connmgr devload devmgmt mmreg mmsystem msacm wininet ras raserror \
sip projects wap tsp extapi imm \
activex ole2 comconst rapitypes
activex ole2 comconst rapitypes tlhelp32
units_win32=rapi cesync rapitypes

2
packages/winceunits/src/buildwinceunits.pp
View File

@ -26,7 +26,7 @@ uses
sipapi, cpl, bt_api, bt_sdp, bthapi, bthutil, pimstore, ril, sms, ws2bth,
keybd, nled, phone, connmgr, devload, devmgmt, mmreg, mmsystem, msacm,
wininet, ras, raserror, sip, projects, wap, tsp, extapi, imm, rapitypes,
storemgr, pnp;
storemgr, pnp, tlhelp32;
implementation

239
packages/winceunits/src/tlhelp32.pas Normal file
View File

@ -0,0 +1,239 @@
{******************************************************************************}
{ }
{ ToolHelp API interface Unit for Object Pascal }
{ }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
{ Corporation. All Rights Reserved. }
{ }
{ The original file is: tlhelp32.h, released June 2000. The original Pascal }
{ code is: TlHelp32.pas, released December 2000. The initial developer of the }
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
{ }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
{ Marcel van Brakel. All Rights Reserved. }
{ }
{ Modified for usage with WinCE by Sven Barth }
{ Based on JwaTlHelp32.pas,v 1.11 2007/09/05 11:58:52 }
{ FPC revision 15911 }
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ }
{ You may retrieve the latest version of this file at the Project JEDI }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{******************************************************************************}
unit TlHelp32;
{$mode objfpc}
interface
uses
windows;
const
libtoolhelp = 'toolhelp.dll';
// Snapshot function
function CreateToolhelp32Snapshot(dwFlags, th32ProcessID: DWORD): HANDLE; cdecl;
external libtoolhelp name 'CreateToolhelp32Snapshot';
function CloseToolhelp32Snapshot(hSnapshot: HANDLE): BOOL; cdecl;
external libtoolhelp name 'CloseToolhelp32Snapshot';
//
// The th32ProcessID argument is only used if TH32CS_SNAPHEAPLIST or
// TH32CS_SNAPMODULE is specified. th32ProcessID == 0 means the current
// process.
//
// NOTE that all of the snapshots are global except for the heap and module
// lists which are process specific. To enumerate the heap or module
// state for all WIN32 processes call with TH32CS_SNAPALL and the
// current process. Then for each process in the TH32CS_SNAPPROCESS
// list that isn't the current process, do a call with just
// TH32CS_SNAPHEAPLIST and/or TH32CS_SNAPMODULE.
//
// dwFlags
//
const
TH32CS_SNAPHEAPLIST = $00000001;
TH32CS_SNAPPROCESS = $00000002;
TH32CS_SNAPTHREAD = $00000004;
TH32CS_SNAPMODULE = $00000008;
TH32CS_SNAPALL = TH32CS_SNAPHEAPLIST or TH32CS_SNAPPROCESS or
TH32CS_SNAPTHREAD or TH32CS_SNAPMODULE;
TH32CS_GETALLMODS = $80000000;
//
// Use CloseToolhelp32Snapshot to destroy the snapshot
//
// Heap walking
type
PHEAPLIST32 = ^HEAPLIST32;
tagHEAPLIST32 = record
dwSize: DWORD;
th32ProcessID: DWORD; // owning process
th32HeapID: DWORD; // heap (in owning process's context!)
dwFlags: DWORD;
end;
HEAPLIST32 = tagHEAPLIST32;
LPHEAPLIST32 = ^HEAPLIST32;
THeapList32 = HEAPLIST32;
//
// dwFlags
//
const
HF32_DEFAULT = 1; // process's default heap
HF32_SHARED = 2; // is shared heap
function Heap32ListFirst(hSnapshot: HANDLE; var lphl: HEAPLIST32): BOOL; cdecl;
external libtoolhelp name 'Heap32ListFirst';
function Heap32ListNext(hSnapshot: HANDLE; var lphl: HEAPLIST32): BOOL; cdecl;
external libtoolhelp name 'Heap32ListNext';
type
PHEAPENTRY32 = ^HEAPENTRY32;
tagHEAPENTRY32 = record
dwSize: DWORD;
hHandle: HANDLE; // Handle of this heap block
dwAddress: DWORD; // Linear address of start of block
dwBlockSize: DWORD; // Size of block in bytes
dwFlags: DWORD;
dwLockCount: DWORD;
dwResvd: DWORD;
th32ProcessID: DWORD; // owning process
th32HeapID: DWORD; // heap block is in
end;
HEAPENTRY32 = tagHEAPENTRY32;
LPHEAPENTRY32 = ^HEAPENTRY32;
THeapEntry32 = HEAPENTRY32;
//
// dwFlags
//
const
LF32_FIXED = $00000001;
LF32_FREE = $00000002;
LF32_MOVEABLE = $00000004;
function Heap32First(var lphe: HEAPENTRY32; th32ProcessID: DWORD;
th32HeapID: ULONG_PTR): BOOL; cdecl; external libtoolhelp name 'Heap32First';
function Heap32Next(var lphe: HEAPENTRY32): BOOL; cdecl; external libtoolhelp
name 'Heap32Next';
function Toolhelp32ReadProcessMemory(th32ProcessID: DWORD; lpBaseAddress: LPCVOID;
lpBuffer: LPVOID; cbRead: DWORD; lpNumberOfBytesRead: LPDWORD): BOOL; cdecl;
external libtoolhelp name 'Toolhelp32ReadProcessMemory';
// Process walking
type
PPROCESSENTRY32 = ^PROCESSENTRY32;
tagPROCESSENTRY32 = record
dwSize: DWORD;
cntUsage: DWORD;
th32ProcessID: DWORD; // this process
th32DefaultHeapID: DWORD;
th32ModuleID:DWORD; // associated exe
cntThreads: DWORD;
th32ParentProcessID: DWORD; // this process's parent process
pcPriClassBase: LONG; // Base priority of process's threads
dwFlags: DWORD;
szExeFile: array [0..MAX_PATH - 1] of WCHAR; // Path
th32MemoryBase: DWORD;
th32AccessKey: DWORD;
end;
PROCESSENTRY32 = tagPROCESSENTRY32;
LPPROCESSENTRY32 = ^PROCESSENTRY32;
TProcessEntry32 = PROCESSENTRY32;
function Process32First(hSnapshot: HANDLE; var lppe: PROCESSENTRY32): BOOL; cdecl;
external libtoolhelp name 'Process32First';
function Process32Next(hSnapshot: HANDLE; var lppe: PROCESSENTRY32): BOOL; cdecl;
external libtoolhelp name 'Process32Next';
// Thread walking
type
PTHREADENTRY32 = ^THREADENTRY32;
tagTHREADENTRY32 = record
dwSize: DWORD;
cntUsage: DWORD;
th32ThreadID: DWORD; // this thread
th32OwnerProcessID: DWORD; // Process this thread is associated with
tpBasePri: LONG;
tpDeltaPri: LONG;
dwFlags: DWORD;
th32AccessKey: DWORD;
th32CurrentProcessID: DWORD;
end;
THREADENTRY32 = tagTHREADENTRY32;
LPTHREADENTRY32 = ^THREADENTRY32;
TThreadEntry32 = THREADENTRY32;
function Thread32First(hSnapshot: HANDLE; var lpte: THREADENTRY32): BOOL; cdecl;
external libtoolhelp name 'Thread32First';
function Thread32Next(hSnapshot: HANDLE; var lpte: THREADENTRY32): BOOL; cdecl;
external libtoolhelp name 'Thread32Next';
// Module walking
type
PMODULEENTRY32 = ^MODULEENTRY32;
tagMODULEENTRY32 = record
dwSize: DWORD;
th32ModuleID: DWORD; // This module
th32ProcessID: DWORD; // owning process
GlblcntUsage: DWORD; // Global usage count on the module
ProccntUsage: DWORD; // Module usage count in th32ProcessID's context
modBaseAddr: LPBYTE; // Base address of module in th32ProcessID's context
modBaseSize: DWORD; // Size in bytes of module starting at modBaseAddr
hModule: HMODULE; // The hModule of this module in th32ProcessID's context
szModule: array [0..MAX_PATH - 1] of WCHAR;
szExePath: array [0..MAX_PATH - 1] of WCHAR;
dwFlags: DWORD; // Reserved
end;
MODULEENTRY32 = tagMODULEENTRY32;
LPMODULEENTRY32 = ^MODULEENTRY32;
TModuleEntry32 = MODULEENTRY32;
//
// NOTE CAREFULLY that the modBaseAddr and hModule fields are valid ONLY
// in th32ProcessID's process context.
//
function Module32First(hSnapshot: HANDLE; var lpme: MODULEENTRY32): BOOL; cdecl;
external libtoolhelp name 'Module32First';
function Module32Next(hSnapshot: HANDLE; var lpme: MODULEENTRY32): BOOL; cdecl;
external libtoolhelp name 'Module32Next';
implementation
end.