Форум на Исходниках.RU

{*******************************************************}

{ }

{ Turbo Pascal Runtime Library }

{ DOS Protected-mode Interface Unit }

{ }

{*******************************************************}

unit WinAPI;

{$S-}

interface

{ Generic types }

type

Bool = WordBool; { Windows compatible boolean }

THandle = Word; { Global memory handle }

TFarProc = Pointer; { Procedure address }

{ Flags returned by GetWinFlags }

const

wf_PMode = {text}000001; { Running in protected mode }

wf_CPU286 = {text}000002; { System CPU is an 80286 }

wf_CPU386 = {text}000004; { System CPU is an 80386 }

wf_CPU486 = {text}000008; { System CPU is an 80486 }

wf_Standard = {text}000010; { Running in standard mode }

wf_Enhanced = {text}000020; { Running in enhanced mode }

wf_CPU086 = {text}000040; { System CPU is an 8086 }

wf_CPU186 = {text}000080; { System CPU is an 80186 }

wf_LargeFrame = {text}000100; { Windows EMS large-frame configuration }

wf_SmallFrame = {text}000200; { Windows EMS small-frame configuration }

wf_80x87 = {text}000400; { System contains a math coprocessor }

wf_DPMI = 000000; { Running in DOS protected mode }

{ GlobalAlloc and GlobalReAlloc flags }

const

gmem_Fixed = {text}00; { Allocate fixed memory }

gmem_Moveable = {text}02; { Allocate moveable memory }

gmem_NoCompact = {text}10; { Don't compact when allocating }

gmem_NoDiscard = {text}20; { Don't discard when allocating }

gmem_ZeroInit = {text}40; { Initialize memory contents to zero }

gmem_Modify = {text}80; { Modify memory flags }

gmem_Discardable = 00; { Allocate discardable memory }

gmem_Not_Banked = 00; { Allocate non-banked memory }

gmem_DDEShare = 00; { Allocate sharable memory }

gmem_Notify = 00; { Notify upon discarding }

{ Flags returned by GlobalFlags (in addition to gmem_Discardable) }

const

gmem_Discarded = 00;

gmem_LockCount = {text}FF;

{ MessageBox Flags }

const

mb_Ok = {text}00;

mb_OkCancel = {text}01;

mb_AbortRetryIgnore = {text}02;

mb_YesNoCancel = {text}03;

mb_YesNo = {text}04;

mb_RetryCancel = {text}05;

mb_IconHand = {text}10;

mb_IconStop = {text}10;

mb_IconQuestion = {text}20;

mb_IconExclamation = {text}30;

mb_IconAsterisk = {text}40;

mb_IconInformation = {text}40;

mb_DefButton1 = {text}00;

mb_DefButton2 = 00;

mb_DefButton3 = 00;

mb_ApplModal = {text}00;

mb_SystemModal = 00;

mb_TaskModal = 00;

mb_NoFocus = 00;

mb_TypeMask = {text}0F;

mb_IconMask = {text}F0;

mb_DefMask = {text}F00;

mb_ModeMask = 00;

mb_MiscMask = $C000;

{ MessageBox return values }

const

id_Ok = 1;

id_Cancel = 2;

id_Abort = 3;

id_Retry = 4;

id_Ignore = 5;

id_Yes = 6;

id_No = 7;

{ Windows API routines }

function AccessResource(Instance, ResInfo: THandle): Integer;

function AllocDStoCSAlias(Selector: Word): Word;

function AllocSelector(Selector: Word): Word;

function ChangeSelector(SourceSelector, DestSelector: Word): Word;

procedure DOS3Call;

procedure FatalExit(Code: Integer);

function FindResource(Instance: THandle; Name, ResType: PChar): THandle;

procedure FreeLibrary(LibModule: THandle);

function FreeResource(ResData: THandle): Bool;

function FreeSelector(Selector: Word): Word;

function GetDOSEnvironment: PChar;

function GetFreeSpace(Flag: Word): Longint;

function GetModuleFileName(Module: THandle; Filename: PChar; Size: Integer): Integer;

function GetModuleHandle(ModuleName: PChar): THandle;

function GetModuleUsage(Module: THandle): Integer;

function GetProcAddress(Module: THandle; ProcName: PChar): TFarProc;

function GetSelectorBase(Selector: Word): Longint;

function GetSelectorLimit(Selector: Word): Longint;

function GetVersion: Longint;

function GetWinFlags: Longint;

function GlobalAlloc(Flags: Word; Bytes: Longint): THandle;

{function GlobalAllocPtr(Flags: Word; Bytes: Longint): Pointer;}

function GlobalCompact(MinFree: Longint): Longint;

{function GlobalDiscard(Mem: THandle): THandle;}

function GlobalDosAlloc(Bytes: Longint): Longint;

function GlobalDosFree(Selector: Word): Word;

procedure GlobalFix(Mem: THandle);

function GlobalFlags(Mem: THandle): Word;

function GlobalFree(Mem: THandle): THandle;

{function GlobalFreePtr(P: Pointer): THandle;}

function GlobalHandle(Mem: Word): Longint;

function GlobalLock(Mem: THandle): Pointer;

function GlobalLRUNewest(Mem: THandle): THandle;

function GlobalLRUOldest(Mem: THandle): THandle;

procedure GlobalNotify(NotifyProc: TFarProc);

function GlobalPageLock(Selector: THandle): Word;

function GlobalPageUnlock(Selector: THandle): Word;

{function GlobalPtrHandle(P: Pointer): THandle;}

function GlobalReAlloc(Mem: THandle; Bytes: Longint; Flags: Word): THandle;

{function GlobalReAllocPtr(P: Pointer; Bytes: Longint; Flags: Word): Pointer;}

function GlobalSize(Mem: THandle): Longint;

function GlobalUnfix(Mem: THandle): Bool;

function GlobalUnlock(Mem: THandle): Bool;

function LoadLibrary(LibFileName: PChar): THandle;

function LoadResource(Instance: THandle; ResInfo: THandle): THandle;

function LoadString(Instance: THandle; ID: Word; Buffer: PChar;

BufferMax: Integer): Integer;

function LockResource(ResData: THandle): Pointer;

function LockSegment(Segment: Word): THandle;

function MessageBox(WndParent: THandle; Text, Caption: PChar;

TextType: Word): Integer;

function PrestoChangoSelector(SourceSelector, DestSelector: Word): Word;

function SetSelectorBase(Selector: Word; Base: Longint): Word;

function SetSelectorLimit(Selector: Word; Limit: Longint): Word;

function SizeOfResource(Instance, ResInfo: THandle): Longint;

function UnlockResource(ResData: THandle): Bool;

function UnlockSegment(Segment: Word): THandle;

{ Inline routines }

(*function MakeLong(A, B: Word): Longint;

inline(

A/ { POP DX }

); { POP AX }

function LoWord(A: Longint): Word;

inline(

/ { POP AX }

A); { POP DX }

function HiWord(A: Longint): Word;

inline(

A/ { POP DX }

); { POP AX }

function LoByte(A: Word): Byte;

inline(

/ { POP AX }

/$E4); { XOR AH,AH }

function HiByte(A: Word): Byte;

inline(

/ { POP AX }

A/$C4/ { MOV AL,AH }

/$E4); { XOR AH,AH } *)

implementation

{ KERNEL routines }

procedure FatalExit; external 'KERNEL' index 1;

function GetVersion; external 'KERNEL' index 3;

function GlobalAlloc; external 'KERNEL' index 15;

function GlobalReAlloc; external 'KERNEL' index 16;

function GlobalFree; external 'KERNEL' index 17;

function GlobalLock; external 'KERNEL' index 18;

function GlobalUnlock; external 'KERNEL' index 19;

function UnlockResource; external 'KERNEL' index 19;

function GlobalSize; external 'KERNEL' index 20;

function GlobalHandle; external 'KERNEL' index 21;

function GlobalFlags; external 'KERNEL' index 22;

function LockSegment; external 'KERNEL' index 23;

function UnlockSegment; external 'KERNEL' index 24;

function GlobalCompact; external 'KERNEL' index 25;

function GetModuleHandle; external 'KERNEL' index 47;

function GetModuleUsage; external 'KERNEL' index 48;

function GetModuleFileName; external 'KERNEL' index 49;

function GetProcAddress; external 'KERNEL' index 50;

function FindResource; external 'KERNEL' index 60;

function LoadResource; external 'KERNEL' index 61;

function LockResource; external 'KERNEL' index 62;

function FreeResource; external 'KERNEL' index 63;

function AccessResource; external 'KERNEL' index 64;

function SizeOfResource; external 'KERNEL' index 65;

function LoadLibrary; external 'KERNEL' index 95;

procedure FreeLibrary; external 'KERNEL' index 96;

procedure DOS3Call; external 'KERNEL' index 102;

function GetDOSEnvironment; external 'KERNEL' index 131;

function GetWinFlags; external 'KERNEL' index 132;

procedure GlobalNotify; external 'KERNEL' index 154;

function GlobalLRUOldest; external 'KERNEL' index 163;

function GlobalLRUNewest; external 'KERNEL' index 164;

function GetFreeSpace; external 'KERNEL' index 169;

function AllocDStoCSAlias; external 'KERNEL' index 171;

function AllocSelector; external 'KERNEL' index 175;

function FreeSelector; external 'KERNEL' index 176;

function ChangeSelector; external 'KERNEL' index 177;

function PrestoChangoSelector; external 'KERNEL' index 177;

function GlobalDosAlloc; external 'KERNEL' index 184;

function GlobalDosFree; external 'KERNEL' index 185;

function GetSelectorBase; external 'KERNEL' index 186;

function SetSelectorBase; external 'KERNEL' index 187;

function GetSelectorLimit; external 'KERNEL' index 188;

function SetSelectorLimit; external 'KERNEL' index 189;

function GlobalPageLock; external 'KERNEL' index 191;

function GlobalPageUnlock; external 'KERNEL' index 192;

procedure GlobalFix; external 'KERNEL' index 197;

function GlobalUnfix; external 'KERNEL' index 198;

{ USER routines }

function MessageBox; external 'USER' index 1;

function LoadString; external 'USER' index 176;

{ Wrapper routines }

(*function GlobalDiscard(Mem: THandle): THandle; assembler;

asm

PUSH Mem

XOR AX,AX

PUSH AX

MOV AX,gmem_Moveable

PUSH AX

CALL GlobalReAlloc

end;

function GlobalPtrHandle(P: Pointer): THandle; assembler;

asm

PUSH P.Word[2]

CALL GlobalHandle

end;

function GlobalAllocPtr(Flags: Word; Bytes: Longint): Pointer; assembler;

asm

PUSH Flags

PUSH Bytes.Word[2]

PUSH Bytes.Word[0]

CALL GlobalAlloc

PUSH AX

CALL GlobalLock

end;

function GlobalReAllocPtr(P: Pointer; Bytes: Longint;

Flags: Word): Pointer; assembler;

asm

PUSH P.Word[2]

CALL GlobalHandle

PUSH AX

CALL GlobalUnlock

PUSH Bytes.Word[2]

PUSH Bytes.Word[0]

PUSH Flags

CALL GlobalReAlloc

PUSH AX

CALL GlobalLock

end;

function GlobalFreePtr(P: Pointer): THandle; assembler;

asm

PUSH P.Word[2]

CALL GlobalHandle

PUSH AX

CALL GlobalUnlock

CALL GlobalFree

end; *)

end.