Subversion Repositories NedoOS

        DEVICE ZXSPECTRUM128
        include "../_sdk/sys_h.asm"
        include "8080.asm"

;
; Main source driver for CC2.ASM:
;

        ;page 76
        ;title 'CC2.ASM v1.6  3/86'

true:   equ 0ffffh
false:  equ not true

ZSYSTEM equ true
SLRMAC: equ true;false
LASM:   equ not SLRMAC

trs80:  equ false       ;true if TRS-80 (org 4200h) version

ALPHA:  equ false       ;true for Alpha-C version
MARC:   equ false       ;true if MARC version
CPM:    equ not MARC    ;true if CPM version

        if not ZSYSTEM
version: equ '6'        ;the 'x' in 'v1.x'
updatn: equ 0           ;the `y' in `v1.xy'      (number)
updaty: equ 0           ;the `z' in `v1.xyz', or zero if none (character)
        endif

        if ZSYSTEM
version: equ '2'        ;the 'x' in 'vZx.yz'
updatn: equ 0           ;the `y' in `vZx.yz'     (number)
updaty: equ 0           ;the `z' in `vZx.yz', or zero if none (character)
        endif

debug:  equ false
I80:    equ true
I86:    equ false


        IF LASM
        ;sym
        ENDIF


ram:    equ 0           ;start of ram area (either 0 or 4200h) for compiler

cr:     equ 0dh
lf:     equ 0ah

        IF CPM
bdos:   equ ram+5
NEDOOSMEMTOP=0xff00;bdosp:      equ ram+6
fcb:    equ ram+5ch
nr:     equ fcb+32
        ENDIF

tbuff:  equ ram+80h
extbas: equ 0015h       ;external base pointer in C.CCC

fnlen:  equ 12
nestmax: equ 5


        IF CPM
;coninp:                equ 1
;conout:                equ 2
;readbuf:       equ 10
;intcon:                equ 11
;select:                equ 14
openfil:        equ 15
closefil:       equ 16
delete:         equ 19
rsequen:        equ 20
wsequen:        equ 21
makfil:         equ 22
;gdisk:         equ 25
sdma:           equ 26
;sguser:                equ 32
        ENDIF

        org PROGSTART;ram+100h  ;start of TPA
begin   
        ;IF SLRMAC
        include cc2a.asm
        include cc2b.asm
        include cc2c.asm
        include cc2d.asm
        include cc2e.asm
        include "../_sdk/stdio.asm"
        ;ENDIF

;
; Initialization code, placed over table storge not used until
; after completion of initialization
;

c2init:

        IF CPM
        ld de,tbuff
        ld c,sdma
        call bdos       ;set default DMA buffer
        ENDIF

        lda erasub      ;bit 1 of erasub is werrs flag
        ld b,a
        and 2
        sta werrs       ;set werrs
        ld a,b
        and 1
        sta erasub      
        

        ld a,1
        sta prerrs      ;print out errors
        sta entn
        sta codflg      ;enable code generation
        dec a
        sta errf        ;no errors yet
        sta prnflg      ;not inside parentheses
        sta modstc      ;clear module nesting count
        sta errsin

        call clrdir     ;clear 512 byte directory area
        call opsin      ;initailize operator stacks
        call minit      ;adjust macro table for -z optimizations

        call readf      ;read in CCI file, or copy down from hi ram
        shld eofad      ;set EOF address

        ld hl,direc     ;init directory pointer
        shld dirp

        lhld st-4
        push hl
        ld b,3
cc21:   xor a           ;compute # of entries in symbol table
        ld a,h          ;by dividing size of table by 8
        rra
        push af
        and 7fh
        ld h,a
        pop af
        ld a,l
        rra
        ld l,a
        dec b
        jp nz,cc21
        shld stno       ;and store # of entries
        pop hl          ;HL is size of symbol table

        ld de,st        ;get base of sym tab in DE
        add hl,de               ;now HL is base of func name tab
        shld fntb
        ex de,hl                ;put in DE
        lhld st-2       ;get length of sym tab
        add hl,de               ;now HL is start of CCI code
        push hl         ;as well as base of generated code area. Save it
        shld start      ;on stack and at "start"

        dec h           ;compute code area offset, which
        dec h           ; when added to a pointer to an absolute
        call cmh        ; location in generated code during code
        shld cdao       ; generation, yields final addr of that code
                        ; in the generated CRL file.
        pop hl          ;get start of CCI code area
        push hl
        call mvup       ;lde CCI code up to high memory
        shld cdp        ;Save pointer to CCI code at "cdp".
        pop hl          ;get back code area pointer

        lda eflag       ;has -e option been used?
        or a
        jp z,cc22               ;if not, go put zeroes in the first 3 bytes of code

        ld (hl),0bdh    ;else stick in a famous "BD" byte to indicate
        inc hl          ;an explicit external address for CLINK
        ex de,hl
        lhld exaddr     ;get the explicit external address
        ex de,hl
        ld (hl),e
        inc hl
        ld (hl),d
        jp cc23 ;and rejoin the mainstream.
        
cc22:   xor a           ;fill first 3 bytes of 5th sector with zeros
        ld (hl),a               ;if explicit external starting address not given.
        inc hl
        ld (hl),a
        inc hl
        ld (hl),a

cc23:   inc hl
        ex de,hl
        lhld st-6       ;get external data area size
        ex de,hl                ;and put it here at 4th byte of 5th sector
        ld (hl),e
        inc hl
        ld (hl),d
        inc hl
        shld codp       ;save code area pointer

        ld hl,lblt      ;Initialize label table
        shld lblp

        ld hl,modstk    ;initialize module stack
        shld modstp

        call fstgs      ;find the collected text strings

        ld hl,ltab      ;initialize logical conditional branch label table
        shld ltabp      ;(first 5 bytes aren't used, but why play with fire?)

        ld hl,pshptb    ;initialize "push optimization" table
        shld pshpp

        ld hl,8000h     ;and "symbolic label" name (number) generator
        shld lbln

        ld hl,modstk    ;initialize module stack
        shld modstp

        ld hl,0
        shld nlcnt      ;initialize line count
        ret


        IF NOT ALPHA
s0:     db 'BD Software C Compiler'
        ENDIF

        IF ALPHA
s0:     db 'BDS Alpha-C Compiler'
        ENDIF

        IF NOT ZSYSTEM
        db ' v1.'
        db version
        db updatn + '0'
        ENDIF

        IF ZSYSTEM
        db ' (for ZCPR3) vZ'
        db version
        db '.'
        db updatn + '0'
        ENDIF

        db ' (part II)+'

;
; Clear new directory for the CRL file about to be created:
;

clrdir: ld bc,512
        ld hl,direc
clrdr2: ld (hl),0
        inc hl
        dec bc
        ld a,b
        or c
        jp nz,clrdr2
        ret


        if 1==0 ;killed by a bug!!!
;
; Initialize operator stack and operand
; information stack:
;

opsin:  push hl
        ld hl,opstk
        shld opstp
        ld (hl),0ffh
        ld hl,infstk
        shld infsp
        pop hl
        ret
        endif

;
; Read in the CCI file from disk, or lde it down from high
; memory if left there by CC1:
;

readf:  lda chainf              ;chained to from CC1?
        or a

        IF CPM
          jp z,readf0           ;if not, load cci file under CP/M
        ENDIF

        lhld curtop             ;yes. copy down to low ram
        ld de,-35
        add hl,de
        push hl                 ;save last addr + 1
        ld a,(hl)
        inc hl
        ld h,(hl)
        ld l,a                  ;HL = first address
        inc hl                  ;or rather, it does now
        ld b,h
        ld c,l                  ;BC = 1st address of text
        ld a,st/256             ;make sure we have enough room...
        cp b                    ;hi byte of symbol table area must be less 
        jp nc,rdf4              ;than high byte of cci code area

        call cmh
        pop de
        add hl,de
        ex de,hl                        ;DE = length
        ld hl,st-6              ;HL = destination
rloop:  ld a,(bc)
        ld (hl),a
        inc hl
        inc bc
        dec de
        ld a,d
        or e
        jp nz,rloop
        shld eofad      ;save end address
        ld (hl),1ah
        ret


readf0:
        IF CPM
        ld hl,fcb+9
        ld (hl),'C'
        inc hl
        ld (hl),'C'
        inc hl
        ld (hl),'I'

        call fopen

        ld hl,st-6
rdf2:   call reads
        jp nc,rdf2a
        call fclose
        ret

rdf2a:  ld de,tbuff
        ld b,80h
rdf3:   ld a,(de)
        ld (hl),a
        inc hl
        inc de
        dec b
        jp nz,rdf3

        lda curtop+1
        ld c,a
        dec c
        ld a,h
        cp c
        jp c,rdf2
        ENDIF

rdf4:   ld de,stgom
        call perrab



;
; lde the CCI code up out of the way to make room for
; code generation:
;

mvup:   call cmh        ;put -(base of cci code)...
        ex de,hl                ;  ...into DE
        lhld eofad      ;end of cci code
        push hl         ;save end of source area
        add hl,de               ;end of cci code - base of cci code
        inc hl          ;end of code - base of code + 1
        ld b,h          ;this is the length of the code;
        ld c,l          ;block length in  BC

        pop de          ;DE is end of source area

        lhld curtop     ;HL is end of memory (destination area)
        dec hl          ;just below BDOS
        dec hl          ; but one more for good measure

mvup2:  ld a,2          ;check to see if we're on a Z80
        inc a
        jp pe,mvup80

        ex de,hl                ;Z80. put source in HL and destination in DE
        db 0edh,0b8h    ;Z80 block lde
        ex de,hl                ;flip registers again
        jp mvup3

mvup80: ld a,(de)               ;get byte of source
        ld (hl),a               ;lde up
        dec hl          ;debump dest
        dec de          ;and source
        dec bc          ;and count
        ld a,b
        or c    
        jp nz,mvup80    ;loop till done

mvup3:  inc hl          ;restore HL to first character of CCI code
        ret             ;and return with HL pointing to start of CCI code




;
; Find the location of the string constant table in
; the just-read-in .CCI file:
;

fstgs:  lhld cdp
fstg1:  call pascd2
        push af
        cp swtcd
        jp nz,fstg2
        inc hl
        call igsht
        call mtchp
fstg1a: ld a,(hl)
        cp nlcd
        inc hl
        jp z,fstg1a
        ld e,(hl)
        ld d,0
        inc hl
        add hl,de
        add hl,de
        add hl,de
        add hl,de
        inc hl
fstg2:  pop af
        inc hl
        jp nz,fstg1
        shld stgad
        ret


;
; The following data storge is overlayed on pass 2 initialization code:
;

        ;org c2init

opstk=c2init ;: ds 40           ;operator stack for expression evaluation
infstk=opstk+40;:       ds 250          ;info stack for expression evaluation (where
                        ;info on each value is pushed and popped as
                        ;needed.)

relt=infstk+250;:       ds 1600         ;relocation table

        ds relt+1600-$

lblt:   ds 1700         ;label table

lbrt:   ds 1600         ;label reference table

;       ds 300
;stack: equ $

strsz:  equ 200

strtb:  ds strsz+3      ;up to (strsz/4) intelligently handled  strings

ltab:   ds 200          ;logical label table
ltabp:  ds 2            ;logical label table pointer

pshptb: ds 30           ;push-optimization history table
pshpp:  ds 2            ;push-optimization table pointer

direc:  ds 512          ;area where CRL directory is built up
endir:  equ $

;
; This is where the .CCI file gets loaded:
;

        ds 6
st:     equ $


        ;IF LASM
        ;end
        ;ENDIF

end
        savebin "cc2.com",begin,end-begin
        
        LABELSLIST "../../us/user.l"