Power-Programmierung/CD1.mdf/assemblr/library/sampler0/strobe.asm

Assembly Source File | 1989-01-13 | 21KB | 532 lines

        page    ,132                    ; print in condensed mode

        title   STROBE - Monitor a memory field for changes  -  P. Quale 3/87
cseg    segment para
        assume  cs:cseg,ds:cseg,es:nothing,ss:nothing

                org     2ch
env_seg         dw      ?               ;pointer to our copy of environment
                org     80h             ;parm list starts here...
parm_len        db      ?               ;its length
parm_char       db      127 dup(?)      ;the parms
        org     100h
strobe  proc    near
begin:
        jmp     init                    ;go to once-only code

prog_id:db      'STROBE 1.02 '
        db      'IBM Internal Use Only '
        db      'P. Quale 03/87'
id_end  equ     $

;history:
;    1.01, 05/26/87: revised to incorporate changes suggested by Kevin McCarthy.
;       The addresses being monitored can now be patched on the fly by patching
;       new values into the fields intvect and intvect2, which have been
;       changed from EQU values to doubleword pointers.

;    1.02, 01/13/89: STROBE now releases its memory when 'R'emoved.  Also
;       removed a potential BRS bug if a derivative program were to have an
;       ASSUME DS:CSEG directive in the timer interrupt routine, by changing
;       the exit statement from 'JMP OLDVECT' to 'JMP CS:OLDVECT'.

;-------macro to simplify window repositioning
posw    macro   name,row,column                 ;convert row/column location
name    equ     ((row-1)*160)+((column-1)*2)    ;to position in video buffer
        endm

;-------macro to define field positions within the window
posf    macro   name,row,column                 ;convert line/column location
name    equ     corner1+((row-1)*160)+((column-1)*2)    ;to pos in video buffer
        endm

        db      0               ;waste a byte to align patch area nicely
old_vect        label   dword           ;original timer vector saved here
old_ofs         dw      0               ;offset
old_seg         dw      0               ;segment
;               keep old_vect as close to front of program as possible

        page
;-------entries on this page are grouped together to facilitate
;-------changes in window location or storage area(s) being tracked

;-------next entries define the control block to be "watched"
;-------in this case, we watch to see when int 21 gets hooked
intnum          equ     021h            ;interrupt number we care about
intvect         dw      intnum*4,0      ;offset, segment (patchable)
prev_value      dw      2 dup(?)        ;its previous (or initial) contents

;-------any other memory fields of interest
intnum2         equ     02fh            ;another interrupt number we care about
intvect2        dw      intnum2*4,0     ;offset, segment (patchable)

;-------next three entries define the window size and location
        posw    corner1,1,62    ;upper left corner of window
        posw    corner2,1,80    ;upper right corner
        posw    corner4,5,80    ;lower right corner

;-------next entries define location of each field within the window
        posf    out1,1,1        ;moving blob goes here on line 1 of window
        posf    out2,2,10       ;entry count here at line 2 col 10 of window
        posf    out3,3,10       ;contents of major block being tracked
        posf    out4,4,10       ;yet another block being tracked
        posf    out5,5,10       ;cs:ip of routine running when timer went off

;-------end of EQUs, etc. peculiar to a specific application of STROBE
        page

;-------next two equates are needed by the window-clearing code
windwid equ     (corner2-corner1+2)/2           ;width in screen positions
winddep equ     (corner4-corner2+160)/160       ;depth in lines

clknum  equ     08h             ;timer interrupt number
clkvect equ     clknum*4        ;its vector address

;-------window attributes/colors used to indicate a value change
table_mono      db      20h,70h,28h,29h  ;normal, reversed, bright, underlined
table_color     db      07h,04fh,2fh,5fh ;white on: black, red, green, magenta
max_change      equ     3       ;n'color changes before we recycle (zero-based)
change_index    dw      (max_change)     ;forces a start at first color

flags           db      0       ;flag bits...
mono            equ     01h
color           equ     02h
sync            equ     04h

vidseg          dw      0       ;video segment address
vidsegm         equ     0b000h  ;video segment address if mono
vidsegc         equ     0b800h  ;video segment address if color
attrib          db      0       ;screen attribute byte
tick_count      dw      0       ;cyclic index into tick-display line
max_tick        equ     18      ;limit for tick_count
blob            equ     0feh    ;timer-tick char. feh=small square, dbh=big one
entry_count     dw      0       ;count of timer-tick entries to this program
count_carry     db      0       ;how many times entry_count wrapped
ss_save         dw      0       ;ss saved here upon entry
sp_save         dw      0       ;sp saved here

;-------enter here on timer interrupt
timer_int:
        assume  cs:cseg,ds:nothing,es:nothing,ss:nothing
        pushf                   ;preserve flags

;-------switch to our own stack
        cli                     ;disable interrupts (and keep them that way)
        mov     ss_save,ss
        mov     sp_save,sp
        push    cs
        pop     ss
        lea     sp,stack_end
        nop

;-------save the rest of the registers
        push    ax
        push    bx
        push    cx
        push    dx
        push    bp
        push    di
        push    si
        push    ds
        push    es

;-------set ds for our internal variables, es for video buffer
        push    cs
        pop     ds
        assume  ds:cseg
        push    vidseg          ;set video segment address
        pop     es              ;...

;-------make sure our stack size hasn't been exceeded
;       (for testing; probably an unnecessary check now)
        mov     ax,0fefeh               ;string that must still be there
        cmp     ax,stack_bottom         ;has anyone overrun our stack?
        je      check_major             ;no
tight_loop:                             ;yes, so stop right here and now
        mov     ax,05341h               ;but leave tracks
        mov     es:corner1,ax           ;upper left corner of window
        jmp     short tight_loop

check_major:
;-------check to see if value of memory field we're watching has changed:
        push    ds              ;save ds for a moment
        assume  ds:nothing
        lds     bx,dword ptr intvect    ;load dword pointer
        mov     ax,ds:[bx]      ;pick up first 2 bytes of field
        mov     bx,ds:[bx+2]    ;next 2 bytes
        pop     ds
        assume  ds:cseg
        cmp     ax,prev_value   ;still the same?
        jne     has_changed     ;no
        cmp     bx,prev_value+2 ;still the same?
        je      clear_window    ;yes
has_changed:                    ;new value.  save new field value and
        call    save_major      ;alert user by changing window background color

clear_window:
;-------clear the screen window and set the background color
        mov     al,20h                  ;get a blank
        mov     ah,byte ptr attrib      ;pick up window color byte
        mov     di,corner1      ;where to start clearing
        mov     cx,winddep      ;n'lines in window
        call    sync_cga        ;avoid flicker during writes if CGA display
clrline:
        push    cx              ;save line count
        mov     cx,windwid      ;width of window
clrbyte:
        mov     word ptr es:0[di],ax    ;clear one screen position
        inc     di
        inc     di
        loop    clrbyte         ;loop for all positions this line
        add     di,160-(windwid*2)      ;point to next line of window
        pop     cx              ;all window lines cleared?
        loop    clrline         ;no

;-------move blob from left to right on top line to indicate timer-tick rate
show_blob:
        mov     bx,tick_count   ;blob's next position on the line
        mov     byte ptr es:out1[bx],blob       ;get timer-tick character
        inc     bx
        inc     bx              ;compensate for double spacing in video buffer
        cmp     bx,max_tick*2   ;have we reached the extreme right?
        jna     same_cycle      ;not yet
        xor     bx,bx           ;yes, restart blob at leftmost position
same_cycle:
        mov     tick_count,bx

;-------for the curious, display count of entries to this routine
show_count:
        mov     ax,entry_count
        inc     ax
        jnz     no_overflow
        inc     byte ptr count_carry
no_overflow:
        mov     entry_count,ax

        mov     di,out2
        mov     ah,byte ptr count_carry
        call    cvtbh
        call    putchar
        mov     ah,byte ptr entry_count+1
        call    cvtbh
        call    putchar
        mov     ah,byte ptr entry_count
        call    cvtbh
        call    putchar

;-------get address of routine interrupted when timer went off
;-------by pointing into entry-time stack for its cs:ip
        push    ss_save
        push    sp_save
        pop     si
        pop     ds
        assume  ds:nothing
        add     si,2            ;point to saved cs:ip in stack
        mov     di,out5         ;where to display it
        call    disp_addr

;-------display the control block of major interest
show_major:
        mov     ax,intvect+2
        mov     ds,ax           ;set ds to segment to display
        mov     si,intvect      ;offset to display
        mov     di,out3         ;where to display it
        call    disp_addr

;-------display any control blocks of secondary interest here...
show_minor:
        mov     ax,intvect2+2
        mov     ds,ax           ;set ds to segment to display
        mov     si,intvect2     ;offset to display
        mov     di,out4         ;where to display it
        call    disp_addr

;-------done.  restore the registers
        pop     es
        pop     ds
        pop     si
        pop     di
        pop     bp
        pop     dx
        pop     cx
        pop     bx
        pop     ax
        cli                     ;no interrupts during upcoming stack-switch
        mov     ss,cs:ss_save
        mov     sp,cs:sp_save
        popf
        jmp     cs:old_vect     ;pass control to the routine we unhooked

;-------subroutines...

;-------handle a change to the value of the field we're watching:
;-------1) save the new value
;-------2) switch to the next color
save_major      proc    near
        push    ax
        push    bx
        push    ds
        assume  ds:nothing
        lds     bx,dword ptr intvect    ;load dword pointer into ds:bx
        mov     ax,ds:[bx]      ;first 2 bytes to save
        mov     bx,ds:[bx+2]    ;next 2 bytes
        pop     ds
        assume  ds:cseg
        mov     prev_value,ax   ;save new value
        mov     prev_value+2,bx ;...

next_color:                     ;switch to the next background color
        lea     bx,table_mono   ;assume mono screen
        test    flags,mono      ;is it?
        jnz     test_max        ;yup
        lea     bx,table_color
test_max:
        mov     ax,change_index
        inc     ax
        cmp     ax,max_change   ;have we used up all the colors yet?
        jng     get_next_attrib ;no
        xor     ax,ax           ;yes, restart with the first
get_next_attrib:
        add     bx,ax           ;point to new attribute char
        mov     bl,ds:0[bx]     ;pick it up
        mov     attrib,bl       ;stash it for others to find
        mov     change_index,ax ;save index for next time
        pop     bx
        pop     ax
        ret
save_major      endp

;-------if using a CGA display, synchronize to avoid flicker
sync_cga        proc    near
        test    cs:flags,sync   ;did user tell us we're on a CGA?
        jz      sync_ret        ;no, just return to caller
        push    ax
        push    dx
        mov     dx,03dah        ;CGA status register
;-------the first 4 lines of code below seemed like a good idea,
;-------but the CGA flicker goes away without them (on an 8MHz AT),
;-------so they're commented out.
;ync_loop_1:
;;;;;;;;in      al,dx           ;wait until outside of vertical sync pulse
;;;;;;;;test    al,08h
;;;;;;;;jnz     sync_loop_1
sync_loop_2:
        in      al,dx           ;now wait for start of new sync pulse
        test    al,08h
        jz      sync_loop_2
        pop     dx
        pop     ax
sync_ret:
        ret
sync_cga        endp

;-------display an address in seg:offset form
;               ds:si points to the address to display
;               es:di is where in the video buffer to put the result
disp_addr       proc    near
        mov     ah,byte ptr ds:3[si]    ;segment
        call    cvtbh
        call    putchar
        mov     ah,byte ptr ds:2[si]
        call    cvtbh
        call    putchar

        mov     byte ptr es:[di],':'    ;semicolon

        add     di,2
        mov     ah,byte ptr ds:1[si]    ;offset
        call    cvtbh
        call    putchar

        mov     ah,byte ptr ds:0[si]
        call    cvtbh
        call    putchar
        ret
disp_addr       endp

;-------convert the byte in ah to ascii hex and pass result back in ax
hextabl db      '0123456789ABCDEF'      ;the hex alphabet
cvtbh   proc    near
        push    bx              ;save
        mov     al,ah           ;duplicate the argument byte
        shr     ah,1            ;shift left nybble over by 4
        shr     ah,1            ; ...
        shr     ah,1            ; ...
        shr     ah,1            ; ...
        and     ax,0f0fh        ;yields two indices into hex table
        xor     bx,bx           ;get a zero
        mov     bl,ah                   ;index value for left nybble
        mov     ah,cs:hextabl[bx]       ;pick up corresponding table char
        mov     bl,al                   ;index for right nybble
        mov     al,cs:hextabl[bx]       ;pick up table char
        pop     bx              ;restore
        ret                     ;return with the answer in ax
cvtbh   endp

;-------put a pair of ascii hex digits into video buffer
putchar proc    near
        mov     es:0[di],ah
        mov     es:2[di],al
        add     di,4            ;bump index as a convenience to caller
        ret
putchar endp

stack_bottom    dw      0fefeh          ;stack underrun sentinel
stack   db      50  dup('STACK ')       ;our own stack, probably too big
resident_paras  equ     ($-1-cseg)/16           ;padding to bring us to...
                org     (resident_paras+1)*16   ;next doubleword boundary
stack_end       equ     $                       ;end of resident code


        page
;-------begin one-time initialization code...
init:
        assume  cs:cseg,ds:cseg,es:cseg,ss:cseg

;-------see if any parms given:
                                ;  M   use Monochrome display
                                ;  C   use Color display
                                ;  S   Synchronize to avoid CGA flicker
                                ;  R   Remove (unhook) an active copy of STROBE

        mov     ah,'R'          ;look for 'R'emove
        call    parmchk
        jne     chk_parm_2      ;not found
        jmp     remove

chk_parm_2:
        mov     ah,'M'          ;look for 'M'ono
        call    parmchk
        je      setup_mono      ;found

        mov     ah,'S'          ;look for 'S'ync
        call    parmchk
        jne     chk_parm_3      ;not found
        or      flags,sync

chk_parm_3:
        mov     ah,'C'          ;look for 'C'olor
        call    parmchk
        je      setup_color     ;found

;-------no user screen-choice, so default to the active screen
        int     011h            ;ask BIOS what equipment we have
        and     al,not 030h     ;isolate screen bits
        cmp     al,030h         ;video mode = mono?
        jne     setup_color     ;no

setup_mono:
        or      flags,mono      ;set up for monochrome display
        mov     vidseg,vidsegm  ;...
        jmp     short finish

setup_color:
        or      flags,color     ;set up for color display
        mov     vidseg,vidsegc  ;...

finish:
;-------release our copy of the environment
        push    es              ;save es
        mov     ax,env_seg      ;point es to our copy of the environment
        mov     es,ax           ;...
        mov     ah,49h          ;subfunction = free allocated memory
        int     21h             ;do it
        pop     es              ;restore es

        call    save_major      ;save comparand & set up initial window color

;-------save current interrupt 08 vector; set up to intercept its interrupts.
;-------note that although a copy of us may already be resident, we don't care:
;-------the copy will get a turn to do its stuff (hopefully in another window)
        xor     ax,ax           ;get a zero
        mov     ds,ax           ;point ds to interrupt vectors
        assume  ds:nothing
        cli                     ;no interrupts just now

        mov     di,ds:clkvect   ;pick up offset that's there now
        mov     es:old_ofs,di   ;stash it
        lea     ax,timer_int    ;our own interrupt handler offset
        mov     ds:clkvect,ax   ;replace the old offset

        mov     ax,ds:clkvect+2 ;pick up segment that's there now
        mov     es:old_seg,ax   ;stash it
        mov     ds:clkvect+2,cs ;replace the old segment address

        sti                     ;enable interrupts again

;-------terminate and stay resident
        lea     dx,stack_end    ;get size of resident portion
        shr     dx,1            ;convert to paragraphs
        shr     dx,1
        shr     dx,1
        shr     dx,1
        mov     ah,31h          ;subfunction = tsr
        xor     al,al           ;exit code = zero
        int     21h             ;exit

;-------remove an active copy of ourself by restoring
;-------its saved interrupt vector and freeing its memory
msg_not_hooked  db      'No active copy of STROBE was found',0dh,0ah,'$'
remove:
;-------we can only do this if interrupt 08 vector points to a copy of us
        xor     ax,ax
        mov     es,ax
        assume  es:nothing

        mov     ax,es:clkvect+2 ;ax = cs of interrupt handler
        mov     es,ax           ;point es to potential copy of us
        lea     si,prog_id      ;point to our program id and version
        mov     di,si
        mov     cx,id_end-prog_id       ;number of bytes that must match
        cld                     ;left-to-right, please
rep     cmpsb                   ;is it a copy of us?
        jne     nocando         ;no
        xor     ax,ax           ;yes, unhook it from interrupt 08 chain
        mov     ds,ax
        assume  ds:nothing
        cli
        mov     ax,es:old_seg   ;restore interrupt vector the copy of us saved
        mov     ds:clkvect+2,ax
        mov     ax,es:old_ofs
        mov     ds:clkvect,ax
        sti
;-------release memory occupied by copy we just unhooked
        mov     ah,49h          ;subfunction = free allocated memory
        int     21h             ;do it (es still points to the copy)
        jmp     short exit_remove       ;all done.
nocando:
        lea     dx,msg_not_hooked
        push    cs              ;be sure we have a good ds
        pop     ds              ;...
        mov     ah,09h          ;subfunction = output to display
        int     21h             ;display the msg
exit_remove:
        ret                     ;exit program

;-------subroutines...

;-------search for a user parm matching the character in ah
parmchk proc    near
        xor     ch,ch
        mov     cl,parm_len     ;length of parm list
        jcxz    not_found
        mov     al,ah           ;duplicate the argument
        add     al,020h         ;lowercase it
        xor     bx,bx           ;set search index to zero
next_char:
        cmp     al,parm_char[bx]
        je      was_found       ;match; exit leaving zf = on
        cmp     ah,parm_char[bx]
        je      was_found       ;match; exit leaving zf = on
        inc     bx
        loop    next_char
not_found:
        cmp     ah,al           ;set zf = off
was_found:
        ret
parmchk endp

strobe  endp
cseg    ends
        end     begin