home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / TURBOPAS / PGM_AIDE.ZIP / PGM-AIDE.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-10-03  |  32.1 KB  |  589 lines
  1. {$C-}
  2. {-----------------------------------------------------------------------------}
  3. {                                                                             }
  4. {                                                                             }
  5. {         "  S o r r y ,  D a v e,   I   C a n ' t   D o   T h a t .  "       }
  6. {                                                                             }
  7. {                                                          Arthur C. Clark    }
  8. {                                                           " 2 0 0 1 "       }
  9. {-----------------------------------------------------------------------------}
  10. { Stayres Version 3.31
  11.  
  12. {  A  Turbo  "stay-resident" program clobbers the Dos register stack.  It
  13.   jumps over the Turbo run-time initialization code that would set up the
  14.   program registers  and environment.   Secondly,  a  stay-resident  program
  15.   could not ordinarily issue file I/O since that would clobber Dos interrupt
  16.   registers.  Therefore,  the following code proposes an inline solution,
  17.   providing a Turbo entry  stack  for  "stay-resident"  programs  and allowing
  18.   those programs to issue Dos I/O and other interrupts.
  19.  
  20.   This Turbo stay-resident program will perform both Dos I/O
  21.   and Bios interrupts. It has been tested for re-entrancy and recursiveness
  22.   on an IBM PC with PCDOS 2.1, 3.1 .
  23.  
  24.   R_U_N   I_N_S_T_R_U_C_T_I_O_N_S
  25.   Execute the command file and activate with the default
  26.   Alt-F1 key. It will also free its memory and return to Dos with the
  27.   Ctrl-Home key at the last "Press a key" prompt (Illustrated in the Stayxit
  28.   file). Maximum free dynamic memory should be between 300-400 paragraphs
  29.   since this it uses a recursive stack. If you get $FF runtime errors or
  30.   "allocation error", "cannot load Command.Com", then raise the mAximum
  31.   free value to something reasonable but less than your maximum memory -
  32.   20K. This program can ONLY run as a COM file.
  33.  
  34.   For those of you already using user interrupts 60-67, please change the
  35.   User_Int constant to an interrupt number you do not currently use .
  36.  
  37.                                                  The Hunter's Helper
  38.  
  39.                                                   Lane Ferris
  40.                                                   4268 26th St
  41.                                                   San Francisco,Ca. 94131
  42.                                                   [ 70357,2716 ]
  43. }
  44. {-----------------------------------------------------------------------------}
  45. {     This code has been tested/used on an IBM PC using PC-DOS 2.10/3.1       }
  46. {-----------------------------------------------------------------------------}
  47. { Authors: Lane H. Ferris (Stay Resident/Exit Code)       }
  48. {          Lynn A. Canning (Screen Counter                }
  49. {          Lynn A. Canning & Karson Morrison (Set Epson Printer}
  50. {          Lynn A. Canning (Pgm-Aide Driver               }
  51. {          Other Public Gurus on whose shoulders we stand.}
  52. {
  53.  PURPOSE:  This code will serve as a template to create other "Stay  Resident"
  54.            programs  in  Turbo  Pascal(tm).   This  code  intercepts  Int  16,
  55.            displacing original Interrupt  16  Vector  to  User  Interrupt  60.
  56.            During  execution  of  other  programs,  it  can  be invoked by the
  57.            special key combination  specified  by  "Our_Char"  (in  this  case
  58.            Alt-F1.)
  59.  
  60.  Modifications:
  61.           7. 7.85 - Replace Windows with a more simple form/less code.
  62.           7. 8.85 - Replace Window Array with Pointers/Heap form.
  63.           7.11.85 - Re-issue termination Keyboard Read / pass back to user
  64.                     Would like to back up Instruction Ptr by two bytes before
  65.                     the Int 16 ($CD16) but it might be a "long call" by
  66.                     some other Kbd interceptor (chirp chirp chrip)... and
  67.                     thats "trouble in River City".
  68.           7.19.85 - Clean up RmWin "incorrect" attribute bugs. If screen
  69.                     isnt cleared, we get border attribute, not text attrb.
  70.                   - Remove last window at Termination Time (Ctrl-Home).
  71.           8.26.85 - Version 3.10 Changes
  72.                     1) Save 40 words in StaySave/Rstr to avoid clobbering
  73.                        Dos Stack when entering Dos with Turbo Write(ln) caused
  74.                        by Int 21 Function 5  (Writln(Lst,..)) which re-issues
  75.                        Int 16.
  76.                     2) Change Int 68 to Int 67 to Avoid collisions with
  77.                        Dos 3.1 on an AT.
  78.                     3) Correct "Press a Key..." to accept any "Key..."
  79.                        (not just Cr).
  80.                     4) Check Int16 function. Jmp directly to Int16 if not
  81.                        a character request. Avoids 40 word Save/Restore
  82.                        overhead.
  83.           9.04.85 - Version 3.20 changes
  84.                     When returning to user program, pass back a fake
  85.                     "Ctrl-key" scan code to allow immediate re-execution
  86.                     of the TSR (Terminate Stay Resident) program. Also
  87.                     solves SideKick incessant bird caws.
  88.           9.18.85 - Version 3.2C
  89.                     When saving/restoring the stack, save 40 words or less
  90.                     depending on stack size (0-Sp = stack size) to avoid
  91.                     overflowing into SS:0 when stack is less than 40 words.
  92.                     Put back the "wait for user key logic" at program end.
  93.                     Beep like SuperKick if Key is OurKey
  94.                     Version 3.31
  95.           9.19.85   Futz around with the "wait for user key logic", allow
  96.                     the Our_key to pass, but beep user to show we aint
  97.                     gonna activate, cuz our InUse bit is still set.
  98.                     Clean up the documentation and duplicate instructions in
  99.                     StaySave/Rstr.
  100.                     Change Int67 to Int60 for Fun and Profit and get around
  101.                     Mark Stanock's use of those locations.
  102. }
  103. Program Stay_Resident;
  104.  
  105. { * * * * * * * CONSTANTS * * * * * * * * * * * * * * * * * * * * * * }
  106.   const
  107.     Our_Char        =  104; {this is the scan code for AltF1}
  108.     Ctrl_Home       = #119; {Control Home Scan Code          }
  109.     Quit_Key        = #119;
  110.     Ctrl_End        = #117; {Control End Scan Code           }
  111.     User_Int        = $60; {place to put new interrupt}
  112.     Kybrd_Int       = $16; {BIOS keyboard interrupt}
  113.     MaxWin          = 3;   { Max number of windows open at one time }
  114.  
  115. {  - - - - - - T Y P E    D E C L A R A T I O N S - - - - - - - - - - - -  }
  116.   Type
  117.     Regtype     = record Ax,Bx,Cx,Dx,Bp,Si,Di,Ds,Es,Flags:integer  end;
  118.     HalfRegtype = record Al,Ah,Bl,Bh,Cl,Ch,Dl,Dh:byte              end;
  119.     filename_type = string[64];
  120.  
  121. { - - - - - - - T Y P E D   C O N S T A N T S - - - - - - - - - - - - - - -}
  122.   Const
  123.     {regs is defined as a typed constant in order to get it in the code segment}
  124.  
  125.       Regs   : regtype = (Ax:0;Bx:0;Cx:0;Dx:0;Bp:0;Si:0;Di:0;Ds:0;Es:0;Flags:0);
  126.  
  127.       OurDseg: integer = 0;            {Our Data Segment Value             }
  128.       OurSseg: integer = 0;            {Our Stack Segment Value            }
  129.       DosSseg: integer = 0;            {Dos Stack Segment Value            }
  130.       Inuse  : Boolean = false;        {Recursion flag                     }
  131.      { The following two constants *MUST* remain in the Ip:CS order        }
  132.      { because StaySave uses them as a JMP target                          }
  133.       User_IntIP : integer = 0;        {Pointer to Original IP Int value   }
  134.       User_IntCs : integer = 0;        {Pointer to Original Cs Int value   }
  135.       StackSize  : integer = 0;        {Current User/or Dos Stack word size}
  136.  
  137.  { - - - - - - - V A R I A B L E S - - - - - - - - - - - - - - - - - - - - - -}
  138.     Var
  139.       SaveRegs                      : regtype;
  140.       HalfRegs                      : halfregtype absolute regs;
  141.       Terminate_flag                : boolean ;
  142.       Keychr                        : char ;
  143.       Old_Xpos,Old_Ypos             : integer ;
  144.  
  145.  
  146. {-----------------------------------------------------------------------------}
  147. {                 W  I  N  D  O  W     R  O  U  T  I  N  E                    }
  148. {---------------------------------------------------------------------------- }
  149.  
  150. {$I WINDO.INC}
  151.  
  152. {-----------------------------------------------------------------------------}
  153. {            S  T  A  Y  E  X  I  T                                           }
  154. {-----------------------------------------------------------------------------}
  155. {$I STAYXIT.320}
  156.  
  157. {----------------------------------------------------------------------}
  158. {          B e e p   :  S o u n d  t h e  H o r n                      }
  159. {----------------------------------------------------------------------}
  160. Procedure Beep(N :integer); {------------------------------------------}
  161.    Begin                    {  This routine sounds a tone of frequency }
  162.       Sound(n);             {  N for approximately 100 ms              }
  163.       Delay(100);           {------------------------------------------}
  164.       Sound(n div 2);
  165.       Delay(100);
  166.       Nosound;
  167.       End {Beep} ;
  168.  
  169. {-----------------------------------------------------------------------------}
  170. {            THE FOLLOWING ARE THE USER INCLUDE ROUTINES                      }
  171. {-----------------------------------------------------------------------------}
  172.  
  173. {-----------------------------------------------------------------------------}
  174. {            E  P  S  O  N    P  R  I  N  T  E  R    S  E  T  U  P            }
  175. {-----------------------------------------------------------------------------}
  176. Procedure EP;
  177. {$I EP.INC}
  178.  
  179. {-----------------------------------------------------------------------------}
  180. {            S  C  R  E  E  N    C  O  U  N  T  E  R                          }
  181. {-----------------------------------------------------------------------------}
  182. Procedure SC;
  183. {$I SC.INC}
  184.  
  185. {-----------------------------------------------------------------------------}
  186. {            P  R  O  G  R  A  M    A  I  D  E                                }
  187. {-----------------------------------------------------------------------------}
  188. Procedure PgmAide;
  189. {$I PGM-AIDE.DVR}
  190.  
  191. {-----------------------------------------------------------------------------}
  192. {            THE ABOVE ARE THE USER INCLUDE ROUTINES                          }
  193. {-----------------------------------------------------------------------------}{---------------------------------------------
  194. {-----------------------------------------------------------------------------}
  195. {              P R O C E S S   I N T E R R U P T                              }
  196. { - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - }
  197. Procedure Process_Intr;
  198.  
  199. {  PURPOSE:  This  procedure  replaces  the  standard  keyboard  interrupt.  If
  200.             anything but <Alt>-F1 is pressed,  the key is  passed  on  to  the
  201.             standard  keyboard  interrupt.  B*U*T  when  <Alt>- F1 is pressed,
  202.             this program takes over.  The variable InUse  is  set  to  TRUE  to
  203.             ensure that this code doesn't try to run "on top of itself " AND to
  204.             indicate  to the Inline code to save/restore the original interrupt
  205.             regs.
  206. }
  207. Begin
  208.           { K e y b o a r d    Interrupt   o c c u r s   here }
  209. {----------------------------------------------------------------------}
  210. { This could also have the include data as $I StaySave.331 }
  211. {****************************************************************************}
  212. {                 S  T  A  Y  S  A  V  E  .  I  N  C                         }
  213. {                                                                            }
  214. {           This is the Staysave.Inc file included above                     }
  215. {                                                                            }
  216. {      Separate the code out into a file or replace the $I Staysave.331      }
  217. {                statement above with this code.                             }
  218. {****************************************************************************}
  219.  
  220. {This Inline routine will save the regs and Stack for Stay resident programs.
  221.  It restores DS and SS from the previously saved integer constants "OurDseg"
  222.  and "OurSSeg". This is important since Dos is not re-entrant and any attempt
  223.  to use Interrupt I/O services will clobber the very stack on which the
  224.  Resident Turbo program just saved its regs. Thus, on the final return, you
  225.  and Toto will end up somewhere other than Kansas and without your Ruby Reds.
  226.    }
  227.  
  228. { Arthor:      Lane Ferris
  229.               - The Hunter's Helper -
  230.  
  231.        Distributed to the Public Domain for use without profit.
  232.                     Original Version 5.15.85
  233. }
  234.            { On entry the Stack will already contain: }
  235.            {  1) Sp for Dos                           }
  236.            {  2) Bp for Dos                           }
  237.            {  3) Ip for Dos                           }
  238.            {  4) Cs for Dos                           }
  239.            {  5) Flags for Dos                        }
  240.   Inline (
  241.  
  242.  { The following routine avoids the overhead of saving the DOS stack         }
  243.  { when the INT 16 function was not for a character request. This happens    }
  244.  { often (every four chars) as DOS checks on ^S/^Q/^C/Keypressed  ad.nausea  }
  245.  
  246.    $80/$FC/$00/                        {Cmp Ah,00     If Char request,       }
  247.    $74/$07/                            {Je   ChrRqst  enter Staysave code    }
  248.    $5D/$5D/                            {Pop  Bp/Pop Bp else  Restore Bp &    }
  249.    $2E/                                {     Jump to Original Dos Interrupt  }
  250.    $FF/$2E/User_IntIP/                 {Jmp Far Cs:[User_IntIp]              }
  251.  
  252.             { Move the current active registers to a save place}
  253.  
  254. {ChrRqst: }
  255.     $FA /                              {Cli         Stop all interrupts       }
  256.                                        { Bp and Sp aready saved at Begin Stmt }
  257.     $55/                               {Push   Bp  Save again for Regpak      }
  258.     $BD/Regs/                          {Mov    Bp,offset REGS address savearea}
  259.     $2E/$89/$46/$00/                   {CS:Mov [Bp+0],AX Save Users Registers }
  260.     $2E/$89/$5E/$02/                   {Cs:Mov [Bp+2],Bx}
  261.     $2E/$89/$4E/$04/                   {CS:Mov [Bp+4],CX}
  262.     $2E/$89/$56/$06/                   {CS:Mov [Bp+6],DX}
  263.     $2E/$8F/$46/$08/                   {Pop    Cs:[Bp+8] Fetch Bp from stack  }
  264.     $2E/$89/$76/$0A/                   {CS:Mov [Bp+A],SI}
  265.     $2E/$89/$7E/$0C/                   {CS:Mov [Bp+C],DI}
  266.     $2E/$8C/$5E/$0E/                   {CS:Mov [Bp+E],DS}
  267.     $2E/$8C/$46/$10/                   {CS:Mov [Bp+10],ES}
  268.     $9C/                               {PUSHF  put Flags on stack to retrieve }
  269.     $2E/$8F/$46/$12/                   {POP Cs:[Bp+12]}
  270.  
  271.                { If Current SS := [OurSseg] or (Inuse = True), }
  272.                { then dont overlay the previously saved stack. }
  273.                { This program is being recursive.              }
  274.  
  275.      $2E/$80/$3E/Inuse/$01/   {Cmp  Cs:[Inuse],1   Inuse = True ?         }
  276.      $74/$62/                 {Je   ReCurin        Yes, -J-U-M-P-         }
  277.  
  278.                { Switch the SS:Sp reg pair over to ES:Si       }
  279.                { Put Turbo's Stack pointers into SS:Sp         }
  280.  
  281.      $2E/$8C/$16/DosSSeg/     {Mov  Cs:DosSSeg,SS Save Dos Stack Segment    }
  282.      $8C/$D6/                 {Mov  Si,SS         Es gets Dos stack         }
  283.      $8E/$C6/                 {Mov  Es,Si                                   }
  284.      $2E/$8E/$16/OurSSeg/     {Mov  SS,Cs:OurSSeg SS Gets our Stack segment }
  285.      $2E/$8E/$1E/OurDseg/     {Mov  Ds,Cs:Our_Ds  DS Gets our Data Segment  }
  286.  
  287.                { If ES:Si (stack ptr) <>  OurSSeg  then        }
  288.                { Sp := Virgin Turbo Stack pointer.             }
  289.                { If Es:Si := OurSSeg, then this is a Read or   }
  290.                { Write before Inuse was set True. Dont clobber }
  291.                { the current setting of Turbo stack pointer.   }
  292.  
  293.      $2E/$3B/$36/OurSSeg/     {Cmp  Si,Cs:OurSSeg If SS := OurSSeg then     }
  294.      $89/$E6/                 {Mov  Si,Sp         dont clobber saved regs   }
  295.      $74/$05/                 {Je   $+5           else get virgin stack ptr }
  296.      $3E/$8B/$36/$74/$01/     {Mov  Si,Ds:[174]   ..(cf. code at B2B 3.0x)  }
  297.      $87/$F4/                 {Xchg Sp,Si         Set new  Stack Pointer    }
  298.  
  299.                { Stack Dos/User interrupted pgm regs for Exit. }
  300.                { These are the original interrupt process regs }
  301.                { that must be returned on interrupt return     }
  302.  
  303.      $2E/$FF/$76/$00/         {Push [Bp+0]  Save Ax                         }
  304.      $2E/$FF/$76/$02/         {Push [Bp+2]  Save Bx                         }
  305.      $2E/$FF/$76/$04/         {Push [Bp+4]  Save Cx                         }
  306.      $2E/$FF/$76/$06/         {Push [Bp+6]  Save Dx                         }
  307.                               {Push [Bp+8]  Save Bp                         }
  308.      $2E/$FF/$76/$0A/         {Push [Bp+A]  Save Si                         }
  309.      $2E/$FF/$76/$0C/         {Push [Bp+C]  Save Di                         }
  310.      $2E/$FF/$76/$0E/         {Push [Bp+E]  Save Ds                         }
  311.      $2E/$FF/$76/$10/         {Push [Bp+10] Save Es                         }
  312.  
  313.                { Now stack the lesser of current stack size or  }
  314.                { 40 Words to our stack, to be re-stack on the   }
  315.                { interrupted pgms stack on exit. This is done   }
  316.                { to allow recursive entry into Dos/or other non }
  317.                { re-entrant pgms.                               }
  318.  
  319.      $29/$C9/                 {Sub  Cx,Cx  Find minimum of current stack    }
  320.      $29/$F1/                 {Sub  Cx,Si  size or 40 words to save.        }
  321.      $D1/$E9/                 {Shr  Cx,1   Stackbytes/2 for words.          }
  322.      $83/$F9/$40/             {Cmp  Cx,+40 This keeps up from overrunning   }
  323.      $7E/$03/                 {Jle  $+3    the Stack Segment when it is less}
  324.      $B9/$40/$00/             {Mov  Cx,40  than Dos stack size              }
  325.      $2E/$89/$0E/StackSize/   {Mov  Cs:StackSize,Cx Save current stack size }
  326.  {Restack:}
  327.      $26/$FF/$34/             {Push Es:[Si] Our Stack := Dos Es:Si          }
  328.      $46/$46/                 {Inc  Si/Inc Si Get Next Dos Stack Word       }
  329.      $E2/$F9/                 {Loop to Restack                              }
  330.  
  331.      $56/                     {Push Si            Save bottom of Dos Stack  }
  332.      $2E/$8C/$5E/$0E/         {Mov  Cs:[Bp+E],Ds  Set New Data Segmt in regs}
  333. {Recurin}                     {                     Jump here if Recursion  }
  334.      $FB                      {Sti Enable Interrupts                        }
  335.  
  336.        ) ;
  337. {...........................................................................}
  338. {---------------------------------------------------------------------------}
  339. {           END OF THE STAYSAVE REGISTER ROUTINE                            }
  340. {---------------------------------------------------------------------------}
  341.  
  342. {  Set New Data Segmt in regs}
  343. {----------------------------------------------------------------------}
  344. { Check the Int 16 request function in Ah reg:
  345.                    0 = read character from Keyboard
  346.                    1 = check character available
  347.                    2 = check shift key values
  348. }
  349.  
  350.           { HalfRegs.Ah = 0  This is a Character Request because StaySave }
  351.           { doesnt allow an enter here unless it is!                      }
  352.  
  353.   Intr (User_Int, Regs);             { Use the DOS replaced interrupt}
  354.                                      { Get Key from Keyboard         }
  355.   If (Halfregs.Ah = Our_Char)        { Separate the tests so code    }
  356.                                      { performs efficiently.         }
  357.      then if  (not InUse) then       { Must be OUR key and not busy  }
  358.  
  359.         Begin { PROGRAM AIDE }
  360.         InUse := true;                  { "dont clobber saved stack"}
  361. {--------------------------------------------------------------------------}
  362. {                       INVOKE USER PROCEDURE HERE                         }
  363. {--------------------------------------------------------------------------}
  364.         PgmAide;
  365. {--------------------------------------------------------------------------}
  366. {                       END USER PROCEDURE HERE                            }
  367. {--------------------------------------------------------------------------}
  368.         Regs.Ax := $1D00;                { Give Dummy Ctrl Scan Code to    }
  369.                                          {           interrupted program   }
  370.         While (not Keypressed);          { Get input key for the users     }
  371.          SaveRegs.Ax := 0 ;               {           interrupted program   }
  372.          Intr(User_Int,SaveRegs);         { Get the Scancode                }
  373.          Regs.Ax := SaveRegs.Ax;
  374.          If HalfRegs.Ah = Our_Char then Beep(650);
  375.  
  376.         InUse := false;                  { ok to restore interrupted stack }
  377.         End;  { PROGRAM AIDE }
  378. {---------------------------------------------------------------------------}
  379. {---------------------------------------------------------------------------}
  380. {             BEGINNING OF THE STAYRSTR ROUTINE                             }
  381. {---------------------------------------------------------------------------}
  382. { This could also be used as $I StayRstr.331 }
  383. {****************************************************************************}
  384. {                  S  T  A  Y  R  S  T  R  .  I  N  C                        }
  385. {                                                                            }
  386. {           This is the StayRstr.Inc file included above                     }
  387. {       Separate the code out into a file or replace the $I StayRstr.331     }
  388. {                  statement above with this code.                           }
  389. {****************************************************************************}
  390. {Version 3.31}
  391.                { Inline Code to restore the stack and regs moved}
  392.                { to the Turbo Resident Stack which allows       }
  393.                { re-entrancy into Dos for I/O and  recursion    }
  394.                { for Turbo Terminate & Stay Resident programs.  }
  395.  
  396.        { Author: Lane Ferris                                       }
  397.        {         - The Hunter's Helper -                           }
  398.        { Distributed to the Public Domain for use without profit.  }
  399.        { Original Version 5.15.85                                  }
  400. {----------------------------------------------------------------------}
  401. {        Restore the Dos (or interrupted pgm) Regs and Stack           }
  402. {----------------------------------------------------------------------}
  403.            { On entry the Stack will already contain: }
  404.            {    Pointer to bottom of stack            }
  405.            {    Bottom of Dos Stack Ptr               }
  406.            {    StackSize words of saved pgm stack    }
  407.            {    Dos Flags                             }
  408.            {    Dos Code Segment                      }
  409.            {    Dos Instruction Ptr                   }
  410.            {    Dos Base Pointer                      }
  411.            {    Dos Original Stack Ptr                }
  412.  
  413.  
  414.            { Retrieve the Regpack registers as they were    }
  415.            { stored for the Interrupt Entry.                }
  416.  
  417.     inline(
  418.     $BD/Regs/                          {Mov    Bp,offset REGS}
  419.     $2E/$8B/$46/$00/                   {CS:Mov Ax,[Bp+0]}
  420.     $2E/$8B/$5E/$02/                   {Cs:Mov Bx,[Bp+2]}
  421.     $2E/$8B/$4E/$04/                   {CS:Mov Cx,[Bp+4]}
  422.     $2E/$8B/$56/$06/                   {CS:Mov Dx,[Bp+6]}
  423.  
  424.     $2E/$8B/$76/$0A/                   {CS:Mov Si,[Bp+A]}
  425.     $2E/$8B/$7E/$0C/                   {CS:Mov Di,[Bp+C]}
  426.     $2E/$8E/$5E/$0E/                   {CS:Mov DS,[Bp+E]}
  427.     $2E/$8E/$46/$10/                   {CS:Mov ES,[Bp+10]}
  428.     $2E/$FF/$76/$12/                   {Push Cs:[Bp+12]  }
  429.                                        {PopF             }
  430.             { The following code was added to avoid }
  431.             { the 80286 Pop flag (POPF) bug which   }
  432.             { enables interrupts while we are trying}
  433.             { to POP  the stack on odd byte boundry }
  434.     $EB/$01/                           {JMP $+3 Skip over IRET   }
  435.     $CF/                               {IRET    POP IP/CS/Flags  }
  436.     $0E/                               {PUSH CS Make a return    }
  437.     $E8/$FB/$FF/                       {CALL CS:$-2 Pop the Flags}
  438.  
  439.            { If [Cs:InUse]:= True,  then dont restore the stack.}
  440.            { This program is being recursive. Else restore  Dos }
  441.            { Stack and Program Entry registers for final exit.  }
  442.  
  443.      $2E/$80/$3E/Inuse/$01/   {Cmp  byte ptr Cs:[Inuse],1                   }
  444.      $74/$25/                 {Je   ReCurOut   J-U-M-P                      }
  445.  
  446.            { Move "StackSize" words back to the interrupted pgms}
  447.            { stack. The originals could have been clobber by our}
  448.            { being recursive. (Especially true of DOS)          }
  449.  
  450.     $FA /                    { Cli      ; Stop all interrupts    }
  451.     $5E/                     {Pop Si     Bottom of Dos Stack              }
  452.     $2E/$8B/$0E/StackSize/   {Mov Cx,Cs:StackSize Saved Stack Words       }
  453.     $2E/$8E/$06/DosSSeg/     {Mov ES,Cs:DosSSeg Get Dos StackSegment      }
  454.   {Restack:}
  455.     $4E/$4E/                 {Dec Si/Dec Si     Backup Dos Stack          }
  456.     $26/$8F/$04/             {Pop Es:[Si]       Dos Stack := Our Stack    }
  457.     $E2/$F9/                 {Loop to Restack                             }
  458.     $89/$F5/                 {Mov Bp,Si         Save Dos Sp across Pops   }
  459.  
  460.            {         - C - A - U - T - I - O - N -              }
  461.            { Restore the original interrupted programs regs     }
  462.            { except Ax. Ax usually contains status. It contains }
  463.            { a scan code and key for Int 16. You may want to    }
  464.            { rework this if using another interrupt.            }
  465.  
  466.     $07/                     {Pop  Es                                     }
  467.     $1F/                     {Pop  Ds                                     }
  468.     $5F/                     {Pop  Di                                     }
  469.     $5E/                     {Pop  Si                                     }
  470.     $5A/                     {Pop  Dx                                     }
  471.     $59/                     {Pop  Cx                                     }
  472.     $5B/                     {Pop  Bx                                     }
  473.     $44/$44/                 {Inc sp/Inc sp Thow old Ax value away        }
  474.  
  475.     $89/$EC/                  {Mov  Sp,Bp         Setup Dos Stack Ptr     }
  476.     $2E/$8E/$16/DosSSeg/      {Mov  SS,Cs:DosSSeg Give back Dos Stack     }
  477.  
  478. {RecurOut}                             {Clean up the Stack                }
  479.     $5D/                               {Pop Bp     Throw away old dos Sp  }
  480.     $BD/Regs/                          {Mov Bp,offset REGS                }
  481.     $2E/$FF/$76/$12/                   {Push Cs:[Bp+12]  Flags from last  }
  482.                                        {PopF             interrupt.       }
  483.             { The following code was added to avoid  }
  484.             { the 80286 Pop flag (POPF) bug which    }
  485.             { enables interrupts while we are trying }
  486.             { to POP  the stack on odd byte boundry  }
  487.  
  488.     $EB/$01/                           {JMP $+3 Skip over IRET   }
  489.     $CF/                               {IRET    POP IP/CS/Flags  }
  490.     $0E/                               {PUSH CS Make a return    }
  491.     $E8/$FB/$FF/                       {CALL CS:$-2 Pop the Flags}
  492.  
  493.     $5D/                               {Pop Bp  Retrieve old BP        }
  494.     $FB/                               {Sti     Enable interrupts      }
  495.     $CA/$02/$00                        {Ret Far 002 Thow old flags away}
  496.         );
  497. {.......................................................................}
  498. {---------------------------------------------------------------------------}
  499. {            END OF THE STAYRSTR ROUTINE                                    }
  500. {---------------------------------------------------------------------------}
  501.  
  502. End ;{Process_Intr}
  503. {-----------------------------------------------------------------------}
  504.  
  505. {-------------------------------------------------------------------------}
  506. {                             M  A  I  N                                  }
  507. {-------------------------------------------------------------------------}
  508.           { The main program installs the new interrupt routine }
  509.           { and makes it permanently resident as the keyboard   }
  510.           { interrupt.  The old keyboard interrupt is addressed }
  511.           { through #60H, so it can still be used.              }
  512.           {                                                     }
  513.           { The following dos calls are used:                   }
  514.           { Function 25 - Install interrupt address             }
  515.           {               input al = int number,                }
  516.           {               ds:dx = address to install            }
  517.           { Function 35 - get interrupt address                 }
  518.           {               input al = int number                 }
  519.           {               output es:bx = address in interrupt   }
  520.           { Function 31 - terminate and stay resident           }
  521.           {               input dx = size of resident program   }
  522.           {               obtained from the memory              }
  523.           {               allocation block at [Cs:0 - $10 + 3]  }
  524.           { Function 49 - Free Allocated Memory                 }
  525.           {               input Es = Block Segment to free      }
  526.           { Interrupt 20 - Return to invoking process           }
  527.           {-----------------------------------------------------}
  528.  
  529. {-----------M A I N    B L O C K---------------------------------------------}
  530. Begin                                  {**main**}
  531.  
  532.   InUse  := false;
  533.   OurDseg:= Dseg;           { Save the Data Segment Address for Interrupts }
  534.   OurSseg:= Sseg;           { Save our Stack Segment for Interrupts        }
  535.  
  536.  
  537.   Terminate_Flag := false ;
  538.   SaveRegs.Es := 00;     { clear for Dos 3.0 bug }
  539.   {now install the interrupt routine}
  540.  
  541.   SaveRegs.Ax := $3500 + User_Int;
  542.   Intr($21,SaveRegs);                 {Check to make sure int not already used}
  543.  
  544.   if SaveRegs.Es <> $00 then
  545.     WriteLn ('Interrupt in use -- can''t install Resident Turbo Code')
  546.   else
  547.     begin
  548.  
  549.  
  550.       SaveRegs.Ax := $3500 + Kybrd_Int;
  551.       Intr($21,SaveRegs);        {get the address of keyboard interrupt }
  552.  
  553.       SaveRegs.Ax := $2500 + User_Int;
  554.       SaveRegs.Ds := SaveRegs.Es;
  555.       SaveRegs.Dx := SaveRegs.Bx;
  556.       Intr($21,SaveRegs);       { set the user-interrupt address to point
  557.                                 { to the keyboard interrupt address }
  558.  
  559.       SaveRegs.Ax := $2500 + Kybrd_Int;
  560.       SaveRegs.Ds := Cseg;
  561.       SaveRegs.Dx := Ofs(Process_Intr);
  562.       Intr ($21,SaveRegs);        { set the keyboard interrupt to point to
  563.                                   "Process-Intr" above}
  564.  
  565.       User_IntIp := MemW[0:User_Int * 4 ];  { Location of User Interrupt Ip }
  566.       User_IntCs := MemW[0:User_Int * 4 +2];{ Location of User Interrupt Cs }
  567.  
  568. {----------------------------------------------------------------------------}
  569. {                INITIALIZE YOUR PROGRAM HERE                                }
  570. {----------------------------------------------------------------------------}
  571.       { Initialize Your Progam Here since you wont get control again
  572.         until "Our_Char" is entered from the Keyboard.               }
  573.       Writeln('  Turbo Stay-Resident Program Aide');
  574.       Writeln('        Press Alt-F1 to Call');
  575.  
  576. {----------------------------------------------------------------------------}
  577. {               END OF INITALIZE PROGRAM CODE                                }
  578. {----------------------------------------------------------------------------}
  579.  
  580.       {now terminate and stay resident}
  581.                                               { Pass return code of zero    }
  582.       SaveRegs.Ax := $3100 + 0 ;              { Terminate and Stay Resident }
  583.       SaveRegs.Dx := MemW [Cseg-1:0003] ;     { Prog_Size from Allocation Blk}
  584.       Intr ($21,SaveRegs);
  585.  
  586.     end;
  587.        { END OF RESIDENCY CODE }
  588. end.
  589.