[Back to MEMORY SWAG index] [Back to Main SWAG index] [Original]
{*******************************}
{* �®¤ã«ì ¯à®á⮣® *}
{* �®£®¯à®æ¥áá�®£® ®ï¿½¨â®à� *}
{* VSTasks v 1.01 *}
{* ¤«ï Turbo Pascal ver 7.0 *}
{* (c) Copyright VVSsoft Group *}
{*******************************}
{$F+$S-}
{ v.1.01 --- ¯® áà�¢ï¿½¥ï¿½¨î á ¢¥àᨥ© 1.0 ¨á¯à�¢«¥ï¿½ ¢ë室 ¨§ ¯à®æ¥áá�- }
{ ¯à®æ¥¤ãàë ¯® ¤®á⨦¥ï¿½¨î END. � ¯à¥¤ë¤ã饩 ¢¥àᨨ �ã¦ï¿½® }
{ ¡ë«® ®¡ï§ï¿½â¥«ì�® ¯¥à¥¤ END-® áâ�¢¨âì HaltCurrentTask, }
{ ¨ï¿½ï¿½ç¥ á¨áâ¥ï¿½ "¢¨á«ï¿½". �¥¯¥àì ¯à¨ ¤®á⨦¥ï¿½¨¨ ª®ï¿½æ� }
{ ¯à®æ¥áá�-¯à®æ¥¤ãàë �¢â®ï¿½â® ¯à®æ¥áá §ï¿½ªàë¢ï¿½¥âáï ... }
{ }
{ (c) VVSsoft Group. �®ï¿½®ï¿½®¢ �«ï¿½¤¨¨à. }
Unit VSTasks;
interface {--------------------------------------------}
Type
PTaskRec =^TTaskRec; { ---- ®¯¨áï¿½â¥«ì ¯à®æ¥áá� -----}
TTaskRec =
record
NumProc : word; { ã�¨ªï¿½«ìï¿½ë© ï¿½®¥à ¯à®æ¥áá� }
Next : PTaskRec; { á«¥¤ãî騩 ®¯¨áï¿½â¥«ì ¯à®æ¥áá� }
OrignSP, { §ï¿½ï¿½ç¥ï¿½¨¥ SP ¤«ï ¢®§¢à�â� }
OrignSS : word; { §ï¿½ï¿½ç¥ï¿½¨¥ SS ¤«ï ¢®§¢à�â� }
Stack : pointer; { ãªï¿½§ï¿½â¥«ì �� á⥪ ¯à®æ¥áá� }
SSize : word; { à�§¥à á⥪� ¯à®æ¥áá� }
end;
Const
CountTask : word = 0; { ¢á¥£® §ï¿½à¥£¨áâà¨à®¢ï¿½ï¿½ï¿½® ¯à®æ¥áᮢ }
PCurTask : PTaskRec = Nil; { ãªï¿½§ï¿½â¥«ì �� ⥪ãéãî ¢ë¯®«ï¿½ï¥ãî §ï¿½¤ï¿½çã }
HeadStack : PTaskRec = Nil; { ãªï¿½§ï¿½â¥«ì �� £®«®¢ã á⥪� }
UniNumber : word = 1; { ã�¨ªï¿½«ìï¿½ë© ï¿½®¥à ¤«ï ᮧ¤ï¿½¢ï¿½¥®£® ¯à®æ¥áá� }
CurTask : word = 0; { �®¥à ⥪ã饣® ¯à®æ¥áá� }
{----------------- ª®¤ë ®è¨¡®ª ॣ¨áâà�樨 ¯à®æ¥áá� --------------}
vstMemoryLow = 1; { �¥â ¯ï¿½ï⨠¤«ï ᮧ¤ï¿½ï¿½¨ï á⥪� ¯à®æ¥áá� }
vstEmptyStackTask = 2; { �¥â §ï¿½à¥£¨áâà¨à®¢ï¿½ï¿½ï¿½ëå ¯à®æ¥áᮢ }
vstMAXLimitProc = 3; { ᫨誮 �®£® ¯à®æ¥áᮢ }
Var
TaskError : byte; { ¯®á«¥¤ï¿½ïï ®è¨¡ªï¿½ }
procedure StartTasks;
{--- §ï¿½¯ã᪠¯à®æ¥áᮢ �� ¢ë¯®«ï¿½¥ï¿½¨¥ ---}
procedure SwithTasks; far;
{--- ¯¥à¥ª«îç¥ï¿½¨¥ ¥¦¤ã §ï¿½¤ï¿½ç�¨ ---}
function RegisterTask(TaskPoint : pointer; SizeStack: word): word;
{--- ॣ¨áâà�æ¨ï §ï¿½¤ï¿½ç¨ ¥á«¨ - 0, â® ®è¨¡ªï¿½ ¢ ¯¥à¥¥ï¿½ï¿½®© TaskError ---}
{--- ¢®§¢à�é�¥â �®¥à §ï¿½à¥£¨áâà¨à®¢ï¿½ï¿½ï¿½®£® ¯à®æ¥áá� ---}
procedure HaltCurrentTask;
{--- á�ï⨥ ⥪ã饩 §ï¿½¤ï¿½ç¨ ---}
procedure HaltAllTasks;
{--- á�ï⨥ ¢á¥å §ï¿½¤ï¿½ç ---}
implementation
{----------------------------------------------------------------}
Var
OriginalSS, { �¤à¥á ®à¨£¨ï¿½ï¿½«ì�®£® á⥪� ¯à®£à�ë }
OriginalSP : word; { ãªï¿½§ï¿½â¥«ì ®à¨£¨ï¿½ï¿½«ì�®£® á⥪� ¯à®£à�ë }
PDopPoint : PTaskRec; { ¤®¯®«ï¿½¨â¥«ìï¿½ë© ãªï¿½§ï¿½â¥«ì }
{------- ¯¥à¥®¯à¥¤¥«¥ï¿½ï¿½ë¥ äã�ªæ¨¨ ¤«ï à�¡®âë á BASM® ---------}
function mMemAvail: word;
Var M: longint;
T: record
L,H: word;
end;
begin
M:=MaxAvail;
If M>$FFFF then mMemAvail:=$FFFF
else
begin
Move(M,T,SizeOf(longint));
mMemAvail:=T.L;
end;
end;
function mGetMem(S:word): pointer;
Var P:pointer;
begin
GetMem(P,S);
mGetMem:=P;
end;
procedure mFreeMem(P: pointer;S: word);
Var D: pointer;
begin
D:=P;
FreeMem(P,S);
end;
procedure StartTasks; assembler;
{ --- §ï¿½¯ã᪠¯à®æ¥áᮢ �� ¢ë¯®«ï¿½¥ï¿½¨¥ --- }
asm
{ 1) ��¯®ï¿½¨âì ¢ á⥪¥ ॣ¨áâàë;
2) ��¯®ï¿½¨âì ¢ á⥪¥ â®çªã ¢ë室� ¨§ ¥ï¿½¥¤¦¥à� ¯à®æ¥áᮢ;
3) �®åà��¨âì ॣ¨áâàë SS ¨ SP ¤«ï ®á�®¢ï¿½®© ¯à®£à�ë;
4) ��©â¨ ¯¥à¢ë© ¯à®æ¥áá ¤«ï §ï¿½¯ãáªï¿½;
5) �¥à¥ãáâ��®¢¨âì ¢á¥ â¥ªã騥 ¯¥à¥¥ï¿½ï¿½ë¥;
6) �¥à¥ãáâ��®¢¨âì SS:SP ¨ ¢®ááâ��®¢¨âì ॣ¨áâàë;
7) �ந§¢¥á⨠"¤«¨ï¿½ï¿½ë© ¢ë室" (ç¨â�© ¢å®¤) RETF ¢ ¯à®æ¥áá;
8) �®á«¥ ¢®§¢à�â� ¢ â®çªã ¢ë室� ¨§ ¯à®æ¥áá�, ¢®ááâ��®¢¨âì
ॣ¨áâàë. }
{----------------------------------------------------}
PUSH BP { á®åàï¿½ï¿½ï¥ à¥£¨áâàë }
PUSH DI {}
PUSH SI {}
PUSH DS {}
PUSH ES {}
LEA DI, @ExitPoint { ¢ DI á¥é¥ï¿½¨¥ ¢ë室� }
PUSH CS { á®åàï¿½ï¿½ï¥ â®çªã ¢ë室� ¨§ }
PUSH DI { ¯à®æ¥áᮢ }
MOV OriginalSS, SS { á®åàï¿½ï¿½ï¥ SS:SP }
MOV OriginalSP, SP {}
MOV AX, CountTask { ¥á«¨ �¥â §ï¿½à¥£¨áâà¨à®¢. §ï¿½¤ï¿½ç }
XOR BX, BX {}
CMP AX, BX {}
JE @Exit { ®ç¥à¥¤ì ¯à®æ¥áᮢ ¯ãáâ� }
MOV DI, HeadStack.word[0] { ¢ ES:DI ãªï¿½§ï¿½â¥«ì �� }
MOV ES, HeadStack.word[2] { ®¯¨áï¿½â¥«ì ¯à®æ¥áá� }
MOV AX, ES:[DI] { �®¥à ⥪ã饣® ¯à®æ¥áá� }
MOV CurTask, AX {}
MOV PCurTask.word[0], DI { PCurTask à�¢ï¿½® ¯¥à¢®ã }
MOV PCurTask.word[2], ES { ¯à®æ¥ááã }
CLI {}
MOV SS, ES:[DI+8] { ¯¥à¥ãáâ��®¢ªï¿½ á⥪� }
MOV SP, ES:[DI+6] {}
STI {}
POP BP { ¢®áâ���¢«¨¢ï¿½¥ ॣ¨áâàë }
POP ES { ¯à®æ¥áá� }
POP DS {}
RETF { "¢ë室" ¢ ¯à®æ¥áá }
@Exit: POP AX { ¤®áâ�¥ ¨§ á⥪� �¥ï¿½ã¦ï¿½®¥ }
POP AX {}
MOV AL, vstEmptyStackTask {}
MOV TaskError, AL {}
@ExitPoint: POP ES { ¢®ááâ���¢«¨¢ï¿½¥ ॣ¨áâàë }
POP DS {}
POP SI {}
POP DI {}
POP BP {}
end;
procedure SwithTasks; assembler;
{ --- ¯¥à¥ª«îç¥ï¿½¨¥ ¥¦¤ã §ï¿½¤ï¿½ç�¨ --- }
asm
{ 1) C®åà��¥ï¿½¨¥ ¢á¥å ॣ¨áâ஢ ⥪ã饣® ¯à®æ¥áá� [DS,ES,BP];
2) ��宦¤¥ï¿½¨¥ á«¥¤ãî饣® ¯à®æ¥áá� ¤«ï ¨á¯®«ï¿½¥ï¿½¨ï;
3) C®åà��¥ï¿½¨¥ ãªï¿½§ï¿½â¥«¥© SS:SP �� á⥪ ⥪ã饣® ¯à®æ¥áá�;
4) �§¥ï¿½¥ï¿½¨¥ ãªï¿½§ï¿½â¥«¥© SS:SP �� á⥪ ¤«ï ¯®á«¥¤ãî饣® ¯à®æ¥áá�;
5) �§¥ï¿½¥ï¿½¨¥ ¢á¥å ⥪ãé¨å ¯¥à¥¥ï¿½ï¿½ëå;
6) �®ááâ��®¢«¥ï¿½¨¥ ॣ¨áâ஢ ¤«ï �®¢®£® ¯à®æ¥áá� [BP,ES,DS]; }
{-----------------------------------------------------------------}
PUSH DS { á®åà��¥ï¿½¨¥ ॣ¨áâ஢ áâ�ண® }
PUSH ES { ¯à®æ¥áá� }
PUSH BP {}
MOV AX, SEG @Data { ãáâ��®¢ªï¿½ ᥣ¥ï¿½â� ¤ï¿½ï¿½ï¿½ëå }
MOV DS, AX {}
MOV ES, PCurTask.word[2] { ¢ ES:DI ãªï¿½§ï¿½â¥«ì �� ®¯¨á�⥫ì}
MOV DI, PCurTask.word[0] { ⥪ã饣® ¯à®æ¥áá� }
MOV ES:[DI+8], SS { á®åàï¿½ï¿½ï¥ SS:SP ¢ ⥪ãé¥ }
MOV ES:[DI+6], SP { ®¯¨á�⥫¥ ¯à®æ¥áá� }
MOV BX, ES:[DI+4] { ¢ BX:SI ãªï¿½§ï¿½â¥«ì �� á«¥¤ãî騩}
MOV SI, ES:[DI+2] { ¯à®æ¥áá }
MOV ES, BX { 㦥 ¢ ES:SI }
XOR AX, AX { ¯à®¢¥àªï¿½ �� Nil }
CMP BX, AX {}
JNE @Next { ¥á«¨ �¥ Nil-ª ®¡à�¡®âª¥ }
CMP SI, AX {}
JNE @Next {}
MOV ES, HeadStack.word[2] { ¨ï¿½ï¿½ç¥ á«¥¤ãî騩 - ��ç�«ìï¿½ë© }
MOV SI, HeadStack.word[0] { ®¯¨á�⥫ì HeadStack }
@Next: MOV PCurTask.word[2], ES { ¥ï¿½ï¥ ãªï¿½§ï¿½â¥«ì �� ⥪ã騩 }
MOV PCurTask.word[0], SI { ®¯¨á�⥫ì }
MOV AX, ES:[SI] { ¥ï¿½ï¥ �®¥à ⥪ã饣® ¯à®æ¥áá�}
MOV CurTask, AX {}
CLI {}
MOV SS, ES:[SI+8] { ¥ï¿½ï¥ ãªï¿½§ï¿½â¥«¨ á⥪� }
MOV SP, ES:[SI+6] { ¯®¤ �®¢ë© ¯à®æ¥áá }
STI {}
POP BP { ¢®ááâ��®¢«¥ï¿½¨¥ ॣ¨áâ஢ }
POP ES { �®¢®£® ¯à®æ¥áá� }
POP DS {}
end;
function RegisterTask(TaskPoint: pointer; SizeStack: word): word; assembler;
{ --- ॣ¨áâà�æ¨ï §ï¿½¤ï¿½ç¨ --- }
{ ¥á«¨ ¢®é§¢à�é¥ï¿½ 0, â® ®è¨¡ªï¿½ ¢ ¯¥à¥¥ï¿½ï¿½®© TaskError }
asm
{ 1) �®§¤ï¿½ï¿½¨¥ ¢ ¯ï¿½ï⨠®¯¨áï¿½â¥«ï ¯à®æ¥áá�;
2) �뤥«¥ï¿½¨¥ ¯ï¿½ï⨠¯®¤ á⥪ ¯à®æ¥áá�;
3) ��宦¤¥ï¿½¨¥ ã�¨ªï¿½«ì�®£® ®¯¨áï¿½â¥«ï ¯à®æ¥áá�;
4) �¢ï§ªï¿½ ®¯¨á�⥫ï �®¢®£® ¯à®æ¥áá� ¢ 楯®çªã ¯à®æ¥áᮢ;
5) �®åà��¥ï¿½¨¥ ¢ á⥪¥ ¯à®æ¥áá� �¤à¥á� ¢å®¤ï¿½ ¢ ¯à®æ¥áá ¨ ॣ¨áâ஢;
6) �ë室 ¢ ®á�®¢ï¿½ãî ¯à®£à�ã. }
{---------------------------------------------------------}
XOR AX, AX {}
NOT AX {}
CMP AX, UniNumber {}
JE @TooManyProc { ᫨誮 �®£® ¯à®æ¥áᮢ }
CALL mMemAvail { ¯à®¢¥àªï¿½ ��«¨ç¨ï ¯ï¿½ï⨠}
MOV BX, SizeStack {}
CMP AX, BX {}
JB @LowMem { ¥á«¨ ¯ï¿½ï⨠�¥â }
PUSH BX {}
CALL mGetMem { ¢ DX:AX ãªï¿½§ï¿½â¥«ì �� á⥪ }
PUSH DX {}
PUSH AX {}
CALL mMemAvail { ¯ï¿½ïâì ¤«ï TTaskRec }
MOV CX, TYPE TTaskRec {}
CMP AX, CX {}
JB @LowMemAndFree { ¥á«¨ �¥ å¢ï¿½â¨â }
PUSH CX { £®â®¢¨ ¯ï¿½à�¥âàë }
CALL mGetMem { ¢ë¤¥«ï¥ ¯ï¿½ïâì }
PUSH ES {}
MOV ES, DX { ES:DI ãªï¿½§ë¢ï¿½¥â �� ®¯¨á�⥫ì }
MOV DI, AX { �®¢®£® ¯à®æ¥áá� }
MOV AX, UniNumber { ¯à¨á¢ï¿½¨¢ï¿½¥ ã�¨ªï¿½«ìï¿½ë© ï¿½®¥à }
MOV ES:[DI], AX {}
INC AX { ¨ï¿½ªà¥¥ï¿½â UniNumber }
MOV UniNumber, AX {}
MOV BX, HeadStack.word[0] { ãªï¿½§ï¿½â¥«ì �� á«¥¤ãî騩 }
MOV CX, HeadStack.word[2] { ®¯¨á�⥫ì = HeadStack }
MOV ES:[DI+2], BX {}
MOV ES:[DI+4], CX {}
POP CX { ¢ CX §ï¿½ï¿½ç¥ï¿½¨¥ ES }
POP AX { ¢ AX á¥é¥ï¿½¨¥ á⥪� }
MOV ES:[DI+10], AX { á¥é¥ï¿½¨¥ ãªï¿½§ï¿½â¥«ï Stack }
MOV BX, SizeStack { á®åàï¿½ï¿½ï¥ à�§¥à á⥪� ¢ }
MOV ES:[DI+14], BX { SSize ⥪ã饣® ®¯¨á�⥫ï }
ADD AX, BX { ¢ëç¨á«ï¥ §ï¿½ï¿½ç¥ï¿½¨¥ SP }
JNC @NotCorrect { ¥á«¨ ª®à४æ¨ï �¥ �ã¦ï¿½ï¿½ }
XOR AX, AX {}
NOT AX { AX=$FFFF }
@NotCorrect: SUB AX, $01 {}
POP BX { ¢ BX ᥣ¥ï¿½â á⥪� }
MOV ES:[DI+12], BX { ᥣ¥ï¿½â ãªï¿½§ï¿½â¥«ï Stack }
MOV ES:[DI+8], BX { OrignSS=BX }
PUSH ES { á®åàï¿½ï¿½ï¥ á¥£¥ï¿½â ãªï¿½§ï¿½â¥«ï }
MOV ES, CX { ¢®ááâ��®¢¨«¨ ES }
MOV CX, TaskPoint.WORD[0] { á¥é¥ï¿½¨¥ ��ç�«ï¿½ §ï¿½¤ï¿½ç¨ }
MOV DX, TaskPoint.WORD[2] { ᥣ¥ï¿½â ��ç�«ï¿½ §ï¿½¤ï¿½ç¨ }
PUSH BP
CLI {}
MOV SI, SS { á®åàï¿½ï¿½ï¥ SS ¢ SI }
MOV BP, SP { á®åàï¿½ï¿½ï¥ SP ¢ BP }
MOV SS, BX { ¯¥à¥ãáâ���¢«¨¢ï¿½¥ á⥪ }
MOV SP, AX {}
MOV BX,SEG HaltCurrentTask { �¢â®ï¿½â¨ç¥áª¨© ¢ë室 ¢ }
MOV AX,OFFSet HaltCurrentTask { ¯à®æ¥¤ãàã HaltCurrentTask }
PUSH BX { ¯® ¤®á⨦¥ï¿½¨î ®¯¥à�â®à� END }
PUSH AX { ⥪ã饩 ¯à®æ¥¤ãàë-¯à®æ¥áá� }
PUSH DX { á®åàï¿½ï¿½ï¥ â®çªã ¢å®¤ï¿½ ¢ }
PUSH CX { ¯à®æ¥áá }
PUSH DS { á®åàï¿½ï¿½ï¥ ¢ �¥ DS }
PUSH ES { -\\- ES }
MOV DX, SP { £®â®¢¨ ¯á¥¢¤® BP }
ADD DX, $02 { §ï¿½â�«ª¨¢ï¿½¥ ¥£® ¢ á⥪ }
PUSH DX {}
MOV CX, SP {}
MOV SS, SI { ¢®ááâ���¢«¨¢ï¿½¥ á⥪ }
MOV SP, BP {}
STI {}
POP BP { ¢®ááâ���¢«¨¢ï¿½¥ BP }
MOV AX, ES {}
POP ES {}
MOV ES:[DI+6], CX { OrignSP=CX }
PUSH ES {}
MOV ES, AX {}
POP AX {}
MOV HeadStack.WORD[0], DI { ¯¥à¥ãáâ���¢«¨¢ï¿½¥ ãªï¿½§ï¿½â¥«ì }
MOV HeadStack.WORD[2], AX { HeadStack }
MOV AX, CountTask { ¨ï¿½ªà¥¥ï¿½â¨à㥠CountTask }
INC AX {}
MOV CountTask, AX {}
MOV AX, UniNumber { ¢®§¢à�é�¥ë© �®¥à ¯à®æ¥áá� }
DEC AX {}
JMP @Exit { ¢ë室 ¨§ ¯à®æ¥¤ãàë }
@TooManyProc: MOV AL, vstMAXLimitProc {}
MOV TaskError, AL {}
JMP @ErrExit {}
@LowMemAndFree: MOV BX, SizeStack {}
PUSH BX {}
CALL mFreeMem {}
@LowMem: MOV AL, vstMemoryLow {}
MOV TaskError, AL {}
@ErrExit: XOR AX, AX {}
@Exit:
end;
procedure HaltCurrentTask; assembler;
{ --- á�ï⨥ ⥪ã饩 §ï¿½¤ï¿½ç¨ --- }
asm
{ 1) ��宦¤¥ï¿½¨¥ ¢ ®ç¥à¥¤¨ ¯à®æ¥áᮢ á«¥¤ãî饣® ¯à®æ¥áá�;
2) �¥à¥ª«îç¥ï¿½¨¥ �� ¥£® SS ¨ SP;
3) �¥à¥ãáâ��®¢ªï¿½ ¢á¥å ¯¥à¥¥ï¿½ï¿½ëå;
4) ��¨ç⮦¥ï¿½¨¥ á⥪� ¯à¥¤ë¤ã饣® ¯à®æ¥áá�;
5) �¤ï¿½«¥ï¿½¨¥ ¨§ ®ç¥à¥¤¨ ¯à®æ¥áᮢ ®¯¨áï¿½â¥«ï ¯à®æ¥áá�;
6) �¤ï¿½«¥ï¿½¨¥ ¨§ ¯ï¿½ï⨠®¯¨áï¿½â¥«ï ¯à®æ¥áá�;
7a) �᫨ ¡ë« ��©¤¥ï¿½ á«¥¤ãî騩 ¯à®æ¥áá - â® ¢®ááâ��®¢«¥ï¿½¨¥
¥£® ॣ¨áâ஢ ¨ RETF;
7b) �᫨ ¡®«ìè¥ ¯à®æ¥áᮢ �¥â, â® ãáâ��®¢ªï¿½ SS:SP ®á�®¢ï¿½®©
¯à®£àï¿½ë ¨ RETF ¢ �¥¥. }
{--------------------------------------------------------------}
MOV AX, SEG @Data { ¯¥à¥ãáâ��®¢ªï¿½ ᥣ¥ï¿½â� DS }
MOV ES, PCurTask.word[2] { ¢ ES:DI ãªï¿½§ï¿½â¥«ì �� ⥪ã騩 }
MOV DI, PCurTask.word[0] { ®¯¨á�⥫ì }
XOR AX, AX { ®¡ï¿½ã«¥ï¿½¨¥ ¤®¯®«ï¿½¨â¥«ì�®£® }
MOV PDopPoint.word[0], AX { ãªï¿½§ï¿½â¥«ï }
MOV PDopPoint.word[2], AX {}
MOV AX, ES { AX:DI }
MOV DX, HeadStack.word[2] { ¢ DX:BX §ï¿½ï¿½ç¥ï¿½¨¥ ��ç�«ï¿½ á⥪� }
MOV BX, HeadStack.word[0] { ¯à®æ¥áᮢ }
@Loop: CMP DX, AX { ¯à®¢¥àªï¿½ à�¢¥ï¿½áâ¢ï¿½ ãªï¿½§ï¿½â¥«¥© }
JNE @NextProc { AX:DI ¨ DX:BX }
CMP BX, DI { ¥á«¨ �¥ à�¢ï¿½ë, â® ¯®¨áª à�¢ï¿½ëå}
JNE @NextProc {}
JMP @DelProcess { ª ã¤ï¿½«¥ï¿½¨î ¯à®æ¥áá� }
@NextProc: MOV ES, DX { áâந ॣ¨áâ஢ãî ¯ï¿½àã }
MOV SI, BX { ES:SI - ãªï¿½§ï¿½â¥«ì }
MOV PDopPoint.word[0], BX { á®åàï¿½ï¿½ï¥ ãªï¿½§ï¿½â¥«ì �� }
MOV PDopPoint.word[2], DX { ¯à¥¤ë¤ã騩 í«¥¥ï¿½â ®¯¨á�⥫ì }
MOV DX, ES:[SI+4] { ¢ DX:BX ãªï¿½§ï¿½â¥«ì �� á«¥¤ãî騩}
MOV BX, ES:[SI+2] { í«¥¥ï¿½â á⥪� ®¯¨á�⥫¥© }
JMP @Loop {}
@DelProcess: MOV ES, AX { ES:DI }
MOV BX, ES:[DI+2] { ¢ BX á¥é¥ï¿½¨¥ á«¥¤ãî饣® }
MOV PCurTask.word[0], BX { í«¥¥ï¿½â� }
MOV DX, ES:[DI+4] { ⮦¥ á ᥣ¥ï¿½â® }
MOV PCurTask.word[2], DX {}
XOR CX, CX { ¯à®¢¥àï¥ PDopPoint �� Nil }
CMP CX, PDopPoint.word[0] {}
JNE @NotNil { ¥á«¨ �¥ Nil }
CMP CX, PDopPoint.word[2] {}
JNE @NotNil {}
MOV HeadStack.word[0], BX { ¯¥à¥áâ�¢«ï¥ ãªï¿½§ï¿½â¥«ì �� }
MOV HeadStack.word[2], DX { ��ç�«® á⥪� }
JMP @FreeMem {}
@NotNil: PUSH ES {}
PUSH DI {}
MOV ES, PDopPoint.word[2] { ¢ ES:DI ãªï¿½§ï¿½â¥«ì �� }
MOV DI, PDopPoint.word[0] { ¯à¥¤ë¤ã騩 í«¥¥ï¿½â }
MOV ES:[DI+2], BX { ¯¥à¥áâ�¢«ï¥ ãªï¿½§ï¿½â¥«ì Next ã }
MOV ES:[DI+4], DX { ¯à¥¤ë¤ã饣® í«¥¥ï¿½â� }
POP DI { ¢ ES:DI ãªï¿½§ï¿½â¥«ì �� ã¤ï¿½«ï¥ë©}
POP ES { í«¥¥ï¿½â }
@FreeMem: CLI {}
MOV SS, OriginalSS { ¢®ááâ���¢«¨¢ï¿½¥ á⥪ }
MOV SP, OriginalSP { ®á�®¢ï¿½®© ¯à®£à�ë }
STI {}
MOV DX, ES:[DI+12] { ¢ DX:BX ãªï¿½§ï¿½â¥«ì �� á⥪ }
MOV BX, ES:[DI+10] { ã¤ï¿½«ï¥®£® ¯à®æ¥áá� }
MOV CX, ES:[DI+14] { ¢ CX à�§¥à á⥪� }
PUSH ES {}
PUSH DI
PUSH DX { £®â®¢¨ á⥪ ¨ ®á¢®¡®¦¤ï¿½¥ }
PUSH BX { ¯ï¿½ïâì á⥪� ã¤ï¿½«ï¥®£® }
PUSH CX { ¯à®æ¥áá� }
CALL mFreeMem {}
POP DI {}
POP ES {}
MOV CX, TYPE TTaskRec { à�§¥à §ï¿½¯¨á¨ TTaskRec -> CX }
PUSH ES { ã¤ï¿½«ï¥ ®¯¨áï¿½â¥«ì ¯à®æ¥áá� ¨§ }
PUSH DI { ¯ï¿½ï⨠}
PUSH CX {}
CALL mFreeMem {}
XOR AX, AX { ®¡ï¿½ã«¨âì �®¥à â¥ã饣® ¯à®æ¥áá�}
MOV CurTask, AX {}
MOV AX, CountTask { ¤¥ªà¥¥ï¿½â CountTask }
DEC AX {}
MOV CountTask, AX {}
JZ @Exit { ¯à®æ¥áᮢ ¡®«ìè¥ ï¿½¥â }
MOV ES, PCurTask.word[2] { PCurTask -> ES:DI }
MOV DI, PCurTask.word[0] {}
MOV BX, ES {}
XOR AX, AX {}
CMP AX, BX { ¥á«¨ PCurTask �¥ à�¢¥ï¿½ }
JNE @SetProcess { Nil, â® ¯¥à¥ãáâ��®¢¨âì }
CMP AX, DI { ⥪ã騩 ¯à®æ¥áá }
JNE @SetProcess {}
MOV ES, HeadStack.word[2] { HeadStack -> ES:DI }
MOV DI, HeadStack.word[0] {}
MOV PCurTask.word[2], ES { ES:DI -> PCurTask }
MOV PCurTask.word[0], DI {}
@SetProcess: MOV AX, ES:[DI] { NumProc -> AX }
MOV CurTask, AX {}
CLI {}
MOV SS, ES:[DI+8] { ¯¥à¥ãáâ��®¢ªï¿½ á⥪� }
MOV SP, ES:[DI+6] {}
STI {}
POP BP { ¢®ááâ��®¢«¥ï¿½¨¥ ॣ¨áâ஢ }
POP ES { ¯à®æ¥áá� }
POP DS {}
@Exit:
end;
procedure HaltAllTasks; assembler;
{ --- á�ï⨥ ¢á¥å §ï¿½¤ï¿½ç --- }
asm
{ 1) �¡ï¿½ã«¥ï¿½¨¥ ¢á¥å ¯¥à¥¥ï¿½ï¿½ëå;
2) �¤ï¿½«¥ï¿½¨¥ ®ç¥à¥¤¨ ¯à®æ¥áᮢ á® á⥪�¨;
3) �áâ��®¢ªï¿½ SS:SP ®á�®¢ï¿½®© ¯à®£àï¿½ë ¨ RETF ¢ �¥¥. }
MOV AX, SEG @Data { ¢®ááâ���¢«¨¢ï¿½¥ ᥣ¥ï¿½â DS }
MOV DS, AX {}
XOR AX, AX { PCurTask=Nil }
MOV PCurTask.word[0], AX {}
MOV PCurTask.word[2], AX {}
CLI {}
MOV SS, OriginalSS { ¢®ááâ���¢«¨¢ï¿½¥ á⥪ ¯à®£à�ë}
MOV SP, OriginalSP {}
STI {}
@Loop: XOR AX, AX {}
CMP AX, CountTask { á®âਠ¥áâì «¨ ¯à®æ¥ááë }
JE @StackEmpty { ¥á«¨ �¥â ¢ë室 }
MOV ES, HeadStack.word[2] { ¢ ES:DI ãªï¿½§ï¿½â¥«ì �� ¯¥à¢ë© }
MOV DI, HeadStack.word[0] { í«¥¥ï¿½â ®ç¥à¥¤¨ ¯à®æ¥áᮢ }
MOV DX, ES:[DI+4] { DX:BX ãªï¿½§ï¿½â¥«ì �� á«¥¤ãî騩 }
MOV BX, ES:[DI+2] { í«¥¥ï¿½â á⥪� ¨«¨ Nil }
MOV HeadStack.word[2], DX { HeadStack = DX:BX }
MOV HeadStack.word[0], BX {}
MOV AX, ES:[DI+12] { ¢ AX:CX ãªï¿½§ï¿½â¥«ì �� á⥪ }
MOV CX, ES:[DI+10] { ¯à®æ¥áá� }
PUSH ES { £®â®¢¨ á⥪ ¤«ï ¢ë§®¢ï¿½ ¯à®æ¥-}
PUSH DI { ¤ãàë ®ç¨á⪨ ¯ï¿½ï⨠}
PUSH AX { AX:CX - ãªï¿½§ï¿½â¥«ì �� á⥪ }
PUSH CX { ¯à®æ¥áá� }
MOV AX, ES:[DI+14] { ¢ AX à�§¥à á⥪� }
PUSH AX {}
CALL mFreeMem { ã�¨ç⮦�¥ á⥪ ¯à®æ¥áá� }
MOV AX, TYPE TTaskRec { ¢ AX à�§¥à ®¯¨áï¿½â¥«ï ¯à®æ¥áá�}
PUSH AX {}
CALL mFreeMem { ã�¨ç⮦�¥ ®¯¨áï¿½â¥«ì ¯à®æ¥áá� }
MOV AX, CountTask { ¤¥ªà¥¥ï¿½â¨à㥠CountTask }
DEC AX {}
MOV CountTask, AX {}
JMP @Loop { ã�¨ç⮦�âì á«¥¤ãî騩 ¯à®æ¥áá }
@StackEmpty: MOV CurTask, AX { CurTask=0 }
end;
{----------------------------------------------------------------}
end.
[Back to MEMORY SWAG index] [Back to Main SWAG index] [Original]