home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / QWRITE11.ZIP / QWRITEV.INC < prev   
Encoding:
Text File  |  1986-10-31  |  9.2 KB  |  132 lines
  1. { This procedure does fast screen writes and automatically configures to
  2.   your machine for Mono, CGA, and EGA.  It also has the feature of suppressing
  3.   the attribute by setting Attr<0; then QwriteV will just overwrite the display
  4.   using the current attributes.  The upper left column is 1,1. }
  5.  
  6. procedure QwriteV (Row, Col: byte; Attr: integer; VAR St);
  7. begin
  8. Inline(
  9.   $31/$C0                {       XOR   AX,AX            ;Set AX=0}
  10.   /$89/$C1               {       MOV   CX,AX            ;Set CX=0}
  11.   /$8E/$C0               {       MOV   ES,AX            ;Set ES=0}
  12.   /$8A/$66/<ROW          {       MOV   AH,[BP+<Row]     ;Move row (Row*256)}
  13.   /$D1/$E8               {       SHR   AX,1             ;(Row*128)}
  14.   /$89/$C7               {       MOV   DI,AX            ;Save (Row*128) in DI}
  15.   /$D1/$E8               {       SHR   AX,1             ;(Row*64)}
  16.   /$D1/$E8               {       SHR   AX,1             ;(Row*32)}
  17.   /$01/$C7               {       ADD   DI,AX            ;Save (Row*160) in DI}
  18.   /$8B/$46/<COL          {       MOV   AX,[BP+<Col]     ;Move col}
  19.   /$48                   {       DEC   AX               ;Convert to 0-79 range}
  20.   /$D1/$E0               {       SHL   AX,1             ;Mult by 2}
  21.   /$01/$C7               {       ADD   DI,AX            ;Offset calc'd in DI}
  22.                          {                              ;}
  23.   /$8B/$5E/<ATTR         {       MOV   BX,[BP+<Attr]    ;Move attr}
  24.                          {                              ;}
  25.   /$C5/$76/<ST           {       LDS   SI,[BP+<St]      ;Place offset in SI}
  26.   /$FC                   {       CLD                    ;Set DF to increment}
  27.   /$AD                   {       LODSW                  ;Load St[1],St[0]}
  28.   /$00/$C1               {       ADD   CL,AL            ;Save length in CL}
  29.   /$74/$41               {       JZ    ExitS            ;Null string}
  30.   /$88/$E0               {       MOV   AL,AH            ;Move St[1] to AL}
  31.   /$26/$80/$3E/$49/$04/$07{      ES: CMP BY[$0449],$07  ;Check video mode}
  32.   /$75/$39               {       JNE   Color            ;  use Color routine}
  33.                          {                              ;}
  34.   /$BA/$F6/$AF           {       MOV   DX,$AFF6         ;Addr for Mono}
  35.   /$8E/$C2               {       MOV   ES,DX            ;ES:DI dest pointer}
  36.   /$84/$FF               {EGA:   TEST  BH,BH            ;If Attr<0 ...}
  37.   /$78/$18               {       JS    Mono1            ;  use char only}
  38.                          {                              ;}
  39.                          {; -- Mono routine; Attr, Char and No Wait--}
  40.   /$88/$DC               {       MOV   AH,BL            ;Copy attr to AH}
  41.   /$41                   {Mono2: INC   CX               ;Bump CX for odd char}
  42.   /$D1/$E9               {       SHR   CX,1             ;Divide counter by 2}
  43.                          {                              ; CF=0 if odd length}
  44.   /$EB/$08               {       JMP   SHORT Mon2b      ;Jump into mono loop}
  45.                          {                              ;}
  46.   /$AD                   {Mon2a: LODSW                  ;Load TWO char}
  47.   /$88/$E7               {       MOV   BH,AH            ;Move Ch2 to BH}
  48.   /$88/$DC               {       MOV   AH,BL            ;Copy attr to AH}
  49.   /$AB                   {       STOSW                  ;To dest & inc DI 2}
  50.   /$88/$F8               {       MOV   AL,BH            ;Move Ch2 to AL}
  51.   /$AB                   {Mon2b: STOSW                  ;To dest & inc DI 2}
  52.   /$E2/$F5               {       LOOP  Mon2a            ;Loop until CX=0}
  53.   /$73/$75               {       JNC   Exit             ;Exit if odd length}
  54.   /$AC                   {       LODSB                  ;Load last char}
  55.   /$AB                   {       STOSW                  ;To dest & inc DI 2}
  56.   /$EB/$71               {       JMP   SHORT Exit       ;Done}
  57.                          {                              ;}
  58.                          {; -- Mono routine; Char Only and No Wait--}
  59.   /$41                   {Mono1: INC   CX               ;Bump CX for odd char}
  60.   /$89/$CA               {       MOV   DX,CX            ;Save CX in DX}
  61.   /$D1/$E9               {       SHR   CX,1             ;Divide counter by 2}
  62.   /$EB/$05               {       JMP   SHORT Mon1b      ;Jump into mono loop}
  63.                          {                              ;}
  64.   /$AD                   {Mon1a: LODSW                  ;Load TWO char}
  65.   /$AA                   {       STOSB                  ;To dest & inc DI 1}
  66.   /$47                   {       INC   DI               ;Pass up attr}
  67.   /$88/$E0               {       MOV   AL,AH            ;Move Ch2 to AL}
  68.   /$AA                   {Mon1b: STOSB                  ;To dest & inc DI 1}
  69.   /$47                   {       INC   DI               ;Pass up attr}
  70.   /$E2/$F7               {       LOOP  Mon1a            ;Loop until CX=0}
  71.   /$D1/$EA               {       SHR   DX,1             ;Divide counter by 2}
  72.                          {                              ;CF=0 if odd length}
  73.   /$73/$5D               {       JNC   Exit             ;Exit if odd length}
  74.   /$AC                   {       LODSB                  ;Load last char}
  75.   /$AA                   {       STOSB                  ;To dest & inc DI 1}
  76.   /$EB/$59               {ExitS: JMP   SHORT Exit       ;Done}
  77.                          {                              ;}
  78.   /$BA/$F6/$B7           {Color: MOV   DX,$B7F6         ;Addr for Color}
  79.   /$8E/$C2               {       MOV   ES,DX            ;ES:DI dest pointer}
  80.   /$79/$C5               {       JNS   EGA              ;If EGA, do Mono}
  81.   /$BA/$DA/$03           {       MOV   DX,$03DA         ;CGA port}
  82.   /$84/$FF               {       TEST  BH,BH            ;If Attr<0 ...}
  83.   /$78/$2A               {       JS    Col1b            ;  use char only}
  84.   /$88/$DC               {       MOV   AH,BL            ;Move attr in AH}
  85.   /$EB/$01               {       JMP   SHORT Col2b      ;Attr and char}
  86.                          {                              ;}
  87.                          {; -- Color routine; Attr, Char and Wait --}
  88.   /$AC                   {Col2a: LODSB                  ;Load source char}
  89.   /$88/$C7               {Col2b: MOV   BH,AL            ;Save char in BH}
  90.   /$FA                   {       CLI                    ;Disable interrupts}
  91.   /$EC                   {E4in2: IN    AL,DX            ;Check CGA status}
  92.   /$A8/$08               {       TEST  AL,$08           ;If #3 bit clear ...}
  93.   /$74/$0A               {       JZ    Col2c            ;  skip tests}
  94.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  95.   /$81/$F9/$90/$00       {       CMP   CX,$0090         ;If <145 Cols left,}
  96.   /$78/$AF               {       JS    Mono2            ;  do mono instead}
  97.   /$EB/$0B               {       JMP   SHORT Col2d      ;  else store direct}
  98.   /$D0/$D8               {Col2c: RCR   AL,1             ;If #0 bit set ...}
  99.   /$72/$ED               {       JC    E4in2            ;  try again for $E4}
  100.   /$EC                   {E5in2: IN    AL,DX            ;Check CGA status}
  101.   /$D0/$D8               {       RCR   AL,1             ;If #0 bit clear ...}
  102.   /$73/$FB               {       JNC   E5in2            ;  try again for $E5}
  103.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  104.   /$AB                   {Col2d: STOSW                  ;Put in dest & inc DI}
  105.   /$FB                   {       STI                    ;Enable interrupts}
  106.   /$E2/$DE               {       LOOP  Col2a            ;Loop till CX=0}
  107.   /$EB/$23               {       JMP   SHORT Exit       ;Done}
  108.                          {                              ;}
  109.                          {; -- Color routine; Char only and Wait --}
  110.   /$AC                   {Col1a: LODSB                  ;Load source char}
  111.   /$47                   {       INC   DI               ;Pass up attr}
  112.   /$88/$C7               {Col1b: MOV   BH,AL            ;Save char in BH}
  113.   /$FA                   {       CLI                    ;Disable interrupts}
  114.   /$EC                   {E4in1: IN    AL,DX            ;Check CGA status}
  115.   /$A8/$08               {       TEST  AL,$08           ;If #3 bit clear ...}
  116.   /$74/$0A               {       JZ    Col1c            ;  skip tests}
  117.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  118.   /$81/$F9/$80/$00       {       CMP   CX,$0080         ;If <129 Cols left,}
  119.   /$78/$A0               {       JS    Mono1            ;  do mono instead.}
  120.   /$EB/$0B               {       JMP   SHORT Col1d      ;  else store direct}
  121.   /$D0/$D8               {Col1c: RCR   AL,1             ;If #0 bit set ...}
  122.   /$72/$ED               {       JC    E4in1            ;  try again for $E4}
  123.   /$EC                   {E5in1: IN    AL,DX            ;Check CGA status}
  124.   /$D0/$D8               {       RCR   AL,1             ;If #0 bit clear ...}
  125.   /$73/$FB               {       JNC   E5in1            ;  try again for $E5}
  126.   /$88/$F8               {       MOV   AL,BH            ;Move char back in AL}
  127.   /$AA                   {Col1d: STOSB                  ;Put in dest & inc DI}
  128.   /$FB                   {       STI                    ;Enable interrupts}
  129.   /$E2/$DD               {       LOOP  Col1a            ;Loop till CX=0}
  130.                          {Exit:}
  131. );
  132. end;