home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / PROCPARM.ZIP / PROCPARM.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1986-09-05  |  8.2 KB  |  257 lines
  1. { ProcParm              Version 2.2A  86/05/27
  2.  
  3.  Author: Mike Babulic    Compuserve ID: 72307,314   FIDO: 134/1
  4.          3827 Charleswood Dr. N.W.
  5.          Calgary, Alberta,
  6.          CANADA
  7.          T2L 2C7
  8.  
  9.  One of the weaknesses of TURBO Pascal is that procedures and functions
  10.  cannot be passed as parameters. The "ProcParm" files are meant to
  11.  overcome this limitation.
  12.  
  13.  There are 6 files:  1) ProcParm.PAS  -  documentation with example program
  14.                      2) ProcParm.INC  -  contains the call_ProcParm procedure
  15.                      3) ProcParm.QK   -  Inline code to be used instead of
  16.                                          the call_ProcParm procedure.
  17.                                          Quicker execution, but larger programs.
  18.                      4) ProcParm.BIN  -  the third (and best) alternative, an
  19.                                          externally assembled binary file.
  20.                                          -  Fastest execution due to less stack
  21.                                             manipulation.
  22.                                          -  Least code added to the program
  23.                                             (12 bytes!).
  24.                      5) ProcParm.P    - this is the "glue" that you $Include
  25.                                         in a program so it can use ProcParm.BIN.
  26.                      6) ProcParm.ASM  - the source code for ProcParm.BIN
  27.  
  28.  The call_ProcParm procedure
  29.  ---------------------------
  30.  
  31.  When this procedure is called by a procedure or function, it will cause a
  32.  "short" jump to the procedure whose offset is the last parameter (of the
  33.  calling procedure). This is done by swapping the last parameter (a procedure
  34.  pointer) and the return address of the calling routine on the stack.
  35.  
  36.  Using ProcParm, procedures can be passed as parameters to other procedures.
  37.  This is accomplished by defining a dummy procedure (or function) with exactly
  38.  the same arguments as the procedure to be passed EXCEPT that a final added
  39.  parameter of type Integer is also defined. When the calling procedure calls
  40.  the dummy procedure, it passes the offset of the procedure to be executed in
  41.  this last parameter (most often by using the Ofs function).
  42.  
  43.  ProcParm will "return" to the routine specified by the last parameter of the
  44.  dummy and THE STACK WILL LOOK EXACTLY THE SAME AS IF THE "returned to"
  45.  PROCEDURE HAD BEEN CALLED BY THE PROCEDURE THAT CALLED THE DUMMY!
  46.  
  47.  ProcParm.QK -- the Inline code
  48.  ------------------------------
  49.  
  50.  The ProcParm.QK file can be "included" in your dummy procedure instead of
  51.  calling the ProcParm procedure. This will speed up a program because several
  52.  fewer 8088 instructions will be executed to "jump" to the passed procedure.
  53.  However, be aware that the cost of this speed is a larger program!
  54.  
  55.  The ProcPtr type will not be declared if you use ProcParm.QK, so use Integer
  56.  instead.
  57.  
  58. ProcParm.BIN  and  ProcParm.P
  59. -----------------------------
  60.  
  61. The ProcParm.P file is "included" in your program to allow it to use the
  62. contents of ProcParm.BIN file. As in the previous two methods, a dummy
  63. procedure is created with the procedure to be "run" as the last parameter. This
  64. is where the similarity ends.
  65.  
  66. As well as allowing you to call procedures and functions in the body of your
  67. TURBO program (NEAR calls), ProcParm.P also allows you to call (FAR) procedures
  68. and functions which lie OUTSIDE the body of the program. This program gives the
  69. example of a procedure stored in a typed constant (FarDummy). Admittedly it is
  70. a very simple procedure, just the 8086 instruction "RETF", but more complex
  71. procedures could be read into an array variable (or into the heap?) and be run
  72. just as easily.
  73.  
  74. You can also make a FAR call with an offset. This is useful if you have set
  75. aside an area of storage for a group of procedures or functions. The method
  76. used is quite a bit slower than the standard FAR call. If speed is important
  77. you should save the address of each procedure in a variable, and use the
  78. regular FAR call. I have included a function to make life easier for you.
  79.  
  80. }
  81.  
  82. {-------------- The procedures to be passed as Parameters --------------}
  83.  
  84. procedure first(a,b:integer);
  85.   begin
  86.     writeln('     FIRST ',a:3,b:3);
  87.   end;
  88.  
  89. procedure second(a,b:integer);
  90.   begin
  91.     writeln('    ',a:3,' SECOND',b:3);
  92.   end;
  93.  
  94. {-------------------- Use of the ProcParm procedure --------------------}
  95.  
  96. {$i procparm.inc}   { Include the call_ProcParm procedure's definition}
  97.  
  98. procedure dummy(a,b:integer; p:integer {ProcPtr});
  99.   begin
  100.     call_ProcParm;
  101.   end;
  102.  
  103. procedure OneTwo(p:integer {ProcPtr});
  104.   begin
  105.    dummy(9,10,p);
  106.   end;
  107.  
  108. {----------------------- Use of ProcParm.QK -----------------------------}
  109.  
  110. procedure fasterDummy(a,b:integer; p:Integer {ProcPtr});
  111.   begin
  112.     {$I procparm.qk}
  113.   end;
  114.  
  115. procedure QuickStep(p:integer {ProcPtr});
  116.   begin
  117.     FasterDummy(20,30,p);
  118.   end;
  119.  
  120. {-------------------- Use of the EXTERNAL procedure --------------------}
  121.  
  122. {$i procparm.p}     { Include the external procedure's definition}
  123.  
  124. procedure ExternalDummy(a,b:integer; p:ProcPtr); external ProcParm[near];
  125.  
  126. procedure Zoom(p:ProcPtr);
  127.   begin
  128.    ExternalDummy(49,50,p);
  129.   end;
  130.  
  131. {------------------------------- Timer -----------------------------------}
  132.  
  133. TYPE TimeType = record
  134.        case boolean of
  135.         False: (ffss,mmhh: integer);
  136.         True:  (frac,sec,min,hour: byte)
  137.        end;
  138.  
  139. VAR
  140.   REGS: record AX,BX,CX,DX,BP,SI,DI,DS,ES,FLAGS: integer end;
  141.   oldTime, theTime: TimeType;
  142.  
  143. procedure Timer;
  144.   begin
  145.     OldTime := TheTime;
  146.     with REGS do begin
  147.       AX := $2C00;
  148.       MsDos(REGS);
  149.       with TheTime do begin
  150.         mmhh := CX;
  151.         ffss := DX;
  152.       end;
  153.     end;
  154.   end;
  155.  
  156. function TimeInSec(t:TimeType):real;
  157.   begin
  158.     with t do TimeInSec := frac/100.0 + sec + 60*(min + 60*hour);
  159.   end;
  160.  
  161. function ElapsedTime: real;
  162. { returns elapsed time in seconds }
  163.   begin
  164.     ElapsedTime := TimeInSec(theTime)-TimeInSec(OldTime);
  165.   end;
  166.  
  167. {------------------------- Timing Procedures -----------------------------}
  168.  
  169. procedure theDummy;
  170.   begin
  171.   end;
  172.  
  173. Const farDummy: integer = $CBCB;   { RETF  ;RETurn Far }
  174.  
  175. procedure Speed1(p:ProcPtr);
  176.   begin
  177.     call_ProcParm;
  178.   end;
  179.  
  180. procedure Speed2(p:ProcPtr);
  181.   begin
  182.     {$i ProcParm.QK}
  183.   end;
  184.  
  185. procedure Speed3(p:ProcPtr); EXTERNAL ProcParm[NEAR];
  186.  
  187. procedure Speed4(p:FarProcPtr); EXTERNAL ProcParm[FAR];
  188.  
  189. procedure Speed5;
  190.   begin
  191.     OffsetProc(ADDR(farDummy),1);
  192.   end;
  193.  
  194. {-------------------------- Run the Examples -----------------------------}
  195.  
  196. const TimeLoop = MaxInt;
  197.  
  198. var
  199.   i: integer;
  200.   s0,s1,s2,s3,s4,s5: real;   { elapsed time from each timing loop }
  201.  
  202. begin
  203.  
  204.   Writeln;
  205.   Writeln('Using call_ProcParm Routine ....');
  206.   OneTwo(Ofs(First));
  207.   OneTwo(Ofs(Second));
  208.  
  209.   Writeln;
  210.   Writeln('Using Inline Code Dummy ....');
  211.   QuickStep(Ofs(First));
  212.   QuickStep(Ofs(Second));
  213.  
  214.   Writeln;
  215.   Writeln('Using External Code Dummy ....');
  216.   Zoom(Ofs(First));
  217.   Zoom(Ofs(Second));
  218.  
  219.   Writeln;
  220.   Writeln('Now running speed test');
  221.   Timer;
  222.   for i := 1 to TimeLoop do theDummy;
  223.   Timer;
  224.   s0 := elapsedTime;
  225.   Writeln('  Ordinary Call = ',elapsedTime:3:2,' seconds');
  226.   Timer;
  227.   for i := 1 to TimeLoop do Speed1(Ofs(theDummy));
  228.   Timer;
  229.   s1 := elapsedTime;
  230.   Writeln('  call_ProcPtr  = ',elapsedTime:3:2,' seconds');
  231.   Timer;
  232.   for i := 1 to TimeLoop do Speed2(Ofs(theDummy));
  233.   Timer;
  234.   s2 := elapsedTime;
  235.   Writeln('  Inline code   = ',elapsedTime:3:2,' seconds');
  236.   Timer;
  237.   for i := 1 to TimeLoop do Speed3(Ofs(theDummy));
  238.   Timer;
  239.   s3 := elapsedTime;
  240.   Writeln('  External NEAR = ',elapsedTime:3:2,' seconds');
  241.   Timer;
  242.   for i := 1 to TimeLoop do Speed4(ADDR(farDummy));
  243.   Timer;
  244.   s4 := elapsedTime;
  245.   Writeln('  External FAR  = ',elapsedTime:3:2,' seconds');
  246.   Timer;
  247.   for i := 1 to TimeLoop do Speed5;
  248.   Timer;
  249.   s5 := elapsedTime;
  250.   Writeln('  Offset   FAR  = ',elapsedTime:3:2,' seconds');
  251.  
  252.   writeln;
  253.   writeln('Relative Speeds : Ordinary: call_.. :  Inline :    NEAR :     FAR :  FARofs :');
  254.   writeln('                :',s0/s0:8:3,' :',s0/s1:8:3,' :',s0/s2:8:3,' :'
  255.                             ,s0/s3:8:3,' :',s0/s4:8:3,' :',s0/s5:8:3,' :');
  256. end.
  257.