home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / FILMOV.ZIP / FILMOV.PAS
Encoding:
Pascal/Delphi Source File  |  1986-02-03  |  5.1 KB  |  100 lines
  1. (* ======================================================================== *)
  2. (*  A L T E R N A T I V E S   T O   "M O V E"   A N D   "F I L L C H A R"   *)
  3. (*                                                                          *)
  4. (*      The routines in this file supplement the MOVE and FILLCHAR standard *)
  5. (*  procedures.  Here is a chart of comparative timings.  Times are in      *)
  6. (*  seconds for 100 repetitions of an operation on 4000 bytes.              *)
  7. (*                                                                          *)
  8. (*    MEMORY to MEMORY   to SCREEN                                          *)
  9. (*    ============================                                          *)
  10. (*    MOVEITER: 39       39      MOVE iteratively -- one byte after another *)
  11. (*    FILLITER: 28       28      FILL iteratively -- one byte after another *)
  12. (*    MOVE    :  1.53     1.98   Built-in to TURBO                          *)
  13. (*    FILLCHAR:  0.88     1.37   Built-in to TURBO                          *)
  14. (*    MOVEWORD:  1.16     1.65   MOVE a whole word (2 bytes) at a time      *)
  15. (*    FILLWORD:  0.60     1.15   FILL a whole word (2 bytes) at a time      *)
  16. (*    MOVEOTHR:  2.80     3.08   MOVE every other byte                      *)
  17. (*    FILLOTHR:  2.20     2.30   FILL every other byte                      *)
  18. (*                                                                          *)
  19. (*  Note that if the total number of bytes is EVEN, MOVEWORD and FILLWORD   *)
  20. (*  can be used to some speed advantage.  Also, they are handy for video    *)
  21. (*  memory, since each character/attribute pair takes one word.             *)
  22. (*      MOVEITER and FILLITER are just included for comparison -- there's   *)
  23. (*  no point in _using_ them!                                               *)
  24. (*      MOVEOTHR and FILLOTHR act on every other byte.  Again, these are    *)
  25. (*  handy for video memory.  How about rapidly FILLing a new attribute but  *)
  26. (*  leaving all the characters the same?                                    *)
  27. (*                                                                          *)
  28. (*      MOVEWORD and FILLWORD originated in messages on BIX, the Byte Info  *)
  29. (*  eXchange, run by Byte magazine.                                         *)
  30. (* ======================================================================== *)
  31.  
  32. procedure MoveIter(VAR Source, Dest; Count : integer);
  33. VAR
  34.   N : integer;
  35. BEGIN
  36.   FOR N := 0 to Count-1 DO
  37.     MEM[Seg(Dest):Ofs(Dest)+N] := Mem[Seg(Source):Ofs(Source)+N];
  38. END;
  39.  
  40. procedure FillIter(VAR Dest; Count : integer; FillVal : byte);
  41. VAR
  42.   N : integer;
  43. BEGIN
  44.   FOR N := 0 to Count-1 DO
  45.     MEM[Seg(Dest):Ofs(Dest)+N] := FillVal;
  46. END;
  47.  
  48. Procedure FillWord ( VAR Dest; Count,FilVal : integer);
  49. Begin Inline(
  50.              $1E/               {push DS              }
  51.              $C4/$BE/Dest/      {les   di,memr[bp]    }
  52.              $8B/$46/<FilVal/   {mov   ax,FilVal[bp]  }
  53.              $8B/$4E/<count/    {mov   cx,count[bp]   }
  54.              $FC/               {cld  ;forward dir    }
  55.              $F3/$AB/           {rep   stosw          }
  56.              $1F);              {pop ds               }
  57. End;
  58.  
  59.  
  60. Procedure MoveWord(VAR Source,Dest;Count:integer);
  61. Begin Inline($1E/              {push DS              }
  62.              $C4/$7E/<dest/    {les   di,dest[bp]    }
  63.              $C5/$76/<source/  {lds   si,source[bp]  }
  64.              $8B/$4E/<count/   {mov   cx,count[bp]   }
  65.              $FC/              {cld                  }
  66.              $F3/$A5/          {rep movsw            }
  67.              $1F);             {pop ds               }
  68. end;
  69.  
  70. Procedure FillOthr ( VAR Dest; Count : integer; FilVal : byte);
  71. Begin Inline(
  72.              $1E/              {push DS              }
  73.              $C4/$BE/Dest/     {les   di,memr[bp]    }
  74.              $8A/$66/<FilVal/  {mov   ah,FilVal[bp]    }
  75.              $8B/$4E/<count/   {mov   cx,count[bp]  }
  76.              $31/$DB/          {XOR     BX,BX        }
  77. {loupe}      $26/              {SEG ES               }
  78.              $88/$21/          {MOV     [BX+DI],AH   }
  79.              $43/              {INC     BX           }
  80.              $43/              {INC     BX           }
  81.              $E2/$F9/          {LOOP looop           }
  82.              $1F);             {pop ds               }
  83. End;
  84.  
  85. Procedure MoveOthr(VAR Source,Dest;Count:integer);
  86. Begin Inline($1E/              {push DS              }
  87.              $C4/$7E/<dest/    {les   di,dest[bp]    }
  88.              $C5/$76/<source/  {lds   si,source[bp]  }
  89.              $8B/$4E/<count/   {mov   cx,count[bp]   }
  90.              $31/$DB/          {XOR     BX,BX        }
  91. {looop}
  92.              $8A/$20/          {MOV     AH,[BX+SI]   }
  93.              $26/              {SEG ES               }
  94.              $88/$21/          {MOV     [BX+DI],AH   }
  95.              $43/              {INC     BX           }
  96.              $43/              {INC     BX           }
  97.              $E2/$F7/          {LOOP looop           }
  98.              $1F);             {pop ds               }
  99. end;
  100.