Subversion Repositories cpu8080

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

!                                                                              !

!                  IMSAI SCS-1 MONITOR/ASSEMBLER FOR 8080 CPU                  !

!                                                                              !

! This copy was converted to IP assembler, and is modified to run on the       !

! MITS serial I/O board, which had jumper selectable baud rates only.          !

!                                                                              !

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

!

!       page    62

!       title           'imsai scs-1 rev. 2 06 oct. 1976'

!

! MITS serial I/O board equates

!

tts:    equ     $20

tti:    equ     $21

tto:    equ     $21

ttyda:  equ     $01

ttytr:  equ     $80

!

        jmp     inita           ! dead start

        jmp     eor             ! restart monitor

!

        alignp  $08

        jmp     brkp            ! breakpoint restart

!

        alignp  $40

!

! this routine initializes the file aread for subsequent

! processing

!

inita:

        lxi     h,file0

        mvi     c,maxfil*felen

        xra     a

init2:  mov     m,a

        inx     h

        dcr     c

        jnz     init2

!

! clear the breakpoint table

!

        mvi     b,nbr*3

        lxi     h,brt

init3:  mov     m,a

        inx     h

        dcr     b

        jnz     init3

!

! this is the starting point of the self contained

! system once the system has been initialized.  commands

! are read from the user, executed, and control returns

! back to this point to read another command.

!

eor:    lxi     sp,area+18

        call    crlf            ! print c/r, line feed

        call    read            ! read input line

        inx     h

        mov     a,m             ! fetch first character

        cpi     '9'+1           ! command or line number?

        jc      line            ! jump if line for file

        call    valc

        call    comm

        jmp     eor

!

! this routine reads in a line from the tty and places

! it in an input buffer.

! the following are special characters

!   cr          terminates read routine

!   lf          not recognized by routine

!   ctrl x      deletes current line

!   del         deletes characer

! all displayable characters between blank & z and the

! above are recognized by the read routine, all others

! are skipped over.  the routine will not accept more

! characters than the input buffer will hold.

!

read:   lxi     h,ibuf          ! get input buffer address

        shld    adds            ! save address

        mvi     e,2             ! initialize character count

next:   call    in8             ! read a line

        mov     a,b

        cpi     24              ! check for ctrl x

        jnz     cr

        call    crlf            ! output a crlf

        jmp     read

cr:     cpi     ascr            ! get an ascii cr

        jnz     del

        mov     a,l

        cpi     ibuf and $00ff  ! check for first char

        jz      read

        mvi     m,ascr          ! place cr at end of line

        inx     h

        mvi     m,1             ! place eof indicator in line

        inx     h

        mvi     a,ibuf+83 and $00ff

        call    cler            ! clear remaining buffer

        lxi     h,ibuf-1

        mov     m,e             ! save character count

        ret

del:    cpi     127             ! check for delete character

        jnz     char

        mvi     a,ibuf and $00ff

        cmp     l               ! is it 1st character

        jz      next

        dcx     h               ! decrement pointer

        dcr     e               ! decrement count

bspa:   mvi     b,$5f

        call    out8

        jmp     next

char:   cpi     ' '             ! check for legal character

        jc      next

        cpi     'z'+1

        jnc     next

        mov     b,a

        call    out8            ! echo character

        mov     m,b

        mvi     a,ibuf+81 and $00ff

        cmp     l               ! check for end of line

        jz      bspa

        inx     h

        inr     e               ! increment character count

        jmp     next

!

! this routine is used to blank out a portion of memory

!

cler:   cmp     l

        rz

        mvi     m,' '           ! place blank in memory

        inx     h

        jmp     cler

!

! see if tty input ready and check for ctrl x.

!

ink:    in      tts             ! get tty status

        ani     ttyda           ! is data available?

        rnz                     ! return if not

        in      tti             ! get the char

        ani     $7f             ! strip off parity

        cpi     'x'-$40         ! is it a ctrl x?

        ret

!

! this routine reads a byte of data from the usart

!

in8:    in      tts             ! read usart status

        cma                     ! invert status

        ani     ttyda

        jz      in8

        in      tti             ! read data

        ani     127             ! strip off parity

        mov     b,a

        ret

!

! this routine outputs a byte of data to the usart

!

out8:   in      tts             ! read status

        cma                     ! invert status

        ani     ttytr

        jz      out8

ok:     mov     a,b

        out     tto             ! transmit data

        ret

!

! this routine will output a carriage return and

! line feed followed by two delete characters which

! provide time for print head to return.

!

crlf:   mvi     b,13            ! cr

        call    out8

lf:     mvi     b,10            ! lf

        call    out8

        mvi     b,127

        call    out8

        call    out8

        ret

!

! this routine jumps to a location in memory given by

! the input command and begins execution of program

! there.

!

exec:   call    vchk            ! check for parameters

        call    crlf

        lhld    bbuf            ! fetch address

        pchl                    ! jump to program

!

! this routine checks the input command agains all

! legal commands stored in a table.  if a legal command

! is found, a jump is made to that routine.  otherwise

! an error message is output to the user.

!

comm:   lxi     d,ctab          ! command table address

        mvi     b,ncom          ! number of commands

        mvi     a,4             ! length of command

        sta     nchr            ! save

        call    coms            ! search table

        jnz     what            ! jump if illegal command

        pchl                    ! be here now

!

! this routine checks to see if a base character string

! is equal to any of the strings contained in a table

! pointed to by d,e.  the table consists of any number

! of chars, with 2 bytes containing values associated

! with it.  reg b contains the # of strings to compare.

! this routine can be used to search through a command

! or symbol table.  on return, if the zero flag is set,

! a match was found! if not, no match was found.  if

! a match was found, d,e point to the last byte

! associated with the character string.  if not, d,e

! point to the next location after the end fo the table.

!

coms:   lhld    adds            ! fetch compare address

        lda     nchr            ! get length of string

        mov     c,a

        call    sear            ! compare strings

        ldax    d               ! fetch value

        mov     l,a

        inx     d

        ldax    d               ! fetch value

        mov     h,a

        rz

        inx     d               ! set to next string

        dcr     b               ! decrement count

        jnz     coms

        inr     b               ! clear zero flag

        ret

!

! this routine checks to see if two character strings in

! memory are equal.  the strings are pointed to by d,e

! and h,l.  on return, the zero flag set indicates a

! match.  reg c indicates the length of the strings.  on

! return, the pointers point to the next address after

! the character strings.

!

sear:   ldax    d               ! fetch character

        cmp     m               ! compare characters

        jnz     inca

        inx     h

        inx     d

        dcr     c               ! decrement character count

        jnz     sear

        ret

inca:   inx     d

        dcr     c

        jnz     inca

        inr     c               ! clear zero flag

        ret

!

! this routine zeroes out a buffer in memory which is

! then used by other scanning routines

!

zbuf:   xra     a               ! get a zero

        lxi     d,abuf+12       ! buffer address

        mvi     b,12            ! buffer length

zbu1:   dcx     d               ! decrement address

        stax    d               ! zero buffer

        dcr     b

        jnz     zbu1

        ret

!

! this routine calls etra to obtain the input parameter

! values and calls an error routine if an error occured

! in that routine

!

valc:   call    etra            ! get input parameters

        jc      what            ! jump if error

        ret

!

! this routine extracts the values associated with a

! command from the input stream and places them in the

! ascii buffer (abuf).  it also calls a routine to

! convert the ascii hexadecimals to binary and stores

! them in the binary buffer (bbuf).  on return, carry

! set indicates an error in input parameters.

!

etra:   lxi     h,0             ! get a zero

        shld    bbuf+2          ! zero value

        shld    fbuf            ! set no file name

        call    zbuf            ! zero buffer

        lxi     h,ibuf-1

val1:   inx     h

        mov     a,m             ! fetch input character

        cpi     ' '             ! look for first character

        cmc

        rnc                     ! return if no carry

        jnz     val1            ! jump if no black

        shld    pntr            ! save pointer

        call    sblk            ! scan to first parameter

        cmc

        rnc                     ! return if cr

        cpi     '/'

        jnz     val5            ! no file name

        lxi     d,fbuf          ! name follows put in fbuf

        mvi     c,nmlen

val2:   inx     h

        mov     a,m

        cpi     '/'

        jz      val3

        dcr     c

        jm      what

        stax    d               ! store file name

        inx     d

        jmp     val2

val3:   mvi     a,' '           ! get an ascii space

val4:   dcr     c

        jm      done

        stax    d               ! fill in with spaces

        inx     d

        jmp     val4

done:   call    sbl2

        cmc

        rnc

val5:   lxi     d,abuf

        call    alps            ! place parameter in buffer

        mov     a,b             ! get digit count

        cpi     5               ! check number of digits

        cmc

        rc                      ! return if too many digits

        lxi     b,abuf

        call    ahex            ! convert value

        rc                      ! illegal character

        shld    bbuf            ! save in binary buffer

        lxi     h,abuf

        call    norm            ! normalize ascii value

        call    sblk            ! scan to next parameter

        cmc

        rnc                     ! return if cr

        lxi     d,abuf+4

        call    alps            ! place parameters in buffer

        mov     a,b             ! get digit count

        cpi     5               ! check number of digits

        cmc

        rc                      ! return if too many digits

        lxi     b,abuf+4

        call    ahex            ! convert value

        rc                      ! illegal value

        shld    bbuf+2          ! save in binary buffer

        lxi     h,abuf+4

        call    norm            ! normalize ascii value

        ora     a               ! clear carry

        ret

!

! this routine fetches digits from the buffer addressed

! by b,c and converts the ascii decimal digits into

! binary.  up to a 16-bit value can be converted.  the

! scan stops when a binary zero is found in the buffer.

!

adec:   lxi     h,0             ! get a 16 bit zero

ade1:   ldax    b               ! fetch ascii digit

        ora     a               ! set zero flag

        rz                      ! return iff finished

        mov     d,h             ! save current value

        mov     e,l             ! save current value

        dad     h               ! times two

        dad     h               ! times two

        dad     d               ! add in original value

        dad     h               ! times two

        sui     48              ! ascii bias

        cpi     10              ! check for legal value

        cmc

        rc                      ! return if error

        mov     e,a

        mvi     d,0

        dad     d               ! add in next digit

        inx     b               ! increment pointer

        jmp     ade1

!

! this routine fetches digits from the buffer addressed

! by b,c and converts the ascii hexadecimal digits into

! binary.  up to a 16-bit value can be converted.  the

! scan stops when a binary zero is foundin the buffer.

!

ahex:   lxi     h,0             ! get a 16 bit zero

ahe1:   ldax    b               ! fetch ascii digit

        ora     a               ! set zero flag

        rz                      ! return if done

        dad     h               ! left shift

        dad     h               ! left shift

        dad     h               ! left shift

        dad     h               ! left shift

        call    ahs1            ! convert to binary

        cpi     $10             ! check for legal value

        cmc

        rc                      ! return if error

        add     l

        mov     l,a

        inx     b               ! increment pointer

        jmp     ahe1

!

! this routine converts ascii hex digits into binary

!

ahs1:   sui     48              ! ascii bias

        cpi     10              ! digit 0-10

        rc

        sui     7               ! alpha bias

        ret

!

! this routine converts a binary value to ascii

! hexadecimal and outputs the characters to the tty.

!

hout:   call    binh

        lxi     h,hcon

chot:   mov     b,m

        call    out8

        inx     h

        mov     b,m

        call    out8

        ret

!

! this routine does the same as above but outputs a

! blank after the last character

!

hotb:   call    hout            ! convert and output

        call    blk1            ! output a blank

        ret

!

! this routine converts a binary value to ascii

! decimal digits and optputs the characters to the tty

!

dout:   call    bind            ! convert value

        call    hout+3          ! output value (2 digits)

        inx     h

        mov     b,m             ! get last digit

        call    out8            ! output

        ret

!

! this routine outputs a blank

!

blk1:   mvi     b,' '           ! get a blank

        call    out8

        ret

!

! this routine is used by other routines to increment

! the starting address in a command and compare it with

! the final address in the command.  on return, the

! carry flag set indicates that the final address has

! been reached.

!

achk:   lhld    bbuf            ! fetch start address

        lda     bbuf+3          ! stop address (high)

        cmp     h               ! compare addresses

        jnz     ach1

        lda     bbuf+2          ! stop address (low)

        cmp     l               ! compare addresses

        jnz     ach1

        stc                     ! set carry if equal

ach1:   inx     h               ! increment start addresses

        shld    bbuf            ! store start address

        ret

!

! this routine outputs character of a string

! until a carriage return is found

!

scrn:   mov     b,m             ! fetch character

        mvi     a,13            ! carriage return

        cmp     b               ! character = cr?

        rz

        call    out8

        inx     h

        jmp     scrn

!

! this routine converts the binary value in reg a into

! ascii hexadecimal digits and stores them in memory

!

binh:   lxi     h,hcon          ! conversion

        mov     b,a             ! save value

        rar

        rar

        rar

        rar

        call    bin1

        mov     m,a

        inx     h

        mov     a,b

        call    bin1            ! convert to ascii

        mov     m,a

        ret

!

! this routine converts a value to hexadecimal

!

bin1:   ani     $f              ! low 4 bits

        adi     48              ! convert to ascii

        cpi     58              ! digit 0-9

        rc

        adi     7               ! modify for a-f

        ret

!

! this routine converts the binary value in reg a into

! ascii decimal digits and stores them in memory

!

bind:   lxi     h,hcon          ! conversion address

        mvi     b,100

        call    bid1            ! convert hundreds digit

        mvi     b,10

        call    bid1            ! convert tens digit

        adi     '0'             ! get units digit

        mov     m,a             ! store in memory

        ret

!

! this routine converts a value to decimal

!

bid1:   mvi     m,'0'-1         ! initialize digit count

        inr     m

        sub     b               ! check digit

        jnc     bid1+2

        add     b               ! restore value

        inx     h

        ret

!

! legal command table

!

ctab:   defb    'dump'

        defw    dump

        defb    'exec'

        defw    exec

        defb    'entr'

        defw    entr

        defb    'file'

        defw    file

        defb    'list'

        defw    list

        defb    'delt'

        defw    dell

        defb    'assm'

        defw    assm

        defb    'page'

        defw    pagemov

        defb    'cust'

        defw    $2000

        defb    'brek'

        defw    break

        defb    'proc'

        defw    proc

!

! this routine checks if any parameters were entered

! with the command, if not an error message is issued

!

vchk:   lda     abuf            ! fetch parameter byte

        ora     a               ! set flags

        jz      what            ! no parameter

        ret

!

! this routine dumps out the fontents of memory from

! the start to final addresses given in the command.

!

dump:   call    vchk            ! check for parameters

dums:   call    crlf            ! start new line

dum1:   lhld    bbuf            ! fetch memory address

        mov     a,m

        call    hotb            ! output value

        call    achk            ! check address

        rc                      ! return if finished

        mov     a,l             ! is next address

        ani     $0f             ! divisible by 16?

        jnz     dum1

        jmp     dums

!

! this routine will move 256 bytes from 1st address

! given in command to 2nd address in command.

!

pagemov:call    vchk            ! check for parameter

        lda     abuf+4          ! fetch 2nd parameter

        ora     a               ! does 2nd parameter exist?

        jz      what

        lhld    bbuf            ! fetch move to address

        xchg

        lhld    bbuf+2          ! fetch move to address

        mvi     b,0             ! set counter

pag1:   ldax    d

        mov     m,a

        inx     h

        inx     d

        dcr     b               ! decrement counter

        jnz     pag1

        ret

!

! this command initializes the beginning of file address

! and end of file address as well as the file area

! when the file command is used

!

file:   call    crlf

! check for file parameters

        lda     fbuf

        ora     a

        jz      fout            ! no ? go list

        call    fsea            ! look up file

        xchg                    ! pntr in de

        jnz     test

! no entry

        lda     abuf            ! check for param

        ora     a

        jz      wha1            ! no?? - error

! check for room in directory

        lda     fef

        ora     a

        jnz     room

        lxi     h,emes1

        jmp     mess

! entry found are these parameters

test:   lda     abuf

        ora     a

        jz      swaps

        lhld    bbuf

        mov     a,h

        ora     l

        jz      swaps

        lxi     h,emes2         ! no-no can?t do

        jmp     mess            ! it - delete first

! move file name to block pointed to by fread

room:   lhld    fread

        xchg

        lxi     h,fbuf          ! file name pointer in h,l

        push    d

        mvi     c,nmlen         ! name length count

mov23:  mov     a,m

        stax    d

        inx     d

        dcr     c               ! test count

        inx     h

        jnz     mov23

        pop     d               ! restore entry pointer

! make file pointed to by d,e current

swaps:  lxi     h,file0

        mvi     c,felen         ! entry length

swap:   ldax    d

        mov     b,m

        mov     m,a             ! exchange

        mov     a,b

        stax    d

        inx     d

        inx     h               ! bump pointer

        dcr     c               ! test count

        jnz     swap

! check for 2nd parameter

            lda abuf

        ora     a

        jz      foot            ! no second parameter

! process 2nd parameter

        lhld    bbuf            ! get address

        shld    bofp            ! set begin

        shld    eofp            ! set end

        mov     a,l             ! is address zero

        ora     h

        jz      fil35           ! yes

fil30:  mvi     m,1             ! non-zero ? set eof

fil35:  xra     a               ! and max line #

        sta     maxl

        jmp     foot            ! output parameters

fout:   lda     ibuf+4

        cpi     's'             ! is command files?

        mvi     c,maxfil

        jz      foul

foot:   mvi     c,1

! output the # of entries in c

foul:   lxi     h,file0

        mov     a,c

fine:   sta     focnt           ! save count

        push    h

        lxi     d,nmlen

        dad     d

        mov     a,m

        ora     a

        jnz     food

        inx     h

        add     m

        inx     h

        jnz     food            ! non zero, ok to output

        inx     sp

        inx     sp

        inx     h

        inx     h

        jmp     feet

! have an entry to output

food:   pop     h               ! ptr

        mvi     c,nmlen

fast:   mov     b,m             ! load character to b

        call    out8

        dcr     c

        inx     h

        jnz     fast            ! do the rest

! now output begin-end ptrs

        call    fool            ! output begin

        call    fool            ! output end

        call    crlf            ! and c/r

! test count, h,l points past eofp

feet:   lxi     d,felen-nmlen-4

        dad     d               ! move to next entry

        lda     focnt

        dcr     a               ! test count

        jnz     fine            ! more to do

        ret                     ! done!

! output number pointed to by h,l

! on ret, h,l point 2 words later

fool:   call    blk1            ! space

        inx     h

        mov     a,m

        dcx     h

        push    h

        call    hout            ! output

        pop     h

        mov     a,m

        inx     h

        inx     h

        push    h

        call    hotb            ! output

        pop     h               ! restore h,l

        ret

!

! search the file directory for the file

! whose name is in fbuf.

! return if found, zero if off, h,l point to

! entry while searching, on entry found with addr

! zero, set fef to >0 and fread to the addr of entry

!

fsea:   xra     a

        sta     fef             ! claim no free entries

        mvi     b,maxfil        ! count of entries

        lxi     d,file0         ! table address

fse10:  lxi     h,fbuf

        mvi     c,nmlen

        call    sear            ! test strings

        push    psw             ! save flag

        push    d

        ldax    d               ! get bofp

        ora     a               ! empty entry?

        jnz     fse20

        inx     d               ! store other word

        ldax    d

        ora     a

        jnz     fse20           ! nope-go test for match

        xchg

        lxi     d,-nmlen-1

        dad     d               ! move to beginning

        shld    fread           ! save addr

        mov     a,d

        sta     fef             ! set free entry found

        pop     h               ! restore interim ptr

        pop     psw             ! unjunk stack

! move to next entry

fse15:  lxi     d,felen-nmlen

        dad     d

        xchg                    ! next entry in de

        dcr     b               ! test count

        rz                      ! done--nope

        jmp     fse10           ! try next

! entry wasn?t free, test for match

fse20:  pop     h

        pop     psw

        jnz     fse15           ! if zero clear, no match

! entry found

        lxi     d,-nmlen        ! backup

        dad     d               ! h,l points to entry

        mov     a,d

        ora     a               ! clear zero

        ret                     ! that?s all

!

! output error message for illegal command

!

what:   call    crlf            ! out crlf

wha1:   lxi     h,emes          ! message address

mess:   call    scrn

        jmp     eor

!

emes:   defb    'what'

        defb    13

emes1:  defb    'full',13

emes2:  defb    'no no',13

!

! call routine to enter data into memory

! and check for error on return

!

! this routine is used to enter data values into memory.

! each value is one byte and is written in hexadecimal

! values greater than 255 will cause carry to be set

! and return to be made to calling program

!

entr:   call    vchk            ! check for parameters

        call    ents

        jc      what

        call    crlf

        ret

!

eend:   equ     '/'             ! termination character

ents:   call    crlf

        call    read            ! read input data

        lxi     h,ibuf          ! set line pointer

        shld    pntr            ! save pointer

ent1:   call    zbuf            ! clear buffer

        call    sblk            ! scan to first value

        jc      ents            ! jump if cr found

        cpi     eend

        rz                      ! return carry is zero

        call    alps            ! place value in buffer

        mov     a,b             ! get digit count

        cpi     3               ! check nmbr of digits

        cmc

        rc                      ! return if more than 2 digits

        lxi     b,abuf          ! conversion address

        call    ahex            ! convert value

        rc                      ! error in hex character

        mov     a,l

        lhld    bbuf            ! fetch memory address

        mov     m,a             ! put in memory

        call    ach1            ! increment memory location

        jmp     ent1

!

! this routine is used to enter lines into the file

! area.  the line number is first checked to see if it is

! a valid number (0000-9999).  next it is checked to see

! if it is greater than the maximum current line number.

! if it is, the next line is inserted at the end of the

! current file and the maximum line number is updated as

! well as the end of file position.  line numbers that

! already exist are inserted into the file area at the

! appropriate place and any extra characters in the old

! line are deleted.

!

line:   lda     file0           ! is a file defined?

        ora     a

        jz      what            ! abort if not

        mvi     c,4             ! no of digits to check

        lxi     h,ibuf-1                !initialize address

lick:   inx     h

        mov     a,m             ! fetch line digit

        cpi     '0'             ! check for valid number

        jc      what

        cpi     '9'+1

        jnc     what

        dcr     c

        jnz     lick

        shld    adds            ! find address

        lxi     d,maxl+3        ! get address

        call    com0

        jnc     insr

! get here if new line is greater than maximum line #

        inx     h

        call    lodm            ! get new line number

        lxi     h,maxl+3

        call    stom            ! make it maximum line number

        lxi     d,ibuf-1

        lhld    eofp            ! end of file position

        mvi     c,1

        call    lmov            ! place line in file

seof:   mvi     m,1             ! end of file indicator

        shld    eofp            ! end of file address

        jmp     eor

! get here if new line must be inserted into already

! eisting file area

insr:   call    fin1            ! find line in file

        mvi     c,2

        jz      equl

        dcr     c               ! new ln not equal to some old ln

equl:   mov     b,m

        dcx     h

        mvi     m,2             ! move line indicator

        shld    insp            ! insert line position

        lda     ibuf-1          ! new line count

        dcr     c

        jz      less            !new ln not = old ln

        sub     b               !count difference

        jz      zero            !line lengths equal

        jc      more

! get here if # of chars in old line > # of chars in

! new line or new line # was not equal to sold old

! line #

less:   lhld    eofp            !end of file address

        mov     d,h

        mov     e,l

        call    adr             !move to address

        shld    eofp            !new end of file address

        mvi     c,2

        call    rmov            !open up file area

        jmp     zero

! get here if # of chars in old line < # of chars in

! new line

more:   cma

        inr     a               !count difference

        mov     d,h

        mov     e,l

        call    adr

        xchg

        call    lmov            !delete excess char in file

        mvi     m,1             !e-o-f indicator

        shld    eofp            !e-o-f address

! get here to insert line into file area

zero:   lhld    insp            !insert address

        mvi     m,ascr

        inx     h

        lxi     d,ibuf-1                !new line address

        mvi     c,1             !check value

        call    lmov            !place line in file

        jmp     eor

!

! this routine is used to find a ln in the file area

! which is greater than or equal to the current line #

!

find:   lxi     h,abuf+3                !buffer address

        shld    adds            !save address

fin1:   lhld    bofp            !begin file address

        mov     a,h             !return to monitor if

        ora     l               !  file is empty...

        jz      eor

fi1:    call    eo1             !check for end of file

        xchg

        lhld    adds            !fetch find address

        xchg

        mvi     a,4

        call    adr             !bump line address

        call    com0            !compare line numbers

        rc

        rz

fi2:    mov     a,m

        call    adr             !next line address

        jmp     fi1

!

! when searching through the file area, this routine

! checks to see if the current address is the end of

! file

!

eof:    inx     h

eo1:    mvi     a,1             !e-o-f indicator

        cmp     m

        rnz

        jmp     eor

!

! this routine is used to add a value to an address

! contained in register h,l

!

adr:    add     l

        mov     l,a

        rnc

        inr     h

        ret

!

! this routine will move character strings from one

! location of memory to another