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

    {
       There was a discussion about  how to trap  floating point errors
    in  TP.  Here  is  the   solution that traps   any kind of run-time
    errors.  The idea is not mine. I saw it in a russian  book about TP
    and OOP.

       The idea is quite simple.  Instead of trying to trap all kind of
    errors, we  can let TP to do  the job for  us.   Whenever  TP stops
    execution of the  program ( because   of a run  time  error or just
    because  the program  stops in a  natural  way )  it   executes the
    default procedure of exit : ExitProc.  Then TP checks the status of
    two variables from  the SYSTEM unit  : ErrorAddr and  ExitCode.  If
    there was a run  time error then ErrorAddr  is not NIL and ExitCode
    containes the run time error code. Otherwise ExitCode containes the
    errorlevel  that  will be    set  for  DOS and  ErrorAddr  is  NIL.
    Fortunatly  we can easily  redefine   the  ExitProc,   and  thus to
    overtake the control from TP. The problem is that we got to be able
    to get back or to jump to any point  of the program  ( even to jump
    inside a procedure / function). The author of the book claimed that
    he took his routines from Turbo Professional.

       Well, there are two files you are gonna need. Save the first one
    as JUMP.PAS Compile it as a unit. The second one is a short program
    that shows  how to use  it. It  asks for   two numbers, divides the
    first  by the second and takes  a  natural logarithm of the result.
    Try to divide by zero, logarithm of a negative number. Try entering
    letters instead of numbers and see how the program recovers.

       The trapping   works  fine under Windows/Dos.   To  run  it with
    WINDOWS recompile the JUMP unit for Windows target. Then add WinCrt
    to the Uses statement and remove Mark/Release lines ( because there
    is no Mark/Release for Windows ).
    }

    Unit Jump;
    Interface
    Type JumpRecord = Record
                            SpReg,
                            BpReg  : Word;
                            JmpPt  : Pointer;
                      end;

    Procedure SetJump ( Var JumpDest : JumpRecord );
    {Storing SP,BP and the address}
    inline(
           $5F/                   {pop di           }
           $07/                   {pop es           }
           $26/$89/$25/           {mov es:[di],sp   }
           $26/$89/$6D/$02/       {mov es:[di+2],bp }
           $E8/$00/$00/           {call null        }
                                  {null:            }
           $58/                   {pop ax           }
           $05/$0C/$00/           {add ax,12        }
           $26/$89/$45/$04/       {mov es:[di+4],ax }
           $26/$8C/$4D/$06);      {mov es:[di+6],cs }
                                  {next:            }

    Procedure LongJump ( Var JumpDest : JumpRecord );
    {Restore everything and jump}
    inline(
           $5F/                   {pop di           }
           $07/                   {pop es           }
           $26/$8B/$25/           {mov sp,es:[di]   }
           $26/$8B/$6D/$02/       {mov bp,es:[di+2] }
           $26/$FF/$6D/$04);      {jmp far es:[di+4]}

    Implementation
    End.

    ------------------------------try.pas------------------------------

    Program Try;
    Uses Jump;                                 {Uses Jump,WinCrt;}
    Var
       OldExit : Pointer;
       MyAddr  : JumpRecord;
       MyHeap  : Pointer;

       a1,a2,
       a3,a4   : real;

    {$F+}
    Procedure MyExit;
    {You can add your error handler here}
    Begin
         If ErrorAddr<>Nil Then Begin
            case ExitCode of
                 106 : Writeln('Invalid numeric format');
                 200 : Writeln('Division by zero');
                 205 : Writeln('Floating point overflow');
                 206 : Writeln('Floating point underflow');
                 207 : Writeln('Invalid floating point  operation');
                 else  Writeln('Hmmm... How did you do that ?');
            end;
            ErrorAddr:=Nil;
            LongJump(MyAddr);
         end;
         ExitProc:=OldExit;
    End;
    {$F-}

    Begin
         OldExit:=ExitProc;
         Mark(MyHeap);        {Just an example of how to restore the heap }
                              {Actually we don't have to do that in       }
                              {this program, because we dont use heap     }
                              {at all. But anyway here it goes            }
                              {Don't forget to remove when compiling this }
                              {for Windows                                       }

         SetJump(MyAddr);     {We'll get back here whenever a run time    }
                              {error occurs                               }
                              {This line should always be before          }
                              {     ExitProc:=MyExit;                     }
                              {Don't ask me why... It's much easier for me}
                              {to follow the rule then to understand it :)}
         ExitProc:=@MyExit;

         Release(MyHeap);      {restoring the heap after a run time error }
                               {Remove this if you are compiling it for   }
                               {Windows                                   }

                               {Try entering whatever you want at the     }
                               {prompt. It should trap every runtime error}
                               {you could possibly get.                   }
         Repeat
               Writeln;
               Write('Enter a number a1=');
               Readln(a1);
               Write('Enter a number a2=');
               Readln(a2);
               a3:=a1/a2;
               Writeln('a1/a2=',a3:10:5);
               a4:=ln(a3);
               Writeln('ln(a1/a2)=',a4:10:5);
         until a3=1;
    end.

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