home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / QWIK13.ZIP / QWRITES.INC < prev   
Encoding:
Text File  |  1986-11-10  |  14.6 KB  |  227 lines
  1. { Qwrites - QwriteV, Qwrite, QwriteC, QwriteCV              ver 1.3, 11-10-86 }
  2. { These four procedures do fast screen writes and automatically configure to
  3.   your machine for Mono, CGA, and EGA.  They also has the feature of leaving
  4.   the attribute alone by setting Attr<0; then they will just overwrite the
  5.   display using the current attributes.  The upper left column is 1,1.
  6.   You MUST read MODIFICATIONS in QWIK13.DOC for any changes in this file!     }
  7.  
  8.  
  9. type Str80 = string[80];
  10.  
  11. { QwriteV - Quick screen write, untyped VAR parameter       ver 1.3, 11-10-86 }
  12. procedure QwriteV (Row, Col: byte; Attr: integer; VAR St);
  13. begin
  14. Inline(
  15.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  16.   /$C5/$76/<ST           {       LDS   SI,[BP+<St]      ;Place offset in SI}
  17.   /$FC                   {       CLD                    ;Set DF to increment}
  18.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  19.   /$31/$C9               {       XOR   CX,CX            ;Set CX=0}
  20.   /$8E/$C1               {       MOV   ES,CX            ;Set ES=0}
  21.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  22.   /$74/$0F               {       JZ    Exit1            ;Null string}
  23.   /$8A/$76/<ROW          {       MOV   DH,[BP+<Row]     ;Move row (Row*256)}
  24.   /$8B/$7E/<COL          {       MOV   DI,[BP+<Col]     ;Move col}
  25.   /$4F                   {       DEC   DI               ;Convert to 0-79 range}
  26.   /$D1/$E7               {       SHL   DI,1             ;Mult by 2}
  27.   /$8B/$5E/<ATTR         {       MOV   BX,[BP+<Attr]    ;Move attr}
  28.   /$E8/$47/$00           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  29.                          {                              ; is pre-compiled!}
  30.   /$1F                   {Exit1: POP   DS               ;Restore Turbo's DS}
  31. );
  32. end;
  33.  
  34. { Qwrite - Quick screen write, value parameter              ver 1.3, 11-10-86 }
  35. procedure Qwrite (Row, Col: byte; Attr: integer; St: Str80);
  36. begin
  37. Inline(
  38.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  39.   /$8D/$B6/>ST           {       LEA   SI,[BP+>St]      ;Place offset in SI}
  40.   /$8C/$D2               {       MOV   DX,SS            ;Move SS into DS for}
  41.   /$8E/$DA               {       MOV   DS,DX            ;  use by LODS}
  42.   /$FC                   {       CLD                    ;Set DF to increment}
  43.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  44.   /$31/$C9               {       XOR   CX,CX            ;Set CX=0}
  45.   /$8E/$C1               {       MOV   ES,CX            ;Set ES=0}
  46.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  47.   /$74/$12               {       JZ    Exit2            ;Null string}
  48.   /$8A/$B6/>ROW          {       MOV   DH,[BP+>Row]     ;Move row (Row*256)}
  49.   /$8B/$BE/>COL          {       MOV   DI,[BP+>Col]     ;Move col}
  50.   /$4F                   {       DEC   DI               ;Convert to 0-79 range}
  51.   /$D1/$E7               {       SHL   DI,1             ;Mult by 2}
  52.   /$8B/$9E/>ATTR         {       MOV   BX,[BP+>Attr]    ;Move attr}
  53.   /$E8/$11/$00           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  54.                          {                              ; is pre-compiled!}
  55.   /$1F                   {Exit2: POP   DS               ;Restore Turbo's DS}
  56. );
  57. end;
  58.  
  59. { QwritesDisp - Subroutine for all QwriteXX procedures      ver 1.3, 11-10-86 }
  60. procedure QwritesDisp;
  61. begin
  62. Inline(
  63.    $88/$EA               {Qdisp: MOV   DL,CH            ;Set DL=0}
  64.   /$D1/$EA               {       SHR   DX,1             ;(Row*128)}
  65.   /$01/$D7               {       ADD   DI,DX            ;Add (Row*128) in DI}
  66.   /$D1/$EA               {       SHR   DX,1             ;(Row*64)}
  67.   /$D1/$EA               {       SHR   DX,1             ;(Row*32)}
  68.   /$01/$D7               {       ADD   DI,DX            ;Dest offset in DI}
  69.   /$88/$E0               {       MOV   AL,AH            ;Move St[1] to AL}
  70.   /$26/$80/$3E/$49/$04/$07{      ES: CMP BY[$0449],$07  ;Check video mode}
  71.   /$75/$39               {       JNE   Color            ;  use Color routine}
  72.                          {                              ;}
  73.   /$BA/$F6/$AF           {       MOV   DX,$AFF6         ;Addr for Mono}
  74.   /$8E/$C2               {       MOV   ES,DX            ;ES:DI dest pointer}
  75.   /$84/$FF               {EGA:   TEST  BH,BH            ;If Attr<0 ...}
  76.   /$78/$18               {       JS    Mono1            ;  use char only}
  77.                          {                              ;}
  78.                          {; -- Mono routine; Attr, Char and No Wait--}
  79.   /$88/$DC               {       MOV   AH,BL            ;Copy attr to AH}
  80.   /$41                   {Mono2: INC   CX               ;Bump CX for odd char}
  81.   /$D1/$E9               {       SHR   CX,1             ;Divide counter by 2}
  82.                          {                              ; CF=0 if odd length}
  83.   /$EB/$08               {       JMP   SHORT Mon2b      ;Jump into mono loop}
  84.                          {                              ;}
  85.   /$AD                   {Mon2a: LODSW                  ;Load TWO char}
  86.   /$88/$E7               {       MOV   BH,AH            ;Move Ch2 to BH}
  87.   /$88/$DC               {       MOV   AH,BL            ;Copy attr to AH}
  88.   /$AB                   {       STOSW                  ;To dest & inc DI 2}
  89.   /$88/$F8               {       MOV   AL,BH            ;Move Ch2 to AL}
  90.   /$AB                   {Mon2b: STOSW                  ;To dest & inc DI 2}
  91.   /$E2/$F5               {       LOOP  Mon2a            ;Loop until CX=0}
  92.   /$73/$7C               {       JNC   Done             ;Exit if odd length}
  93.   /$AC                   {       LODSB                  ;Load last char}
  94.   /$AB                   {       STOSW                  ;To dest & inc DI 2}
  95.   /$EB/$78               {       JMP   SHORT Done       ;Done}
  96.                          {                              ;}
  97.                          {; -- Mono routine; Char Only and No Wait--}
  98.   /$41                   {Mono1: INC   CX               ;Bump CX for odd char}
  99.   /$89/$CA               {       MOV   DX,CX            ;Save CX in DX}
  100.   /$D1/$E9               {       SHR   CX,1             ;Divide counter by 2}
  101.   /$EB/$05               {       JMP   SHORT Mon1b      ;Jump into mono loop}
  102.                          {                              ;}
  103.   /$AD                   {Mon1a: LODSW                  ;Load TWO char}
  104.   /$AA                   {       STOSB                  ;To dest & inc DI 1}
  105.   /$47                   {       INC   DI               ;Pass up attr}
  106.   /$88/$E0               {       MOV   AL,AH            ;Move Ch2 to AL}
  107.   /$AA                   {Mon1b: STOSB                  ;To dest & inc DI 1}
  108.   /$47                   {       INC   DI               ;Pass up attr}
  109.   /$E2/$F7               {       LOOP  Mon1a            ;Loop until CX=0}
  110.   /$D1/$EA               {       SHR   DX,1             ;Divide counter by 2}
  111.                          {                              ;CF=0 if odd length}
  112.   /$73/$64               {       JNC   Done             ;Exit if odd length}
  113.   /$AC                   {       LODSB                  ;Load last char}
  114.   /$AA                   {       STOSB                  ;To dest & inc DI 1}
  115.   /$EB/$60               {       JMP   SHORT Done       ;Done}
  116.                          {                              ;}
  117.   /$8E/$46/$FC           {Color: MOV   ES,[BP-$04]      ;Copy DS in ES}
  118.   /$26/$80/$3E/>TOEGA/$00{       ES: CMP BY[>ToEGA],$00 ;Check for EGA}
  119.   /$BA/$F6/$B7           {       MOV   DX,$B7F6         ;Addr for Color}
  120.   /$8E/$C2               {       MOV   ES,DX            ;ES:DI dest pointer}
  121.   /$75/$BC               {       JNE   EGA              ;If EGA, do Mono}
  122.   /$BA/$DA/$03           {       MOV   DX,$03DA         ;CGA port}
  123.   /$84/$FF               {       TEST  BH,BH            ;If Attr<0 ...}
  124.   /$78/$29               {       JS    Col1b            ;  use char only}
  125.   /$88/$DC               {       MOV   AH,BL            ;Move attr in AH}
  126.   /$EB/$01               {       JMP   SHORT Col2b      ;Attr and char}
  127.                          {                              ;}
  128.                          {; -- Color routine; Attr, Char and Wait --}
  129.   /$AC                   {Col2a: LODSB                  ;Load source char}
  130.   /$88/$C7               {Col2b: MOV   BH,AL            ;Save char in BH}
  131.   /$FA                   {       CLI                    ;Disable interrupts}
  132.   /$EC                   {E4in2: IN    AL,DX            ;Check CGA status}
  133.   /$A8/$08               {       TEST  AL,$08           ;If #3 bit clear ...}
  134.   /$74/$09               {       JZ    Col2c            ;  skip tests}
  135.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  136.   /$80/$F9/$90           {       CMP   CL,$90           ;If <145 Cols left,}
  137.   /$78/$A7               {       JS    Mono2            ;  do mono instead}
  138.   /$EB/$0B               {       JMP   SHORT Col2d      ;  else store direct}
  139.   /$D0/$D8               {Col2c: RCR   AL,1             ;If #0 bit set ...}
  140.   /$72/$EE               {       JC    E4in2            ;  try again for $E4}
  141.   /$EC                   {E5in2: IN    AL,DX            ;Check CGA status}
  142.   /$D0/$D8               {       RCR   AL,1             ;If #0 bit clear ...}
  143.   /$73/$FB               {       JNC   E5in2            ;  try again for $E5}
  144.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  145.   /$AB                   {Col2d: STOSW                  ;Put in dest & inc DI}
  146.   /$FB                   {       STI                    ;Enable interrupts}
  147.   /$E2/$DF               {       LOOP  Col2a            ;Loop till CX=0}
  148.   /$EB/$22               {       JMP   SHORT Done       ;Done}
  149.                          {                              ;}
  150.                          {; -- Color routine; Char only and Wait --}
  151.   /$AC                   {Col1a: LODSB                  ;Load source char}
  152.   /$47                   {       INC   DI               ;Pass up attr}
  153.   /$88/$C7               {Col1b: MOV   BH,AL            ;Save char in BH}
  154.   /$FA                   {       CLI                    ;Disable interrupts}
  155.   /$EC                   {E4in1: IN    AL,DX            ;Check CGA status}
  156.   /$A8/$08               {       TEST  AL,$08           ;If #3 bit clear ...}
  157.   /$74/$09               {       JZ    Col1c            ;  skip tests}
  158.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  159.   /$80/$F9/$80           {       CMP   CL,$80           ;If <129 Cols left,}
  160.   /$78/$99               {       JS    Mono1            ;  do mono instead.}
  161.   /$EB/$0B               {       JMP   SHORT Col1d      ;  else store direct}
  162.   /$D0/$D8               {Col1c: RCR   AL,1             ;If #0 bit set ...}
  163.   /$72/$EE               {       JC    E4in1            ;  try again for $E4}
  164.   /$EC                   {E5in1: IN    AL,DX            ;Check CGA status}
  165.   /$D0/$D8               {       RCR   AL,1             ;If #0 bit clear ...}
  166.   /$73/$FB               {       JNC   E5in1            ;  try again for $E5}
  167.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  168.   /$AA                   {Col1d: STOSB                  ;Put in dest & inc DI}
  169.   /$FB                   {       STI                    ;Enable interrupts}
  170.   /$E2/$DE               {       LOOP  Col1a            ;Loop till CX=0}
  171.                          {                              ;}
  172.   /$C3                   {Done:  RET                    ;Return to call}
  173. );
  174. end;
  175.  
  176. { QwriteC - Quick screen write, self-centering, value param:   v1.3, 11-10-86 }
  177. procedure QwriteC (Row, ColL, ColR: byte; Attr: integer; St: Str80);
  178. begin
  179. Inline(
  180.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  181.   /$8D/$B6/>ST           {       LEA   SI,[BP+>St]      ;Place offset in SI}
  182.   /$8C/$D2               {       MOV   DX,SS            ;Move SS into DS for}
  183.   /$8E/$DA               {       MOV   DS,DX            ;  use by LODS}
  184.   /$FC                   {       CLD                    ;Set DF to increment}
  185.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  186.   /$31/$C9               {       XOR   CX,CX            ;Set CX=0}
  187.   /$8E/$C1               {       MOV   ES,CX            ;Set ES=0}
  188.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  189.   /$74/$1A               {       JZ    Exit3            ;Null string}
  190.   /$8A/$B6/>ROW          {       MOV   DH,[BP+>Row]     ;Move row (Row*256)}
  191.   /$8B/$BE/>COLL         {       MOV   DI,[BP+>ColL]    ;Move col}
  192.   /$03/$BE/>COLR         {       ADD   DI,[BP+>ColR]    ;Add right col}
  193.   /$4F                   {       DEC   DI               ;Convert to 0-79 range}
  194.   /$29/$CF               {       SUB   DI,CX            ;Offset calc'd in DI}
  195.   /$81/$E7/$FE/$FF       {       AND   DI,$FFFE         ;Make even}
  196.   /$8B/$9E/>ATTR         {       MOV   BX,[BP+>Attr]    ;Move attr}
  197.   /$E8/$15/$FF           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  198.                          {                              ; is pre-compiled!}
  199.   /$1F                   {Exit3: POP   DS               ;Restore Turbo's DS}
  200. );
  201. end;
  202.  
  203. { QwriteCV - Quick screen write, self-centering, untyped VAR parameter
  204.                                                             ver 1.3, 11-10-86 }
  205. procedure QwriteCV (Row, ColL, ColR: byte; Attr: integer; VAR St);
  206. begin
  207. Inline(
  208.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  209.   /$C5/$76/<ST           {       LDS   SI,[BP+<St]      ;Place offset in SI}
  210.   /$FC                   {       CLD                    ;Set DF to increment}
  211.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  212.   /$31/$C9               {       XOR   CX,CX            ;Set CX=0}
  213.   /$8E/$C1               {       MOV   ES,CX            ;Set ES=0}
  214.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  215.   /$74/$16               {       JZ    Exit4            ;Null string}
  216.   /$8A/$76/<ROW          {       MOV   DH,[BP+<Row]     ;Move row (Row*256)}
  217.   /$8B/$7E/<COLL         {       MOV   DI,[BP+<ColL]    ;Move col}
  218.   /$03/$7E/<COLR         {       ADD   DI,[BP+<ColR]    ;Add right col}
  219.   /$4F                   {       DEC   DI               ;Convert to 0-79 range}
  220.   /$29/$CF               {       SUB   DI,CX            ;Offset calc'd in DI}
  221.   /$81/$E7/$FE/$FF       {       AND   DI,$FFFE         ;Make even}
  222.   /$8B/$5E/<ATTR         {       MOV   BX,[BP+<Attr]    ;Move attr}
  223.   /$E8/$E0/$FE           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  224.                          {                              ; is pre-compiled!}
  225.   /$1F                   {Exit4: POP   DS               ;Restore Turbo's DS}
  226. );
  227. end;