[Back to TSR SWAG index] [Back to Main SWAG index] [Original]

    {
    I love it when people actually post there hard slaved code. I've
    seen a number of people wanting to write tsr's, and all the examples
    in BP that I've ever come across are pathetic and above 6K of mem!
    So for those serious here is some flexible and easy to use code.
    Drowning in comments ;-) It's extremely efficient on memory (1040)
    bytes! I  can write it in pascal using 550 bytes put then I decided
    to make it user friendly to a degree ;-) Shout if you need to know
    more info on tsr writing eg. making it be polite to dos etc ;-))
    }

    {$A-}{$R-}{$S-}{$D-}{$F-}{$L-}{$Q-}{$T-}{$V-}{$X-}{$Y-}{$G+}
    {$B-}{$N-}{$P-}
    {$M 1024,0,0}
    (* Ulti-Tsr-Demo-Proggie Coded: Matthew Tagg Jan '95                    *)

    (* The beauty of this is that your init code, eg paramter parsing etc.  *)
    (* does NOT effect the size in memory! Unlike crappy BP's attemp at a   *)
    (* tsr! Another beautiful thing is that for you who hate the technical  *)
    (* stuff can let the program work out what to keep in memory!           *)
    (* USES *)                          (* There is no USES, so don't       *)
                                        (* use units, they suck. Use include*)
                                        (* files if you want but units      *)
                                        (* create new segments AARG         *)
                                        (* NOT for tsr's!                   *)
    Const
       CharSEG  = $B800;                (* $B800 = COLOUR or $B000 for Mono *)
       DSegSize = 128;                  (* Data Segment Size                *)
       SSegSize = 256;                  (* Stack Segmetn Size               *)
       SSize    = SSegSize-16;          (* This is the value of the Stack   *)
                                        (* pointer (sp) and bp              *)
       DSegOff  = 2;                    (* This is added to the value copied*)
                                        (* from cs and written to ds ie DS  *)
                                        (* points to 32 bytes ahead of CS   *)
                                        (* I do this so that that pointers  *)
                                        (* Are not overriden                *)
       DatOffs  = DSegOff*16;           (* Offset relocation number         *)
                                        (* Use this to reference your data  *)
                                        (* ie. say you want to move the var *)
                                        (* NUM int the ax >                 *)
                                        (*   mov ax, CS:datoffs+NUM         *)
                                        (*           ^^^ Must use segment   *)
                                        (* override! OR easier to set       *)
                                        (*  DS = CS+DSegoff   default=2     *)
                                        (* When in a pascal routine you can *)
                                        (* reference it normally            *)

       CodeOffs = 16;                   (* Were OUR Code/Data starts, first *)
                                        (* 16 bytes of the int09 proc are   *)
                                        (* used for pushing stuff but we    *)
                                        (* don't need that crap!            *)

                                        (* PS Typed Constants use up memory *)
                                        (* They just another name for       *)
                                        (* initialised data.                *)
                                        (* Untyped are the same as EQU in   *)
                                        (* asm.  Untyped = No memory        *)

       PSize = 8;                       (* The amount of bytes used by the  *)
                                        (* Pointers                         *)
       NewSSegLoc = (CodeOffs+PSize+DsegSize+16) div 16;
                                        (* This says were the stack must    *)
                                        (* start (+16 so no code is over-   *)
                                        (* ridden)                          *)
    Var
    (* VARIABLES TO BE USED IN THE ACTUAL TSR                               *)
       Bob            : Byte;           (* Just test variables              *)
       Obo            : Word;           (* Used by the i.s.r (you can use   *)
                                        (* your own)      `                 *)

       EndData        : Word;           (* Insert all data to be saved,     *)
                                        (* ie data use in the i.s.r,        *)
                                        (* BEFORE this statement all init   *)
                                        (* data can come after  Saves Mem!  *)

    (* VARIABLES TO BE USED IN THE INIT PART                                *)
       ProgSize       : Word;           (* Memory required in 16 byte       *)
                                        (* Paragraphs                       *)

       ThisDoes       : Byte;           (* Eg....                           *)
       NotGetSaved    : Char;
       ButCanBe       : Pointer;
       UsedInThe      : Longint;
       InitCode       : PChar;

       LastVar        : Word;           (* WARNING DO NOT CHANGE THIS       *)
                                        (* Do Not Insert Any Variable After *)
    {$F+}
    Procedure Int09; Interrupt; Assembler;
    Asm
       Dw 0,0                              (* Pointers 4*2 bytes = 8     *)
       Dw 0,0
    (* Data Seg (8*16=128bytes Not Bad) *) (* Bp7 Chews up the first 80  *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  (* bytes for whatever AAARG   *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  (* Change the size according  *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  (* to the amount of data your *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  (* prog uses                  *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    (* Stack Seg (8*16=128*)            (* Temp Stack                 *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 (* You can make the stack size    *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 (* whatever you want, but remember*)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 (* to change the const SSize,     *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 (* Default=256                    *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    (* Stack Seg (8*16+8*16=256) *)     (* Temp Stack                       *)
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
       Db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

       Nop                              (* Used for to ensure safety        *)
       Sti                              (* Interupts allowed                *)

       Pushf                            (* Pushf simulates and interrupt    *)
       Call Dword Ptr CS:[CodeOffs]     (* Calls the saved INT8             *)

       Inc   CS:DatOffs+Bob             (* Has a second passed? If not exit *)
       Cmp   CS:DatOffs+Bob,18          (* else call our interrupt WRT      *)
       Jne @Finnish

       Mov   Cs:DatOffs+Bob,0           (* Rests it for the next time       *)
       Inc   Cs:DatOffs+Obo             (* Obo is the number we write to the*)
                                        (* screen.                          *)
       Pushf
       Call Dword Ptr Far [CS:Codeoffs+4]; (* Call our routine              *)
       Sti
    @Finnish:
       iret
    End;

    (* You can delete this procedure (for demo purposes only)               *)
    Procedure PWord(Num,Pos,Base:Word); (* Proc. to write a number in any   *)
                                        (* base                             *)
    Const
       AlphaNum : Array[0..35] of Byte =

    (48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
    81,82,83,84,85,86,87,88,89,90);Begin   Asm
          Push  CharSEG                 (* Set ES to our text segment addr  *)
          Pop   Es                      (* Text Graphics segment            *)
          Mov   Ax, Num                 (* Ax to be divided                 *)
       @l1:
          Xor   Dx, Dx                  (* Clear                            *)
          Div   Base                    (* Dx = Remainder, Ax = Quotient    *)
          Cmp   Dx,0                    (* Remainder                        *)
          Jnz   @l2                     (* Finnished?                       *)
          Cmp   Ax,0                    (* Quotient                         *)
          Jz    @Fin
       @l2:
          Mov   Si, Dx
          Mov   Di, Pos                 (* Load offs                        *)
          Mov   Dl, Byte Ptr [AlphaNum+Si]
          Mov   [Es:Di], Dl
          Sub   Pos,2                   (* Inc bx by 2                      *)
          Jmp   @l1
    @Fin:
          Pop   Pos                     (* Maintain stack                   *)
       End;
    End;

    Procedure Wrt;Interrupt; (* This Is Our Interrupt Service Routine       *)
    Begin
       Asm
          Mov   Ax, Cs                  (* ALWAYS include these three       *)
          Add   Ax, DSegOff             (* instructions if you want to use  *)
          Mov   Ds, Ax                  (* your pascal declared variables.  *)
       End;
       (* DO WHAT YOU WANT HERE                                             *)
       PWord(Obo,158,10);               (* Write a number in the top left   *)
                                        (* hand column, demo purposes only! *)
    End;
    {$F-}{ <-----------------------------
                                        |                                   }
    (* Init Procedures follow, note the {$f-} means these are now local     *)
    (* BTW if you make your own init procedures make sure you place them    *)
    (* after the Getvec or you can place them before the getvec but then    *)
    (* change the line further down that needs the name of the first init   *)
    (* procedure to your own name (currently the first init proc is GetVec  *)

    Procedure GetVec(VecNo :Word; Var SavPoint :Pointer); (* DOS Sucks      *)
    Var
       SavSeg, SavOff :Word;            (* Temp variables for pointer       *)
    Begin
       Asm
          Push  Es                      (* Save Es                          *)
          Shl   VecNo, 2                (* Multiply num by 4 to get address *)
          Mov   Es, Word Ptr 0h         (* Zero Es. Vect Int's start at 0:0 *)
          Mov   Di, VecNo               (* Di = Num * 4                     *)
          Mov   Ax, Word Ptr [Es:Di]    (* Copy offset word of int,         *)
          Mov   SavOff, Ax              (* and save it                      *)
          Add   Di, 2                   (* Point to next word (segment)     *)
          Mov   Ax, Word Ptr [Es:Di]    (* Ax = Offset                      *)
          Mov   SavSeg, Ax              (* Save in temporary variable       *)
          Pop   Es                      (* Retrieved stored value           *)
       End;
       SavPoint := Ptr(SavSeg, SavOff); (* Convert Seg:Offset to pointer    *)
    End;

    Procedure SetVec(VecNo :Word; NewPoint :Pointer);  (* Don't use units   *)
    Type                                (* Revectors the interrupts         *)
       PType          = Array[0..1] of Word;
    Var
       NtPoint        : ^PType;
    Begin
       Asm Cli End;                     (* No interrupts can be generated   *)
       NtPoint := @NewPoint;            (* during the process               *)
       MemW[0:VecNo*4] := NtPoint^[0];
       MemW[0:VecNo*4+2] := NtPoint^[1];
       Asm Sti End;                     (* Enable Interrupts                *)
    End;

    Begin
       If (Ofs(Int09) <> 0) Then Halt;  (* Used to ensure the proc is       *)
                                        (* included                         *)
                                        (* If pascal doesn't see a reference*)
                                        (* to a proc. or var. it excludes   *)
                                        (* it!                              *)

       EndData := Ofs(EndData);         (* Basicly finds the size of the    *)
                                        (* DS to be kept in memory          *)
       GetVec($8, Pointer(MemL[Cseg:CodeOffs]));
                                        (* Vector 8 is the timer interrupt  *)
                                        (* generated every 18.2 times a sec *)
       SetVec($8, Ptr(Cseg, CodeOffs+PSize+DSegSize+SSegSize));
       (*                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            *)
                                        (* This is where the CODE actually  *)
                                        (* starts in the code segment       *)
       MemW[Cseg:Codeoffs+4] := Ofs( WRT );
       MemW[Cseg:Codeoffs+6] := Seg( WRt );
       (*           -----------------^^^                                    *)
       (* Substitute your own i.s.r routine name over here, if you want     *)

       (* This next stuff copies the data we defined and places it in       *)
       (* our new data segment                                              *)
       Asm
          Mov   Ax, Cs                  (* Seeing as you can't say          *)
          Add   Ax, DSegOff             (* Mov Es, Cs ..this is a way round *)
          Mov   Es, Ax                  (* Inc Ax, so no code overriden ;)  *)
          Xor   Di, Di                  (* Di = 0                           *)
          Xor   Si, Si                  (* Si = 0                           *)
          Mov   Cx, EndData             (* # of bytes to copy               *)
          Rep   Movsb                   (* ... and copy it                  *)
       End;

       (* What I am actually doing is having all three segments in the code *)
       (* segment, risky if you don't be careful but worth the space (g)    *)
       Asm
          Mov   Ax, Cs                  (* Get the current Code Seg         *)
          Add   Ax, NewSSegLoc          (* Add the New Stack Segment Locat  *)
          Mov   Ss, Ax                  (* Adjust SS                        *)
          Mov   Sp, SSize               (* The stack pointer, is SSegSize-16*)
          Mov   Bp, SSize               (*   (-16) to allow for segment     *)
                                        (* alignment.                       *)
          Push  Bp
       End;

       (* This allocates the amount of memory to be used in 16 byte         *)
       (* paragraphs. The variable progsize is the memory used by our prog. *)
       (* @GetVec is the FIRST of the init procdures so it gets that address*)
       (* and uses it as the size of our code, it adds 256 because of the   *)
       (* PSP (Program Segment Prefix) and then divides by 16 to get        *)
       (* paragraphs and adds on 1 more to to be safe.                      *)
       ProgSize := (Ofs(GetVec)+256) div 16 + 1;
       Asm                              (* Uses dos int 31.. *KEEP*         *)
          Mov   Dx, ProgSize
          Mov   Al, 0                   (* Return code ei ERRORLEVEL        *)
          Mov   Ah, 31h                 (* Dos Func 31h                     *)
          Int   21h
       End;
    End.

[Back to TSR SWAG index] [Back to Main SWAG index] [Original]