{
 by Sean L. Palmer
 Public Domain

 This is a 'multitasking' Program in the sense that it hooks into
 the timer interrupt, but what that interrupt ends up actually
 doing is controlled by the current value in SaveAdr, which
 changes With each interrupt as the routine passes control back
 to the tick handler not by Exiting normally, but by an explicit
 transfer of control.
 The end result of this is that you can Write a state-driven
 interrupt handler
 The included example is RealLY simplistic, and barely tested.
 I intend to use this to Write a comm port driver that
 parses the incoming data as it receives it which would
 be nice in a communications Program that shells to Dos, as
 the incoming Chars could be saved to disk in the background
 With buffered ZModem or something...
}

Program intTest;

Uses
  Dos;

Var
  saveAdr : Word;  {offset in this code segment of where we are now}
  active  : Boolean;  {to avoid re-entrancy}

Procedure intHandler; Far; Assembler;
Asm
  pusha
  mov  ax, seg @DATA
  mov  ds, ax

  {anything you need to do before continuing (reading port data?), do here}

  in   al, $61  {click speaker as an example}
  xor  al, 2
  out  $61, al

  test active, $FF  {exit now if interrupted ourselves}
  jz   @OK
  popa
  iret

 @OK:
  inc Byte ptr active
  sti
  jmp [saveAdr]  {near jump to continue where handler last left off}
end;

{call this Procedure from StateHandler to suspend execution Until next time}

Procedure wait; near; Assembler;
Asm {wait For next interrupt}
  pop Word ptr saveAdr  {save where to continue next time}
  dec Byte ptr active
  popa                  {restore caller regs}
  iret
end;

Const
  c : Char = '.';

Procedure stateHandler;
begin
{
 a stateHandler Procedure should never ever Exit (only by calling 'wait'),
 shouldn't have any local Variables or parameters, and shouldn't call
 'wait' With anything on the stack (like from a subroutine).
 This routine is using the caller's (interrupted Program's) stack, so be
 very very careful}

 Asm
   pop bp  {clean up stack mess left by Turbo's Procedure header}
 end;
 {^ alternative method here is to init saveAdr to offset(proc)+3 and skip
  the push bp; mov bp,sp altogether}

  Repeat  {this is an example only}
    c := '@';
    wait;
    c := '.';
    wait;
  Until False;                {don't let it return normally!!}
end;

Var
  oldHook : Procedure;
  i       : Integer;

begin
  saveAdr := ofs(stateHandler);
  getIntVec($1C, @oldHook);
  setIntVec($1C, @intHandler);
  For i := 1 to 1500 do
    Write(c);
  setIntVec($1C, @oldHook);
end.