; programm : spooler  1.01
; datum    : 28.06.1988

           jmp start
ausp       dw 0000        ; pointer fr gedruckte zeichen
einp       dw 0000        ; pointer fr aufgenommene zeichen
alt0f      dw 0000,0000
alt1c      dw 0000,0000
alt17      dw 0000,0000
inst       db 13,10,'Spooler ist bereits installiert loeschen J/N$'
weg        db 13,10,'Spooler-Bereich geloescht$'
kill       db 13,10,'Spooler ist deaktiviert$'
mess       db 13,10,'Spooler ist aktiviert$'
beg        equ 0400
lang       equ 04bff
ende       equ beg+lang
par        equ [082]

zahl:      inc     bx
           cmp     bx,ende
           jnz     back

           mov     bx,beg
back:      ret
neu17:     or      ah,ah        ; was zu drucken ?
           jnz     i17r        ; wenn nicht dann zurck
           push    bx
           mov     bx,cs: word ptr [einp] ; pointer bernehmen
           mov     cs: byte ptr [bx],al    ; zeichen abspeichern
           call    zahl                   ; testen ob buffer zuende
druck:     int     1ch                     ; versuchen zeichen auszugeben
           cmp     bx,cs: word ptr [ausp] ; buffer immer noch voll
           jz      druck                   ; wieder ausgeben
           mov     cs: word ptr [einp],bx ; sonst pointer sichern
           pop     bx
i17r:      mov     ax,0000                 ; ok anzeigen
           iret

neu1c:     push    ax      ; wird 18,2 mal pro sekunde angesprungen
           push    bx
           push    cx
           push    dx
los:       mov     dx,0379      ; vorweg testen ob drucker ok
           in      al,dx
           test    al,080       ; besetzt ?   dann zurck
           jz      rueck
           mov     bx,cs: word ptr [ausp]  ; sind ein und aus gleich ?
           cmp     bx,cs: word ptr [einp]
           jz      rueck                    ; wenn ja dann zurck
           mov     al,cs: byte ptr [bx]     ; sonst ein zeichen nehmen
           dec     dx                       ; ausgabeport einsetzen
           out     dx,al                    ; zeichen ausgeben
           mov     al,01d                   ; strobe aktivieren
           mov     dx,037a                  ; steuerregister
           out     dx,al                    ; und ausgeben
           mov     al,01c                   ; strobe inaktiv
           out     dx,al                    ; uns ausgeben
           call    zahl                    ; testen ob bufferende
           mov     cs: word ptr [ausp],bx  ; und pointer sichern
           mov     cx,100                  ; und verz”gern
weit:      loop    weit
           jmp short los                    ; und wieder von vorne
rueck:     pop     dx
           pop     cx
           pop     bx
           pop     ax
           iret

neu0f:     push    ax        ; interrupt durch den drucker !!!
           int     01c       ; neuen int 01c anspringen
           mov     al,020    ; und interrupt fr beendet erkl„ren
           out    020,al
           pop     ax
           iret              ; und wieder zurck

start:     cli
           push ax
           push es
           push ds
           push bx
           mov ax,03517
           int 021
           cmp bx,offset neu17
           jne init
           mov bx,es
           mov dx,offset inst
           mov ah,09
           int 021
           mov ah,01
           int 021
           and al,0df
           cmp al,74        ; auf J testen
           jne no_clear
           push ds
           mov ds,bx
           xor ax,ax
           mov cx,lang
           mov di,beg
           rep stosb
           pop ds
           mov dx,offset weg
           mov ah,09
           int 021
           mov ah,par
           cmp ah,'-'
           jne no_clear
           mov dx,offset kill
           mov ah,09
           int 021
           push ds
           mov ds,bx
           mov dx,word ptr [alt1c]
           mov ds,word ptr 2[alt1c]
           mov ax,0251c
           int 021
           mov ds,bx
           mov dx,word ptr [alt0f]
           mov ds,word ptr 2[alt0f]
           mov ax,0250f
           int 021
           mov ds,bx
           mov dx,word ptr [alt17]
           mov ds,word ptr 2[alt17]
           mov ax,02517
           int 021
           push es
           mov es,bx
           mov ah,049
           int 021
           pop es
           pop ds

no_clear:  pop bx
           pop ds
           pop es
           pop ax
           sti
           mov ah,04c
           int 021

init:      mov ax,0350f
           int 021
           mov cs: word ptr [alt0f],bx
           mov cs: word ptr 2[alt0f],es
           mov ax,0351c
           int 021
           mov cs: word ptr [alt1c],bx
           mov cs: word ptr 2[alt1c],es
           mov ax,03517
           int 021
           mov cs: word ptr [alt17],bx
           mov cs: word ptr 2[alt17],es
           mov cs: word ptr [ausp],0400h
           mov cs: word ptr [einp],0400h
           mov es,cs
           xor ax,ax
           mov cx,lang
           mov di,beg
           rep stosb
           mov ax,0250f
           mov ds,cs
           mov dx,offset neu0f
           int 021
           mov ds,cs
           mov ax,0251c
           mov dx,offset neu1c
           int 021
           mov ds,cs
           mov ax,02517
           mov dx,offset neu17
           int 021
           mov dx,offset mess
           mov ah,09
           int 021
           in  al,021
           and al,07f
           out 021,al
           pop bx
           pop ds
           pop es
           pop ax
           sti
           mov dx,ende
           inc dx    ; speicherbedarf
           int 027

