home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / QWIK21.ZIP / QWRITES.INC < prev   
Encoding:
Text File  |  1986-12-10  |  16.1 KB  |  250 lines
  1. { Qwrites.inc - QwriteLV, QwriteV, Qwrite, QwriteC, QwriteCV  v 2.1, 12-09-86 }
  2. { These five 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 QWIK21.DOC for any changes in this file!     }
  7.  
  8. { QwriteLV - Quick screen write, specified Length, untyped VAR parameter      }
  9. {                                                           ver 2.1, 12-09-86 }
  10. { Unlike other QwriteXX procedures, this one lets you specify both Length and }
  11. { starting index for partial strings.  All other procedures assume length is  }
  12. { the value in St[0] and the index points to St[1].                           }
  13. procedure QwriteLV (Row, Col: byte; Attr, Length: integer; VAR St);
  14. begin
  15. Inline(
  16.    $8B/$4E/<LENGTH       {       MOV   CX,[BP+<Length]  ;Move length in CX}
  17.   /$85/$C9               {       TEST  CX,CX            ;If CX<=0,}
  18.   /$7E/$18               {       JLE   Exit0            ;  nothing to do.}
  19.   /$1E                   {       PUSH  DS               ;Save Turbo's DS}
  20.   /$C5/$76/<ST           {       LDS   SI,[BP+<St]      ;Place offset in SI}
  21.   /$FC                   {       CLD                    ;Set DF to increment}
  22.   /$AC                   {       LODSB                  ;Load St[i]}
  23.   /$88/$C4               {       MOV   AH,AL            ;Move St[i] to AH}
  24.   /$8B/$56/<ROW          {       MOV   DX,[BP+<Row]     ;Move row in DX}
  25.   /$8B/$7E/<COL          {       MOV   DI,[BP+<Col]     ;Move col in DI}
  26.   /$4F                   {       DEC   DI               ;Convert to 0-?? range}
  27.   /$D1/$E7               {       SHL   DI,1             ;Mult by 2}
  28.   /$8B/$5E/<ATTR         {       MOV   BX,[BP+<Attr]    ;Move attr in BX}
  29.   /$E8/$71/$00           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  30.                          {                              ; is pre-compiled!}
  31.   /$1F                   {       POP   DS               ;Restore Turbo's DS}
  32.                          {Exit0:                        ;}
  33. );
  34. end;
  35.  
  36. { QwriteV - Quick screen write, untyped VAR parameter       ver 2.0, 11-24-86 }
  37. procedure QwriteV (Row, Col: byte; Attr: integer; VAR St);
  38. begin
  39. Inline(
  40.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  41.   /$C5/$76/<ST           {       LDS   SI,[BP+<St]      ;Place offset in SI}
  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.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  46.   /$74/$0F               {       JZ    Exit1            ;Null string}
  47.   /$8B/$56/<ROW          {       MOV   DX,[BP+<Row]     ;Move row in DX}
  48.   /$8B/$7E/<COL          {       MOV   DI,[BP+<Col]     ;Move col in DI}
  49.   /$4F                   {       DEC   DI               ;Convert to 0-?? range}
  50.   /$D1/$E7               {       SHL   DI,1             ;Mult by 2}
  51.   /$8B/$5E/<ATTR         {       MOV   BX,[BP+<Attr]    ;Move attr}
  52.   /$E8/$45/$00           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  53.                          {                              ; is pre-compiled!}
  54.   /$1F                   {Exit1: POP   DS               ;Restore Turbo's DS}
  55. );
  56. end;
  57.  
  58. { Qwrite - Quick screen write, value parameter              ver 2.0, 11-24-86 }
  59. procedure Qwrite (Row, Col: byte; Attr: integer; St: Str80);
  60. begin
  61. Inline(
  62.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  63.   /$8D/$B6/>ST           {       LEA   SI,[BP+>St]      ;Place offset in SI}
  64.   /$8C/$D2               {       MOV   DX,SS            ;Move SS into DS for}
  65.   /$8E/$DA               {       MOV   DS,DX            ;  use by LODS}
  66.   /$FC                   {       CLD                    ;Set DF to increment}
  67.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  68.   /$31/$C9               {       XOR   CX,CX            ;Set CX=0}
  69.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  70.   /$74/$12               {       JZ    Exit2            ;Null string}
  71.   /$8B/$96/>ROW          {       MOV   DX,[BP+>Row]     ;Move row in DX}
  72.   /$8B/$BE/>COL          {       MOV   DI,[BP+>Col]     ;Move col in DI}
  73.   /$4F                   {       DEC   DI               ;Convert to 0-?? range}
  74.   /$D1/$E7               {       SHL   DI,1             ;Mult by 2}
  75.   /$8B/$9E/>ATTR         {       MOV   BX,[BP+>Attr]    ;Move attr}
  76.   /$E8/$11/$00           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  77.                          {                              ; is pre-compiled!}
  78.   /$1F                   {Exit2: POP   DS               ;Restore Turbo's DS}
  79. );
  80. end;
  81.  
  82. { QwritesDisp - Subroutine for all QwriteXX procedures      ver 2.1, 12-09-86 }
  83. procedure QwritesDisp;
  84. begin
  85. Inline(
  86.    $4A                   {Qdisp: DEC   DX               ;Convert to 0-?? range}
  87.   /$88/$E6               {       MOV   DH,AH            ;Save St[1] in DH}
  88.   /$31/$C0               {       XOR   AX,AX            ;Set AX=0}
  89.   /$8E/$C0               {       MOV   ES,AX            ;Set ES=0}
  90.   /$26/$A1/$4A/$04       {       ES:   MOV AX,[$044A]   ;Get CRT columns}
  91.   /$F6/$E2               {       MUL   DL               ;(CRT columns)*(Row-1)}
  92.   /$D1/$E0               {       SHL   AX,1             ;Mult by 2}
  93.   /$01/$C7               {       ADD   DI,AX            ;Dest offset in DI}
  94.   /$88/$DC               {       MOV   AH,BL            ;Move attr to AH}
  95.   /$88/$F0               {       MOV   AL,DH            ;Move St[1] to AL}
  96.   /$8E/$46/$FC           {       MOV   ES,[BP-$04]      ;Copy DS in ES}
  97.   /$26/$80/$3E/>QWAIT/$00{       ES: CMP BY[>Qwait],$00 ;Check need for wait}
  98.   /$26/$8E/$06/>QSEG     {       ES:   MOV ES,[>Qseg]   ;ES:DI dest pointer}
  99.   /$75/$32               {       JNE   Color            ;  use Color routine}
  100.                          {                              ;}
  101.   /$84/$FF               {       TEST  BH,BH            ;If Attr<0 ...}
  102.   /$78/$16               {       JS    Mono1            ;  use char only}
  103.                          {                              ;}
  104.                          {; -- Mono routine; Attr, Char and No Wait--}
  105.                          {; Algorithm packs in an extra STOSW per LOOP}
  106.   /$41                   {Mono2: INC   CX               ;Bump CX for odd char}
  107.   /$D1/$E9               {       SHR   CX,1             ;Divide counter by 2}
  108.                          {                              ; CF=0 if odd length}
  109.   /$EB/$08               {       JMP   SHORT Mon2b      ;Jump into mono loop}
  110.                          {                              ;}
  111.   /$AD                   {Mon2a: LODSW                  ;Load TWO char}
  112.   /$88/$E7               {       MOV   BH,AH            ;Move Ch2 to BH}
  113.   /$88/$DC               {       MOV   AH,BL            ;Copy attr to AH}
  114.   /$AB                   {       STOSW                  ;To dest & inc DI 2}
  115.   /$88/$F8               {       MOV   AL,BH            ;Move Ch2 to AL}
  116.   /$AB                   {Mon2b: STOSW                  ;To dest & inc DI 2}
  117.   /$E2/$F5               {       LOOP  Mon2a            ;Loop until CX=0}
  118.   /$73/$6C               {       JNC   Done             ;Exit if odd length}
  119.   /$AC                   {       LODSB                  ;Load last char}
  120.   /$AB                   {       STOSW                  ;To dest & inc DI 2}
  121.   /$EB/$68               {       JMP   SHORT Done       ;Done}
  122.                          {                              ;}
  123.                          {; -- Mono routine; Char Only and No Wait--}
  124.                          {; Algorithm packs in an extra STOSB per LOOP}
  125.   /$41                   {Mono1: INC   CX               ;Bump CX for odd char}
  126.   /$89/$CA               {       MOV   DX,CX            ;Save CX in DX}
  127.   /$D1/$E9               {       SHR   CX,1             ;Divide counter by 2}
  128.   /$EB/$05               {       JMP   SHORT Mon1b      ;Jump into mono loop}
  129.                          {                              ;}
  130.   /$AD                   {Mon1a: LODSW                  ;Load TWO char}
  131.   /$AA                   {       STOSB                  ;To dest & inc DI 1}
  132.   /$47                   {       INC   DI               ;Pass up attr}
  133.   /$88/$E0               {       MOV   AL,AH            ;Move Ch2 to AL}
  134.   /$AA                   {Mon1b: STOSB                  ;To dest & inc DI 1}
  135.   /$47                   {       INC   DI               ;Pass up attr}
  136.   /$E2/$F7               {       LOOP  Mon1a            ;Loop until CX=0}
  137.   /$D1/$EA               {       SHR   DX,1             ;Divide counter by 2}
  138.                          {                              ;CF=0 if odd length}
  139.   /$73/$54               {       JNC   Done             ;Exit if odd length}
  140.   /$AC                   {       LODSB                  ;Load last char}
  141.   /$AA                   {       STOSB                  ;To dest & inc DI 1}
  142.   /$EB/$50               {       JMP   SHORT Done       ;Done}
  143.                          {                              ;}
  144.   /$BA/$DA/$03           {Color: MOV   DX,$03DA         ;CGA port}
  145.   /$84/$FF               {       TEST  BH,BH            ;If Attr<0 ...}
  146.   /$78/$29               {       JS    Col1b            ;  use char only}
  147.   /$88/$DC               {       MOV   AH,BL            ;Move attr in AH}
  148.   /$EB/$01               {       JMP   SHORT Col2b      ;Attr and char}
  149.                          {                              ;}
  150.                          {; -- Color routine; Attr, Char and Wait --}
  151.   /$AC                   {Col2a: LODSB                  ;Load source char}
  152.   /$88/$C7               {Col2b: MOV   BH,AL            ;Save char in BH}
  153.   /$FA                   {       CLI                    ;Disable interrupts}
  154.   /$EC                   {E4in2: IN    AL,DX            ;Check CGA status}
  155.   /$A8/$08               {       TEST  AL,$08           ;If #3 bit clear ...}
  156.   /$74/$09               {       JZ    Col2c            ;  check #0 bit.}
  157.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  158.   /$80/$F9/$90           {       CMP   CL,$90           ;If <145 Cols left,}
  159.   /$78/$B7               {       JS    Mono2            ;  do mono instead}
  160.   /$EB/$0B               {       JMP   SHORT Col2d      ;  else store direct}
  161.   /$D0/$D8               {Col2c: RCR   AL,1             ;If #0 bit set ...}
  162.   /$72/$EE               {       JC    E4in2            ;  try again for $E4}
  163.   /$EC                   {E5in2: IN    AL,DX            ;Check CGA status}
  164.   /$D0/$D8               {       RCR   AL,1             ;If #0 bit clear ...}
  165.   /$73/$FB               {       JNC   E5in2            ;  try again for $E5}
  166.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  167.   /$AB                   {Col2d: STOSW                  ;Put in dest & inc DI}
  168.   /$FB                   {       STI                    ;Enable interrupts}
  169.   /$E2/$DF               {       LOOP  Col2a            ;Loop till CX=0}
  170.   /$EB/$22               {       JMP   SHORT Done       ;Done}
  171.                          {                              ;}
  172.                          {; -- Color routine; Char only and Wait --}
  173.   /$AC                   {Col1a: LODSB                  ;Load source char}
  174.   /$47                   {       INC   DI               ;Pass up attr}
  175.   /$88/$C7               {Col1b: MOV   BH,AL            ;Save char in BH}
  176.   /$FA                   {       CLI                    ;Disable interrupts}
  177.   /$EC                   {E4in1: IN    AL,DX            ;Check CGA status}
  178.   /$A8/$08               {       TEST  AL,$08           ;If #3 bit clear ...}
  179.   /$74/$09               {       JZ    Col1c            ;  check #0 bit.}
  180.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  181.   /$80/$F9/$80           {       CMP   CL,$80           ;If <129 Cols left,}
  182.   /$78/$A9               {       JS    Mono1            ;  do mono instead.}
  183.   /$EB/$0B               {       JMP   SHORT Col1d      ;  else store direct}
  184.   /$D0/$D8               {Col1c: RCR   AL,1             ;If #0 bit set ...}
  185.   /$72/$EE               {       JC    E4in1            ;  try again for $E4}
  186.   /$EC                   {E5in1: IN    AL,DX            ;Check CGA status}
  187.   /$D0/$D8               {       RCR   AL,1             ;If #0 bit clear ...}
  188.   /$73/$FB               {       JNC   E5in1            ;  try again for $E5}
  189.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  190.   /$AA                   {Col1d: STOSB                  ;Put in dest & inc DI}
  191.   /$FB                   {       STI                    ;Enable interrupts}
  192.   /$E2/$DE               {       LOOP  Col1a            ;Loop till CX=0}
  193.                          {                              ;}
  194.   /$FB                   {Done:  STI                    ;Enable interrupts}
  195.   /$C3                   {       RET                    ;Return to call}
  196. );
  197. end;
  198.  
  199. { QwriteC - Quick screen write, self-centering, value param   v 2.1, 12-09-86 }
  200. procedure QwriteC (Row, ColL, ColR: byte; Attr: integer; St: Str80);
  201. begin
  202. Inline(
  203.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  204.   /$8D/$B6/>ST           {       LEA   SI,[BP+>St]      ;Place offset in SI}
  205.   /$8C/$D2               {       MOV   DX,SS            ;Move SS into DS for}
  206.   /$8E/$DA               {       MOV   DS,DX            ;  use by LODS}
  207.   /$FC                   {       CLD                    ;Set DF to increment}
  208.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  209.   /$31/$C9               {       XOR   CX,CX            ;Set CX=0}
  210.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  211.   /$74/$1A               {       JZ    Exit3            ;Null string}
  212.   /$8B/$96/>ROW          {       MOV   DX,[BP+>Row]     ;Move row in DX}
  213.   /$8B/$BE/>COLL         {       MOV   DI,[BP+>ColL]    ;Move col in DI}
  214.   /$03/$BE/>COLR         {       ADD   DI,[BP+>ColR]    ;Add right col}
  215.   /$4F                   {       DEC   DI               ;Convert to 0-?? range}
  216.   /$29/$CF               {       SUB   DI,CX            ;Offset calc'd in DI}
  217.   /$81/$E7/$FE/$FF       {       AND   DI,$FFFE         ;Make even}
  218.   /$8B/$9E/>ATTR         {       MOV   BX,[BP+>Attr]    ;Move attr}
  219.   /$E8/$1E/$FF           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  220.                          {                              ; is pre-compiled!}
  221.   /$1F                   {Exit3: POP   DS               ;Restore Turbo's DS}
  222. );
  223. end;
  224.  
  225. { QwriteCV - Quick screen write, self-centering, untyped VAR parameter
  226.                                                             ver 2.1, 12-09-86 }
  227. procedure QwriteCV (Row, ColL, ColR: byte; Attr: integer; VAR St);
  228. begin
  229. Inline(
  230.    $1E                   {       PUSH  DS               ;Save Turbo's DS}
  231.   /$C5/$76/<ST           {       LDS   SI,[BP+<St]      ;Place offset in SI}
  232.   /$FC                   {       CLD                    ;Set DF to increment}
  233.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  234.   /$31/$C9               {       XOR   CX,CX            ;Set CX=0}
  235.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  236.   /$74/$16               {       JZ    Exit4            ;Null string}
  237.   /$8B/$56/<ROW          {       MOV   DX,[BP+<Row]     ;Move row in DX}
  238.   /$8B/$7E/<COLL         {       MOV   DI,[BP+<ColL]    ;Move col in DI}
  239.   /$03/$7E/<COLR         {       ADD   DI,[BP+<ColR]    ;Add right col}
  240.   /$4F                   {       DEC   DI               ;Convert to 0-?? range}
  241.   /$29/$CF               {       SUB   DI,CX            ;Offset calc'd in DI}
  242.   /$81/$E7/$FE/$FF       {       AND   DI,$FFFE         ;Make even}
  243.   /$8B/$5E/<ATTR         {       MOV   BX,[BP+<Attr]    ;Move attr}
  244.   /$E8/$EB/$FE           {       CALL  NEAR Qdisp       ;Call Qdisp, address}
  245.                          {                              ; is pre-compiled!}
  246.   /$1F                   {Exit4: POP   DS               ;Restore Turbo's DS}
  247. );
  248. end;
  249.  
  250.