SPRAY.ASM

comment }
  SPRAY.COM      program copyright Dave Angel  71046,1567.
                 free for anybody, as long as it's not included with
                 commercial software.  Nominal charge (under $6) okay.

  SPRAY.ASM      This file serves as both documentation and source code.
                 The program was written in response to a message by
                 Joe Wallace 21550,6003, who wanted a program to dump
                 memory after an accidental abort of some other program.

                 The program was entered with KEDIT, assembled with MASM
                 5.1, and debugged with SYMDEB.  There are several known
                 simplifications, to keep it small.

                 It only parses the command line to the extent that if the
                 command line is non-blank it gives the copyright message.
                 If run with a blank line, it dumps memory from its own end
                 to the 640k boundary.  If you have some other amount of
                 memory, change the line below containing '**memory' as
                 appropriate.

                 It outputs to standard out, and you have to redirect it if
                 you want it in a disk file.  So you'd run   SPRAY>C:\temp
                 to get it to dump to a file on C: called temp.

                 Finally, it will go somewhat beyond the (640k) limit, as
                 much as 63.9 k beyond.  This is no problem on most
                 systems, you just may get a bit of garbage at the end.
                 But on a few systems you may get funny errors accessing
                 that memory.  If so, the 'nextsegment' logic needs to be
                 tightened up, to handle the final, partial segment.

                 Good luck.  Any suggestions or improvements welcome.
                 Dave Angel  Compuserve 71046,1456    or    Genie   D.Angel
                 July 27, 1989

}
CGROUP  group  CODE
CODE    segment
        org     100h
     assume  cs:CODE, DS:CODE
start   proc    near
        mov     sp,100h
        cmp     byte ptr ds:[80h],0
        jz      start2
        mov     dx,offset CGROUP:helpmessage
        mov     ah,9
        int     21h
        jmp     next2
helpmessage     db    'SPRAY  copyright 1989 by Dave Angel 71046,1567',13,10
                db    '   free software to dump memory to stdout',13,10,'$'

start2:
        mov     di,offset CGROUP:endcode
        mov     si,offset CGROUP:endcode+5  ; source starting address
        cld
        mov     cx,78
        xor     bx,bx           ; bx is count of printables 'in-a-row'
loop1:
        cmp     si,0fff0h
        jb      loop1a
        call    nextsegment        ; call if we're at end of segment
loop1a:
        lodsb                   ; retrieve one byte
        cmp     al,20h
        jb      loop5
        cmp     al,7fh
        ja      loop5           ; skip if unprintable character
;  found a printable character
loop2:
        stosb
        inc     bx
        loop    loop1
; we've printed enough on this line, go to next
loop3:
        mov     al,0dh
        stosb
        mov     al,0ah
        stosb
        call    flushoutput             ; write the data so far
        xor     bx,bx
        loop    loop1

;  We found a non-printable
loop5:
        cmp     bx,3
        ja      loop5a          ; skip if at least 3 printables in a row
        sub     di,bx
        add     cx,bx           ; back up over them, if 3 or less
        jmp     loop5b
loop5a:
        cmp     cx,8
        jb      loop3           ; if near the end of line, make a new one
        mov     al,20h
        stosb
        dec     cx
        stosb           ; otherwise, add two spaces and keep scanning
loop5b:
        dec     cx
loop6:
        xor     bx,bx           ; zero 'printables in-a-row'
        cmp     si,0fff0h
        jb      loop6a
        call    nextsegment        ; call if we're at end of segment
loop6a:
        lodsb
        cmp     al,20h
        jb      loop6
        cmp     al,7fh
        ja      loop6           ; ignore any more unprintables
        jmp     loop2
start   endp

flushoutput     proc    near
;  DI points one beyond last character of buffer.  So write from
;    endcode to one less than DI
        mov     cx,di
        mov     dx,offset CGROUP:endcode            ; address
        sub     cx,dx           ; count
        mov     bx,1            ; standard out
        mov     ah,40h
        push    ds
        push    cs
        pop     ds
        int     21h             ; write the line to stdout
        pop     ds
     ; ignore errors
        mov     di,offset cgroup:endcode
        mov     cx,78
        ret
flushoutput     endp


nextsegment     proc    near
;  this routine is only called when SI exceeds FFF0
;  here's where we move to another segment, and check for 640k.  We adjust
;  DS and SI, and return, if still more to do.

        push    bx              ; save bx
        mov     bx,0a000h       ; end of **memory assumed to be A000
        mov     ax,ds
        add     ax,0fffh
        sub     si,0fff0h
        mov     ds,ax
; notice, we're being sloppy here, and dumping as much as 63.9k beyond 640k
        cmp     ax,bx
        jae     next2
        pop     bx              ; restore bx
        ret                     ; return if still more memory to go
next2:
        mov     ax,4c00h
        int     21h
nextsegment     endp
endcode label   byte
CODE    ends
        end     start