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

Assembly Source File | 1986-06-27 | 29KB | 963 lines

     name    plist
    page    78,132
    title    PLIST12 --- Print text file (version 1.2A)

;    Zider Brothers,    San Francisco
;
;    Based on LIST.ASM by Ray Duncan
;
;6.27    Fixed output buffer bug.
;    Added version id on help screen.
;    Added PLIST id to error messages.
;    Fixed automatic computation of remaining available space
;      (courtesy Chris Dunford via Vern Buerg).
;
;6.5.86    Fixed title buffer init to conform to page offset, line
;      width parms.
;    Fixed end-of-input processing (now does not pump out extra
;      line with pg_offset pad plus line feed)
;
;6.4.86    Add /7 option to strip hi-bit (make ok 8-bit the default now)
;    Enlarged I/O buffers to max space available (64K assumed - may
;      blow system if full 64KB not available for code).
;    DEL char (07Fh or 127 decimal) is now treated as low-order control
;      character.
;    Add /b option for blanks substituted for low-order control chars
;      (Default is that non-special treatment control chars are discarded
;      from the output listing stream to keep output devices from
;      interpreting WordStar embedded print control chars).
;    Change default output file to zz.spl (from zz.lst).
;    Speed on AT 6/1 around 90-100K bps, and about 11-17,000 lines per minute.
;
;5.8.85    Add std    error out for error messages
;    Disable    code that toggles lpi, cpi on exit if parm was exercised
;    Change to COM file format
;    Input buffer moved to end, fill    above program
;    Change input block size    to 4096    bytes (for DOS 2.0 hard    disk)
;    Conversion speed from 14K bps to 19K bps, depending on tabs expansion
;    Make ZZ.LST the default (file) output--21K-24K bps (bits per second)
;
;5.7.85    Make compressed, 8 lpi the default (using IBM PC Graphics printer)
;    Add /N option to get uncompressed print    ("normal" print)
;    Exit print without changing settings if    none set, toggle back if set
;    Disable    FF bracketing, make no FF's at begin/end the default
;    Add /F switch to enable    lead-in    FF (tail end still disabled)
;    Add /S switch to print to std output device (so    can redirect to    file)
;    Change name to PLIST to    avoid confusion    with LIST545, etc by Vern Buerg
;    Add syntax, options help when null command line    tail
;    Add page offset    of 8 spaces
;    Added clarifying comments, code section identification breaks.
;
;5.6.85    Hack to    add 8 Lines Per    Inch option (/8)
;
;-----original documentation:
;
; LIST --- a utility to    print out text files with titles and page
; numbers on  the current list device.    The high bit of    all
; characters is     stripped [this option now must be specified on the command
; line with the /7 option], so that raw Wordstar or other word
; processing files can    be listed.  Embedded form feed codes are
; recognized, and tabs are  expanded.  Unknown control codes (such
; as the ^B and    ^U codes found in Wordstar documents) are discarded.
; If using an Epson printer, compressed    mode can be turned on with
; /C switch in command so that lines up    to 128 characters long will
; fit on a normal page.     Requires PC-DOS 2.0 or    MS-DOS 2.0.

; Used in the form:
; A>LIST path\filename.ext  ["title text"]  [/C]
; (items in square brackets are    optional)

; version 1.0    February 28, 1984
; Copyright (c)    1984 by    Ray Duncan
; May be freely    reproduced for non-commercial use.

cr    equ    0dh        ;ASCII carriage    return
lf    equ    0ah        ;ASCII line feed
ff    equ    0ch        ;ASCII form feed
eof    equ    01ah        ;End of    file marker
tab    equ    09h        ;ASCII tab character
blank    equ    20h        ;space character

command        equ    80h    ;buffer    for command tail

prog_size    =    offset end_code        ; s/b about 09f6h
end_segment    equ    0ffffh
stack_space    equ    100h
avail        =    end_segment-(offset end_code - cseg) - stack_space
;avail2        =    end_segment-prog_size-stack_space    ;gives error
        public    buf_size
;buf_size    equ    1024
buf_size    equ    avail/2
        public    output_buffer
output_buffer    equ    prog_size+buf_size
chk_stack    equ    output_buffer+buf_size+1
stack_start    equ    end_segment-stack_space+1

inblksize    equ    buf_size
outblksize    equ    buf_size
;inblksize    equ    8192    ;size of block reads from input    file
;outblksize    equ    8192    ;size of block writes to output file
pg_offset    equ    8    ;set page offset to 8 spaces
linesize equ    132-pg_offset    ;maximum length    of output line
page6lpi    equ    58    ;58 out of 66 lines
page8lpi    equ    80    ;80 of of 88 lines
heading_lines    equ    3    ;number    of lines in page heading

std_out        equ    1    ;standard output
std_error    equ    2    ;standard error--not redirectable
std_printer    equ    4    ;standard printer
    page
cseg    segment    para public 'CODE'

;old assume:
;    assume    cs:cseg,ds:data,es:data,ss:stack
    assume    cs:cseg,ds:cseg,es:cseg,ss:cseg
    org    100H
ENTRY:    jmp    start
;
;DATA area at end of the program.
;
who_am_i    db    'PLIST12: Zider Brothers, San Francisco'
start:
list    proc    far        ;entry point from PC-DOS

    push    ds        ;save DS:0000 for final
    xor    ax,ax        ;return    to PC-DOS
    push    ax

list13:                ;make sure we're running under DOS 2.0.
    mov    ah,30h
    int    21h
    cmp    al,2
    jae    list01        ;proceed, DOS 2.0 or greater
    mov    dx,offset msg3    ;DOS 1.x --- print error message
    mov    cx,msg3_len
    jmp    list9


;----------------------------------------------------------
;        Process command line

list01:    call    get_title    ;get listing title from
                ;command line tail.
    call    get_switch    ;look for /C, /N, /6, /8, etc switches,    if any
    call    get_filename    ;get path and file spec. for
                ;input file from command line tail.

    jnc    list15        ;jump, got acceptable name.
    mov    dx,offset msg2    ;missing or illegal filespec,
    mov    cx,msg2_len
    jmp    list9        ;print error message and exit.

;----------------------------------------------------------
;        Open input file

list15:    call    open_input    ;now try to open input file
    jnc    list2        ;jump,opened input ok
    mov    dx,offset msg1    ;open of input file failed,
    mov    cx,msg1_len
    jmp    list9        ;print error msg and exit.

;----------------------------------------------------------
;        Open output file

list2:
    cmp    s_switch,0    ;output    to std out?
    jne    list25        ;jump if DOS std output    selected
    call    open_zzlst    ;open default output file
    jnc    list25        ;skip if ok open
    mov    dx,offset zzmsg    ;opening default file error
    mov    cx,zzmsg_len
    jmp    list9        ;print error msg and xit.

;----------------------------------------------------------
;        Initialization

list25:    call    init_buff    ;initialize input deblocking buffer

;----------------------------------------------------------
;        Set page, printer configuration

list20:    test    compress_switch,-1 ;was    /C switch found?
    jz    list21
    call    compress_on    ;yes,turn on compressed    print mode
list21:    test    ate_lpi,-1    ;/8 switch found?
    jz    list22
    call    ate_on
list22:    test    six_lpi,-1    ;/6 switch found?
    jz    list23
    call    six_on
list23:    test    norm_switch,-1    ;was /N    switch found?
    jz    list3
    call    compress_off

;===============================================================;
;        Main program control loop            ;
;                                ;

;----------------------------------------------------------
;        Process character input stream

list3:
    call    get_char    ;read 1    character from input.
    cmp    al,20h        ;is it a low-order control code?
    jb    short list30    ;yes, go check out what kind.
    cmp    al,07fh        ;not low-order, pivot on DEL char (127 decimal)
    jb    list4        ;ok char, write to list device.
    je    short list30    ;treat it like low-order control char.

mod1    label    word
    nop            ;high bit is set on char = upper 128 chars.
    nop            ;..two bytes here may be modified to
                ;  'and  al,07h' by /7 option to strip hi-bit.
                ;  Otherwise code falls through to jmp:
    jmp    list4        ;now write to list device.

list30:    cmp    al,tab        ;is it a tab command?
    je    list5        ;yes,jump to special processing.
    cmp    al,cr        ;carriage return?
    jne    list31        ;
    mov    column,0    ;carriage return, store it into output
    jmp    list45        ;  string and initialize column count.
list31:    cmp    al,lf        ;is it a line feed?
    je    list7        ;yes,jump to special processing. (force print)
    cmp    al,ff        ;is it a form feed?
    je    list6        ;yes, jump to special processing.
    cmp    al,eof        ;is it end of file marker?
    je    list8        ;yes,jump to close files.
    test    blank_sub,-1    ;substitute blank char for control char?
    jz    list32        ;no
    mov    al,blank    ;yes, replace ctl char with blank
    jmp    list4        ;now write to list device
list32:    jmp    list3        ;none of the above--ignore it and get another

;----------------------------------------------------------
;        Special tab expansion

list5:                ;process tab character
    mov    ax,column    ;let DX:AX=column count
    cwd
    mov    cx,8        ;divide    it by eight...
    idiv    cx
    sub    cx,dx        ;remainder is in DX.
    add    column,cx    ;update    column pointer.
list55:                ;8 minus the remainder
    push    cx        ;gives us the number of
    mov    al,20h        ;spaces    to send    out to
    call    put_char    ;move to the next tab position
    pop    cx        ;restore space count
    loop    list55
    jmp    short list3    ;get next character

;----------------------------------------------------------
;        Form feed processing

list6:                ;form feed detected
    call    write_maybe    ;if anything waiting in    output
                ;buffer, print it first
    call    print_heading    ;new page and print title
    jmp    list3        ;get next character from input

;----------------------------------------------------------
;        Put character into output line buffer

list4:
    inc    column        ;bump line char count

list45:                ;write this character into
    call    put_char    ;forming output    string.
                ;is output buffer about    to overflow?
    cmp    linput_ptr,linesize-1
    je    list7        ;yes, force print of buffer.
    jmp    list3        ;no, get next char. from input file.

;----------------------------------------------------------
;        Line feed  char or line full, flush line buffer

list7:                ;line feed detected, interpreted
                ;as print command.
    call    heading_maybe    ;print heading if needed
    call    write_line    ;print contents    of text    buffer
    jmp    list3        ;get more from input file

;----------------------------------------------------------
;        End of file processing

list8:                ;end of    file detected  (^Z, 1AH)
    call    close_input    ;close input file
    call    write_maybe    ;print anything    that's waiting
                ;in output buffer.

;disable end of    job form feed check and form feed output:
;    cmp    ff_switch,0    ;see if    FF's have been specified
;    je    list81        ;skip it if /F not set
;    mov    al,ff        ;send form feed    to finish listing.
;list81:
;    call    put_char

;     call    write_line    ;why need? already called write_maybe
    call    flush_out    ;flush output buffer
    call    close_output    ;close output file
    jmp    list85        ;skip following    code

;disable this exit code--leave printer in mode(s) selected by cmd line parms:
;                ;turn off compressed print mode,
;                ;if it was enabled.
;    test    compress_switch,-1
;    jz    list82
;    call    compress_off
;list82:    cmp    norm_switch,0
;    je    list83
;    call    compress_on
;list83:    cmp    ate_lpi,0
;    je    list84
;    call    six_on
;list84:    cmp    six_lpi,0
;    je    list85
;    call    ate_on

list85:
    ret            ;now return to PC-DOS.

;----------------------------------------------------------
;        Error: program termination
;
;DX    offset to error message
;CX    length of error message

error_out:
list9:                ;come here to print error message
    mov    bx,std_error
    mov    ah,40H
    int    21H
    mov    bx,std_error
    mov    cx,hlpmsg_len
    mov    dx,offset hlpmsg    ;help with syntax added    here
    mov    ah,40H
    int    21H
    ret            ;return to DOS

list    endp

;                                ;
;        End of main program control loop           ;
;===============================================================;

page

;----------------------------------------------------------
;        Get filename

get_filename proc near        ;process name of input file
                ;DS:SI <- addr command line
    mov    si,offset command
                ;ES:DI <- addr filespec    buffer
    mov    di,offset input_name
    cld
    lodsb            ;any command line present?
    or    al,al        ;return    error status if    not.
    jz    get_filename4
get_filename1:            ;scan over leading blanks
    lodsb            ;to file name
    cmp    al,cr        ;if we hit carriage return
    je    get_filename4
    cmp    al,'/'        ;or switch,
    je    get_filename4
    cmp    al,'"'          ;or quote mark, filename missing.
    je    get_filename4    ;so go return error flag.
    cmp    al,20h        ;is this a blank?
    jz    get_filename1    ;if so keep scanning.
get_filename2:            ;found first char of name,
    stosb            ;move last char. to output
                ;file name buffer.
    lodsb            ;check next character, found
    cmp    al,cr        ;carriage return yet?
    je    get_filename3    ;yes,exit with success code.
    cmp    al,'"'          ;same if quote encountered.
    je    get_filename3
    cmp    al,20h        ;is this a blank?
    jne    get_filename2    ;if not    keep moving chars.
get_filename3:            ;exit with carry =0
    clc            ;for success flag
    ret
get_filename4:            ;exit with carry =1
    stc            ;for error flag
    ret
get_filename endp

;----------------------------------------------------------
;        Get title

get_title proc near        ;process title for listing
                ;DS:SI <- addr command line
    mov    si,offset command
                ;ES:DI <- addr page heading buffer
    mov    di,offset heading1
    add    di,pg_offset    ;mov pointer into buf by page offset amt
    cld
    lodsb            ;any command line present?
    or    al,al        ;no,exit
    jz    get_title3
get_title1:            ;scan for leading <"> to find title.
    lodsb
    cmp    al,cr        ;if we hit carriage return,
    je    get_title3    ;title text is missing.
    cmp    al,'"'          ;found delimiter?
    jne    get_title1    ;if so keep scanning.
get_title2:            ;get next char.    of title.
    lodsb
    cmp    al,'"'          ;terminate if 2nd <"> delimiter
    je    get_title3    ;or carriage return found
    cmp    al,cr
    je    get_title3
    stosb            ;store this char. into page heading buffer
    jmp    get_title2    ;examine next char.
get_title3:
    ret
get_title endp

;----------------------------------------------------------
;        Get switch

get_switch proc    near        ;Scan the input    line for a "/"
                ;delimiting a switch, then make
                ;sure it is legal "/C" or "/c".
                ;If legal switch found,    set
                ;variable COMPRESS_SWITCH true.
                ;Also check for    /8 for 8 lines per inch
                ;        /6 for 6 lines per inch
                ;        /N for normal (uncompressed)
                ;        /S for std out
    mov    ax,std_printer    ;set default output device to printer
    mov    output_handle,ax
    mov    si,offset command+1  ; DS:SI = addr of command line
get_switch1:            ;look for "/" character
    lodsb
    cmp    al,cr        ;if we run into    a carriage return,
    jnz    gsw1        ;not cr
    jmp    get_switch2    ;is cr,switch missing so take normal exit.
gsw1:    cmp    al,'/'
    jne    get_switch1    ;not '/' yet, keep looking.
    lodsb            ;found '/', pick up next char.
chk_8:    cmp    al,'8'        ;8 lines per inch?
    jne    chk_6
    mov    es:ate_lpi,-1    ;set 8 lines per inch switch
    jmp    get_switch1    ;check for more    options
chk_6:    cmp    al,'6'        ;6 lines per inch?
    jne    chk_7
    mov    es:six_lpi,-1    ;set 6 lines per inch switch
    jmp    get_switch1    ;check for more    options
chk_7:    cmp    al,'7'        ;7-bits only? (strip high bit)
    jne    chk_b
    mov    es:sept_bits,-1    ;set for 7-bit output only (flag not used..
                ;  ..used self-modifying code instead:
    mov    ax,cs:and_w    ;move op to in-line code location
    mov    cs:mod1,ax    ;                    )
    jmp    get_switch1    ;check for more options
and_w    label    word        ;and-operator
and_op:    and    al,07fh        ;strip hi-bit op code bytes

chk_b:    cmp    al,'b'        ;b=blank sub for low control chars
    jne    chk_c
    mov    es:blank_sub,-1    ;set for blank
    jmp    get_switch1    ;check for more options
chk_c:    or    al,20h        ;and fold to lower case.
    cmp    al,'c'        ;c=compress
    jne    chk_n        ;not /C, check for /N
                ;set compress switch
    mov    es:compress_switch,-1
    jmp    get_switch1    ;check for more    options
chk_n:    cmp    al,'n'        ;n=normal
    jne    chk_f        ;not n,    check for /F
    mov    es:norm_switch,-1
    jmp    get_switch1    ;check for more    options
chk_f:    cmp    al,'f'        ;f=bracket print with FF's
    jne    chk_s
    mov    es:ff_switch,-1
    jmp    get_switch1    ;check for more    options
chk_s:    cmp    al,'s'        ;/S
    jne    get_switch2    ;not f,    jump to    return
    mov    es:output_handle,std_out    ;set output to std out
    mov    es:s_switch,-1
    jmp    get_switch1    ;check for more    options

get_switch2:
    ret            ;exit
get_switch endp

;----------------------------------------------------------
;        Open input file

open_input proc    near        ;open input file
                ;DS:DX=addr filename
    mov    dx,offset input_name
    mov    al,0        ;AL=0 for read only
    mov    ah,3dh        ;function 3dh=open
    int    21h        ;handle    returned in AX,
    mov    input_handle,ax    ;save it for later.
    ret            ;CY is set if error
open_input endp

;----------------------------------------------------------
;        Open default output file

open_zzlst    proc    near    ;open default output file
;This will open    an existing file if it exists
    mov    dx,offset zzlst    ;ASCIIZ    string of default output file name
    mov    al,1        ;open file for writing
    mov    ah,3dh        ;open a    file
    int    21h
    jc    ozz1        ;if CY, check if not found
savozz:    mov    output_handle,ax
    mov    zzlst_handle,ax    ;in case we need it
;move to the end of the file for default file append
    mov    bx,ax        ;handle to BX for LSEEK
    mov    cx,0
    mov    dx,0
    mov    al,2        ;to end of file plus offset of zero (CX:DX)
    mov    ah,42h        ;LSEEK call (what's an LSEEK???)
    int    21h        ;CY may be set here if invalid handle or function

ozzxit:    ret            ;carry will be set if error

    public ozz1
ozz1:    cmp    ax,2        ;if =2, then file not found and must be created
    jne    ozz9
    mov    dx,offset zzlst    ;in case trashed by DOS
    mov    cx,20h        ;creating normal file
    mov    ah,3ch        ;create file call
    int    21h
    jnc    savozz        ;ok create if no CY

ozz9:    stc            ;other error (too many handles or access denied)
    ret
open_zzlst    endp

;----------------------------------------------------------
;        Initialize buffers

init_buff proc near        ;initialize input buffer
    call    read_block    ;read 1st block    of input file
    mov    linput_ptr,pg_offset    ;initialize pointer to output string
    ret
init_buff endp

;----------------------------------------------------------
;        Read input block

read_block proc    near        ;read block of data from input file.
    mov    bx,input_handle
    mov    cx,inblksize
    mov    dx,offset input_buffer
    mov    ah,3fh
    int    21h
    jnc    read_block1    ;jump if no error status
    mov    ax,0        ;simulate a zero length    read if    error
read_block1:
    cmp    ax,inblksize    ;was full buffer read in?
    je    read_block2    ;yes,jump
    mov    bx,ax        ;no, store End-of-File mark
    mov    byte ptr [input_buffer+bx],eof
read_block2:
    mov    input_ptr,0    ;initialize pointer to input buffer.
    ret
read_block endp

;----------------------------------------------------------
;        Set page, printer configuration

compress_on proc near        ;turn on compressed printing mode
                ;by sending command string.
    mov    cx,comp_command_length
    mov    bx,output_handle
    mov    dx,offset comp_command
    mov    ah,40h
    int    21h
    ret
compress_on endp

compress_off proc near            ;turn off compressed printing mode
                    ;by sending command string.
    mov    cx,norm_command_length
    mov    bx,output_handle
    mov    dx,offset norm_command
    mov    ah,40h
    int    21h
    ret
compress_off endp

ate_on    proc    near            ;turn on 8 lpi
    mov    ax,page8lpi
    mov    pagesize,ax
    mov    linecount,ax
    mov    cx,ate_lpi_cmd_len
    mov    bx,output_handle
    mov    dx,offset ate_lpi_cmd
    mov    ah,40H
    int    21H
    ret
ate_on    endp

six_on    proc    near            ;turn on 6 lpi
    mov    ax,page6lpi
    mov    pagesize,ax
    mov    linecount,ax
    mov    cx,six_lpi_cmd_len
    mov    bx,output_handle
    mov    dx,offset six_lpi_cmd
    mov    ah,40H
    int    21H
    ret
six_on    endp


;----------------------------------------------------------
;        Get one character from input buffer

get_char proc    near        ;get one character from    input buffer
    mov    bx,input_ptr    ;is pointer at end of buffer?
    cmp    bx,inblksize
    jne    get_char1    ;no,jump
                ;yes, buffer is    exhausted,
    call    read_block    ;new block must    be read    from disk.
    mov    bx,0        ;initialize buffer pointer.
get_char1:
    mov    al,byte    ptr [input_buffer+bx]
    inc    bx        ;bump input buffer pointer
    mov    input_ptr,bx
    ret
get_char endp

;----------------------------------------------------------
;        Put char into output line buffer

    public    put_char
put_char proc    near        ;put one character into    output buffer
    mov    bx,linput_ptr
    mov    [line_buffer+bx],al
    inc    linput_ptr    ;bump pointer to output    string
    ret
put_char endp

;----------------------------------------------------------
;        Heading maybe--if end of the page

    public    heading_maybe
heading_maybe proc near        ;print heading if the line
                ;count justifies it
    mov    ax,pagesize
    cmp    linecount,ax
    jl    heading_maybe2    ;jump,page not full yet
    call    print_heading    ;form feed (maybe) and print title
heading_maybe2:
    ret
heading_maybe endp

;----------------------------------------------------------
;        Print heading

    public print_heading
print_heading proc near        ;print form feed, title, and page no.
    inc    pagecount    ;bump page number,
    mov    ax,pagecount    ;load it,
    aam            ;and turn it into ASCII,
    add    ax,'00'
    mov    heading2,ah    ;then store into heading string.
    mov    heading2+1,al
                ;now print the heading string.
    cmp    pagecount,1    ;check if first    page heading
    je    chk_ff        ;see if    FF switch was specified
    public    ph2
ph2:    mov    dx,offset heading_buffer    ;header including lead FF
    mov    cx,heading_length
    public    ph3
ph3:
;put these lines  into output buffer now instead:
;    mov    bx,output_handle
;    mov    ah,40h
;    int    21h

    call    put_line

                ;initialize line count
    mov    linecount,heading_lines
    mov    column,0    ;and column counter
    ret

    public chk_ff
chk_ff:    cmp    ff_switch,-1    ;see if    set
    je    ph2        ;if set, jump back
    mov    dx,offset heading_buffer+1    ;not set, skip lead FF on page 1
    mov    cx,heading_length-1
    jmp    ph3

print_heading endp


;----------------------------------------------------------
;        Write maybe--if chars in the output line buffer

write_maybe proc near        ;transmit line to list device, if
                ;output    buffer contains    anything.
    mov    ax,linput_ptr    ;pointer is more than pg_offset if
    cmp    ax,pg_offset    ;characters are waiting in buffer.
;    or    ax,ax        ;
    jz    write_maybe1    ;nothing, jump to exit
    call    write_line    ;something there, send it to printer
write_maybe1:
    ret
write_maybe endp

;----------------------------------------------------------
;        Write line buffer -- put line in output

write_line proc    near        ;transmit contents of output
                ;buffer    to the standard    list device.
    mov    al,lf        ;append    line feed to string.
;    call    put_char    ;insert code directly instead of call
    mov    bx,linput_ptr
    mov    [line_buffer+bx],al
    inc    linput_ptr    ;bump pointer into output line buffer
    mov    cx,linput_ptr    ;CX contains length of string
                ;DX:DX=buffer address
    mov    dx,offset line_buffer

    call    put_line    ;put line into output buffer
;    mov    bx,output_handle;BX=handle for standard    list device is default
;    mov    ah,40h        ;function 40h=write to device.
;    int    21h        ;request service from DOS.


    inc    linecount    ;count lines printed this page.
    mov    linput_ptr,pg_offset    ;reset pointer to list device buffer
    ret
write_line endp

;----------------------------------------------------------
;        Put line into output buffer
;
;DX    ptr to line buffer
;CX    cnt of chars in line to be put

    public    put_line
put_line    proc    near

    cmp    cx,0        ;anything to send?
    je    xit_putlin
put1:    mov    ax,output_ptr    ;get current ptr into output block
    mov    bx,ax        ;set index for destination
    add    ax,cx        ;add the line size to be added
    cmp    ax,outblksize    ;see if we can take it
    jbe    putl2        ;if not, flush the block first
    call    flush_out
    jc    xit_putlin    ;exit if carry (error writing block)
    jmp    put1        ;recycle

putl2:    mov    output_ptr,ax    ;save new ptr (a bit out of order, but available)
    mov    si,dx        ;source into si
    mov    di,offset output_buffer
    add    di,bx        ;dest into di
    cld            ;increment pointers (clear direction flag: fwd)
    rep    movsb        ;do your thing
    clc            ;clear carry to indicate ok return

xit_putlin:
    ret

    public    flush_out
flush_out    proc    near
    push    cx
    push    dx
    mov    cx,output_ptr        ;bytes to write
    mov    dx,offset output_buffer    ;source of bytes
    mov    bx,output_handle    ;file to write them to
    mov    ah,40h            ;DOS Write to File call
    int    21H            ;the old 21H maneuver
    cmp    ax,cx            ;written should equal requested
    jne    error_putlin
    mov    output_ptr,0        ;zero the buffer counter
    clc
flush_xit:
    pop    dx            ;restore registers
    pop    cx
    ret

    public    error_putlin
error_putlin    equ    $        ;here if file write error
    mov    dx,offset msg4
    mov    cx,msg4_len
    mov    bx,std_error
    mov    ah,40h
    int    21h
    stc
    jmp    flush_xit

flush_out    endp

put_line    endp

;----------------------------------------------------------
;        Close input file

close_input proc near        ;close input file
    mov    bx,input_handle    ;BX=handle
    mov    ah,3eh
    int    21h
    ret
close_input endp

;----------------------------------------------------------
;        Close output file

close_output    proc    near    ;close output file
    mov    bx,output_handle
    mov    ah,3eh
    int    21h
    ret
close_output    endp

;Move this to the end:
;cseg    ends

page
;===============================================================;
;        Data area                    ;

;disable data segment setup:
;data    segment    para public 'DATA'

        public    input_name
input_name    db    64 dup (0)    ;buffer    for input filespec

        public    input_handle
input_handle    dw    0        ;token from PCDOS for input file.
        public    output_handle
output_handle    dw    std_printer    ;for printer or    std out
zzlst        db    'ZZ.SPL',0    ;ASCIIZ    string for default output
zzlst_handle    dw    1        ;std file output name, later reset

        public    input_ptr
input_ptr    dw    0        ;pointer into input blocking buffer
        public    linput_ptr
linput_ptr    dw    pg_offset    ;pointer into line blocking buffer
        public    output_ptr
output_ptr    dw    0        ;ptr into output blocking buffer

column        dw    0        ;column    count for tab processing
        public    linecount
linecount    dw    page8lpi    ;line counter, current page.
                    ;(set to "pagesize" initially to
                    ;force first heading on    listing)
pagesize    dw    page8lpi    ;initially at 8    lpi size
        public    pagecount
pagecount    dw    0        ;current page number

compress_switch    dw    0        ;set to    -1 if /C switch
                    ;found in command line tail.

comp_command    db    0fh        ;command string    for compressed mode
comp_command_length equ    $-comp_command

norm_switch    dw    0        ;set to    -1 if /N switch
norm_command    db    12h        ;command string    for normal print
                    ;(actually: turn off compressed)
norm_command_length equ    $-norm_command

ate_lpi        dw    0        ;set to    -1 if /8 switch
ate_lpi_cmd    db    1BH,'0'        ;ESC 0
ate_lpi_cmd_len    equ    $-ate_lpi_cmd

sept_bits    dw    0        ;set to -1 if /7 switch

blank_sub    dw    0        ;set to -1 if /b switch

six_lpi        dw    0        ;set to    -1 if /6 switch
six_lpi_cmd    db    1BH,'2'        ;ESC 2
six_lpi_cmd_len    equ    $-six_lpi_cmd

ff_switch    dw    0        ;set to    -1 if /F switch    (lead FF)
s_switch    dw    0        ;set to    -1 if /S switch    (std out)

msg1        db    cr,lf
        db    'PLIST: cannot find input file.'
        db    cr,lf,'$'
msg1_len    equ    $-msg1-1    ;net of    trailing '$'

msg2        db    cr,lf
        db    'PLIST: missing file name.'
        db    cr,lf,'$'
msg2_len    equ    $-msg2-1

msg3        db    cr,lf
        db    'PLIST: requires PC-DOS version 2.0 or greater.'
        db    cr,lf,'$'
msg3_len    equ    $-msg3-1

msg4        db    cr,lf
        db    'PLIST: error writing output block.'
        db    cr,lf,'$'
msg4_len    equ    $-msg4-1

zzmsg        db    cr,lf
        db    'PLIST: error opening default file ZZ.SPL.'
        db    cr,lf,'$'
zzmsg_len    equ    $-zzmsg-1


hlpmsg        db    cr,lf
        db    'Syntax:  [d\p\]filename.ext ["title text"] [/8/6/b/7/n/c/f/s]',cr,lf
        db    cr,lf
        db    '       /8      print 8 lpi (default)',cr,lf
        db    '       /6      print 6 lpi (66 lines per page)',cr,lf
        db    '       /b      blank substitution for low ctrl chars (default: discard)',cr,lf
        db    '       /7      7-bits print (strip high bit)',cr,lf
        db    '       /c      compressed print (default)',cr,lf
        db    '       /n      non-compressed print (10 cpi)',cr,lf
        db    '       /f      leading Form Feeds added (no trailing in any case)',cr,lf
        db    '       /s      output to std out (screen), else file zz.spl default',cr,lf
        db    cr,lf
        db    'Notes:  no wildcards (*.*)  - use FOR expansion ',cr,lf
        db    '        output dumped into zz.spl on current path - 15,000 lpm on AT',cr,lf
        db    '        Version 1.2A 6.27.86',cr,lf
        db    cr,lf
        db    'Usage:  ',cr,lf,cr,lf
        db    '  C>for %1 in (*.sno) do plist %1 "6.4.86 Snobol4+ source        %1       "',cr,lf
        db    '  C>plist d:t.dta /s >tt',cr,lf
        db    '$'


hlpmsg_len    equ    $-hlpmsg-1    ;not including the '$'


        public    line_buffer
line_buffer    db    pg_offset dup(' ')    ;page offset blank pad
        db    linesize-pg_offset dup (?);buffer used to build    output
                    ;lines for list    device

        public        heading_buffer
heading_buffer    db    ff        ;form feed control code
heading1    db    linesize-pg_offset-7 dup (' ')    ;filled    in with    title from user
        db    'Page '                ;7 chars in Page ##
heading2    db    '00',cr
        db    heading_lines dup (lf)
heading_length    equ    $-heading_buffer

;input_buffer    db    inblksize    dup ('x');deblocking buffer for    input file
        public    input_buffer
        even
end_code    equ    $        ;end of code label
input_buffer    equ    $        ;filled    above program, no cseg
                    ;space required    in .COM    file
;output_buffer    equ    $+inblksize    ;output buffer space
;data segment disabled:
;data    ends

;disable code for stack    segment:
;stack    segment    para stack 'STACK'
;    db    64 dup (?)
;stack    ends

cseg    ends

    end    entry