diff --git a/EDASM.SRC/ASM/ASM1.S b/EDASM.SRC/ASM/ASM1.S new file mode 100644 index 0000000..d3d0ba3 --- /dev/null +++ b/EDASM.SRC/ASM/ASM1.S @@ -0,0 +1,2176 @@ +Name : ASM1.S +End of file : 37,977 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + + MSB OFF + REP 50 +; +; EDASM.ASM - load addr:$6800-$9EFF (len $4000) +; The 1st part of the code ($6800-$77FF) is relocated +; to $D000 of LCBank2. The rest of the code remained +; resident @ $7800-$9EFF +; +; Basically, compilers can be written as: +; Source -> Scanner/Lexer -> Parser -> CodeGenerator +; +; ORG $5800 ;modify ORG in ASSEMBLER.1 + ORG $D000 +; +; This part of the code is loaded into memory +; at $6800 and relocated to $D000 bank2 +; +; Print the symbol table after an assembly listing +; The symbol table is about 27K. If there is not +; enough mem to do a listing, the assembler will +; print only those symbols it can sort. The VO +; symbol table may not contain all idfers +; Ref pg 84,113 +; +DoPass3 LDA LstASym ;List symbols? + ORA LstVSym + BMI ChkPrtCols ;Yes + RTS +; +ChkPrtCols LDA #4 + BIT Lst6Cols + BPL UsePrtr +; + LDA #6 +UsePrtr LDX PrSlot ;Printer? + BNE SetPtrCols ;Yes + LDA #2 ;40-col std video +SetPtrCols STA NumCols ;# of print cols=2,4,6 +; +; Find out if the symbol table is empty by +; checking the header nodes. +; + LDA #0 + TAY ;Y=0 +ChkLoop CMP HeaderT,Y ;Do we have an empty symbol table? + BNE LD025 ;No + INY + BNE ChkLoop + JMP LD16E ;All zeroes => Yes +; +LD025 LDA #0 + STA SortF ;Default to sort by symbol + BIT SubTtlF ;Output subtitle? + BVC LD056 ;No +; + LDA #$FF + STA SubTtlF ;There is a subtitle string + LDX #ChnFile ;Get the src Pathname + LDA PNTable,X ; from table of ptrs + STA SrcPathP + LDA PNTable+1,X + STA SrcPathP+1 +; +; The buffers below are overwritten +; since we are done w/assembly +; + LDX #12 + STX ChnPNB +LD042 LDA SymbolTxt-1,X + STA ChnPNB,X + DEX + BNE LD042 +; + LDX #16 ;Include null char +LD04D LDA SortedTxt,X + STA SubTitle,X + DEX + BPL LD04D +; +LD056 LDA EndSymT + BNE LD05C + DEC EndSymT+1 +LD05C DEC EndSymT + BIT DskSrcF ;Should this instr be after LDY #HeaderT? + LDA #HeaderT + BMI LD06A ;branch never taken +; + LDA StrtSymT+1 + LDY StrtSymT +LD06A STY SymNodeP ;Points @ node containing + STA SymNodeP+1 ; symbolicname + STY SavSTS ;Save Start of SymTbl + STA SavSTS+1 ; as it will be trashed + LDA #2 ;Skip over ptr to + BNE LD099 ; next node +; +; The code below will trash the link ptrs (field) of nodes +; (StrtSymT) - points @ symbolicname field of the node +; (SymNodeP) - points @ link field of the same node +; (StrtSymT) & (SymNodeP) will be changed +; The purpose is to change the layout of the Nodes +; removing the link field altogether +; Layout of record now looks like this: +; symbolicname (variable in length) +; flagbyte +; 16-bit value +; +LD076 LDY #0 +LD078 LDA (StrtSymT),Y ;Get char fr symbolicname + STA (SymNodeP),Y ; move it forward in node + BPL LD081 ;eo symbolicname + INY + BNE LD078 +; +LD081 LDX #3 +LD083 INY + LDA (StrtSymT),Y ;Copy flagbyte + STA (SymNodeP),Y ; & value field + DEX + BNE LD083 +; + INY + TYA + CLC + ADC SymNodeP ;Point @ next node + STA SymNodeP + BCC LD096 + INC SymNodeP+1 +; +LD096 INY ;Skip over link field + INY + TYA +LD099 CLC + ADC StrtSymT + STA StrtSymT ;Point @ symbolicname of next node + BCC LD0A2 + INC StrtSymT+1 +; +LD0A2 CMP EndSymT ;EO symbol table? + LDA StrtSymT+1 + SBC EndSymT+1 + BCC LD076 ;No +; + LDY SymNodeP+1 + LDX SymNodeP + BNE LD0B1 + DEY +LD0B1 DEX + STX EndSymT ;New end of Symbol table + STY EndSymT+1 +; + LDA SavSTS ;Restore Start of symbol table + STA StrtSymT + LDA SavSTS+1 + STA StrtSymT+1 + NOP +; +LD0BF LDA StrtSymT ;Start w/the 1st rec + STA SymP + LDA StrtSymT+1 + STA SymP+1 +; +; The code below builds a fixed array of 2/4-bytes entries for sorting +; Sort by Symbol - array of 2-bytes entries. Each element is a ptr +; to a symbolicnname +; Sort by Address - array of 4-byte entries. Each element consists +; of a ptr to a symbolicname and address associated with +; the symbolicname +; + LDA #2 ;Default to 2-byte entries + BIT SortF ;Sort by symbol? + BPL LD0CE ;Yes + ASL ;Sort by addr - use 4-byte entries +LD0CE CLC + ADC EndSymT + STA UnsortedP ;Points to a 2/4-byte entry in + STA SortedP + LDA EndSymT+1 + ADC #0 + STA UnsortedP+1 ; the aux array for fixed rec size + STA SortedP+1 ;Init this for later use by PrSymTbl + LDA #0 + STA RecCnt + STA RecCnt+1 +; +; This loop builds up the aux array +; +LD0E3 JSR PollKbd ;Abort? + BCC LD0EB + JMP AbortAsm ;Yes +; +LD0EB LDY #0 +LD0ED LDA (SymP),Y ;Looking for eo symbolicname + BPL LD0F5 ;Got it + INY + JMP LD0ED +; +LD0F5 BIT SortF ;Sort by Address? (Also means is it phase 2?) + BMI LD108 ;Yes, skip code below +; +; Sort by symbol - always done since (SortF) was set to $00 initially +; (SortF) will set to $FF after printing if LstASym=$80 +; + ORA #%10000000 ;set msb on for last + STA (SymP),Y ; char of symbolicname + INY + LDA (SymP),Y ;Get symbol's flag byte + BPL LD108 ;Symbol is defined (msb off) + ORA #%01111110 ;Retain original $80 and $01 bits + EOR #%10000000 ;Clear msb to mark symbol is + STA (SymP),Y ; undefined =$7E/$7F (ref pg 231) +; +; msb of ALL chars of symbolicname are on +; msb of flagbyte is off ($7x) +; +LD108 INY + LDA (SymP),Y ;Get associated addr + STA SymAddr ;Save here just in case we need it later + INY + LDA (SymP),Y + STA SymAddr+1 + STY SymIdx ;Save index for $D198 call +; + LDA SymP + LDY #0 + STA (UnsortedP),Y ;Ptr to symbolic name + LDA SymP+1 + INY + STA (UnsortedP),Y + BIT SortF ;Sort by symbol? + BPL LD12D ;Yes +; + INY + LDA SymAddr + STA (UnsortedP),Y ;Store associated addr + INY + LDA SymAddr+1 + STA (UnsortedP),Y +; +LD12D JSR LD198 ;Setup envron for next entry + BCC LD0E3 ;Continue building up work array +; +; Building of the aux work array of 2/4-byte records is complete +; + LDA UnsortedP + BNE LD138 + DEC UnsortedP+1 +LD138 DEC UnsortedP +; + LDA UnsortedP + STA AuxAryE + LDA UnsortedP+1 + STA AuxAryE+1 ;Points @ EO array to be sorted + BIT LstASym ;Alphabetic Symbol listing? + BPL LD14C ;no +; + JSR DoSort + JSR PrSymTbl ;Print it +; +LD14C DEC SortF + LDA SortF ;Do we need to sort by address? + CMP #$FF + BNE LD16E ;No -> done + BIT SubTtlF ;SBTL directive? + BVC LD163 ;No +; +; Overwrite 'SYMBOL'00 with 'ADDRESS'00 +; + LDX #7 +LD15A LDA AddrTxt,X + STA SubTitle+10,X + DEX + BPL LD15A +; +LD163 BIT LstVSym ;Value ordered listing? + BPL LD16E ;no +; + LDA #$80 + STA LstASym ;Force an Alphabetic sort + JMP LD0BF ;Build aux array again w/(SortF)=$FF +; +LD16E LDA #$00 + STA SubTtlF ;Reset SBTL flag +doRtn RTS +; +SymbolTxt ASC 'SYMBOL TABLE' +SortedTxt ASC 'SORTED BY SYMBOL' ;null-terminated + DB 0 +AddrTxt ASC 'ADDRESS' + DB 0 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Setup enviornment to process next entry of 2/4-byte array +; Output +; C=1 out of mem or EO symbol table +; +LD198 CLC + LDA SymIdx ;Get index into symbol's record + ADC #1 ;Skip over hi-byte of assoc addr + ADC SymP + STA SymP ;Points @ next record of Symbol table + BCC LD1A5 + INC SymP+1 +; +LD1A5 LDA UnsortedP ;Ptr to entry of aux array + CMP MemTop + LDA UnsortedP+1 + SBC MemTop+1 + BCS doRtn1 ;Probably out of mem +; + CLC + LDA #2 + BIT SortF ;Sort by Symbol? + BPL LD1B7 ;Yes + ASL ;=4 +LD1B7 ADC UnsortedP + STA UnsortedP ;Point @ next empty slot + BCC LD1BF + INC UnsortedP+1 +; +LD1BF INC RecCnt + BNE LD1C5 + INC RecCnt+1 +LD1C5 LDA SymP ;Check if EO symbol table? + CMP EndSymT + LDA SymP+1 + SBC EndSymT+1 ;C=1 => yes +doRtn1 RTS +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Sorting Algorithm +; See Disassembled ProDOS Linker for more details +; Before calling, the work array of 2-byte/4-byte +; entries must be setup +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +DoSort LDA NumRecs ;Size of unsorted array + STA Jump + LDA NumRecs+1 + STA Jump+1 +; +; WHILE Jump <> 0 +; +WhileLoop LSR Jump+1 ;Jump := Jump DIV 2 + ROR Jump + LDA Jump + ORA Jump+1 + BNE LD1E1 + RTS +; +LD1E1 SEC + LDA NumRecs + SBC Jump + STA EndIdx ;NumRecs-Jump + LDA NumRecs+1 + SBC Jump+1 + STA EndIdx+1 +; + LDX #0 + STX StrtIdx+1 + INX + STX StrtIdx ;=1 +; +; FOR JJJ := 1 to NumRecs-Jump +; +ForLoop LDA StrtIdx + STA JJJ + LDA StrtIdx+1 + STA JJJ+1 +; +; REPEAT +; +RptLoop CLC + LDA JJJ + ADC Jump + STA III ;III := JJJ + Jump + LDA JJJ+1 + ADC Jump+1 + STA III+1 +; + LDX #3 +LD20C LDA JJJ,X ;$9F-$A2 + STA J.TH,X ;$AB-$AE + DEX + BPL LD20C +; +; Compute ptrs to the i-th & j-th elements +; of the array being sorted +; NB. The code below assumes the mem locations +; JJJ & III are consecutively declared +; Mulby4/Mulby2 and add to (EndSymT) +; For the 4-byte entries array (Sort by Address) +; (J.TH)=(EndSymT)+JJJ;4 and (I.TH)=(EndSymT)+III;4 +; For the 2-byte entries array (Sort by Symbol) +; (J.TH)=(EndSymT)+JJJ;2 and (I.TH)=(EndSymT)+III;2 +; + LDX #2 +LD215 ASL J.TH,X ;Compute offset fr + ROL J.TH+1,X ; BO of fixed array + BIT SortF ;Sort by Symbol? + BPL LD221 ;Yes + ASL J.TH,X ;No, it's sort by address + ROL J.TH+1,X +; +LD221 CLC + LDA EndSymT ;First compute ptr to the j-th + ADC J.TH,X ; & then on looping back + STA J.TH,X + LDA EndSymT+1 + ADC J.TH+1,X + STA J.TH+1,X + DEX + DEX + BEQ LD215 ; the i-th element +; + BIT SortF ;Sort by Symbol + BPL LD268 ;Yes +; +; Sort addresses in ascending order +; (J.TH)-ptr to j-th element +; (I.TH)-ptr to i-th element +; + CLC + LDA #2 + ADC J.TH ;Skip over ptr to symbolicname + STA SymPJ + LDA #0 + ADC J.TH+1 + STA SymPJ+1 ; to point @ 16-bit address +; + CLC + LDA #2 + ADC I.TH + STA SymPI + LDA #0 + ADC I.TH+1 + STA SymPI+1 +; +; IF Ary[J].addr > Ary[I].addr then SWAP(Ary[J], Ary[I]) +; + LDY #1 + LDA (SymPJ),Y ;Compare addresses (hi-byte first) + CMP (SymPI),Y + BEQ LD25D + BCS LD264 +LD25A JMP NextJ ;less than +; +LD25D DEY ;Y=0 + LDA (SymPI),Y ;Hi-bytes equal so compare lo-bytes + CMP (SymPJ),Y + BCS LD25A +LD264 LDY #3 ;Greater than => swap entries + BNE LD298 ;always +; +; Sort by symbol +; IF Ary[J].name > Ary[I].name then SWAP(Ary[J], Ary[I]) +; +LD268 LDY #0 + LDA (J.TH),Y ;Get ptr to symbolicname field + TAX + INY + LDA (J.TH),Y ;with an entry of the symbol table + STA SymPJ+1 + STX SymPJ +; + LDA (I.TH),Y + TAX + DEY ;=0 + LDA (I.TH),Y + STA SymPI + STX SymPI+1 +; +LD27E LDA (SymPJ),Y ;Get len byte of symbolic name + CMP (SymPI),Y ;Compare it against its counterpart + BNE LD294 ;No match + INY + CPY #14 ;At most 14 chars will be compared + BCS NextJ + LDA (SymPJ),Y + TAX + AND (SymPI),Y + BMI LD27E ;All chars match + TAX + BPL NextJ + SEC ;Flag we have to swap ptrs +LD294 BCC NextJ ;C=0 ==> 1st symbol < 2nd symbol +; +; Swap contents of 2/4-byte table +; Fall thru : 2-byte entries +; + LDY #1 +LD298 LDA (J.TH),Y ;Swap ptrs to the symbolicnames (if Y=1/3) + TAX + LDA (I.TH),Y + STA (J.TH),Y ;as well as corr addresses (if Y=3) + TXA + STA (I.TH),Y + DEY + BPL LD298 +; + SEC + LDA JJJ + SBC Jump + STA JJJ ;JJJ := JJJ - Jump + LDA JJJ+1 + SBC Jump+1 + STA JJJ+1 ;Is J > Jump? + BMI NextJ ;No, less than + ORA JJJ + BEQ NextJ ;No, JJJ=Jump + JMP RptLoop +; +; UNTIL JJJ =< Jump +; +NextJ INC StrtIdx + BNE LD2C1 + INC StrtIdx+1 +; +LD2C1 LDA StrtIdx+1 ;Finish w/FOR loop? + CMP EndIdx+1 + BCC LD2D2 + BEQ LD2CC +LD2C9 JMP WhileLoop ;No +; +LD2CC LDA EndIdx + CMP StrtIdx + BCC LD2C9 +LD2D2 JMP ForLoop ;Start Index =< End Index + REP 50 +; +; Print the sorted symbols and addresses +; (SortedP) should be pointing @ BO aux work array +; +PrSymTbl JSR PrtFF +LD2D8 LDA #0 + STA ColCnt ;# of cols printed + JSR PollKbd ;Abort assembling + BCC LD2E4 + JMP AbortAsm ;Yes +; +; NB: All chars of symbolicname would have their msb on +; The msb of the corr flag byte is 0 +; +LD2E4 LDY #0 + LDA (SortedP),Y ;Get ptr to symbolicname + STA SymP + INY + LDA (SortedP),Y + STA SymP+1 + DEY ;Y=0 +LD2F0 LDA (SymP),Y ;Is it the flag byte? + BPL LD2F8 ;Yes + INY + JMP LD2F0 +; +LD2F8 LDA #SPACE + STA SymRefCh ;Init with a blank + LDA #$00 + STA IsFwdRef + LDA (SymP),Y ;Get flag byte + ROR ;bit01 -> C (Check bit $01) + BCC LD307 ;=> Forward referenced bit was off + DEC IsFwdRef ;-1 +LD307 ROL ;Get back flag byte + CMP #$7E + BCC LD310 + LDA #'*' ;Symbol was referenced but not defined + BNE LD329 ;always +; +LD310 BIT Bit40 ;Was symbol unreferenced? + BEQ LD319 ;No + LDA #'?' ;Defined but never referenced + BNE LD329 +; +LD319 BIT Bit10 ;Was symbol defined to be EXTERN? + BEQ LD322 + LDA #'X' ;Yes + BNE LD329 +; +LD322 BIT Bit08 ;Was symbol defined to be ENTRY? + BEQ LD32B +; + LDA #'N' ;Yes +LD329 STA SymRefCh +LD32B LDA SymRefCh + JSR PutC + INY + LDA (SymP),Y ;Get symbol's addr + TAX + INY + LDA (SymP),Y ;Get its hi-byte + BNE LD348 ;Definitely 16-bits + BIT IsFwdRef ;Was forward-referenced bit on? + BMI LD348 ;Yes, consider all such addr as 16 bits +; + LDA #SPACE ;Print 2 spaces for zp/single-byte addr + JSR PutC + JSR PutC + JMP LD34B +; +LD348 JSR PrByte ;addr +LD34B TXA + JSR PrByte + LDA #SPACE + JSR PutC +; +; Print up to 14 chars of the symbolicname +; + LDY #0 +LD356 LDA (SymP),Y ;Get char fr symbolicname + BPL LD362 ;It is the flagbyte + JSR PutC + INY + CPY #14 + BCC LD356 +; +; If symbolicname < 14 chars long, print reqd # of blanks +; +LD362 DEY +LD363 INY + CPY #14 + BCS LD370 + LDA #SPACE + JSR PutC + JMP LD363 ;Loop back to print more spaces +; +LD370 JSR AdvRecP ;Adv to next entry of aux array + BCS doRtn2 ;We're done with table + INC ColCnt + LDA ColCnt + CMP NumCols + BCC LD383 + JSR PutCR ;Further printing will + JMP LD2D8 ; start on next row +LD383 JMP LD2E4 ;Further printing is on same row +doRtn2 RTS +;================================================= +; Adv ptr to next entry of work array +; On return +; C=1 - End of work array +; +AdvRecP CLC + LDA #2 + BIT SortF ;Sort by addr? + BPL LD38F ;No, by symbol + ASL ;=4 +LD38F ADC SortedP ;next Rec + STA SortedP + BCC LD397 + INC SortedP+1 +LD397 LDA SortedP ;EO aux array? + CMP AuxAryE + LDA SortedP+1 + SBC AuxAryE+1 + RTS +;================================================= +; Checks if external ROM is present +; (A)=slot # (1-7) +; Z=1 yes, Z=0 no +;================================================= +Chk4ROM TAX + LDA #%00000010 +LD3A3 DEX + BEQ LD3A9 + ASL + BNE LD3A3 +; +LD3A9 BIT SLTBYT ;Is a Slot ROM present? + BNE LD3B1 ;Yes + LDA #1 + RTS +LD3B1 LDA #0 ;Z=1 + RTS +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; (Y)=preserved +; Get ptr to next line record and save it +; +LD3B4 LDA SrcP ;save temporarily + PHA + LDA SrcP+1 + PHA + TYA + PHA + JSR NextRec ;Point @ start of next src line + LDX FCTIndex + LDA SrcP ;Save it + STA XA060,X + LDA SrcP+1 + STA XA060+1,X + PLA + TAY ;restore + PLA + STA SrcP+1 + PLA + STA SrcP + RTS +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; START of Assembler's Tables +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; +; ($D3D4) Table of Ptrs to messages incl. error msgs +; Ref page 219 Workbench +; +ErrMsgT EQU * ;Error code + DW LD50F ;0 + DW LD524 ;2 + DW LD539 ;4 + DW LD54A ;6 + DW LD553 ;8 + DW LD56C ;A + DW LD57E ;C + DW LD58C ;E + DW LD59F ;10 + DW LD5AA ;12 + DW LD5C0 ;14 + DW LD5D4 ;16 + DW LD5E8 ;18 + DW LD5F6 ;1A + DW LD605 ;1C + DW LD612 ;1E + DW LD626 ;20 + DW $0000 ;22 - none? + DW LD63B ;24 + DW LD64D ;26 + DW LD65A ;28 + DW LD668 ;2A + DW LD678 ;2C + DW LD688 ;2E + DW LD6A0 ;30 + DW LD6BD ;32 + DW LD6CB ;34 + DW LD6DD ;36 + DW LD6F1 ;38 + DW LD705 ;3A + DW LD71A ;3C + DW LD726 ;3E + DW LD739 ;40 + DW LD74B ;42 + DW LD75A ;44 + DW LD76E ;46 + DW LD781 ;48 +ErrMsgTE EQU * +;================================================= +FileTxt ASC ' # ELIF' ;FILE # +ASEndTxt EQU * +ASErrTxt ASC ' ERRORS IN THIS ASSEMBLY' + DB $00 +SuccTxt EQU * + ASC '** SUCCESSFUL ASSEMBLY := NO ERRORS' + DB $00 +WarnTxt ASC ' WARNINGS IN THIS ASSEMBLY' + DB $00 +CreatTxt ASC '** ASSEMBLER CREATED ON ' + DB $01 +FSPCTxt ASC '** FREE SPACE PAGE COUNT' + DB $01 +TotLnTxt ASC '** TOTAL LINES ASSEMBLED ' + DB $01 +ContTxt ASC 'PRESS RETURN TO CONTINUE' + DB $01 +AbortTxt ASC 'ASSEMBLY ABORTED. PRESS RETURN' + DB $01 +InLinTxt ASC 'ENIL NI ' ;' IN LINE' + ASC 'RORRE ' ;' ERROR' +;================================================= +; There is a table of ptrs to these messages +; +LD50F ASC 'UNDEFINED IDENTIFIER' + DB $00 +LD524 ASC 'DUPLICATE IDENTIFIER' + DB $00 +LD539 ASC 'UNDEFINED OPCODE' + DB $00 +LD54A ASC 'OVERFLOW' + DB $00 +LD553 ASC 'RELATIVE EXPRSN OPERATOR' + DB $00 +LD56C ASC 'EXPRESSION SYNTAX' + DB $00 +LD57E ASC 'EQUATE SYNTAX' + DB $00 +LD58C ASC 'INVALID IDENTIFIER' + DB $00 +LD59F ASC 'DSECT/DEND' + DB $00 +LD5AA ASC 'SYMBOL/RLD TABLE FULL' + DB $00 +LD5C0 ASC 'ASSEMBLER PARAMETER' + DB $00 +LD5D4 ASC 'INCLUDE/CHN NESTING' + DB $00 +LD5E8 ASC 'MACRO NESTING' + DB $00 +LD5F6 ASC 'MACRO ARGUMENT' + DB $00 +LD605 ASC 'ADDRESS MODE' + DB $00 +LD612 ASC 'RESERVED IDENTIFIER' + DB $00 +LD626 ASC 'MACRO FILE NOT FOUND' + DB $00 +LD63B ASC 'DIRECTIVE OPERAND' + DB $00 +LD64D ASC 'BRANCH RANGE' + DB $00 +LD65A ASC 'BYTE OVERFLOW' + DB $00 +LD668 ASC 'INDIRECT SYNTAX' + DB $00 +LD678 ASC 'INDEXING SYNTAX' + DB $00 +LD688 ASC 'INDIRECT REQUIRES ZPAGE' + DB $00 +LD6A0 ASC 'INVALID AFTER 1ST IDENTIFIER' + DB $00 +LD6BD ASC 'SW16 REGISTER' + DB $00 +LD6CB ASC 'INVALID DELIMITER' + DB $00 +LD6DD ASC 'OBJ BUFFER OVERFLOW' + DB $00 +LD6F1 ASC 'OBJ BUFFER CONFLICT' + DB $00 +LD705 ASC 'INVALID FROM INCLUDE' + DB $00 +LD71A ASC 'BUFFER SIZE' + DB $00 +LD726 ASC '>255 EXTRNS/ENTRYS' + DB $00 +LD739 ASC 'DUPLICATE EXT/ENT' + DB $00 +LD74B ASC 'SWEET16 OPCODE' + DB $01 +LD75A ASC 'EXTRN USED AS ZXTRN' + DB $01 +LD76E ASC 'ORG MUST BE > $100' + DB $00 +LD781 ASC '6502X ADRS MODE/OPCODE' + DB $00 +; +LD798 ASC '----- NEXT OBJECT FILE NAME IS ' +LD7B7 DB $0D + ASC 'SOURCE FILE #' +LD7C7 DB $0D + ASC ' INCLUDE FILE #' +;================================================= +; This table works in conjunction wth the next table +; They are indexed with the same (X) +; Table for operand parser (47 bytes) +; If -ve token (other than $A0) matched with src char +; If followed by $00 - proceed to evaluate expr +; If followed by $A0 - chk for a CR +; If there is a CR and next token is +; +ve and odd - return to caller with C=0 and (A)=MODULO2 +; which is an index btwn (0-12) for further processing +; to determine the length of the instruction +; +ve and even - call a rtn for further processing (2,4,6 valid) +; If -ve token does not match src char +; use table $D806 to advance to next -ve token +; ($D7D7) +; + MSB ON +AModTkns EQU * + ASC '#' ;$A3 + DB $00 ;Evaluate Expression + ASC ' ' ;Check for white space + DB 4+1 ;If CR, ret its mod2 value - imm +; +LD7DB ASC '(' ;$A8 + DB $00 ;eval expr + ASC ',' ;$AC + ASC 'X' ;$D8 + ASC ')' ;$A9 + ASC ' ' ;Check for CR + DB $02 ;Helper rtn 1 - IsZPMod? + DB 14+1 ;$0F - (zp,X) +LD7E3 DB $06 ;Helper rtn 3 - Is65C02? + DB 24+1 ;$19 - (abs,X) +; +LD7E5 ASC ')' ;$A9 + ASC ',' ;$AC + ASC 'Y' ;$D9 + ASC ' ' ;Check for CR + DB $02 ;helper rtn 1 + DB 12+1 ;$0D - (zp),y +; +LD7EB ASC ' ' ;Check for CR + DB $06 ;helper rtn 3 + DB $02 ;helper rtn 1 + DB 16+1 ;$11 - (zp) +LD7EF DB 18+1 ;$13 - (abs) +; +LD7F0 DB $04 ;helper rtn 2 - IsAccMode? + DB 20+1 ;$15 - Acc +LD7F2 DB $8D ;cr + DB 20+1 ;$15 - Acc +LD7F4 ASC ' ;' ;$BB + DB 20+1 ;$15 - Acc +; +LD7F6 DB $00 ;eval expr + ASC ' ' ;Check for CR + DB $02 ;Helper rtn 1 + DB 2+1 ;$03 - zp +LD7FA DB 0+1 ;$01 - abs +; +LD7FB ASC ',' ;$AC + ASC 'X' ;$D8 + ASC ' ' ;Check for CR + DB $02 ;Helper rtn 1 + DB 6+1 ;$07 - zp,X +LD800 DB 8+1 ;$09 - abs,X +; +LD801 ASC 'Y' ;$D9 + ASC ' ' ;Check for whitespace + DB $02 ;Helper rtn 1 + DB 22+1 ;$17 - zp,Y +LD805 DB 10+1 ;$0B - abs,Y + MSB OFF +;================================================= +; ($D806) - 47 bytes +; Command to the AdrMod parser +; if token is +; 0 - compare next src char to next token in $D7D7 table +; +ve - index to next token in $D7D7 table to be used to +; compare against curr src char +; -ve - error token +; +; error code = error token & $7E +; +AModCmds DB LD7DB-AModTkns ;index to token in $D7D7 to be used next + DB $00 ;Compare next token and src char + DB $80+$34 ;error code + DB $00 + DB LD7F0-AModTkns ;$19 + DB $00 + DB LD7E5-AModTkns ;$0E + DB $80+$2A ;Index Syntax +; + DB $80+$2A + DB $80+$34 ;Invalid Delimiter + DB LD7E3-AModTkns ;$0C + DB $00 + DB $80+$2E ;Indirect req zp + DB $00 + DB $80+$2A + DB LD7EB-AModTkns ;$14 +; + DB $80+$2A + DB $80+$34 + DB $80+$2E + DB $00 + DB $80+$34 + DB LD7EF-AModTkns ;$18 + DB LD7EF-AModTkns ;$18 + DB $00 +; + DB $00 + DB LD7F2-AModTkns ;$1B + DB $00 + DB LD7F4-AModTkns ;$1D + DB $00 + DB LD7F6-AModTkns ;$1F + DB $00 + DB $00 +; + DB LD7FB-AModTkns ;$24 + DB LD7FA-AModTkns ;$23 + DB $00 + DB $00 + DB $80+$34 + DB LD801-AModTkns ;$2A + DB $80+$34 ;Invalid Delimiter + DB LD800-AModTkns ;$29 +; + DB $00 + DB $00 + DB $80+$2C ;Indexing Syntax + DB $80+$34 + DB LD805-AModTkns ;$2E + DB $00 + DB $00 +;================================================= +; ($D835) 6502/X6502 Opcode Translation table 213 bytes +; The 15 addressing modes of a 65C02 +; 1) implied - opcode +; 2) accumulator - opcode +; 3) program counter relative - opcode reladdr +; 4) immediate - opcode # +; 5) direct - opcode zp +; 6) absolute - opcode abs +; 7) direct indexed X - opcode zp,X +; 8) absolute indexed X - opcode abs,X +; 9) direct indexed Y - opcode zp,Y +; 10) absolute indexed Y - opcode abs,Y +; 11) indexed indirect X - opcode (zp,X) +; 12) absolute indexed indirect X - JMP (abs,X) +; 13) absolute indirect - JMP (abs) +; 14) indirect - opcode (zp) +; 15) indirect indexed Y - opcode (zp),Y +;================================================= +; Implied and accumulator mode opcodes are all single bytes +; PC rel (branch ops) are 2 bytes +; Only these 3 modes need to be considered separately viz +; JMP (abs) - 1 of its kind! +; opcode (abs,X) JMP (abs,X) - one of its kind +; opcode zp,Y - LDX zp,Y STX zp,Y - 2 only +; NOP,BRK special +; +; This table is for ADC/AND/ etc +; L8516 DB $03,$02,$02,$02,$03,$03,$02,$02,$02 ;instr len for 9 addr modes +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +OpcodeT EQU * +ADCOps EQU * + DB $6D ;ADC abs 3 + DB $65 ;ADC zp 2 + DB $69 ;ADC # 2 + DB $75 ;ADC zp,X 2 + DB $7D ;ADC abs,X 3 + DB $79 ;ADC abs,Y 3 + DB $71 ;ADC (zp),Y 2 + DB $61 ;ADC (zp,X) 2 + DB $72 ;ADC (zp) - C02 2 +; +ANDOps EQU * + DB $2D ;AND abs + DB $25 ;AND zp + DB $29 ;AND # + DB $35 ;AND zp,X + DB $3D ;AND abs,X + DB $39 ;AND abs,Y + DB $31 ;AND (zp),Y + DB $21 ;AND (zp,X) + DB $32 ;AND (zp) - C02 +; +ASLOps EQU * + DB $0E ;ASL abs + DB $06 ;ASL zp + DB $0A ;ASL A + DB $16 ;ASL zp,X + DB $1E ;ASL abs,X +; + DB $90 ;BCC + DB $B0 ;BCS + DB $F0 ;BEQ +; +BITOps EQU * + DB $2C ;BIT abs + DB $24 ;BIT zp + DB $89 ;BIT # - C02 + DB $34 ;BIT zp,X - C02 + DB $3C ;BIT abs,X - C02 +; + DB $30 ;BMI + DB $D0 ;BNE + DB $10 ;BPL + DB $80 ;BRA + DB $00 ;BRK + DB $50 ;BVC + DB $70 ;BVS +; +CLROps EQU * + DB $18 ;CLC + DB $D8 ;CLD + DB $58 ;CLI + DB $B8 ;CLV +; +CMPOps DB $CD ;CMP + DB $C5 ;CMP + DB $C9 ;CMP # + DB $D5 ;CMP + DB $DD ;CMP + DB $D9 ;CMP + DB $D1 ;CMP + DB $C1 ;CMP + DB $D2 ;CMP +; +CPXOps EQU * + DB $EC ;CPX abs + DB $E4 ;CPX zp + DB $E0 ;CPX # +; +CPYOps EQU * + DB $CC ;CPY abs + DB $C4 ;CPY zp + DB $C0 ;CPY # +; +DECOps EQU * + DB $CE ;DEC abs + DB $C6 ;DEC zp + DB $3A ;DEC A - C02 + DB $D6 ;DEC zp,X + DB $DE ;DEC abs,X +; + DB $CA ;DEX + DB $88 ;DEY +; +EOROps EQU * + DB $4D ;EOR + DB $45 ;EOR + DB $49 ;EOR + DB $55 ;EOR + DB $5D ;EOR + DB $59 ;EOR + DB $51 ;EOR + DB $41 ;EOR + DB $52 ;EOR +; +INCOps EQU * + DB $EE ;INC + DB $E6 ;INC + DB $1A ;INC + DB $F6 ;INC + DB $FE ;INC +; + DB $E8 ;INX + DB $C8 ;INY +; +JMPOps EQU * + DB $4C ;JMP abs + DB $6C ;JMP (abs) + DB $7C ;JMP (abs,X) - C02 +; +JSROps DB $20 ;JSR abs +; +LDAOps EQU * + DB $AD ;LDA + DB $A5 ;LDA + DB $A9 ;LDA + DB $B5 ;LDA + DB $BD ;LDA + DB $B9 ;LDA + DB $B1 ;LDA + DB $A1 ;LDA + DB $B2 ;LDA +; +LDXOps EQU * + DB $AE ;LDX abs + DB $A6 ;LDX zp + DB $A2 ;LDX # + DB $B6 ;LDX zp,Y + DB $00 ;Acc - (TXA) + DB $BE ;LDX abs,Y +; +LDYOps EQU * + DB $AC ;LDY abs + DB $A4 ;LDY zp + DB $A0 ;LDY # + DB $B4 ;LDY zp,X + DB $BC ;LDY abs,X +; +LSROps EQU * + DB $4E ;LSR + DB $46 ;LSR + DB $4A ;LSR + DB $56 ;LSR + DB $5E ;LSR +; +NOPOps DB $EA ;NOP +; +ORAOps EQU * + DB $0D ;ORA + DB $05 ;ORA + DB $09 ;ORA + DB $15 ;ORA + DB $1D ;ORA + DB $19 ;ORA + DB $11 ;ORA + DB $01 ;ORA + DB $12 ;ORA +; +PSHOps EQU * + DB $48 ;PHA + DB $08 ;PHP + DB $DA ;PHX + DB $5A ;PHY + DB $68 ;PLA + DB $28 ;PLP + DB $FA ;PLX + DB $7A ;PLY +; +ROLOps EQU * + DB $2E ;ROL + DB $26 ;ROL + DB $2A ;ROL + DB $36 ;ROL + DB $3E ;ROL +; +ROROps EQU * + DB $6E ;ROR + DB $66 ;ROR + DB $6A ;ROR + DB $76 ;ROR + DB $7E ;ROR +; + DB $40 ;RTI + DB $60 ;RTS +; +SBCOps EQU * + DB $ED ;SBC + DB $E5 ;SBC + DB $E9 ;SBC + DB $F5 ;SBC + DB $FD ;SBC + DB $F9 ;SBC + DB $F1 ;SBC + DB $E1 ;SBC + DB $F2 ;SBC +; + DB $38 ;SEC + DB $F8 ;SED + DB $78 ;SEI +; +STAOps EQU * + DB $8D ;STA abs + DB $85 ;STA zp + DB $00 ;# - missing + DB $95 ;STA zp,X + DB $9D ;STA abs,X + DB $99 ;STA abs,Y + DB $91 ;STA (zp),y + DB $81 ;STA (zp,X) + DB $92 ;STA (zp) +; +STXOps EQU * + DB $8E ;STX abs + DB $86 ;STX zp + DB $00 ;abs,X missing + DB $96 ;STX zp,Y +; +STYOps EQU * + DB $8C ;STY abs + DB $84 ;STY zp + DB $00 ;abs,X missing + DB $94 ;STY zp,X +; +STZOps EQU * + DB $9C ;STZ abs - C02 + DB $64 ;STZ zp - C02 + DB $00 ;# - missing + DB $74 ;STZ zp,X - C02 + DB $9E ;STZ abs,X - C02 +; + DB $AA ;TAX + DB $A8 ;TAY +; +TRBOps EQU * + DB $1C ;TRB abs - C02 + DB $14 ;TRB zp - C02 +; +TSBOps EQU * + DB $0C ;TSB abs - C02 + DB $04 ;TSB zp - C02 +; + DB $BA ;TSX + DB $8A ;TXA + DB $9A ;TXS + DB $98 ;TYA +; +; ($D8EC) These are SW16 pseudo opcodes (30 bytes) +; SET ($10) is treated separately & is missing fr this table +; NB-Like the table above, these pseudo opcodes are +; in alphabetic order +; +SW16Ops EQU * + DB $A0 ;ADD + DB $03 ;BC + DB $0A ;BK + DB $05 ;BM + DB $08 ;BM1 + DB $02 ;BNC + DB $09 ;BNM1 + DB $07 ;BNZ + DB $04 ;BP + DB $01 ;BR + DB $0E ;BRL + DB $0C ;BS + DB $0F ;BSL + DB $06 ;BZ + DB $0D ;CPIM + DB $D0 ;CPR + DB $F0 ;DCR + DB $E0 ;INR + DB $20 ;LD + DB $60 ;LDD + DB $40 ;LDI + DB $80 ;POP + DB $C0 ;POPD + DB $00 ;RTN + DB $0B ;RS + DB $30 ;ST + DB $50 ;STI + DB $70 ;STD + DB $90 ;STP + DB $B0 ;SUB +;================================================= +; ($D90A) 213 bytes cycle times +; A value of $29 -> no cycle times? +;================================================= +CycTimes DB 4 ;ADC abs + DB 3 ;ADC zp + DB 2 ;ADC # + DB 4 ;ADC zp,X + DB 4 ;ADC abs,X + DB 4 ;ADC abs,Y + DB 5 ;ADC (zp),y + DB 6 ;ADC (zp,X) + DB 5 ;ADC (zp) +; + DB 04,03,02,04,04,04,05,06,05;AND + DB 06,05,02,06,07 ;ASL + DB 03,03,03 ;BCC,BCS,BEQ + DB 04,03,02,04,04 ;BIT + DB 03,03,03,03,07,03,03;BMI,BNE,BPL,BRA,BRK,BVC,BVS + DB 02,02,02,02 ;CLC,CLD,CLI,CLV +; + DB 04,03,02,04,04,04,05,06,05;CMP +; + DB 04,03,02 ;CPX + DB 04,03,02 ;CPY +; + DB 06,05,02,06,07 ;DEC + DB 02,02 ;DEX,DEY +; + DB 04,03,02,04,04,04,05,06,05;EOR + DB 06,05,02,06,07 ;INC + DB 02,02 ;INX,INY +; + DB 03,05,06,06 ;JMP,JSR + DB 04,03,02,04,04,04,05,06,05;LDA +; + DB 04,03,02,04,$29,04;LDX + DB 04,03,02,04,04 ;LDY + DB 06,05,02,06,07 ;LSR + DB 02 ;NOP + DB 04,03,02,04,04,04,05,06,05;ORA + DB 03,03,03,03 ;PHA,PHP,PHX,PHY + DB 04,04,04,04 ;PLA,PLP,PLX,PLY +; + DB 06,05,02,06,07 ;ROL + DB 06,05,02,06,07 ;ROR +; + DB 6,6 ;RTI,RTS + DB 04,03,02,04,04,04,05,06,05;SBC +; + DB 02,02,02 ;SEC,SED,SEI + DB 04,03,$29,04,05,05,06,06,05;STA +; + DB 04,03,$29,04 ;STX + DB 04,03,$29,04 ;STY + DB 04,03,$29,04,05 ;STZ +; + DB 02,02 ;TAX,TAY + DB 06,05,06,05 ;TRB,TSB + DB 02,02,02,02 ;TSX,TXA,TXS,TYA +; +; 30 bytes - no cycle time for SW16 pseudo opcodes +; + DB $29,$29,$29,$29,$29,$29,$29,$29 + DB $29,$29,$29,$29,$29,$29,$29,$29 + DB $29,$29,$29,$29,$29,$29,$29,$29 + DB $29,$29,$29,$29,$29,$29 +;================================================= +; ($D9DF) Char mapping +; char NV-B DIZC +; '0'-'9' --> $43 (0100 0011) +; 'A'-'F' --> $40 (0100 0000) (hexdec) +; 'G'-'Z' --> $00 (0000 0000) +; 'a'-'f' --> $C0 (1100 0000) +; 'g'-'z' --> $80 (1000 0000) +; others --> $01 (0000 0001) +; Value is popped into Status reg +; setting/resetting its ALL bits +; +CharMap1 DB $01,$01,$01,$01,$01,$01,$01,$01 + DB $01,$01,$01,$01,$01,$01,$01,$01 + DB $01,$01,$01,$01,$01,$01,$01,$01 + DB $01,$01,$01,$01,$01,$01,$01,$01 + DB $01,$01,$01,$01,$01,$01,$01,$01 + DB $01,$01,$01,$01,$01,$01,$01,$01 + DB $43,$43,$43,$43,$43,$43,$43,$43;$30-$39 + DB $43,$43 + DB $01,$01,$01,$01,$01,$01,$01 + DB $40,$40,$40,$40,$40,$40;$41-$46 + DB $00,00,00,00,00,00,00,00,00 + DB $00,00,00,00,00,00,00,00,00,00,00 + DB $01,01,01,01,01,01 + DB $C0,$C0,$C0,$C0,$C0,$C0;$61-$66 + DB $80,$80,$80,$80,$80,$80,$80,$80,$80;$67-$7A + DB $80,$80,$80,$80,$80,$80,$80,$80,$80 + DB $80,$80 + DB $01,$01,$01,$01,$01 +;================================================= +; Char mapping +; char NV-B DIZC +; '0'-'9' --> $42 (0100 0010) +; 'A'-'F' --> $40 (0100 0000) +; 'G'-'Z' --> $00 (0000 0000) +; 'a'-'f' --> $C0 (1100 0000) +; 'g'-'z' --> $80 (1000 0000) +; others --> $01 (0000 0001) +; Value is popped into Status reg +; setting/resetting its ALL bits +; +CharMap2 DB 01,01,01,01,01,01,01,01 + DB 01,01,01,01,01,01,01,01 + DB 01,01,01,01,01,01,01,01 + DB 01,01,01,01,01,01,01,01 + DB 01,01,01,01,01,01,01,01 + DB 01,01,01,01,01,01,00,01 + DB $42,$42,$42,$42,$42,$42;$30-$39 + DB $42,$42,$42,$42 + DB 01,01,01,01,01,01,01 + DB $40,$40,$40,$40,$40,$40;$41-$46 + DB 00,00,00,00,00,00,00,00,00 + DB 00,00,00,00,00,00,00,00,00,00,00 + DB 01,01,01,01,01,01 + DB $C0,$C0,$C0,$C0,$C0,$C0;$61-$66 + DB $80,$80,$80,$80,$80,$80,$80,$80,$80;$67-$7A + DB $80,$80,$80,$80,$80,$80,$80,$80,$80 + DB $80,$80 + DB 01,01,01,01,01 +;================================================= +; Directives/Mnemonics/Sweet16 table +; The table entries are variable in length +; because of the DCI text field +; Format of an entry +; If mnemonics +; 1) DCI text - variable in len +; 2) 1st flag byte - permitted addressing modes +; 3) 2nd flag byte - permitted addressing modes +; 4) index into opcode & cycle timing tables +; If directives +; 1) DCI text +; 2) flag byte - $80/$81 +; 3) DDB JMP addr-1 +; +; 1st Flag byte +; 1000 000x - directives (if x=1, print expr result field) +; 0100 xxxx - sweet16 pseudo opcode +; 0010 0000 - single byte opcodes excluding acc mode opcodes +; 0001 000x - JMP,JSR,CPIM,BSL,BRL +; 0000 1000 - branch opcodes +; 0000 0100 - LDX,STX --> special mode viz LDX zp,Y or STX zp,Y +; 0000 0011 - ADC,AND,CMP,EOR,LDA,ORA,SBC,STA +; 0000 0010 - ASL,DEC,INC,LSR,ROL,ROR +; 0000 0001 - JMP (abs) +; 0000 0000 - BIT,CPX,CPY,LDY,STY,STZ,TRB,TSB +; +; 1st Flag byte - addressing modes +; 1000 0000 - Directives +; 0100 0000 - Sweet 16 +; 0010 0000 - Implied mode +; 0001 0000 - (abs) +; 0000 1000 - Relative mode +; 0000 0100 - zp,Y (for LDX,STX) +; 0000 0011 - (zp) +; 0000 0010 - acc mode +; 0000 0001 - (abs,X) (for JMP) +; 0000 0000 +; +; 2nd flag byte - addressing modes +; +; 1000 0000 - (zp,X) +; 0100 0000 - (zp),Y +; 0010 0000 - abs,Y +; 0001 0000 - abs,X +; 0000 1000 - zp,X +; 0000 0100 - immediate mode +; 0000 0010 - zp +; 0000 0001 - abs +; +; NB: If the meaning of the bits in the 2 flag bytes +; are re-arranged/changed, the data tables OpcodeT, +; ModeBitsT etc. must be modified as well. Code +; involving the use of these values must be re-written +; +; Single byte (excluding those which are acc modes) +; & branch ops don't have sub-tables +; +MnemTbl EQU * +LtrA DCI 'ADC' ;mnemonics + DB %00000011 ;$03 + DB %11111111 ;$FF + DB ADCOps-OpcodeT ;index to sub-table of Opcode table + DCI 'ADD' + DB $40 ;0100 0000 + DB $02 + DB SW16Ops-OpcodeT + DCI 'AND' + DB %00000011 ;$03 + DB %11111111 ;$FF + DB ANDOps-OpcodeT + DCI 'ASC' + DB %10000000 + DDB L8DD2-1 + DCI 'ASL' + DB %00000010 ;$02 + DB %00011011 ;$1B + DB ASLOps-OpcodeT +LtrB DCI 'BC' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+1 +; + DCI 'BCC' + DB %00001000 ;$08 + DB %00000011 ;$03 + DB $17 ; -OpcodeT + DCI 'BCS' + DB $08 + DB $03 + DB $18 + DCI 'BEQ' + DB $08 + DB $03 + DB $19 + DCI 'BGE' + DB $08 + DB $03 + DB $18 +; + DCI 'BIT' + DB %00000000 ;$00 + DB %00011111 ;$1F + DB BITOps-OpcodeT + DCI 'BK' + DB $60 ;0110 0000 + DB $00 + DB SW16Ops-OpcodeT+2 + DCI 'BLT' + DB $08 + DB $03 + DB $17 + DCI 'BM' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+3 + DCI 'BM1' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+4 +; + DCI 'BMI' + DB $08 + DB $03 + DB $1F ; -OpCodeT + DCI 'BNC' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+5 + DCI 'BNE' + DB $08 + DB $03 + DB $20 + DCI 'BNM1' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+6 + DCI 'BNZ' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+7 + DCI 'BP' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+8 + DCI 'BPL' + DB $08 + DB $03 + DB $21 + DCI 'BR' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+9 + DCI 'BRA' + DB $08 + DB $03 + DB $22 +; + DCI 'BRK' + DB $20 + DB $00 + DB $23 + DCI 'BRL' + DB $58 ;0101 1000 + DB $03 + DB SW16Ops-OpcodeT+10 + DCI 'BS' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+11 + DCI 'BSL' + DB $58 ;0101 1000 + DB $03 + DB SW16Ops-OpcodeT+12 +; + DCI 'BVC' + DB $08 + DB $03 + DB $24 + DCI 'BVS' + DB $08 + DB $03 + DB $25 + DCI 'BZ' + DB $48 ;0100 1000 + DB $03 + DB SW16Ops-OpcodeT+13 +LtrC DCI 'CHN' + DFB $80 + DDB L928C-1 + DCI 'CHR' + DFB $80 + DDB L8FC7-1 +; + DCI 'CLC' + DB $20 ;0010 0000 + DB $00 + DB $26 + DCI 'CLD' + DB $20 + DB $00 + DB $27 + DCI 'CLI' + DB $20 + DB $00 + DB $28 + DCI 'CLV' + DB $20 + DB $00 + DB $29 +; + DCI 'CMP' + DB $03 ;0000 0011 + DB $FF + DB CMPOps-OpcodeT + DCI 'CPIM' + DB $50 ;0101 0000 + DB $01 + DB SW16Ops-OpcodeT+14 + DCI 'CPR' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+15 +; + DCI 'CPX' + DB $00 + DB $07 + DB CPXOps-OpcodeT + DCI 'CPY' + DB $00 + DB $07 + DB CPYOps-OpcodeT +; +LtrD DCI 'DATE' + DB $80 + DDB L901D-1 + DCI 'DB' + DB $80 + DDB L8CC3-1 + DCI 'DCI' + DB $80 + DDB L8E54-1 + DCI 'DCR' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+16 + DCI 'DDB' + DB $80 + DDB L8DCD-1 +; + DCI 'DEC' + DB $02 ;0000 0010 + DB $1B + DB DECOps-OpcodeT + DCI 'DEF' + DB $81 + DDB L9144-1 + DCI 'DEND' + DB $80 + DDB L908E-1 +; + DCI 'DEX' + DB $20 + DB $00 + DB $3E + DCI 'DEY' + DB $20 + DB $00 + DB $3F +; + DCI 'DFB' + DB $80 + DDB L8CC3-1 + DCI 'DO' + DB $81 ;1000 0001 + DDB L90B7-1 + DCI 'DS' + DB $81 + DDB L8C0E-1 + DCI 'DSECT' + DB $80 + DDB L9065-1 + DCI 'DW' + DB $80 + DDB L8D67-1 +LtrE DCI 'ELSE' + DB $80 + DDB L90CB-1 + DCI 'ENTRY' + DB $81 + DDB L9144-1 +; + DCI 'EOR' + DB $03 + DB $FF + DB EOROps-OpcodeT + DCI 'EQU' + DB $81 + DDB L8A31-1 + DCI 'EXTRN' + DB $81 + DDB L91A8-1 +LtrF DCI 'FAIL' + DB $80 + DDB L9215-1 + DCI 'FIN' + DB $80 + DDB L90D7-1 +LtrI DCI 'IBUFSIZ' + DB $81 + DDB L93C4-1 + DCI 'IDNUM' + DB $80 + DDB L905E-1 + DCI 'IFEQ' + DB $81 + DDB L90DE-1 + DCI 'IFGE' + DB $81 + DDB L90FC-1 + DCI 'IFGT' + DB $81 + DDB L90EB-1 + DCI 'IFNE' + DB $81 + DDB L90B7-1 + DCI 'IFLE' + DB $81 + DDB L9112-1 + DCI 'IFLT' + DB $81 + DDB L9107-1 +; + DCI 'INC' + DB $02 + DB $1B + DB INCOps-OpcodeT + DCI 'INCLUDE' + DB $80 + DDB L9360-1 + DCI 'INR' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+17 + DCI 'INTERP' + DB $81 + DDB L9131-1 +; + DCI 'INX' + DB $20 + DB $00 + DB $4E + DCI 'INY' + DB $20 + DB $00 + DB $4F +LtrJ DCI 'JMP' + DB $11 ;0001 0001 + DB %00000001 + DB JMPOps-OpcodeT + DCI 'JSR' + DB $10 ;0001 0000 + DB %00000001 + DB JSROps-OpcodeT +; +LtrL DCI 'LD' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+18 +; + DCI 'LDA' + DB $03 + DB $FF + DB LDAOps-OpcodeT +; + DCI 'LDD' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+19 + DCI 'LDI' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+20 + DCI 'LDP' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+21 +; + DCI 'LDX' + DB $04 ;0000_0100 + DB %00100111 ;$27 + DB LDXOps-OpcodeT + DCI 'LDY' + DB $00 + DB %00011111 ;$1F + DB LDYOps-OpcodeT +; + DCI 'LSL' + DB $02 + DB $1B + DB ASLOps-OpcodeT + DCI 'LSR' + DB $02 + DB $1B + DB LSROps-OpcodeT +; + DCI 'LST' + DB $80 + DDB L8ECA-1 +LtrM DCI 'MACLIB' + DB $80 + DDB L937F-1 + DCI 'MSB' + DB $80 + DDB L8E66-1 +; +LtrN DCI 'NOP' + DB $20 + DB $00 + DB $6D +LtrO DCI 'OBJ' + DB $81 + DDB L8BAD-1 +; + DCI 'ORA' + DB $03 + DB $FF + DB ORAOps-OpcodeT + DCI 'ORG' + DB $81 + DDB L8A82-1 +LtrP DCI 'PAGE' + DB $80 + DDB DoPage-1 + DCI 'PAUSE' + DB $80 + DDB L927A-1 +; + DCI 'PHA' + DB $20 + DB $00 + DB $77 + DCI 'PHP' + DB $20 + DB $00 + DB $78 + DCI 'PHX' + DB $20 + DB $00 + DB $79 + DCI 'PHY' + DB $20 + DB $00 + DB $7A + DCI 'PLA' + DB $20 + DB $00 + DB $7B + DCI 'PLP' + DB $20 + DB $00 + DB $7C + DCI 'PLX' + DB $20 + DB $00 + DB $7D + DCI 'PLY' + DB $20 + DB $00 + DB $7E +; + DCI 'POP' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+21 + DCI 'POPD' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+22 +LtrR DCI 'REF' + DB $81 + DDB L91A8-1 + DCI 'REL' + DB $80 + DDB L9126-1 + DCI 'REP' + DB $80 + DDB L8FA3-1 +; + DCI 'ROL' + DB $02 + DB $1B + DB ROLOps-OpcodeT + DCI 'ROR' + DB $02 + DB $1B + DB ROROps-OpcodeT +; + DCI 'RS' + DB $60 ;0110 0000 + DB $00 + DB SW16Ops-OpcodeT+24 +; + DCI 'RTI' + DB $20 + DB $00 + DB $89 + DCI 'RTN' + DB $60 ;0110 0000 + DB $00 + DB $23 ;BRK? + DCI 'RTS' + DB $20 + DB $00 + DB $8A +; +LtrS DCI 'SBC' + DB $03 + DB $FF + DB SBCOps-OpcodeT + DCI 'SBTL' + DB $80 + DDB L8F61-1 + DCI 'SBUFSIZ' + DB $81 + DDB L93C7-1 +; + DCI 'SEC' + DB $20 + DB $00 + DB $94 + DCI 'SED' + DB $20 + DB $00 + DB $95 + DCI 'SEI' + DB $20 + DB $00 + DB $96 +; + DCI 'SET' + DB $C0 ;1100 0000 + DDB L94C0-1 + DCI 'SKP' + DB $80 + DDB L8FEA-1 + DCI 'ST' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+25 +; + DCI 'STA' + DB %00000011 + DB %11111011 + DB STAOps-OpcodeT + DCI 'STD' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+27 + DCI 'STI' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+26 + DCI 'STP' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+28 + DCI 'STR' + DB $80 + DDB L8E94-1 +; + DCI 'STX' + DB $04 ;0000_0100 + DB %00000011 ;$03 + DB STXOps-OpcodeT + DCI 'STY' + DB $00 + DB $0B ;0000_1011 + DB STYOps-OpcodeT + DCI 'STZ' + DB $00 + DB $1B + DB STZOps-OpcodeT +; + DCI 'SUB' + DB $40 + DB $02 + DB SW16Ops-OpcodeT+29 + DCI 'SYS' + DB $81 + DDB L9131-1 + DCI 'SW16' + DB $C0 ;1100 0000 + DDB L946F-1 +; +LtrT DCI 'TAX' + DB $20 + DB $00 + DB $AD + DCI 'TAY' + DB $20 + DB $00 + DB $AE + DCI 'TIME' + DB $80 + DDB L905E-1 +; + DCI 'TRB' + DB $00 + DB $03 + DB TRBOps-OpcodeT + DCI 'TSB' + DB $00 + DB $03 + DB TSBOps-OpcodeT +; + DCI 'TSX' + DB $20 + DB $00 + DB $B3 + DCI 'TXA' + DB $20 + DB $00 + DB $B4 + DCI 'TXS' + DB $20 + DB $00 + DB $B5 + DCI 'TYA' + DB $20 + DB $00 + DB $B6 +; +LtrX DCI 'X6502' + DB $81 + DDB L9139-1 +LtrZ DCI 'ZDEF' + DB $81 + DDB L9140-1 + DCI 'ZREF' + DB $81 + DDB L91A4-1 + DCI 'ZXTRN' + DB $81 + DDB L91A4-1 +DotDrtv DCI '.ASCII' + DB $80 + DDB L8DD2-1 + DCI '.BLOCK' + DB $81 + DDB L8C0E-1 + DCI '.BYTE' + DB $80 + DDB L8CC3-1 + DCI '.DBYTE' + DB $80 + DDB L8DCD-1 + DCI '.DEF' + DB $81 + DDB L9144-1 + DCI '.EQU' + DB $81 + DDB L8A31-1 + DCI '.INCLUDE' + DB $80 + DDB L9360-1 + DCI '.LIST' + DB $80 + DDB L8F3D-1 + DCI '.NOLIST' + DB $80 + DDB L8F3A-1 + DCI '.ORG' + DB $81 + DDB L8A82-1 + DCI '.PAGE' + DB $80 + DDB DoPage-1 + DCI '.REF' + DB $81 + DDB L91A8-1 + DCI '.SKIP' + DB $80 + DDB L8FEA-1 + DCI '.TITLE' + DB $80 + DDB L8F61-1 + DCI '.WORD' + DB $80 + DDB L8D67-1 + DS 4,0 ;unused +;================================================= +; Table of ptrs to first letter subtables +; +Tbl1stLet DW DotDrtv + DW LtrA + DW LtrB + DW LtrC + DW LtrD + DW LtrE + DW LtrF + DW $0000 + DW $0000 + DW LtrI + DW LtrJ + DW $0000 + DW LtrL + DW LtrM + DW LtrN + DW LtrO + DW LtrP + DW $0000 + DW LtrR + DW LtrS + DW LtrT + DW $0000 + DW $0000 + DW $0000 + DW LtrX + DW $0000 + DW LtrZ +; +; Assembler's creation date and time +; +LDF3F ASC '30-APR-85' +LDF48 ASC '22:46 ' +; +; Area to preserve the zero page locations $60-$F1 +; +SvZPArea DS $92,0 +; +; ($DFE0) Haven't figure out what is this! +; May be encoded message. Or just random bytes +; generated by a DS 32 statement +; + DW $D581 + DW $D589 + DW $D58E + DW $D546 + DW $A023 + DW $A048 + DW $A308 + DW $DCC7 + DW $9BF8 + DW $A071 + DW $B9AF + DW $9B18 + DW $9B6D + DW $DDC0 + DW $9F49 + DW $C8D3 + REP 50 \ No newline at end of file diff --git a/EDASM.SRC/ASM/ASM2.S b/EDASM.SRC/ASM/ASM2.S new file mode 100644 index 0000000..49cb83d --- /dev/null +++ b/EDASM.SRC/ASM/ASM2.S @@ -0,0 +1,3389 @@ +Name : ASM2.S +End of file : 64,420 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + + ORG $7800 + REP 50 +; EdAsm Interpreter will transfer control here +; +Assembler EQU * ;ENTRY +ColdStrt JMP ExecAsm +; +; Patch the addr @ this offset with $60 (RTS) +; if user wants to use the letters A,X,Y as labels +; + DW IsAXY ;Points to subrtn checking A,X,Y as labels +; +DateStr ASC '30-APR-85 22:46' +; +ResetEnt JSR GoMon ;Comes here when Apple RESET key is pressed +; +ExecAsm JSR SaveZP + TSX + STX EIStack ;Save EdAsm Interpreter's H/W stack + SEI ;Disable H/W interrupts + JSR SetupVec + JSR InitASM + JSR DoPass1 + JSR DoPass2 + JSR PollKbd +; +; The ProDOS version of EdAsm does not +; support memory resident source file(s). +; +CleanUp LDA DskSrcF ;Assembling a mem resident src file? + BPL FlushObj ;Yes (Never taken) +; + LDX FCTIndex + CPX #InclFile + BCC CleanUp2 + BEQ CleanUp1 + LDX #MacFile ;Close Macro file (if any) + JSR ClsFile +; +CleanUp1 LDX #InclFile ;Close INCLUDE file (if any) + JSR ClsFile +; +CleanUp2 LDX #ChnFile ;Close CHAIN file (if any) + JSR ClsFile +; +FlushObj JSR L99DF ;Flush obj code +; +ListSymTbl BIT CancelF ;Suppress symbol table listing? + BPL ListErrs ;Yes +; + LDA EndSymT+1 ;Need to preserve this + STA SavSTE ; during calcn # of free pages + JSR DoPass3 ;Output symbol table etc + JSR PollKbd +AbortAsm LDA SavSTE + STA EndSymT+1 ;Restore +; +ListErrs LDA NbrErrs ;Any errors encountered? + ORA NbrErrs+1 + BEQ TellUser + JSR PrSummry ;Yes +; +TellUser JSR PrtEndAsm ;Tell user assembly process is ending +; +EndAsm JSR PrtFF ;Do a form feed + BIT DskListF ;Listing to file? + BPL ExitASM ;No + LDX #LstFile + JSR ClsFileX +; +ExitASM LDX EIStack + TXS + JSR SaveZP + JSR SetupVec + RTS + REP 50 +; +; Comes here whenever EdAsm.Asm has to do an orderly +; exit as a result of errors which make continuation +; of the assembly process non-feasible +; +; (A)=keycode if PollKbd called prior to +; transfer of control +; +CanclAsm INC CancelF ;Flag we have to stop + BEQ ForceAbort + CMP #CTRLB ;This code may not be executed + BCC ListSymTbl + BCS ExitASM ;Always +; +ForceAbort BIT AbortF ;Was it user abort? + BMI AbortNow ;Yes +; + LDA #BEL ;Ring, ring + JSR VidOut + JSR VidOut + JSR PrtCR + BIT KBDSTROBE + LDX #>AbortTxt-ASEndTxt + JSR L986A +WaitK1 LDA KBD ;Wait for keystroke + BPL WaitK1 + BIT KBDSTROBE +; +AbortNow JSR CountErr ;Increment # of errors + JMP CleanUp + REP 50 +; +SetupVec LDA SOFTEV + LDX ResetEnt+1 + STA ResetEnt+1 + STX SOFTEV + LDA SOFTEV+1 + LDX ResetEnt+2 + STA ResetEnt+2 + STX SOFTEV+1 + LDA SOFTEV+1 + EOR #$A5 + STA PWREDUP + RTS + REP 50 +; +; Comes here when Apple // RESET key +; is pressed during an assembly +; +GoMon LDA RDROM2 + TSX + STX StackP + LDX #$80 + TXS + JMP MONZ + REP 50 +; +; We are at the end of an assembly session so print +; 1) # of warnings & errors if any +; 2) success if no errs +; 3) total # of lines assembled +; 4) Date +; 5) # of free pages +; +PrtEndAsm JSR PutCR + LDA #0 + STA BCDNbr+2 + LDA NbrWarns + STA BCDNbr + LDA NbrWarns+1 + STA BCDNbr+1 + ORA NbrWarns + BEQ PrtErrs + JSR PrtDecS ;Print BCD as dec str + LDX #>WarnTxt-ASEndTxt;# of warnings in assembly + JSR MsgPrtr +; +PrtErrs LDA NbrErrs+1 + STA BCDNbr+1 + LDA NbrErrs + STA BCDNbr + ORA NbrErrs+1 + BEQ GudAsm ;No errs + JSR PrtDecS + LDX #>ASErrTxt-ASEndTxt;# of errors in assembly + JSR MsgPrtr + JMP PrtCrMsg +; +GudAsm LDX #>SuccTxt-ASEndTxt + JSR MsgPrtr +PrtCrMsg LDX #>CreatTxt-ASEndTxt + JSR MsgPrtr +; + LDX #0 +PrtLoop LDA DateStr,X + JSR PutC + INX + CPX #$10 ;16-1 + BCC PrtLoop +; + JSR PutCR + LDX #>TotLnTxt-ASEndTxt + JSR MsgPrtr + LDA TotLines + STA BCDNbr + LDA TotLines+1 + STA BCDNbr+1 + LDA TotLines+2 + STA BCDNbr+2 + JSR PrtDecS ;Covert BCD into dec str & print + JSR PutCR + LDX #>FSPCTxt-ASEndTxt + JSR MsgPrtr +; + LDX EndSymT+1 ;Mem Page of Top of Symbol Table + INX + LDA #0 + STA BCDNbr + STA BCDNbr+1 + STA BCDNbr+2 +; +; Count # of free mem pages btwn ends of +; Symbol table & Relocation Dictionary. +; The symbol table is build upwards from LoMem while +; the Relocation Dict is build downwards from MemTop. +; +PrtLoop1 CPX RLDEnd+1 + BEQ PrtFreeMem + JSR L81A3 + INX + BNE PrtLoop1 +; +PrtFreeMem JSR PrtDecS ;Print dec + JSR PutCR +doRTS RTS + REP 50 +; Message Printer +; Entry: +; (X)=offset to message +; +MsgPrtr LDA ASEndTxt,X + CMP #SPACE + BCC ChkEndMsg + JSR PutC + INX + BNE MsgPrtr +ChkEndMsg TAX ;end of msg? + BNE doRTS + JMP PutCR ;yes + REP 50 +; +SummaryStr STR 'YRAMMUS RORRE' +; +; Print summary of errors +; ErrTIdx = index into Save Error Info table +; +PrSummry LDA #0 + STA ErrTIdx ;Index into err table + JSR PrtFF ;Do a Form Feed + JSR PutCR +; + LDX #$0D +PrtLoop2 LDA SummaryStr,X + JSR PutC + DEX + BPL PrtLoop2 +; +; Print out errors encountered +; +PrtAsmErr LDA ErrTIdx + CMP ErrNbr4 + BCC PrtErrLin + RTS +; +PrtErrLin TAY ;Move index into Y-reg + LDA ErrInfoT+3,Y + STA BCDNbr + LDA ErrInfoT+2,Y + STA BCDNbr+1 ;line # + LDA #0 + STA BCDNbr+2 + LDA ErrInfoT+1,Y + TAX ;Index into ErrMsgT + JSR PrtErrMsg + LDA #'O' ;'OF ' + JSR PutC + LDA #'F' + JSR PutC + LDA #SPACE + JSR PutC +; + LDA ErrInfoT,Y ;bug? instr should be removed + LDX #$06 +PrtLoop3 LDA FileTxt,X + JSR PutC + DEX + BPL PrtLoop3 +; + LDA ErrInfoT,Y ;file # + JSR PrByte + JSR PutCR + INY + INY + INY + INY + STY ErrTIdx + JSR PollKbd + BCS StopPrt ;Abort + JMP PrtAsmErr ;next +; +StopPrt PLA ;Dump RTS addr + PLA + JMP EndAsm + REP 50 +; +; Error Handler/Reporter +; Register we have an assembler syntax error or warning +; NB. (ErrorF) is reset before a line is assembled +; Ref pg 217 for List of Assembler Errors +; Entry: +; (X) = error token +; Ret: +; (ErrorF) = $80 if error; unchanged if warning +; (Y) = unchanged +; Once an error is issued on a line, secondary errors are not +; reported. However, it's possible for the line to be +; flagged with more than 1 warning. +; +RegAsmEW BIT ErrorF ;Has this line been flagged? + BPL NewErrWarn ;No +doRTS1 RTS +; +NewErrWarn TXA + LSR ;Is err token odd? + BCC FlagErr ;No, considered as an error +; + SEC ;Yes, treat as a warning + SED + LDA #0 + ADC NbrWarns + STA NbrWarns + LDA NbrWarns+1 + ADC #0 + STA NbrWarns+1 + CLD + BIT LstWarns ;Suppress warnings? + BPL doRTS1 ;Yes +; + JSR DoAlert ;Alert user + JMP doPause +; +; Flag as an error +; +FlagErr DEC ErrorF ;Is err due to idfer not found during pass2? + BEQ SkipIt ;Yes + JSR SaveErrInfo ;No, save err info for this line +SkipIt LDA #$80 ;Flag no more errs will be + STA ErrorF ; reported for curr srcline + JSR DoAlert +FlagErrZ JSR CountErr ;Increment # of errors +; +doPause LDX #$06 ;(X) used below in delay + JSR IsVideo ;Output thru video? + BNE PutCR ;No +; +DelayLup LDA #0 + STA RDROM2 + JSR WAIT + STA RDBANK2 + DEX + BNE DelayLup +; +PutCR LDA #CR + JMP PutC + REP 50 +; +; Print *****, sound the bell and then print +; an error message +; (X)=error token +; (Y) preserved +; NB:Fall thru to the PrtErrMsg code +; +DoAlert JSR PutCR + TYA ;save (Y) + PHA ;on stack + LDA WinLeft ;Make sure any display + STA PrtCol ; is inside our window +; + LDY #5 + LDA #'*' ;print 5 ;'s +PrtLoop4 JSR PutC + DEY + BNE PrtLoop4 +; + PLA + TAY ;restore (Y) + LDA PrSlot ;If slot # is 0, + BEQ RingBell ; use std Apple ][ video + CMP VidSlot ;Is 80-col card? + BEQ RingBell ;Yes +; + BIT RDROM2 + JSR BELL1 ;Apple Monitor rtn + BIT RDBANK2 + JMP PrtBlnk +; +RingBell LDA #BEL ;video output + JSR PutC +PrtBlnk LDA #SPACE + JSR PutC + REP 50 +; +; Print Error or Warnings +; ($7A6B) +; Entry: +; (X)=error token +; bits +; 7 +; 6-1 index into a table of ptrs to Error/Warning Messages +; 0 on=counted as warning, off=counted as error +; +; Range for index $00-$48 +; +PrtErrMsg TXA + AND #%01111110 ;Isolate the index + TAX + CPX #>ErrMsgTE-ErrMsgT+1 + BCC PrtEM1 + BRK +PrtEM1 LDA ErrMsgT,X + STA MsgP + LDA ErrMsgT+1,X + STA MsgP+1 + TYA + PHA +; + LDY #0 +PrtEMLoop LDA (MsgP),Y + CMP #SPACE + BCC L7A8E ;Skip embedded 0,1,CR + JSR PutC + INY + BNE PrtEMLoop +; +L7A8E LSR ;C=0 if a null-terminated line + PHP ;Save Carry for later + LDA VidSlot ;slot #0? + BNE SkipIt2 ;No +; + LDA #CR + JSR MonCOUT ;Std Apple II 40-col video + LDA WinLeft + STA PrtCol +SkipIt2 PLP + PLA + TAY +; + LDX #$0E ;' ERROR IN LINE' + BCC PrtLoop5 ;null-terminated line + LDX #$08 +PrtLoop5 LDA InLinTxt-1,X ;' IN LINE' + JSR PutC + DEX + BNE PrtLoop5 + NOP + JMP PrtDecS + REP 50 +; +; Increment # of errors +; +CountErr SEC + SED + LDA #0 + ADC NbrErrs + STA NbrErrs + LDA NbrErrs+1 + ADC #0 + STA NbrErrs+1 + CLD + RTS + REP 50 +; +; (Y) & (X) preserved +; Save info for first 8/16 errors encountered +; X=error token +; +SaveErrInfo LDA VidSlot ;Is slot #0? + BNE NotStd ;No + LDA #8*4 ;std 40-col video + BNE Is2Many ;always +NotStd LDA #16*4 ;File/Printer/80-col +Is2Many CMP ErrNbr4 + BCC doRTS2 ;Too many errs + BEQ doRTS2 +; +; Use table @ $A0B2 for storing error info +; + TYA + PHA + LDY ErrNbr4 ;multiple of 4 + LDA FileNbr ;file # + STA ErrInfoT,Y + TXA ;errtoken + AND #%01111110 ;Isolate the index + STA ErrInfoT+1,Y + LDA BCDNbr+1 ;line # + STA ErrInfoT+2,Y + LDA BCDNbr + STA ErrInfoT+3,Y + INY + INY + INY + INY + STY ErrNbr4 + PLA + TAY +doRTS2 RTS + REP 50 +; Bit table +; +Bit01 DB $01 ;not used +Bit02 DB $02 +Bit08 DB $08 +Bit10 DB $10 +Bit40 DB $40 + REP 50 +; +; Save zero page locations $60-$F1 +; +SaveZP LDX #$92 + BIT LCBANK2 ;2 successive writes + BIT LCBANK2 +SavLoop LDA Z60-1,X + LDY SvZPArea-1,X + STY Z60-1,X + STA SvZPArea-1,X + DEX + BNE SavLoop + BIT RDBANK2 + RTS + REP 50 +; +; ($7B13) Init Assembler module +; +InitASM LDA #>ColdStrt + STA HighMem + STA MemTop + LDA #ChnPNB + STA SrcPathP + LDA # drive 1 + LDA #>OLDataB ;Only 16 bytes used + STA OLBufAdr + LDA #LstDBuf + STA HighMem + STA MemTop + LDA # no label + BEQ L7EDD +; +; This part of code checks for an idfer in the LABEL field +; Should be part of Lexer (Static semantic analysis) +; + JSR RsvdId ;Chk for A,X,Y as 1st char of label + JSR FindSym + BCS NewLabel ;No such label + TAX ;Sym found but has it been defined? + BMI L7E94 ;No +; + LDX #$02 ;Duplicate idfer + JSR RegAsmEW + LDA #$00 + STA LabelF ;Flag no label field + JMP L7EC8 ;(Y)-indexing lobyte? +; +L7E94 STA SymFByte ;Symbol's curr flag byte + DEY ;Index flag byte again + AND #entry+fwdrefd ;0000 1001 + BIT DummyF ;Are we in a DSECT? + BMI L7E9F ;Yes + ORA #relative +L7E9F STA (SymP),Y ;save modified status of flag byte + INY + LDA PC ;Value associated w/symbol + STA (SymP),Y + INY + LDA PC+1 + STA (SymP),Y + JMP L7EC8 +; +; New label +; +NewLabel LDA #$00 + STA SymFByte + LDX #relative + BIT DummyF ;Are we in a DUMMY section? + BPL L7EBA ;No +; + LDX #$00 ;abs +L7EBA STX RelExprF + LDA #$00 ;Initial flag byte to be + JSR AddNode ; stored into Node + BCC L7EC8 ;(Y)-indexing hibyte + LDX #$0E ;Invalid identifier + JSR RegAsmEW +; +L7EC8 DEY + DEY ;Indexing flag byte of symtbl entry + TYA + CLC + ADC SymP + STA SymFBP ;Point @ the symbol's flag byte + LDA #0 + ADC SymP+1 + STA SymFBP+1 +; +; This part handles the mnemonic/psuedo opcode field +; + LDY #0 ;Start w/1st char + JSR L81F0 ;Skip over non-blanks + BNE L7EE5 ;Got a CR +; +L7EDD JSR NxtField ;We got at least 1 space so skip over them + JSR HndlMnem + BCC L7EF0 ;No errs +; +L7EE5 LDX #$04 ;undefined opcode + JSR RegAsmEW + LDA #3 + STA Length + BNE L7F01 ;always +; +L7EF0 CMP #$FF ;1st flag byte + BEQ L7F04 ;Proceed to next line rec + BIT ZAB ;SW16 opcodes? + BVC L7EFE ;No + BIT SW16F ;Are SW16 ops valid? + BPL L7EFE + DEC SW16F ;When (SW16F)=0, code gen problems may arise +; +; Looks like the above code which checks for SW16 +; validity will come here no matter what. +; To avoid (SW16F) decrementing to 0, use SW16 directive +; to set its value to $01. +; +L7EFE JSR GInstLen ;Determine len of inst +L7F01 JSR AdvPC ; so we can adjust PC +; +L7F04 JSR NextRec ;Adv to next src line record + JSR L81A3 ;Let user know we are doing something + JMP Pass1Lup + REP 50 +; +DoPass2 INC PassNbr ;Flag we are in 2nd pass + LDA #'*' + STA RepChar + LDA #-1 + STA ListingF + JSR PutCR + JSR OpenSrc1 ;Re-open initial src file + LDA GenF + CMP #$80 ;Write obj code into mem? + BNE Pass2Lup ;No +; + LDA CurrORG ;These 4 inst serves no purpose since + STA ObjPC ; its contents are changed when an + LDA CurrORG+1 ; OBJ/ORG directive is declared + STA ObjPC+1 ; Renamed as CodeLen if REL file + ASL GenF ;$00 - Remove suspension +; +; Assemble each src line +; +Pass2Lup JSR GSrcLin ;Any more src lines to assembled? + BCC L7F33 + RTS +; +; Init before each line is scanned/parsed +; +L7F33 LDY #-1 + STY ZAB ;=$FF + INY ;=0 + STY Length + STY ErrorF + STY LstCodeF + STY NumCycles + LDA SrcP + STA Src2P ;Save a copy of ptr + LDA SrcP+1 + STA Src2P+1 ; to curr srcline +; + BIT CondAsmF ;Assembling alt block? + BMI L7F50 ;Yes, proceed to scan for alt blk + BVC L7F57 ;If V=1, then we will be assembling + ASL CondAsmF ; alt block so set flag to $80 +; +L7F50 LSR ZAB ;Clear msb (=$7F) + JSR L80F7 ;Do we have a FIN/ELSE? + BCC L7F77 :No, skip assembling src line +; +; Assemble curr src line +; Should be the lexical analyser/scanner +; +L7F57 LDA (SrcP),Y ;Pure comment line? + CMP #'*' + BEQ L7F77 + CMP #' ;' + BEQ L7F77 ;Yes, ignore curr src line +; +; Ignore the label field and go directly to +; the mnemonic field +; + JSR L81F0 ;Skip over non-blanks + BNE L7F6E ;Got a cr + JSR NxtField ;Skip over 1 or more blanks + JSR HndlMnem + BCC L7F7A +; +L7F6E LDX #$04 ;undefined opcode + JSR RegAsmEW +L7F73 LDX #3 + STX Length +L7F77 JMP L806F +; +L7F7A STA ZAB ;1st flag byte after mnem/directive byte + BIT Bit80 ;Directives? + BEQ CodeGen ;No + CMP #$83 ;1000 0011 + BNE L7F88 + JMP L807A ;Skip listing & storing generated code +; +L7F88 CMP #$81 ;1000 0001 + BNE L7F77 + STA LstCodeF ;$81 - these control directives + LDA ValExpr ; have expr result field which + STA ERfield ; is printed to right of PC field + LDA ValExpr+1 + STA ERfield+1 + JMP L806F ;list code, store generated code +; +Bit80 DB $80 +; +; Prepare to generate code +; +CodeGen JSR GInstLen ;Determine instr's len + LDA #$27 ;0010 0111 + STA LstCodeF + LDX #0 + LDA ModWrdL + BIT Bit40 ;sw16 opcode? + BEQ L7FCB ;No + LDA SW16F + BNE L7FB5 + LDX #$42+1 ;odd-warning + JSR RegAsmEW ;sw16 opcode +; +; This part is for SW16 ops +; + LDX #$00 +L7FB5 LDA SubTIdx + TAY + LDA OpcodeT,Y ;Get SW opcode +L7FBB CMP #$10 ;Non-reg ops? + BCC GenNow ;Yes +; + JSR IsSW16Reg + BNE L7F73 ;No + LDA OpcodeT,Y ;Get sw16 reg opcode + ORA ValExpr ;=Rn + BNE GenNow ;always +; +; This part of the code is for 6502 ops and is used +; by the Code Generator to compute the index to the +; actual opcode within the OpcodeTable +; NB: Highly dependent on the 3 bytes following +; a mnemonic entry & arrangement data in the various +; tables like AModTbl, OpcodeT etc. See comments +; b4 MnemTbl for more info +; (A)=1st flag byte after a mnenmonic entry +; +L7FCB AND #%00000101 ;zp,Y/JMP/JSR/(zp) + ORA ModWrdH + BEQ L7FED ;single byte ops (A)=0 + LDA LenTIdx ;Index into inst len table + BPL L7FD6 ;always! +L7FD5 BRK +L7FD6 CMP #9 ;0-8 (first 9 modes of AModTbl) + BCC L7FED + CMP #12 ;(abs,X) + BNE L7FE5 + JSR Is65C02 ;Are 65C02 opcodes allowed? + BCS L8002 ;No + BCC L7FE7 +L7FE5 BCS L7FD5 ;CRASHED! +; +; On fall thru, (A)=9-11 => (abs), acc, zp,Y addr modes +; +L7FE7 AND #%00000011 ;(A) -> 1-3 + BNE L7FED +; + LDA #2 ;JMP (abs,X) +; +; Single byte & branch ops don't have sub-tables +; Instead the (SubTIdx) is just the index into +; the opcode table. For these ops, (A) must be +; to 0 +; +L7FED CLC + ADC SubTIdx ;Calc the index into opcode table + TAY + LDA CycTimes,Y + STA NumCycles + LDA OpcodeT,Y ;get opcode + BIT X6502F ;R 65C02 ops allowed? + BMI GenNow ;Yes +; + JSR IsC02Op ;Is the opcode valid? + BCC GenNow ;Yes +; +L8002 LDX #$48 ;65C02 addr mode/opcode + JSR RegAsmEW + JMP L7F73 +; +; Code Generation +; Relocation Dictionary entries are created for +; 1) all 6502 opcodes except branch & single byte ops +; 2) DFB,DDB,DW pseudo ops +; 3) SW16 pseudo ops +; +GenNow STA GMC,X ;X=0 -> save opcode + INX + STX GMCIdx + LDA ModWrdL + BIT Bit08 ;branch instr? + BNE L8038 ;Yes +; + TXA ;X=1 on fall thru + CMP Length ;Single byte ops? + BCS L8025 ;Yes + LDA ValExpr + STA GMC,X + INX + LDA ValExpr+1 + STA GMC,X + INX ;unnecessary inst +; +L8025 LDX Length + DEX + BEQ L806F ;Single byte ops + LDA RelExprF ;Is expr's val abs? + BEQ L806F ;Yes +; + LDA #1 ;offset + LDY #0 ;Little Endian (Reverse) + JSR AddRLDEnt ;Make an RLD entry + JMP L806F +; +; Branch instructions +; +L8038 LDA ValExpr ;Branch target addr to + STA ERfield ; be printed to right of + LDA ValExpr+1 ; branch object code + STA ERfield+1 + LDA LstCodeF + ORA #$80 + STA LstCodeF + JSR CalcDisp +; + LDX GMCIdx + LDA ModWrdL + AND #$10 ;BRL/BSL? + TAY + BNE L8063 ;yes +; +; 6502/C02 +; + LDA ValExpr ;(Y)=0 + BPL L8058 ;Forward branch + INC ValExpr+1 ;=0 +L8058 LDA ValExpr+1 ;(ValExpr) has displacement byte + BEQ L8063 + LDX #$26 ;branch range err + JSR RegAsmEW +; + LDX GMCIdx +L8063 LDA ValExpr + STA GMC,X + TYA ;6502 branch instr? + BEQ L806F ;Yes + INX + LDA ValExpr+1 ;SW16 BSL/BRL + STA GMC,X +; +L806F JSR PrtAsmLn + JSR StorGMC + LDA Length + JSR AdvPC +; +L807A JSR PollKbd + BCS L8088 + JSR NextRec + JSR L81A3 + JMP Pass2Lup ;Assemble next srcline +L8088 JMP CanclAsm + REP 50 +; +; Chk if instruction is to be printed +; C=0 - Yes +; C=1 - No +; +RVLsting CLC + LDA ErrorF ;Was an error reported for this srcline? + BNE doRTS5 ;Yes + BIT CondAsmF ;Has this line been assembled? + BPL L8098 ;Yes + BIT LstUnAsm ;Print unasm src block? + BPL L80A4 ;No +L8098 BIT MacroF ;Is line a result of mac exp? + BPL L80A0 ;No + BIT LstExpMac ;List such lines? + BPL L80A4 ;No +L80A0 BIT ListingF ;Is listing ON? + BMI doRTS5 ;Yes +L80A4 SEC +doRTS5 RTS + REP 50 +; +; Print Assembled Line +; +PrtAsmLn JSR RVLsting + BCS doRTS6 ;No + JSR ListCode ;Print generated code + JSR LstSrcLn ;Print src stmt +doRTS6 RTS + REP 50 +; +; Store generated machine code +; +StorGMC LDY Length ;# of bytes + BEQ doRTS7 +; + LDY #0 +L80B8 LDA GMC,Y + BIT GenF ;Is code generation suppressed? + BMI doRTS7 ;Yes + BVS L80C5 ;Write to disk + STA (ObjPC),Y ;Write to mem + BVC L80C8 ;Always +L80C5 JSR Wr1Byte +L80C8 INY + CPY Length + BNE L80B8 ;Next byte +; + BIT GenF ;Did we do a mem store? + BVS doRTS7 ;No, a disk store + TYA + JSR AdvObjPC +doRTS7 RTS + REP 50 +; +; ($80D6) (A)=byte to store in mem/disk +; +StorByt BIT GenF ;Suppress code generation? + BMI doRTS8 ;Yes + BVS L80F1 ;Write to Disk + LDY #0 + STA (ObjPC),Y + INC ObjPC + BNE L80E6 + INC ObjPC+1 +; +L80E6 LDA ObjPC ;Are we out of mem? + CMP HighMem + LDA ObjPC+1 + SBC HighMem+1 + BCS L80F4 ;Yes +doRTS8 RTS +; +L80F1 JMP Wr1Byte +; +L80F4 JMP L8282 ;err + REP 50 +; +; ($80F7) Do we have a FIN/ELSE statement? +; Scan curr line for conditional block directives FIN/ELSE +; C=0 - no +; C=1 - yes +; (SrcP) & Y-reg preserved +; +L80F7 STY SavIndY ;Index into field of src line + LDA SrcP + PHA + LDA SrcP+1 + PHA + JSR L81F0 ;Look ahead for a space + BNE L812D ;None found +; + JSR SkipSpcs ;Skip until non-blank + JSR AdvSrcP ;Now pointing @ pseudo code field +; + LDX #3 ;Y=0 +L810C JSR ChrGot + CMP FINTxt,Y + BNE L811A + INY + DEX + BNE L810C + BEQ L812A ;Got a hit +; +L811A LDY #0 + LDX #4 +L811E JSR ChrGot + CMP ELSETxt,Y + BNE L812D + INY + DEX + BNE L811E +L812A SEC ;got a hit + BCS L812E ;always +; +L812D CLC +L812E PLA + STA SrcP+1 + PLA + STA SrcP + LDY SavIndY + RTS +; +FINTxt ASC 'FIN' +ELSETxt ASC 'ELSE' + REP 50 +; Add an entry to the relocation entry dictionary table +; Entry: +; (CodeLen) - zeroed whenever the initial srcfile is read +; A=offset +; X=1,2; 1 - 8-bits, 2 - 16-bits +; Y=order of bytes 0=DW(low-hi), 1=DDB(hi-low) +; On 6502, normal order is lower 8 bits of a 16-bit +; value is stored in 1st byte and upper 8-bits in 2nd +; byte (pg 103). However, according to page 229, +; normal order is DDB. +; The Relocation Dictionary is build downwards from +; high mem towards the End of Symbol Table +; The initial start of the RLD is @ MemTop +; & is build downwards towards LoMem +; Each entry is 4 bytes +; +AddRLDEnt BIT RelCodeF ;Gen REL code? + BMI L8143 ;yes + RTS +; +L8143 PHA + LDA RLDEnd ;Chk if there is enough mem + SEC + SBC #4 ; for 1 RLD entry (4 bytes) + STA RLDEnd + LDA RLDEnd+1 + SBC #0 + STA RLDEnd+1 +; + LDA EndSymT + CMP RLDEnd + LDA EndSymT+1 + SBC RLDEnd+1 + BCC L8163 + LDX #$12 ;Sym/RLD table full! + JSR RegAsmEW + JMP CanclAsm +; +L8163 DEX ;Do we have a 2-byte operand? + TXA ;NB. Acc=0 on fall thru. + BNE L8170 ;Yes +; + LDX Ret816F ;Are we using hi-8 bits? + DEX + BMI L8178 ;No, lo-8 bits with (A)=$00 + LDA #$40 ;Yes + BNE L8178 ;always +; +; Bits of the RLD flag byte are defined as follows: +; $80 - sizeof relocatable field +; $40 - Upper/Lower 8 if a 16-bit value +; $20 - Normal/reversed 2-byte field +; $10 - Field is EXTRN 16-bit reference +; $01 - "Not EO RLD" (Clear => EO RLD) +; +L8170 TYA ;Y=0 or 1 + ASL + ASL + ASL + ASL + ASL ;-> $00(Reverse) or $20 (Normal) + ORA #$80 ;Sizeof relocatable field=2 bytes +; +L8178 ORA #$01 ;Flag 'Not EO RLD' => more entries + LDY GblAbsF + BEQ L8180 ;ZDEF/ZREF + ORA #$10 ;EXTRN 16-bit reference +; +; RLD entries are build downwards from high mem +; +L8180 LDY #3 + STA (RLDEnd),Y ;Set RLD flagbyte + PLA ;Restore offset + CLC + ADC CodeLen ;Calc the offset in image + DEY ;Y=2 + STA (RLDEnd),Y + LDA #0 + ADC CodeLen+1 + DEY ;Y=1 + STA (RLDEnd),Y + DEY ;Y=0 +; +; Set 4-th byte of an RLD entry. First we check if the symbol refers +; to an 8-bit or 16-bit address. If it's a 16-bit address +; then 4-th byte takes a valid value which is an ESD number. +; + LDA GblAbsF ;ZDEF/ZREF? + BNE L81A0 ;No => DEF/EXTRN (A)=ESD # +; +; The operand refers to an 8-bit value. Check if +; #addr16. If the former, return a 0 +; else return the low 8-bit value of the 16-bit +; address in 4-th byte of the RLD entry. +; + LDA #0 + LDX Ret816F ;-1,0,1 + DEX + BMI L81A0 ;It's # and CR for ProDOS +; +WhiteSpc LDA (SrcP),Y + CMP #SPACE + BEQ doRet + CMP #CR +doRet RTS + REP 50 +; +; This subrtn is part of Scanner +; There are 2 entry points viz ChrGet and ChrGot +; On entry: +; (Y) = index into the src line +; (SrcP) = Pointing somewhere within source line +; Ret: +; (A) - char (converted to uppercase if alphabetic) +; C=1 if char is non-alphabetic +; C=0 if char is alphabetic (A-Z, a-z) +; Z=1 if char is numeric digit (0-9) +; Z=0 if char is non-numeric +; V=1 if char is hexdec digit (0-9, A-F, a-f) +; V=0 if char is non-hexdec +; (X) - unchanged +; (Y) - incr by 1 if 1st entry point else unchanged +; +ChrGet INY +ChrGot LDA (SrcP),Y ;Get char fr src line + STY ZPSaveY ;Save (Y) temporarily + TAY ;Use char as an index as well as saving it in (Y) + BPL L8211 ;Must be std ASCII or +; + BRK ;else crash +; +L8211 LDA CharMap1,Y ;Get flag byte + PHA ;Save for later use + TYA ;Get back char + LDY ZPSaveY ;restore Y + PLP ;Now set up Status reg - neat + BPL doRet2 ;If (A)=$61-$7A (a-z) + AND #$DF ; convert to upper case +doRet2 RTS + REP 50 +; +; This subrtn is part of Scanner +; Same logic as above except CharMap2 is used +; Entry: +; (Y) = index into src line +; Ret: +; (A)=char (uppercase if alphabetic) +; C=0 - alphanumeric char +; C=1 - non-alphanumeric char +; V=0 - non-hexdec char +; V=1 - hexdec char +; (X) - unchanged +; +ChrGet2 INY +ChrGot2 LDA (SrcP),Y + STY ZPSaveY + TAY + BPL L8227 +; + BRK ;source file must be std ASCII +; +L8227 LDA CharMap2,Y ;Get the bit flags + PHA + TYA + LDY ZPSaveY + PLP ; and pop into Status reg + BPL doRet3 + AND #$DF +doRet3 RTS + REP 50 +; +; On entry +; (Y)=index into src line +; Ret: +; (Y)=0 +; src ptr pointing @ 1st char of the field +; (X) - unchanged +; +NxtField LDA (SrcP),Y + CMP #SPACE + BNE L823D + INY + BNE NxtField +; +L823D CLC + TYA + ADC SrcP + STA SrcP + LDA #0 + TAY ;(Y)=0 + ADC SrcP+1 + STA SrcP+1 + RTS + REP 50 +; +; Set SrcP to beginning of next assembly src line +; Source Lines are terminated with a CR +; (X)-unchanged +; Ret with (Y)=0 & src ptr pointing @ 1st char of line +; +NextRec LDY #0 +L824D LDA (SrcP),Y + INY ;NB: skip past char + CMP #CR ; b4 comparision + BNE L824D +; +; On fall thru, Y=# to advance +; +AdvSrcP CLC + TYA + ADC SrcP + STA SrcP + LDA #0 + TAY ;=0 + ADC SrcP+1 + STA SrcP+1 + RTS + REP 50 +; +; A=# to advance +; +AdvPC CLC + ADC PC + STA PC + BCC doRet4 + INC PC+1 +doRet4 RTS + REP 50 +; +; A=# to advance +; +AdvObjPC CLC + ADC ObjPC ;code buf + STA ObjPC + BCC L8275 + INC ObjPC+1 +L8275 JMP L828A + REP 50 +; +; Not referenced +; +L8278 LDA MemTop + CMP ObjPC + LDA MemTop+1 + SBC ObjPC+1 + BCC L828A +; +L8282 LDX #$36 ;Obj buf overflow + JSR RegAsmEW + JMP CanclAsm +; +L828A LDA ObjPC ;Should not be >= HiMem + CMP HighMem ; which was passed by Editor + LDA ObjPC+1 + SBC HighMem+1 + BCS L8282 + RTS +;================================================= +; ($8295) +; This subrtn is called periodically within a loop +; to check if user wants +; 1) to stop the assembly - Abort Mode +; 2) a pause during a listing - Pause Mode +; 3) turn listing on/off +; 4) to shift listing left/right for 40-col display +; Ret: +; C=1 if ctrl-C pressed +; +PollKbd LDA KBD + BMI L829C +L829A CLC + RTS +; +L829C STA KBDSTROBE + CMP #CTRLC+$80 + BNE L82A7 + DEC AbortF ;Pending + SEC + RTS +; +L82A7 LDX PassNbr ;doing pass 1? + BEQ L829A ;Yes + CMP #BS+$80 + BNE L82B9 +; +; EdAsm.ASM allows an 80-col listing to be viewed on a 40-col video screen +; Move the 40-col window one column to left edge of the 80-col listing +; + LDA WinLeft + BEQ L829A +L82B3 DEC WinLeft + DEC WinRight + BNE L829A ;always +; +L82B9 CMP #CTRLU+$80 ;RArrow + BNE L82C9 +; +; Move the 40-col window one column to right edge of the 80-col listing +; +L82BD INC WinLeft + INC WinRight + LDA WinLeft + CMP #40 + BCS L82B3 + BCC L829A ;always +; +L82C9 CMP #SPACE+$80 + BEQ WaitK3 + CMP #CTRLO+$80 + BNE L82D6 + SEC + ROR ListingF ;Turn on listing + CLC + RTS +; +L82D6 CMP #CTRLN+$80 + BNE L829A + LSR ListingF ;Turn off listing + CLC + RTS +; +WaitK3 LDA KBD ;Get another keypress + BPL WaitK3 ; before continuing + CLC + RTS +;================================================= +Wait4CR BIT KBDSTROBE + JSR PrtCR + LDX #>ContTxt-ASEndTxt + JSR L986A +WaitK4 LDA KBD + BPL WaitK4 + BIT KBDSTROBE + CMP #CR+$80 + BNE WaitK4 + JSR PrtCR + RTS +;================================================= +; Compute relative addr of a branch op +; Ret: +; Val=Val-PC-Len +; +CalcDisp SEC + LDA ValExpr + SBC Length + TAX + LDA ValExpr+1 + SBC #0 +; + TAY + TXA + SEC + SBC PC + STA ValExpr + TYA + SBC PC+1 + STA ValExpr+1 + RTS +;================================================= +; (A) = opcode +; Check if (A) is NCR 65C02 opcode +; C=1 - yes +; (X)-unchanged +; +IsC02Op LDY #0 +L8319 CMP L8327,Y + BCC doRet5 + BEQ doRet5 + INY + CPY #$12 + BCC L8319 + CLC +doRet5 RTS +; Rockwell opcodes +L8327 DB $04,$0C,$14,$1A,$1C,$34,$3C,$3A,$5A + DB $64,$74,$7A,$80,$89,$9C,$9E,$DA,$FA +;================================================= +; Process mnemonic/pseudo opcode field +; Ret +; $AB) - 1st flag byte if not a directive +; - may be changed to $83 if data directives +; - $80 if macro invocation +; (A)=($AB) +; C=0 - succ +; C=1 - fail +; +HndlMnem LDA #$80 + STA ZAB + JSR ChrGot + BCC L8348 ;alphabetic char + CMP #'.' ;If a DOT directive + BNE L83AC + LDA #'A'-1 ; use ASCII @ in place of dot +L8348 SEC + SBC #'A'-1 + ASL + TAX + LDA Tbl1stLet,X + STA MnemP + LDA Tbl1stLet+1,X + BEQ L839C ;No such opcode/directive w/this 1st letter + STA MnemP+1 +L8359 JSR ChrGot ;Note:msb of char=0 + EOR (MnemP),Y ;Effectively comparing 7 bits + ASL ;C=1 if last char of opcode was compared + BNE L837E ;No hit +L8361 INY ;Z=1 => 7 bits comparison above matched + BCC L8359 ;Continue to cmp next char +; +; On fall thru, if C=1 then that was last char/byte of +; mnemonic entry & we have got a match +; + JSR WhiteSpc ;sp/cr? + BNE L8386 ;no + LDA (MnemP),Y ;Get 1st flag byte + STA ZAB + BPL L837C ;Not a directive +; +; This part of the code handles directives by doing a jump via RTS +; (ZAB) has the directive's only flag byte which may be modified +; by the directive handler +; + STY SavIndY ;Save index into Mnemonics table + INY + LDA (MnemP),Y ;Get RTS addr-1 (hibyte) + PHA + INY + LDA (MnemP),Y + PHA ;lobyte + LDY SavIndY ;Restore index + RTS +L837C CLC ;6502/SW16 opcode + RTS +; +L837E LDA (MnemP),Y ;Skip rest of entry + BMI L8385 ;Last byte of entry has msb=1 + INY + BNE L837E +; +L8385 INY +L8386 SEC ;Add 3 more bytes + INY + INY + TYA + ADC MnemP ; to skip + STA MnemP + BCC L8392 + INC MnemP+1 +; +L8392 LDY #0 ;Try next entry with + JSR ChrGot + EOR (MnemP),Y + ASL + BEQ L8361 ; the same first letter +; +; Not mnemonics/pseudo code/directive +; Assume it's a macro invocation +; +L839C LDA MacroF ;Are macros allowed? + BEQ L83AC ;No + BMI L83A4 ;Invocation fr a macro defn file -> err + BPL L83AE ;No, so it's ok +; +L83A4 LDX #$18 ;Macro nesting +L83A6 JSR RegAsmEW + JMP DrtvDone +L83AC SEC ;Flag it's an err + RTS +; +L83AE BIT DskSrcF ;Are we assembling fr disk? + BPL L83A4 ;No + JSR L9DF8 ;Incr line #? + JSR LD3B4 ;Save ptr to next src line + LDX #MacFile + JSR L9D51 ;Save curr line # of src line + JSR SetPNBuf ;Use macro PN buf + LDA MacroPNB ;Len of maclib prefix + STA MacPNLen + BEQ L83CD ;No prefix was declared +; + JSR L83F4 ;Form fullpathname of macro defn file + JMP L83D0 +; +L83CD JSR GetPNStr ;Get macro defn filename into MacroPNB buf +L83D0 CMP #SPACE+1 ;Is it a space/cr? + BCC L83DD ;Yes +; + LDA MacPNLen + STA MacroPNB ;Reset the len maclib prefix + LDX #$34 + BNE L83A6 ;Invalid delimiter error +; +L83DD JSR AdvSrcP ;Point @ BO string parmlist + LDX #$40 + STX MacroF ;Flag a macro had been invoked + LDX FCTIndex + JSR Open4RW ;Open Macro defn file for reading + LDA MacPNLen + STA MacroPNB ;Set back to maclib name (neat trick) + JSR L841A ;Parsed passed STR parms + JMP DrtvDone +;================================================= +; Append macro name to MacroLib subdir/prefix +; to create a full pathname to macro defn file +; +L83F4 LDX MacroPNB ;Get len byte of maclib prefix + LDY #0 ;Starting fr 1st char of filename +L83F9 JSR WhiteSpc ;Get a char fr src line + BEQ L8416 ;sp/cr? + JSR ToUpper + CMP #SPACE + BCS L8408 +L8405 JMP L92D6 ;error +; +L8408 INX + STA MacroPNB,X + INY + CPX #64 + BCC L83F9 + JSR WhiteSpc + BNE L8405 ;If not cr/space, too many +L8416 STX MacroPNB ;Set len byte + RTS +;================================================= +; String parameters in the operand field of the +; asm statement containing the macro name are parsed +; and stored into a 128-byte buf. To pass a comma, +; use $2C or $AC. +; Pg 115 +; C=0 parsing successful +; +L841A LDA #0 + STA MParmCnt ;# of string parms passed + LDX #127 + LDA #0 +L8422 STA MacStrBuf,X ;zero buf + DEX + BPL L8422 +; + LDY #0 + JSR NxtField ;Point @ operand field + JSR WhiteSpc + BEQ doRet6 ;sp/cr +; +L8432 LDA (SrcP),Y ;Get char fr passed string parm + CMP #CR + BEQ L8446 ;done + CMP #',' ;If not a delimiter, + BNE L8440 ; just copy it into our buf + LDA #0 ;Replace w/0 as delimiter + INC MParmCnt +L8440 STA MacStrBuf,Y + INY + BNE L8432 ;Next char +; +L8446 LDA #0 ;Place 0 as last delimiter + STA MacStrBuf,Y + INC MParmCnt + LDA MParmCnt + CMP #10 + BCC doRet6 ;Any # of str parms can be passed + LDA #9 ; but only 9 will be processed + STA MParmCnt +doRet6 RTS +;================================================= +; ($8458) We must determine the address mode of opcode +; Ret: +; Length of instruction opcode +;================================================= +GInstLen STA ModWrdL ;1st flag byte + INY + LDA (MnemP),Y ;2nd flag byte - addr mode bits + STA ModWrdH ; of this mnemonic + INY + LDA (MnemP),Y + STA SubTIdx ;Index into sub-table of opcode table + DEY + DEY ;Moveback to 1st flag byte + JSR NxtField ;Point @ operand field +; + LDA #0 + STA LenTIdx + STA ValExpr ;val of operand if any + STA ValExpr+1 +; + LDA ModWrdL + BIT ModWrdL + BMI L84CE ;Directives/SET + BIT Bit20 + BNE L84D4 ;Implied + BIT Bit08 + BNE L84D9 ;Branch opcodes +; +; There are now thirteen X6502 addr modes to consider +; + JSR GAdrMod ;Get an index to addr mode table + BCS L84FE ;error +; +; Checks the returned/parsed addr mode against permitted modes +; +ChkAMod STA LenTIdx ;=0-12 + TAX + LDA AModTbl,X ;Get the parsed addr mode +; + CPX #8 + BCC L849B +; +; When (X)=8-12, the addressing modes are: +; (zp), (abs), acc, zp,Y & (abs,X) +; + AND ModWrdL ;1st flag byte + AND #%00000111 ;Retain only these bits + CMP AModTbl,X ;Is addr mode valid? + BEQ L8502 ;Yes + BNE L849F ;=> Further checks +; +; X=0-7 The bits of ModWrdH (2nd flag byte) are completely defined +; +L849B BIT ModWrdH ;Is the returned mode valid? + BNE L8502 ;Yes +; +L849F CPX #11 ;Was mode parsed as zp,Y? + BNE L84A7 ;No + LDA #5 ;Force the mode as + BNE ChkAMod ; abs,Y (for LDA/STA) +; +L84A7 CPX #1 ;Was mode parsed as zp? + BNE L84B5 ;nope + LDA ModWrdL + AND #%00010000 ;JMP/JSR? + BEQ BadMode ;No + LDA #0 ;Allow for JMP/JSR zp but + BEQ ChkAMod ; convert 'em to JMP/JSR abs (always) +; +L84B5 CPX #8 ;Was mode parsed as (zp)? + BNE BadMode ;No + LDA ModWrdL + AND #%00010000 ;JMP? + BEQ BadMode ;No + LDA #9 + BNE ChkAMod ;Convert to JMP (abs) (always) +; +BadMode LDX #$1C ;addr mode error + JSR RegAsmEW + LDA #$00 + STA LenTIdx ;Assume abs mode addressing + BEQ L84FE ;always +; +L84CE BVS L8513 ;=> SET directive + LDA #$00 ;zero len + BEQ L8511 ; for directives +;--- +L84D4 LDA #1 ;Single byte opcodes + BNE L8511 ;always +; +Bit20 DB $20 +; +;--- Branch opcodes (both 65C02/SW16) +; +L84D9 LDA #$00 ;There are no sub-tables for such + STA LenTIdx ; opcodes so set this index to 0 + LDX #2 ;len of instr + LDA ModWrdL + AND #$10 ;BSL/BRL? + BEQ L84E6 ;No + INX ;=3 +L84E6 STX Length + JSR EvalExpr + LDA PassNbr + BEQ L8513 + BCC L8513 + LDA NxtToken + CMP #$34+$80 ;Invalid delimiter + BNE L84FE + TAX + JSR RegAsmEW + JMP L8513 +; +L84FE LDA #3 ;len of instruction + BNE L8511 ;always +; X=0-12 +L8502 LDA ModWrdL + BIT Bit40 ;sw16? + BEQ L850E ;no + LDA L851F,X ;Get instr len + BNE L8511 ;always +; +L850E LDA InstLenT,X ;Get instr len +L8511 STA Length +L8513 LDA Length + RTS + REP 50 +; +; (X)=index into addr mode table +; Not only this, it can be used to index an opcode within +; a sub-table of opcodes (eg ADCOps) by adding it to SubTIdx +; This table is highly dependent on the meaning of the +; bits of the 2 mnemonic flag bytes +; +InstLenT DB $03 ;abs + DB $02 ;zp + DB $02 ;# + DB $02 ;zp,X + DB $03 ;abs,X + DB $03 ;abs,Y + DB $02 ;(zp),Y + DB $02 ;(zp,X) + DB $02 ;(zp) +; +; This sub-table is used by SW16 opcodes +; +L851F DB $03 ;(abs) - CPIM + DB $01 ;acc - SW16 Reg ops + DB $02 ;zp,Y + DB $03 ;(abs,X) +; +; bit flags used to check the validity of +; the parsed addressing mode +; +AModTbl DB $01 ;abs + DB $02 ;zp + DB $04 ;imm + DB $08 ;zp,X + DB $10 ;abs,X + DB $20 ;abs,Y + DB $40 ;(zp),y + DB $80 ;(zp,X) + DB $03 ;(zp) +; + DB $01 ;(abs) + DB $02 ;acc + DB $04 ;zp,Y + DB $01 ;(abs,X) +;================================================= +L8530 LDX #$34 ;invalid delimiter + JSR RegAsmEW + SEC + RTS + REP 50 +; +; This subrtn will parse the addressing mode of the +; operand of a 6502 mnemonic/SW16 psuedo opcode +; Ret +; (A)=index (0-12) use to get addr mode fr a table +; C=0 - succ +; C=1 - syntax error +; +; To trace this rtn, re-assemble the code by doing +; an ORG $5800 for the tables and code @ $D000 (ASM1.S) +; Under the EI interpreter, xload EDASM.ASM2,A$5800 +; xload bugbyter,a$1000 +; Enter MONitor and type 1000G +; +GAdrMod LDX #0 ;X=index into the 2 tables + LDY #0 ;Position @ start of operand +L853B JSR ChrGot ;Y=index into operand text + ORA #$80 + CMP AModTkns,X + BEQ L855E ;Got a hit +; + LDA AModTkns,X ;Get a token + BPL L8570 ;Not a char +; + CMP #SPACE+$80 + BNE L8554 +; +; Token is $A0 +; + LDA #CR ;Is char a cr? + CMP (SrcP),Y + BEQ L8563 ;Yes, eol +; +; On fall thru, if token is $A0 and CR not found +; +L8554 LDA AModCmds,X + BEQ L855E ;=> next token & src char + BMI L8583 ;Error token + TAX ;Index to next token fr $D7D7 table to be + BNE L853B ; used to cmp against SAME char of src code +; +; No fall thru here +; Proceed to get next token of $D7D7 table +; and next char of src to be compared +; +L855E INX ;next token + INY ;next src char + JMP L853B +; +; Got a CR +; +L8563 INX ;Prepare to look at next token + DEY ;Index prev src char + LDA AModTkns,X + BEQ L856C ;$A0+cr followed by $00 + BPL L858B ;$A0+cr followed by +ve byte value (always) +; +L856C LDX #$0A ;expr syntax err- never reported! (LDA #$0A) + BNE L8583 ;always - bug? +; +L8570 BNE L858B ;token > 0 +; +; Got a $00 token +; + STX SavIndX ;Save X + JSR EvalExpr + LDX SavIndX + BCC L8554 ;No errs during evaluation + LDA NxtToken + AND #$7F + CMP #$34 ;Invalid delimiter + BNE L8589 +; +; (A) = error token +; +L8583 TAX ;(X) overwritten! Is it a bug? + PHA ;Save error token + JSR RegAsmEW + PLA +L8589 SEC + RTS +; +L858B LSR ;If odd then + BCC L8590 + CLC ; ret to caller w/mod2 which + RTS ; is an index to Adr Mode Table +; +L8590 ASL ;Even, get back token first + JSR L8598 ;Now, execute helper function + BCC L855E ;Loop back to process next src char + BCS L8554 ;Go get index to next token + REP 50 +; +; Calls help subroutines (functions). +; Only 3 defined so far. +; Entry +; (A)=2,4,6 - index into subrtn table +; +; The helper functions with return the required values +; primarily the C bit +; +L8598 STX SavIndX + TAX ;Token is an index + CPX #7 ;Only 3 subrtns currently + BCC L85A0 + BRK +; +L85A0 LDA L85AE-1,X ;Prepare for JMP + PHA + LDA L85AE-2,X ;lobyte + PHA + JSR ChrGot ;Get curr char +L85AB LDX SavIndX + RTS ;Do the JMP now +; +L85AE DW IsZPMod-1 + DW IsAccMod-1 + DW Is65C02-1 + REP 50 +; +; Checks if expr is a 8-bit or 16-bit value +; For addressing modes involving zp +; Ret: +; C=0 - Yes +; C=1 - No +; +IsZPMod LDA ExprAccF + AND #%11101111 ;Clear EXTeRNal symbol bit + ORA ValExpr+1 ;Is hi-byte of expr zero? + BEQ L85CF ;Yes => 8-bit + LDA ExprAccF + AND #%00010000 ;Is EXTeRNal symbol bit set? + BEQ L85C6 ;No + LDA Ret816F ;EXTRN but is lo-byte being returned? + BEQ L85C8 ;Yes +L85C6 SEC ;16-bit + RTS +; +L85C8 LDX #$44+1 ;odd-warning + JSR RegAsmEW ; (EXTRN used as ZXTRN) + LDX SavIndX +L85CF DEY ;Move back + CLC + RTS + REP 50 +; +; Check a single 'A' in the operand field +; i.e. checking for accumulator mode +; Entry: +; (A)=char to check +; Ret: +; C=0 - Yes +; C=1 - No +; +IsAccMod CMP #'A' + BNE L85DD + INY ;Look 1 char ahead + JSR WhiteSpc ;Is the next char sp/cr? + BEQ L85CF ;Yes, we have a single 'A' in operand field + DEY ;No, just move back +L85DD SEC + RTS + REP 50 +; +; Check if 65C02 opcodes are valid +; Only Status reg is changed +; Ret: +; C=0 - Yes +; C=1 - No +; NB. If X6502F off, LDA (ZP) is still considered +; valid. It is equivalent to LDA ZP +; +Is65C02 BIT X6502F ;Are X6502 opcodes allowed? + BMI L85CF ;Yes + BPL L85DD ;always + REP 50 +; +; Evaluate expressions. No check for numeric overflow +; Support for +,-,;,/ and bitwise AND ^, OR |,EOR ! +; Ref pg 89 for Expression Syntax adopted for Assembler +; +; Expression := [byteopr] Term [opr Term]...] +; byteopr := >, < +; +; Meaning of: +; ExprAccF - Expression's accumulated flag bits +; NxtToken - Use to chk for eo expr(sp/cr), comma, ) +; Error if -ve +; SavSEF - prev subexpr's RelExprF +; RelExprF - non-zero if subexpr is evaluated fr a relocatable addr +; - zero, it's fr an abs addr +; Ret +; (A)= +; C=0 - no errors parsing +; C=1 - err during eval +; +; NB. If relocatable code is generated, only +,- can be used +; +EvalExpr LDA #$00 + STA RelExprF ;Assume expr's val is absolute not relative + STA ExprAccF + STA NxtToken + STA GblAbsF ;Assume ZDEF/ZREF + JSR SkipSpcs +; +; Check for the presence of the byte operators +; Set (Ret816F) +; (-1) - 16-bits; 0 - low 8-bits, 1 - hi 8-bits +; + LDA #-1 ;Default is to ret a 16-bit value + STA Ret816F + LDA (SrcP),Y + CMP #'<' ;EDASM not MERLIN! + BNE L8601 + INY + INC Ret816F ;=0 + BEQ L8606 ;Proceed to set to 1 +L8601 CMP #'>' + BNE L8608 + INY +L8606 INC Ret816F ;0-lobyte, 1-hibyte +; +L8608 CMP #'-' ;unary ops + BEQ L8610 + CMP #'+' + BNE L8618 ;Get on with it +; +L8610 LDA #0 + STA ValExpr ;Returned value + STA ValExpr+1 + BEQ L8628 ;always +; +L8618 JSR EvalTerm ;The leading term is treated differently + LDA NxtToken ;Err? + BMI L869C ;Yes +; + LDA Accum + STA ValExpr ;Partial result + LDA Accum+1 + STA ValExpr+1 +L8627 INY ;Eval [opr term] +L8628 LDA (SrcP),Y + LDX #6 +L862C CMP Operators,X + BEQ L8636 + DEX + BPL L862C ;Chk next operator + BMI L8662 ;No hit +; +L8636 CPX #2 ;+/-? + BCC L864E ;Yes +; +; Perform additional checks for the operators +; /,;,&,^,| which cannot operate on rel expr/sub-expr +; + LDA RelExprF ;Is it a relative subexpr? + BEQ L864E ;No, abs + LDA PassNbr + BEQ L864E + BIT RelCodeF ;REL code output? + BPL L864E ;No, BIN +L8646 LDX #$08 ;rel exprn op + JSR L87FB + JMP L869C +; +L864E BIT RelCodeF + BPL L865C ;BIN + BIT Ret816F ;Are we returning a 16-bit value? + BMI L865C ;Yes + LDA #$10 ;Was an EXTeRNal symbol used + BIT ExprAccF ; during evaln? + BNE L8646 ;Yes +L865C JSR EvalSExpr ;Eval new sub expr + JMP L8627 ;Next [opr term] +; +L8662 LDX Ret816F ;-1,0,1 + BMI L8674 ;Return 16-bit value + BEQ L8670 ;Return val of lobyte +; + LDA ValExpr ;Save lobyte + STA Lower8 ; here and + LDA ValExpr+1 ; return val of hibyte + STA ValExpr ; by storing it here +L8670 LDA #0 + STA ValExpr+1 +; +L8674 JSR GNToken ;Chk for comma, ) and cr/space + ORA NxtToken ;In case of err + STA NxtToken +L867B LDA NxtToken + DEY ;Index prev char + CMP #$80 ;C=1 if err + RTS + REP 50 +; +; We are going to process a new subexpression +; after the operator +; X=0-6 +; +EvalSExpr LDA RelExprF + STA SavSEF ;Save it + LDA #$00 ;Assume absolute value + STA RelExprF + LDA L888E,X ;Get JMP addr-1 hibyte + PHA + LDA L8895,X ;lo byte + PHA + INY + JSR EvalTerm + LDA NxtToken + BNE L869A + RTS ;Combine the 2 subexprs +; +L869A PLA ;Dump JMP addr + PLA +L869C LDY #0 + DB $24 +L869F INY + JSR ChrGot2 ;alphanumeric char? + BCC L869F ;Yes, skip + JSR GNToken ;Is it cr/space,comma,) + BNE L869F ;No + BEQ L867B ;always + REP 50 +; +; Entry: +; (A)=char to check +; Ret: +; Z=1, (A)=0 if space/cr (white space) +; (A)=1 if char is , +; (A)=2 if char is ) +; Z=0, (A)=err token +; (Y)-unchanged +; +GNToken JSR WhiteSpc + PHP ;Save Z bit + TAX ;Save char in X-reg + LDA #$00 + PLP ;Was is a cr/space? + BEQ doRet7 ;Yes + LDA #$01 + CPX #',' + BEQ doRet7 + LDA #$02 + CPX #')' + BEQ doRet7 + LDA #$34+$80 ;err token +doRet7 RTS + REP 50 +; +; Process a term where +; Term := Constant, Identifier +; If a term is an idfer, look up its value +; Ret: +; (Y)=index src line? +; (Accum)= Term's 16-bit value +; NB. Y-reg seems to have a dual purpose. To index the +; src line and to index an entry of the symbol table +; Its returned value must be monitored and adjust correctly +; Todo: Need to check this more closely. +; +EvalTerm JSR AdvSrcP ;On ret, (Y)=0 + STY Accum + STY Accum+1 + JSR ChrGot ;Get 1st char + BCC L8716 ;Alphabetic char => idfer + BEQ L86D6 ;Numeric char + JMP L8781 ;Not alphanumeric +; +; Decimal constant +; +L86D6 LDA (SrcP),Y ;Get numeric char + SEC + SBC #'0' ;$30-$39 -> 0-9 + CLC + ADC Accum + STA Accum + BCC L86E6 + INC Accum+1 + BEQ L870E ;Overflow +L86E6 JSR ChrGet ;Look 1 char ahead + BEQ Mul10 ;If numeric, continue + DEY ;else move back and ret + RTS +; +; The next char is numeric so the +; accumulated result must be x 10 +; before we loop back to process it +; Logic: 2R x 2 x 2 + 2R = 10R +; +Mul10 JSR Mul2 ;2R + BCS L870E + LDA Accum+1 ;save temporarily + PHA + LDA Accum + JSR Mul2 ;2R x 2 + BCS L870D + JSR Mul2 ;4R x 2 + BCS L870D + ADC Accum ;+ 2R + STA Accum + PLA + ADC Accum+1 + STA Accum+1 + BCC L86D6 ;Loop back to process the next char + PHA ;overflow +L870D PLA +L870E JMP L87F9 ;error +;= +Mul2 ASL Accum + ROL Accum+1 + RTS +; +; Identifier +; +L8716 JSR RsvdId ;Chk single A,X,Y + BCC L871C + RTS ;error +; +L871C JSR FindSym + BCS L8757 ;Idfer's not in symbol table + TAX ;Save idfer's flag byte + CLC + BMI L8757 ;Idfer's undefined + AND #external ;0001 0000 Is it declared as an EXTeRNal? + BIT ExprAccF + BEQ L8734 ;Ifder is not EXTeRNal + STX SavFByt ;Save flag byte here while + LDX #$40 ; we report Duplicate EXT/ENT + JSR RegAsmEW + LDX SavFByt ;Get flagbyte back +L8734 TXA ; into (A) +L8735 AND #external+fwdrefd;0001 0001 + ORA ExprAccF + STA ExprAccF + TXA ;Test old flag byte + AND #external ;0001 0000 + BEQ L874A ;No, not EXTeRNal + LDA PassNbr + BEQ L8754 + LDA (SymP),Y ;LoByte of value field + STA GblAbsF ;0=>ZDEF/ZREF + BNE L8754 ;Its ENTRY/EXTRN +; +L874A LDA (SymP),Y ;Get value of symbolic idfer + STA Accum ; & ret it here + INY + LDA (SymP),Y + STA Accum+1 + DEY +L8754 DEY + DEY + RTS +; +; Identifer is undefined +; (A)-symbol's flag byte +; (Y)-indexing symbol's value field if symbol was found +; (Y)=0 if symbol not found +; +L8757 LDX PassNbr + BEQ L876F ;Its pass 1 + BIT Bit02 ;Is No-such-label error? + BEQ L8764 ;No + INC ErrorF ;Flag as err since its pass 2 + BNE L8769 ;=1 +L8764 ORA #nosuchlabel ;0000 0010 + DEY + STA (SymP),Y ;Modified flag byte +L8769 LDX #$00 ;Undefined idfer + DEY ;what's this for? + JMP L87FB ;Go report it +; +L876F TAX ;(A)=flag byte + LDA #fwdrefd ;0000 0001 + BCC L8735 ;Symbol was found but undefined + ORA ExprAccF ;Symbol not found + STA ExprAccF + LDA #undefined+fwdrefd;symbol's flag byte + JSR AddNode + DEY + DEY + DEY ;Indexing last char of symbolicname? + RTS +; +; 1st char is non-alphanumeric +; Is it an ASCII char const? +; +L8781 CMP #''' ;Opening single quote? + BNE L879E ;No + STY Accum+1 ;Zero the hibyte + INY + LDA (SrcP),Y ;Get char within quotes + CMP #CR + BNE L8791 + JMP L880F +; +L8791 ORA msbF + STA Accum + INY + LDA (SrcP),Y ;Look for a + CMP #$27 ; closing single quote + BEQ doRet8 ;Got one + DEY ;Move back +doRet8 RTS +; +; Program counter reference +; +L879E CMP #'*' ;Do we have a star? + BNE L87AF +; + LDA #relative ;Flag symbol's val is relative + STA RelExprF ; & not an absolute addr + LDA PC + STA Accum + LDA PC+1 + STA Accum+1 + RTS +; +; Checks for bin/octal/hexdec const +; +L87AF CMP #'%' ;binary + BNE L87B9 + LDA #'2' + LDX #$01 + BNE L87CB ;always +; +L87B9 CMP #'$' ;hexdec + BNE L87C3 + LDA #$C0 ;'@'+$80 + LDX #$04 + BNE L87CB ;always +; +L87C3 CMP #'@' ;octal + BNE L880F + LDA #'8' + LDX #$03 +L87CB STA RadixCh ;=$32,$38,$C0 + STX BitsDig ;=$01,$03,$04 +; +; Conversion starts here +; +L87CF JSR ChrGet ;Is next char hexdec? + BVC L8808 ;No + CMP #'9'+1 + BCC L87DA + SBC #$07 ;'A'-'F' ($41-$46) -> $3A-$3F +L87DA CMP RadixCh + BCS L8808 ;Not valid + LDX BitsDig + CPX #$03 + BEQ L87E8 ;Octal + BCS L87E9 ;HexDec +; + ASL ;binary + ASL +L87E8 ASL +L87E9 ASL + ASL + ASL + ASL +; +; binary x000 0000, octal xxx0 0000 hex xxxx 0000 +; (X)=# of shifts (% - 1, @ - 3, $ - 4) +; +L87ED ASL + ROL Accum + ROL Accum+1 + BCS L87F9 ;Overflow + DEX + BNE L87ED + BEQ L87CF ;Process another numeral +; +L87F9 LDX #$06 ;overflow +L87FB STX NxtToken + JSR RegAsmEW + LDA #$80 + ORA NxtToken + STA NxtToken ;$80,$86,$88,$8A + NOP + RTS +; +L8808 DEY ;Move back + JSR ChrGot + BVC L880F ;Char is not hexdec + RTS +; +L880F LDX #$0A ;expr syntax + JMP L87FB +; +; ; operator +; +ExprMUL JSR AdvSrcP + STY ValExpr+2 ;zero these + STY ValExpr+3 + LDY #16 ;# of times +L881D LDA ValExpr + LSR + BCC L882E +; + CLC + LDX #-2 +L8825 LDA ValExpr+4,X ;$A1-$A2 + ADC Accum+2,X ;$AF-$B0 + STA ValExpr+4,X + INX + BNE L8825 +; +L882E LDX #3 +L8830 ROR ValExpr,X + DEX + BPL L8830 + DEY + BNE L881D + RTS +; +; / operator +; +ExprDIV JSR AdvSrcP + STY ValExpr+2 + STY ValExpr+3 ;zero these + LDY #16 +L8842 ASL ValExpr ;dividend + ROL ValExpr+1 + ROL ValExpr+2 + ROL ValExpr+3 + SEC + LDA ValExpr+2 + SBC Accum ; divisor + TAX + LDA ValExpr+3 + SBC Accum+1 + BCC L885C + STX ValExpr+2 + STA ValExpr+3 + INC ValExpr +L885C DEY + BNE L8842 + RTS +; +; - operator +; +ExprSUB LDA RelExprF + EOR SavSEF ;prev subexpr's RelExprF + STA RelExprF + LDA Accum+1 ;Do 1's complement + EOR #$FF + STA Accum+1 + LDA Accum + EOR #$FF + SEC ;Proceed to add 1 + BCS L887C ; giving 2's complement +; +; + operator +; +ExprADD LDA SavSEF ;Get prev subexpr's RelExprF + ORA RelExprF + STA RelExprF + CLC + LDA Accum +L887C ADC ValExpr + STA ValExpr + LDA Accum+1 + ADC ValExpr+1 + STA ValExpr+1 + RTS +; +Operators DB $2B ;+ + DB $2D ;- + DB $2A ;; + DB $2F ;/ + DB $21 ;! EOR + DB $5E ;^ AND + DB $7C ;| OR +; +; This table of JMP (via RTS) addresses is split into 2 parts +; +L888E DB ExprADD-1 ;lobyte + DB >ExprSUB-1 + DB >ExprMUL-1 + DB >ExprDIV-1 + DB >ExprEOR-1 + DB >ExprAND-1 + DB >ExprORA-1 +; +; | operator bitwise OR +; +ExprORA LDA Accum + ORA ValExpr + STA ValExpr + LDA Accum+1 + ORA ValExpr+1 + STA ValExpr+1 + RTS +; +; ^ operator bitwise AND +; +ExprAND LDA Accum + AND ValExpr + STA ValExpr + LDA Accum+1 + AND ValExpr+1 + STA ValExpr+1 + RTS +; +; ! operator - bitwise EOR +; +ExprEOR LDA Accum + EOR ValExpr + STA ValExpr + LDA Accum+1 + EOR ValExpr+1 + STA ValExpr+1 + RTS + REP 50 +; +; Part of symbol table handler +; ($88C3) Find the key +; HeaderT-table of ptrs to singly list of keys with same hash value +; Ret: +; C=1 - Symbol not in table +; (Y)=0 +; C=0 - Symbol in table +; (A) = flag byte +; (Y)-indexing lobyte value field/indexing next char of src line +; +; PrvSymP would be set correctly for existing chains +; +FindSym JSR HashFn ;Hash the label + LDY HeaderT+1,X ;(X)=hashed value x 2 + BEQ L8908 ;Empty slot => Not Found! +; +; Get ptr to 1st node in singly linked list (chain) +; + LDA HeaderT,X +FindLoop STA SymP + STY SymP+1 + STA PrvSymP + STY PrvSymP+1 +; + LDY #0 + LDA (SymP),Y + STA NxtSymP ;Point to next node + INY + LDA (SymP),Y ; in chain + STA NxtSymP+1 ;If NIL ($0000) end of chain +; + LDA #2 ;Skip past link pointer + CLC + ADC SymP ; to point @ the symbolic name + STA SymP + BCC L88EC ;This will allow us to use the + INC SymP+1 ;same (Y) index for SrcP & SymP +; +L88EC LDY #-1 ;Prepare to get 1st char of src line +L88EE JSR ChrGet2 + ORA #$80 + CMP (SymP),Y + BEQ L88EE ;Got a match, try next char + AND #$7F ;Match last char of symbolic name + CMP (SymP),Y ;Do we have a complete match? + BNE L8902 ;No + JSR ChrGet2 ;Maybe but is next char alphanumeric? + BCS L890A ;No, probably a CR/SPACE => total match +; +L8902 LDA NxtSymP ;On fall thru, a partial match + LDY NxtSymP+1 ;End of this chain? + BNE FindLoop ;No, continue with next node in chain +L8908 SEC ;Flag symbolic name not found + RTS +; +L890A LDA (SymP),Y ;Get symbol's flag byte + BMI L891A ;Not defined yet +; + AND #%10111111 ;Set it to referenced + STA (SymP),Y + PHA ;Save flag byte + AND #relative ;Retain this bit + ORA RelExprF + STA RelExprF + PLA ;Restore +; +L891A CLC ;Flag symbolic name found + INY ;Indexing value field + RTS ; or 1st char in next src line? + REP 50 +; +; HashFn +; The Header Table can have at most 128 entries. Each +; entry is a 2-byte pointer (called a HEADER NODE) to a +; singly linked list of nodes (chain of nodes). +; Only the first 3 chars of a symbolic name are used +; by this hashing function. +; Ret: +; Y - preserved +; (X)=8-bit value which is used to index HeaderT +; +HashFn TYA + PHA ;save (Y) + LDA #0 + STA HashIdx ;zero the hash value + JSR ChrGot2 ;1st char of label + AND #%00000011 ;0000 00xx + LSR + ROL HashIdx + LSR + ROL HashIdx ;0000 00xx +; + LDA HashIdx + PHA ;save temporarily + LDA #0 + STA HashIdx + JSR ChrGet2 ;Is 2nd char alphanumeric? + BCC L8947 ;yes +; +; one-char label +; + PLA ;Discard hashed value + PLA ;restore Y-reg + TAY + PHA + LDA (SrcP),Y ;Get char again ($41-$5A) + AND #%00011111 ;$01-$1A (note: A,X,Y may be missing) + ASL + ASL + JMP L897D +; +L8947 AND #%00000111 ;0000 0yyy + LSR + ROL HashIdx + LSR + ROL HashIdx + LSR + ROL HashIdx ;=0000 0yyy + ASL HashIdx ;=0000 yyy0 + ASL HashIdx ;=000y yy00 + PLA ;(A)=0000 00xx + EOR HashIdx + PHA ;(A)=000y yyxx + LDA #$00 + STA HashIdx + JSR ChrGet2 ;Is 3rd char alphanumeric? + BCC L8968 ;Yes + PLA ;2-char label field + ASL + ASL ;0yyy xx00 + BPL L897D ;always +; +; 3rd char +; +L8968 AND #%00000111 ;0000 0zzz + ASL + ASL + ASL + ASL + ASL + ASL + ROR HashIdx ;(HashIdx)=z000 0000 + ASL + ROR HashIdx ;(HashIdx)=zz00 0000 + ASL + ROR HashIdx ;(HashIdx)=zzz0 0000 + LSR HashIdx ;(HashIdx)=0zzz 0000 + PLA ;(A)=000y yyxx + EOR HashIdx +; +L897D ASL ;x2 to make hash value into an index + STA HashIdx ; 0,2,4,...,254 + TAX + PLA ;restore (Y) + TAY + RTS + REP 50 +; +RsvdId JSR IsAXY ;Chk if reserved idfer + BCC doRet9 ;No + LDX #$1E ;Reserved idfer err + JMP RegAsmEW + REP 50 +; +; Chk for a single 'A','X','Y' in label/operand field +; C=1 - Yes +; (X) & (Y) - unchanged +; +IsAXY JSR ChrGot2 ;Patch here if we want the letters + CMP #'X' ; A,X,Y to be used as labels/operands + BEQ L899F + CMP #'A' + BCC doRet9 + BEQ L899F + CMP #'Y' + BNE L89A7 +L899F JSR ChrGet2 ;Is next char alphanumeric? + DEY ;Backup to 1st char + BCC doRet9 ;Yes + SEC + RTS +L89A7 CLC +doRet9 RTS + REP 50 +; +; ($89A9) Add a node +; Entry: +; (A)=initial value of flag byte of the Symbol +; ref pg 231 of manual for details +; Ret: +; C=0 - succ +; (Y)=index last byte of entry (Hi-byte) +; C=1 - fail +; The bits of the flag byte are defined as follows: +; $80 - undefined +; $40 - unreferenced +; $20 - relative to beginning of module +; $10 - External +; $08 - Entry +; $04 - macro (not implemented) +; $02 - No such label +; $01 - forward referenced +; Layout of Node +; ptr to next node in chain (set to NIL) +; symbolicname (variable in length) +; flag byte +; 16-bit value +; NB. 1) msb of all chars of symbolic name +; except the last one are on +; 2) The size of a node structure is not fixed. +; Symbolic names with the same hash value (collision) +; are connected together in a singly linked list. +; +AddNode PHA ;Save flag byte + LDY #0 + JSR ChrGot + BCC L89B4 + SEC + PLA + RTS +; +L89B4 LDX HashIdx ;Is there already a chain + LDA HeaderT+1,X ; associated with this value? + BNE L89C8 ;Yes + LDA #>HeaderT ;Start a new singly linked list + CLC + ADC HashIdx ;=$xx + STA PrvSymP ;Point @ $BCxx + LDA # $100 + JSR RegAsmEW +; +L8AAE LDA ValExpr ;New ORG value + PHA + LDA ValExpr+1 + PHA + JSR L99DF ;Flush all obj code incl RLD etc + LDX #ObjFile + JSR Open4RW ;Kill old objfile, create new one for output + LDA #BINtype + STA ftypeT ;Reset to BIN after obj file is opened + LDA GenF + AND #$7F ;N=0 => Lift suppression of code generation + STA GenF + PLA + STA ValExpr+1 + PLA + STA ValExpr +; + LDA ValExpr + STA CurrORG + LDA ValExpr+1 + STA CurrORG+1 +; + LDY #6 +L8AD7 LDA GFInfoPB,Y + STA SFInfoPB,Y + DEY + BNE L8AD7 +; + LDA CurrORG ;Set auxtype of OBJ file + STA SFIaux + LDA CurrORG+1 ; to the new ORG value + STA SFIaux+1 ;NB. ORG can never be $0000-$00FF + JSR PRODOS8 + DB $C3 + DW SFInfoPB + BEQ L8AF5 + JMP DOSErrs +; +L8AF5 LDA #0 + STA FileLen + STA FileLen+1 + BIT RelCodeF ;REL code? + BPL L8B05 ;No +; + JSR Wr1Byte ;Write 2 zeros @ BOF + JSR Wr1Byte ; as place holder +; +L8B05 LDA #0 + STA CodeLen + STA CodeLen+1 + LDA ListingF ;Listing on? + BPL L8B2C ;no +; + LDX #$1F + LDA #>LD798 ;Next obj file + STA Msg2P + LDA #ObjPNB+1 + STA Msg2P + LDA #= + PHA + LDA ValExpr+1 + PHA + STY ValExpr ;# of bytes to write + STX ValExpr+1 + JSR Is16K ;Is val > 16384? + BCC L8B4E + JMP L8B6D ;Yes +; +; Move fileposn forward by write random data +; +L8B4E JSR L8CAB ;Fill + PLA + STA ValExpr+1 + PLA + STA ValExpr + JMP SetPC +; +; Move fileposn backwards +; +L8B5A BIT GenF + BVS L8B61 ;disk write + JMP SetPC +; +L8B61 SEC + LDA ValExpr ;Make sure this + SBC CurrORG ; >= curr ORG + TAY + LDA ValExpr+1 + SBC CurrORG+1 + BCS L8B75 +; +L8B6D LDX #$06 + JSR RegAsmEW ;overflow err + JMP CanclAsm +; +L8B75 STY CodeLen ;file pos rel to curr ORG + STA CodeLen+1 + LDA CodeLen + CLC + BIT RelCodeF ;R we writing a REL file? + BPL L8B82 ;No + ADC #2 ;2 more for the Code Image Len @ BOF +L8B82 STA FileLen + TAY ;lobyte of new file posn + LDA CodeLen+1 + ADC #0 + STA FileLen+1 ;file len + LDX #ObjFile ;Force a flush + JSR SetFPos (A,Y) - fileposn +; +SetPC LDA ValExpr + STA PC ;PC=new ORG Addr + LDA ValExpr+1 + STA PC+1 + JMP DrtvFin + REP 50 +; +; Greater than 16384 (16K) +; C=0 - No +; C=1 - Yes +; +Is16K BIT ValExpr+1 + BMI L8BAB + BVC L8BA9 + LDA ValExpr+1 + AND #%00111111 + ORA ValExpr ;Zero? + BNE L8BAB ;No +L8BA9 CLC + RTS +L8BAB SEC + RTS + REP 50 +; OBJ directive +; This directive cannot be used in conjunction with +; REL directive. To store object code directly into +; mem, do ASM srcfile,@ and have the following +; src statements +; ORG $1000 ;optional +; OBJ $6000 +; at the beginning of file +; Normally sym table is $0800-$7000 +; Ref pg 96 +; +L8BAD LDA #0 + STA ValExpr + STA ValExpr+1 + JSR EvalOprnd + BCC L8BBB +L8BB8 JMP L8A50 +; +L8BBB LDA NxtToken ;Is sp/cr? + BNE L8BB8 ;No + BIT GenF + BVS L8BFC ;disk write + LDA ValExpr + ORA ValExpr+1 + BNE L8BCF + LDA #$80 + STA GenF ;N=1-Suppress code generation + BNE L8BFC ;Always +L8BCF BIT RelCodeF ;Is REL obj code? + BPL L8BDB ;No +; +L8BD3 LDX #$38 ;Can't use OBJ and + JSR RegAsmEW ; REL directives together + JMP DrtvFin +; +L8BDB LDA EndSymT + CMP ValExpr ;Is value < curr EO + LDA EndSymT+1 ; symbol table? + SBC ValExpr+1 + BCS L8BD3 ;Yes, err +; + LDA ValExpr + STA ObjPC + STA MemTop + STA RLDEnd + LDA ValExpr+1 + STA ObjPC+1 + STA RLDEnd+1 + STA MemTop+1 +; + JSR L828A ;Ensure val < mem limit + LDA #$00 ;N=0,V=0-Flag gen obj code in mem + STA GenF +L8BFC JMP DrtvFin + REP 50 +; +; Evaluate a Directive's operand expression +; This rtn expects all idfers used in the expr +; are defined +; +EvalOprnd LDA PassNbr + PHA + LDA #1 ;Force a pass 2 + STA PassNbr + JSR EvalExpr + TAX ;error token? + PLA + STA PassNbr + RTS + REP 50 +; +; DS/.BLOCK directive +; +L8C0E JSR EvalOprnd + BCS L8C1D + JSR Is16K ;Is expr's val > 16384? + BCC L8C23 + LDX #$06 ;Yes, overflow +L8C1A DB $2C +L8C1B LDX #$24 ;directive operand err +L8C1D JSR RegAsmEW + JMP DrtvFin +; +L8C23 SEC + ROR RndF ;Assume no filler char + LDA NxtToken ;Is sp/cr? + BEQ L8C5F ;Yes + CMP #$01 ;Comma? + BNE L8C1B ;No, err +; + LDA ValExpr ;# of bytes to reserve + PHA + LDA ValExpr+1 + PHA + INY + INY + JSR WhiteSpc ;Is it sp/cr after comma? + BEQ L8C44 ;Yes + JSR EvalExpr ;2nd expr -> filler byte + BCS L8C44 + LDA NxtToken ;Make sure nxt char is sp/cr + BEQ L8C49 ;Yes, it is +L8C44 PLA ;Dump val + PLA + JMP L8C1B ;err +; +L8C49 CLC + ROR RndF ;Flag we will use a filler + LDA ValExpr + STA Filler ;byte used to fill + LDA ValExpr+1 + BEQ L8C59 ;Must be 8-bits + LDX #$28 ;byte overflow err + JSR RegAsmEW +; +L8C59 PLA + STA ValExpr+1 + PLA + STA ValExpr +; +L8C5F LDA ValExpr ;# of bytes to reserve + CLC + ADC PC + STA NewPC ;New PC + LDA ValExpr+1 + ADC PC+1 + STA NewPC+1 +; + LDA PassNbr + BEQ L8CA0 + LDA ValExpr + STA ERfield ;# of bytes reserve + LDA ValExpr+1 + STA ERfield+1 +; + LDA #%10000001 + STA LstCodeF + BIT GenF + BMI L8C9D ;No obj code output + BIT RndF ;Use filler char? + BMI L8C9A ;No +; +L8C84 LDA ValExpr + ORA ValExpr+1 + BEQ L8C9D ;Done + LDA Filler + JSR StorByt + LDA ValExpr + BNE L8C95 + DEC ValExpr+1 +L8C95 DEC ValExpr + JMP L8C84 +; +L8C9A JSR L8CAB ;Fill w/random data +L8C9D JSR PrtAsmLn ;print code,stmt +L8CA0 LDA NewPC ;Adjust PC + STA PC + LDA NewPC+1 + STA PC+1 + JMP L8D44 + REP 50 +; +; Fill obj file with random data +; until new posn +; +L8CAB LDA ValExpr ;# of bytes to write + ORA ValExpr+1 + BEQ doRtn4 + LDA BUTN3 ;Get data byte here + JSR StorByt + LDA ValExpr + BNE L8CBD + DEC ValExpr+1 +L8CBD DEC ValExpr + JMP L8CAB +doRtn4 RTS + REP 50 +; +; Define Byte (DB/DFB) psuedo opcode - pg 102 +; +L8CC3 JSR L8D5E ;Setup +NxtDFB STX ByteCnt ;curr cnt + JSR EvalExpr ;rtn will take care of comma + LDX ByteCnt ;double as index + LDA ValExpr ;val defined + STA GMC,X + INX + BCS L8CED ;err during eval + LDA PassNbr + BEQ L8CED + LDA RelExprF ;Evaluate fr relocatable expr? + BEQ L8CED ;No, abs +; +; For each byte an RLD entry is created if +; expr is obtained fr relative addr +; + STX ByteCnt ;Save temporarily + STY SavIndY ;Save index into operand field + DEX + TXA ;offset + LDX #$01 + LDY #$00 ;Reverse order + JSR AddRLDEnt ;Make RLD entry +; + LDX ByteCnt + LDY SavIndY +L8CED STX Length + LDA NxtToken + BEQ L8D0C ;cr/space + EOR #$01 + BEQ L8CFD ;Comma +L8CF7 JSR L9193 ;err + JMP L8D35 +; +L8CFD INY + INY + LDA (SrcP),Y + CMP #SPACE+1 + BCC L8CF7 + CPX #4 ;4 bytes generated? + BNE NxtDFB ;No +; + JSR AdvSrcP +L8D0C LDA PassNbr + BEQ L8D20 + LDX #$00 + JSR L8E28 ;Store MC,update PC etc +L8D15 LDA NxtToken + BEQ L8D26 ;cr/space -> done + LDX #0 ;Reset cnt + LDY #0 ; & index + JMP NxtDFB +; +L8D20 JSR L8D52 ;update total cnt + JMP L8D15 +;--- +L8D26 LDA PassNbr + BNE L8D44 +L8D2A JSR L8D52 ;update total cnt + LDA TotCnt + JSR AdvPC + JMP DrtvDone +;--- +L8D35 LDA PassNbr + BEQ L8D2A + JSR StorGMC ;write instr + JSR PrtAsmLn ;print code,stmt + LDA Length + JSR AdvPC +;--- +L8D44 LDA #0 + STA Length + LDA #$83 + STA ZAB +; +DrtvDone LDY #0 + LDA ZAB + CLC + RTS + REP 50 +; +; Keep track of total # of bytes generated +; +L8D52 CLC + LDA Length + ADC TotCnt + STA TotCnt + LDA #0 + STA Length + RTS + REP 50 +; +; (X)=0 +; +L8D5E LDX #%00100001 ;$21 + STX LstCodeF + LDX #0 + STX TotCnt ;cntr + RTS + REP 50 +; +; DW directive +; +L8D67 LDA #$00 ;Reverse +; +L8D69 STA EndianF ;enter here for DDB + JSR L8D5E +NxtDW JSR EvalExpr + STY SavIndY ;Index into operand field + LDY ValExpr + LDX ValExpr+1 + LDA EndianF + BEQ L8D81 +; + STY GMC+1 ;normal (DDB) + STX GMC + BNE L8D85 ;always +L8D81 STY GMC + STX GMC+1 +; +L8D85 BCS L8D98 ;err during eval + LDA PassNbr + BEQ L8D98 + LDA RelExprF + BEQ L8D98 ;abs expr +; + LDA #$00 ;offset + LDX #$02 + LDY EndianF ;byte ordering + JSR AddRLDEnt ;Make RLD entry +; +L8D98 LDY SavIndY ;Restore index into operand field + LDX #2 + STX Length + LDA NxtToken + BEQ L8DB4 ;cr/space -> done + EOR #$01 + BEQ L8DA9 ;comma +L8DA6 JMP L8CF7 ;err +; +L8DA9 INY + INY + LDA (SrcP),Y + CMP #SPACE+1 + BCC L8DA6 + JSR AdvSrcP +; +L8DB4 LDA PassNbr + BEQ L8DC7 + JSR L8E28 ;Store MC, update PC, print +L8DBB LDA NxtToken ;Is cr/space? + BNE L8DC2 ;No, comma or ) + JMP L8D26 ;done +; +L8DC2 LDY #$00 ;Index into src line + JMP NxtDW +; +L8DC7 JSR L8D52 ;update total cnt + JMP L8DBB + REP 50 +; +; Define Double Byte (DDB) +; +L8DCD LDA #$01 ;Normal + JMP L8D69 + REP 50 +; +; ASC directive +; +L8DD2 LDA #-1 + STA StrType +L8DD6 JSR SkipSpcs + STA Delimitr + JSR AdvSrcP + LDA PassNbr + BEQ L8E41 ;Pass 1 + LDA #%00100001 + STA LstCodeF + BNE L8DED ;always +; +L8DE8 ORA msbF +L8DEA STA GMC-1,Y ;$9A-$9D +L8DED INY + LDA (SrcP),Y + CMP Delimitr + BEQ GotDelim2 ;Done + CMP #CR + BEQ L8E13 ;No comment field + CPY #5 ;4 bytes at a time + BNE L8DE8 +; + DEY ;=4 + STY Length + JSR AdvSrcP + JSR L8E28 ;Store MC,update PC etc + LDY #0 + BEQ L8DED ;always +; +GotDelim2 INY ;Skip past 2nd delimiter + JSR WhiteSpc ;Do we have a sp/cr? + BEQ L8E12 ;Yes + JSR L8530 ;invalid delim +L8E12 DEY ;Backup to 2nd delim +L8E13 DEY ;Backup to last char + STY Length + BIT StrType ;ASC? + BMI L8E22 ;yes + LDA GMC-1,Y ;DCI + ORA #$80 + STA GMC-1,Y ;last char of str +L8E22 JSR L8E28 ;Store MC,update PC etc + JMP L8D44 +;================================================= +L8E28 JSR StorGMC + LDA ZAB + CMP #$82 ;Print 1 line + up to 4 bytes? + BNE L8E35 ;Yes + BIT LstGCode ;Do we list gen code? + BPL L8E3C ;No +L8E35 JSR PrtAsmLn ;print + LDA #$82 + STA ZAB +L8E3C LDA Length + JMP AdvPC ;Update PC & ret to caller +; +L8E41 INY + LDA (SrcP),Y + CMP Delimitr + BEQ L8E4C + CMP #CR + BNE L8E41 +L8E4C DEY + TYA +L8E4E JSR AdvPC ;(A) has # of bytes to be added to PC + JMP DrtvDone + REP 50 +; +; DCI pseudo opcode +; +L8E54 LDA msbF + PHA + LDA #$00 + STA msbF ;OFF temporarily + STA StrType + JSR L8DD6 ;Scan as all chars except last as ASC + PLA + STA msbF + JMP DrtvDone + REP 50 +; +; MSB directive +; (X) not used? +L8E66 JSR SkipSpcs + JSR ChrGot + CMP #'O' + BNE L8E91 + JSR ChrGet + CMP #'N' + BEQ L8E8A ;got 'ON' +; + CMP #'F' + BNE L8E91 + INY + JSR WhiteSpc + BEQ L8E87 ;cr? + INY + JSR WhiteSpc + BNE L8E91 ;not-terminated +; +L8E87 LDA #$00 + DB $2C +L8E8A LDA #$80 + STA msbF + JMP DrtvDone +L8E91 JMP L8C1B ;err + REP 50 +; +; STR directive +; +L8E94 LDA #-1 ;ASC + STA StrType + JSR SkipSpcs + STA Delimitr + LDX #0 + DEY ;Move back past delimiter + JSR AdvSrcP ;SrcP pointing @ sp b4 delim + INY ;Indexing delim +L8EA4 INY + INX + LDA (SrcP),Y ;Scan ahead for + CMP Delimitr ; 2nd one + BEQ L8EB0 ;Got it + CMP #CR + BNE L8EA4 ;Treat char as part of str +L8EB0 CPX #2 + BCS L8EB7 ;only 1 byte? + JMP L8A50 ;Yes, err +; +L8EB7 LDA PassNbr + BNE L8EBF + TXA ;len of str + 1 (len byte) + JMP L8E4E ;Just adj PC & ret to caller +; +L8EBF DEX + LDY #$01 ;Skip past 1st delim + LDA #%00100001 + STA LstCodeF + TXA ;len of str + JMP L8DEA ;Store & can scanning as ASC + REP 50 +; +; LST directive +; +L8ECA JSR SkipSpcs + JSR ChrGot + BCS L8F34 ;non-alphabetic char + CMP #'O' + BNE L8EF3 + JSR ChrGet + BCS L8F34 ;non-alphabetic + CMP #'N' + BNE L8EE9 + LDA PassNbr + BEQ L8EEE + JSR PutCR + SEC + BCS L8EEE ;always +; +L8EE9 CMP #'F' + BNE L8F34 + CLC +L8EEE ROR ListingF ;ON => set msb + JMP L8F22 +; +; The code here looks for 8 listing flags viz. +; Cyc, Gen, Warn, Unasm, Asym, Vsym, Sixup, Exp +; Only the 1st char is considered. +; +; The defaults are: +; LST ON,NOCyc,NOGen,Warn,Unasm,Asym,NOVsym,NOSixup,Exp +; Ref pg 111-113 +; +L8EF3 LDA #$80 ;Default to ON + STA OnOffSW + JSR ChrGot + BCS L8F34 ;Non-alphabetic + CMP #'N' ;look for 'NO' + BNE L8F12 + JSR ChrGet + BCS L8F34 + CMP #'O' + BNE L8F34 + LDA #$00 ;Got one + STA OnOffSW ;Set to OFF + JSR ChrGet + BCS L8F34 ;Non-alphabetic +; +L8F12 LDX #8 +L8F14 CMP LstOptns-1,X + BEQ L8F1E ;Got a match + DEX + BNE L8F14 + BEQ L8F34 ;probably err +; +L8F1E LDA OnOffSW + STA LstFlags-1,X +L8F22 JSR ChrGet + BCC L8F22 ;alphabetic + CMP #SPACE + BEQ L8F37 + CMP #CR + BEQ L8F37 ;done + INY + CMP #',' ;delimiter + BEQ L8EF3 ;Next option +L8F34 JMP L9193 +L8F37 JMP DrtvDone + REP 50 +; +; .NOLIST directive +; +L8F3A CLC + BCC L8F3E ;always +; .LIST directive +; +L8F3D SEC +; +L8F3E ROR ListingF + JMP DrtvDone +; +LstOptns ASC 'CUEWGAVS' + REP 50 +; +; PAGE directive +; +DoPage DEY + DEY + LDA PassNbr + BEQ L8F5E + JSR RVLsting ;Are we listing? + BCS L8F5E ;No + LDA #FF + JSR PutC + JMP L9008 ;Ret to Pass2 loop +L8F5E JMP DrtvDone + REP 50 +; +; SBTL directive +; SubTtlF=$40 - directive encountered +; =$FF - a string has been set +; =$00 - no subtitle +; NB: $FF also means $40-bit is set +; +L8F61 LDA #$40 + STA SubTtlF + LDA PassNbr ;Pass 1? + BEQ L8FA0 ;Yes +; + JSR SkipSpcs + STA Delimitr + CMP #CR + BEQ L8FA0 + JSR AdvSrcP + STX SavIndX +; + LDX #0 +L8F79 INY + LDA (SrcP),Y + CMP Delimitr + BEQ L8F8C + CMP #CR ;CR => no 2nd delimiter + BEQ L8F8D + STA SubTitle,X + INX + CPX #35 + BCC L8F79 +; +L8F8C INY ;Bump past char +L8F8D LDA #0 + STA SubTitle,X ;null-terminated + LDA #$FF + STA SubTtlF ;Flag there is a string (NB. V=1) + JSR WhiteSpc ;cr/space? + BEQ L8F9E ;Yes + JMP L8C1B ;No, err +; +L8F9E LDX SavIndX +L8FA0 JMP DoPage ;Do a FF + REP 50 +; +; REP directive +; +L8FA3 LDA PassNbr + BNE L8FAA +L8FA7 JMP DrtvDone +; +L8FAA JSR RVLsting + BCS L8FA7 ;No + JSR L9013 ;Get # of times + BCS L8FA7 + JSR ListCode + JSR PrtDecS ;line # + LDA RepChar + LDX ValExpr ;char count +L8FBE JSR PutC + DEX + BNE L8FBE + INX + BNE L8FFD ;always + REP 50 +; CHR directive +; +L8FC7 JSR SkipSpcs + STA Delimitr + INY + JSR WhiteSpc + BEQ L8FE4 + STA RepChar ;This is what we want + INY + JSR WhiteSpc + BEQ L8FE7 + CMP Delimitr + BNE L8FE4 + INY + JSR WhiteSpc + BEQ L8FE7 +L8FE4 JSR L9018 ;err +L8FE7 JMP DrtvDone + REP 50 +; +; SKP directive +; +L8FEA LDA PassNbr + BNE L8FF1 +L8FEE JMP DrtvDone +; +L8FF1 JSR RVLsting + BCS L8FEE ;No + JSR L9013 ;Get # of times + BCS L8FEE + LDX ValExpr ;# of blank lines +L8FFD LDA #SPACE + JSR PutC + JSR PutCR + DEX + BNE L8FFD +; +L9008 PLA ;Discard ret addr + PLA + JSR NextRec + JSR L81A3 ;Update counters + JMP Pass2Lup +;================================================= +L9013 JSR EvalOprnd ;Result in ValExpr + BCC doRtn5 +L9018 JSR L8C1B ;err + SEC +doRtn5 RTS + REP 50 +; +; DATE directive +; +L901D LDX #9 ;# of ASCII chars to get + LDY #0 +L9021 LDA PassNbr + BNE L9029 + TXA ;Don't generate + JMP L8E4E +; +; DATETIME field: Offset 0-8=DD-MMM-YY; 11-16=HH:MM +; +L9029 STY DTCurIdx ;0,11 + TXA ;9,6 + CLC + ADC DTCurIdx + STA DTEndCol ;9,17 + LDX #%00100001 + STX LstCodeF +L9035 LDX #0 +L9037 LDY DTCurIdx + CPY DTEndCol + BCS L9053 + LDA DateTime,Y ;Already in ASCII + ORA msbF + STA GMC,X + INC DTCurIdx + INX + CPX #4 + BCC L9037 + STX Length ;=4 so store MC, + JSR L8E28 ; update PC, print etc + JMP L9035 +; +L9053 STX Length + TXA + BEQ L905B ;Nothing to store + JSR L8E28 ;Write MC,update PC etc +L905B JMP L8D44 + REP 50 +; +; IDNUM/TIME directive - pg 106 +; +L905E LDX #6 ;# of ASCII chars to get + LDY #11 ;Index TIME portion + JMP L9021 + REP 50 +; +; DSECT directive +; +L9065 LDA DummyF + BMI L90AF ;Already declared +; + LDA PC + STA SavPC + LDA PC+1 + STA SavPC+1 + LDA ObjPC ;renamed as CodeLen when + STA SavObjPC ; REL code is generated + LDA ObjPC+1 + STA SavObjPC+1 + LDA GenF + STA SavGenF +; + LDA #$FF + STA GenF ;Suppress obj code output temporarily + LDA #0 ;PC=0 + STA PC + STA PC+1 + LDA #$80 + STA DummyF + JMP DrtvDone + REP 50 +; +; DEND directive +; +L908E LDA DummyF + BPL L90AF ;Not declared +; + LDA SavPC + STA PC + LDA SavPC+1 + STA PC+1 + LDA SavGenF + STA GenF + LDA PassNbr + BEQ L90AA ;Pass 1 +; + LDA SavObjPC + STA ObjPC + LDA SavObjPC+1 + STA ObjPC+1 +L90AA LSR DummyF ;msb off + JMP DrtvDone +; +L90AF LDX #$10 ;Dummy section error +L90B1 JSR RegAsmEW + JMP DrtvDone + REP 50 +; +; DO & IFNE directive-marks BO cond asm block +; CondAsmF +; V=1 - false, V=0 - true +; N=1 - within Alt blk +; +L90B7 JSR EvalOprnd + BCS L9123 + LDA ValExpr + BNE L90C8 + LDA ValExpr+1 + BNE L90C8 +L90C4 LDA #$40 ;false + STA CondAsmF +L90C8 JMP DrtvFin ;true - CondAsmF=$00 + REP 50 +; +; ELSE directive +; NB. ELSE block is optional +; +L90CB LDA #$80 + EOR CondAsmF ;$00->$80, $40->$C0, $80->$00 + BEQ L90D2 + LSR ;$00->$80->$00, $40->$C0->$40 +L90D2 STA CondAsmF + JMP DrtvDone + REP 50 +; +; FIN directive-marks EO cond asm block +; +L90D7 LDA #$00 + STA CondAsmF + JMP DrtvDone + REP 50 +; +; IFEQ directive +; +L90DE JSR EvalOprnd + BCS L9123 + LDA ValExpr + ORA ValExpr+1 + BNE L90C4 + BEQ L90C8 ;=0 -> true + REP 50 +; +; IFGT directive +; +L90EB JSR EvalOprnd + BCS L9123 + LDA ValExpr+1 + BMI L90C4 ;-ve + BNE L90C8 ;+ve but > 0 -> true + LDA ValExpr + BEQ L90C4 ;=0 -> false + BNE L90C8 ;true + REP 50 +; +; IFGE directive +; +L90FC JSR EvalOprnd + BCS L9123 + LDA ValExpr+1 + BMI L90C4 ;-ve so < 0 + BPL L90C8 ;>=0 - true +; IFLT +L9107 JSR EvalOprnd + BCS L9123 + LDA ValExpr+1 + BPL L90C4 + BMI L90C8 ;true +; IFLE +L9112 JSR EvalOprnd + BCS L9123 + LDA ValExpr+1 + BMI L90C8 + BNE L90C4 ;+ve but > 0 - false + LDA ValExpr + BEQ L90C8 + BNE L90C4 ;> 0 - false +; +L9123 JMP L9193 + REP 50 +; +; REL directive +; RLD will be cleared when an abs ORG is encountered +; e.g. +; REL +; ORG $3000 +; +L9126 SEC + ROR RelCodeF ;msb=1 + LDA #RELtype + STA ftypeT + JMP DrtvDone + REP 50 +; +; INTERP directive +; +L9131 LDA #SYStype + STA ftypeT + JMP DrtvDone + REP 50 +; +; X6502 directive +; +L9139 LDA #$C0 ;N=1,V=1 + STA X6502F ;NCR 65C02 + JMP DrtvDone + REP 50 +; +; ZDEF directive - pg 100-101 +; +L9140 LDA #$00 + BEQ L9146 ;always +; +; DEF/ENTRY directive +; +L9144 LDA #$01 +; +; Common code +; +L9146 STA GblAbsF + LDA PassNbr ;pass 2 + BNE L918E + INC SymNbr ;# of ENTRY/EXTRN points + BEQ L9196 ;>255 +; + JSR NxtField ;Point @ operand field + JSR ChrGot ;Get its 1st char + BCS L919C ;A non-alphabetic char => err + JSR RsvdId ;Is operand a reserved idfer? + BCS L918B ;No + JSR FindSym + BCC L9172 ;Found in symbol table +; +; Idfer is found somewhere else +; + LDX GblAbsF ;R we creating a global ZP idfer? + BEQ L919C ;Yes -> err + LDA #$00 + STA RelExprF ;Init expr as abs + LDA #undefined+entry+fwdrefd;Symbol's flag byte + JSR AddNode ;Add to symbol table + JMP DrtvFin +; +; Symbol is already in the symbol table +; +; Consider the case +; lab1 ENTRY lab1 +; A node had been created when the label field was parsed +; +L9172 DEY ;(A) has symbol's flag byte + BIT Bit10 ;EXTeRNal symbol? + BNE L919C ;Yes -> err + BIT Bit08 ;ENTRY symbol? + BNE L9199 ;Yes -> err + LDX GblAbsF ;ZDEF/ZREF? + BNE L9187 ;No + TAX ;Save temporarily + AND #fwdrefd ;ForwardRef? + BNE L919C ;Yes -> err + TXA +L9187 ORA #entry ;flag as ENTRY + STA (SymP),Y ;Set sym's flag byte +L918B JMP DrtvFin +; +L918E JSR EvalExpr + BCC L918B +; +L9193 LDX #$24 ;Directive operand err + DB $2C +L9196 LDX #$3E ;>255 ENT/EXT idfers + DB $2C +L9199 LDX #$40 ;Duplicate ENT + DB $2C +L919C LDX #$0E ;Invalid idfer + JSR RegAsmEW + JMP DrtvFin + REP 50 +; +; ZREF directive - pg 101,102 +; Each assembly supports max 255 DEF/REF idfers +; To circumvent this, assemble modules separately +; +L91A4 LDA #$00 + BEQ L91AA +; +; REF/EXTRN directive +; +L91A8 LDA #$01 +; +; Common code +; +L91AA STA GblAbsF + LDA PassNbr + BNE L920C + INC SymNbr ;# of ENTRYs/EXTRNs + BEQ L9196 ;>255 +; + JSR NxtField + JSR ChrGot + BCS L919C ;non-alphabetic char + JSR RsvdId ;Is operand a reserved id? + BCS L920C ;No + JSR FindSym ;Is it in symbol table? + BCC L91E9 ;Yes +; + LDA PC + PHA + LDA PC+1 + PHA +; + LDA #0 + STA PC+1 + LDA SymNbr ;Extern symbol #? + STA PC + LDA #relative + STA RelExprF ;Mark expr as relative + LDA #relative+external + ORA GblAbsF ;0-ZDEF/ZREF,1-DEF/REF + JSR AddNode ;(A) has symbol's flag byte +; + PLA + STA PC+1 + PLA + STA PC + BCS L919C ;Fail to add to symbol table + BCC L920C +; +; Found in symtbl; no node created; just update node +; +L91E9 TAX ;symbol's flagbyte + BMI L91F2 ;undefined symbol + AND #external ;Defined but is it EXTeRNal? + BNE L9199 ;Yes -> duplicate + BEQ L919C ;Always +; +L91F2 BIT Bit08 ;ENTRY symbol? + BNE L919C ;Yes -> err + LDA GblAbsF ;ZDEF/ZREF? + BEQ L919C ;Yes -> invalid + DEY + ORA #relative+external + STA (SymP),Y + INY + LDA SymNbr ;symbol # + STA (SymP),Y ;Value field + INY + LDA #0 + STA (SymP),Y + DEY + DEY ;Index symbol's flag byte +; +L920C LDA #0 + STA ValExpr + STA ValExpr+1 + JMP DrtvFin + REP 50 +; +; FAIL directive pg 108-109 +; +L9215 JSR SkipSpcs + JSR WhiteSpc ;cr/space? + BNE L9220 ;No +L921D JMP L9193 +; +L9220 CMP #'3' ;Pass 3 means both passes + BEQ L922E + EOR #'1' + BEQ L922A ;pass 1 + LDA #1 ;pass 2 +L922A CMP PassNbr ;Correct pass? + BNE L926C ;No +; +L922E INY + LDA (SrcP),Y + CMP #',' ;If not comma, + BNE L921D ; error + INY + JSR AdvSrcP + JSR PutCR + LDA #'>' + LDX #6 +L9240 JSR PutC + DEX + BNE L9240 +; + LDA #BEL + JSR PutC + JSR PutC + LDX #$08 +L9250 LDA FailTxt-1,X + JSR PutC + DEX + BNE L9250 +; +L9259 LDA (SrcP),Y ;Print user's msg + CMP #CR + BEQ L9265 + JSR PutC + INY + BNE L9259 +; +L9265 JSR FlagErrZ ;incr err cnt + LDA PassNbr + BNE L926F ;pass 2 +L926C JMP DrtvDone +L926F JMP L9008 +; +FailTxt ASC ':ERULIAF' + REP 50 +; +; PAUSE directive +; Allows for manual disk swaps-pg 98 +; +L927A JSR L9013 ;Get # + BCS L9289 + LDX ValExpr ;1/2 -> 0/1 + DEX + CPX PassNbr + BNE L9289 + JSR Wait4CR +L9289 JMP DrtvDone + REP 50 +; +; CHN directive +; We should not declare a CHN in an INCLUDE/macro defn file +; +L928C JSR NxtField + LDX FCTIndex + BEQ L92B9 ;OBJ -> incl/chn nesting + CPX #MacFile ;CHN directive in Macro defn file? + BEQ L92B9 ;Yes, error +; + JSR ClsFile ;Close curr SRC/CHN file + LDX FCTIndex +; +; X=2,4 +; The code below is also used by the INCLUDE directive +; +L929C JSR SetPNBuf ;Use src/isrc PN buf + JSR GetPNStr ;Copy str into the PN buf + SEC + ROR NewF ;=$80 +; + SED + LDA #0 + SEC ;add 1 + ADC FileNbr + STA FileNbr + CLD +; + JSR L92F0 ;Inform user we're opening another file + LDX FCTIndex + JSR Open4RW ;Open source file for input + JMP DrtvDone +; +L92B9 JMP L9364 + REP 50 +; +; Get filename into corresponding PN buffer fr +; a src line record +; Input +; PathName-ptr to PN buf +; Ret: +; If no errs +; (Y)=len of filename +; (A)=space +; +GetPNStr LDY #64 + LDA #SPACE +L92C0 STA (PathP),Y ;First blank the pathname buffer + DEY + BNE L92C0 + TYA ;Y=A=0 + STA (PathP),Y ;len byte +; + LDY #0 +L92CA JSR WhiteSpc ;Get char fr src line rec + BEQ L92E7 ;If sp/cr, done + JSR ToUpper + CMP #SPACE + BCS L92DB +L92D6 LDA #$40 ;Char is invalid + JSR DOSErrs ;Report as "Invalid PN system" +; +L92DB INY + STA (PathP),Y + CPY #64 + BCC L92CA + JSR WhiteSpc ;CR? + BNE L92D6 ;No, error +; +L92E7 TYA + LDY #0 + STA (PathP),Y ;Set len byte + TAY + LDA #SPACE + RTS + REP 50 +; +; Print src file name & associated messages +; +L92F0 LDA PassNbr ;Is pass 1? + BEQ L92F8 ;Yes + BIT ListingF ;Pass2:Is listing on? + BMI doRtn6 ;Yes +; +L92F8 LDA #>LD7C7 ;include file + LDY #LD7B7 ;src file + LDY #' + JSR PutC +; + LDY #0 + LDA (PathP),Y + TAX ;# of chars to print + SEC ;Add 1 to skip + LDA PathP + ADC #0 + STA Msg2P ; past len byte + LDY PathP+1 + BCC L9334 + INY +L9334 STY Msg2P+1 +; + JSR L7E19 ;Print src PN + JSR IsVideo ;Video output? + BEQ doRtn6 ;Yes, just ret +; + LDY #0 +L9340 LDA LD7B7,Y ;Src file # + JSR VidOut + INY + CPY #$10 + BCC L9340 +; + LDA #BS + JSR VidOut + LDY #0 + LDA (PathP),Y ;Get len byte of filename + TAX + INY ;Skip past len byte +L9356 LDA (PathP),Y ;Get char + JSR VidOut + INY + DEX + BNE L9356 +doRtn6 RTS + REP 50 +; +; INCLUDE directive +; We can't declare a INCLUDE directive in +; an INCLUDE or a MACRO defn file +; +L9360 LDA IDskSrcF + BPL L9369 +L9364 LDX #$16 ;incl/chn nesting + JMP L90B1 +; +L9369 LDA MacroF ;Processing macros? + BMI L9364 ;Err -> INCLUDE in a macro defn file +; + JSR NxtField ;No, Point @ PN + LDA #$80 + STA IDskSrcF + JSR LD3B4 ;Get ptr to next srcline & save it +; + LDX #InclFile + JSR L9D51 ;Save curr line # of CHN/SRC file + JMP L929C ; b4 opening the INCLUDE file + REP 50 +; +; MACLIB directive - pg 115 +; MacroF $00=not using macros +; non-zero-macros enabled +; $04,$06 +; $40-macro had been invoked +; $80-curr srcline is an expanded stmt +; +L937F LDX #$06 ;Flag we are going + STX MacroF ; to use macros + LDA PassNbr ;Pass 2? + BNE L93AE ;Yes +; + LDA StrtSymT+1 ;Chk directive is b4 + CMP EndSymT+1 + BNE L9393 ; declaration of 1st idfer + LDA StrtSymT + CMP EndSymT + BEQ L9396 +L9393 JMP L9453 +; +L9396 LDA DskListF ;Output listing to file? + BNE L93A0 ;Yes +; + LDX #>MacExpBuf ;$7200 + LDA # 256 & is treated as # of bytes +; Case 2) Operand < 128 & is the # of mempages +; In both cases, the work buffers will align at +; the start of a mempage +; NB These directives must be declared b4 any +; symbols/identifers, and cannot be in an +; INCLUDE file +; min size of SBuf/IBuf = 1 mempage +; +L93C4 LDX #InclFile + DB $2C +; SBUFSIZ directive +L93C7 LDX #ChnFile + LDA PassNbr ;Pass 1? + BNE L93FC ;No +; + TXA ;Save (X) + PHA + JSR L9439 ;Get # of pages + PLA + TAX ;X=2,4 + LDA ValExpr+1 ;Is requested # of mem pages + CMP XA056+1,X ; =< curr bufsize? ($A059,$A05B) + BCC L93FF ;Less than + BEQ L93FC ;Same size, no further action +; +; When size of SBuf is increased/decreased, we need to +; adjust the ptrs to the start of 1) IBuf & 2) SymTbl +; When size of IBuf is increased/decreased we need to +; adjust the ptr to the start of SymTbl only. +; Do we need to ensure there is 1 mempage btwn +; the end of SBuf & start of IBuf? +; + LDY XA056+1,X ;No, bufsize has increased so save + STY ValExpr ; curr bufsize here temporarily + STA XA056+1,X ;Set new bufsize + SEC + SBC ValExpr + CLC + PHA ;(A)=# of pages to increment + ADC XA074+3,X ;$A079/$A07B since X=2 or 4 + STA XA074+3,X ;NB.($A07A,7B) has not been initialised! + PLA + CLC + ADC StrtSymT+1 + STA StrtSymT+1 ;New start of Symbol table + STA EndSymT+1 + CMP MemTop+1 ;Chk within mem limits + BCS L940F ;err +L93FC JMP DrtvDone +; +; (A)=new bufsize (in mempages) +; +L93FF CPX #ChnFile ;Are we resizing the SRC buf? + BNE L9414 ;No +; + CLC ;X=2 + ADC XA074+1,X ;Chk that the EO SBuf ($A077) + SEC + SBC #1 + CMP XA06A+1,X ; is above ($A06D) - bug? + BCS L9414 ;($A06D) has not been initialised! +L940F LDX #$3C ;bufsiz err + JMP L9441 +; +L9414 BEQ L93FC + LDA ValExpr+1 ;New size of ibuf/sbuf + LDY XA056+1,X ;Curr size of ibuf/sbuf ($A059,$A05B) + STA XA056+1,X + TYA + SEC + SBC ValExpr+1 + STA ValExpr+1 ;# of pages to decrement + LDA XA074+3,X ;$A079/$A07B since X=2/4 + SEC + SBC ValExpr+1 + STA XA074+3,X +; + LDA StrtSymT+1 ;More mem for sym table + SEC + SBC ValExpr+1 + STA StrtSymT+1 + STA EndSymT+1 + JMP L93FC + REP 50 +; +; Get # of mem pages +; +L9439 LDX FCTIndex + CPX #ChnFile ;SRC file? + BEQ L9447 ;yes +; + LDX #$3A ;Invalid fr INCLUDE +L9441 JSR RegAsmEW +L9444 JMP CanclAsm +; +L9447 LDA StrtSymT+1 ;Is symbol table empty? + CMP EndSymT+1 + BNE L9453 + LDA StrtSymT + CMP EndSymT + BEQ L9458 ;Yes +L9453 LDX #$30 ;No, invalid after 1st idfer + JMP L9441 +; +L9458 JSR L9013 + BCS L9444 + LDA ValExpr+1 ;If 16-bit value then ignore + BNE L9463 ; lobyte by taking hibyte + LDA ValExpr ;Since hibyte is 0, take lobyte to be # of mempages +L9463 STA ValExpr+1 ;bufsize is returned here in terms # of mempages + BEQ L9469 ;Can't be 0 + BPL doRtn7 ;Allow only mempages < $7F (actually $78) +L9469 LDX #$06 ;Overflow err + JMP L9441 +doRtn7 RTS + REP 50 +; +; SW16 directive +; This is acceptable +; SW16 operand +; where operand evaluates to a 16-bit addr +; +L946F JSR SkipSpcs + JSR ChrGot + BCC L948C ;alphabetic char + CMP #CR + BEQ L9482 + CMP #' ;' ;comment char? + BEQ L9482 ;yes +L947F JMP L9193 ;directive operand error +; +L9482 LDA #SWEET16 + STA ValExpr + BNE L9498 ;always +; +L948C JSR EvalExpr ;process operand + BCC L9494 ;good + JMP L94EE ;report err +; +L9494 LDA NxtToken ;sp/cr? + BNE L947F ;No, error +; +L9498 LDA #3 + STA Length + LDA #$01 + STA SW16F ;Flag SW16 opcodes can be assembled + LDA #$20 ;JSR opcode + STA GMC +L94A4 LDA #%00100111 + STA LstCodeF + LDA ValExpr + STA GMC+1 ;20 xx yy + LDA ValExpr+1 + STA GMC+2 + LDA RelExprF ;abs + BEQ L94BD +; + LDA #$01 ;offset + LDX #$02 + LDY #$00 ;Reverse order + JSR AddRLDEnt ;Make RLD entry +L94BD JMP DrtvDone + REP 50 +; +; SW16 SET pseudo opcode is parsed as a directive +; +L94C0 LDA #$10 ;pseudo opcode + STA GMC + LDA #3 + STA Length + JSR EvalExpr ;Rn (0-15) + BCS L94EE + LDA NxtToken + CMP #$01 ;Do we have a ,? + BNE L94EC ;No + JSR IsSW16Reg + BNE L94F2 ;No + LDA ValExpr + ORA GMC + STA GMC ;$1n where n=0-F + INY + INY + JSR EvalExpr ;Eval 2-byte constant + BCS L94EE + LDA NxtToken ;Must be cr/space + BEQ L94A4 +; + LDA #$34 ;Invalid delimiter err +L94EB DB $2C +L94EC LDA #$24 ;directive operand err +L94EE TAX + JSR RegAsmEW +L94F2 JMP DrtvDone + REP 50 +; +; Chk if sw16 reg ($00-$0F) +; Z=0 +; Z=1 - yes +; (Y)-unchanged? +; +IsSW16Reg LDA ValExpr+1 + BNE L9500 + LDA #$F0 + BIT ValExpr ;valid values 0-F + BNE L9500 + RTS +; +L9500 PHP + LDX #$32 ;SW16 reg err + JSR RegAsmEW + PLP + RTS + REP 50 +; +; Print Code Section. The following may be printed +; (1) program counter +; (2) generated machine code, +; (3) expr result/branch target field +; (4) cycle time +; of the assembled instruction +; Ref: Page 81 +; Input +; (LstCodeF) +; msb=0 => output ER field +; For the other bits: 0 => precede printing +; of a generated code byte with a space +; NB. Not all bits will be used even if they have been set +; +ListCode BIT ListingF ;Is listing on? + BPL doRtn8 ;No + BIT CondAsmF ;Conditional assembly? + BPL ListPC ;No +; +; A total of 17 chars are printed for code section +; + LDA #SPACE ;Unassembled src line + JSR PutC + LDA #'S' + JSR PutC + LDY #14 + LDA #SPACE +L951E JSR PutC + DEY + BPL L951E + BIT LstCyc ;Print cycle times? + BMI Pr3BL ;Yes, just print spaces instead +doRtn8 RTS +; +ListPC JSR PrtPC ;Print PC field + JSR PutC ; follow by : + LDA LstCodeF + STA SavLstF ;Save temporarily + ASL LstCodeF + ASL LstCodeF + LDX #0 + LDY #0 + ASL LstCodeF ;bit20 is usually 1 + BCS LCLoop +; + LDA #SPACE + JSR PutC + INY +Pr1BL LDA #SPACE + JSR PutC + INY +LCLoop CPX Length ;Have all generated code bytes been printed? + BCC PrMCode ;No + CPY #12 ;NB. By the time 4 MC bytes had + BCS LCDone ; been printed, (Y)=12 + LDA SavLstF ;Is there a result field? + BPL Pr1BL ;No, just print a space + CPY #8 ;Yes, print it now? + BCC Pr1BL ;Not yet +; + LDA ERfield+1 ;offset 8 fr : + JSR PrByte + LDA ERfield + JSR PrByte + JMP LCDone +; +PrMCode LDA GMC,X ;Up to 4 bytes of + JSR PrByte ; generated obj code + INX ; are printed/line + INY ;NB. When 3 MC bytes had + INY ; been printed, (Y)=8 here + ASL LstCodeF + BCC Pr1BL + BCS LCLoop ;always +; +LCDone BIT LstCyc ;Print cycle times? + BPL L959D ;no + LDX NumCycles + BNE PrCTimes +; +Pr3BL LDX #3 ;Output blanks when + JSR PrBlnkX ; no cycle times printed + BEQ L959D ;always +; +PrCTimes LDA #'(' ;Print Cycle times + JSR PutC + LDA #'E' + CPX #16 + BCS L9595 + TXA ;# of cycles + AND #$0F + ORA #'0' +L9595 JSR PutC + LDA #')' + JSR PutC +L959D LDA SavLstF ;Restore + STA LstCodeF + RTS + REP 50 +; +; Print src line +; Input +; (Src2P)-Point to BO a src line +; Ref pg 82 - TAB control +; +LstSrcLn LDA ZAB + CMP #$82 + BNE L95AB + JMP PutCR +; +L95AB JSR PrtDecS ;line # + LDY #-1 + STY TabTIdx ;index tabtable + INY ;=0 +L95B3 LDA (Src2P),Y ;get src char + LDX TabChar ;Get user-defined tabchar + CPX #SPACE ;Is it a space? + BEQ L95BF ;Yes + CPX #TAB + BNE L95F5 +; +L95BF CMP #TAB ;Is src char a TAB? + BEQ L95C7 ;Yes + CMP #SPACE + BNE L95F5 +; +L95C7 INC TabTIdx + LDX ZAB + INX ;-1? + BEQ L95F3 ;Yes + LDX TabTIdx ;1st tab stop? + BEQ L95E3 ;Yes + CPX #2 ;3rd tab stop? + BEQ L95E3 ;Yes + BCS L95F3 + LDA ZAB ;2nd tabstop + CMP #$7F ;Alt block? + BEQ L95E3 + BIT Bit20 + BNE L95C7 +; +; Only the first 3 editor tabs are used if +; first tab setting is >= 12 +; +L95E3 LDA TabTable,X ;Get tab stop fr editor's tab table + SEC + SBC PrtCol + BCC L95F3 + BEQ L95F3 + TAX ;(A)=# of spaces to print + JSR PrBlnkX + BEQ L95F8 ;always +; +L95F3 LDA #SPACE +L95F5 JSR PutC +L95F8 INC Src2P ;Skip src tab char + BNE L95FE + INC Src2P+1 +L95FE CMP #CR + BNE L95B3 + RTS + REP 50 +; +; Output char in Acc thru printer or video +; A, X, Y regs are preserved +; +PutC STA SaveA ;Save the regs + TXA + PHA + TYA + PHA + LDA SaveA ;Restore char + CMP #FF + BEQ L963A + CMP #CR + BNE L9666 +; + LDX PrtCol ;# of chars printed so far + BNE L961E + LDA #SPACE ;newline + JSR PrtChar + LDA #CR +L961E INC LineCnt + LDX LineCnt + CPX LogPL + BCC L9666 + LDA PhyPL ;Did user set this(via ctl-string)? + BNE L9632 ;Yes + BIT SubTtlF ;SBTL directive? + BVS L9642 ;Yes +; +L962E JSR DoLF ;LF +L9631 INX +L9632 CPX PhyPL + BCC L962E + BEQ L962E + BCS L9652 ;always +; +L963A LDX LineCnt + BEQ L9674 + LDA PhyPL ;Is this set? + BNE L9631 ;Yes +; +L9642 JSR IsVideo ;Output via video? + BNE L964D ;No +; + JSR DoLF ;Yes, just output space followed by cr + JMP L9652 +; +L964D LDA #FF ;Send a FormFeed to printer + JSR PrtChar +; +L9652 LDA #0 + STA LineCnt + SED + SEC ;add 1 + ADC PageNbr + STA PageNbr + LDA #0 + ADC PageNbr+1 + STA PageNbr+1 + CLD + JMP L9674 +; +L9666 LDX LineCnt + BNE L9671 + LDX PrtCol + BNE L9671 + JSR L979F ;Print page header +L9671 JSR PrtChar +; +L9674 PLA ;Restore X,Y regs + TAY + PLA + TAX + LDA SaveA + RTS + REP 50 +; +; ($967B) +; +DoLF LDA #SPACE + JSR PrtChar + LDA #CR + JMP PrtChar + REP 50 +; +; X=# of spaces +; Z=1 +; +PrBlnkX LDA #SPACE + JSR PutC + DEX + BNE PrBlnkX + RTS + REP 50 +; +PrtPC LDA PC+1 + LDX PC + JSR PrByte + TXA + JSR PrByte + LDA #':' + RTS + REP 50 +; +; Prints (A) as 2 hex digits +; (X),(Y) preserved +; +PrByte PHA ;save + LSR + LSR + LSR + LSR + JSR PrHex + PLA +PrHex AND #$0F + ORA #'0' + CMP #'9'+1 + BCC L96AF + ADC #$06 +L96AF JMP PutC + REP 50 +; +; A, X, Y-regs are preserved +; Print BCD # ($60-62) out as a 5-char dec string +; The BCD digits are packed in 3 mem bytes +; but only up to 5 nybbles will be used. +; 12 34 05 is printed as 53412 +; The output dec string will be preceded +; by the required # of leading spaces +; +PrtDecS PHA + TYA + PHA + TXA + PHA + LDY #%00000011 + STY ZCF ;Make sure msb=0 for this byte + LDX #%00001010 ;Start w/lower nybble + STX ZCE ; of the 3rd BCD # +; + LDX #5 ;5 chars +L96C1 DEY ;=2 on fall thru +L96C2 LDA BCDNbr,Y ;$60-$62 + LSR ZCE + PHP ;Save C for later + BCC L96CE + LSR ;if odd, use the upper nybble + LSR ; by shifting it + LSR + LSR ; into lower nybble +L96CE AND #$0F ;Isolate BCD digit (0-9) + BNE L96DC ;non-zero +; + BIT ZCF ;Was prev output char a leading space? + BMI L96DC ;No => output as a '0' + CPX #1 ;unit's digit? + BEQ L96DC ;Yes => must print as a '0' + LDA #$10 ;Print as a leading space +; +L96DC EOR #'0' + JSR PutC + CMP #'0' ;C=1 if (A)='0'-'9' + ROR ZCF ;Save C for next iteration + PLP + DEX + BEQ L96ED ;done + BCS L96C2 ;Use the same byte + BCC L96C1 ;Was even => next byte +; +L96ED LDA #SPACE + BIT MacroF ;Macro Expanded line? + BPL L96F5 ;No + LDA #'+' +L96F5 JSR PutC + PLA + TAX + PLA + TAY + PLA + RTS + REP 50 +; +; Output char via monitor +; +MonCOUT PHA + ORA #$80 + BIT RDROM2 + JSR COUT1 ;video h/w + BIT RDBANK2 + PLA + RTS +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; A=output char to monitor/file/printer +; Ret: +; (A),(X),(Y)-preserved +; +PrtChar PHA + CMP #SPACE ;ctrl-chars? + BCC L9715 ;yes + INC PrtCol ;# of chars printed so far + BCS L9721 ;printable chars +; +L9715 CMP #FF ;Is it a CR? + BCC L9721 + CMP #CR+1 + BCS L9721 + LDA #0 ;Yes + STA PrtCol ;Reset cnt +L9721 LDA PrSlot ;Output thru 40-col video? + BEQ L9786 ;Yes + BIT DskListF ;Listing to file? + BPL L9777 ;No, printer +; + STX SaveX ;Save X,Y-regs + STY SaveY + LDX LstDBIdx + PLA + PHA + CMP #CR + BEQ L9739 + CMP #FF + BNE L9765 ;Proceed to save to buf +; +; Flush it - when char is FF/CR +; +L9739 AND #$7F ;Make sure its std ASCII + STA LstDBuf,X ;Save char in data buffer + INX + STX WrLstLen + LDA #0 + STA WrLstLen+1 + JSR PRODOS8 + DB $CB + DW WrLstPB + BEQ L9761 +; + PHA ;ProDOS error code + LDA #0 + STA DskListF ;Reset all subsequent + LDA VidSlot ; output through + STA PrSlot ; video card + LDX #LstFile + JSR ClsFileX + PLA + JSR DOSErrs ;don't come back +; +L9761 LDX #0 + BEQ L976F ;always +L9765 AND #$7F ;Save char in Circular Data buf + STA LstDBuf,X + INX + BNE L976F + BEQ L9765 ;Buf is filled so store @ beginning +; +L976F STX LstDBIdx ;# of bytes to write + LDX SaveX + LDY SaveY + PLA + RTS +; +; Output via I/O hooks set by a PR#n cmd +; +L9777 PLA + PHA + ORA #$80 + BIT RDROM2 + JSR COUT + BIT RDBANK2 + PLA + RTS +; +; 40 col output via video H/W +; (Y)-preserved +; +L9786 STY SaveY + LDY PrtCol + PLA + CMP #SPACE + BCC L9797 ;Non-printable char +; + CPY WinLeft ;R we within display window? + BCC L979C + CPY WinRight + BCS L979C ;No +; +L9797 LDY SaveY + JMP VidOut +; +L979C LDY SaveY + RTS + REP 50 +; +; Print the header +; Ret: +; (A) & (Y) preserved +; +L979F BIT ListingF ;listing on? + BMI L97A4 ;yes + RTS +; +L97A4 BIT SubTtlF ;SBTL directive? + BVS L97A9 ;Yes + RTS +; +L97A9 PHA + TYA + PHA + LDY FileNbr + BIT Bit40 +; + JSR Prt1Dec ;print it + LDA #SPACE + JSR PrtChar + LDY #0 + LDA (SrcPathP),Y ;Get len byte of Pathname + TAX + CMP #16 + BCC L97D2 + LDX #0 + TAY ;Index last char of PN + LDA #'/' +L97C7 CMP (SrcPathP),Y ;Look for a trailing / + BEQ L97CF ;Got it + INX + DEY + BNE L97C7 ;Keep looking +L97CF INY + BNE L97D4 ;always +; +L97D2 LDY #1 ;Skip past len byte +L97D4 LDA (SrcPathP),Y ;Get char of filename + JSR PrtChar + INY + DEX + BNE L97D4 + LDA #SPACE + JSR PrtChar +L97E2 LDY PrtCol ;Print reqd # of blanks + CPY #19 + BCS L97F0 + LDA #SPACE + JSR PrtChar + JMP L97E2 +; +L97F0 LDX #0 + BIT SubTtlF ;Is there a title string? + BPL L9801 ;No +L97F6 LDA SubTitle,X + BEQ L9801 ;null-terminated + JSR PrtChar + INX + BNE L97F6 +L9801 LDA #SPACE ;Print reqd # of spaces + JSR PrtChar + INX + CPX #36 + BCC L9801 +; + LDX #0 +L980D LDA DateTime,X ;Follow by printing + JSR PrtChar ;the DATE & TIME + INX + CPX #16 + BCC L980D +; + LDX #0 +L981A LDA PageTxt,X + JSR PrtChar + INX + CPX #6 + BCC L981A +; + LDX #1 + CLV ;Bug? +L9828 LDY PageNbr,X ;page # + JSR Prt1Dec + DEX + BPL L9828 +; + LDA #CR + JSR PrtChar + LDA #SPACE + JSR PrtChar + LDA #CR ;Output a blank line + JSR PrtChar + LDA #2 + STA LineCnt + PLA + TAY + PLA + RTS +; +PageTxt ASC ' PAGE ' + REP 50 +; +; ($984D) +; Entry: +; (Y)=BCD # +; Ret: +; +Prt1Dec LDA #%10101010 +L984F ASL + PHA + TYA + BCC L9858 + LSR ;Shift upper nybble + LSR + LSR + LSR ; to lower nybble +L9858 AND #$0F ;Isolate lonybble + BNE L985E + BVC L9866 +L985E ORA #'0' + JSR PrtChar + BIT Bit40 +L9866 PLA + BPL L984F + RTS + REP 50 +; +; Entry: +; (X)=index into text message block +; +L986A LDA ASEndTxt,X + CMP #SPACE + BCC L9877 + JSR VidOut + INX + BNE L986A +L9877 TAY + BEQ PrtCR + RTS +; +PrtCR LDA #CR + JMP VidOut + REP 50 +; +; Entry: +; A=char to be displayed on ROM monitor/video card +; A, X, Y regs are preserved +; +VidOut STY SaveY + STX SaveX + PHA ;Char to be displayed + LDA VidSlot ;slot # + BEQ L98A2 +; + JSR SwapIO ;Swap in 80-col display + PLA + PHA + ORA #$80 + BIT RDROM2 + JSR COUT + BIT RDBANK2 + JSR SwapIO ;Swap out 80-col display + PLA +L989D LDY SaveY + LDX SaveX + RTS +; +L98A2 PLA + JSR MonCOUT + JMP L989D +;================================================= +SwapIO LDY #3 +L98AB LDA IOHooks,Y + PHA + LDA CSWL,Y ;Save curr I/O Hooks + STA IOHooks,Y ;vector here + PLA + STA CSWL,Y ;Set I/O to Firmware + DEY + BPL L98AB + RTS +; +IOHooks DW BASICINT ;$C300 + DW RDKEY +;================================================= +; Not used? +L98C1 LDA #$20 +L98C3 STA (BASL),Y + INY + CPY WNDWDTH + BCC L98C3 + RTS + REP 50 +; +; Do a Form Feed if output to printer +; +PrtFF JSR IsVideo ;Video output? + BEQ L98D5 ;Yes +; + LDA #FF ;send to printer + JMP PutC +; +L98D5 LDA #SPACE + JSR PutC + JMP PutCR + REP 50 +; Entry: +; A - slot # +; Ret: +; Z=1 - output thru video +; X,Y - not used +; +IsVideo LDA PrSlot ;Std 40-col? + BEQ Exit1 + CMP #3 ;Slot 3 80-col card +Exit1 RTS +; +Tens2Tbl DB 0,10,20,30,40,50,60,70,80,90 + REP 50 +; +; Open a file for reading/writing +; Destroy if it's OBJ/LST file and create a new one +; Entry: +; X=FCTIndex (0,2,4,6,8) +; +Open4RW JSR SetPNBuf ;Set ptr to correct PN buf + LDA #0 + STA XA04C,X ;Zero flag + STA XA04C+1 ;Len of partial line rec + LDA PathP + STA GFIPN + STA DestroyPN + LDA PathP+1 + STA GFIPN+1 + STA DestroyPN+1 + JSR PRODOS8 + DB $C4 + DW GFInfoPB + TAY ;Save err code if any + CPX #LstFile + BEQ L991A + CPX #ObjFile + BNE L9962 ;If (X)=2,4,6 ==> Don't destroy these + STX ObjDBIdx ;Zero this +; +L991A TYA ;Does OBJ/LST file exists? + BEQ L9923 ;Yes + CMP #$46 ;File not found? + BEQ L9948 ;Yes, so that's ok for OBJ/LST files + BNE L997E ;Some other errors, report it +; +L9923 LDA GFIftype ;Check the file type + CMP #BINtype + BEQ L993D ;Proceed to destroy it + CMP #RELtype ;Kill all files whose type + BNE L993D ; is not REL including SYS + CMP #SYStype ;On fall thru (A)=REL + BNE L9939 ;Always! -> destroy +; +L9932 CMP ftypeT,X ;Same filetype? + BNE L997C ;No, err + BEQ L993D ;Yes +; +L9939 CPX #LstFile + BEQ L9932 +; +L993D JSR PRODOS8 + DB $C1 + DW DestroyPB + BEQ L9948 + JSR DOSErrs +; +L9948 LDA PathP + STA CreatePN + LDA PathP+1 + STA CreatePN+1 + LDA ftypeT,X + STA CrFType + JSR PRODOS8 + DB $C0 + DW CreatePB + BEQ L9981 ;If no errs, check it's there + BNE L997E ;always +; +; Handle SRC,INCLUDE,MACRO files +; (X=)2,4,6 +; If macro file doesn't exist, it is not +; considered fatal. Just ret to mainloop +; +L9962 TYA ;If no errs then + BEQ L9975 ; the file exists + CPX #MacFile + BNE L997E + CMP #$46 ;File not found? + BNE L997E +; + LDX #$20 ;Macro file not found + JSR RegAsmEW + JMP CanclAsm +; +L9975 LDA GFIftype ;Ensure it's a TXT file + CMP #TXTtype + BEQ L9989 ;Proceed to open +; +L997C LDA #$11 ;EI error code +L997E JSR DOSErrs +; +L9981 JSR PRODOS8 ;Chk newly created OBJ/LST file is there + DB $C4 + DW GFInfoPB + BNE L997E ;Sorry, some sort of OS error +; +L9989 LDA PathP ;Open for I/O + STA OpenPN + LDA PathP+1 + STA OpenPN+1 + LDA FBufTbl,X + STA OpenFBuf + LDA FBufTbl+1,X + STA OpenFBuf+1 + JSR PRODOS8 + DB $C8 + DW OpenPB + BEQ L99AA + JSR DOSErrs +L99AA LDA OpenRN + STA RefNbrT,X + RTS + REP 50 +; +; ($99B1) +; Close the file flushing it only if its an OBJ file +; Entry: +; (X)-index into file control tables +; X,Y-preserved +; +ClsFile TYA + PHA + TXA + PHA + BNE L99BD +; (X)=0 + JSR Flush ;OBJ file + PLA + PHA + TAX +; +L99BD JSR SetPNBuf + JSR ClsFileX + PLA + TAX + PLA + TAY + RTS +;================================================= +; Entry: +; (X)=index into File Control Table +; RefNbrT +; Ret: +; RefNbrT +; (X),(Y)-unchanged +; +ClsFileX LDA RefNbrT,X + BEQ Exit2 ;Already closed + STA CloseRN + JSR PRODOS8 + DB $CC + DW ClosePB + BEQ L99DB + JSR DOSErrs +; +L99DB STA RefNbrT,X ;zero the slot +Exit2 RTS + REP 50 +; +; Write out all obj code +; For REL files, append RLD and ESD (if required) +; Create a new objfilename fr old name +; (GenF)=$00,$40,$80,$8F,$FF +; Entry: +; N=1 - No code generation +; V=1 - Write to disk file +; V=0 - Write to mem +; RelCodeF=$80 +; Ret: +; GenF=$C0 +; +L99DF BIT GenF ;Generate code? + BPL L99E4 +Exit3 RTS ;No +; +L99E4 BVC Exit3 ;Writing to mem, skip code below + PHA ;Save A,X,Y regs + TYA + PHA + TXA + PHA + LDA RelCodeF ;Writing REL codefile? + BMI L99F2 ;Yes + JMP L9AA2 +; +L99F2 LDA CodeLen ;Save temporarily cos + STA CodeImgLen ; its val will changed + LDA CodeLen+1 ; when the RLD is appended + STA CodeImgLen+1 ; by calling Wr1Byte + LDA MemTop ;leftovers? +; + SEC + LDA RLDEnd + SBC #4 + STA RLDEnd + LDA RLDEnd+1 + SBC #0 + STA RLDEnd+1 +; + LDA MemTop + STA RLDEntP + LDA MemTop+1 + STA RLDEntP+1 +; +; Write out all entries in Relocation Dictionary +; +L9A11 LDA RLDEntP ;Point @ EO of entry + SEC + SBC #4 + STA RLDEntP + LDA RLDEntP+1 + SBC #0 + STA RLDEntP+1 +; + LDA RLDEnd + CMP RLDEntP + LDA RLDEnd+1 + SBC RLDEntP+1 + BCS L9A35 ;Finish writing out all RLD entries +; + LDY #3 +L9A2A LDA (RLDEntP),Y ;Write out RLD entry + JSR Wr1Byte ;1st byte written is RLD flag byte + DEY + BPL L9A2A + JMP L9A11 ;Next RLD entry +; +L9A35 LDA #0 ;Mark EO RLD + JSR Wr1Byte ; with a zero byte + LDA MemTop ;Mark RLD is now empty + STA RLDEnd + LDA MemTop+1 + STA RLDEnd+1 +; +; This will write out all entries in the ESD if any +; The code scans through the entire symbol table +; looking for idfers which are marked as EXTeRNal/ENTRY +; The link field is not used at all because the nodes +; are stored one after another in contiguous mem. +; + LDA StrtSymT ;Start fr BO symbol table + CLC + ADC #2 + STA WrkP ;Skip link field + LDA StrtSymT+1 + ADC #0 + STA WrkP+1 +; +L9A4F LDY #0 +L9A51 LDA (WrkP),Y ;Get symbol's char + BPL L9A59 ;last char + INY + JMP L9A51 +; +L9A59 INY + LDA (WrkP),Y ;Symbol's flag byte + AND #external+entry + BEQ L9A82 ;No, skip this entry +; + STY SymLen +L9A62 LDY #0 +L9A64 LDA (WrkP),Y ;Write out the symbolicname + JSR Wr1Byte + INY + CPY SymLen + BNE L9A64 +; + LDA (WrkP),Y ;Write symbol's flag byte + JSR Wr1Byte + INY ;lobyte of addr if ENTRY or + LDA (WrkP),Y ;symbol # referred to by an RLD entry if EXTERN + JSR Wr1Byte + INY + LDA (WrkP),Y ;Hi-byte of addr if ENTRY + JSR Wr1Byte + JMP L9A84 +; +L9A82 INY + INY +L9A84 INY ;Skip link field of next Node + INY + INY ;Indexing symbolicname of next Node + TYA + CLC + ADC WrkP ;Pointing @ next symbolic name + STA WrkP + LDA WrkP+1 + ADC #0 + STA WrkP+1 +; + LDA WrkP + CMP EndSymT ;Finish? + LDA WrkP+1 + SBC EndSymT+1 + BCC L9A4F ;Loop back for more +; + LDA #$00 ;Marks EO ESD + JSR Wr1Byte +; +L9AA2 BIT RelCodeF ;REL file? + BPL L9AB9 ;No, BIN object file + LDX #ObjFile + LDY #0 + LDA #0 + JSR SetFPos ;Position to BOF + LDA CodeImgLen ;Store len of + JSR Wr1Byte ; code image + LDA CodeImgLen+1 + JSR Wr1Byte +; +; Create an OBJx name fr old name - ref pg 93 +; +L9AB9 LDX #ObjFile ;Close this OBJ file + JSR ClsFile + LDA #$C0 ;Suppress code generation + STA GenF + LDY ObjPNB ;len byte + LDA ObjPNB,Y + CLC + ADC #1 + CMP #'Z'+1 + BNE L9AD3 + LDA #'0' ;start fr 0 + BNE L9AD9 ;always +L9AD3 CMP #'9'+1 + BNE L9AD9 + LDA #'A' +L9AD9 STA ObjPNB,Y + PLA + TAX + PLA + TAY + PLA + RTS + REP 50 +; +; Write 1 byte +; Write out to file when buf is filled with 128 bytes +; Entry: +; (A)-byte to be written +; ObjDBIdx-# of bytes in buf/index to next byte to store +; +; Ret: +; (FileLen)++ +; (CodeLen)++ +; Preserved: +; (A),(X) +; +Wr1Byte STA OneByte + PHA + TXA ;save X + PHA + LDX ObjDBIdx + LDA OneByte + STA ObjDataB,X + INC ObjDBIdx ;Is buffer full? + BPL L9AFB ;No + TYA ;Save Y + PHA + JSR Flush ;Write out to disk + PLA + TAY +; +L9AFB INC FileLen ;curr filelen + BNE L9B01 + INC FileLen+1 +L9B01 INC CodeLen ;curr len of code image + BNE L9B07 + INC CodeLen+1 +L9B07 PLA + TAX + PLA + RTS + REP 50 +; +; Write out generated object code +; Entry: +; ObjDBIdx-# of bytes to write +; +Flush LDX #0 + JSR SetPNBuf + LDA ObjDBIdx + BEQ L9B50 ;Nothing to write + STA WrObjLen + STX WrObjLen+1 + LDA #>ObjDataB + STA WrObjDB + LDA # write obj code +L9B69 PLA + PHA + TAX + LDA RefNbrT,X + STA SMarkRN + LDA #0 + STA SMfposn+2 + JSR PRODOS8 + DB $CE + DW SMarkPB + BEQ L9B82 + JSR DOSErrs +; +L9B82 PLA + TAX + PLA + TAY + PLA + RTS + REP 50 +; +; Character Handler +; Get next assembly statement +; This subrtn should be part of src handler +; Entry: +; DskSrcF - +; MacroF - +; FCTIndex - 2,4,6 +; +; Ret: +; SrcP +; C=0 - more src lines to process +; C=1 - all lines assembled +; MacroF - $8x if macro expanded source line +; (X) changed +; FCTIndex +; IDskSrcF-include file +; +GSrcLin EQU * + LDA DskSrcF ;Are we using disk source files? + BMI L9B95 ;Yes +; + LDA SrcP ;Chk if there are still + CMP TxtEnd ; lines to be assembled + LDA SrcP+1 + SBC TxtEnd+1 +Exit4 RTS ;If C=1, done +; +L9B95 BIT MacroF ;Have a macro been invoked? + BVS L9B9D ;Yes + BPL L9BA2 ;No + BMI L9B9F ;Always -> Get stmt fr macro defn file +; +L9B9D ASL MacroF ;=$80 +L9B9F JMP L9CDD ;Handle macro defn file +; +; Chain/Include files are handled here +; +L9BA2 LDX FCTIndex ;=2,4 + LDA XA04C,X ;Get flag + STA XA04C + BIT XA04C ;Ready for processing? + BVC L9BBB ;No +; + LDA SrcP ;Are we done with this + CMP XA06A,X ; $A06C/$A06E + LDA SrcP+1 ; chunk of source code? + SBC XA06A+1,X + BCC Exit4 ;No +; +L9BBB JSR L9BFC ;Read another block + BCS L9BCC +; + LDA XA060,X ;$A062/$A064 + STA SrcP ;Point @ beginning + LDA XA060+1,X + STA SrcP+1 ; of block of source code + CLC + RTS +; +L9BCC LDX FCTIndex + JSR ClsFile ;Close it + CPX #ChnFile ;SRC + BEQ L9BD8 + JSR L9D61 ;X=4 +; +L9BD8 LDA #0 + STA XA04C,X ;X=2/4 + CPX #InclFile + BCS L9BE3 + SEC ;SRC was closed + RTS +; +L9BE3 BEQ L9BE6 ;(X)=4 + BRK +; +L9BE6 DEX + DEX ;=2 + STX IDskSrcF ;NB. only msb has meaning + STX FCTIndex +; +; An INCLuded/macro defintion file was closed. We +; must return to the parent source file +; +L9BEC LDA XA060,X ;Point to where we were + STA SrcP + LDA XA060+1,X ; stop b4 suspension + STA SrcP+1 +L9BF6 JSR SetPNBuf ;Set up PN buf correctly + JMP L9B95 +; +; Read another block for source code +; +L9BFC BIT XA04C ;Ready 4 processing? + BVC L9C06 ;No + LDY XA04C+1,X ;Is there is a partial line leftover + BNE L9C0A ; from previous disk read? +L9C06 JSR ReadMore ;No, just read more src lines into mem + RTS +; +; Before we read a new block of source code into mem we +; need to move the partial line leftover from the last +; disk read into a temp buf indicated by LoMem. Then we read +; in a block of source code. After that we proceed to +; PREPEND the leftover partial line to the beginning of this +; new block of source code so we have a full line of code. +; Finally, we setup a ptr to this line of source code. +; For this to work during the entire assembly process, there +; must be one mem page ($100 bytes) reserved just below +; the start of the SRC/INCLUDE (SBuf/IBuf) data files i.e. +; if SBuf = $0900, a mempage must be reserved @ $0800 +; if IBuf = $0E00, a mempage must be reserved @ $0D00 +; +L9C0A LDA XA06A,X ;Point to the EO last + STA SrcP3 + LDA XA06A+1,X ; complete line rec of prev read + STA SrcP3+1 +; +; (Y)=len of partial line +; +L9C14 LDA (SrcP3),Y ;Copy partial line into + STA (LoMem),Y ; this part of mem + DEY + BNE L9C14 +; + LDA XA04C+1,X ;Len of the partial line should + STA BufIdx ; saved here first b4 we proceed + JSR ReadMore ; to load in more src lines +; +; Set (SrcP3) to point @ 1 mem page below the start +; of the block of source code just read in +; + LDY XA074+1,X ;Point to SBuf/IBuf (hi-byte) + DEY ;less 1 page + STY SrcP3+1 + LDY XA074,X ;$A076/$A078 + STY SrcP3 +; + LDA LoMem + STA L9C3E+1 ;self-modifying code + LDA LoMem+1 + STA L9C3E+2 +; + LDX BufIdx ;# of bytes to copy + LDY #255 +L9C3E LDA X0800,X ;Prepend partial line to + STA (SrcP3),Y ; start of source block + DEY + DEX + BNE L9C3E +; + INY + TYA + LDX FCTIndex + STA XA060,X ;Set a ptr to the beginning + LDA SrcP3+1 + STA XA060+1,X ; of block of source code + CLC + RTS + REP 50 +; +; Read in a block of src code into BO SBuf/IBuf +; fr a SRC/INCLUDE file +; +ReadMore LDX FCTIndex ;=2,4 + JSR SetPNBuf + LDA XA074,X ;Block of source code to be + STA ReadDBuf + LDA XA074+1,X ; read into this mem location + STA ReadDBuf+1 ;SBuf/IBuf +; + LDA #0 ;Whole # of + STA ReadLen + LDA XA056+1,X ;SBuf/IBuf size + STA ReadLen+1 ; pages are read + LDA RefNbrT,X + STA ReadRN + JSR PRODOS8 + DB $CA + DW ReadPB + BEQ L9C8F +; + CMP #$4C ;Is eof? + BEQ L9C86 ;Yes + JSR DOSErrs +; +L9C86 LDA #0 + STA XA04C+1,X ;Zero len of partial src line + PLA ;Dump ret addr + PLA + SEC + RTS +; +L9C8F LDA LenRead ;# of bytes read + CLC + ADC ReadDBuf + STA SBufP ;Point to end of + LDA LenRead+1 + ADC ReadDBuf+1 ; read data (+1) + STA SBufP+1 +; + LDA #CR + LDX #0 +L9CA4 LDY SBufP ;Search backwards + BNE L9CAA + DEC SBufP+1 +L9CAA DEC SBufP ; fr end of src buffer + LDY #0 + CMP (SBufP),Y ;Do we have a CR? + BEQ L9CBA ;Yes + INX + BNE L9CA4 ;Keep searching +; + LDA #$11 ;Can't find a CR -> File type mismatch + JSR DOSErrs +; +L9CBA TXA ;Len of partial line + LDX FCTIndex + STA XA04C+1,X ; @ end of read buf + LDA SBufP ;This points to the end of + STA XA06A,X + LDA SBufP+1 ; last complete line rec + STA XA06A+1,X ; in SBuf/IBuf +; + LDA XA074,X + STA XA060,X ;Set src ptr to BO src data buf + LDA XA074+1,X + STA XA060+1,X + LDA #$40 ;Marks block is ready for processing + STA XA04C,X + CLC + RTS + REP 50 +; +; Read a src line fr macro definition file into +; expansion buf. Expand the src line. +; Assume during expansion of a srcline, the MacStrBuf +; is not overwritten. +; Entry: +; (X)=6 +; +L9CDD LDX FCTIndex ;Is curr src file + CPX #MacFile ; a macro defn file? + BEQ L9CE4 ;Yes + BRK +L9CE4 JSR SetPNBuf ;Set up PN buf to Macro defn file + LDA RefNbrT,X ;Macro defn file already opened + STA ReadRN + LDX #127 ;lexLength + LDA #CR ;Fill buf w/cr +L9CF1 STA MacExpBuf,X + DEX + BPL L9CF1 +; + LDX #0 ;index=0 +L9CF9 LDA #>OneByte + STA ReadDBuf + LDA #MacExpBuf ;Get srcline fr this area + STA SrcP + LDA #1st char can't be numeric char +L9DA5 LDA DecimalS,Y ;Create a unique label + CMP #'1' + BCS L9DB0 + BIT ZCF + BPL L9DB7 +L9DB0 STA MacExpBuf,X ; within a macro expansion + SEC + ROR ZCF ;msb=1 + INX +L9DB7 INY + CPY #4 + BCC L9DA5 + SEC + RTS +; +L9DBE LDA MParmCnt ;Set when macro was invoked + ORA #'0' + CLC ;Store char in macro exp buf + RTS +; +; Replace argument w/substitution string +; +L9DC4 AND #$0F ;'0'-'9' -> 0-9 + STA MacArg + LDY #-1 +L9DCA INY + DEC MacArg + BMI L9DBE ;&0 parm + BEQ L9DD9 ;We have the correct substn str +; +L9DD1 LDA MacStrBuf,Y ;Look for a 0 delimiter + BEQ L9DCA ;Got one + INY + BNE L9DD1 +; +L9DD9 LDA MacStrBuf,Y ;Now copy str over starting + BNE L9DE0 + SEC + RTS +L9DE0 STA MacExpBuf,X ; fr the correct position + INY + INX + LDA MacStrBuf,Y + BNE L9DE0 + SEC + RTS +; +L9DEC PHA + TXA + PHA + LDX #$1A ;mac arg err + JSR RegAsmEW + PLA + TAX + PLA + RTS + REP 50 +; +; Incr by decimal str by 1 +; +L9DF8 LDY #4 + SEC ;Add 1 to cntr +L9DFB DEY + BMI Exit5 ;done + LDA DecimalS,Y ;valid values $30-$39 + AND #%00111111 + SED + ADC #0 + CLD + CMP #$40 + BCC L9E0D ;No overflow + EOR #%01110000 ;Zero it (=$30 or '0') +L9E0D STA DecimalS,Y + BCS L9DFB ;Overflow, 'carry' forward +Exit5 RTS + REP 50 +; +; ($9E13) +; (X)=Common index into various file control tables +; Valid values of (X)=0,2,4,6,8 +; +; Ret: +; (PathP)-ptr to PN buffer +; ($C9) - ptr to SRC/INCL PN +; For source files (X=2,4,6), FCTIndex=(X) +; A,Y preserved +; +SetPNBuf CPX #9 ;max 8 + BCC L9E18 + BRK +L9E18 PHA + LDA PNTable,X ;Get ptr to pathname + STA PathP ; buffer to use + LDA PNTable+1,X + STA PathP+1 + TXA + BEQ L9E38 ;X=0 +; + CPX #MacFile + BEQ L9E36 ;X=6 + BCS L9E38 ;X=8 +; + LDA PNTable,X ;X=2,4 + STA SrcPathP + LDA PNTable+1,X + STA SrcPathP+1 +; +L9E36 STX FCTIndex ;=2,4,6 +L9E38 PLA + RTS + REP 50 +; +; $9E3A-not referenced +; + INC CancelF + JSR CountErr ;incr # of errs + JMP CleanUp + REP 50 +; +; Handler ProDOS errors +; Such errors will cause the Assembler to abort +; (A)=error code (defined in EI module) +; +DOSErrs TAX + PLA + STA ZPRetAdr + PLA + STA ZPRetAdr+1 + TXA + PHA + JSR PutCR + PLA + JSR PrtError ;Output thru EdAsm Interp + JMP CanclAsm +;================================================= +SBufSize DB 4 ;Defaults to 4 pages=1K +IBufSize DB 16 ;Defaults to 16 pages=4K +; +; Table of ptrs to pathname buffers +; +PNTable DW ObjPNB ;ptrs to fullpathname buffers + DW ChnPNB + DW InclPNB + DW MacroPNB + DW LstPNB ;May be a partial PN +; +; ($9E61) These 1024-byte areas are used by ProDOS8 +; A ptr to them is passed when an MLI Open call is made +; If there is a disk output of the listing, the MACRO +; I/O buf will be $6E00-$71FF. Otherwise its $7400-$77FF +; $7200-$727F: Macro expansion buf +; $7280-$72FF: Macro string parm buf +; $7300-$73FF: LST data buf +; +FBufTbl DW XA100 ;OBJ + DW XA500 ;SRC + DW XA900 ;INCL + DW X7400 ;MACRO (ptr changed if listing to file) + DW X7400 ;LST +; +; $9E6B-only 5 out of 10 bytes used +; +RefNbrT DS 10,0 ;ProDOS8 file ref #s for 5 open files +; +OneByte DB $00 ;1-byte data buffer +BufIdx DB $00 +; +; $9E77 All these P8 parameter blocks are internal to EdAsm.Asm +; +OpenPB DB $03 +OpenPN DW $0000 +OpenFBuf DW $0000 +OpenRN DB $A0 +; +ReadPB DB $04 +ReadRN DB $A0 +ReadDBuf DW $A0A0 +ReadLen DW $A0A0 ;requested +LenRead DW $A0A0 ;actual +; $9E85 +WrObjPB DB $04 ;BIN/SYS/REL obj code file +WrObjRN DB $A0 +WrObjDB DW $A0A0 +WrObjLen DW $A0A0 + DW $A0C0 +; $9E8D +WrLstPB DB $04 ;TXT file +WrLstRN DB $A0 + DW LstDBuf +WrLstLen DW $A0C0 + DW $A0C5 +; Not used +L9E95 DB $02 + DW $00A0 + DW $0000 +; Not used +L9E9A DB $01 ;get/set prefix + DW EdAsmDir +; Not used +L9E9D DB $02 + DW $FEA0 + DW $A0A0 +; +GFInfoPB DB $0A +GFIPN DW $A0A0 +GFIAcc DB $A0 ;access bits +GFIftype DB $A0 + DW $A0A0 + DB $A0 + DW $A0A0 + DW $A0A0 + DW $A0A0 + DW $A0A0 + DW $A0A0 +; +SFInfoPB DB $07 + DW $A0A0 + DB $A0 + DB $C0 +SFIaux DW $A0A0 + DB $A0 + DW $A0A0 + DW $0000 + DW $0000 +; +CreatePB DB $07 +CreatePN DW $A0A0 +;CreatABits DB $C3 + DB $C3 +CrFType DB TXTtype + DW $0000 + DB $01 + DW $0000 + DW $0000 +; +DestroyPB DB $01 +DestroyPN DW $A0A0 +; +ClosePB DB $01 +CloseRN DB $A0 +; +SMarkPB DB $02 +SMarkRN DB $A0 +SMfposn DS 3,$A0 +; +OnlinePB DB $02 +OLUnit DB $A0 +OLBufAdr DW $A0EB ;=$7300 +; +; Name of 1st SRC file is stored here +; +L9EDC DS $23,0 ;$9EDC-$9F1C (should be 65) + DSECT + ORG L9EDC+65 +;================================================= +; 5 files may be opened at any one time +; OBJ, SRC, INCLUDE, MACLIB, LST +; X=0 object file +; X=2 source file/chained source file +; X=4 include source file +; X=6 macro defn file +; X=8 listing file +; +ObjPNB DS 65 ;Object +ChnPNB DS 65 ;Chain +InclPNB DS 65 ;Include +MacroPNB DS 65 ;macro lib's prefix +LstPNB DS 33 ;LST filename +; corr filetypes +ftypeT DS 10 +; +; ($A04C) This table consists of five 2-byte entries +; 1st byte is a flag; 2nd byte len of partial line which doubles +; as an index into the last mem page of the SBuf/IBuf data buffers +; +; $A04C,$A04D,$A04E-$A051 +; +XA04C DS 10 ;$A04C-$A055 +; +; curr val of SBufSiz, IBufSiz +; Only $A059/$A05B used +; +XA056 DS 10 ;$A056-$A05F +; +; The table below store ptrs to the mem location of the +; curr src line within the block of source code of +; consisting of complete line recs +; $A060 : Unused +; $A062 : src/chn +; $A064 : incl +; $A066 : Unused +; $A068 : Unused +; +XA060 DS 10 ;$A060-$A069 +; +; The table below store ptrs to the mem location of +; the end of last complete line record in SBuf/IBuf +; $A06A : Unused +; $A06C : No init - src/chn +; $A06E = $1D00 - incl +; $A070 : Unused +; $A072 : Unused +; +XA06A DS 10 ;$A06A-$A073 +; +; Memory map: +; $0800-$08FF - Reserved for use with SRC data buf +; $0900-$0CFF - SRC file data buffer - 4 mempages +; $0D00-$0DFF - Reserved for use with INCLUDE data buf +; $0E00-$1DFF - INCLUDE file data buffer - 16 mempages +; $1E00-$xxxx - Start of Symbol table +; +; The following locations are set +; to point @ various buffers: +; $A074 <= $1E00 +; $A076 <= $0900 +; $A078 <= $0E00 - changed by SBufSize directive +; $A07A : No init but may be changed by IBufSiz directive +; $A07C : Unused? +; +XA074 DS 10 ;$A074-$A07D ptrs to start of SBuf/IBuf data bufs +; +; $A07E : line # (lo) - hi is stored at $A086 +; $A080 : line # (lo) - hi is stored at $A088 +; $A082 : Unused? +; $A084 : Unused? +; $A086 : line # (hi) +; $A088 : line # (hi) +; $A08A : Unused? +; $A08C : Unused? +; +XA07E DS 8 ;$A07E-$A085 +XA086 DS 8 ;$A086-$A08D +SubTitle DS 36 ;Store area for subtitle string ($A08E-$B1) +; +; +; This is a table of recs which is used to store +; a) the file # where an asmbly error occurs (1-byte) +; b) index into a table of ptrs to Error msgs (1-byte) +; c) line # of src stmt which is flagged as incorrect (2 bytes) +; Up to 16 (64 bytes) errors may be saved for later display +; +ErrInfoT DS 64 ;($A0B2-$F1) + DEND \ No newline at end of file diff --git a/EDASM.SRC/ASM/EQUATES.S b/EDASM.SRC/ASM/EQUATES.S new file mode 100644 index 0000000..23f5092 --- /dev/null +++ b/EDASM.SRC/ASM/EQUATES.S @@ -0,0 +1,210 @@ +Name : EQUATES.S +End of file : 7,281 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + +************************************************** +* Symbol names ending with +* B - buffer +* F - flag +* P - pointer +* S - string (can be p,c or otherwise) +* T - table +* +* This would allow us to give more meaningful abbrv +* to symbol names +* +*================================================= +* +* Indices to access file control tables (FCT) +* +ObjFile EQU 0 +ChnFile EQU 2 +InclFile EQU 4 +MacFile EQU 6 +LstFile EQU 8 +* +* There are flags which describes the +* characteristics of a symbol - ref pg 231 +* +undefined equ $80 +unrefd equ $40 +relative equ $20 +external equ $10 +entry equ $08 +macro equ $04 +nosuchlabel equ $02 +fwdrefd equ $01 +* +* zero page usage +* NB. The contents of $60-$F1 are saved & will be +* restored by the Assembler on exit. +* Some of these locations are re-cycled i.e. they have a +* different meaning when use in another part of the code +* +Z60 EQU $60 +BCDNbr EQU $60 ;src file line #s in BCD +StrtSymT EQU $63 ;start of symtable +EndSymT EQU $65 ;curr end of symtable +PassNbr EQU $67 ;pass 1=0, pass 2=1 pass 3=2 +ListingF EQU $68 ;$80-LST ON +SubTtlF EQU $69 ;=$00,$40=SBTL, $FF=SBTL str +LineCnt EQU $6A ;# of printed lines +PageNbr EQU $6B +FileNbr EQU $6D +LogPL EQU $6E ;logical page len +PhyPL EQU $6F ;physical page len +SavIndX EQU $70 ;Temp location to save (X) +ByteCnt EQU $70 ;# of generated bytes so far +PrtCol EQU $71 ;Printing col +EIStack EQU $72 ;EdAsm Interpreter's stack ptr +CancelF EQU $73 +NbrErrs EQU $74 ;# of errors +PrSlot EQU $76 +AbortF EQU $77 +SavIndY EQU $78 ;Temp location to save (Y) +SrcP EQU $79 ;Set to point to somewhere within src line +UnsortedP EQU $79 ;Ptr to a record of the unsorted aux work array +Src2P EQU $7B ;Copy of src ptr used during code listing +PC EQU $7D ;position/program counter +SortedP EQU $7D ;Ptr to a record of the sorted aux array +ObjPC EQU $7F ;PC for OBJ code store in mem +SymFBP EQU $7F ;Ptr to a symbol's flag byte field (use during pass1) +CodeLen EQU $7F ;curr len of code image of REL files (stored @ BOF) +AuxAryE EQU $7F ;Ptr to last end of sorted array +FileLen EQU $81 ;curr len of BIN/REL file +CurrORG EQU $83 ;curr origin addr +SymP EQU $85 ;Ptr to symbol +MnemP EQU $85 ;Ptr to mnenmonic table entry +Delimitr EQU $85 ;Double as delimiter +DTEndCol EQU $85 ;end index of DateTime str +StrType EQU $86 ;0=DCI -1=ASC +DTCurIdx EQU $86 ;curr index into DateTime str +MemTop EQU $87 +TotLines EQU $89 ;3 bytes +VidSlot EQU $8C +SaveA EQU $8D +SaveY EQU $8E +SaveX EQU $8F +DskListF EQU $90 ;$00,$40,$80-list to txt file +LstDBIdx EQU $91 ;LST Data buf index, double as # of chars to write +WinLeft EQU $92 ;left & right edges +WinRight EQU $93 ;of 40-col window +X6502F EQU $94 +HighMem EQU $95 ;HiMem of generated obj code +ExprAccF EQU $97 ;expression's accumulated flag bits +ColCnt EQU $97 ;curr print col +SortF EQU $98 +NxtToken EQU $98 ;Flag to indicate nature of next char +LstCodeF EQU $99 ;Bits to control listing of machine code +SymRefCh EQU $99 ;Preceding char printed b4 symbol's addr +GMC EQU $9A ;$9A-$9D Generated Machine Code buf +IsFwdRef EQU $9A ;Forward ref bit was set +NumCols EQU $9B ;=2,4,6 # of print cols +SymIdx EQU $9C ;Save index into symbol record +ERfield EQU $9D ;Expr Result field +SymAddr EQU $9D ;Addr associated w/symbolicname +ValExpr EQU $9F ;value of expression +RLDEntP EQU $9F ;Ptr to RLD entry +WrkP EQU $A1 ;Work ptr to symbol table entry +JJJ EQU $9F ;Running vars used +III EQU $A1 ; during sorting +Length EQU $A3 ;len of inst => 1-1 byte, 2-2 bytes etc +ModWrdL EQU $A4 ;Permitted modes of a 65C02 +ModWrdH EQU $A5 ; mnemonic/SW16 pseudo opcode +StrtIdx EQU $A3 ;Starting index of FOR loop +EndIdx EQU $A5 ;Ending Index of FOR loop +LenTIdx EQU $A6 ;Index into inst len table +Filler EQU $A7 ;byte used to fill reserved storage +SavLstF EQU $A7 ;Used to save List flags temporarily +GMCIdx EQU $A7 ;Used to index GMC buf during code generation +RadixCh EQU $A7 ;Char used to check radix during str2bin conversion +Jump EQU $A7 ;Gap btwn 2 elements +SavFByt EQU $A7 ;Save symbol's flag byte temporarily +BitsDig EQU $A8 ;# of bits/digit-use into bin/octal/hex conversion +LabelF EQU $A9 ;Instruction has a label field +RecCnt EQU $A9 ;Use to count the # of recs in aux array +NumRecs EQU $A9 ;Renamed above label +SubTIdx EQU $AA ;offset into a sub-table of opcode table +ZAB EQU $AB +ErrorF EQU $AC ;curr line is flagged as incorrect +ErrTIdx EQU $AC ;Used to index ErrInfo Table +msbF EQU $AD +J.TH EQU $AB ;offset/ptr to the j-th/i-th +I.TH EQU $AD ; elements of the aux array +EndianF EQU $AE ;little/big endian flag +Accum EQU $AF ;Main accumulator ($AF-$B0) +NewPC EQU $AF ;Used temporarily by DS directive +SymPJ EQU $AF +Ret816F EQU $B1 ;-1=16-bits,0-low 8-bits,1-high 8-bits +SymPI EQU $B1 +RepChar EQU $B2 ;char used by REP directive +SymNbr EQU $B3 ;# of idfers declared as EXTRN/ENTRY (DEF/RE) +SymLen EQU $B3 ;len of symbolic name +SavSTS EQU $B3 ;Save start of symbol table +GblAbsF EQU $B4 ;Global Abs addr flag $00-ZDEF/ZREF; $01-DEF/REF +DummyF EQU $B5 ;dummy section flag +SavPC EQU $B6 +SavObjPC EQU $B8 +CodeImgLen EQU $B8 +CondAsmF EQU $BA ;Conditional Assembly Flag $00,$40,$80 +TabTIdx EQU $BB ;Index into Editor's tab table +SymFByte EQU $BC ;Symbol's curr flag byte +RelCodeF EQU $BD +DskSrcF EQU $BE ;-1=Disk src file, 0-mem src file +GenF EQU $BF ;N=1-suppress code gen,V=1-disk,V=0-mem +ObjDBIdx EQU $C0 ;Gen obj code buf index, double as # of bytes to write +IDskSrcF EQU $C1 ;msb=on - stmts fr INCLUDE file +MacroF EQU $C2 ;0=not using macros,$40,$06,$04,$80-macro file opened +MParmCnt EQU $C3 +MacArg EQU $C4 ;macro argument 0-9 +ZC5 EQU $C5 ;not used +FCTIndex EQU $C6 ;0,2,4,6,8 - Index of File Control tables (FCT) +PathP EQU $C7 ;Pathname ptr +SrcPathP EQU $C9 ;Curr src filename ptr +RelExprF EQU $CB ;If non-zero, rel addr expr/sub-expr +SavSTE EQU $CC ;temp save for hibyte of EO symbol table +SavSEF EQU $CC ;prev subexpr's RelExprF +NewF EQU $CD ;$80-new file is being assembled +Msg2P EQU $CE ;message ptr +Lower8 EQU $CE ;Low 8 bits of 16-bit val +ParmBIdx EQU $CE ;Index into parm string passed by EI +OnOffSW EQU $CE ;$80=ON,$00=FF +SrcP3 EQU $CE ;Ptr to partial src line-1 +ZCE EQU $CE +ZCF EQU $CF +SymNodeP EQU $CE ;Use in printing of symbol table +TotCnt EQU $CF ;total # of bytes generated +RLDEnd EQU $D0 ;Points to end of Rel dict table (build downwards) +ZD2 EQU $D2 ;Not used +SavGenF EQU $D4 ;Save GenF when DSECT is declared +SBufP EQU $D5 ;ptr to SBuf/IBuf data buf +MsgP EQU $D5 ;Message ptr +HashIdx EQU $D7 +PrvSymP EQU $D8 ;Ptr to previous symbol's node +NxtSymP EQU $DA ;Ptr to next symbol's node +NumCycles EQU $DD ;instruction's # of cycles +NbrWarns EQU $DE ;2 bytes used +* +* These flags are for the LST directive +* $00-OFF, non-zero=ON +* +LstFlags EQU $E0 +LstCyc EQU $E0 ;cycle times (OFF) +LstUnAsm EQU $E1 ;unassembled source (ON) +LstExpMac EQU $E2 ;expansion of macro lines (ON) +LstWarns EQU $E3 ;warnings (ON) +LstGCode EQU $E4 ;generate obj code (OFF) +LstASym EQU $E5 ;Alphabetic symbol (ON) +LstVSym EQU $E6 ;Value-ordered Symbol (OFF) +Lst6Cols EQU $E7 ;6-col symbol dump (OFF) +ZE8 EQU $E8 ;Was init but not used +SW16F EQU $E9 +ZPSaveY EQU $EA +RndF EQU $EC ;$80-use random data, $00-use filler byte +ErrNbr4 EQU $EB ;Err # x 4=index +* +DecimalS EQU $ED ;'0000' 4-byte ASCII str ($ED-$F0) +ZPRetAdr EQU $EF +MacPNLen EQU $F1 ;Len byte of Maclib prefix/Macro file PathName +*================================================= \ No newline at end of file diff --git a/EDASM.SRC/ASM/EXTERNALS.S b/EDASM.SRC/ASM/EXTERNALS.S new file mode 100644 index 0000000..5f900d1 --- /dev/null +++ b/EDASM.SRC/ASM/EXTERNALS.S @@ -0,0 +1,24 @@ +Name : EXTERNALS.S +End of file : 884 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + +************************************************** +* EXTERN labels used by Assembler +* The 1024-byte buffers are used by ProDOS8 for I/O +* +X0800 EQU $0800 +X6E00 EQU $6E00 ;1024-byte buf for MACRO defn file if List to File +MacExpBuf EQU $7200 ;$7200-$727F Use to expand macro lines +MacStrBuf EQU $7280 ;$7280-$72FF Use to store string parms passed +OLDataB EQU $7300 ;Online data buf +LstDBuf EQU $7300 ;256-bytes circular data buf for LST file +X7400 EQU $7400 ;1024-bytes buf for LST/MACRO file +ObjDataB EQU $BD00 ;128-byte data buf for obj code +AsmParmB EQU $BD80 ;128-byte buf use to pass by editor to pass parm to asmbler +XA100 EQU $A100 ;1024-bytes buf for OBJ file +XA500 EQU $A500 ;1024-bytes buf for SRC file +*XA900 EQU $A900 ;1024-bytes buf for INCLUDE file +* +HeaderT EQU $BC00 ;Table of ptrs to 1st node of singly linked lists +*================================================= \ No newline at end of file diff --git a/EDASM.SRC/BUGBYTER/BB1.S b/EDASM.SRC/BUGBYTER/BB1.S new file mode 100644 index 0000000..4268b19 --- /dev/null +++ b/EDASM.SRC/BUGBYTER/BB1.S @@ -0,0 +1,782 @@ +Name : BB1.S +End of file : 14,078 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + + ORG $0800 + MSB ON +; BB (ProDOS version) was assembled @ $0800 +; but may be run from any location starting +; from $0800 as long as there is enough memory +; +BBSTART EQU * + SEC + BCS SkipSWA +; +XUNDSW DB $80 ;Allow BB to call ProDOS +Btn0SW DB $00 ;Use Paddle button 0 for trace/suspend (ON=$80) +PDL0SW DB $80 ;Use Paddle 0 for trace rate +KBDPOLL DB $00 ;Tr/SS keyboard polling (msb on=OFF) +SNDSW DB $80 ;$80-ON +CYCLEC DW $0000 ;Cycle Counter +BARTC DW $FFFF ;Beginning & Ending Addresses +EARTC DW $FFFF ; of Real Time Code +; +IBuff EQU * ;$080E-$088D (128 chars) +SkipSWA LDA #iRTS + STA Z2F + JSR Z2F +RetHere EQU * + TSX + LDY STACK,X ;Hi + DEX + LDA STACK,X + SBC #>RetHere-1 + STA Z44 + BCS L0824 + DEY +L0824 STY Z44+1 ;($44,$45)=load addr +; + CLC + ADC #>L08CF + STA MONPC ;bugbyter's main entry point + BCC L082E + INY +L082E STY MONPC+1 +; + CLC + ADC #>BBDATA-L08CF ;#$46 + STA Z46 ;Point to end of bugbyter's program code + TYA + ADC # 000x xxxx + CMP #%00011001 ;Checking for opcodes $19,$39,$59 etc + BEQ L0874 + AND #$0F ;0000 xxxx + CMP #%00001100 ;This should cover ($XC,$XD,$XE) + BCS L0874 + AND #%00001101 ;0000 xx0x + CMP #%00001000 ;$X8 opcodes (1-byte) + BEQ L0890 ;NB: (Y)=0 + TXA ;Restore opcode + BEQ L0890 ;BRK instruction + CMP #iJSR + BEQ L0874 + AND #%10011111 ;x00x xxxx (Y)=0 + BNE L088F ;Assume all are 2-byte instructions + BEQ L0890 ;($40,$60) always +; +; Handle 3-byte 65C02 instructions +; We only need to consider references to memory +; locations btwn BBSTART-BBDATA ($0800-$2150) +; +L0874 INY ;Skip opcode & low byte of abs addr + INY + LDA (MONPC),Y ;Abs addr's hi byte + CMP #CMDTBL-1 + STA MONPC + LDA Z44+1 + ADC #MONZ ;RESET vector + STA SOFTEV + LDA #BBStack ;BB's stack usage ($100-$11F) + TXS + JSR SwapZP + JSR DRegHdr ;Show registers + JSR L0ADD ;Show all SDs +; +; Display copyright notice +; +DCPYRCMD LDX #$26 +L0910 LDA COPYRK,X + STA SLIN23+1,X + DEX + BPL L0910 + JMP BBGetLn +;================================================= +; BB's ctrl-Y Handler +; +WrmStrt JSR SwapZP +L091F JSR DRegHdr +L0922 JSR L0ADD ;Show all SDs +XDelLin JMP DelLin +;================================================= +; Execute cmd +; +XCmd LDX INPUTLEN ;null entry? + BEQ XDelLin + BIT MemPgDSW ;Mem Page being displayed? + BMI ParseCmd ;Yes + JSR HndlCmd + BEQ ParseCmd ;No hit +; + STX Z40 ;Entry # + TXA + ASL + TAX + LDA CMDTBL+1,X + PHA + LDA CMDTBL,X + PHA + RTS +; +EqSign INY + INY + JSR Bin2Dec + JMP L0982 +; +; Convert dec rep to hex rep +; +PlusDecS LDA #$00 + BEQ L0953 ;always +NegDecS LDA #$80 +L0953 STA Z40 + INY + JSR Dec2Bin ;First convert dec str to its binary value + LDA IBuff,Y + CMP #'=' + BNE L09D8 ;Input err + INY + INY + LDA #'$' + STA (ScrLoc),Y + INY + BIT Z40 + BPL DspHexS ;+ve dec->hex +; + SEC + LDA #0 ;-ve dec->hex + SBC Z3E + STA Z3E + LDA #0 + SBC Z3E+1 + STA Z3E+1 +; +DspHexS LDA Z3E+1 ;Now convert binary value + JSR PUTHEX ; to its hex rep & + LDA Z3E + JSR PUTHEX ; show on cmdln SD +; +L0982 JSR CPY2IB ;Copy scrn ln to input buffer + JMP BOCL +; +ParseCmd LDA #>SLIN23 + STA ScrLoc + LDA # Bin value -> HexS + CMP #'$' + BNE L09A2 + INY ;Skip over $ +; +L09A2 JSR Hex2Bin ;Do we have a hexdec str? + BCS InputErr ;No + LDA IBuff,Y + CMP #'=' + BEQ EqSign ;HexS -> DecS +; + CMP #':' ;Addr: + BEQ L0A16 ;Mem Page Display or assignment +; + BIT MemPgDSW + BMI InputErr + JSR ToUpper +; +; Debugging modes viz TRACE, SINGLE STEP, EXECUTE +; AddrT, AddrS, AddrG, AddrJ +; + CMP #'T' + BNE L09C1 + JMP TKEY1 +; +L09C1 CMP #'S' + BNE L09C8 + JMP SKEY1 +; +L09C8 CMP #'G' + BNE L09CF + JMP GKEY1 +; +L09CF CMP #'J' + BNE L09D6 + JMP JKEY1 +; AddrL +L09D6 CMP #'L' ;DisAssembly +L09D8 BNE InputErr + JMP LKEY1 +; +InputErr JSR BELL2 + JMP BOCL +;================================================= +; Parse the cmd line for keywords +; Ret Z=1 no hit, Z=0 hit +; +HndlCmd LDX #$00 + LDA CMDTBLP + STA Z40PTR ;points @ table of COMMAND keywords + LDA CMDTBLP+1 + STA Z40PTR+1 +; +L09EF LDY #0 + LDA (Z40PTR),Y ;Get entry len + BEQ L0A15 ;end of table + STA Z42 +L09F7 INY + CPY Z42 + BEQ L0A14 ;got a hit + LDA IBuff-1,Y + JSR ToUpper + CMP (Z40PTR),Y + BEQ L09F7 ;keep searching +; + INX ;cmd # (to be used later as an index) + CLC + LDA Z40 ;bump to next entry + ADC Z42 + STA Z40 + BCC L09EF + INC Z41 + BCS L09EF ;always +L0A14 DEY ;Z=0 to flag a hit +L0A15 RTS +; +; An assignment or memory page display +; +L0A16 INY + STY ALTYSV + CPY INPUTLEN + BEQ L0A8F ;-> display mem page +; +; Altering mem contents +; + JSR SVMONPC + LDA Z3E + STA MONPC + STA IMM1+1 + LDA Z3E+1 + STA MONPC+1 + STA IMM1+2 +; + JSR DoAsm ;Try to assemble inst + JSR RSTMONPC + LDY ALTYSV + DEY +L0A3A INY +L0A3B CPY INPUTLEN ;End of input? + BEQ L0AB8 ;Yes, chk if a mem page display is needed +; + LDA IBuff,Y + CMP #SPACE + BEQ L0A3A ;Skip blanks +; +; Memory cell assignment. Altering the contents of mem +; Including 6502 instr & operands +; + CMP #'"' + BEQ L0A5C + CMP #''' + BEQ L0A60 ;-> string assignment +; + JSR Hex2Bin + BCS InputErr + LDA Z3E + JSR L0AC3 ;Assign to mem + JMP L0A3B ;Loop back for more +; +; String assignment +; +L0A5C LDA #$00 + BEQ L0A62 ;always +L0A60 LDA #$80 +L0A62 STA HIGHB ;string type +L0A65 INY + CPY INPUTLEN + BEQ L0AB8 + LDA IBuff,Y + CMP #'/' ;Accepts next char verbatim + BNE L0A7E + INY + CPY INPUTLEN + BEQ L0AB8 + LDA IBuff,Y ;Get ASCII char + JMP L0A86 +; +L0A7E CMP #'"' ;Check for closing quotes + BEQ L0A3A + CMP #''' + BEQ L0A3A +; +L0A86 EOR HIGHB + JSR L0AC3 ;Assign to mem + JMP L0A65 ;Next char +; +; Do a mem page display +; +L0A8F LDA Z3E ;Starting addr + STA MBStrtAdr + LDA Z3E+1 + STA MBStrtAdr+1 + BIT MemPgDSW + BMI L0AA1 + JSR ClrScrn ;Blank entire scrn if necessary +; +L0AA1 JSR L1D23 ;Display mem page + LDA #$80 + STA MemPgDSW + LDA IMM9+1 + STA IMM1+1 + LDA IMM9+2 + STA IMM1+2 + JMP L0922 +; +L0AB8 BIT MemPgDSW + BPL L0AC0 + JSR L1D23 +; +L0AC0 JMP L0922 +;================================================= +; Change contents of mem cell +; +L0AC3 PHA + STY ALTYSV + JSR SwapZP + PLA +IMM1 STA $FFFF ;curr Mem loc + JSR SwapZP + LDY ALTYSV + INC IMM1+1 + BNE L0ADC + INC IMM1+2 +L0ADC RTS +;================================================= +; Update BB SDs +; +L0ADD BIT MasDSW + BPL L0ADC + BIT MemPgDSW + BMI L0ADC +; + JSR DBBREGS ;Show (regs) + JSR DMONPC ;Show PC + JSR DREGS + JSR L14C3 ;Show Stack SD + JSR L151A ;Show MC SD + JMP L1719 ;Show BP SD +;================================================= +; ($0AF9) BB Command Level +; +BBGetLn JSR CLRIB + LDY #1 + STY Z40 + LDX #$00 + STX Z41 + STX Z42 + STX INSFLAG + BEQ L0B36 ;always +; +; This rtn allows user to type up to 128 chars using the +; 39-char CmdLn SD. We may think of this SD as a 39-char +; wide window into the IBuff which can store up to 128 chars +; +; (Z40) - cursor posn within cmdln SD (1-39) +; (Z41) - IBuff index of char at cursor posn +; (Z42) - IBuff index of char at posn 1 of cmdln SD +; Posn 0 of SD is the colon prompt +; +DelLin JSR CLRIB +BOCL LDX #0 + STX Z42 + LDY #1 +CMDCLP CLC +InsChar ROR INSFLAG ;bit7=0 => overwrite mode +L0B18 STY Z40 ;cursor posn + STX Z41 ;index of char under cursor +; + LDY #1 ;Skip past colon + LDX Z42 ;Start refresh of cmdln SD fr here +L0B20 LDA IBuff,X + CMP #SPACE + BCS L0B29 + AND #$3F ;Convert to inverse char (00-3F) +L0B29 STA SLIN23,Y + INX + INY + CPY #40 ;Only 1-39 chars are displayed + BNE L0B20 ;next char +; + LDY Z40 ;curr cursor posn + LDX Z41 ;index into IBuff +L0B36 LDA SLIN23,Y + AND #$3F ;$00-$3F + ORA #$40 ;$40-$7F + STA SLIN23,Y ;Flash the char + LDA #':' ;Put a colon in front + STA SLIN23 ; of cmdln SD +; +WAITK1 LDA KBD + BPL WAITK1 +; + STA KBDSTROBE + CMP #CTRLX + BEQ DelLin ;Clear every thing and re-start input + CMP #CTRLB + BEQ BOCL + CMP #TAB + BEQ InsChar ;Proceed to set INSERT flag (NB. C=1) + CMP #ESC + BNE L0B6C + CPX #0 ;Was it the 1st char? + BNE BOCL ;No, move cursor to BO input line +; + LSR MemPgDSW ;msb=0 + BIT MemPgDSW ;Was MEM PAGE SD displayed? + BVC L0B36 ;No, get 1st char (Y=1, X=0) + JMP L091F +; +L0B6C CMP #SPACE ;Was space bar pressed? + BNE L0B77 + CPX #0 ;Was 1st char a space? + BNE L0B77 ;char is a space but it's not 1st char + JMP DNxtMem ;Yes +; +L0B77 CMP #CURSL ;BS key + BEQ ML1CH + CMP #DELCH ;Delete key + BEQ ML1CH +; + CMP #CURSR ;FS + BEQ MR1CH + CMP #CTRLD + BEQ DELCHR + CMP #CTRLC + BEQ ASISST + CMP #CTRLN + BEQ EOCL + CMP #CR + BEQ L0BFA ;Accept input +; + CMP #SPACE ;If ctrl-char, + BCC L0B36 ; ignore input char + BIT INSFLAG ;Insert mode? + BPL Add2IB ;No, Overwrite mode + JSR MVCHARS ;Move chars forward +; +Add2IB STA IBuff,X ;Replace old char w/new one +L0BA2 CPX #127 ;maxlen? + BNE L0BAC + JSR BELL2 ;Too many chars + JMP CMDCLP +; +L0BAC INX + CPY #39 ;Is it at the edge of SD? + BNE L0BB4 ;No, proceed to incr (Y) + INC Z42 + DB $24 ;Y=39 on fall thru +L0BB4 INY + JMP L0B18 +; +MR1CH CLC + ROR INSFLAG ;Set overwrite mode + BPL L0BA2 ;always +; +ML1CH DEX + BPL L0BC4 + JMP BOCL ;(X) was 0 +L0BC4 CPY #1 ;Is cursor @ BO SD? + BNE L0BCB ;No, just decr (Y) + DEC Z42 ;Yes + DB $24 ;NB. On fall thru (Y) = 1 +L0BCB DEY + JMP CMDCLP +; +; Enter next key verbatim +; +ASISST LDA #$20 ;ASCII space + STA SLIN23,Y +WAITK2 LDA KBD + BPL WAITK2 + STA KBDSTROBE ;Clear key latch + STA IBuff,X ;Store key as it is + BMI MR1CH ;always +; +DELCHR STX Z40 ;Save temporarily +L0BE3 CPX #127 ;maxlen + BEQ L0BF0 + LDA IBuff+1,X ;Shift chars left + STA IBuff,X ; within input buffer + INX + BNE L0BE3 ;Always since (X) < 128 +L0BF0 LDA #SPACE ;Replace with space + STA IBuff,X + LDX Z40 ;Restore + JMP CMDCLP +; +; CR - Accept user input +; +L0BFA LDA #SPACE + STX INPUTLEN +L0BFF STA SLIN23,Y ;Clear rest of scrn line + INY + CPY #40 + BNE L0BFF +; + JSR ClrIBZ ;Clear rest of buffer + JMP XCmd +; +EOCL LDX #127 +L0C0F LDA IBuff,X ;Trailing spaces + CMP #SPACE + BNE L0C19 + DEX + BPL L0C0F +L0C19 INX + BPL L0C1D + DEX ;(X) was 128, so set to 127 +; +L0C1D TXA + TAY ;(Y)=(X) + LDA #0 + CPX #39 + BCC L0C2A +; + TXA + LDY #38 ;Y becomes 39 on looping back + SBC #38 +; +L0C2A STA Z42 ;index of char @ posn 1 of SD + INY + JMP CMDCLP +;================================================= +; ($0C30) Fill the input buffer with 128 blanks +; +CLRIB LDX #0 + LDA #SPACE +ClrIBZ STA IBuff,X + INX + BPL ClrIBZ + RTS +;================================================= +; Move chars forward in IBuff to make space +; for char to be inserted +; +MVCHARS PHA ;save char to be inserted + STX Z40 ;curr index + LDX #127 +L0C40 CPX Z40 ;finish? + BEQ L0C4D ;done + LDA IBuff-1,X + STA IBuff,X + DEX + BPL L0C40 +L0C4D PLA + LDX Z40 + RTS +;================================================= +; ($0C51) Display next mem location on cmdln SD +; +DNxtMem LDA #>SLIN23 + STA STOSCR+1 + LDA # C=0 + RTS +;================================================= +; ($0C91) Convert a ASCII hex digit into its binary +; value & combine it into with the partial result +; ($3E,$3F) - partial result +; C=1 - (A) is not an ASC hex char +; (A) & (X) - changed +; +Add2Bin EOR #'0' ;Change numeric char into its binary value + CMP #10 + BCC L0C9F ;Was ASCII '0'-'9';now $00-$09 + ADC #$88 ;Adjust + ORA #$20 + CMP #$FA ;$FA-$FF (ASCII 'A'-'F') + BCC L0CB3 ;On fall thru (A)=$0A-$0F +; +L0C9F AND #$0F ;Mask off upper nybble + STA Z44 ;$00-$0F + LDX #4 + LDA Z3E ;Shift to accommodate +L0CA7 ASL ; the incoming value + ROL Z3E+1 + DEX + BNE L0CA7 + ORA Z44 ;Combine it + STA Z3E +L0CB1 CLC + DB $24 +L0CB3 SEC ;Invalid numeral + RTS +;================================================= +; ($0CB5) Display the topmost line of column +; and the break point headers +; +DRegHdr BIT MasDSW + BPL L0CE8 + JSR ClrScrn ;Clear entire screen if necessary + LDX #'C' ;cycle + STX SLIN00 + DEX + STX SLIN00+8 ;"B" - break point reg + LDA #'R' ;rate + STA SLIN00+5 +; +L0CCB LDX L2105 ;Set (ScrLoc) + JSR VTABX +; + LDY #39 +L0CD3 LDA REGSK-11,Y + STA SLIN00,Y + LDA BPHDR-11,Y ;BP header + STA (ScrLoc),Y + DEY + CPY #10 + BNE L0CD3 +; + LDA #$00 + STA MemPgDSW +L0CE8 RTS \ No newline at end of file diff --git a/EDASM.SRC/BUGBYTER/BB2.S b/EDASM.SRC/BUGBYTER/BB2.S new file mode 100644 index 0000000..5602473 --- /dev/null +++ b/EDASM.SRC/BUGBYTER/BB2.S @@ -0,0 +1,1590 @@ +Name : BB2.S +End of file : 27,417 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + +;================================================= +; Execute BI commands +; +DOTCMD JSR SwapZP + BIT TXTSET + BIT TXTPAGE1 + LDA #$00 ;Set to full text screen +; STA CH + DB $8D,$24,00 ;This should ensure +; STA WNDLFT + DB $8D,$20,00 ; the assembled copy +; STA WNDTOP + DB $8D,$22,00 ; is an exact image of + LDA #40 +; STA WNDWDTH ; the original program + DB $8D,$21,00 + LDA #24 +; STA WNDBTM + DB $8D,$23,00 + LDA #23 +; STA CV + DB $8D,$25,00 +; + LDA #>SLIN23 +; STA BASL + DB $8D,$28,00 + LDA # no-yet-to-be-executed inst + STX Z3E+1 ;1 -> 2 yet-to-be-executed inst displayed + JSR SVMONPC + LDA AdrModSW ;(Is this for the next-to-be-exec inst?) + PHA +; +L0EBE JSR PCADJ + STA MONPC + STY MONPC+1 + JSR INSDIS ;Get format & len of instr + INC Z3E + LDX Z3E + JSR VTABX + JSR ClrEOL + JSR INSTDSP ;Show disassembled inst + DEC Z3E+1 + BPL L0EBE ;next yet-to-be-executed-inst +; + PLA + STA AdrModSW + JSR RSTMONPC + JSR L1624 ;Copy INSTBE data to INSTSV area +; +L0EE3 BIT TrigSW + BPL L0EF2 + BIT BRKFLAG ;IN? + BMI L0F3C ;Yes + JSR L18B4 ;Chk if it's one of ours + BMI L0F3C ;No hit +; +; BB has encountered an inst located @ a BP addr +; +L0EF2 LDA #$80 + STA TrigSW + LDX BPHitM1 + INC BPCntL,X + BNE L0F02 + INC BPCntH,X +; +L0F02 LDA BPTrigL,X ;If trigger = count + CMP BPCntL,X + BNE L0F2C + LDA BPTrigH,X + CMP BPCntH,X + BNE L0F2C + INC BPBrkL,X ; incr BROKE cntr + BNE L0F1A + INC BPBrkH,X +; +; Stops program execution b4 executing the inst @ the BP addr. +; BB will highlight the row in the BP SD that corresponds to +; the breakpoint that was triggered +; +L0F1A LDA #$80 ;Flag we have to update BP SD + STA BPDSW + ASL ;(A)=0 + STA BPCntL,X ;Clears the count + STA BPCntH,X + JSR BELL2 + JMP L1060 ;Back to cmd level +; +L0F2C BIT MasDSW + BPL L0F34 + JSR L173A ;Update BP SD +; +L0F34 BIT ExecSW + BPL L0F3C + JMP L1058 +; +; During Trace mode, instead of using the keyboard, user can use +; Paddle Button 0 to control the tracing. To do this, user +; must set Btn0SW to $80 b4 entering trace mode. +; Ref pg 168 +; +L0F3C BIT Btn0SW ;Use Paddle Button 0 to suspend tracing? + BPL L0F46 ;No + BIT BUTN0 + BMI L0F3C ;Loop until paddle 0 is released +; +; NB. User's program will never receive any keystroke unless +; BB's keyboard polling is turned off. +; To turn off keyboard polling, set (KBDPOLL) to $80+ASCII char. +; BB will ignore all chars typed at keyboard except this special +; interrupt char which the user had specified. +; ref pg 167 +; +L0F46 BIT KBDPOLL ;Is polling off? + BPL L0F5B ;No, allow user's program to accept keystroke + LDA KBD ;Is there a keypress? + BPL L0F76 ;No + CMP KBDPOLL ;Yes, is it the interrupt char? + BNE L0F76 ;No + STA KBDSTROBE ;Yes, clear keyboard ready flag +; +ExitDbg JMP L1060 ;Stop SS/TR & transfer back to BB's cmd level +; +L0F5B BIT SSSW + BPL ChkKS +L0F60 LDA #$C0 ;Set values for noise generation + STA IMM2+1 + LDA #$02 + STA IMM3+1 +WAITK5 LDA KBD + BPL WAITK5 + CMP #SPACE + BNE ChkKS2 + STA KBDSTROBE +; +L0F76 LDA #$10 ;Set sound delay + STA IMM2+1 + STA IMM3+1 +L0F7E JMP L103D +; +; These keystrokes are checked during Single Step or Trace modes +; +ChkKS LDA KBD + BPL L0F7E +ChkKS2 STA KBDSTROBE + CMP #ESC ;Did user ask for a ret to cmdline? + BEQ ExitDbg ;Yes, exit debugging + CMP #SPACE ;Did user ask for a single step? + BEQ ExecSS ;yes + CMP #CR + BEQ L0FE2 + CMP #'1' ;Did user ask to display primary Apple screen? + BEQ DTxtPg1 + CMP #'2' ;Did user ask to display secondary Apple screen? + BEQ DTxtPg2 + JSR ToUpper + CMP #'T' ;Did user ask to display text screen? + BEQ DTxtScr +; + CMP #'L' ;Did user ask to display lores graphic screen? + BEQ DLoResGr + CMP #'H' ;Did user ask to display hires graphic screen? + BEQ DHiResGr + CMP #'F' ;Did user ask to display full screen graphics? + BEQ DFullGr + CMP #'M' ;Did user ask to display mixed text & graphics? + BEQ DMixGr +; + CMP #'Q' ;Did user ask to turn off the sound? + BEQ SNDOFF + CMP #'S' ;Did user ask to turn on the sound? + BEQ SNDON +; + CMP #'R' + BEQ Tr2RTS +; + CMP #'K' ;key board to adjust trace rate + BEQ UseKR + CMP #'P' + BEQ UsePdl0 ;game paddle to adjust trace rate +; + CMP #'C' ;Did user ask to clear cycle counter? + BEQ ClrCC + CMP #CURSR ;Did user ask to skip next instruction? + BNE SkipNxtI +; + STA SSSW + STA SW13 ;Flag "skip next inst"s + JSR DSSTEP ;Display "SINGLE STEP" + JMP L123B +; +Tr2RTS ROR RTSSW ;Trace until RTS + JSR DWAIRTS +; +; Do trace until BP encountered or end of program +; +L0FE2 JSR DTRACE + LSR SSSW ;Clear SS mode + BPL SkipNxtI ;always +; +ExecSS JSR DSSTEP + SEC + ROR SSSW + BMI SkipNxtI ;always +; +DTxtPg1 STA TXTPAGE1 + BEQ SkipNxtI +DTxtPg2 STA TXTPAGE2 + BEQ SkipNxtI ;always +; +DTxtScr STA TXTSET + BEQ SkipNxtI +DLoResGr STA LORES + STA TXTCLR + BEQ SkipNxtI +DHiResGr STA HIRES + STA TXTCLR + BEQ SkipNxtI +DFullGr STA MIXCLR + BEQ SkipNxtI +DMixGr STA MIXSET + BEQ SkipNxtI +; +SNDOFF LDA #$00 +SNDON STA SNDSW + BEQ SkipNxtI +; +ClrCC LDA #$00 + STA CYCLEC + STA CYCLEC+1 + JSR DBBREGS + BNE SkipNxtI ;always +; +; $80 use KBD rate, $00=game paddle to control rate +; +UsePdl0 LDA #$00 ;Use paddle +UseKR STA SW06 +; +; Skip next inst +; +SkipNxtI BIT SSSW ;Single Step? + BPL L103D ;No + JMP L0F60 +; +L103D BIT SNDSW ;Make some noise? + BPL L1058 ;No +IMM2 LDX #$C0 +IMM3 LDY #$02 + LDA SPKR +L1049 INX + BEQ L1058 ;->done + NOP + JMP L1050 +L1050 DEY + BEQ IMM3 + JMP L1056 +L1056 BNE L1049 ;always +; +L1058 BIT AdrModSW ;Is inst valid i.e. opcode defined? + BMI L1069 ;Yes + JMP L123B ;->??? +; +L1060 STA TXTSET ;Exit + STA TXTPAGE1 + JMP L0922 ;Update SDs & get next cmd +; +; NB. (A) may be a random value +; +L1069 LDX HSTAKP + LDY INSTBE ;Get opcode + BEQ L1060 ;BRK -> back to cmd level +; + CPY #iRTI + BEQ L10AB + CPY #iRTS + BEQ L10B2 + CPY #iJMP + BEQ L10D9 +; + LDA #$00 + CPY #$6C ;JMP (ABSOLUTE) + BEQ L10DA + LDA HXREG + CPY #$7C ;JMP (ABSOLUTE,X) - new addressing mode + BEQ L10DA +; + CPY #$BA ;TSX + BEQ L1104 + CPY #$9A ;TXS + BEQ L110B +; + CPY #iJSR + BEQ L1110 +; + TYA + AND #%01011111 + CMP #$5A ;PHY,PLY,PHX,PLX? + BNE L109E ;No + JMP L1194 +; +L109E TYA + AND #%10011111 + CMP #$08 ;PHP,PLP,PHA,PLA + BEQ L10A8 + JMP L11F0 ;BR insts +L10A8 JMP L11B2 +; RTI inst +L10AB CLC + INX + LDA STACK,X + STA HFLAGS +; RTS inst +L10B2 BIT RTSSW ;Wait for RTS? + BPL L10C1 ;No + CLC + ROR RTSSW ;Clear + JSR L1F98 ;Remove "AWAITING RTS" msg + JMP ExecSS +; +L10C1 INX + LDA STACK,X ;Get the ret addr + STA MONPC + INX + LDA STACK,X + STA MONPC+1 + STX HSTAKP + PHP + JSR L14C3 ;Update Stack SD + PLP + BCC L1101 ;Was RTI inst + JMP L123B +; +; JMP instructions handler +; If inst is JMP abs, (A) is irrelevant +; +L10D9 CLC ;JMP abs +L10DA TAY ;JMP (abs) or JMP (abs,X) + LDA INSTBE+1 + LDX INSTBE+2 + STA MONPC + STX MONPC+1 + BCC L1101 ;JMP abs +; +; JMP indirect modes +; (Y)=0 if JMP (abs) +; (Y)=(HXREG) if JMP (abs,X) +; + JSR SVMONPC + TYA + PHA + JSR SwapZP + PLA + CLC + ADC SVxZ3A + LDX SVxZ3A+1 + BCC L10FA + INX +; +L10FA JSR L13DD + STA MONPC + STX MONPC+1 +L1101 JMP L1242 +; +L1104 LDA HSTAKP ;TSX + STA HXREG + JMP L123B +; +L110B LDX HXREG ;TXS + JMP L11D8 +; +; NB. We are still in simulation mode +; This part of the code allows user to +; execute ProDOS calls in real time +; +L1110 LDY INSTBE+2 ;JSR + LDA INSTBE+1 + BNE L1148 ;Addr is not @ mem page bdry + BIT XUNDSW ;Allow execution of ProDOS calls? + BPL L1148 :No + CPY #$BF ;Is ProDOS Global Page + BNE L1148 ;No +; + LDY #5 +L1123 LDA (MONPC),Y + STA L113F,Y ;Self-modifying code + DEY + CPY #2 + BNE L1123 +; + LDA MONPC + CLC + ADC #3 + STA MONPC + BCC L1138 + INC MONPC+1 +; +L1138 TXS + JSR SwapZP + JSR RstRegs +L113F JSR PRODOS8 + DB 0 + DW 0 + JMP L1172 +; +; This part of the BB's code allows the user to execute code in +; real time while in Simulation mode. It checks if the instr is +; within the specified Real Time Code region +; +L1148 CPY BARTC+1 ;Is (Y,A) btwn (BARTC) + BCC L117B + BNE L1162 + CMP BARTC + BCC L117B +; + CPY EARTC+1 ; and (EARTC)? + BCC L1162 + BNE L117B + CMP EARTC + BCC L1162 ;Yes + BNE L117B +; +; Execute code in real time +; +L1162 STY SVxZ3A+1 ;Set up the JMP addr + STA SVxZ3A + TXS + JSR SwapZP + JSR RstRegs + JSR GoFullSpd ;xfer control to code +; +L1172 JSR SavRegs + LDX #>BBStack ;Reset BB's stack area $100-$1FF + TXS + JMP L1238 +; +; Simulation mode +; +L117B CLC + JSR PCADJ2 ;(Y,A)-effective addr + LDX HSTAKP + PHA + TYA + STA STACK,X ;Save (Y) and (A) here + DEX + PLA + STA STACK,X + DEX + STX HSTAKP + JSR L14C3 ;Update Stack SD + JMP L10D9 +; +; PHY,PLY,PHX,PLX +; +L1194 TYA + ASL + AND #%01000000 + BNE L11A4 + BCC L11A0 + LDA HXREG ;PHX + BCS L11BF ;always +; +L11A0 LDA HYREG ;PHY + BCC L11BF +; +L11A4 INX + LDA STACK,X + BCC L11AE + STA HXREG ;PLX + BCS L11CE ;always +L11AE STA HYREG ;PLY + BCC L11CE ;always +; +; PHP,PLP,PHA,PLA +; +L11B2 TYA + ASL + ASL + BMI L11C6 ;PLP/PLA + BCC L11BD ;PHP + LDA HACCUM ;PHA + BCS L11BF ;always +; +L11BD LDA HFLAGS +L11BF STA STACK,X + DEX + JMP L11D8 ;-> adjust SP +; +L11C6 INX + LDA STACK,X + BCC L11D6 ;PLP + STA HACCUM ;PLA +; +L11CE TAY + LDA HFLAGS + PHA + PLP + TYA + PHP + PLA +; +L11D6 STA HFLAGS +L11D8 STX HSTAKP :NB. Must adjust SP + JSR L14C3 ;Update stack SD + JMP L123B +;================================================= +; (INSTLEN)=0-1 byte, 1-2 bytes, 2-3 bytes +; Branch inst should make use of PCADJ3 entry +; with displacement in (A) +; Ret +; (Y,A)-effective addr +; +PCADJ SEC +PCADJ2 LDA INSTLEN ;length +PCADJ3 LDY MONPC+1 + TAX ;Test displacement sign + BPL PCADJ4 ; (for relative branch) + DEY ;Extend -ve by decrementing MONPC+1 +; +PCADJ4 ADC MONPC + BCC L11EF + INY +L11EF RTS +; +; Check if the inst in Y-reg is a branch opcode +; There are 9 rel branch insts whose opcodes are +; $10,$30,$50,$70,$90,$B0,$D0,$F0 and $80 +; +L11F0 CPY #$80 ;If BRA, + BNE L11F6 + LDA #$10 ; use $10 +L11F6 AND #$1F ;If relative branch, then + EOR #$14 ; change displacement .. + CMP #$04 + BNE L1201 ;-> Not a branch inst + STA INSTBE+1 ; ..to $04 @ this location +; +L1201 JSR SwapZP + JSR RstRegs +; +; Next-Instruction-To-Be-Executed +; +INSTBE NOP ;Opcode + NOP ;Lobyte + NOP ;HiByte + JMP L1230 +; +; Relative instructions that actually branch comes here +; + CLD + JSR SwapZP + JSR PCADJ + STA MONPC + STY MONPC+1 +; + CLC + LDA INSTSV+1 ;displacement of rel insts + JSR PCADJ3 + STA MONPC + LDX #3 ;3 cycles for successful brch + CPY MONPC+1 + BEQ L1228 + INX +; +L1228 STX NumCycles + STY MONPC+1 ;Addr of next inst + JMP L1242 +; +; Instructions that do not involve transfer of +; control (include those relative insts that +; did not branch) +; +L1230 JSR SavRegs + LDA #2 ;This is the default + STA NumCycles +; +L1238 JSR SwapZP +; +L123B JSR PCADJ + STA MONPC + STY MONPC+1 ;Addr of next inst +; +; Common code for all instructions +; +L1242 BIT MasDSW ;Update Master Display? + BPL L128B ;No +; + LDX CDBar ;Next-to-be-executed + JSR VTABX + BIT SW13 ;Was inst skipped? + BPL L125A +; + JSR DSKIP ;Yes + LSR SW13 ;clear msb + BPL L1269 ;Always +; +L125A JSR DOptions + JSR InvLine + JSR DREGS + JSR L151A ;Update MC SD + JSR DBBREGS +; +L1269 BIT SSSW ;Single Step mode? + BMI L1288 ;Yes +; + LDY KBDRate ;Trace mode + BIT SW06 ;Are we using the KB rate? + BMI L1280 ;Yes + BIT PDL0SW ;Use Paddle 0? + BPL L1280 +; + LDX #0 ;Yes + JSR PREAD2 ;Get a reading fr paddle 0 +L1280 STY RATEC + INY + TYA + JSR WAIT2 +; +L1288 JSR ScrollUp +L128B BIT ExecSW ;Executing in full speed? + BMI L1293 + JMP L0E49 ;No, continue with SS/TR mode +; +L1293 JSR SVMONPC + JMP L0DDB +;================================================= +; ($1299) Display relevant info on the right side of inst +; +DOptions LDY #30 + LDX L2100 ;Curr display option + LDA OPTSK,X ;Show Letter + STA (ScrLoc),Y + LDA #':' + INY + STA (ScrLoc),Y + CPX #5 + BCS L12B2 ;O=E/O=B + INY + LDA CPURegs,X ;Get the register's curr value and display + JMP DBINSTR ; its contents as a string of 0's and 1' +; +L12B2 BNE L12D4 ;-> O=E +; +; Display machine code in hex +; +L12B4 LDX #-1 + LDY #32 ;offset in scrn line +L12B8 INX + LDA INSTSV,X + JSR PUTHEX + INY + CPX INSTLEN + BNE L12B8 + RTS +; +; Branch insts +; +L12C6 LDA INSTSV+1 ;Print the displacement + LDY #34 + JSR PUTHEX + LDY NumCycles ;# of cycles + JMP L149F +; +; Compute effective addrs/rel branches +; & instruction cycles - pg 160, 208 +; +L12D4 LDY INSTBE+1 + LDX INSTBE+2 + LDA INSTBE ;Get opcode + STA Z40 ;Save here for later +; +; The following instructons are handled +; individually because their bit patterns +; do not conform to the norm +; + CMP #$80 + BEQ L12C6 ;-> BRA + CMP #$14 + BEQ L1329 ;-> TRB zp + CMP #$BC + BEQ L1327 ;-> LDY abs,X + CMP #$3C + BEQ L1327 ;-> BIT abs,X + CMP #$7C + BNE L12F6 + JMP L13B7 ;-> JMP (abs,X) +L12F6 CMP #$6C + BNE L12FD + JMP L13CD ;-> JMP (abs) +; +L12FD AND #%00011111 ;abcd efgh + STA Z41 ;000d efgh + CMP #$10 + BEQ L12C6 ;Branch inst + CMP #$19 + BEQ L135F ;abs,Y inst +; + CMP #$14 ;inst involving zp,X and zp,Y + BEQ L132C ; & the special case TRB zp + CMP #$15 + BEQ L132C + CMP #$16 + BEQ L132C +; + CMP #$1D ;abs,X inst + BEQ L1352 +; + CMP #$01 ;(zp,X) inst - indirect + BEQ L138E + CMP #$11 ;(zp),Y inst + BEQ L1399 + CMP #$12 ;(zp) inst + BEQ L1386 + CMP #$1E ;abs,X inst +L1327 BEQ L1352 +L1329 JMP L142C ;Others +; +; Instructions involving zp,X zp,Y +; +L132C LDX #$00 + LDA Z40 ;Opcode + AND #%11011111 + CMP #$96 + BEQ L1349 ;LDX zp,Y & STX zp,Y +; + TYA ;addr lobyte + CLC + ADC HXREG + LDY #4 ;# of cycles + PHA + LDA Z41 ;000d efgh + CMP #$16 + BNE L1345 ;-> zp,X + LDY #6 ;# of cycles +L1345 PLA + JMP L13FB +; +; STX zp,Y/LDX zp,Y +; +L1349 TYA ;addr lobyte (zp loc) + CLC + ADC HYREG + LDY #4 ;# of cycles + JMP L13FB +; +; abs,X insts, LDX abs,Y inst +; BIT abs,X & LDY abs,X +; +L1352 LDA Z40 ;Get opcode + CMP #$BE + BEQ L135F ;-> LDX abs,Y +; +; abs,X insts +; + TYA + CLC + ADC HXREG + JMP L1363 +; +; abs,Y instructions +; +L135F TYA ;addr lo + CLC + ADC HYREG +L1363 BCC L1366 + INX +; +L1366 PHA ;Save addr lo-byte + LDA Z40 ;Get opcode + CMP #$BE + BEQ L137D ;-> LDX abs,Y + LDY #5 ;# of cycles + AND #$F0 + CMP #$90 + BEQ L1382 ;-> STA abs,X/STZ abs,X +; + LDY #7 ;# of cycles + LDA Z41 + CMP #$1E + BEQ L1382 ;->abs,X shifts insts +L137D LDY #4 ;# of cyles for + JSR L1425 ; other abs,X insts +L1382 PLA + JMP L13FB +; +; (zp) inst +; +L1386 TYA ;zp loc + JSR L140B + LDY #5 ;# of cycles + BNE L13FB ;Always +; +; (zp,X) +; +L138E TYA + CLC + ADC HXREG + JSR L140B + LDY #6 ;# of cycles + BNE L13FB ;always +; +; (zp),Y inst +; +L1399 TYA ;zp loc + JSR L140B ;(A,X) - ptr + STX INSTBE+2 + CLC + ADC HYREG + BCC L13A6 + INX +; +L13A6 PHA + LDY #6 ;# of cycles + LDA Z40 + CMP #$91 ;STA (zp),y + BEQ L13B3 + DEY ;Less 1 cycle + JSR L1425 ;Cross mem page bdry? +L13B3 PLA + JMP L13FB +; +; JMP (abs,X) +; +L13B7 JSR SwapZP + LDA INSTBE+1 + CLC + ADC HXREG + LDX INSTBE+2 + BCC L13C6 + INX +L13C6 JSR L13DD + LDY #6 ;# of cycles + BNE L13FB ;always +; +L13CD JSR SwapZP + LDA INSTBE+1 + LDX INSTBE+2 + JSR L13DD + LDY #5 ;# of cycles + BNE L13FB ;always +;================================================= +; Get pointer located in non-zp memory +; Entry +; (X,A)=addr +; Ret +; (A,X)=pointer +; +L13DD STA IMM4+1 + STX IMM4+2 + STX IMM5+2 + CLC + ADC #1 + STA IMM5+1 ;-> page brdy bug? +IMM4 LDA $FFFF + PHA +IMM5 LDA $FFFF + PHA + JSR SwapZP + PLA + TAX + PLA + RTS +;================================================= +; Print addr & # of cycles +; (Y)=# of cycles +; (A,X)=addr +; +L13FB STY Z43 ;# of cycles + LDY #32 + PHA + TXA + JSR PUTHEX + PLA + JSR PUTHEX + JMP L14A1 +;================================================= +; Get zp pointer +; Input +; (A)=zp location +; Output +; (A,X)=pointer stored @ zp loc +; +L140B PHA + JSR SwapZP + PLA + TAX + STX IMM10+1 + INX + STX IMM11+1 +; +IMM10 LDA $00 ;zpage locn + PHA +IMM11 LDA $00 + PHA ;hi + JSR SwapZP + PLA + TAX + PLA + RTS +;================================================= +; 1 more cycle if mem page boundary is crossed +; +L1425 CPX INSTBE+2 + BEQ L142B + INY +L142B RTS +;================================================= +; Determine # of cycles for other inst +; Need to check all 65C02 opcodes are included +; +L142C LDY #5 ;Assume 5 cycles + LDA Z40 ;opcode abcd efgh + AND #%11100111 ;abc0 0fgh + CMP #$04 + BNE L143F + LDA Z40 ;$04,$0C,$14,$1C (TSB,TRB) + AND #%00001000 + BEQ L149F ;-> TSB/TRB dp + INY ;-> TSB/TRB abs + BNE L149F ;always +; +L143F LDY #3 ;3 cycle inst + LDA Z41 ;000d efgh + CMP #$04 + BEQ L149F ;$24,$44,$64,$84,$A4,$C4,$E4 + CMP #$05 + BEQ L149F ;$05,$25,$45,$65,$85,$A5,$C5,$E5 +; + LDA Z40 ;Get opcode + AND #%11011111 ;ab0d efgh + STA Z42 + CMP #$86 + BEQ L149F ;-> LDX/STX zp + LDA Z40 ;Get opcode + CMP #iJMP + BEQ L149F ;-> JMP abs + AND #%10111111 ;a0cd efgh + CMP #$08 + BEQ L149F ;-> $08,$48 + LDA Z40 ;Get opcode + ASL + CMP #$B4 + BEQ L149F ;-> PHY/PHX +; + INY ;4 cycle inst + CMP #$F4 + BEQ L149F ;->PLY/PLX +; + LDA Z41 ;000d efgh + CMP #$0D + BEQ L149F ;-> $0D,$2D,$4D,$6D,$8D,$AD,$CD,$ED + CMP #$0C + BEQ L149F ;-> $0C,$2C,$4C,$6C,$8C,$AC,$CC,$EC + LDA Z42 ;ab0d efgh + CMP #$8E + BEQ L149F ;-> $8E,$AE + LDA Z40 ;Get opcode + CMP #$9C + BEQ L149F ;-> STZ abs + AND #%10111111 ;a0cd efgh + CMP #$28 + BEQ L149F ;-> $28,$68 +; + INY ;5 cycle inst + LDA Z41 ;000d efgh + CMP #$06 ;$06,$26,$46,$66,$C6,$E6 + BEQ L149F +; + INY ;6 cycle inst + LDA Z40 ;Get opcode + AND #%10011111 + BEQ L149F ;-> $20,$40,$60 + LDA Z41 ;000d efgh + CMP #$0E + BEQ L149F ;-> $0E,$2E,$4E,$6E,$8E,$AE,$CE,$EE +; +; On fall thru, instructions not filtered out +; by the code above will be 2 cycles +; Print # of cycles +; + LDY #2 +L149F STY Z43 ;# of cycles +L14A1 LDY #37 + LDA #'(' + STA (ScrLoc),Y + INY + CLC + LDA Z43 + ADC #'0' + STA (ScrLoc),Y + INY + LDA #')' + STA (ScrLoc),Y +; + LDA Z43 + CLC + ADC CYCLEC + STA CYCLEC + BCC L14C2 + INC CYCLEC+1 +L14C2 RTS +;================================================= +; Show Stack SD +; +L14C3 BIT MasDSW + BPL L1519 ;-> No update +; + SEC + LDA HSTAKP + SBC L210D ;# of locations above stack ptr + STA Z40 +; + LDX #2 ;top of SD-1 +L14D2 INX + STX Z43 + JSR VTABX + LDY #1 + LDA #'1' + STA (ScrLoc),Y ;Show "1xx:" + INY + LDA Z40 + TAX + JSR PUTHEX + LDA #':' + STA (ScrLoc),Y +; + INY + INY + LDA STACK,X + JSR PUTHEX +; + LDA Z43 + CMP StackPBar + BNE L1510 +; + LDY #8 +L14FA LDA (ScrLoc),Y ;Hilite stack ptr bar + AND #$3F + STA (ScrLoc),Y + DEY + BPL L14FA +; + CPX #32 + BCS L1510 +; +; BB's stack area +; + LDA #$60 ;Flashing space + INY ;=1 + STA (ScrLoc),Y + LDY #8 + STA (ScrLoc),Y +; +L1510 INC Z40 ;NB. If -1, (Z40) becomes 0 + LDX Z43 + CPX L210B ;wnd btm of Stack SD + BCC L14D2 ;Next stack location +L1519 RTS +;================================================= +; Show MemCell SD +; +L151A JSR SwapZP + LDY L2103 ;lst line of MC SD + LDX #-1 +L1522 INX + STY ALTYSV + LDA SLATLO,Y + STA STOSCR+1 ;Point @ scrn loc + LDA SLATHI,Y + STA STOSCR+2 +; + LDY #$00 ;Show "xxxx:" + LDA MCAdrH,X + STA IMM6+2 + STA IMM7+2 + JSR STOHEX + LDA MCAdrL,X + STA IMM6+1 + STA IMM7+1 + JSR STOHEX + LDA #':' + JSR STOSCR +; +IMM6 LDA $FFFF + PHA + LDA MCType,X ;Pointer? + BPL L1569 ;No + INC IMM7+1 ;mem page bdry bug! +; +IMM7 LDA $FFFF + JSR STOHEX + PLA + JSR STOHEX + BNE L1577 ;always +; +L1569 PLA ;Hex + PHA + JSR STOHEX + LDA #SPACE + JSR STOSCR + PLA + JSR STOSCR +; +L1577 LDY ALTYSV + INY + CPY #22 ;Last line of MC SD? + BNE L1522 ;No, next mem cell + JMP SwapZP +;================================================= +; Store the hexdec rep of (A) into a mem location +; esply video mem +; +STOHEX PHA + LSR + LSR + LSR + LSR + JSR STONYB + PLA + AND #$0F +STONYB ORA #'0' ;hi-bit A2 ASCII + CMP #'9'+1 + BCC STOSCR + ADC #$06 +; +; Store a char into any video mem location +; User must set up the location b4 calling rtn +; +STOSCR STA $FFFF,Y ;Self-modifying code + INY + RTS +;================================================= +; ($159A) +; Returns the format and length of the opcode +; Each opcode is of the form xxxx xxyy +; Three cases are considered since xxxx xx11 is invalid +; (1) xxxx xx00 +; (2) xxxx xx10 +; (3) xxxx xx01 +; Case (1) & (2) will lead to +; (A) = 00xx xxxx with C-bit=bit1 (which is 0 or 1) +; Case (3) will lead to +; (A) = 0100 00xx with C-bit=bit2 (which is 0 or 1) +; The original 01 will be in bit7,6 +; bits5-7 are masked off +; +INSDIS LDY #0 + LDA (MONPC),Y ;get opcode +INSDIS1 LDX #$FC ;%1111 1100 + STX AdrModSW + LSR ;test bit 0 (A=0xxx xxxy) C-bit=y(bit0) + BCC L15AB + ROR ;(A=10xx xxxx) C-bit=y(bit1) + BCS L15BA ;opcode was xxxx xx11 -> invalid! + AND #%10000111 ;(A)=1000 0xxx mask bits +; +L15AB LSR ;(A)=00xx xxxx or 0100 00xx (on fall thru) + TAX ;C-bit=bit1 or bit2 (see comments above) + LDA FMT1,X ;Get format index byte + BCC L15B6 ;Even, use low nybble + LSR ;Odd, shift high nybble + LSR + LSR + LSR +; +L15B6 AND #$0F ;mask 4-bits + BNE L15BF +L15BA LDA #$00 ;Set print format index to 0 + STA AdrModSW +L15BF TAX + LDA FMT2,X ;Index into print format table + STA INSTFMT ;Save for addr field formatting + AND #%00000011 ;Mask for 2-bit length + STA INSTLEN ;0-1 byte, 1-2 bytes, 2-3 bytes +; + TAY +L15CC LDA (MONPC),Y ;Save instruction + STA INSTSV,Y + DEY + BPL L15CC + RTS +;================================================= +; ($15D5) Swap 16 zpage locations ($3A-$49) +; (Y) unchanged +; (X)=$FF +; +SwapZP LDX #15 +L15D7 LDA MONPC,X + LDY HOLDPZ,X + STA HOLDPZ,X + STY MONPC,X + DEX + BPL L15D7 + RTS +;================================================= +; ($15E5) Save & Restore 6502's regs +; +SavRegs PHP + CLD + STA SAVEA + STX SAVEX + STY SAVEY + PLA + STA SAVEP + RTS +; +RstRegs LDA SAVEP + PHA + LDA SAVEA + LDX SAVEX + LDY SAVEY + PLP + RTS +;================================================= +SVMONPC LDA MONPC + STA SVxZ3A + LDA MONPC+1 + STA SVxZ3A+1 + RTS +; +RSTMONPC LDA SVxZ3A + STA MONPC + LDA SVxZ3A+1 + STA MONPC+1 + RTS +; +CPY2IB LDA SLIN23,Y ;Copy # of chars from cmdln + STA IBuff-1,Y ; to input buffer + DEY + BNE CPY2IB + RTS +;================================================= +; Restore (INSTSV) to that of INSTBE +; +L1624 LDA INSTBE + STA INSTSV + LDA INSTBE+1 + STA INSTSV+1 + LDA INSTBE+2 + STA INSTSV+2 +; + LDA L20F1 ;FORMAT of inst BE + STA INSTFMT + AND #%00000011 + STA INSTLEN ;len of instruction + RTS +;================================================= +; Update the PC display +; +DMONPC LDA #SLIN01 + STA ScrLoc + LDY #11 ;scrn line offset + LDA MONPC+1 + JSR PUTHEX + LDA MONPC + JMP PUTHEX +;================================================= +; Update regs display +; +DREGS LDX #1 + JSR VTABX + LDY #17 ;display acc + LDA HACCUM + JSR PUTHEX + INY + LDA HXREG ;display X-reg + JSR PUTHEX +; + INY + LDA HYREG ;display Y-reg + JSR PUTHEX +; + INY + LDA HSTAKP ;display stack pointer + JSR PUTHEX +; + INY + LDA HFLAGS ;display processor flags + JSR PUTHEX + INY + LDA HFLAGS + JMP DBINSTR ;Display flags as 0s and 1s +;================================================= +; ($1680) Display the hexdec rep of (A) +; (A) - destroyed +; (Y) - horiz offset into screen line, incr by 1 +; (X) - unchanged +; SrcLoc set prior to entry +; +PUTHEX PHA + LSR + LSR + LSR + LSR + JSR PUTNYBZ + PLA +PUTNYB AND #$0F ;lower nybble +PUTNYBZ ORA #'0' + CMP #'9'+1 + BCC L1693 + ADC #$06 +L1693 STA (ScrLoc),Y + INY + RTS +;================================================= +; ($1697) Display (A) as a string of ASC 0's and 1's +; SrcLoc set prior to entry +; +DBINSTR LDX #8 +L1699 ASL ;Shift bit into C + PHA ;Save temporarily for later + LDA #%01011000 + ROL ;Now shift C into bit0 + STA (ScrLoc),Y ;1011 000c ($B0 or $B1) + INY + PLA ;recover + DEX + BNE L1699 ;next bit + RTS +;================================================= +; Show numbered line +; (A) index into table +; (A) & (X) unchanged +; (Y) incr by 1 +; SrcLoc set prior to entry +; +DNbrdLin STX Z40 ;save (X) temporarily + TAX + DEX +L16AA EQU * + LDA LinNbrL,X ;Get ASCII line # + STA (ScrLoc),Y ; & show it + INY + LDA LinNbrH,X + STA (ScrLoc),Y + INX + TXA + LDX Z40 + RTS \ No newline at end of file diff --git a/EDASM.SRC/BUGBYTER/BB3.S b/EDASM.SRC/BUGBYTER/BB3.S new file mode 100644 index 0000000..f840144 --- /dev/null +++ b/EDASM.SRC/BUGBYTER/BB3.S @@ -0,0 +1,1903 @@ +Name : BB3.S +End of file : 34,069 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + +;================================================= +; ($16BA) Convert a binary value to to its +; decimal value & show it on screen +; The binary value is first converted into its BCD +; equivalent then a DEC to hex string converter +; is called +; NB. Only ADC and SBC inst are affected by a SED +; +Bin2Dec LDA #0 + STA Z40 ;Zero result + STA Z40+1 +; + SED ;Set 6502 dec mode + STY Z43 ;Save Y-reg + LDY #16 ;Loop cnt +L16C5 ASL Z3E + ROL Z3E+1 + LDA Z40 ;Add in the C + ADC Z40 + STA Z40 + LDA Z40+1 + ADC Z40+1 + STA Z40+1 + ROL Z40+2 + DEY + BNE L16C5 +; + CLD ;Back to binary mode + LDY Z43 ;Restore Y + LDA Z40+2 ;Output as 5-char string + JSR PUTNYB + LDA Z40+1 + JSR PUTHEX + LDA Z40 + JMP PUTHEX +;================================================= +; Display contents of BB's regs C, R and B +; +DBBREGS LDA #>SLIN01 + STA STOSCR+1 + LDA # bin val + BCS L17AD ;Not valid + LDX Z3E ;Valid values 1-16 + BEQ L17AD + CPX #17 ;Max # of BPs=16 + BCS L17AD +; + DEX ;Range: 0-15 + JSR L17BE ;Clear this BP's data record +; +L179F ASL BPDSW ;Clear flag + BIT MasDSW + BPL L17AA + JSR L180F ;Clear BP SD +L17AA JMP L0922 ;Update SDs & get next cmd +; +L17AD JMP InputErr +; +L17B0 JSR L17B5 ;Clear all BP records + BMI L179F ;always +;================================================= +; Zero all BP records +; Ret +; (A)=0, (X)=$FF +; +L17B5 LDX #15 +L17B7 JSR L17BE ;Zero one record + DEX + BPL L17B7 + RTS +;================================================= +; Init a BP record +; Entry +; (X)=rec # (0-15) +; Ret +; (A)=0 +; +L17BE LDA #0 + STA BPSetT,X + STA BPAdrL,X + STA BPAdrH,X + STA BPCntL,X + STA BPCntH,X + STA BPTrigL,X + STA BPTrigH,X + STA BPBrkL,X + STA BPBrkH,X + RTS +;================================================= +; BP handler +; +BRKHNDLR SEI + SEC + LDA MONPC + SBC #2 + STA MONPC + BCS L17E8 + DEC MONPC+1 +; +L17E8 CLC + LDA HSTAKP + ADC #4 + STA HSTAKP +; + LDX #>BBStack ;Use BB's stack area + TXS + JSR L18B4 ;Is it on our list of BP's + BMI L1800 ;No +; + JSR L0ADD ;Update all SDs + LDX BPHitM1 + JMP L0E59 ;Let BB's SS rtn handle break +L1800 JMP (SVBRKV) ;Let the original BRK handler take care of it +;================================================= +; ($1803) Clear Disassembly/Code SD +; +L1803 LDX L2108 ;wndbtm of CD SD + LDA #3 + STA L2114 ;wndtop + LDA #10 + BNE L1825 ;Proceed to set wndlft +; +; ($180F) Clear BP SD +; +L180F LDY L2105 ;wndtop of BP SD + INY + STY L2114 ;WndTop + LDX #21 ;WndBtm + LDA #10 + BNE L1825 ;Always +; +; ($181C) Blank entire screen +; +ClrScrn LDY #0 +ClrEOS STY L2114 ;WndTop + LDX #23 ;WndBtm + LDA #0 +L1825 STA L2112 ;WndLft + LDA #39 + STA L2113 ;WndRht (ending col) + BIT MasDSW + BMI L1833 + RTS +; +L1833 JSR VTABX + JSR ClrEOL + DEX + CPX L2114 + BPL L1833 ;next line + RTS +;================================================= +ScrollUp LDA L2108 ;wndbtm of CD SD + STA L2115 ;WndBtm + LDA #10 ;WndLft + STA L2112 + LDA #39 + STA L2113 ;WndRht +; +ScrolUpZ LDX #SLIN03 + STA Z43PTR + BNE L1873 ;always +; +ScrolDwn SEC + ROR ScrollSW + LDX L2115 + JSR VTABX ;Set (ScrLoc) to point to last line of SD + BNE L1885 ;always +; +L186A INX +L186B LDA ScrLoc + STA Z43PTR + LDA ScrLoc+1 + STA Z43PTR+1 +L1873 JSR VTABX ;Set (ScrLoc) +; + LDY L2113 ;WndRht +L1879 LDA (ScrLoc),Y +IMM12 ORA #$80 ;Set (IMM12+1) to appropriate byte + STA (Z43PTR),Y + DEY + CPY L2112 ;WndLft + BPL L1879 +; +L1885 BIT ScrollSW ;Up or down? + BMI L1891 ;Down + CPX L2115 + BCC L186A ;Next line + BCS ClrEOL ;Always +; +L1891 DEX + CPX #3 + BPL L186B +; +; Clear line +; Left and Right edges as well as (SrcLoc) must be set +; (A)=char used to blank the line-$A0/$20 +; +ClrEOL LDA #SPACE +ClrEOLI LDY L2113 ;WndRht +L189B STA (ScrLoc),Y + DEY + CPY L2112 ;WndLft + BPL L189B + RTS +;================================================= +; Inverse a line +; +InvLine LDY L2113 ;WndRht +L18A7 LDA (ScrLoc),Y + AND #$3F + STA (ScrLoc),Y + DEY + CPY L2112 ;WndLft + BPL L18A7 + RTS +;================================================= +; Chk if there is a hit +; (X)-$FF - no hit +; otherwise (X) index into BP addr +; +L18B4 LDX NumBPM1 +L18B7 LDA BPSetT,X + BPL L18CA + LDA MONPC + CMP BPAdrL,X + BNE L18CA + LDA MONPC+1 + CMP BPAdrH,X + BEQ L18CE ;Got a hit +L18CA DEX + BPL L18B7 + RTS ;X=-1 if ret from here +L18CE STX BPHitM1 ;currBP + RTS +;================================================= +; ($18D2) +; Set real BP's +; +INCMD BIT BRKFLAG ;Already IN? + BPL L18DA ;No + JMP InputErr +; +L18DA JSR SVMONPC + LDX NumBPM1 +L18E0 STX Z40 + LDA BPSetT,X + BPL L1918 ;Disabled +; + LDA BPAdrL,X ;BP addr + STA MONPC + LDA BPAdrH,X + STA MONPC+1 + JSR INSDIS ;Get addr mode format and len + LDA Z40 ;Make into an index + ASL + ASL + TAX +; + LDY #0 +L18FB LDA INSTSV,Y ;NB. Addr mode format byte is also saved + STA L088F,X + INX + INY + CPY #4 + BNE L18FB +; +; Patch location with a BRK + $EA's +; 1-byte opcodes -> BRK +; 2-byte opcodes -> BRK NOP +; 3-byte opcodes -> BRK NOP NOP +; + LDY INSTLEN ;Len of instr +L190A BNE L190F + TYA ;Y=A=0 -> BRK opcode will be patched + BPL L1911 +L190F LDA #iNOP +L1911 STA (MONPC),Y + DEY + BPL L190A +; + LDX Z40 +L1918 DEX + BPL L18E0 ;Next BP +; + STX BRKFLAG ;=$FF, disable BP modification +L191E JSR RSTMONPC + JMP L0922 ;Update SDs & get next cmd +;================================================= +; ($1924) +; +OUTCMD BIT BRKFLAG ;IN? + BMI L192C ;Yes + JMP InputErr +; +L192C JSR SVMONPC + LDX NumBPM1 +L1932 STX Z40 + LDA BPSetT,X + BPL L1968 ;Not enabled +; + LDA BPAdrL,X + STA MONPC + LDA BPAdrH,X + STA MONPC+1 + TXA + ASL + ASL ;index;4 + STA Z41 + ADC #3 + TAX + LDA L088F,X ;Get addr mode format byte + AND #%00000011 ;Isolate len + STA INSTLEN + INC INSTLEN ;0-1 byte,1-2 bytes,2-3 bytes +; + LDY #0 + LDX Z41 ;Restore original inst +L195A LDA L088F,X + STA (MONPC),Y ; @ location which was + INX ; set as a real BP + INY + CPY INSTLEN + BNE L195A +; + LDX Z40 +L1968 DEX + BPL L1932 + INX ;=0 + STX BRKFLAG ;Enable BP modification + JMP L191E +;================================================= +; Set Break Points +; Each BP consists of 4 pieces of data viz +; Addr, Count, Trigger and Broke values +; +SETBPCMD BIT BRKFLAG ;Is BP modification allowed? + BPL L197A ;Yes +L1977 JMP InputErr +; +L197A JSR Dec2Bin + BCS L1977 + BIT MasDSW + BPL L1977 +; + LDX Z3E ;BP#=1-16 + DEX + BMI L1977 + CPX #16 + BCS L1977 + CPX NumBPM1 + BEQ L1994 + BCS L1977 +; +; Edit BP data rec +; +L1994 STX BPHitM1 ;# of BPs - 1 + ASL BPDSW ;clear msb + JSR L180F ;Clear BP SD + JSR L1719 + LDX BPHitM1 ;currBP + SEC + TXA + ADC L2105 ;wndtop BP SD + TAX + JSR VTABX ;Set (SrcLoc) +; + LDX #0 ;Start w/col # 1 which is Addr +L19AE LDA BPTabsT,X ;Get scrn col offset for this col + TAY + LDA #0 + STA Z41 + STA Z3E ;Numeric val of col + STA Z3E+1 +L19BA LDA (ScrLoc),Y ;Get screen char + AND #$3F ;Convert to a flashing + ORA #$40 + STA (ScrLoc),Y ; char on the screen +; +WAITK6 LDA KBD + BPL WAITK6 + STA KBDSTROBE + CMP #ESC + BEQ L1A3A + CMP #CR + BEQ L1A3A ;Done editing data for this BP +; + CMP #CURSL + BEQ MOVEL + CMP #CURSR + BEQ MOVER + CMP #SPACE + BEQ MOVER +; + JSR ToUpper + STA Z40 ;char + STX Z42 ;Save col # + JSR Add2Bin ;Accmulate bin value + BCS WAITK6 ;Ignore, not a hex digit +; + LDX Z42 ;Restore col # + JSR L1A45 ;Blank entry if reqd + INC Z41 ;# of chars typed for curr entry so far + LDA Z40 ;Get typed char + STA (ScrLoc),Y + INY + TXA ;Form an index with col # + ASL ;Each table is 32 bytes in size + ASL + ASL + ASL + ASL +; + CLC + ADC BPHitM1 ;BP#-1 + TAX + LDA Z3E ;16-bit value + STA BPAdrL,X + TXA + CLC + ADC #16 + TAX + LDA Z3E+1 + STA BPAdrL,X +; + LDX Z42 ;col # + LDA Z41 ;char cnt + CMP #4 ;Have user typed 4 chars? + BNE L19BA ;No, next char +; +; On fall thru, we're done editing the current col since +; a 4-char hexdec str had been typed +; +MOVER CPX #3 ;Was the 4-th col just edited? + BEQ L1A29 ;Yes + INX ;Move cursor to col on right + BNE L1A29 ;always +; +MOVEL TXA ;Is it 1st col? + BEQ L1A29 ;Yes + TYA + CMP BPTabsT,X ;Is cursor on 1st char of col being edited? + BNE L1A29 ;No + DEX ;Prepare to edit col on the left +; +L1A29 LDA (ScrLoc),Y ;Get char under cursor + BMI L19AE ;Normal + CMP #$60 + BCC L1A33 + EOR #$40 +L1A33 ORA #$80 + STA (ScrLoc),Y + JMP L19AE +; +L1A3A LDX BPHitM1 ;currBP + LDA #$80 ;Flag BP has been set + STA BPSetT,X + JMP L0922 ;Update SDs & get next cmd +;================================================= +; (X)-offset to BP Tabs tables +; (Y)-bo scrn line +; Ret +; (Z41)=0 if it was non-zero +; +L1A45 LDA Z41 ;1st char entered? + BNE L1A59 ;No + LDA #4 + STA Z41 ;Blank col + LDA #SPACE +L1A4F STA (ScrLoc),Y + INY + DEC Z41 + BNE L1A4F + LDY BPTabsT,X ;Get cursor's posn +L1A59 RTS +;================================================= +; Convert ASCII rep of a dec string to its binary value +; Ret +; ($3E,$3F)-16-bit binary value +; +Dec2Bin LDA #$00 + STA Z3E + STA Z3E+1 +L1A60 LDA IBuff,Y ;Get a char + CMP #'0' ;Is it $B0-$B9? (hi-bit ASCII 0-9) + BCC NOTNUM + CMP #'9'+1 + BCS NOTNUM ;No + AND #$0F ;(A)=0-9 + STA Z44 ;Save incoming digit + LDA Z3E+1 + STA Z43 ;Save HOB temporarily + LDA Z3E ;First x4 + ASL + ROL Z3E+1 + ASL + ROL Z3E+1 + CLC ; then +1 + ADC Z3E + PHA ;Save intermediate result on stack + LDA Z3E+1 + ADC Z43 ;Add in HOB + STA Z3E+1 +; + PLA ;Finally x2 + ASL + ROL Z3E+1 + CLC ;Now add in the incoming digit + ADC Z44 + STA Z3E + BCC L1A92 + INC Z3E+1 +; +L1A92 INY + CPY INPUTLEN + BNE L1A60 ;Next char + CLC + RTS +NOTNUM SEC + RTS +;================================================= +; Change (Mem Cells) +; +MEMCMD LDX #0 +L1A9E TXA + CLC + ADC L2103 ;vtab + TAY + LDA SLATLO,Y + STA ScrLoc + LDA SLATHI,Y + STA ScrLoc+1 +; +L1AAE LDY #0 + STY ALTYSV + STY Z3E + STY Z3E+1 +L1AB7 LDA (ScrLoc),Y ;Flashing + AND #$3F + ORA #$40 + STA (ScrLoc),Y +WAITK7 LDA KBD + BPL WAITK7 + STA KBDSTROBE +; + CMP #CURSL + BEQ L1B2D + CMP #DELCH + BEQ L1B2D +; + CMP #ESC + BEQ L1B48 ;exit +; + CMP #CURSR + BEQ L1B3A + CMP #SPACE + BEQ L1B3A + CMP #CR + BEQ L1B3A ;Accept +; + CPY #0 + BNE L1AF9 +; + JSR ToUpper + CMP #'P' ;pointer + BEQ L1AF0 + CMP #'H' ;hex + BNE L1AF9 +; + LDA #0 +L1AF0 STA MCType,X + JSR L1B4B + JMP L1AAE +; +L1AF9 STA HIGHB ;Char + STX Z40 + JSR Add2Bin ;Accumulate result + LDX Z40 + BCS L1AB7 ;Not a hex digit + LDA ALTYSV ;Is it 1st char? + BNE L1B14 +; + LDY #3 ;Yes, blank entry + LDA #SPACE +L1B0E STA (ScrLoc),Y + DEY + BPL L1B0E +; + INY ;Y=0 +L1B14 LDA HIGHB ;char + STA (ScrLoc),Y + INY + INC ALTYSV + LDA Z3E ;Save partial result + STA MCAdrL,X + LDA Z3E+1 + STA MCAdrH,X + CPY #4 + BNE L1AB7 ;Get next char + BEQ L1B3A ;done +; +L1B2D CPY #0 ;BS or DEL key + BNE L1B32 ;Not 1st char + DEX +L1B32 TXA + BPL L1B38 + LDX NumMCM1 ;Wraparound to last cell +L1B38 BPL L1B42 +; +L1B3A CPX NumMCM1 + BCC L1B41 + LDX #-1 ;Wraparound to 1st cell +L1B41 INX +L1B42 JSR L1B4B ;Update MC SD + JMP L1A9E ;Continue editing +; +L1B48 JMP L0922 ;Update SDs & get next cmd +; +; Update MEM SD +; +L1B4B STX Z40 + JSR L151A ;Display MEM SD + LDX Z40 + RTS +;================================================= +; ($1B53) Customise Master Display +; +SETCMD EQU * +; +; Set the relative sizes of the CD and BP SD's +; + LDY #3 + JSR ClrEOS ;Clear all SD's + JSR L0CCB ;Show Reg & BP Headers + JSR SVMONPC + ASL IMM12+1 ;clear msb + LDA #1 + STA ALTYSV + LDA #11 ;left edge of CD & BP SD's + STA L2112 ;WndLft + LDA #38 + STA L2113 ;WndRht + LDA #21 + STA L2115 ;WndBtm? +; + LDA L2106 ;Get sentinel val + STA MONPC + LDX L2108 ;wndbtm of CD SD + STX MONPC+1 +; + LDA NumBPM1 + STA Z3E + LDA L2105 ;wndtop BP SD + STA Z3E+1 + LDA #'1' ;Show 1st numbered line + JSR L1C38 ; in inverse + JSR L1C4A ;Fix the sizes of CD & BP SD's +; + LDA Z3E + STA NumBPM1 + LDA Z3E+1 + STA L2105 ;wndtop of BP SD +; +; Set the next-instruction-to-be executed horizontal bar +; in the CD SD. This bar divides the SD among instructions +; that had been executed and those yet to be executed +; First setup the necessary window variables +; + LDX MONPC+1 + STX L2108 ;wndbtm of CD SD + STX L2115 + STX Z3E+1 +; + LDY #0 + STY ALTYSV + DEY + STY Z3E ;=-1 + LDA #$20 ;ASCII space + JSR L1C38 ;Show dividing inverse line (no numbering) + LDA MONPC ;If (A)=-1, CD SD + STA L2106 + BMI L1BBC ; is only 1 line + JSR L1C4A ;CD SD is at least 2 lines +; +; Adjust the relative sizes of the MemCell and Stack SDs +; +L1BBC LDA MONPC+1 + STA CDBar + LDA Z3E + STA L2109 +; + LDX #0 + STX L2112 ;WndLft + INX + STX ALTYSV ;=1 + LDA #8 + STA L2113 ;WndRht + LDA #21 + STA L2115 ;WndBtm +; + LDA L210A ;StackPBar+2 + STA MONPC + LDX L210B ;wndbtm of stack SD + STX MONPC+1 +; + LDA NumMCM1 + STA Z3E + LDY L2103 ;wndtop of MC SD + DEY + STY Z3E+1 + LDA #'1' ;Show 1st numbered + JSR L1C38 ; line in inverse + JSR L1C4A ;Fix the sizes of the MC & Stack SD's +; + LDA Z3E + STA NumMCM1 + LDY Z3E+1 + INY + STY L2103 +; +; Finally set the stack pointer bar +; + LDX MONPC+1 + STX Z3E+1 + STX L210B ;wndbtm of stack SD + STX L2115 +; + LDY #0 + STY ALTYSV + DEY + STY Z3E ;=-1 + LDA #$20 ;ASCII space + JSR L1C38 ;Show inverse line + LDA MONPC ;if (A)=-1, Stack SD + STA L210A + BMI L1C22 ; is 1 scrn line + JSR L1C4A ;Stack SD is at least 2 lines tall +; +L1C22 LDY MONPC + INY + STY L210D ;# of locations above stackptr + LDA MONPC+1 + STA StackPBar + LDA #$80 ;Normal char mask + STA IMM12+1 ; @ this location + JSR RSTMONPC + JMP L091F +;================================================= +; (A) - char to store +; (X)- screen row # +; (L2112) - offset into screen row +; +L1C38 LDY SLATLO,X + STY ScrLoc + LDY SLATHI,X + STY ScrLoc+1 + LDY L2112 ;WndLft + STA (ScrLoc),Y + JMP InvLine +;================================================= +; ($1C4A) This rtn divides a screen area into a +; lower and upper window. +; It is used to adjust the relative sizes of +; 1) CD & BP SD's and +; 2) Stack & MemCell SD's +; It is also used to split the +; 3) CD SD +; 4) Stack SD +; The caller must call this rtn to do 1) and 3) consecutively +; Likewise, 2) and 4) must be done consecutively +; +; Caller have to set up the following variables +; ALTYSV - 0/1 => start numbering fr 1/2 +; MONPC - Sentinel? +; MONPC+1 - wndbtm of upper window +; Z3E - $FF skip numbering lines of lower window +; Z3E+1 - wndtop of lower window +; L2115 - wndbtm of lower window +; wndtop of upper window is fixed at 3 +; +; Show numbered lines in upper window +; +L1C4A LDA ALTYSV + LDX MONPC+1 ;btm of upper window + CPX #3 ; cannot be < its wndtop + BEQ L1C5E +L1C53 DEX + CLC + ADC #1 ;(A)=line # + JSR L1CC7 ;Show it + CPX #3 ;wndtop? + BNE L1C53 ;No +; +; Show numbered lines in lower window +; +L1C5E LDA Z3E ;Show numbering of lines? + BMI WAITK8 ;No +; + LDA #0 ;Starting numbering fr 1 + LDX Z3E+1 ;top of lower window +L1C66 INX + CLC + ADC #1 + JSR L1CC7 ;Show line # + CPX L2115 ;btm of lower window + BNE L1C66 +; +WAITK8 LDA KBD + BPL WAITK8 + STA KBDSTROBE + CMP #CURSL + BEQ DECSZ + CMP #CURSR + BEQ INCSZ + CMP #CR ;If cr, accept + BNE WAITK8 + RTS +; +; Decrease size of upper window and increase size of lower window +; +DECSZ LDA MONPC+1 ;btm of upper window + CMP #3 ; cannot be < its wndtop + BEQ WAITK8 + DEC MONPC + DEC MONPC+1 + DEC Z3E+1 ;top of lower window + INC Z3E + JSR ScrolUpZ +; + LDX L2115 ;btm of lower window + CLC + LDA Z3E + ADC #1 + JSR L1CC7 ;Show btm line + JMP WAITK8 +; +; Increase size of upper window and decrease size of lower window +; +INCSZ LDX Z3E + INX + CPX ALTYSV + BEQ WAITK8 + INC MONPC + INC MONPC+1 + INC Z3E+1 ;top of lower window + DEC Z3E + JSR ScrolDwn + LDX #3 ;top of upper window + SEC ;NB: it's not CLC + LDA MONPC + ADC ALTYSV + JSR L1CC7 ;Show topmost line + JMP WAITK8 +;================================================= +; (X)-vtab of line +; (A)-char +; +L1CC7 TAY ;Save A + JSR VTABX + TYA + LDY L2112 ;Do a htab & + JSR DNbrdLin ; show numbered line + RTS +;================================================= +; ($1CD3) Disassemble a few inst +; starting fr specified addr +; +LKEY1 JSR L1803 ;Clear Code Disasm SD + LDA Z3E ;Start fr this addr + STA LastAdr + LDA Z3E+1 + STA LastAdr+1 +; +; Disassemble fr last addr +; +DISASMCMD JSR SVMONPC + SEC ;Flag there is a pending + ROR CodeDSW ; update for code SD + LDY L2106 + INY + STY ALTYSV + LDA LastAdr + STA MONPC + LDA LastAdr+1 + STA MONPC+1 +; +L1CF8 JSR INSDIS ;decode inst + JSR ScrollUp + JSR INSTDSP ;Display inst + JSR L12B4 ;Display machine code + JSR PCADJ + STA MONPC + STY MONPC+1 + DEC ALTYSV + BPL L1CF8 ;Next inst +; + LDA MONPC ;Save this for later + STA LastAdr + LDA MONPC+1 + STA LastAdr+1 +; + JSR RSTMONPC + JSR L1624 ;Restore + JMP XDelLin +;================================================= +; Display contents of 2/3 of a mem page (184 bytes) +; +L1D23 LDA MBStrtAdr ;Starting addr + STA IMM9+1 + LDA MBStrtAdr+1 ; of mem block + STA IMM9+2 + JSR SwapZP +; + LDX #0 +L1D34 STX ALTYSV ;cntr + LDA SLATLO,X + STA STOSCR+1 ;Start of scrn line + LDA SLATHI,X + STA STOSCR+2 +; + LDY #0 + LDA IMM9+2 ;Show "xxxx:" + JSR STOHEX + LDA IMM9+1 + JSR STOHEX + LDA #':' + JSR STOSCR +; + LDX #7 ;8/row +IMM9 LDA $FFFF ;Get (memory) + LDY MPTabs2,X ;Get offset into scrn line + JSR STOSCR ;Show Apple's char rep + LDY MPTabs1,X ;Get offset into scrn line + JSR STOHEX ;Show its hex rep + INC IMM9+1 + BNE L1D6F + INC IMM9+2 +L1D6F DEX + BPL IMM9 +; + LDX ALTYSV + INX + CPX #23 + BNE L1D34 ;Next row + JMP SwapZP +;================================================= +; ($1D7D) Display inst +; +INSTDSP LDY #$FC ;Use this as opcode if addr + BIT AdrModSW ; mode format is not valid + BPL L1D87 +; + LDY INSTSV ;Get opcode +L1D87 JSR L1E04 ;Get its index + STA Z44 ; in mnemonic table + LDY #11 ;Display PC and ':' + LDA MONPC+1 + JSR PUTHEX + LDA MONPC + JSR PUTHEX + LDA #':' + STA (ScrLoc),Y + INY + INY +; + LDA #3 ;Display instruction's mnemonic + STA Z43 ;as 3 ASCII chars + LDX Z44 +L1DA4 LDA MNEMTBL,X + STA (ScrLoc),Y + INX + INY + DEC Z43 + BNE L1DA4 +; +; Display its operand field +; + INY + STY Z40 + LDY INSTLEN + LDX #$06 ;Count for 6 format bits +PrAdr1 CPX #$03 ;If X=3, then addr + BEQ PrAdr5 +PrAdr2 ASL INSTFMT + BCC PrAdr3 + LDA CHAR1-1,X + STY Z41 + LDY Z40 + STA (ScrLoc),Y + INY + LDA CHAR2-1,X + BEQ L1DD2 + STA (ScrLoc),Y + INY +L1DD2 STY Z40 + LDY Z41 +PrAdr3 DEX + BNE PrAdr1 + RTS +; +PrAdr4 DEY + BMI PrAdr2 +; + STY Z41 + LDY Z40 + JSR PUTHEX + STY Z40 + LDY Z41 +PrAdr5 LDA INSTFMT + CMP #$E8 ;handle relative addressing mode + LDA INSTSV,Y + BCC PrAdr4 ;special (print target, not offset) +; + JSR PCADJ3 ;(A) has displacement + TAX + INX + BNE PRNTYX + INY +PRNTYX TYA ;(A,X)=(MonPC)+OFFSET+1 + LDY Z40 + JSR PUTHEX + TXA + JMP PUTHEX +;================================================= +; Get index into mnemonic table +; Perform some mapping of inst e.g $6C,$7C -> $4C +; Entry +; (Y)=opcode +; Ret: +; (A)-index into Mnemonic table +; +L1E04 CPY #$6C ;JMP (abs) + BEQ L1E0C + CPY #$7C ;JMP (abs,X) + BNE L1E0E +L1E0C LDY #$4C ;JMP abs +; $A2 -> $A6 +L1E0E CPY #$A2 ;LDX #imm + BNE L1E14 + LDY #$A6 ;LDX zp +; $9C,$9E -> $64 +L1E14 CPY #$9C ;STZ abs + BEQ L1E1C + CPY #$9E ;STZ abs,X + BNE L1E1E +L1E1C LDY #$64 ;STZ zp +; $89 -> $34 +L1E1E CPY #$89 ;BIT #imm + BNE L1E24 + LDY #$34 ;BIT zp,X +; +L1E24 TYA + AND #$0F + CMP #$02 + BNE L1E2E + DEY ;$X2 -> $X1 e.g. + BNE L1E24 ; sta (zp) -> sta (zp),Y +; +L1E2E CMP #$0A + BEQ L1E3A + AND #%00000111 + BEQ L1E43 + CMP #$04 + BNE L1E48 +; +; $XA,$X4,$XC opcodes +; +L1E3A LSR + LSR + TYA ;opcode + ROR + SEC + ROR + CLC + BCC L1E4E ;always +; +; $X0, $X8 opcodes +; +L1E43 TYA ;opcode + LSR + CLC + BCC L1E4E ;always +; +; Others viz $X1,$X3,$X5,$X6,$X7,$X9,$XB,$XD,$XE,$XF +; +L1E48 LSR + TYA + ROR + LSR + LSR + SEC +; +L1E4E ROR + LSR + STA Z44 + CLC + ASL + ADC Z44 +L1E56 RTS +;================================================= +; ($1E57) Mini Assembler-Ref to Apple IIe reference manual +; +DoAsm LDX #3 ;# of chars to compare + JSR GNNB + DEY + JMP L1E63 +; +; Check the 3 chars are alphabetic +; +L1E60 LDA IBuff,Y +L1E63 CMP #'A' ;Is it alphabetic? + BCC L1E56 + JSR ToUpper + CMP #'Z'+1 + BCS L1E56 ;No + INY + DEX + BNE L1E60 +; + LDA #$00 + STA Z41 + STA Z43 ;Len of inst + CPY INPUTLEN + BEQ L1EC5 ;No operand -> try to assemble inst +; +; Parse the operand +; X char(s) check +; 0 ,Y +; 1 ) +; 2 ,X +; 3 #$ +; 4 ($ +; 5 $ +; + LDX #5 ;# of format indices +AMod1 JSR GNNB ;Get 1st char of addr + STY Z42 + CMP CHAR1,X ;Does 1st char match pattern? + BNE AMod2 ;No + JSR GNNB ;Yes, get 2nd char + CMP CHAR2,X ;Matches 2nd half? + BEQ AMod4 ;Yes -> C=1 +; + LDA CHAR2,X ;Is 2nd half zero? + BEQ AMod3 ;Yes -> C=1 + CMP #'$' ;Is 2nd half optional? + BEQ AMod3 ;Yes -> C=1 + LDY Z42 +; +AMod2 CLC ;No match->Clear bit +AMod3 DEY ;Back up 1 char +AMod4 ROL Z41 ;Shift C-bit into format byte + CPX #3 ;Time to check for addr? + BNE AMod6 ;No +; + JSR Hex2Bin ;Yes, get the number + LDX #1 ;Assume 2-byte operand + LDA Z3E+1 + BEQ AMod5 ;single byte + INX +AMod5 STX Z43 ;Store inst len + LDX #3 ;Prepare to look for ,X +AMod6 DEX ;Done w/format check? + BPL AMod1 ;No +; +; On fall thru, the inst's addr mode +; had been parsed. +; + LDA Z41 ;Get the format + ASL + ASL ;Put len which is 2 bits + ORA Z43 ;in bits0,1 + CMP #$20 ;Add "$" if 1-/2-byte + BCS AMod7 + ORA #%10000000 ; operand doesn't have it +AMod7 STA Z41 ;Update format +; + LDA #$00 ;Start with BRK opcode +L1EC5 EQU * ;Enter here w/opcode in Acc + STA Z40 ;Save the opcode +L1EC7 LDA Z40 ;Get trial opcode + JSR INSDIS1 ;Determine its len & format + BIT AdrModSW ;Is addr mode format valid? + BPL L1F04 ;No +; + LDY Z40 ;Get Opcode + JSR L1E04 ;Get its index in mnemonic table + TAX ;Use X-reg as the index + LDY ALTYSV + JSR GNNB + DEY + LDA #3 + STA Z42 ;# of chars to compare +L1EE2 LDA IBuff,Y + JSR ToUpper + CMP MNEMTBL,X + BNE L1F04 ;No hit + DEC Z42 + BEQ L1EF6 ;Got a match + INX + INY + JMP L1EE2 +; +L1EF6 LDA Z41 ;Get parsed format + LDY INSTFMT ;Get trial format + CPY #$9D ;Is it relative? + BEQ RelMode ;Yes + CMP INSTFMT ;Same format? + BEQ MovInst ;Yes, move inst to memory +; +L1F04 DEC Z40 ;Else try next opcode + BNE L1EC7 + INC Z41 ;No more, try with + DEC Z43 ; len of inst = 2 + BEQ L1EC7 ;Go try next format +L1F0E RTS ;Unrecognised inst +; +; Calc offset byte for relative addresses +; +RelMode SBC #$81 ;Is format compatible + LSR ;with Relative mode? + BNE L1F0E ;No->Bad branch +; + LDY Z3E+1 + LDX Z3E + BNE RelMode1 + DEY ;Point to offset +RelMode1 DEX ; displacement -1 + TXA + CLC ;NB C is clear + SBC MONPC ;Form Addr-PC-2 + STA Z3E + BPL RelMode2 ;Check page + INY +RelMode2 TYA ;Get page + SBC MONPC+1 ;Check page + BNE L1F0E ;Err if > 1-byte displacement +; +; Inst had been assembled; move inst to mem +; (INSTLEN)=1 - 2-byte opcode +; =2 - 3-byte opcode +; +MovInst LDY INSTLEN ;Single byte opcode? + BEQ L1F3A ;Yes +MovInst1 LDA Z3E-1,Y ;Copy operand + STA (MONPC),Y + STA INSTSV,Y + DEY + BNE MovInst1 +; +; Display the inst +; +L1F3A LDA Z40 ;opcode + STA INSTSV + STA (MONPC),Y + BIT MemPgDSW ;Is Mem Pg SD up? + BMI L1F54 ;Yes->no SD update + BIT CodeDSW ;Update Code SD? + BPL L1F54 ;No +; + JSR ScrollUp + JSR INSTDSP + JSR L12B4 +; +L1F54 JSR PCADJ + STY IMM1+2 + STA IMM1+1 + JSR RSTMONPC + PLA + PLA + JSR L1624 ;Restore + JMP L0AB8 +;================================================= +; Get next non-blank char +; ($1F68) Y=index into Input buffer +; (A) - char +; (X) not used +; (Y) set to index next char in buf +; +GNNB LDA IBuff,Y + INY + JSR ToUpper + CMP #SPACE + BEQ GNNB + RTS +;================================================= +; Display "TRACE" +; +DTRACE LDX #10 +L1F76 LDA TRACEK,X + STA SLIN23,X + DEX + BPL L1F76 + RTS +;================================================= +; Display "SINGLE STEP" +; +DSSTEP LDX #10 +L1F82 LDA STEPK,X + STA SLIN23,X + DEX + BPL L1F82 + RTS +;================================================= +; Display "Waiting" for RTS +; +DWAIRTS LDX #11 +L1F8E LDA WAITRTS,X + STA SLIN23+28,X + DEX + BPL L1F8E + RTS +;================================================= +; Erase "WAITING" +; +L1F98 LDX #11 + LDA #SPACE +L1F9C STA SLIN23+28,X + DEX + BPL L1F9C + RTS +;================================================= +; ($1FA3) Show "SKIP" +; +DSKIP LDY #31 +L1FA5 LDA SKIPM-31,Y + STA (ScrLoc),Y + INY + CPY #35 + BNE L1FA5 + RTS +;================================================= +QUITCMD JSR SwapZP + JMP DOSWrm ;ProDOS warm start +; +MONCMD JSR SwapZP + JMP MONZ +;================================================= +ASMCMD SEC + ROR CodeDSW + JSR L1803 ;Clear Code SD + JMP XDelLin +;================================================= +; This cmd allows user to send own output to screen +; during SS/TR mode +; +OFFCMD JSR ClrScrn ;Clear all SD's except cmdln SD + CLC + DB $24 +; +; This cmd enables BB control of screen output +; during SS/TR mode +; +ONCMD SEC + ROR MasDSW + JMP L091F +;================================================= +; Set ScrLoc to the beginning of screen line +; (X),(Y) unchanged +; +VTABX LDA SLATLO,X + STA ScrLoc + LDA SLATHI,X + STA ScrLoc+1 + RTS +;================================================= +; (X),(Y) unchanged +; +ToUpper CMP #'a' + BCC L1FE3 + AND #$DF +L1FE3 RTS +;================================================= +; Read paddle +; +PREAD2 LDA PTRIG ;Start countdown + LDY #$00 ;Time the period + NOP + NOP +L1FEB LDA PADDL0,X ; until Paddle button 0 is pressed + BPL L1FF4 + INY + BNE L1FEB + DEY +L1FF4 RTS +;================================================= +; Delay rtn +; +WAIT2 SEC +L1FF6 PHA +L1FF7 SBC #1 + BNE L1FF7 + PLA + SBC #1 + BNE L1FF6 + RTS +;================================================= +PRTERR LDA #'E' + JSR COUT2 + LDA #'R' + JSR COUT2 + LDA #'R' + JSR COUT2 +BELL2 LDA #BEL +COUT2 JMP (CSWL) +; +BBDATA EQU * ;Start of bugbyter's variables +;================================================= +; Break Point records. Each record consists of 5 +; pieces of data, 4 of which may be changed by +; onscreen editing. +; +BPSetT DS 16,0 ;$80=BP is set, $00=no BP +; +BPAdrL DS 16,0 ;User-defined Addr of BP's +BPAdrH DS 16,0 +; +BPCntL DS 16,0 ;# of times BP addr was encountered +BPCntH DS 16,0 +; +BPTrigL DS 16,0 ;User-defined cnt b4 breaking. To cause a +BPTrigH DS 16,0 ; break, trigger must be set to at least 1 +; +BPBrkL DS 16,0 ;counter for # of times +BPBrkH DS 16,0 ; BB was triggered at a BP +;================================================= +; Mem cells' addresses and flags +; +MCAdrL DS 17,0 +MCAdrH DS 17,0 +MCType DS 17,0 ;msb on=1 ptr, =0 hex +; +SVBRKV DW 0 +HOLDPZ DS 11,0 +; +SAVEA DB 0 +SAVEX DB 0 +SAVEY DB 0 +SAVEP DB 2 +SAVES DB $FF +SVxZ3A DW 0 ;Save area for ($3A) which MONPC +; +INSTSV DS 3,0 ;NB. Format & INSTSV must be consecutive locations +INSTFMT DB 0 ;FORMAT +INSTLEN DB 0 ;LENGTH OF INST +; +L20F1 DB 0 ;FORMAT of inst BE +L20F2 DB 0 ;LENGTH of inst BE +AdrModSW DB $80 ;$80=addr mode is valid +BRKFLAG DB $00 ;$FF=IN, $00=OUT +BPDSW DB $00 ;$80-update BP SD +TrigSW DB $80 +BPHitM1 DB $FF ;currBP +INSFLAG DB $00 ;bit7=1 => insert, bit7=0 => overwrite mode +SW06 DB $80 ;$80-use kbd rate, $00-use game paddle to adjust rate +ExecSW DB $00 ;$80-execution mode +SSSW DB $00 ;Single Step +MasDSW DB $80 ;Master Display +MemPgDSW DB $00 ;Mem Page displayed +CodeDSW DB $00 ;Code DisAssembly (CD) SD switch +RTSSW DB $00 +; +L2100 DB 3 ;Display Option during SS and TR (default O=P) +NumCycles DB 0 +NumMCM1 DB 4 ;# of mem cells-1 +L2103 DB 17 ;wndtop of Mem Cell SD +NumBPM1 DB 3 ;min=0 => 1 BP (# of BP's) +L2105 DB 17 ;wndtop BP SD +L2106 DB 11 ;Sentinel (2108)-(2106)=4 always (min -1) +CDBar DB 13 ;Position of next-to-be-executed-inst bar +L2108 DB 15 ;wndbtm of CD SD (min 3) +L2109 DB 1 ;# of yet-to-be-executed inst minus 1 +L210A DB 11 ;Sentinel (210B)-(210A)=4 always (min 1) +L210B DB 15 ;wndbtm of stack SD (min 3) +StackPBar DB 9 ;Position of stack ptr bar within stack SD +L210D DB 6 ;# of locations above stackptr (min 0) +INPUTLEN DB 0 ;len of input string +SW13 DB 0 ;$80=skip next inst +RATEC DB 0 +KBDRate DB 0 +; +L2112 DB 0 ;WndLft +L2113 DB 0 ;WndRht +L2114 DB 0 ;WndTop +L2115 DB 0 ;WndBtm +; +ScrollSW DB 0 ;$80=down, $00=up +ALTYSV DB 0 +LastAdr DW 0 +MBStrtAdr DW 0 ;Starting addr of memory block displayed +HIGHB DB 0 ;hibyte flag for string entry +BPTabsT DB 15,21,27,33 ;BP scrn col offsets +;================================================= + MSB ON +SKIPM ASC "SKIP" +OPTSK ASC "AXYPSBE" +TRACEK ASC "TRACE " +STEPK ASC "SINGLE STEP" +WAITRTS ASC "AWAITING RTS" +REGSK ASC "PC A X Y S P NV-BDIZC" +BPHDR ASC "BP POINT COUNT TRIG BROKE " +COPYRK ASC "(C) 1984 COMPUTER-ADVANCED IDEAS V2.21" +; +; Use to show line numbering during a SET cmd & BP #s +; +LinNbrL ASC "12345678911111111" +LinNbrH ASC " 01234567" +;================================================= +; command keywords +; an entry of this table consists of 2 parts +; 1) the entry len +; 2) a string of chars whose len is 1 less the entry len +;================================================= +COMMAND DB $03 + ASC "A=" + DB $03 + ASC "X=" + DB $03 + ASC "Y=" + DB $03 + ASC "P=" + DB $03 + ASC "S=" + DB $03 + ASC "R=" + DB $04 + ASC "PC=" + DB $03 + ASC "C=" + DB $03 + ASC "O=" + DB $04 + ASC "SET" + DB $04 + ASC "MEM" + DB $02 + ASC "M" + DB $04 + ASC "CLR" + DB $03 + ASC "BP" + DB $04 + ASC "ASM" + DB $02 + ASC "." + DB $03 + ASC "ON" + DB $04 + ASC "OFF" + DB $03 + ASC "IN" + DB $04 + ASC "OUT" + DB $02 + ASC "Q" + DB $02 + ASC "T" + DB $02 + ASC "S" + DB $02 + ASC "G" + DB $02 + ASC "J" + DB $02 + ASC "L" + DB $02 + ASC "V" + DB $00 +;================================================= +; +CMDTBL DW SETREG-1 + DW SETREG-1 + DW SETREG-1 + DW SETREG-1 + DW SETREG-1 + DW SETREG-1 + DW SETREG-1 + DW SETREG-1 + DW SETOPT-1 + DW SETCMD-1 + DW MEMCMD-1 + DW MONCMD-1 + DW CLRBPCMD-1 + DW SETBPCMD-1 + DW ASMCMD-1 + DW DOTCMD-1 + DW ONCMD-1 + DW OFFCMD-1 + DW INCMD-1 + DW OUTCMD-1 + DW QUITCMD-1 + DW TRACECMD-1 + DW SSTEPCMD-1 + DW XSUBRCMD-1 + DW JUMPCMD-1 + DW DISASMCMD-1 + DW DCPYRCMD-1 +; +OURCTLYV DW WrmStrt +OURBRKV DW BRKHNDLR +CMDTBLP DW COMMAND +NumJmps EQU *-CMDTBL-1 +;================================================= +; Screen Line offsets for Mem Page display +; +MPTabs2 DB 39,38,37,36,35,34,33,32 +MPTabs1 DB 28,25,22,19,16,13,10,7 +;================================================= +; BB uses absolate screen addressing for output +; +SLATLO DB >SLIN00 + DB >SLIN01 + DB >SLIN02 + DB >SLIN03 + DB >SLIN04 + DB >SLIN05 + DB >SLIN06 + DB >SLIN07 + DB >SLIN08 + DB >SLIN09 + DB >SLIN10 + DB >SLIN11 + DB >SLIN12 + DB >SLIN13 + DB >SLIN14 + DB >SLIN15 + DB >SLIN16 + DB >SLIN17 + DB >SLIN18 + DB >SLIN19 + DB >SLIN20 + DB >SLIN21 + DB >SLIN22 + DB >SLIN23 +SLATHI DB 4 (value) +c.eof EQU $2 ;->4 (value) +c.attr EQU $3 ; (flags) +c.newl EQU $3 ; (character) +c.bufPtr EQU $3 ;&4 (pointer) +c.newPath EQU $3 ;&4 (pointer) +c.fileId EQU $4 ; (value) +c.reqCnt EQU $4 ;&5 (value) +c.blkNum EQU $4 ;&5 (address) +c.outRef EQU $5 +c.auxId EQU $5 ;&6 (value) +c.transCnt EQU $6 ;&7 (value) +c.fKind EQU $7 ; (value) +c.date EQU $8 ;&9 (value) +c.outBlk EQU $8 ;&9 (count) +c.time EQU $a ;&b (value) +c.modDate EQU $a ;&b (value) +c.modTime EQU $c ;&d (value) +c.creDate EQU $e ;&f (value) +c.creTime EQU $10 ;&11 (value) \ No newline at end of file diff --git a/EDASM.SRC/EDITOR/EDITOR1.S b/EDASM.SRC/EDITOR/EDITOR1.S new file mode 100644 index 0000000..3170f69 --- /dev/null +++ b/EDASM.SRC/EDITOR/EDITOR1.S @@ -0,0 +1,1800 @@ +Name : EDITOR1.S +End of file : 32,624 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + +;================================================= +; $0A,$0B - R5 - TxtBgn +; $0C,$0D - R6 - HiMem +; $0E,$0F - R7 - TxtEnd (last char of text buf being edited) +;================================================= +; UNLOCK cmd +; +LD282 SET R1,$C2C2 + BR LD28A +; +; LOCK cmd +; +LD287 SET R1,$C200 +LD28A SET R4,XBD80 ;PN is in $BD80 buf + RTN +; +LD28E LDA #TXTtype + JSR XB883 ;Does file exist? + BCC LD298 ;Yes +LD295 JMP XB602 ;Display err (A)=err code +; +LD298 JSR LD29E + JMP XB1CB +; +; Modify the file attributes if necessary +; +LD29E LDA XBACA ;File's curr access bits + AND Reg1+1 + CMP Reg1 ;Change file's properties? + BEQ LD2C3 ;No +; + LDY #12 +LD2A9 LDA XBAC8,Y ;$BAC8-$BAD4 + STA XBADA,Y ;$BADA-$BAE6 + DEY + BPL LD2A9 +; + LDA Reg1+1 + EOR #$FF ;Change all 1's to 0's & vice-versa + AND XBACA + ORA Reg1 + STA XBADC + JSR XB904 ;Change file's info + BNE LD295 ;Err +LD2C3 RTS +;================================================= +; DELETE cmd +; +LD2C4 SET R1,$C2C2 ;Set access bits + SET R4,XBD80 ;Set ptr to PN + RTN +; + LDA #TXTtype + JSR XB883 ;Get file's attributes + BCS LD295 ;File not found + LDA XBACA ;Get file's curr access bits + AND #%11000010 ;Mask off B,R bits + CMP #%11000010 ;Are the D,N,W bits on? + BEQ LD2F4 ;Yes +; + JSR NEWSW16 + SET R9,XB521 ;"File locked" msg + RTN + JSR LD484 ;Prt msg +; + JSR LDD37 ;Get key + PHA + JSR XB339 ;Do a CR + PLA + CMP #'Y' + BNE LD305 +; + JSR LD29E ;Modify file's properties +LD2F4 LDA XBAC8 ;Set ptr to pathname + STA XBAF4 ; to be destroyed + LDA XBAC8+1 + STA XBAF4+1 + JSR XB90B ;Destroy it +LD303 BNE LD295 ;Err +LD305 JMP XB1CB +;================================================= +; RENAME cmd +; Both Old & New PathNames are in $BD80 buf +; separated/terminated by a null char ($00) +; +LD308 SET R4,XBD80 ;Set ptr to PN + LD R4 + ST R1 +LD30D LDI R1 ;Search for null-separator + BNZ LD30D + LD R1 + ST R2 + DCR R2 ;Move back to point @ 0 + SET R3,$FFFF ;Count # of chars +LD316 INR R3 ; in New PN + LDI R1 ;Look for the null-terminator + BNZ LD316 + RTN +; + JSR XB8B2 ;Setup FileNameB w/old PN + JSR NEWSW16 + SET R1,XBAFB + LD R2 ;Get ptr to new PN and + STD R1 ; store it @ locations $BAFB-FC + LD R3 ;len byte + STI R2 + RTN +; + JSR XB912 ;Rename the file + BNE LD331 ;Err + JMP XB1CB +LD331 JMP XB602 +;================================================= +; Is this referenced? +; + JSR NEWSW16 +LD337 SET R9,XB427 ;Bad Format + BR LD33F +LD33C SET R9,XB420 ;Syntax +LD33F RTN + JSR XB620 ;ERR + JMP XB198 +;================================================= +; Print the line +; +LD346 BIT PrintF ;Print or List? + BMI LD34D + JSR LD491 ;Show line # +; +LD34D LDA #$FF + STA Z60 + LDA #$01 + STA Z7B + LDY #0 + LDA (Reg9),Y ;Is it a comment line? + CMP #'*' + BEQ LD361 + CMP #' ;' + BNE LD36B ;No +; +LD361 LDA #SPACE ;Is tabchar a space? + CMP TabChar + BNE LD36B + LDA #$D0 ;Yes, ignore tab expansion + STA Z60 ; for comment lines +LD36B DEY +; +; Print line loop +; +LD36C INY + LDX PrColumn ;curr prt col + CPX #79 + LDA VideoSlt ;=$C3 if 80-col card in slot 3 + BNE LD377 ;No + CPX #39 +LD377 BCC LD386 +; + JSR XB339 ;Do a cr + LDA #$D0 ;No tab expansion if + STA Z60 ; text line requires + LDA #6 ; multiple print lines + STA PrColumn + STA CH +; +LD386 LDA (Reg9),Y ;Get char + STA Z5E + BPL LD38E + AND #$7F +LD38E CMP TabChar + BNE LD3B3 + INC Z60 + BMI LD3B3 ;Ignore tab expansion +; +; Print reqd # of spaces for tabs +; +LD396 LDX Z60 ;tab col + CPX #10 + BCS LD3B1 + LDA UserTabT,X ;tabs + SEC + SBC #1 + BMI LD3B1 + CMP PrColumn ;curr prt col + BCC LD3B1 + BEQ LD3B1 + LDA #SPACE + JSR XB343 + JMP LD396 +; +LD3B1 LDA Z5E ;char +LD3B3 CMP #CR + BEQ LD3FE + CMP #' ;' + BNE LD3C5 + LDX TabChar + CPX Z7B + BNE LD3C5 + LDX TruncF + STX Z7B +LD3C5 LDA Z5E + LDX Z7B + BEQ LD3F7 + STA Z7B + TAX + BMI LD3E0 +; + CMP #SPACE ;Is it a ctrl-char? + BCS LD3F4 ;No + BIT PrintF ;List? + BMI LD3F4 ;No, send it to printer as is + CMP TabChar + BNE LD3EE + LDA #SPACE + BNE LD3F4 ;always +; +LD3E0 AND #$7F + CMP TabChar + BEQ LD3EC + CMP #SPACE + BCS LD3F0 :Std ASCII + BCC LD3EE ;$00-$1F -> $40-$5F +; +LD3EC LDA #%11100000 ;->$A0 (on fall thru) +LD3EE EOR #%01000000 +LD3F0 LDX #$3F + STX InvFlg +LD3F4 JSR XB343 +LD3F7 LDX #$FF + STX InvFlg + JMP LD36C +; +LD3FE JSR XB343 ;Finish print line + TYA ;Compute mem location + SEC + ADC Reg9 + STA Reg9 + LDA #0 + ADC Reg9+1 + STA Reg9+1 ; of next txt line + LDA #CR + RTS +;================================================= +; Add cmd +; (Reg12)=ptr to $BD00 +; +LD410 LDD R12 ;Was a line # issued w/cmd? + BZ LD418 ;No + INR R0 ;It's an INSERT, incr line # + ST R11 ; since we are adding after + BRL LD656 +; +LD418 SET R11,$FFFF + RTN +; + JSR LD4D3 ;Get addr 1 past EO txtbuf +LD41F JSR LD44C ;Get input line + JSR NEWSW16 + LD R9 ;Compute end addr of + ADD R2 ; new line of text + INR R0 + CPR R6 ;HiMem + BC LD446 ;Out of Mem + RTN +; +LD42C LDX Reg2 ;Get input len + INX + LDY #-1 +LD431 INY + LDA InBuf,Y ;Copy to txtbuf+1 + STA (Reg9),Y + DEX + BNE LD431 +; + JSR NEWSW16 + LD R9 + ADD R2 + ST R7 ;New TxtEnd + INR R0 + ST R9 ;1 past new TxtEnd + RTN + JMP LD41F ;Loop back to add another line +; +LD446 SET R9,XB432 + BRL LD33F +;================================================= +; Get input line +; Output +; Reg1 - Ptr to Inbuf +; Reg2 - input len +; +LD44C JSR LD491 ;Print line # + LDA #$3F ;'?' + STA Prompt + JSR LA710 ;Input line using cmd line rtn + LDA #0 + STA Reg2+1 + LDA #>InBuf + STA Reg1 + LDA #$20 on fall thru +LD4BC EOR #'0' + JSR XB343 ;Print char + CMP #'0' + ROR Reg3 + DEY + BNE LD49E + LDA #SPACE + JMP XB343 ;Done +; +LD4CD SET R9,XB43E ;Bad range + BRL LD33F +;================================================= +; Input +; (Reg11)= Line # +; Output +; (Reg9)=Addr of line +; +LD4D3 JSR NEWSW16 + LD R5 ;TxtBgn (Start addr of text buf) + ST R9 ;Set initial addr + LD R11 ;Get Line # and + ST R1 ; store it here + SUB R0 ;Zero ACC + ST R11 ; and this reg +LD4DC INR R11 ;Line counter + DCR R1 ;Are we done yet? + BZ LD4E4 ;Yes + LD R9 + CPR R7 ;=TxtEnd + BNC LD4E6 ;Keep searching +LD4E4 RTN + RTS +; +LD4E6 RTN + LDY #0 +LD4E9 LDA (Reg9),Y ;Look for EOL (cr-terminated) + INC Reg9 + BNE LD4F1 + INC Reg9+1 +LD4F1 CMP #CR + BNE LD4E9 +; + JSR NEWSW16 + BR LD4DC ;Incr the line count +;================================================= +LD4FA DW 10000 + DW 1000 + DW 100 + DW 10 + DW 1 +;================================================= +; KILL2 cmd +; Can be issued whichever txt buf is currently +; in use. +; +LD504 RTN +LD505 LDA SwapMode + LDX #0 ;Deactivate split-buf mode + STX SwapMode + CMP #$01 ;Was text buf 1 active? + BCC LD51B ;Normal non-split buf + BNE LD51E ;No, buf2 +; + LDA XBA33+2 ;Make txtbuf2 active + STA Reg6 + LDA XBA33+3 + STA Reg6+1 +LD51B JMP XB1CB +LD51E JMP LD80D ;Make txtbuf1 active +;================================================= +; NEW cmd +; Clears the current text buffer +; Input +; Reg5 - Points to 1st char of curr txtbuf +; Reg7 - Points to last char of curr txtbuf +; When Reg5 & Reg7 both point @ same location -> +; the text buffer is empty. +; When Reg5 points @ a pair of zeroes, an XLOAD +; cmd was issued previously. +; +LD521 LD R5 + ST R2 + ST R7 ;This will clear text buf + SUB R0 ;Zero Acc + SET R1,XBE00 ;Point @ curr PN + STI R1 ;Store a zero byte @ $BE00 + LDD R2 ;Were we editing a text file? + BNZ LD52F ;Yes + POPD R2 ;Load the double zero @ (Reg5) into ACC + DCR R0 + STD R2 ;Store $FFFF there +LD52F RTN + JMP XB1CB +;================================================= +; Print cmd +; +LD533 RTN + LDA #$FF + STA PrintF + JSR NEWSW16 + BRL LD631 +;================================================= +; +LD53E JSR NEWSW16 +LD541 SET R9,XB448 ;Invalid parm + BRL LD33F +;================================================= +; COLumn cmd +; +LD547 LD R11 ;Get parm into SW16 Acc + RTN + LDA Reg0 + LDX #0 + CMP #40 + BEQ LD558 + CMP #80 + BNE LD53E + JSR LA75B ;Chk if 80-col card present +; +; On fall thru (X)=$C3 if there is an 80-col card +; No 80-col card if (X)=0 +; +LD558 LDA DevCtlS ;Get slot # + BEQ LD561 + CMP #$03 ;ext 80-col card? + BNE LD567 ;No +; +LD561 TXA + AND #$0F + STA DevCtlS +; +LD567 JSR LA78A ;Reset I/O hooks + JMP XB1CB +;================================================= +; MON cmd +; +LD56D RTN + LDA #$4C + STA USRADR + LDA #>XB198 + STA USRADR+1 + LDA #= + CPR R11 ; start line #? + BC LD600 ;Yes + SET R1,100 ;Chk for relative range + CPR R1 ;Is it >= 100? + BC LD60D ;Yes, err + DCR R0 ;Is it zero? + BM1 LD60D ;Yes, err + ADD R11 + ST R8 ;End line # +LD600 RTN +; + JSR LD4D3 ;Get start addr into (Reg9) +LD604 JSR NEWSW16 + LD R9 ;Is addr >= TxtEnd? + CPR R7 + BC LD5D7 ;Yes, ignore this range + RTN + RTS +; +LD60D BRL LD4CD +;================================================= +; Init the Printer +; +LD610 EQU * ;ENTRY + LDA DevCtlS ;Slot # (1-7) + BEQ LD61D + ORA #$C0 + STA CSWL+1 + LDA #$00 + STA CSWL +; +LD61D LDY #1 +LD61F INY + LDA DevCtlS,Y + BEQ LD62E + LDA DevCtlS,Y + JSR XB343 + JMP LD61F +LD62E JMP XB339 ;Output CR and back to caller +;================================================= +; List cmd +; The following are valid +; List 3 +; List 10- +; List 1,3,4-5 +; List 10-2 +; +LD631 INR R5 ;TxtBgn + INR R5 + POPD R5 + BNZ LD639 ;There is a txt file + BRL LD6EC +; +; This will start the listing of a range of lines +; +LD639 RTN + JSR XB339 ;Do a cr + JSR LD5D4 ;Get line # range +; +; Print lines loop +; +LD640 JSR LDD2E ;Chk for a keypress + JSR LD346 ;Print line + JSR NEWSW16 + LD R11 ;Curr line # + INR R11 + CPR R8 ;Ending line # + BC LD639 + LD R9 ;Curr location + CPR R7 ;TxtEnd + BC LD639 + RTN + JMP LD640 +;================================================= +; Insert cmd +; Input +; (Reg11) - line # +; +LD656 RTN +; +LD657 JSR LD4D3 ;Get addr of line +LD65A JSR LD44C ;Get input line + JSR LD663 ;Insert into txtbuf + JMP LD65A +; +; Input +; Reg1 - Point @ location (within InBuf) to be copied +; Reg9 - Point @ location within txtbuf where +; text is to be inserted +; Reg2 - # of bytes to copy/insert +; +LD663 JSR LD672 ;Move rest of txt up in mem + JSR NEWSW16 + ST R7 ;new TxtEnd + INR R9 ;Point @ dest +LD66B LDI R1 ;Move chars fr InBuf + STI R9 ; to txtbuf + DCR R2 ;decr len + BNZ LD66B + RTN + RTS +;================================================= +; Create room for insertion +; +LD672 JSR NEWSW16 + INR R2 ;input len/# of bytes of copy + LD R7 ;Save old TxtEnd + ST R10 + ADD R2 + CPR R6 ;HiMem + BNC LD67F + BRL LD446 ;Out of mem +LD67F ST R7 ;new TxtEnd (dest) + DCR R9 + RTN + JMP LD691 ;Make room for new line(s) +;================================================= +; Copy chars to the space created +; +LD685 JSR NEWSW16 + ST R7 ;TxtEnd + INR R9 ;addr of dest line +LD68A LDI R1 ;Get char and + STI R9 ; store it + DCR R2 ;Are we done? + BNZ LD68A ;No + RTN + RTS +;================================================= +; Move contents of file up in mem +; Input +; Reg7 - dest +; Reg9 - BO src-1 +; Reg10 - src +; +LD691 LDY #0 + LDA (Reg10),Y + STA (Reg7),Y + LDA Reg7 + BNE LD69D + DEC Reg7+1 +LD69D DEC Reg7 +; + LDY Reg10+1 + LDX Reg10 + BNE LD6A6 + DEY +LD6A6 DEX + STX Reg10 + STY Reg10+1 +; + CPY Reg9+1 ;Are we done? + BEQ LD6B1 + BCS LD691 +LD6B1 CPX Reg9 + BEQ LD6B7 + BCS LD691 ;No +LD6B7 RTS +; +LD6B8 BRL LD33C ;err +;================================================= +; Del cmd +; More than an interval of line #s are accepted +; with the cmd but it's not recommended +; +LD6BB RTN +LD6BC JSR LD6C2 + JMP LD6BC ;Proceed to do another interval +; +LD6C2 JSR LD5D4 ;Get line #/line interval + JSR NEWSW16 + LD R9 ;Get addr of start line # + ST R10 ; which is the dest addr + LD R8 ;End line # + ST R11 + INR R11 ;Go past this line + BZ LD6B8 ; cannot be -1 + RTN + JSR LD4D3 ;Get its addr (src addr) + JMP L9C57 ;Move (txtbuf) down +;================================================= +; Replace cmd - equivalent to type Del followed +; by an Insert +; +LD6D6 LDD R12 ;Get start line # + BNZ LD6DA + INR R0 ;If 0, make it 1 +LD6DA ST R4 ;Save for Insert + POPD R12 ;Backup to BO buf @ $BD00 + RTN + JSR LD6C2 ;Perform a Del + JSR NEWSW16 + LD R4 + ST R11 + RTN + JMP LD657 +; +LD6E9 BRL LD446 +;================================================= +; FILE cmd +; Called by SAVE on an empty txtbuf +; and List after an XLOAD +; +LD6EC RTN + JSR XB339 + JSR LA04E ;Print filename + JSR NEWSW16 + LD R7 ;Is txtbuf empty? + SUB R5 + BZ LD6FB ;Yes + INR R0 +LD6FB ST R11 ;# of bytes used + SET R9,L9ED6 + RTN + JSR LD481 +; + JSR NEWSW16 + LD R6 ;Compute # of bytes free + SUB R7 ;=HiMem-TxtEnd + ST R11 + SET R9,L9EE1 + RTN + JSR LD481 +; + LDY #1 + LDA (Reg5),Y ;Is it a txtfile? + BNE LD768 ;Yes + JSR NEWSW16 + SET R0,$0006 + ADD R5 ;Compute # of bytes + ST R1 + LD R7 ; used as non-text data + INR R0 + SUB R1 + ST R11 + SET R9,L9EF1 + RTN + JSR LD481 +; + LDA #SPACE + JSR XB343 + LDY #$03 + LDA (Reg5),Y ;Is there an ASCII + JSR LA440 ; representation? + BNE LD74C ;No + DEY + DEY + JSR L9C3C ;Yes, print 3 chars + JSR L9C3C + JSR L9C3C + JSR NEWSW16 + SET R9,L9F0D ;Get msg ptr + RTN + JSR LD484 ; and print msg +LD74C LDA #'$' + JSR XB343 + LDY #5 ;Get load addr + LDA (Reg5),Y + JSR L9C43 + DEY + LDA (Reg5),Y + JSR L9C43 + JSR NEWSW16 + SET R9,L9F21 + RTN + JSR LD484 +LD768 JMP XB1CB +;================================================= +; SWAP cmd +; 1) Whether there are two files being edited or not, +; file buf1 will always start @ $801. +; 2) When file1 is edited, file2 will be stored +; downwards fr HiMem ($9900). +; 3) When file2 is edited, file1 will remain where +; it is. File2 will be moved to 1 mempage above +; the TxtEnd of file1. +; 4) When a SWAP cmd is issued and file buf1 is empty +; file2 becomes file1. +; +; Input +; (SwapMode)-split-buf mode 0,1,2 +; $B9EE-$BA32 - save area for file 1 +; $BA33-$BA7B - save area for file 2 +; The first four bytes of each area are the +; TxtBgn/TxtEnd of the respective files +; The next 65-byte are are their corr. filenames +; $BE00 - name of file currently being edited +; +LD76B SET R1,XB9EE + SET R2,SwapMode + LDI R2 ;Get split-buf mode byte @ SwapMode + DCR R0 + DCR R0 + BNZ LD779 ;Buf1 was used/Non-split buf + SET R1,XBA33 ;Buf2 was used +; +LD779 LD R5 ;Get ptrs in (TxtBgn) + STD R1 ; & (TxtEnd) and + LD R7 + STD R1 ; save'em @ $B9EE/$BA33 (4 bytes) + SET R2,XBE00 ;Point @ curr pathname +LD780 LDI R2 ;Save pathname to 65-byte + STI R1 ; buf @ $B9F2/$BA37 + BNZ LD780 ;Not EO PN yet + RTN +; + LDA SwapMode ;Were we + CMP #$01 ; editing file1? + BEQ LD7B1 ;Yes + BCS LD7E6 ;No, file2 + LDA #$00 ;We had a non-split buf + STA XBE00 ; -> new file2 + JSR LD798 + JMP XB1CB +;================================================= +; Create a new file in txtbuf2 +; Or swapping in txtbuf2 +; +LD798 LDY #2 + STY SwapMode ;Flag it +LD79C INC Reg7+1 ;Set BO txtbuf2 + LDY Reg7+1 ; to 1 mem page + STY Reg5+1 ; above txtbuf1 + LDY #0 + STY Reg5 + STY Reg7 + LDA #CR + STA (Reg5),Y ;Mark BOF w/cr + INC Reg5 + INC Reg7 + RTS +; +; File1 is currently edited. We are swapping in +; txtbuf2. +; +LD7B1 LDA Reg5 ;Is buf1 empty? + LDX #$02 + CMP Reg7 + BNE LD7C1 + LDA Reg5+1 + CMP Reg7+1 + BNE LD7C1 ;No -> swap in txtbuf2 +; +LD7BF LDX #0 ;No swapping since buf1 is empty +LD7C1 JSR LD79C + STX SwapMode + JSR NEWSW16 + SET R3,XBA33 + LDD R3 ;BO txtbuf2 + ST R9 + LDD R3 + ST R6 ;HiMem of txtbuf2 + DCR R0 + ST R7 ;EO txtbuf2 + LD R5 ;New TxtBgn of txtbuf2 + ST R10 ;Dest addr of txtbuf2 + RTN + JSR L9C57 ;Move contents of txtbuf2 +; + JSR NEWSW16 +LD7DB SET R2,XBE00 ;Copy PN to +LD7DE LDI R3 ; currPN buf + STI R2 + BNZ LD7DE + RTN + JMP XB1CB +; +; Swap in txtbuf1 +; +LD7E6 JSR NEWSW16 + LD R5 ;TxtBgn + ST R9 + DCR R9 + LD R7 ;TxtEnd + ST R10 + LD R6 ;HiMem + ST R7 + DCR R7 + RTN +; + JSR LD691 + JSR NEWSW16 + SET R2,XBA33 + INR R7 ;Now BOF + LD R7 + STD R2 + LD R6 ;HiMem + STD R2 + RTN +; + LDY Reg7+1 + DEY + STY Reg6+1 ;HiMem of txtbuf1 + LDY #$01 + STY SwapMode ;editing txtbuf1 + DEY + STY Reg6 ;=0 +; +LD80D JSR NEWSW16 + SET R3,XB9EE ;txtbuf1 + LDD R3 + ST R5 ;TxtBgn + LDD R3 + ST R7 ;TxtEnd + BR LD7DB +;================================================= +; COpy cmd +; The dest line must not fall between first line +; and last line +; 2 cases: +; 1) Dest line is before 1st line +; 2) Dest line is after 1st line +; +LD819 LDD R12 ;Get 1st line # + ST R11 + RTN + JSR LD4D3 ;Get its addr + JSR NEWSW16 + LD R9 + CPR R7 ;Is it > TxtEnd? + BC LD82E ;Yes + ST R8 + LDD R12 ;Is there a last line #? + BNZ LD82B ;Yes + LD R11 ;Copying 1 line +LD82B CPR R11 + BC LD831 +LD82E BRL LD4CD ;Range err +; +LD831 ST R11 ;last line # + INR R11 ;Next line + RTN +; + JSR LD4D3 ;Get addr of next line + JSR NEWSW16 + LD R9 + ST R3 + SUB R8 + ST R10 ;# of chars to copy +LD83E LDD R12 ;Get dest line # + ST R11 + RTN + JSR LD4D3 ;Get its addr + JSR NEWSW16 + LD R9 ;Ensure addr of destline is not + CPR R3 ; within addr of lastline+1 + BZ LD852 + BC LD852 + CPR R8 ; and addr of firstline + BZ LD852 + BC LD82E ;Err +; +; R9 - addr of destline (set by above code) +; R1 and R2 must be set properly +; before the rtns below are called +; R1 - src addr of copy +; R2 - # of bytes to move +; +LD852 LD R8 ;Is addr of 1stline + CPR R9 ; < addr of destline? + BNC LD857 ;Yes (case 2) + ADD R10 +LD857 ST R1 + LD R10 ;# of chars to copy + ST R2 + DCR R2 + RTN + JSR LD672 ;Create room in txtbuf + JSR LD685 ; before doing the copy + JMP XB1CB +;================================================= +; Find cmd +; +LD865 RTN + JSR LD5D4 ;Get line #/line interval +LD869 JSR LD87A ;Search + JSR LD346 ;Print the line + JSR NEWSW16 + INR R11 + RTN + JSR LDD2E ;If ctrl-C, don't come back + JMP LD869 ;Next line +;================================================= +; Search for a line which has a match within +; current interval of line #s. It will return +; to caller if a match is encountered. Otherwise +; control will be transferred back to EI @ $B1CB +; Output +; Reg2 - addr where a subsequent search will begin +; Reg9 - addr of line which has a match +; Reg4 - start addr of matched str +; Reg11- curr line # +; +LD87A JSR NEWSW16 +LD87D SET R3,CR + SET R10,XBD80 ;Ptr to search string + SET R2,CTRLA ;Wild card char + LD R9 ;Get start addr of search + ST R4 ; & save it here + CPR R7 ;Are we @ eo txtbuf? (TxtEnd) + BC LD8AF ;Yes, done w/this interval + LD R8 ;Is end line # + CPR R11 ; < curr line #? + BNC LD8AF ;Yes, done +; +LD88F LDI R10 ;Get char fr parm string + BZ LD8B6 ;eos -> complete match + ST R1 ;Save char + LDI R9 ;Get char fr line + CPR R3 ;Is it a CR? + BNZ LD8A3 ;No + INR R11 ;Next line of text + RTN +; + LDA KBD + CMP #CTRLC+$80 + BNE LD87A + JMP LDD2E ;Don't come back +; +LD8A3 CPR R1 ;Compare against char fr parm string + BZ LD88F ;Match, try next pair of chars + LD R1 ;Get back char + CPR R2 ;Is it the wild card? + BZ LD88F ;Considered a match +; + LD R4 ;Restore start + ST R9 ; addr of search + INR R9 ;Move search addr forward by 1 + BR LD87D +; +LD8AF RTN + JSR LD5D4 ;Is there another line interval? + JMP LD87A ;Yes +; +LD8B6 LD R9 ;Got a hit + ST R2 ;Save for a later search + RTN +; +; Now we search for the start addr of the line +; containing the matched string +; +LD8B9 JSR NEWSW16 + SET R3,CR +LD8BF POP R9 ;Move back until + CPR R3 ; CR is found + BNZ LD8BF + INR R9 ;Point @ 1st char of line + RTN + RTS +;================================================= +; Change cmd +; Like Find, this cmd accepts several line # +; intervals. There must be an oldstr at least 1 +; char long +; (Z62)=vert Tab +; (Z63)=msb off (All) +; (Z67)- +; +LD8C6 SET R10,XBD80 + LDI R10 ;Is there an oldstr? + BNZ LD8CF + BRL LD337 ;No, err +; +LD8CF SET R9,XB45B ;'All or Some' msg + RTN + JSR LD484 ;Print it + JMP LD8DC +; +LD8D9 JSR XB375 ;Ring... +LD8DC JSR LDD37 ;Get key + CMP #'S' + BEQ LD8E8 + CMP #'A' + BNE LD8D9 ;Try again + CLC +LD8E8 ROR Z63 ;msb=0 if All + JSR LD5D4 ;Get line # interval + LDX CV + CPX #23 + BCC LD8F4 + DEX +LD8F4 STX Z62 + LDA #$FF + STA Z67 + BNE LD8FC ;always +LD8FB EQU *-1 ;RTN +; +LD8FC JSR LD87A ;Do we have a line w/a match? + JSR NEWSW16 ;Yes + SET R1,InBuf +LD905 LD R9 ;Are we pointing @ + CPR R4 ; the matched str? + BZ LD90D + LDI R9 ;No, copy char to + STI R1 ; the InBuf + BR LD905 +; +; Reg10-Pointing @ replacement str +; A replacement string can contain "nothing" +; In which case, the matched str will be +; deleted from the line +; +LD90D LDI R10 ;Do we have a replacement str? + BZ LD913 ;No + STI R1 ;Copy it to InBuf until EO +LD911 BR LD90D ; replacement str encountered +; +LD913 LD R1 ;Point 1 past repstr within InBuf + ST R10 ;Save for later +LD915 LDI R2 ;Now copy rest of line + STI R1 ; to InBuf +LD917 CPR R3 ;=CR + BNZ LD915 +; + SET R9,InBuf + INR R4 ;Point 1 past addr of matched str + LD R4 ;Load ptr into SW16 ACC + SET R1,Z7E + STD R1 ;(Z7E)-point @ 1 past matched str + LD R10 + STD R1 ;(Z80)-point @ 1 past repstr + RTN +; + LDA CV + PHA + JSR LDB28 ;Display modified text line + PLA + CMP CV + BCS LD933 + STA Z62 +LD933 JSR NEWSW16 + SET R1,Z7E + LDD R1 + ST R9 ;=(Z7E) + LDD R1 + ST R10 ;=(Z80) + RTN + BIT Z63 ;Rep All? + BPL LD95A ;Yes +; +LD942 JSR LD972 ;Prompt for Y/N + CMP #CTRLC + BNE LD94C + JMP XB1CB ;Abort +LD94C CMP #'Y' + BEQ LD95A + CMP #'N' + BEQ LD8FC + JSR XB375 ;Ring... + JMP LD942 +; +; Replace the old line +; +LD95A JSR LD8B9 ;Point @ BOL w/matched str + JSR NEWSW16 + LD R10 ;Compute len of substr + SET R10,InBuf + SUB R10 ; w/rep str @ its end + ADD R9 ;Compute addr where to + ST R4 ; start next search + RTN + JSR LDAEE + JSR NEWSW16 + LD R4 + ST R9 + BR LD8FB ;Continue search and replace +;================================================= +; Display 'Y/N' and get user's response +; +LD972 LDA #'Y' + JSR XB343 + LDA #'/' + JSR XB343 + LDA #'N' + JSR XB343 + JSR LDD37 ;Getkey + PHA + JSR LD990 ;Do BS thrice + JSR XB37F ;Print a space + JSR LD990 + PLA + RTS +; +LD990 LDA #BS+$80 + JSR XB343 + JSR XB343 + JMP XB343 +;================================================= +; Copy pathname fr $BD80 buf to Curr filename buf +; including the terminating 0 +; +LD99B SET R2,XBD80 + SET R10,XBE00 +LD9A1 LDI R2 ;Get 1 byte at a time + STI R10 ; and store it + BNZ LD9A1 ;Not null-terminator yet + RS +;================================================= +; Append cmd +; A optional line # may precede the pathname +; +LD9A6 SET R4,XBD80 ;Set to PN + LDD R12 ;Was a line # issued w/cmd? + BNZ LD9BF ;Yes + SET R0,$FFFF ;Append to EO txtbuf + BR LD9BF +; +; Load cmd-equivalent to an APPEND cmd +; with line #1 +; +LD9B1 SET R12,XBA78 ;Useless instr + BS LD99B ;Copy PN to curr PN buf + SET R12,XBD00 ;Not used + SET R0,$0001 ;Replace all lines from line #1 + SET R4,XBE00 ;Ptr to Curr PN buf +; +; Code common to Append & Load +; If (Reg11) = -1($FFFF) => Append @ EO text buf +; = 1 => Load cmd +; Any other value in (Reg11) is treated as a +; line #. The Editor first deletes that line and +; all lines that follow it in the text buffer +; then appends the contents of the specified +; text file +; +LD9BF ST R11 ;=$FFFF,$0001,line # + RTN + JSR LD4D3 ;Get start addr of the line + LDX #TXTtype +LD9C6 JSR LoadFile ;Also called by XLOAD + BCS LD9E6 ;Read errs +; +LD9CB LDA XBA8A ;Load addr + CLC + ADC XBA8E ;# of bytes actually read + TAX + LDA XBA8A+1 + ADC XBA8E+1 + TAY + TXA + BNE LD9DE + DEY +LD9DE DEX + STX Reg7 ;Last byte of + STY Reg7+1 ; file's data in mem + JMP XB1CB +LD9E6 JMP XB602 +;================================================= +; $D9E9 +; Input +; Reg9 - Load addr +; Reg6 - Top of free space (HiMem) +; +LoadFile EQU * + LDA Reg9 ;Load addr + STA XBA8A ; is the Data buf + LDA Reg9+1 + STA XBA8A+1 + SEC + LDA Reg6 ;HiMem (=$9900) + SBC Reg9 + STA XBA8C ;# of bytes to read + LDA Reg6+1 + SBC Reg9+1 + STA XBA8C+1 + TXA ;ftype + JMP XB937 ;Open and Read the file +;================================================= +; SAVE cmd +; Save an entire text file or a range of lines +; Input +; Reg7 (TxtEnd) - Point to last char of file in mem +; Reg5 (TxtBgn) - Point to 1st char of file +; $BD80 - buffer containing filename +; +LDA06 LD R7 ;Do we have an empty + CPR R5 ; edit buffer? + BNZ LDA0D ;No + BRL LD6EC +; +LDA0D SET R10,XBD80 + SET R12,XBA78 ;Set SW16 subrtn ret addr stack + LDI R10 ;Did user include a filename? + BZ LDA18 ;No + BS LD99B +; +LDA18 SET R12,XBD00 ;Point @ line range + SET R4,XBE00 + RTN + LDA XBE00 ;Is there an old PN? + BNE LDA2D ;Yes +; + JSR NEWSW16 + SET R9,XB40A ;missing FN/PN + BRL LD33F +; +LDA2D LDY #0 + LDA (Reg12),Y ;Did user specify a + INY + ORA (Reg12),Y ; start line #? + BNE LDA45 ;Yes + INY + LDA (Reg12),Y ;Ending line #? + BEQ LDA45 +; + JSR NEWSW16 + LD R5 ;TxtBgn + ST R10 + LD R7 ;TxtEnd + ST R9 + INR R9 + BR LDA59 +; +LDA45 JSR LD5D4 + JSR NEWSW16 + LD R9 ;Addr of line + ST R10 + LD R8 ;Ending line # + ST R11 + BM1 LDA52 + INR R11 +LDA52 RTN +; + JSR LD4D3 + JSR NEWSW16 +; +LDA59 LD R9 ;Addr of line + SUB R10 + ST R9 ;# of bytes to write + RTN + LDA #TXTtype + JSR LDA65 +LDA62 JMP XB1CB +;================================================= +; Input +; (A)=ftype +; (Reg4) - Ptr to PN +; (Reg9) - # of bytes to write +; (Reg10) - Ptr to Data buf +; +LDA65 JSR XB883 ;Is the file there? + BCS LDA6F ;No + BEQ LDA9F ;Yes and ftype is correct + JMP XB602 ;Err +; +; The file must be created first since it does not exist +; +LDA6F LDA XBAC8 + STA XBAE8 ;Ptr to PN + LDA XBAC8+1 + STA XBAE8+1 + LDA FileType + STA XBAEB + LDA #$C3 + STA XBAEA ;Access bits + LDA #$00 + STA XBAEC ;auxtype + STA XBAEC+1 + JSR XB919 ;Create file + BEQ LDA95 + JMP XB602 ;Err +; +LDA95 LDX #>XA900 + LDY #XA900 + LDY # both str have same len + DCR R1 + LD R1 ;Get addr of rest of InBuf to + ST R10 ; copy & save it here + SET R2,$FFFE ;-2 +LDB0D LDI R10 ;Get next char fr InBuf + INR R2 + CPR R3 ;Is a CR? + BNZ LDB0D ;No, keep looking + RTN + JMP LD663 ;Insert rest of InBuf into txtbuf +; +; Modified line is shorter +; +LDB16 LD R9 ;Get addr of rest of oldline + ST R10 ; to overwrite & save it here (dest) +LDB18 LDI R9 ;Get char fr old line + CPR R3 ;Is it a CR? + BNZ LDB18 ;No + DCR R9 ;Now pointing @ CR of oldline (src) + RTN + JSR L9C57 ;Move rest of txtbuf down + JSR NEWSW16 + LD R10 + ST R9 ;Addr where next search will continue +LDB26 RTN + RTS +;================================================= +LDB28 LDA Reg11 ;Curr line # + CMP Z66 ;??? + STA Z66 + BEQ LDB37 + LDA Reg11+1 +LDB32 STA Z66+1 + JMP LDB42 +; +LDB37 LDA Reg11+1 + CMP Z66+1 + BNE LDB32 + LDA Z62 + JSR LDB4A +LDB42 LDA #$1D ;ctrl-] (clrEOL) + JSR XB343 + JMP LD346 ;Print line +; +LDB4A STA CV + JSR XB36B ;Do a VTab + LDA #$00 + STA PrColumn ;char posn + RTS +;================================================= +; Edit cmd +; The cmd Edit begin#-end#.string. can be used +; to modify those lines within an interval of +; lines with the specified search string. +; If no search string included, then it is +; assumed a null string is passed. +; +LDB54 RTN + JSR LD5D4 ;Get line # interval +LDB58 JSR LD87A ;Get a line to edit, search if necessary + LDA TruncF + STA Z7A + LDA #$FF + STA TruncF + JSR LDB73 + LDA Z7A + STA TruncF + JSR NEWSW16 + INR R11 + INR R9 + RTN + JMP LDB58 +;================================================= +; Input +; (Reg9)-addr of line to be edited +; +LDB73 LDA #$FF + STA Z67 + LDA PrColumn + BEQ LDB81 + JSR XB339 ;Do a CR + JMP LDB73 +; +LDB81 LDA CV + STA Z62 + CMP #21 + BCC LDB98 + LDA #23 + JSR LDB4A + JSR XB339 + LDA #21 + STA Z62 + JSR LDB4A +; +LDB98 JSR NEWSW16 + SET R1,InBuf + SET R2,CR + LD R9 ;Get addr of line + ST R3 +LDBA3 LDI R3 ;Move (line) including + STI R1 ; CR to InBuf + CPR R2 + BNZ LDBA3 + RTN +; + LDA Reg9 ;Save line's addr + PHA + LDA Reg9+1 + PHA + JSR LDBBD ;Edit the line + PLA + STA Reg9+1 + PLA + STA Reg9 + BCS LDB98 ;Line was not changed + JMP LDAEE ;Save changes to txtbuf +;================================================= +; Edit the line +; Output +; C=0 - line was modified +; +LDBBD LDY #$00 + STY Z65 + STY Z64 +LDBC3 LDA #>InBuf + STA Reg9 + LDA #X2000 + STA XBA8A ;Data buf/Load addr + LDA # ctrl-S +; Z=1,C=1 -> ctrl-C +; Z=0,C=0 -> any other key +; +KeyPress LDA KBD + BPL LDD2C + CMP #CTRLS+$80 + BEQ LDD2C ;Z=1 + BIT KBDSTROBE + CMP #CTRLC+$80 + BNE LDD23 + SEC + RTS +; +LDD23 CMP #SPACE+$80 ;Single-step? + BNE LDD2C +LDD27 LDA KBD ;Wait for another + BPL LDD27 ; key press +LDD2C CLC + RTS +;================================================= +; Chk for a ctrl-C +; +LDD2E JSR KeyPress + BCS LDD34 ;ctrl-C + RTS +LDD34 JMP LDCA9 +;================================================= +LDD37 JSR LA614 ;Get char fr user's input key rtn + CMP #$60 + BCC LDD40 + AND #$5F ;To ucase +LDD40 RTS +;================================================= +; Init tab table +; +LDD41 EQU * ;ENTRY + LDA #$00 + STA SwapMode + STA XBE00 ;Curr PN + LDY #10 +LDD4A LDA DefTabsT,Y ;Only 3 are set + CPY #3 + BCC LDD53 + LDA #0 ;Zero the rest +LDD53 STA UserTabT,Y + DEY + BPL LDD4A +; + LDA #SPACE + STA TabChar + RTS +;================================================= +; PR# cmd +; Parsed parms are in $BD00 buf +; +LDD5E RTN + LDY #1 + LDX XBD00 ;Get Slot # + STX Z59 + BEQ LDD8C ;slot 0 + CPX #8 + BCS LDD99 ;slot > 7 +; + LDA #%00000010 +LDD6E DEX + BEQ LDD74 + ASL + BNE LDD6E +LDD74 BIT SLTBYT + BEQ LDD99 ;Invalid +; + LDA XBD00,Y + STA DevCtlS,Y +LDD7F INY + CPY #33 + BEQ LDD8C + LDA XBD00,Y + STA DevCtlS,Y + BNE LDD7F +; +LDD8C LDA #0 ;Set delimiter + STA DevCtlS,Y ; to mark EOS + LDX Z59 + STX DevCtlS + JMP XB1CB +LDD99 JMP LD53E +;================================================= +; Tabs cmd +; Input +; Reg12-ptr to $BD00 buf +; +LDD9C SET R9,UserTabT + LD R9 + ST R2 + SET R8,10 ;Up to 10 tab cols + LD R8 + ST R10 + SUB R0 ;zero ACC +; +LDDA7 STI R9 ;Zero the table first + DCR R8 + BNZ LDDA7 +; +LDDAB LDD R12 ;Get tab posn (stored as a 16-bit val) + BM LDDB3 ;If $FFFF, EO list + STI R2 ;Save to UserTabT + LDI R12 + DCR R10 + BNZ LDDAB +LDDB3 RTN +; + LDA XBD80 ;Is a tab char passed? + BEQ LDDBB ;No + STA TabChar +LDDBB JMP XB1CB +; +DefTabsT DB $10 ;16,22,36 + DB $16 + DB $24 +;================================================= +; TYPE cmd +; The command interpreter's ChkAttrF ($B883) +; rtn expects a ptr to pathname to be stored +; at Reg4 +; +LDDC1 SET R4,XBD80 ;Set ptr to PN + RTN + LDA #TXTtype + JSR XB883 ;Chk file's properties + BCC LDDCF +LDDCC JMP XB602 ;Not found, show errmsg +; +LDDCF BNE LDDCC ;Wrong filetype -> err +; + LDX #>XA900 ;1024-byte I/O buf + LDY # yes +; + LDY #0 +LDDF5 LDA XBD00,Y ;Get a char fr buf + JSR XB343 ;Show it + INY + CPY L9F48 + BCC LDDF5 +LDE01 BCS LDDE9 ;always +; +LDE03 LDA #$4C ;EOF err +LDE05 LDX L9F43 + STX XBAF7 ;Close Ref # + JSR XB8FE ;Close file + CMP #$4C + BEQ LDE15 + JMP XB602 ;Report err +LDE15 JMP XB1AB ;Back to EI Main loop +;================================================= +; Editor's Cmd table - used by $B20F +; + MSB ON +LDE18 EQU * ;ENTRY + DB $00 + ASC "ASM" + DB $0A ;Index into $9D21 table + ASC "," ;comma + DB $0C ;->$9D21 + DB $00 ;->$9D21 (Chk for a CR) + DB $00 ;Not used to index $DFA2 + ASC "APPEND" + DB $10 + DB $0A + DB $00 + DB $30 ;->$DFA2 + ASC "Add" + DB $10 ;->$9D21 + DB $00 ;->$9D21 + DB $02 ;->$DFA2 table + ASC "BLOAD" + DB $0A ;->$9D21 table + ASC "," + DB $22 ;->$9D21 table + DB $00 + DB $24 ;->$DFA2 table + ASC "BSAVE" + DB $0A + ASC "," + DB $22 + ASC "," + DB $24 + DB $00 + DB $4E + ASC "CATALOG" + DB $12 + DB $00 + DB $50 + ASC "CAT" + DB $12 + DB $00 + DB $0E + ASC "COLumn" + DB $16 + DB $00 + DB $44 + ASC "COpy" + DB $02 + ASC "-" + DB $10 + ASC "TO" + DB $02 + DB $00 + DB $22 + ASC "CREATE" + DB $0A + DB $00 + DB $5A + ASC "Change" + DB $04 + DB $08 + DB $00 + DB $28 + ASC "DELETE" + DB $0A + DB $00 + DB $08 + ASC "Del" + DB $04 + DB $00 + DB $16 + ASC "END" + DB $00 + DB $5C + ASC "EXIT" + DB $12 + DB $00 + DB $4C + ASC "EXEC" + DB $0A + DB $00 + DB $52 + ASC "Edit" + DB $04 + DB $06 + DB $00 + DB $2E + ASC "FILE" + DB $00 + DB $34 + ASC "Find" + DB $04 + DB $06 + DB $00 + DB $2A + ASC "Insert" + DB $02 + DB $00 + DB $14 + ASC "KILL2" + DB $00 + DB $1A + ASC "LOaD" + DB $0A + DB $00 + DB $10 + ASC "LOCK" + DB $0A + DB $00 + DB $0A + ASC "List" + DB $04 ;->$9D21 + DB $00 + DB $26 ;->$DFA2 + ASC "MON" + DB $00 + DB $04 + ASC "NEW" + DB $00 + DB $1C + ASC "Online" + DB $00 ;Chk for CR + DB $4A ;->$DFA2 + ASC "PR#" + DB $16 + ASC "," + DB $0E + DB $00 + DB $36 + ASC "PreFiX" + DB $12 + DB $00 + DB $06 + ASC "PTRON" + DB $00 + DB $46 + ASC "PTROFF" + DB $00 + DB $48 + ASC "Print" + DB $04 + DB $00 + DB $2C + ASC "RENAME" + DB $1A ;->$9D21 + ASC "," + DB $1C ;->$9D21 + DB $00 + DB $20 ;->$DFA2 + ASC "Replace" + DB $04 + DB $00 + DB $32 + ASC "SETDelim" + DB $18 + DB $00 + DB $38 + ASC "SETLcase" + DB $00 + DB $3A + ASC "SETUcase" + DB $00 + DB $3C + ASC "SWAP" + DB $00 + DB $18 + ASC "SaVE" + DB $04 + DB $12 + DB $00 + DB $12 + ASC "TYPE" + DB $0A + DB $00 + DB $58 + ASC "TRuncOFf" + DB $00 + DB $3E + ASC "TRuncON" + DB $00 + DB $40 + ASC "Tabs" + DB $04 + DB $06 + DB $00 + DB $1E + ASC "UNLOCK" + DB $0A + DB $00 + DB $0C + ASC "Where" + DB $02 + DB $00 + DB $42 + ASC "XLOAD" + DB $0A + ASC "," + DB $26 + DB $00 + DB $54 + ASC "XSAVE" + DB $0A + ASC "," + DB $1E ;->$9D21(A$) + ASC "," + DB $20 ;->$9D21 (L$) + DB $00 + DB $56 ;->$DFA2 + DB $28 ;What's this + MSB OFF +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; These are the entry points for the various +; SW16 routines utilised by the EI ($B659-B6A3) +; The "JMP" takes place at $B6A3 where the +; SW16 PC is set with the contents of R2 register +; R2 was previously set by EI code at $B680-$B68C +; +LDFA2 EQU * + DW LD33C-1 ;0 + DW LD410-1 ;2 + DW LD56D-1 ;4 + DW LA29E-1 ;6 + DW LD2C4-1 ;8 + DW LD287-1 ;A + DW LD282-1 ;C + DW LA077-1 ;E + DW LD9B1-1 ;10 + DW LDA06-1 ;12 + DW LD656-1 ;14 + DW LD6BB-1 ;16 + DW LD76B-1 ;18 + DW LD504-1 ;1A + DW LD521-1 ;1C + DW LDD9C-1 ;1E + DW LD308-1 ;20 + DW LD819-1 ;22 + DW L9BD6-1 ;24 + DW LD631-1 ;26 + DW LD8C6-1 ;28 + DW LD865-1 ;2A + DW LD533-1 ;2C + DW LDB54-1 ;2E + DW LD9A6-1 ;30 - Append + DW LD6D6-1 ;32 + DW LD6EC-1 ;34 + DW LDD5E-1 ;36 + DW LD5AD-1 ;38 + DW LD5CB-1 ;3A + DW LD5C2-1 ;3C + DW LD582-1 ;3E + DW LD58A-1 ;40 + DW LD58F-1 ;42 + DW LD547-1 ;44 + DW LA024-1 ;46 + DW LA049-1 ;48 + DW LA309-1 ;4A - Online + DW LDCC8-1 ;4C + DW L9BF9-1 ;4E + DW LA072-1 ;50 + DW XB9B0-1 ;52 + DW L9B19-1 ;54 + DW L9B6E-1 ;56 + DW LDDC1-1 ;58 + DW L9F4A-1 ;5A + DW $C8D3 ;5C - NOT USED? +; \ No newline at end of file diff --git a/EDASM.SRC/EDITOR/EDITOR3.S b/EDASM.SRC/EDITOR/EDITOR3.S new file mode 100644 index 0000000..3a5a2db --- /dev/null +++ b/EDASM.SRC/EDITOR/EDITOR3.S @@ -0,0 +1,2080 @@ +Name : EDITOR3.S +End of file : 34,353 +This file was generated using the DiskBrowser utility with minimal editing. +It is meant for viewing purposes only. + + ORG $9900 +; +; Parse cmd line for dec string +; Convert to a 16-bit unsigned val +; Stops process on a non-dec char +; +; Output +; C=0 - Conversion was done and +; (Reg11)=16-bit value +; C=1 - No conversion +; +L9900 LDA #0 + STA Reg11 + STA Reg11+1 + LDA Z12 ;Get char + JSR L996D ;Convert if dec digit + BCS L9958 ;Not dec + STA Reg11 + STA L996C +L9912 JSR XB274 ;Get next non-blank char + JSR L996D + BCS L9957 ;Not a dec digit +; + STA Reg4 ;(A)=0-9 + ORA L996C + STA L996C + LDA Reg11 + STA Reg0 + CMP #$98 ;Max val < 65520 + LDA Reg11+1 + STA Reg0+1 + SBC #$19 + BCS L99A5 ;Overflow +; + ROL Reg0 ;x4 + ROL Reg0+1 + ROL Reg0 + ROL Reg0+1 +; + LDA Reg0 ;x5 + CLC + ADC Reg11 + STA Reg11 + LDA Reg0+1 + ADC Reg11+1 + STA Reg11+1 + ROL Reg11 ;x2 + ROL Reg11+1 equi to mulby10 +; + CLC ;Add incoming digit + LDA Reg4 + ADC Reg11 + STA Reg11 + BCC L9954 + INC Reg11+1 +L9954 JMP L9912 ;Next digit +; +L9957 CLC +L9958 RTS +;================================================= +L9959 JSR L9900 ;Convert dec string + BCS L9964 + LDA L996C ;Was a string of 0's entered? + BEQ L9965 ;Yes + CLC +L9964 RTS +; +L9965 LDX #$58 ;Bad Line #/Range + PLA + PLA + JMP XB290 ;err msg +; +L996C DB $C0 ;Flag +;================================================= +; Input +; (A) char +; Output +; C=0 if decimal char and (A)= 0-9 +; C=1 not a decimal char +; +L996D CMP #'9'+1 ;Is char '0'-'9'? + BCS L9979 + CMP #'0' + BCC L9979 ;No + AND #$0F ; --> 0-9 + CLC + RTS +L9979 SEC + RTS +;================================================= +; Save (Reg11) into $BD00/$BD80 buf +; +L997B LDA Reg11 + JSR L9982 + LDA Reg11+1 +L9982 EQU * + LDY #0 + STA (Reg12),Y + INC Reg12 + BNE L998C + INC Reg12+1 +L998C RTS +;================================================= +; If there is no dec/hexdec str issued with cmd +; then ($BD00-$01)=$0000 +; +L998D JSR L9959 ;Convert & +L9990 JSR L997B ; store + DEX + JMP XB211 +; +L9997 JSR L9900 ;Convert dec string + JMP L99A0 ;Chk if parm is mandatory +; +L999D JSR L9959 ;Get mandatory dec # +L99A0 BCC L9990 ;Yes, proceed to store it +; +L99A2 LDX #$1C ;Parms omitted + DB $2C +L99A5 LDX #$0B +L99A7 JMP XB290 +;================================================= +L99AA JSR L99CD ;(Reg12)=ptr to $BD80 buf +; +L99AD JSR L9A18 ;Copy parm as it + JMP XB211 +;================================================= +L99B3 JSR L9A18 ;Copy 1st reqd parm + BCC L99A2 ;Err if not parm's not passed + JSR L9A1E ;Copy 2nd optional parm + JMP XB211 +;================================================= +L99BE LDA #CR ;Set CR to be + STA Z12 ; the end + DEX + LDY #33 + STY Z10 + JSR L9A22 ;Copy parm as is + JMP XB211 +;================================================= +; Output +; (Reg12) - ptr to $BD80 +; +L99CD LDA #>XBD80 ;SET R12,$BD80 + STA Reg12 + LDA #err + LDY #-1 ;Flag an interval + BMI L9A4B ;always +; +L9A70 LDA #-1 ;Store a couple of $FF + JSR L9982 ; to mark end of interval + JSR L9982 + DEX + JSR L99CD + JMP XB211 ;Continue parsing cmd line +;================================================= +; (Z12)-char +; Output +; (Z12) (A) +; , $FF +; - $00 +; CR $E0 +; +L9A7F JSR L997B ;Save Reg11 to buffer + LDA Z12 ;Get char + SEC + SBC #'-' + JMP L9982 +;================================================= +; Parse for L$/A$ parms +; +L9A8A LDA #'L' + BNE L9A93 ;always +L9A8E JSR L9AA5 + LDA #'A' +L9A93 CMP Z12 + BNE L9A9F + JSR XB274 + JSR L9AC4 + BCC L9AA2 +L9A9F JMP L99A2 +L9AA2 JMP L9990 +;================================================= +; Set ptr to buf for storing A$ and L$ 16-bit +; values which are separated by a 0 +; +L9AA5 EQU * ;ENTRY + LDA #>XBD00 + STA Reg12 ;SET R12,XBD00 + LDA # $3A-$3F + AND #$0F ; -> $0A-$0F +L9B15 CLC +L9B16 RTS +; +L9B17 SEC +L9B18 RTS +;================================================= +; XLOAD cmd +; This cmd is only valid if edit is not split +; +L9B19 RTN + JSR L9C4F ;Chk if swap is in effect + JSR NEWSW16 ;No +L9B20 SET R4,XBD80 ;Point @ PN + SET R0,$0006 + ADD R5 ;TxtBgn + ST R3 + ST R9 ;=TxtBgn+6 ($807) +L9B29 LDD R12 ;Is a Load addr specified? + BZ L9B36 ;No + CPR R9 ;Addr must not be < this + BNC L9B32 + CPR R6 ;Is it < HiMem? + BNC L9B35 ;Yes +L9B32 BRL LD541 ;Invalid parm err +; +L9B35 ST R9 ;=Specified LoadAdr +L9B36 LD R5 ;Ptr to TxtBgn ($801) + ST R2 + SUB R0 ;Zero ACC and + STD R2 ; locations $801-$802 + RTN + LDA #BINtype + JSR XB883 + BCC L9B45 + JMP XB602 +; +L9B45 LDY #5 +L9B47 LDA XBAC8,Y ;Copy Access bits, filetype + STA (Reg5),Y ; & auxtype to $803-$806 + DEY + CPY #1 + BNE L9B47 +; + LDX XBACB ;Is file of type TXT? + CPX #TXTtype + BEQ L9B60 ;Yes + CPX #$02 + BCC L9B60 + CPX #$0F ;DIRtype + BNE L9B65 +L9B60 LDA #$11 ;File type mismatch + JMP XB602 +; +L9B65 JSR NEWSW16 + LD R3 + ST R7 ;TxtEnd + RTN + JMP LD9C6 ;(X)=filetype -> go loadfile +;================================================= +; XSAVE cmd +; An XLOAD must precede an XSAVE; this cmd will not +; be executed if this rule is not obeyed. Internal +; control info will be properly setup by the +; XLOAD cmd. +; If no addr is specified, (Reg9) may not be +; computed correctly unless an XLOAD cmd is +; immediately followed by an XSAVE cmd. For +; this case, Reg5 and Reg7 must be set correctly +; For this multiple cmd (w/o A$, L$ parms) +; XLOAD : XSAVE +; to work correctly, Reg9 and Reg10 must +; be setup properly +; Reg12 - ptr to $BD00 buf +; +L9B6E SET R0,$0006 + ADD R5 ;TxtBgn + CPR R7 ;TxtEnd + BNZ L9B78 + BRL LD6EC ;Just do a FILE cmd +; +L9B78 SET R4,XBD80 ;Ptr to PN + ST R10 ;=TxtBgn+6 + LDD R12 ;Did user specify an addr? + BZ L9B89 ;No + ST R10 + LDD R12 ;Did user specify a len? + BNZ L9B86 ;Yes + BRL LD541 ;Invalid parm +; +L9B86 ST R9 + BR L9B8F +L9B89 LD R7 ;XLOAD should have set this + ST R9 ; correctly to last byte of + INR R9 ; file's data in mem + LD R9 ;Compute # of bytes + SUB R10 + ST R9 ; to write +L9B8F RTN +; + JSR L9C4F ;Must not have a split buf + LDY #0 + LDA (Reg5),Y ;Chk for a double zero + INY + ORA (Reg5),Y + BEQ L9BA1 ;Got 'em +L9B9C LDA #$11 + JMP XB602 +; +L9BA1 LDY #3 + LDA (Reg5),Y ;filetype + JSR LDA65 ;Write the file + LDA FileType +L9BAA JSR XB883 + LDY #3 +L9BAF LDA XBAD1,Y ;Date/Time + STA XBAE3,Y ; last mod + DEY + BPL L9BAF +; + LDY #2 +L9BBA LDA (Reg5),Y ;Copy access,filetype + STA XBADA,Y ;and auxtype @ $803-$806 + INY + CPY #6 + BCC L9BBA +; + LDA XBAC8 ;PN ptr + STA XBADA + LDA XBAC8+1 + STA XBADA+1 + JSR XB904 ;Set file's attrib + JMP XB1CB +;================================================= +; BLOAD cmd +; +L9BD6 RTN + JSR L9C4F + JSR NEWSW16 + SET R4,XBD80 ;Ptr to PN + LDD R12 ;Get load addr + CPR R5 ;Is it >= TxtBgn? + BC L9BE7 ;Yes +L9BE4 BRL LD541 +; +L9BE7 CPR R6 ;Is it >= HiMem? + BC L9BE4 ;Yes, err + ST R9 + RTN + LDX #BINtype + JSR LoadFile +L9BF1 BCC L9BF6 + JMP XB602 +L9BF6 JMP XB1CB +;================================================= +; BSAVE cmd +; +L9BF9 SET R4,XBD80 ;Ptr to PN + LDD R12 + ST R10 ;adr + LDD R12 + ST R9 ;len + RTN + LDA #BINtype + JSR LDA65 ;Save the file + LDA #BINtype + STA XBADD + JSR XB883 ;Get info on freshly-created file +; + LDY #3 +L9C10 LDA XBAD1,Y ;Date&Time of + STA XBAE3,Y ; last modification + DEY + BPL L9C10 +; + LDA XBA92 ;Ptr to data buf + STA XBADE + LDA XBA92+1 + STA XBADE+1 + LDA #$C3 ;Access bits + STA XBADC + LDA XBAC8 ;Ptr to PN + STA XBADA + LDA XBAC8+1 + STA XBADA+1 + JSR XB904 ;Set file's attributes + JMP XB1CB +;================================================= +L9C3C LDA LA5B4,Y ;Get char + INY + JMP XB343 ; and print it +;================================================= +; PrByte +; +L9C43 JSR XB99B ;Convert (A) into 2-char str + PHA + TXA + JSR XB343 + PLA + JMP XB343 +;================================================= +L9C4F LDA SwapMode ;Is txt buf split? + BEQ L9C56 ;No + JMP XB6EA ;Show err & don't ret to caller +L9C56 RTS +;================================================= +; Move contents of txtbuf down in mem +; +L9C57 JSR NEWSW16 + SET R1,Z7E + LD R9 + STD R1 ;src addr + LD R7 ;TxtEnd + STD R1 ;=$80 + LD R10 + STD R1 ;=$82 (dest addr) + ADD R7 ;Compute the final addr + SUB R9 ; of last char of txtbuf + RTN +; + LDY #0 +L9C68 LDA (Z7E),Y + STA (Z82),Y + INC Z82 + BNE L9C72 + INC Z82+1 +L9C72 LDA Z7E + CMP Z80 + LDA Z7E+1 + SBC Z80+1 +; + INC Z7E + BNE L9C80 + INC Z7E+1 +L9C80 BCC L9C68 +; +L9C82 JSR NEWSW16 ;Is new TxtEnd + CPR R5 ; >= new TxtBgn? + BC L9C89 ;Yes + LD R5 +L9C89 ST R7 ;TxtEnd + RTN + RTS +;================================================= +; Print error msg table +; (X)-index into err msg table +; +L9C8C LDA L9CA0,X + BEQ L9C97 + JSR XB343 + INX + BNE L9C8C +L9C97 RTS +;================================================= +; Editor's error message printer +; +L9C98 EQU * ;ENTRY + JSR L9C8C + LDX #$68 ;ERROR + JMP L9C8C +;================================================= +; +L9CA0 ASC 'CMD SYNTAX' + DB $00 + ASC 'NUMERIC OVERFLOW' + DB $00 + ASC 'PARAMETER(S) OMITTED' + DB $00 + ASC 'UNKNOWN COMMAND' + DB $00 + ASC 'MULTI BUFFER' + DB $00 + ASC 'EXEC NEST' + DB $00 + ASC 'BAD LINE#/RANGE' + DB $00 + ASC ' ERROR' + DB $07,CR,$00 +;================================================= +; Editor's Default Tab table +; +L9D11 EQU * ;ENTRY + DB 32,36,48 +L9D14 EQU * ;ENTRY + ASC 'EDASM.AUTOST' + DB $00 +;================================================= +; $9D21 +; This 'JMP via RTS' table is utilised by the EI's +; code ($B20F-$B262) for further processing of +; the command line stored at InBuf +; +JMPTBL EQU * ;ENTRY + DW XB659-1 ;0 - Chk for a CR + DW L999D-1 ;2 + DW L9A3F-1 ;4 + DW L99AD-1 ;6 + DW L99B3-1 ;8 + DW L99D6-1 ;A + DW L9A04-1 ;C + DW L99BE-1 ;E + DW L998D-1 ;10 + DW L99F5-1 ;12 + DW L998D-1 ;14 + DW L9997-1 ;16 + DW L99AA-1 ;18 + DW L99D6-1 ;1A + DW L9A0C-1 ;1C + DW L9AB2-1 ;1E + DW L9AAE-1 ;20 + DW L9A8E-1 ;22 + DW L9A8A-1 ;24 + DW L9AB2-1 ;26 +; +; Ptr to the various messages. This table must +; be arranged in 1:1 corr with the table above +; +L9D49 DW XB289 ;0 + DW L9D7D ;2 + DW L9D8F ;4 + DW L9DA2 ;6 + DW L9DAD ;8 + DW L9DBD ;A + DW L9DC7 ;C + DW L9DD6 ;E + DW L9D85 ;10 + DW L9D71 ;12 + DW L9DDF ;14 + DW L9DE3 ;16 + DW L9DA2 ;18 + DW L9DE7 ;1A + DW L9DF4 ;1C + DW L9E0C ;1E + DW L9E16 ;20 + DW L9E20 ;22 + DW L9E29 ;24 + DW L9E01 ;26 +;================================================= +; ERROR FRAGMENTS +; +L9D71 ASC ' ' + DB $00 +L9D7D ASC ' LINE# ' + DB $00 +L9D85 ASC ' ' + DB $00 +L9D8F ASC ' > ' + DB $00 +L9DA2 ASC ' .STRING. ' + DB $00 +L9DAD ASC '.OLDSTR.NEWSTR.' + DB $00 +L9DBD ASC ' PATHNAME' + DB $00 +L9DC7 ASC '' + DB $00 +L9DD6 ASC '' + DB $00 +L9DDF ASC '<#>' + DB $00 +L9DE3 ASC ' # ' + DB $00 +L9DE7 ASC ' OLDPATHNAME' + DB $00 +L9DF4 ASC ' NEWPATHNAME' + DB $00 +L9E01 ASC '[A<$>ADRS]' + DB $00 +L9E0C ASC '[A<$>ADRS' + DB $00 +L9E16 ASC 'L<$>LGTH]' + DB $00 +L9E20 ASC 'A<$>ADRS' + DB $00 +L9E29 ASC 'L<$>LGTH' + DB $00 +;================================================= +; Convert (A) into BCD and return +; 2-byte dec string in (X,A) +; +L9E32 TAX + CPX #100 + BCC L9E3B + LDA #'*' + TAX + RTS +; +L9E3B LDA #0 + SED +L9E3E CLC + ADC #1 + DEX + BNE L9E3E +; + CLD + PHA + AND #$F0 ;Isolate ten's digit + LSR + LSR + LSR + LSR + ORA #'0' ;-> ASCII + TAX + PLA + AND #$0F ;Isolate unit's digit + ORA #'0' + RTS +;================================================= +; Convert ProDOS Date/Time into ASCII format +; +L9E55 EQU * ;ENTRY + LDA #'-' + STA DateTime+2 + STA DateTime+6 + LDA #':' + STA DateTime+13 + LDA #SPACE + STA DateTime+10 + STA DateTime+9 + LDA P8TIME + ORA P8TIME+1 + BNE L9E7E +; + LDX #5 ;No Time + LDA #SPACE +L9E76 STA DateTime+10,X + DEX + BNE L9E76 + BEQ L9E9A ;always +; +L9E7E LDA P8TIME + AND #%00111111 ;xxMM MMMM + JSR L9E32 + STX DateTime+14 + STA DateTime+15 + LDA P8TIME+1 + AND #%00011111 ;xxxH HHHH + JSR L9E32 + STX DateTime+11 + STA DateTime+12 +; +L9E9A LDA P8DATE+1 ;YYYY YYYM + LSR ;0YYY YYYY + PHP ;Save M-bit in C + JSR L9E32 + STX DateTime+7 + STA DateTime+8 + LDA P8DATE ;MMMD DDDD + PHA + AND #%00011111 ;000D DDDD + JSR L9E32 + STX DateTime + STA DateTime+1 + PLA + AND #%11100000 ;MMM0 0000 + PLP ;M-bit + ROR ;MMMM 0000 + LSR ;Index in Months table + LSR + LSR ;000M MMM0 (div8) + STA DateTime+3 ;Use as tmp + LSR ;0000 MMMM (div16) + CLC + ADC DateTime+3 + TAX + DEX + LDY #3 +L9ECB LDA MonthsT,X + STA DateTime+2,Y ;Month in ASCII + DEX + DEY + BNE L9ECB + RTS +;================================================= +L9ED6 ASC 'BYTES USED' + DB CR +L9EE1 ASC 'BYTES REMAINING' + DB CR +L9EF1 ASC 'BYTES USED BY NON TEXT DATA' + DB CR +L9F0D ASC ' = XSAVE FILE TYPE' + DB CR +L9F21 ASC ' = XSAVE AUX TYPE' + DB CR +;================================================= +L9F34 JSR PRODOS8 ;Newline + DB $C9 + DW XBAA0 + RTS +; +L9F3B JSR PRODOS8 + DB $CA + DW L9F42 + RTS +; +; Read text file parm block +; Used by the TYPE cmd +; +L9F42 DB $04 +L9F43 DB $A0 ;Ref # + DW XBD00 ;read data buf +L9F46 DW 255 ;max val +L9F48 DW $A0A0 +;================================================= +; CREATE cmd +; +L9F4A SET R4,XBD80 ;Ptr to PN + RTN + LDA #$0F ;DIRtype + JSR XB883 ;Does file exist? + BCS L9F5A ;No + LDA #$47 ;Err +L9F57 JMP XB602 +; +L9F5A LDA FileType + STA XBAEB + LDA #$0D ;sub-DIR + STA XBAEE + LDA #$C3 ;Access bits + STA XBAEA + LDA XBAC8 ;Re-use + STA XBAE8 + LDA XBAC8+1 ; ptr to PN + STA XBAE8+1 + JSR XB919 ;Create subdir + LDX #$01 + STX XBAEE ;Reset this + TAX + BNE L9F57 ;Err + JMP XB1CB +;================================================= +CPYRIGHTS EQU * ;ENTRY + DB CR,CR,CR,CR,CR,CR,CR + ASC ' PRODOS EDITOR-ASSEMBLER // ' + DB CR,CR + ASC ' RELEASE 1.1 ' + MSB ON + ASC "01-MAY-85" + MSB OFF + DB CR,CR + ASC ' BY JOHN ARKLEY' + DB CR,CR,CR + ASC ' ' + MSB ON + ASC "COPYRIGHT (C) 1983-85" + MSB OFF + DB CR,CR + ASC ' ' + MSB ON + ASC " APPLE COMPUTER INC." + MSB OFF + DB CR +;================================================= +; PTRON cmd +; +LA024 RTN + LDA DevCtlS ;Slot # (0000 0sss) + ASL + ASL + ASL + ASL + AND #$70 ;0sss 0000 + BEQ LA042 ;Slot 0 +; + STA LA1A0 ;Unit # + JSR PRODOS8 + DB $C5 + DW LA19F + BEQ LA03F ;Printers should not ret 0 + CMP #$28 ;No device connected? + BEQ LA042 ;Yes +LA03F JMP LD53E ;Invalid parm +; +LA042 LDA #$80 +LA044 STA PtrMode ;PTRON flag + JMP XB1CB +;================================================= +; PTROFF cmd +; +LA049 RTN + LDA #$00 + BEQ LA044 ;always +;================================================= +; Print name of file in active txtbuf +; +LA04E LDA SwapMode + CMP #$02 + BNE LA054 ;Useless instr +LA054 LDA XBE00 + BEQ LA066 +; + LDY #0 +LA05B LDA XBE00,Y + BEQ LA066 + JSR XB343 ;Output char + INY + BPL LA05B +; +LA066 JMP XB339 ;Do a cr +;================================================= +LA069 JSR NEWSW16 +LA06C SET R9,XB50D ;Dir not found + BRL LD33F +;================================================= +; CATALOG cmd +; +LA072 SET R0,80 ;# of cols + BR LA07A +; +; CAT +; +LA077 SET R0,40 +; +LA07A SET R4,LA5B3 + STI R4 + SET R4,XBD80 ;Point @ PN + LDI R4 ;Did user include PN? + BNZ LA090 ;Yes + SET R4,XBB80 ;No, try curr pfx + LDI R4 ;Get len byte + BZ LA06C ;No prefix set + ADD R4 ;Compute EO pfx + ST R1 + SUB R0 ;Zero ACC + STI R1 ;Append a 0 to pfx + BR LA091 +; +LA090 DCR R4 +LA091 RTN +; +; Reg4-ptr to PN +; +LA092 LDA #$0F ;DIRtype + JSR XB883 ;Chk file's info + BCS LA0C6 ;Not found + JSR XB339 ;Do a cr +LA09C LDA XBACE ;Storage type + CMP #$0D ;Linked dir file? + BEQ LA0AC ;Yes + CMP #$0F ;Vol Dir? + BNE LA069 ;No + LDA #'/' + JSR XB343 +; +LA0AC LDX #>XA900 ;1024-byte I/O buf + LDY #LA8D1 + STA Reg4 + LDA #' +; +LA5AC DB $A0,$A0,$B0,$C0 +LA5B0 DB $C5 ;month +LA5B1 DB $A0 ;day +LA5B2 DB $A0 ;year +LA5B3 DB 40 ;# of cols +; +; ASCII representation of filetypes +; +LA5B4 ASC 'UNK' ;$00 + ASC 'BAD' ;$01 + ASC 'PCD' ;$02 + ASC 'PTX' ;$03 + ASC 'TXT' ;$04 + ASC 'PDA' ;$05 + ASC 'BIN' ;$06 + ASC 'FNT' ;$07 + ASC 'GRF' ;$08 + ASC 'BA3' ;$09 + ASC 'DA3' ;$0A + ASC 'WPF' ;$0B + ASC 'SOS' ;$0C + ASC '$0D' ;$0D + ASC '$0E' ;$0E + ASC 'DIR' ;$0F + ASC '$U0' ;$F0-CMD + ASC '$U1' ;$F1 + ASC '$U2' ;$F2 + ASC '$U3' ;$F3 + ASC '$U4' ;$F4 + ASC '$U5' ;$F5 + ASC '$U6' ;$F6 + ASC '$U7' ;$F7 + ASC '$U8' ;$F8 + ASC '$U9' ;$F9-OS + ASC 'INT' ;$FA + ASC 'IVR' ;$FB + ASC 'BAS' ;$FC + ASC 'VAR' ;$FD + ASC 'REL' ;$FE + ASC 'SYS' ;$FF +;================================================= +LA614 LDY CH + LDA (BASL),Y + BIT RDROM2 + JSR LA653 ;Get key via I/O hooks + AND #$7F + BIT RDBANK2 + RTS +;================================================= +; Editor's KSW entry point +; Input +; (A)=char under cursor +; +LA624 PHA + PHA + LDA (BASL),Y ;Get char fr screen location + CMP #UNDERSCORE+$80 + BEQ LA631 ;Yes + PLA ;char + LDA #UNDERSCORE+$80 + BMI LA632 ;Always +LA631 PLA +LA632 STA (BASL),Y ;Replace it + PLA +LA635 INC Z4E ;Delay + BNE LA645 + INC Z4E+1 + PHA + LDA #$3F + AND Z4E+1 + CMP #$01 + PLA + BCC LA624 +LA645 BIT KBD + BPL LA635 +; + STA (BASL),Y ;Got a key, store it @ screen location + LDA KBD + BIT KBDSTROBE + RTS +; +LA653 JMP (KSWL) +;================================================= +; (A)= $80 - set ucase +; = $40 +; = $7F - clear ucase +; = $00 +; +; Output +; CaseMode - 1000 0000 - ucase only +; - 0100 0000 - disable lcase +; - 0000 0000 - lcase +; +LA656 AND CaseMode + DB $2C +LA659 ORA CaseMode + STA CaseMode + RTS +;================================================= +; Get char and do some char mapping if necessary +; +LA65E JSR RDCHAR + JSR LA668 ;Chk the key + BCS LA65E + RTS +; +LA667 DB $00 ;Keyed in char +; +; If //e, //c or later, /// emulation just return +; with C=0 and (A)= char keyed in +; For ][/][+, map the char and save in InBuf if char is valid +; Input +; (A)= char +; Output +; C=1 - ignore key +; C=0 - accept key +; (A) - modified char +; +LA668 AND #$7F + CMP #$5F ;Underscore _ + BCS LA6CB ;If $5F-$7F, ret w/C=0, (A)=key + STA LA667 + LDA #%00001000 + BIT MACHID ;//c or later? + BNE LA6C8 ;Yes + BMI LA6C8 ;//e +; +; ][/][+ +; + LDA VideoSlt ;Is there a video card? + BNE LA6C8 ;Yes + LDA LA667 + CMP #']' + BCS LA6A2 ;$5D -> $4D + CMP #'[' + BCS LA6CB ; [ or \ + CMP #$1E + BEQ LA69D ;ctrl-^ -> ^ + CMP #$00 + BEQ LA69D ;ctrl-@ -> @ + CMP #$1D + BEQ LA69B ;ctrl-] -> ] + CMP #'@' + BEQ LA6A2 ;->$50 (P) + BNE LA6A5 ;always +; +LA69B LDA #'|' +LA69D ORA #$40 + JMP LA6B2 +; +LA6A2 EOR #$10 + CLC +LA6A5 BCC LA6B2 + BIT CaseMode ;Is case disabled? + BVS LA6CB ;Yes + BIT BUTN2 ;1-wire shift down? + BPL LA6CB ;No + ORA #$20 +LA6B2 CMP #CTRLE ;Enable lcase? + BEQ LA6C1 ;Yes + CMP #CTRLW ;Disable lcase? + BNE LA6CB + LDA #$40 ;Yes + JSR LA659 + SEC + RTS +; +LA6C1 LDA #$00 + JSR LA656 + SEC + RTS +; +LA6C8 LDA LA667 +LA6CB CLC + RTS +; +LA6CD CMP #DEL + BEQ LA6D5 + CMP #BS + BNE LA6E6 +; +LA6D5 DEX + CPX #-1 ;Was cursor @ BOL? + BEQ LA708 ;Yes + LDA InBuf,X + AND #$7F + INX + CMP #SPACE ;ctrl-chars? + BCC LA712 ;Yes + LDA #BS ;Printable chars so do BS +; +LA6E6 CMP #TAB ;CTRLI + BCC LA6EE + CMP #SPACE + BCC LA6F1 +LA6EE JSR XB343 ;Printable char +; +LA6F1 CMP #CTRLX + BEQ LA703 + CMP #BS + BEQ LA712 + CPX #248 + BCC LA700 + JSR XB33D ;Sound the alarm +LA700 INX + BPL LA716 +LA703 LDA #'\' ;Cancel input + JSR XB343 +LA708 JSR XB339 ;Display a CR i.e. start entry on a new line +;================================================= +; Input cmd line +; +LA70B EQU * ;ENTRY + LDA Prompt ;prompt + JSR XB343 +LA710 LDX #1 +LA712 TXA + BEQ LA708 + DEX +LA716 BIT RDROM2 + LDA #%00001000 + BIT MACHID + BNE LA729 ;//c or later + BMI LA729 ;//e or /// emulation + JSR LA65E ;Get char fr ][ kbd + ORA #$80 + BMI LA72C ;always +; +LA729 JSR RDCHAR +LA72C BIT RDBANK2 + CMP #CTRLU+$80 + BNE LA73B +; + LDY CH + LDA (BASL),Y ;Pick char fr screen location + BMI LA73B + ORA #$E0 +LA73B STA InBuf,X + AND #$7F + CMP #CR + BNE LA6CD +; + TXA ;Got a CR + PHA +LA746 LDA InBuf,X ;Remove msb fr all + AND #$7F + STA InBuf,X ; preceding chars + DEX + BPL LA746 +; + PLA + TAX + LDA #$1D ;ctrl-] -> $9D (clrEOL) + JSR XB343 + JMP XB339 ;Do a CR +;================================================= +; Checks for an 80-col card +; Output +; (X)=$C3 80-col card detected in slot 3 +; (X)=$00 no 80-col card +; +LA75B EQU * ;ENTRY + LDX #$C3 + LDA #%00000010 ;Is 80-col card present? + BIT MACHID + BEQ LA76B ;Maybe + LDA SLTBYT + AND #%00001000 ;Is there a ROM in slot 3? + BNE LA787 ;Yes (NB. (X)=$C3) +; +LA76B LDA #$01 ;Pascal v1.1 Protocol? + CMP XC30B + BNE LA785 ;No + CMP XC30B ;Useless instructions + BNE LA785 + CMP XC30B + BNE LA785 +; +; Device signature byte=$8x if 80-col card +; + LDA XC30C ;Get Device Signature byte + AND #$F0 ;=$x0 + CMP #$80 :80-column card? + BEQ LA787 ;Yes +LA785 LDX #$00 ;No 80-col card +LA787 RTS +;================================================= +; Reset I/O hooks +; +LA788 EQU * ;ENTRY + LDX VideoSlt ;=$Cs +; +; If you enter here, set (X)=$Cs or $00 +; +LA78A EQU * ;ENTRY + TXA + STX VideoSlt + BEQ LA7AB ;If (X)=0, init video +; + CPX CSWL+1 + BEQ LA7AA ;Already setup +; + LDA #$00 + STA CSWL + STX CSWL+1 ;=$Cs00 + LDA #CR + JSR XB343 ;Init the card + LDX VideoSlt + CPX KSWL+1 + BEQ LA7AA + STX KSWL+1 ;=$C300 + LDA #$00 + STA KSWL +LA7AA RTS +; +LA7AB LDA CSWL+1 + CMP #$C3 + BNE LA7E0 +; + LDA XC30C ;Device signature byte + CMP #$81 ;ALS Smarterm card? + BNE LA7D0 +; + LDA #CTRLT+$80 + BIT RDROM2 + JSR COUT + LDA #'A'+$80 + JSR COUT + LDA #'1'+$80 + JSR COUT + BIT RDBANK2 + JMP LA7E0 +; +LA7D0 LDA #CTRLU+$80 + BIT RDROM2 ;Read ROM + JSR COUT + BIT RDBANK2 ;Read only RAM bank 2 + LDA #$40 ;LCase off + JSR LA656 +; +; Setup Editor's I/O Hooks (Apple ][) +; +LA7E0 LDA #>XB3D9 ;Use CmdInt's CSW + LDX #LA624 ; but use Editor's KSW + STA KSWL + LDA #LDE18 + CLC + ADC #1 ;Skip 1st byte + STA Reg0 + LDA #LA8C6 + LDY #X2000 + STA A1 + LDA #X2000+$1000-1 + STA A2 + LDA #SW16SET ;1X +LD060 DB >SW16RTN ;0 + DB >SW16LD ;2X + DB >SW16BR ;1 + DB >SW16ST ;3X + DB >SW16BNC ;2 + DB >SW16LDat ;4X + DB >SW16BC ;3 + DB >SW16STat ;5X + DB >SW16BP ;4 + DB >SW16LDDat ;6X + DB >SW16BM ;5 + DB >SW16STDat ;7X + DB >SW16BZ ;6 + DB >SW16POP ;8X + DB >SW16BNZ ;7 + DB >SW16STPat ;9X + DB >SW16BM1 ;8 + DB >SW16ADD ;AX + DB >SW16BNM1 ;9 + DB >SW16SUB ;BX + DB >SW16BK ;A + DB >SW16POPD ;CX + DB >SW16RS ;B + DB >SW16CPR ;DX + DB >SW16BS ;C + DB >SW16INR ;EX + DB >SW16CPIM ;D + DB >SW16DCR ;FX + DB >SW16BRL ;E + DB >LD011 ;Unused + DB >SW16BSL ;F +; +LD07F DB EIWrmStrt + STA USRADR+1 + LDA #X9900 + STA HiMem ;HiMem for Editor=$9900 + LDA #X9D14 ;Is EdAsm.AutoST present? + STA Reg4 + LDA #XAD00 ;1024-byte I/O buffer + LDY #XDE18 ;Ptr to start of + STA LB286+1 + LDA # $01-$1A +LB3E8 CMP #$9D ;ctrl-] - clrEOL + BNE LB3F6 + TYA + PHA + JSR CLREOL + PLA + TAY + LDA #$9D + RTS +; +LB3F6 CMP #FF+$80 ; ctlr-L - form feed? + BNE LB404 + TYA + PHA + JSR HOME + PLA + TAY + LDA #FF+$80 + RTS +; +LB404 BIT RDROM2 + JMP COUT1 ;Call Monitor's ROM rtn +;================================================= +; Command Interpreter's Error messages +; +LB40A ASC 'PATH/FILENAME MISSING' ;ENTRY + DB CR +LB420 ASC 'SYNTAX' ;ENTRY + DB CR +LB427 ASC 'BAD FORMAT' ;ENTRY + DB CR +LB432 ASC 'MEMORY FULL' ;ENTRY + DB CR +LB43E ASC 'BAD RANGE' ;ENTRY + DB CR +LB448 ASC 'INVALID PARAMETER ' ;ENTRY + DB CR +LB45B ASC 'ALL OR SOME?(A/S)?' ;ENTRY + DB CR +LB46E ASC 'FILE NOT FOUND' + DB CR +LB47D ASC 'FILE TYPE MISMATCH' + DB CR +LB490 ASC 'WRITE PROTECTED' + DB CR +LB4A0 ASC 'FILE LOCKED' + DB CR +LB4AC ASC 'BAD PATH/FILE NAME' + DB CR +LB4BF ASC 'FILE SIZE MISMATCH' + DB CR +LB4D2 ASC 'FILE TOO LARGE' + DB CR +LB4E1 ASC 'DISK FULL' + DB CR +LB4EB ASC 'DISK I/O FAILURE' + DB CR +LB4FC ASC 'PRODOS ERROR=$' +; +HexStr DW $5858 + DB CR +LB50D ASC 'DIRECTORY NOT FOUND' ;ENTRY + DB CR +LB521 ASC ' THE FILE IS LOCKED. DESTROY ANYWAY (Y/N)?' ;ENTRY + DB CR +LB54D ASC 'PATH NOT FOUND' + DB CR +LB55C ASC 'DUPLICATE FILE NAME' + DB CR +LB570 ASC 'DIRECTORY FULL' + DB CR +LB57F ASC 'PLEASE RE-MOUNT ' + DB $80 +LB590 ASC 'PRESS RETURN TO CONTINUE ' + DB $80 +LB5AA ASC 'ASSEMBLER NOT ONLINE' + DB CR +;================================================= +; ($B5BF) Command interpreter's error message table +; Each entry consists of 3 bytes +; +ErrTable EQU * + DB $10 ;error code + DW LB4D2 ;msg ptr + DB $11 + DW LB47D + DB $12 + DW LB4BF + DB $27 + DW LB4EB + DB $2A + DW LB4EB + DB $2B + DW LB490 + DB $48 + DW LB4E1 + DB $46 + DW LB46E + DB $40 + DW LB4AC + DB $4B + DW LB4AC + DB $4E + DW LB4A0 + DB $44 + DW LB54D + DB $45 + DW LB50D + DB $47 + DW LB55C + DB $49 + DW LB570 + DB $FC + DW LB5AA + DB $FD + DW LB590 + DB $FE + DW LB57F + DB $FF + DW LB4FC +;================================================= +; ($B5F8) +; Input +; (A)=error code +; +FatalErr EQU * ;ENTRY + TAX ;error code + PLA ;dump RTS addr + PLA + TXA + JMP PrErrMsg +;================================================= +; +LB5FF JSR ClsFile2 ;ENTRY +; +; ($B602) Print Error Message and return to CI mainloop +; (A) - error code +; +PrErrMsg EQU * ;ENTRY + JSR PrErrMsg2 + JMP EIWrmStrt +;================================================= +; ($B608) +; Input +; (A)=error code +; +PrErrMsg2 LDX #$39 +LB60A DEX + DEX + DEX + BMI LB649 ;Not found + CMP ErrTable,X ;Is this the error code? + BNE LB60A ;keep searching +; + INX + LDA ErrTable,X ;msg ptr + STA Z12 ;Reg9 + INX + LDA ErrTable,X + STA Z12+1 +; +LB620 EQU * ;ENTRY + LDA #'E' + JSR PrChar + LDA #'R' + JSR PrChar + JSR PrChar + JSR RingBell + LDA #':' + JSR PrChar + LDA #SPACE + JSR PrChar +; + LDY #0 +LB63C LDA (Z12),Y ;Reg9 + BMI LB648 + JSR PrChar + INY + CMP #CR + BNE LB63C +LB648 RTS +; +; Error code not in our table +; Just show a generic error message +; +LB649 STA ErrCode ;error code + JSR Cnv2Hex + STA HexStr+1 + STX HexStr + LDA #$FF ;Show err msg w/errcode in hex + JMP PrErrMsg2 +;================================================= +LB659 EQU * ;ENTRY + LDA #CR + CMP Z12 + BEQ LB662 + JMP LB28E ;cmd syntax +; +; 3 of the commands get some special treament viz +; ASM, END and LIST +; +LB662 LDA #$00 + STA Z00+1 + JSR GetToken ;Get token fr Cmd table + STA Z00 + BEQ LB6E6 ;ASM cmd +; + CMP #$5C ;END cmd + BEQ LB6A4 + CMP #$26 ;LIST cmd? + BNE LB67A + JSR LB2AF ;Yes, make a copy of cmd + LDA Z00 +LB67A LDY Z00 + CPY #$5D ;']' - sentinel value + BCC LB682 +; $D680 + LDY #0 +LB682 LDA XDFA2,Y + STA Z04 ;Set SW16 R2 w/JMP addr-1 + INY + LDA XDFA2,Y + STA Z04+1 + STA RDBANK2 + BIT PtrMode ;Is Printer on? + BPL LB697 ;No + JSR XD610 ;Init printer +; +; The last instruction of the Sweet16 code below +; will take us to the addr stored in R2 since +; R15 is SW16's PC +; +LB697 JSR NEWSW16 + SET R0,CR + DCR R5 + STI R5 + LD R2 + SET R12,XBD00 + ST R15 +;================================================= +; END cmd +; +LB6A4 EQU * + LDA SwapMode ;Do we have a split txt buf? + BNE LB6EA ;Yes, so can't quit + JSR XA872 ;Load Quit Code + LDX #$00 ;Slot # + JSR XA78A ;Init I/O Hooks +; + LDA ROMIN2 + LDA ROMIN2 + LDA #$60 ;RTS + STA USRADR + LDA #>BASCLD + STA SOFTEV + LDA # $F128 + STA SOFTEV+1 + LDA #$45 + STA PWREDUP + JSR SETKBD + JSR SETVID + JSR HOME + JSR PRODOS8 + DB $65 + DW QuitP +; +LB6D9 EQU * + STA InBuf+$FF + JMP BASCLD ;Do a Monitor cold Start +; +QuitP DB $04 + DB $00 ;If quit type $EE, + DW $0000 ; addr of launch pathname + DB $00 ; reserved + DW $0000 +;================================================= +; Prepare for Assembly +; +LB6E6 EQU * + LDA SwapMode ;Do we have a split txt buf? + BEQ LB6EF ;No +LB6EA EQU * ;ENTRY + LDX #$41 ;Multi-buffer + JMP LB290 +; +LB6EF LDA TxtEnd+1 ;Is edit buffer empty? + CMP TxtBgn+1 + BNE LB6FB + LDA TxtEnd + CMP TxtBgn + BEQ LB700 ;Yes +LB6FB LDX #$47 ;'Buffer' + JMP LB290 +; +LB700 LDA #SPACE + LDX #16 +LB704 STA DateTime,X ;Prepare data area + DEX + BPL LB704 +; + JSR PRODOS8 + DB $82 ;Get time + DW * + JSR X9E55 ;Date/Time Conversion +; +; The assembler uses the Editor's first 3 tabs +; if the 1st tab col of user-defined tab +; table is < 12. Otherwise, a modified tab +; table is passed to the assembler +; + LDY #2 +LB715 LDX UserTabT ;Get 1st tab col + CPX #12 + BCC LB729 + LDA UserTabT,Y +; DB $B9,$68,$00 + CLC + ADC #17 +LB721 STA TabTable,Y ;Tabs table passed to the assembler + DEY + BPL LB715 + BMI DoAsmbly ;always +; +LB729 LDA X9D11,Y ;Editor's default tab table + BNE LB721 ;always +; +DoAsmbly LDA #$00 + STA PtrMode ;Disable Printer + JSR LoadAsm + LDA RDBANK2 + JSR X7800 ;xfer control to Assembler + JSR LB741 ;Re-load EdAsm.Ed + JMP EIMainLoop +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Set prefix to EdAsm's Launch dir +; Load the Editor's modules into mem +; Relocator module loaded @ $8900-$98FF to +; $D000 LC Bank2 +; Return to caller if successful else crash into Monitor +; +LB741 EQU * + JSR LB836 ;Set prefix to EdAsm's Dir + BCC LoadDEd + LDA #$FE ;Re-mount... + JSR PrErrMsg2 +; +; Print EDASM's launch dir. This directory contains +; the files EDASM.SYSTEM, EDASM.ED and EDASM.ASM +; $BE79-BA(65 bytes incl leading and trailing /'s) +; + LDY #0 + LDX EdAsmDir ;len byte +LB750 LDA EdAsmDir+1,Y + JSR PrChar + INY + DEX + BNE LB750 +; + JSR PrtCR + LDA #$FD ;Press return... + JSR PrErrMsg2 +; +WaitK1 LDA KBD + BPL WaitK1 + BIT KBDSTROBE + CMP #CR+$80 + BNE WaitK1 + JSR PrtCR + JMP LB741 ;try again +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Load the file EDASM.ED +; +; $9900-$A8FF - Editor overlay +; $D000-$DFFF - Editor code +; +LoadDEd LDA #>LoadAdrEd + STA ReadDBuf + LDA #EdStr + LDY #LoadAdrEd + STA A1 ;start addr + LDA #LoadAdrEd+$1000-1 + STA A2 ;end addr + LDA #XD000 ;dest addr + STA A4 + LDA #LoadAdrAsm + STA ReadDBuf + LDA #AsmStr + LDY #LoadAdrAsm + STA A1 ;start addr + LDA #LoadAdrAsm+$1000-1 + STA A2 + LDA #FileNameB + STA GFIPath + STA PathNameP + LDA #XA900 ;1024-byte I/O buffer + LDY #=ReadLen? + CMP ReadLen + LDA fileEOF+1 + SBC ReadLen+1 + PHP + LDA ReadLen + BNE LB990 + DEC ReadLen+1 +LB990 DEC ReadLen + PLP + BCS LB997 ;yes + RTS +LB997 LDA #$10 ;err code + SEC +LB99A RTS +;================================================= +; ($B99B) +; Input +; (A) - byte value to be converted +; Output +; (X,A) - Hex Digits +; +Cnv2Hex EQU * ;ENTRY + PHA ;Convert to 2 HEX digits + LSR ;Shift upper nybble + LSR + LSR + LSR + JSR LB9A5 + TAX ;Save in X + PLA +LB9A5 AND #$0F + ORA #'0' + CMP #'9'+1 + BCC LB9AF + ADC #$06 +LB9AF RTS +;================================================= +; EXEC command +; Ref pg 62 for lots of info on use of EXEC files +; +LB9B0 EQU * ;ENTRY + SET R4,XBD80 + RTN +; +LB9B4 EQU * + BIT ExecMode ;exec mode? + BPL LB9C3 ;No + ASL ExecMode + LDA RdExeRN ;Close the old EXEC file first + STA CloseRN + JSR ClsFile +LB9C3 LDA #TXTtype + JSR CkAttrF + BCC LB9CD ;Found +; +LB9CA JMP PrErrMsg ;Not Found +; +LB9CD BNE LB9CA ;Wrong type +; + LDX #>XAD00 ;1024-byte I/O buf for ProDOS8 + LDY #L2400 ;EI's load addr + STA A1 ;start=$2400 + LDA #EIStart + STA A4 ;dest + LDA #EIStart-1 + PHA + LDY #0 + LDA ROMIN2 ;read ROM + LDA ROMIN2 ;write-enabled LC Bank2 RAM + JMP MOVE +;================================================= +; Use this to set the default prefix +; +SDefPfxP DB $01 + DW TxBuf2 +; +; Use this parameter block to get the current prefix +; +CurrPfxP DB $01 + DW CurrPfxB +; +; EdAsm's Dir is where the 3 files EdAsm.Ed, +; Edasm.Asm and Edasm.System resides +; +PFX3P DB $01 + DW EdAsmDir +; +OnLineP DB $02 +OLUnit DB $60 + DW CurrPfxB+1 +;================================================= +ShowErr STA ErrCode + TSX + STX StackP2 + LDX #$80 +L2144 TXS +L2145 STA CLR80VID + JSR SETNORM + JSR INIT + LDA RDROM2 ;read ROM, write-protect RAM LC Bank2 + JSR SETKBD + JSR SETVID + JSR HOME + JSR PRERR ;PRINT "ERR=XX" + LDA ErrCode + JSR $FDD3 ;unsupported mon entry point + JMP MON +; +SendBanr LDA Banner,Y + BPL L2171 + JSR COUT + INY + JMP SendBanr +L2171 RTS +; + MSB ON +Banner DB $8D,$8D,$8D + ASC " PRODOS EDITOR-ASSEMBLER //" + DB $8D,$8D,$8D,$8D,$8D,$8D + ASC "ENTER THE DATE AND PRESS RETURN" + DB $8D,$8D + ASC "DD-MMM-YY" + DB 0 + MSB OFF +TensT DB 00,10,20,30,40,50,60,70,80,90 +Day DB $00 +L21CE DB $00 +L21CF DB $00 +L21D0 DB $00 +L21D1 DB $00 +MMM DS 3,0 +; +L21D5 LDA #BEL+$80 + JSR COUT +L21DA LDA #$00 + STA CH +L21DE JSR RDKEY + CMP #'0'+$80 + BCC L21D5 + CMP #'3'+1+$80 + BCS L21D5 + JSR COUT + AND #$0F + TAX + LDA TensT,X + STA Day + STA L21D0 + JMP L220D +; +L21FB LDA L21D0 + STA Day + LDA #1 + STA CH + JMP L220D ;enter 2nd digit for DD +; +L2208 LDA #BEL+$80 + JSR COUT +L220D JSR RDKEY + CMP #BS+$80 + BEQ L21DA + CMP #'0'+$80 + BCC L2208 + CMP #'9'+1+$80 + BCS L2208 + JSR COUT + AND #$0F + CLC + ADC Day + STA Day + BEQ L21D5 + CMP #31+1 ;at most 31 + BCS L21D5 ;err + RTS +; Year +L222F LDA #BEL+$80 + JSR COUT +L2234 LDA #7 + STA CH +L2238 JSR RDKEY + CMP #BS+$80 + BEQ L2289 + CMP #'0'+$80 + BCC L222F + CMP #'9'+1+$80 + BCS L222F + JSR COUT + AND #$0F + TAX + LDA TensT,X + STA L21CF + STA L21D1 + JMP L226B +; +L2259 LDA L21D1 + STA L21CF + LDA #$08 + STA CH + JMP L226B +; +L2266 LDA #BEL+$80 + JSR COUT +L226B JSR RDKEY + CMP #BS+$80 + BEQ L2234 + CMP #'0'+$80 + BCC L2266 + CMP #'9+1+$80 + BCS L2266 + JSR COUT + AND #$0F + CLC + ADC L21CF + STA L21CF + BEQ L222F + CLC +L2289 RTS +; +L228A DB $A0 + MSB ON +Months ASC "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC" + MSB OFF +; +L22AF LDA #5 ;3rd letter of MMM + STA CH + JMP L22DF +; +L22B6 SEC + RTS +; +; Month entry +; +L22B8 LDA #BEL+$80 + JSR COUT +L22BD LDA #3 ;1st letter of MMM + STA CH +L22C1 JSR ToUCase + CMP #BS+$80 + BEQ L22B6 + JSR PRUCase + BCS L22C1 + STA MMM +L22D0 JSR ToUCase + CMP #BS+$80 + BEQ L22BD + JSR PRUCase + BCS L22D0 + STA MMM+1 +L22DF JSR ToUCase + CMP #BS+$80 + BNE L22EC + JSR COUT + JMP L22D0 +; +L22EC JSR PRUCase + BCS L22DF + STA MMM+2 +; + LDX #$00 + STX L21CE +L22F9 LDY #$00 + INC L21CE + STX L228A +L2301 LDA MMM,Y + CMP Months,X + BNE L2311 + INX + INY + CPY #$03 + BCC L2301 + BEQ L2322 ;match +L2311 LDX L228A + INX + INX + INX + CPX #48 ;bug? (should be 36) + BCC L22F9 +; + LDA #3 + STA CH + JMP L22B8 ;re-enter +L2322 CLC + RTS +; +; Display char (in A) as uppercase letter +; +PRUCase CMP #'A'+$80 + BCC BELL + CMP #'Z'+1+$80 + BCS BELL + JSR COUT + CLC + RTS +BELL LDA #BEL+$80 + JSR COUT + SEC + RTS +; +ToUCase JSR RDKEY + CMP #$E0 ;should be "a" ($E1) + BCC L2341 + AND #$DF +L2341 RTS +;================================================= +; Move ProDOS Quit code fr LCBank2 to main 48K mem +; first. Save code as EdAsm.Swap +; +L2342 LDA RDBANK2 ;read and write-protect RAM LC Bank2 + LDA RDBANK2 + LDA #>XD000 + STA A1 ;start=$D000 + LDA #X3000 + STA A2 ;dest=$3000 + LDA # SPACE + jmp CmdFileErr ;CR => null cmd line +; +Phs01 jsr SkipSpcs + jsr ChkDrtv ;Is it a directive? + bcs Phs0Loop ;Not valid, ignore +; + pha ;Index into JMP table + jsr WhiteSpc + jsr AdvCP ;Ensure cp is @ 1st char of directive + pla + jsr HndlDrtv ;Process directive + jmp Phs0Loop +; +; If 1st char is not CR/SPACE, then it is a pathname of a src file +; +NotCmd bit MapFileF ;Output a LinkMAP? (default ON) + bpl EndPhs0 ;No + jsr OpLnkMap ;Open LinkMap file for output +EndPhs0 jmp DoPhase1 +;================================================= +; JMP via an RTS to parse the operand +; field of a directive +; +HndlDrtv tax + lda L36F0,x ;Directive JMP table + pha + lda L36EA,x + pha + rts +;================================================= +; BIN command/directive +; Input +; FTypeF=0 OBJECT file type not set +; Output +; FTypeF=1 +; TrgtFTyp=BIN +; NB. Only one BIN/REL/SYS directive +; may be declared +; +CmdBin lda FTypeF ;Has the OBJ type been set? + beq CmdBin1 ;No + jmp DupCmdErr +; +CmdBin1 lda #$01 + sta FTypeF ;Flag it's set + lda #BINtype + sta TrgtFTyp + jsr GetOutFN ;Get Link OBJ/MAP filenames + rts +;================================================= +; REL command/directive +; Input +; FTypeF=0 +; Output +; FTypeF=$80 +; TrgtFTyp=REL +; +CmdRel lda FTypeF + beq CmdRel1 + jmp DupCmdErr +; +CmdRel1 lda #$80 + sta FTypeF + lda #RELtype + sta TrgtFTyp + jsr GetOutFN + rts +;================================================= +; SYS command/directive +; Input +; FTypeF=0 +; Output +; FTypeF=$02 +; TrgtFTyp=SYS +; +CmdSys lda FTypeF + beq CmdSys1 + jmp DupCmdErr +CmdSys1 lda #$02 + sta FTypeF + lda #SYStype + sta TrgtFTyp + jsr GetOutFN + rts +;================================================= +; ORG command/directive +; Input +; Output +; Origin=Value of Expression +; Only 1 ORG may be declared and it must be b4 the src pathnames +; +CmdOrg lda Origin ;Already set? + ora Origin+1 + beq CmdOrg1 + jmp DupCmdErr ;Yes, duplicate cmd +; +CmdOrg1 jsr SkipSpcs + jsr ChrGot + beq BadOrg ;sp/cr + jsr EvalExpr + lda Value16 ;Chk it's valid + sta Origin + lda Value16+1 + beq BadOrg ; < $0100 + sta Origin+1 + ora Origin + beq BadOrg ; $0000 + rts +BadOrg jmp CmdSynErr ;syntax err +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; ALN Command/Directive +; Align Origin @ start of next mempage +; Output +; Origin=$xx00 +; +; This directive is usually used after a pathname +; and may be used repeatedly +; +CmdAln lda Origin ;ORG must be set first either by a + ora Origin+1 ; directive or via src filename + bne CmdAln1 + jmp CmdOrderErr ;Wrong cmd order +; +CmdAln1 lda Origin ;Align @ the beginning + beq doRTS + inc Origin+1 ; of the next mempage + lda #$00 + sta Origin +doRTS rts +;================================================= +; OPT command/directive. Only allowed to be used once +; Default +; OPT +M,+E,+S,+X,-N,-D,-P +; Input +; OptionsF +; Output +; OptionsF=1 - If Directive not declared +; +; One/Some/All of the following flags may be set +; M)apFileF - Output LinkMAP file (default ON) +; E)RefF - Add ENTRY records (default ON) +; S)ortLMF - Sort LoadMap table (default ON) +; X)RefF - Cross-referenced (default ON) +; N)umSortF - Sort LoadMap numerically (default OFF) +; O)ptDF - not used (default OFF) +; P)ageF - Pagination (default OFF) +; +CmdOptn EQU * + lda OptionsF ;First time directive is declared? + beq CmdOptn1 ;Yes + jmp DupCmdErr ;Duplicate cmd +; +CmdOptn1 inc OptionsF ;Flag we have encountered this cmd + jsr SkipSpcs +; +GetOptFlg jsr ChrGot ;chrgot + beq doRTS1 ;cr/space + cmp #'+' ;ON switch flag? + bne IsOptnOff ;No + lda #$80 ;ON + sta Switch + bne WhchOptn ;always +; +IsOptnOff cmp #'-' + bne BadOptn +; + lda #$00 ;OFF + sta Switch +WhchOptn jsr ChrGet ;Get char after switch flag + beq BadOptn ;It's a cr/space + ldx #0 +OptnLoop cmp OptionsT,x + beq GotOptn ;Got a hit + inx + cpx #7 + bcc OptnLoop ;Next +BadOptn jmp OptnErr ;Invalid option/option syntax +; +GotOptn lda Switch + sta OptFlagT,x ;$A2-$A8 +NxtOptn jsr ChrGet ;Get char + beq doRTS1 ;cr/space + cmp #',' ;delimiter + bne NxtOptn + iny ;Skip comma + jmp GetOptFlg ;Loop back for another option +doRTS1 rts +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Parse for the pathnames of the OBJ file and +; LinkMap txt file. Full and partial pathname +; are accepted. If there is no operand field +; following the BIN/REL/SYS directive/cmd then +; the default filenames are used. +; +; Output +; LinkObjS buf +; +GetOutFN jsr SkipSpcs +CpyLoop3 jsr ChrGot + beq GotWS ;cr/space + jsr ChkChar ;Is char valid? + bne IsCR ;No + iny + sta LinkObjS,y + bne CpyLoop3 +; +IsCR cmp #CR ;Is it a CR? +GotWS php ;Save compare status + cpy #0 ;Is there an operand? + beq Chk4CR ;No + sty LinkObjS ;Len byte +Chk4CR plp + beq doRTS2 ;Yes, it's a CR, so done + cmp #',' ;Check for the delimiter + bne FNF2 ;Not found +; + ldx #0 + iny ;Skip the comma +ChkLoop jsr ChrGot + beq GotCR ;cr/space + jsr ChkChar ;Is char valid? + bne FNF2 ;No, err + inx + iny + sta LinkMapS,x + bne ChkLoop +; +GotCR cpx #0 ;If no user-defined LinkMap + beq doRTS2 ; file use default + stx LinkMapS ;Len byte +doRTS2 rts +; +FNF2 lda #$40 ;fileNotFound + jsr ErrHndlr ;Don't come back +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Check if a char is valid +; Valid chars are: / . 0-9 A-Z +; Input +; (A)=ascii char +; Output +; Z=1 if char is valid +; +ChkChar cmp #'/' + beq doRTS3 + cmp #'.' + beq doRTS3 + jsr IsDecChar ;Is it a decimal digit? + bcc CharOK ;Yes + cmp #'A' + bcc doRTS3 + cmp #'Z'+1 + bcc CharOK + cmp #'A' + rts +; +CharOK sta Prompt + cmp Prompt ;Ensure Z=1 +doRTS3 rts +;================================================= +; Set PathName buf to OBJECT file +; +MovObjFN EQU * + ldy LinkObjS ;len byte +MovLoop lda LinkObjS,y + sta PathNameB,y + dey + bpl MovLoop + rts + REP 50 +; Set PathName buf to LinkMap text file +; +MovMapFN EQU * + ldy LinkMapS ;Get its len byte +MovLoop2 lda LinkMapS,y + sta PathNameB,y + dey + bpl MovLoop2 + rts + REP 50 +; Open for LinkMap text file for writing +; Input +; Output +; +OpLnkMap EQU * + jsr MovMapFN ;Set PN to LinkMap's + jsr PRODOS8 ;DESTROY + DB $C1 + DW DestryP +; + jsr PRODOS8 ;CREATE + DB $C0 + DW CrLnkMapP + bne GotErr +; + jsr PRODOS8 ;OPEN + DB $C8 + DW Open2P + beq FileOpn +GotErr jsr ErrHndlr ;Don't come back +; +FileOpn lda Open2P+c.outRef + sta WrMapFP+c.refNum + lda #0 + sta WrMapFIdx ;# of bytes to write + sta WrMapFIdx+1 ;HOB=Always 0 + rts +;================================================= +; Using info fr the ESD (if any) of the src files, +; build 3 arrays called ENTRY, EXTRN & SymbolicName +; tables. +; EntRecP - Point to an element of the ENTRY table of 24-byte records +; XtnRecP - Point to an element of the EXTRN table of 8-byte records +; SymP - Point to an element of the SymbolicName table of 16-byte records +; ModNbr - src file # assigned during processing +; CurrORG - starting PC of current src file +; +DoPhase1 ldy #$04 ;Building ENTRY/EXTERN tables + jsr DspMsg + jsr DspCR + ldy #$04 + jsr StorMsgY ;Store same msg to LinkMap +; + lda #>EntTbl + sta EntRecP ;ENTRY table @ $4700 + lda #XtnTbl ;XTRN table @ $7100 + sta XtnRecP + lda #SymTbl ;SymbolicName table @ $9200 + sta SymP + lda # we've a PN + cmp #CR + beq GoPhase2 ;Empty line -> no more cmds + jsr IsALN ;Is it Align directive? + bcc GotAln ;Yes -> align mem + jmp DoBreak ;Abort! +; +GotAln beq AlignMem ;ALN option + jmp CmdOrderErr ;No, invalid cmd order +; +AlignMem lda CurrORG ;Already @ a mempage bdry? + beq Phs1Loop ;Yes + inc CurrORG+1 ;Next mempage + lda #$00 + sta CurrORG + beq Phs1Loop ;always +; +GoPhase2 jmp DoPhase2 +; +; The name of a src file is already in CmdLine buffer +; Open the src file and setup some variables +; using the info fr the opened src file. +; +; CmdLineB - Pathname of src file +; EntRecP - ptr to a rec of ENTRY table +; XtnRecP - ptr to a rec of EXTRN table +; SymP - ptr to a rec of SymbolicName table +; +; Origin - ORG of 1st src file (if not) set by an ORG directive +; CurrORG - Starting PC assigned to curr src file +; SMSrcFP+c.mark - file posn of source file +; SrcP - pointer into a chunk of source file +; +; Z80 - End of chunk of RLD data read +; Z82 - Start of RLD data read +; +Phs11 jsr DspLineB + jsr OpenSrc ;Open src file and get info + bcc Phs12 + jsr ErrHndlr ;Don't come back +; +Phs12 lda Origin ;Was it set? + ora Origin+1 + bne OrgSet ;Yes +; + lda SrcORG ;Use the ORG as recorded + sta Origin ; in the 1st src file + sta CurrORG ; as our origin & use it as + lda SrcORG+1 ; the starting PC as well + sta Origin+1 ;NB. Once set, it will remain unchanged + sta CurrORG+1 ; throughout linking process +; +OrgSet lda #2 + clc + adc SrcCodeLen ;Len of code image + sta SMSrcFP+c.mark ;Set file posn to src file's + lda #0 ; relocation dictionary (RLD) + adc SrcCodeLen+1 + sta SMSrcFP+c.mark+1; which is just after the code image + lda OpSrcFP+c.outRef + sta SMSrcFP+c.refNum + jsr PRODOS8 ;SET_MARK + DB $CE + DW SMSrcFP + bne GotErr2 +; + jsr L3348 ;Read max chunk of RLD/ESD + bcc FinalData ;=> The entire RLD/ESD was read + cmp #$10 ;Did we encounter an EOF? + beq MoreData ;No, more data chunks +GotErr2 jsr ErrHndlr ;(A)=$4C, so let EI take care of it +; +; A fixed chunk (of 5K) had been read so there may be more +; data to be read. There seems to be no provision dealing +; with files in which the END of RLD is not within +; the first 5K of RLD/ESD data i.e. the RLD is very big. +; The code below doesn't seem to be able to handle this +; situation. Is there a bug here? +; The code below will never be executed if sizeof RLD+ESD < 5K +; +MoreData jsr GetEndRLD ;Scan for end of RLD + lda SrcP+1 ;Is SrcP still at the BO + cmp #SrcDBuf ; which is EO SrcDBuf+1 + bne L2353 +BigESD jmp RldEsdErr ;Src file's ESD too large +; +; This code is only executed if the size of the RLD is less +; than the size of the SrcDBuf located @ $0C00 (which is 5K) +; SrcP is pointing @ EO RLD +; The code below is definitely buggy. +; +L2353 lda #>SrcDBuf ;Start addr + clc + adc RWFileP+c.transCnt;Actual # of bytes read + sta Z80 ;Point @ EO data chunk + 1 + lda #SrcDBuf + sta Z82 ;DEST addr + lda #SrcDBuf ;Prepare to append more ESD data + clc + adc RWFileP+c.transCnt; fr src file by reading 'em + sta RWFileP+c.dataBuf; into this starting location + lda #FileDBSiz + sec + sbc RWFileP+c.transCnt + sta RWFileP+c.reqCnt;=$1400-(# of bytes of + lda # Done processing this file +MkRecs1 php ;save msb + and #$7F + iny + sta (EntRecP),y ;Copy char to both ENTRY and + sta (SymP),y ; SymbolicName records + plp ;Is msb off? + bpl CkSymTyp ;Yes, last char of symbolic name + cpy #15 ;max len of linker symbol + bcc MakeRecs ;Next char +; +; Only first 15 chars are copied. We skip the rest of chars. +; However, we still need to locate the eo the symbolicname +; in order to get @ the symbol-type flag etc. +; +SkipLoop lda (SrcP),y ;Get symbolicname's char + iny + tax ;Is this the last char? + bmi SkipLoop ;No +; +CkSymTyp tya + ldy #0 + sta (EntRecP),y ;Set the len byte + sta (SymP),y + tay + lda (SrcP),y + sta ESDRec ;Symbol-type flag + iny + lda (SrcP),y ;If EXTRN, this is the symbol # + sta ESDRec+1 ; referred to by an RLD entry + iny + lda (SrcP),y ;Hibyte of addr if + sta ESDRec+2 ; symbol-type is ENTRY +; + lda ESDRec ;Chk symbol-type + and #%00001000 ;Is it EXTRN symbol-type? + bne DoEntry ;No, it's ENTRY symbol-type +; + ldx #XtnRecP + bit Z9E ;Include code fr this file? + bpl DoXtrn ;Yes + jmp NxtEntryZ ;No recs will be added to the 3 tables +; +; Process an EXTRN symbol-type rec in ESD of a src file +; +DoXtrn lda #0 ;Zero the curr ENTRY slot + ldy #24 +ZeroLup2 sta (EntRecP),y ; which was partially + dey ; filled with the symbolicname + bpl ZeroLup2 +; +; Create a EXTRN record in table @ $7100 +; Each record is 8 bytes +; Initial Layout of each record is as follows: +; offset Description +; 0 DW ptr to a record in SymbolicName table ($9200) +; ptr to another EXTRN rec if the SymbolicName +; matched with that in one of the ENTRY recs +; 2 DW Ptr to an ENTRY record; NIL initially +; 4 DB file # of src file (also called module #) +; 5 DB FlagByte +; 6 DB symbol # referred to by an RLD record +; 7 DB 0 +; + ldy #0 + lda SymP + sta (XtnRecP),y ;Ptr to the corr record of + lda SymP+1 ; symbolicname table @ $9200 + iny + sta (XtnRecP),y + iny ;=2 + lda #$00 + sta (XtnRecP),y ;Set to NIL + iny + sta (XtnRecP),y + iny ;=4 + lda ModNbr ;file # of the src module + sta (XtnRecP),y + lda ESDRec ;symbol-type flag byte + ora #%11000000 ;Set undefined, unref'd bits + iny ;=5 + sta (XtnRecP),y + iny ;=6 + lda ESDRec+1 + sta (XtnRecP),y ;Symbol # referred to by an RLD record + iny ;=7 + lda #$00 + sta (XtnRecP),y ;hibyte=0 - Not used + jsr ScanEntTbl ;Is this symbol already in ENTRY table? + bne ChkSymTbl ;No + jsr L2668 ;Yes, add this EXTRN rec to singly-link list + jmp DoneXtrn ;Add this EXTRN rec to its table +; +ChkSymTbl jsr L2629 ;Is symbol already in SymbolicName table? + bne AddSymName ;No => add the SymbolicName rec to its table +; + ldy #0 + lda Z88 ;Set this link to point + sta (XtnRecP),y ; to SymbolicName record + iny + lda Z88+1 ; already in table + sta (XtnRecP),y + jmp DoneXtrn ;=> Don't add new SymbolicName rec to its table +; +; We are adding a new SymbolicName rec to the its table +; This is done by incrementing SymP by the appropiate +; # of bytes i.e. SymP++ (in C Syntax) +; +AddSymName jsr IncrSymP ;Adv to next empty slot of SymbolicName table + lda SymP+1 ;Is SymbolicName table full? + cmp #XA8E0 + bcc DoneXtrn +SymTblFull jmp TableFull ;Yes +; +; Do a XtnP++ to point @ the next empty slot in EXTRN table +; +DoneXtrn jsr IncrXtnP + jmp NxtEntryZ ;Prepare to process next rec in appended ESD +; +; Process an ENTRY symbol-type record in ESD of src file +; The 1st field is already done +; Layout of 24-byte records in ENTRY table @ $4700 +; offset +; 0 STR up to 16 chars including len byte +; 16 DB file # of src file (start fr 0) +; 17 DB symbol-type +; 18 DW relocated addr +; 20 DW 0 (Ptr to EXTRN record) - first/head +; 22 DW 0 (Ptr to EXTRN record) - last/tail +; +DoEntry bit Z9E ;Include code fr this file? + bmi DoEntry1 ;No +; + lda ESDRec+2 ;Hibyte of addr as recorded in src file + cmp SrcORG+1 ;Origin as recorded in src file + bcc DoEntry1 + lda L3806+1 ;addr+1 of last byte of code image + sec + sbc ESDRec+2 ;Hibyte of addr + bmi DoEntry1 ;Is addr to be relocated btwn + bne CalcAddr + lda ESDRec+1 ; addrs of 1st & last byte of image? + cmp L3806 + bcs DoEntry1 ;Out of range +; +; Calc relocated addr of the instruction +; First do an equivalent to a subtraction +; to obtain the inst' offset wrt +; the src file's origin +; +CalcAddr lda ESDRec+1 + clc + adc NegSrcOrg ;2's complement of + sta ESDRec+1 + lda ESDRec+2 + adc NegSrcOrg+1 ; src file's Origin + sta ESDRec+2 ;Got the offset +; + lda ESDRec+1 ;Calc the relocated addr + clc + adc CurrORG + sta ESDRec+1 + lda ESDRec+2 + adc CurrORG+1 + sta ESDRec+2 +; +DoEntry1 ldy #16 + lda ModNbr ;src file # + sta (EntRecP),y + iny + lda ESDRec ;symbol type + ora #%01000000 ;Set not-referenced bit + sta (EntRecP),y + iny + lda ESDRec+1 ;Relocated addr lo + sta (EntRecP),y + iny + lda ESDRec+2 ;Relocated addr hi + sta (EntRecP),y +; + lda #0 ;FOR Y=20 TO 24 +ZeroLup1 iny + cpy #24 + sta (EntRecP),y ;Set both links to NIL + bcc ZeroLup1 +; + ldy #0 + tya ;Zero len byte so that search will + sta (EntRecP),y ;not include this ENTRY rec + jsr ScanEntTbl ;Is this symbol already in ENTRY table? + php ;Save for later + lda (SymP),y ;Get a copy of len byte + sta (EntRecP),y ; & restore it + plp + bne NxtEntry ;Not in ENTRY table + jsr StorDupSym ;Record duplicate symbol +; +; Do a EntP++ to point @ the next empty slot in ENTRY table +; +NxtEntry jsr IncrEntP +; +NxtEntryZ jsr NxtESDRec ;Point @ next rec in appended ESD + lda $01,x ;(X)=$8A,$8C => (A)=$60,$00 (hi-byte of table?) + cmp GoShowMsgZ,x ;Locations $360D+$8A=$3697 or $3699 + beq TableFull ;A bug here & in the table + jmp ScanESD ;Scan next ESD record +; +TableFull ldy #$0A ;symtbl full + jsr GoShowMsg +; +; We have finishing processing the ESD of the curr file +; Do some housekeeping b4 processing the next file +; NB. If a src PN is preceded by an asterik, +; its SymbolicNames will be referenced but no +; object code will be incorporated into the +; final OBJ file. +; +DoneESD EQU * + bit Z9E ;Was src PN preceded by a ;? + bmi NxtSrc ;Yes => its code will not be incorporated in OBJ file +; + lda SrcCodeLen + clc + adc CurrORG ;Starting PC for + sta CurrORG ; the next src file + lda SrcCodeLen+1 + adc CurrORG+1 + sta CurrORG+1 +; +NxtSrc inc ModNbr + lda ModNbr + cmp #50 ;max # of src files + bcs TooMany + jmp Phs1Loop ;Process next src file +; +TooMany ldy #$0B ;Too many src files + jsr GoShowMsg +;================================================= +; Get the end of RLD +; Each record in the Relocation Dictionary is 4 bytes long +; Input +; SrcP - ptr to beginning of RLD chunk +; Output +; (Y)=0 +; SrcP - End of RLD if found +; Z=1 +; X - not used +; +; Possible bug here. The code should check that SrcP +; should not exceed upper limit of SrcDBuf ($2000) +; unless it's assumed that RLD is always < 5K. For +; this case, since each RLD record is 4 bytes, the max # +; of RLD records in a src file = (5x1024)/4 -1 = 1279 +; This rtn should be re-written to handle files with huge RLDs +; When the EO RLD is not found, it should check that +; SrcP == (SrcDBuf+FileDBSiz) by returning a flag to the caller +; +RLDEntSiz EQU 4 ;size of an RLD entry +GetEndRLD EQU * + ldy #0 +ScanLoop lda (SrcP),y ;Get RLD-flag byte + and #$01 ;Is it EO RLD? + beq doRTS4 ;Yes + lda #RLDEntSiz ;Point @ next RLD record + clc + adc SrcP + sta SrcP + lda #0 + adc SrcP+1 + sta SrcP+1 + jmp ScanLoop ;Continue scanning +doRTS4 rts +;================================================= +; Phase 2 of the Linking process +; This rtn will attempt to resolve EXTRN's by checking +; if its symbolic name is in the ENTRY table +; NB. After phase 1, some recs in EXTRN table are +; already in a singly-linked list. Their SymbolicName +; fields would have been changed to point to another +; EXTRN rec or is set to NIL if they happen to be +; the last node of the list. +; The msb of their flagbyte would be 0 (symbol is defined) +; +DoPhase2 EQU * + lda #0 + ldy #0 + sta (EntRecP),y ;Zero the len byte of ENTRY record + ldy #5 ; and flag byte of EXTRN record + sta (XtnRecP),y ;These recs are empty slots + ldy #$05 ;Resolving REF/EXTRN... + jsr DspMsg + jsr DspCR + ldy #$05 + jsr StorMsgY ;Store same msg +; + lda #>XtnTbl + sta XtnRecP ;Point to start + lda # EXTRN # +; offset 1 - 1st char whose msb is off -> msb on +; +L25C6 EQU * + ldy #0 + lda (XtnRecP),y ;Get ptr to the SymbolicName rec + sta SymP + iny + lda (XtnRecP),y + sta SymP+1 + ldy #1 ;Skip its len byte + lda (SymP),y ;Is msb of 1st char off? + bpl L25DD ;Yes + dey + lda (SymP),y ;No, get EXTRN # + jmp L25EA +; +L25DD inc XtnNbr ;EXTRN # + bne L25E4 + jmp ExtrnErr ;>255 EXTRN's in REL output ESD +; +L25E4 ora #$80 ;Set 1st char's msb to 1 + sta (SymP),y + lda XtnNbr ;EXTRN # +L25EA ldy #7 + sta (XtnRecP),y + ldy #0 + sta (SymP),y ;Overwrite len byte w/EXTRN # + rts + REP 50 +; +; Check if a SymbolicName is present in +; one of the recs of ENTRY table ($4700) +; Input +; SymP - ptr to a SymbolicName rec +; +; Output +; Z=1 - Yes +; Z88 - Ptr to the ENTRY record +; (Y)=0 +; Uses a brute force method to search for the key +; The search is conducted record by record until +; no more records are left to be processed +; +ScanEntTbl EQU * + lda #>EntTbl ;Start search fr BO ENTRY table + sta Z88 + lda # hit + rts +; +NoHit lda #24 ;Pointer size = 24 bytes + ldx #Z88 ;Ptr to be adjusted + jsr IncRecPZ ;Adv to next ENTRY record (Z88++) + ldy #0 + lda (Z88),y ;Get symbol's len byte fr ENTRY rec + bne ScanEntLup ;No EOT, so try again + ldy #0 + lda #1 ;Z=0 ==> Not found + rts +;================================================= +; Search if EXTRN symbol's name is in SymbolicName table ($9200) +; Input +; Output +; On return +; (Y)=0 +; Z=1 match +; (Z88) - ptr to symbolicname record +; +L2629 EQU * + lda #>SymTbl ;SymbolicName table + sta Z88 + lda # already referenced + eor (Z88),y ;Clear unreferenced bit + sta (Z88),y ; but retain the other bits +; +; The ENTRY rec is referenced the 1st time +; so create a singly-linked list by +; setting the first and last link to point +; to the same EXTRN rec +; + ldy #20 ;first link + lda XtnRecP + sta (Z88),y ;Ptr to EXTRN record + iny + lda XtnRecP+1 + sta (Z88),y ;Store in ENTRY rec +; + iny ;last link + lda XtnRecP ;Ptr to same EXTRN record + sta (Z88),y + iny ;23 + lda XtnRecP+1 + sta (Z88),y + rts +; +; The ENTRY symbol has been referenced more than once +; We add the new node to the end of the singly-linked list +; +L26B2 ldy #22 + lda (Z88),y ;Get ptr to "last" EXTRN record + sta Z82 ;Save it for later (prev) + lda XtnRecP + sta (Z88),y ;Set the "last" link to point + iny ;23 + lda (Z88),y ; to this EXTRN record + sta Z82+1 + lda XtnRecP+1 ; which now the last node + sta (Z88),y ;in the singly-linked list +; + ldy #0 + lda XtnRecP ;(Z82) - previously the "last" EXTRN record + sta (Z82),y ;Replace its "next" link (which was NIL) + iny + lda XtnRecP+1 ; with ptr to this EXTRN record + sta (Z82),y + rts + REP 50 +; +; Copy to pathame buf +; +L26D1 ldy TempESD ;len byte +L26D4 lda TempESD,y + sta PathNameB,y + dey + bpl L26D4 + rts +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Open a temporary binary ESD file for output +; This rtn will be called if there are unresolved +; EXTRN symbols +; +; Output +; (Z86) - ptr to tmpESD data buffer +; Write1P+c.refNum - EXTRN # used to write tempESD file +; +L26DE EQU * + jsr L26D1 ;Set PN to "EDASM.TEMPESD" + jsr PRODOS8 ;DESTROY + DB $C1 + DW DestryP +; + lda #0 + sta CreateP+c.auxId ;auxtype + sta CreateP+c.auxId+1 + lda #BINtype + sta CreateP+c.fileId + jsr PRODOS8 ;CREATE + DB $C0 + DW CreateP + beq L26FF + jsr ErrHndlr ;Don't come back +; +L26FF jsr PRODOS8 ;OPEN + DB $C8 + DW Open3P + beq L270A + jsr ErrHndlr ;Don't come back +; +L270A lda Open3P+c.outRef + sta Write1P+c.refNum;write RN for tempESD file +L2710 lda #>X9100 ;Reset to BO data buf + sta Z86 ; b4 next ESD rec is created + lda #EntTbl + sta Z8E ;Point @ BO ENTRY table + lda # re-cycled zp loc +; +L2721 jsr PollKbd + ldy #17 + lda (Z8E),y ;Get ENTRY record's flag byte + bit ERefF ;Include ENTRY records in tempESD file? + bmi L2733 ;Yes + and #$40 ;Is its SymbolicName still unreferenced? + bne L2733 ;Yes + jmp L2755 +; +L2733 jsr L27DE ;Copy symbolicname to tmpESD area + tya ;Save len of symbolicname name + pha + ldy #17 + lda (Z8E),y ;Get ENTRY record's flag byte again + and #%00111111 ;Clear undefined/unreferenced bits + sta ESDRec + iny + lda (Z8E),y + sta ESDRec+1 ;Relocated addr + iny + lda (Z8E),y + sta ESDRec+2 + pla + tay ;Restore Y + jsr L2818 ;Add ENTRY data to tempESD data buf + jsr L27C1 ;Write out to tempESD file +; +L2755 lda #24 ;Pointer size + ldx #Z8E + jsr IncRecPZ ;Next ENTRY record + ldy #0 + lda (Z8E),y ;Is EOT? + bne L2721 ;No + rts + REP 50 +; +; Scan through the EXTRN table for recs whose +; SymboliName remained undefined. Output info +; to tempESD file +; Input +; Output +; +L2763 EQU * + lda #>XtnTbl + sta XtnRecP + lda #X9100 ;Start of buffer + sta Write1P+c.reqCnt;writelen + lda Z86+1 + sbc #BIN/SYS +; + lda #$00 ;REL OBJECT file + sta X9100 + sta X9100+1 + sta Write1P+c.reqCnt+1;Write 2 zeroes for + lda #$02 ; the code image len + sta Write1P+c.reqCnt + jsr PRODOS8 ;WRITE + DB $CB + DW Write1P + beq L2941 + jsr ErrHndlr ;Don't come back +; +L2941 lda WrMapFP+c.refNum + jsr ClsFile + jsr OpTmpRLD ;Open a tempRLD file 4 writing +; +L294A jsr L343B ;Set file posn to BO cmd file +; +; Skip all directives at the BO cmd file +; to get at the src pathnames +; +L294D jsr Read1Cmd ;Get a src filename + bne Phs3Loop ;Not cr/space => pathname + cmp #CR + bne L294D ;A leading space, skip to the directive + jmp CmdOrderErr ;Invalid cmd order +; +; Mainloop for phase 3 +; +Phs3Loop jsr DspLineB ;Show PN of the curr src + jsr OpenSrc ;Open it 4 reading + bit Z9E ;Is src PN preceded by ;? + bpl L296C ;No +; + lda OpSrcFP+c.outRef;Close it + jsr ClsFile + jmp L2B55 ;Skip reading fr it +; +L296C lda #2 + clc + adc SrcCodeLen ;Set file posn to BO + sta SMSrcFP+c.mark + lda #0 + adc SrcCodeLen+1 + sta SMSrcFP+c.mark+1; Relocation Dictionary +; + lda OpSrcFP+c.outRef + sta SMSrcFP+c.refNum + sta RdCodeImgP+c.refNum + jsr PRODOS8 ;SET_MARK + DB $CE + DW SMSrcFP + beq L2991 +L298E jsr ErrHndlr ;Don't come back +; +L2991 jsr L3348 ;Have we read entire RLD? + bcc L2999 ;Yes + jsr ErrHndlr ;Don't come back +; +L2999 lda #2 ;Set file posn to BO + sta SMSrcFP+c.mark ; code image of src file + lda #0 + sta SMSrcFP+c.mark+1 + jsr PRODOS8 ;SET_MARK + DB $CE + DW SMSrcFP + bne L298E +; + lda #0 + sta LwrBound + sta LwrBound+1 + sta UprBound + sta UprBound+2 + jsr Rd1PgImg ;Read the first $100 bytes of code image +; +; Loop to process all recs in the RLD of curr src file +; +L29B8 jsr PollKbd + ldy #0 + lda (SrcP),y ;Get flag byte fr RLD record + sta RLDFlags + bne L29C7 + jmp L2B13 ;EO RLD => done w/this src file +; +; The code below doesn't check for overflow +; What happens if field offset is a # +; > $6EFF? +; +L29C7 ldy #1 + lda (SrcP),y + sta Z80 ;Field offset in code image + clc + adc #>X9100 + sta Z86 + iny + lda (SrcP),y + sta Z80+1 + adc # BIN/SYS +; + ldy #2 + lda Z80 ;Field offset + clc + adc Z96 ;Len of Code Image of + pha + lda Z80+1 ; REL OBJECT file excluding + adc Z96+1 ; that of curr src file + sta (SrcP),y ;Patch field offset of RLD record + dey ;Y=1 + pla + sta (SrcP),y +; +L2A0E bit RLDFlags ;Is size of relocatable field 2? + bmi L2A54 ;Yes +; + ldy #0 ;Get original addr (lo/hi) + lda (Z86),y ; byte fr the code image + bit RLDFlags ;Is it hi-8 of addr? + bvs L2A31 ;Yes +; +; (A) has the lo-8 of the addr (fr a > byte operator) +; Since only the lobyte is used to patch the code +; any value for the hibyte can be used. So let's +; use 0 as RelAdrHi +; + sta RelAdr + lda #$00 + sta RelAdr+1 + jsr L30D9 ;Calc/get relocated addr + ldy #0 + lda RelAdr ;Use the lo 8-bit to + sta (Z86),y ; patch the code image + jmp L2A96 ;Skip code below +; +; (A) has the hi-8 of the addr (fr a < byte operator) +; For this case, we need both the low & high bytes +; of the original addr if relocation rec is not +; flagged as EXTRN symbol-type +; +L2A31 sta RelAdr+1 ;hi-byte + ldy #3 + lda (SrcP),y ;lo 8-bits/EXTRN symbol # + sta RelAdr + lda RLDFlags ;Get RLD flag byte + and #$10 ;EXTRN symbol-type? + beq L2A47 ;No +; + lda #$00 + sta RelAdr ;Overwrite EXTRN symbol # +; +; On fall thru, the relocated addr will not be +; calculated but obtained fr an ENTRY rec if +; it is available. +; +L2A47 jsr L30D9 ;Calc/get the relocated addr + ldy #0 + lda RelAdr+1 + sta (Z86),y ;Patch code image + jmp L2A96 ;Skip code below +; +; Size of relocatable field is 2 +; Get relocated addr fr the RLD rec +; +L2A54 ldy #0 + lda RLDFlags ;Get RLD rec's flag byte + and #$20 ;Normal/Reversed order? + bne L2A7B + lda (Z86),y ;Little Endian (reversed order) + sta RelAdr + iny + lda (Z86),y + sta RelAdr+1 + jsr L30D9 ;Calc/get relocated addr +; + ldy #0 + lda RelAdr + sta (Z86),y ;Patch the code + iny + lda RelAdr+1 + sta (Z86),y + jmp L2A96 ;=>next RLD +; +; Handle a Big Endian +; +L2A7B lda (Z86),y + sta RelAdr+1 ;hiaddr + iny + lda (Z86),y + sta RelAdr ;loaddr + jsr L30D9 ;Calc/get relocated addr + ldy #0 + lda RelAdr+1 + sta (Z86),y ;Patch the code + iny + lda RelAdr + sta (Z86),y +; +L2A96 lda #4 ;Pointer size + ldx #SrcP + jsr IncRecPZ ;Adv SrcP to next RLD rec + jmp L29B8 ; loop back to process it + REP 50 +; +; Flush object code if neccessary. Move buffered +; code forward into "window" so that another page +; of code image can be read into the $9200 data buffer +; The variables LwrBound & UprBound gives a "window" +; into the code image. +; Normally (UprBound - LwrBound) = $100 except when +; the last (partial) page of code is read. In this +; case (UprBound - LwrBound) < $100 +; Input +; LwrBound - +; UprBound - +; Output +; UprBound - +; +L2AA0 EQU * + lda UprBound ;Do we need to flush OBJECT code b4 + ora UprBound+2 ; b4 we "move" our window forward? + beq L2AA9 ;No, we are still @ BO of src file + jsr L2AD8 ;Yes +; +L2AA9 ldy #0 ;Move buffered Code Image +L2AAB lda X9200,y ; forward into our "window" + sta X9100,y ; @ $9100-$91FF so we can + iny + bne L2AAB + jsr Rd1PgImg ; load another page @ $9200 +; + lda UprBound + sta LwrBound + lda UprBound+2 + sta LwrBound+1 + inc UprBound+2 ; Incr by 1 page +; + lda UprBound + cmp SrcCodeLen ;Has the entire code + lda UprBound+2 + cmp SrcCodeLen+1 ; image been read? + bcc L2AD7 ;No +; + lda SrcCodeLen + sta UprBound ;This may no longer be + lda SrcCodeLen+1 + sta UprBound+2 ; 1 mempage > LwrBound +L2AD7 rts + REP 50 +; Write object code @ $9100 +; Input +; Output +; +L2AD8 EQU * + sec + lda UprBound + sbc LwrBound + sta Write1P+c.reqCnt;# of bytes to write + lda UprBound+2 + sbc LwrBound+1 + sta Write1P+c.reqCnt+1; usually $100 bytes + jsr PRODOS8 ;WRITE + DB $CB + DW Write1P + beq L2AD7 +; +L2AEF jsr ErrHndlr ;Don't come back +; +; Read $100 bytes of data into buf starting @ $9200 +; fr src file. The symbolicname table @ $9200 is +; re-used as a Read data buf +; Output +; Z=1 +; (A) = $4C if EOF or +; = $00 read succeeded +; +Rd1PgImg EQU * + lda #0 + sta RdCodeImgP+c.reqCnt + lda #1 + sta RdCodeImgP+c.reqCnt+1 + lda #>X9200 ;Read Data Buf + sta RdCodeImgP+c.dataBuf + lda # err handler + rts +; +; Skip rest of code image +; +L2B13 EQU * + lda UprBound + cmp SrcCodeLen + bne L2B21 + lda UprBound+2 + cmp SrcCodeLen+1 + beq L2B27 ;Done w/this src file +L2B21 jsr L2AA0 ;Keep flushing objcode N reading code image + jmp L2B13 ; until we are done +; +L2B27 jsr L2AD8 ;Append rest of OBJECT code + lda RdCodeImgP+c.refNum + jsr ClsFile + jsr Add2TmpRLD ;Append patched RLD @ SrcDBuf +; + ldx ModNbr + lda CurrORG ;Starting posn counter + sta OrgAdrLo,x ; for this src file + lda CurrORG+1 + sta OrgAdrHi,x + jsr L2BA2 ;adj pc? +; + lda CurrORG+1 + sta EndAdrHi,x + lda CurrORG + sta EndAdrLo,x + bne L2B52 + dec EndAdrHi,x ;End posn counter +L2B52 dec EndAdrLo,x ; for this src file +; +L2B55 inc ModNbr ;Next src module +L2B58 jsr Read1Cmd ;Is it a pathname? + bne L2B9C ;Yes, prepare to loop back + cmp #CR + beq DonePhs3 ;Empty line => Finish all cmds + jsr IsALN ;Is it Align directive? + bcc L2B69 ;Possible + jmp DoBreak ;Don't comeback +; +L2B69 beq L2B6E ;Align option + jmp CmdOrderErr ;cmd order err +; +L2B6E lda CurrORG ;Already aligned @ start of mempage? + beq L2B58 ;Yes, read another cmd line +; + ldx #0 + txa +L2B75 sta X9100,x + inx + bne L2B75 +; + lda #0 + sec + sbc CurrORG + sta Write1P+c.reqCnt;# of zero bytes to fill + sta SrcCodeLen ; Re-used + lda #0 + sta Write1P+c.reqCnt+1 + sta SrcCodeLen+1 ;Used by $2BA2 + jsr PRODOS8 ;WRITE + DB $CB + DW Write1P + bne L2B9F +; + jsr L2BA2 ;Adj PC + jmp L2B58 ;Read next cmd line +; +L2B9C jmp Phs3Loop ;Loop back to process new src file +; +L2B9F jsr ErrHndlr ;Don't come back + REP 50 +; Adjust file posn +; Input +; Output +; (Z96) - curr val of code image len +; +L2BA2 lda SrcCodeLen + clc + adc CurrORG + sta CurrORG ;CurrORG += SrcCodeLen + lda SrcCodeLen+1 + adc CurrORG+1 + sta CurrORG+1 + bit FTypeF ;REL OBJECT file? + bpl L2BC4 ;No -> exit +; + clc + lda SrcCodeLen + adc Z96 + sta Z96 ;Z96 += SrcCodeLen + lda SrcCodeLen+1 + adc Z96+1 + sta Z96+1 +L2BC4 rts +; +; Prepare to exit Phase 3 +; +DonePhs3 bit FTypeF ;REL OBJECT file? + bpl L2BD8 ;No +; + ldy #0 + sty SrcDBuf + sty Write2P+c.reqCnt+1 + iny ;=1 + sty Write2P+c.reqCnt;# of bytes to write=1 + jsr L31C1 ;Marks EO RLD file +; +L2BD8 bit FTypeF ;Is REL OBJECT file? + bmi DoPhase4 ;Yes + jmp L2C8E +;================================================= +; Phase 4 of the Linking process done only if +; the OBJECT file is of type REL +; Contents of TempRLD and TempESD files are appended +; to the relocatable OBJECT file +; Input +; Output +; +DoPhase4 ldy #$07 + jsr DspMsg + jsr DspCR + lda Write2P+c.refNum;RN of tempRLD file + sta SMarkP+c.refNum + jsr PRODOS8 ;SET_MARK + DB $CE + DW SMarkP ;Set file posn to BO tempRLD file + beq L2BF8 + jsr ErrHndlr ;Don't come back +; +L2BF8 jsr L2C5A ;Append tempRLD to REL OBJECT file + lda Write2P+c.refNum + jsr ClsFile ;Now close tempRLD file + jsr PollKbd + jsr L26D1 ;Set PN to TempESD + jsr PRODOS8 ;OPEN + DB $C8 + DW Open2P + beq L2C12 + jsr ErrHndlr ;Don't come back +; +L2C12 lda Open2P+c.outRef + sta Write2P+c.refNum + jsr L2C5A ;Append TempESD to REL OBJECT file + lda Write2P+c.refNum + jsr ClsFile ;Now close tempESD +; + lda Open3P+c.outRef + sta SMarkP+c.refNum ;Posn to BO REL OBJECT file + jsr PRODOS8 ;SET_MARK + DB $CE + DW SMarkP + beq L2C32 + jsr ErrHndlr ;Don't come back +; +L2C32 lda Z96 ;Write the CodeImage Len + sta X9100 + lda Z96+1 ; of REL OBJECT file + sta X9100+1 + lda #0 + sta Write1P+c.reqCnt+1 + lda #2 + sta Write1P+c.reqCnt;2 bytes only + jsr PRODOS8 ;WRITE + DB $CB + DW Write1P + beq L2C51 + jsr ErrHndlr ;Don't come back +; +L2C51 jsr PollKbd + jsr L31CD ;Open LinkMap file for appending + jmp L2C8E + REP 50 +; +; ($2C5A) Read entire contents of tempRLD/tempESD +; and append it to the OBJECT file (which is of +; type REL) +; Input +; Output +; +L2C5A lda Write2P+c.refNum;RN of tempRLD/tempESD file + sta RWFileP+c.refNum + jsr L334E ;Read data chunk fr file + php ;Save for later + bcc L2C6D + cmp #$10 + beq L2C6D ;Not EOF + jsr ErrHndlr ;Don't come back +; +L2C6D lda Open3P+c.outRef ;OBJECT file's RN + sta RWFileP+c.refNum;Write same data chunk + lda RWFileP+c.transCnt + sta RWFileP+c.reqCnt + lda RWFileP+c.transCnt+1 + sta RWFileP+c.reqCnt+1;to the OBJECT file + jsr PRODOS8 ;WRITE + DB $CB + DW RWFileP + beq L2C8A + jsr ErrHndlr ;Don't come back +L2C8A plp ;Has last chunk been read? + bcs L2C5A ;No, do another chunk + rts +; +L2C8E EQU * + lda Open3P+c.outRef ;Finally, close OBJECT file + jsr ClsFile + bit FTypeF ;Was it relocatable OBJECT file? + bpl L2C9D ;No +; + ldy #$07 ;Phase 4... + jsr StorMsgY +L2C9D bit MapFileF ;Output to LinkMap? + bmi L2CA4 ;Yes + jmp L2E10 +; +L2CA4 bit SortLMF ;Sort LoadMap table? + bmi DoPhase5 ;Yes + jmp L2E10 +;================================================= +; Phase 5 of the Linking process +; Sort Relocated Adr table +; First create a LoadMap table of 4-byte records +; The LoadMap table starts @ $9100 +; Layout of each record is: +; DW ptr to an ENTRY table rec +; DW relocated addr stored in the ENTRY table rec +; +; Output: +; (EntRecP) - ptr to a rec in ENTRY table +; (Z86) - ptr to a rec in LoadMap table +; (Z80) - ptr to EO LoadMap table +; +DoPhase5 ldy #$08 + jsr DspMsg + jsr DspCR + ldy #$08 + jsr StorMsgY +; + lda #>EntTbl ;ENTRY table is still in mem + sta EntRecP ;Set up a ptr to its beginning + lda #X9100 ;4-byte records in LoadMap table + sta Z86 + lda # 0 +; +WhileLoop lsr Jump+1 ;Jump=Jump div 2 + ror Jump + lda Jump + ora Jump+1 + bne L2D2C + rts +; +L2D2C sec + lda NumRecs + sbc Jump + sta EndIdx + lda NumRecs+1 + sbc Jump+1 + sta EndIdx+1 +; + ldx #0 + stx StrtIdx+1 + inx + stx StrtIdx +ForLoop jsr PollKbd +; +; FOR JJJ := 1 to NumRecs-Jump +; + lda StrtIdx + sta JJJ + lda StrtIdx+1 + sta JJJ+1 +; +; REPEAT +; +RptLoop clc + lda JJJ + adc Jump + sta III ;I=J+Jump + lda JJJ+1 + adc Jump+1 + sta III+1 +; + ldx #3 +L2D5A lda JJJ,x + sta J.TH,x + dex + bpl L2D5A +; +; Mulby4 and add to X9100-4 +; Calc indices to the elements to be compared +; (J.TH) - Ptr to j-th element +; (I.TH) - Ptr to i-th element +; + ldx #2 +L2D63 asl J.TH,x ;x4 + rol J.TH+1,x + asl J.TH,x + rol J.TH+1,x +; + clc + lda #>X9100-4 + adc J.TH,x + sta J.TH,x + lda # Swap the records +; +; Sort SymbolicName alphabetically +; IF ENTRY[J].name > ENTRY[I].name then SWAP(Ary[J], Ary[I]) +; The 1st field of an ENTRY rec is a 16-byte p-string +; +L2D98 ldy #0 + lda (J.TH),y ;Get ptr to j-th + tax ; ENTRY rec + iny + lda (J.TH),y + sta EntRPJ+1 + stx EntRPJ + lda (I.TH),y + tax + dey ;=0 + lda (I.TH),y ;Get ptr to i-th + sta EntRPI ; ENTRY rec + stx EntRPI+1 + lda (EntRPJ),y ;Get len byte of symbolic name + cmp (EntRPI),y + beq L2DB8 + bcc L2DB8 +; + lda (EntRPI),y ;The len of this symbolic name is shorter +L2DB8 tax ;# of chars to compare + iny ;=1 +L2DBA lda (EntRPJ),y ;Get char fr symbolic name + cmp (EntRPI),y + bne L2DCF ;Not match + iny + cpy #16 ;At most 15 chars will be compared + bcs NextJ ;All chars matched + dex + bne L2DBA + lda #SPACE + cmp (EntRPJ),y + beq NextJ + sec ;Flag we have to do a swap +L2DCF bcc NextJ ;C=0 -> 1st symbolic name < 2nd +; +; Swap the records in LoadMap +; Too costly to swap those in ENTRY table +; + ldy #3 +L2DD3 lda (J.TH),y ;Swap the ptrs as + tax + lda (I.TH),y + sta (J.TH),y ; well as the corr addrs + txa + sta (I.TH),y + dey + bpl L2DD3 +; + sec + lda JJJ ;J > Jump + sbc Jump + sta JJJ + lda JJJ+1 + sbc Jump+1 ;J := J - Jump + sta JJJ+1 ;Is J > Jump? + bmi NextJ ;No, less than + ora JJJ + beq NextJ ;No, J=Jump + jmp RptLoop +; +; UNTIL JJJ =< Jump +; +NextJ inc StrtIdx + bne L2DFC + inc StrtIdx+1 +; +L2DFC lda StrtIdx+1 ;Finis w/FOR loop + cmp EndIdx+1 + bcc L2E0D + beq L2E07 +L2E04 jmp WhileLoop ;No +L2E07 lda EndIdx + cmp StrtIdx + bcc L2E04 +L2E0D jmp ForLoop +;----- +L2E10 bit MapFileF ;Write LinkMap? + bmi DoPhase6 ;Yes + jmp OK2Exit +;================================================= +; Phase 6 of the Linking process +; Makes use of LoadMap table to store info +; into the LinkMap txtfile +; +DoPhase6 ldy #$09 + jsr DspMsg + jsr DspCR + ldy #$09 + jsr StorMsg + jsr StorCR + jsr L343B ;Reset to BO cmd line file + jsr StorCR + jsr StorCR + lda #0 + sta ModNbr + sta L380F ;counter + sta PageF ;Don't output to printer +; +L2E3A jsr PollKbd + jsr Read1Cmd + bne L2E4F ;If non-blank & not cr, it's a PN + cmp #CR ;Is 1st char a CR? + bne L2E49 ;No, a leading space, ignore it + jmp L2ED3 ;No more directives +L2E49 jsr StorCmd ;Just store cmd in LinkMap file + jmp L2E3A ;Get another command +; +; Got the Pathname of a src file +; +L2E4F jsr StorCR + jsr StorCR + ldy #$18 ;MOD ORG etc + jsr StorMsg + ldy #$19 ;# ADR ADR etc + jsr StorMsg + jsr StorCR + jmp L2E76 ;-> proceed to start storing info +; +; Loop to get the PN of another src file +; +L2E65 jsr PollKbd + jsr Read1Cmd + bne L2E76 ;Not cr/space + cmp #CR + beq L2ED3 ;No more commands => done + jsr L2F43 ;Set module's Addr Range + beq L2E88 ;always +; +; Start writing info into LinkMap file +; +L2E76 jsr StorSpc + lda ModNbr + jsr StorByte + jsr StorSpc + jsr StorSpc +; + ldx L380F ;Get src file index +L2E88 lda OrgAdrHi,x ;Start Addr + jsr StorByte + lda OrgAdrLo,x ; of this src module + jsr StorByte +; + lda #'-' + jsr StorChar + lda EndAdrHi,x ;Its End Addr + jsr StorByte + lda EndAdrLo,x + jsr StorByte + jsr StorSpc + jsr StorSpc +; + ldy #0 +L2EAD jsr ChrGot ;Store PN + cmp #CR + beq L2EBA + jsr StorChar + iny + bne L2EAD +; +L2EBA jsr StorCR + cpx L380F + bne L2ED0 +; + sed + lda ModNbr + clc + adc #1 + sta ModNbr + cld + inc L380F +L2ED0 jmp L2E65 ;Loop back for next module +; +L2ED3 bit XRefF ;Did user ask for xferencing? + bpl ExitPhs6 ;No +; + lda #$80 + sta PageF + jsr L2FE4 ;Store header details etc... + bit SortLMF ;Did we sort the LoadMap table? + bpl L2F09 ;No +; +; Use Sorted LoadMap table +; + lda #>X9100 + sta Z86 + lda #EntTbl ;Points to BO of ENTRY table + sta Z88 + lda # not referenced by any module +; Input +; Output +; +L3029 EQU * + ldy #17 + lda (Z88),y ;Get flag byte + and #%01000000 + beq L3037 + ldy #$16 ;unreferenced + jsr StorMsg + rts +; +L3037 lda Z88 ;Ptr to ENTRY record + sta XtnRecP + lda Z88+1 + sta XtnRecP+1 +; + ldy #20 +L3041 lda (XtnRecP),y ;Ptr to linked list + pha + iny + lda (XtnRecP),y ; of EXTRN records + sta XtnRecP+1 + pla + sta XtnRecP + ora XtnRecP+1 + beq L3072 ;NIL => end of linked list +; + ldy #4 + lda (XtnRecP),y ;(A)=# to be converted + ldy #0 ;ten's digit + jsr L3079 + jsr StorSpc + lda WrMapFIdx ;# of bytes in Map file's data buf + ldy #0 + cmp #77 ; must not exceed this number + bcc L3041 ;Next node +; + jsr StorCR + ldy #26 ;# of spaces + jsr StorSpcsY + ldy #0 + jmp L3041 ;Next Node in linked list +L3072 rts + REP 50 +; Store REL file # as a 2-byte ASC char in LinkMap file +; Input +; Output +; +StorRFNbr ldy #16 + lda (Z88),y ;REL file # + ldy #0 +L3079 cmp #10 + bcc L3084 + sec + sbc #10 + iny ;ten's digit + jmp L3079 +; +L3084 pha ;unit's digit + tya + ora #'0' + jsr StorChar + pla + ora #'0' + jsr StorChar + rts + REP 50 +; Store ENTRY record's name +; Input +; (Z88) - ptr to ENTRY record +; Output +; +StorName EQU * + ldy #0 + lda (Z88),y ;len byte + cmp #16 + bcc L309C +; + lda #15 ;At most 15 +L309C tax +L309D iny + lda (Z88),y ;symbolname + jsr StorChar + dex + bne L309D +; + sty SymLen ;# of chars stored so far + sec + lda #16 + sbc SymLen + tay ;# of spaces to store +; +; Enter here with (Y)=# of space to store +; +StorSpcsY EQU * + lda #SPACE + jsr StorChar + dey + bne StorSpcsY + rts + REP 50 +; Store Relocated address in LinkMap file +; Input +; (Z88)-ptr to ENTRY record +; Output +; +StorAdr EQU * + ldy #19 + lda (Z88),y ;Relocated Addr + jsr StorByte + dey + lda (Z88),y ;of this ENTRY record + jsr StorByte + jsr StorSpc + rts + REP 50 +; Store cmd line incl terminating CR +; Input +; (cp) +; Output +; +StorCmd EQU * + ldy #0 +L30CC lda (cp),y + and #$7F + jsr StorChar + iny + cmp #CR + bne L30CC + rts + REP 50 +; If an RLD entry of src file flag its an +; (a) ENTRY symbol, calc relocated addr +; (b) EXTRN symbol, get relocated addr +; fr its associated ENTRY rec & +; we must modify the +; RLD & EXTRN recs +; Input +; RLDFlags +; Output +; RelAdr - value of relocated addr +; +L30D9 EQU * + lda RLDFlags + and #$10 ;Is EXTERN symbol? + bne L3105 ;Yes +; + lda RelAdr ;This is equiv to a subtraction + clc + adc NegSrcOrg ;2's complement of + sta RelAdr + lda RelAdr+1 + adc NegSrcOrg+1 ; origin in src file + sta RelAdr+1 +; + lda RelAdr + clc + adc CurrORG + sta RelAdr + lda RelAdr+1 + adc CurrORG+1 + sta RelAdr+1 + rts +; +; EXTRN symbol +; +L3105 ldy ModNbr ;Get ptr to the + lda SrcModTLo,y ; first EXTRN rec + sta XtnRecP ; of curr src file + lda SrcModTHi,y + sta XtnRecP+1 +; +; Search thru the EXTRN recs for the EXTRN symbol # +; NB. A hit is guaranteed during the search +; through the sub-array of EXTRN recs +; + lda #0 + sta RelAdr + sta RelAdr+1 + ldy #3 ;Get the EXTRN symbol # + lda (SrcP),y ; fr RLD record of src file +L311E ldy #6 + cmp (XtnRecP),y + beq L312A ;Matched + jsr IncrXtnP + jmp L311E ;Try next EXTRN rec +; +L312A ldy #5 + lda (XtnRecP),y ;symbol type + and #%10111111 ;Clear unreferenced bit + sta (XtnRecP),y + and #$80 ;Is the symbolicname still undefined? + bne L316D ;Yes +; + ldy #2 + lda (XtnRecP),y ;Get ptr to associated + sta Z82 ; ENTRY record + iny + lda (XtnRecP),y + sta Z82+1 +; + ldy #18 + lda (Z82),y ;Get relocated addr fr ENTRY record + sta RelAdr ;lo + iny + lda (Z82),y + sta RelAdr+1 ;hi +; + bit FTypeF ;Is it OBJECT file relocatable? + bpl L3179 ;No, just ret +; +; The OBJECT file is of type REL +; We need to patch the curr RLD rec +; + ldy #0 ;Get flag byte fr + lda (SrcP),y ; RLD rec of src file + and #%11101111 ;Mark symbol is no + sta (SrcP),y ; longer EXTRN-type since + ldy #3 ; symbolicname is defined + and #%11000000 + cmp #$40 ;lo 8 bits? + bne L3166 ;=>hi 8 bits +; + lda RelAdr ; Use lo 8-bits to patch + DB $2C +L3166 lda #0 ;Use 0 to patch + sta (SrcP),y ; the RLD record + jmp L3179 ;Done +; +; The symbolicname had not been defined +; +L316D bit FTypeF + bpl L3179 +; +; If the target OBJECT file is REL then +; patch the RLD entry of the src file +; Once again we assume the RLD is < 5K +; since the patched RLD was written out only +; when processing of the src file is complete +; + ldy #7 ;Get the EXTRN # that + lda (XtnRecP),y ; was assigned by the Linker + ldy #3 ; & replace that in the RLD rec which + sta (SrcP),y ; was assigned by the Assembler +L3179 rts + REP 50 +; Setup to open and write a TempRLD binary file +; Input +; Output +; Write2P+c.refNum - RN to write tempRLD file +; +OpTmpRLD EQU * + ldy TempRLD +L317D lda TempRLD,y + sta PathNameB,y + dey + bpl L317D +; + jsr PRODOS8 ;DESTROY + DB $C1 + DW DestryP + lda #BINtype + sta CreateP+c.fileId + jsr PRODOS8 ;CREATE + DB $C0 + DW CreateP + beq L319C + jsr ErrHndlr ;Don't come back +; +L319C jsr PRODOS8 ;OPEN + DB $C8 + DW Open2P + beq L31A7 + jsr ErrHndlr ;Don't come back +; +L31A7 lda Open2P+c.outRef + sta Write2P+c.refNum;write RN of tempRLD file + rts + REP 50 +; Append patched RLD of curr src file to the tempRLD file +; Input +; Output +; +Add2TmpRLD EQU * + bit FTypeF ;Is OBJECT file of type REL? + bpl L31CC ;No +; + sec + lda SrcP + sbc #>SrcDBuf + sta Write2P+c.reqCnt;writelen + lda SrcP+1 + sbc #LoadAdrEd + sta EdLoadAdr + lda #$2000 + sta EdRdLen + lda #<$2000 + sta EdRdLen+1 + jsr PRODOS8 ;OPEN + DB $C8 + DW OpenEdP + beq Opened1 + jsr FatalErr +; +Opened1 lda EdRefNbr + sta RdEdRefNbr + jsr PRODOS8 ;READ + DB $CA + DW RdEdP + beq Loaded1 + jsr FatalErr +; +Loaded1 lda RdEdRefNbr + sta CloseP+c.refNum + jsr PRODOS8 ;CLOSE + DB $CC + DW CloseP + beq Closed1 + jmp FatalErr +; +Closed1 jsr S2CurrPfx + bcs FatalErr +;================================================= +; Setup memory map for Editor/Command Interpreter +;================================================= + lda #%11111111 ;$FF + sta BitMap+20 + lda #%00011111 ;$1F + sta BitMap+19 + lda #%01111111 ;$7F + sta BitMap+22 + lda #%10000001 ;$81 + sta BitMap+23 +; +; TxtBgn=$0801 +; + lda #CR + dec TxtBgn ;Put a CR @ $0800 + ldy #$00 + sta (TxtBgn),y + inc TxtBgn ; and @ $0801 + sta (TxtBgn),y + rts +;================================================= +FatalErr EQU * + sta $FE ;Save err code + tsx + stx $FF ;Save stack ptr +; + ldx #$80 + txs + lda RDROM2 ;Read ROM; no write + jsr SETKBD ;reset input to keyboard + jsr SETVID ;reset output to screen + jsr HOME ;home cursor and clear screen + jsr PRERR ;print "ERR" + jmp MON ;std monitor entry w/beep +;================================================= +; Set prefix to EDASM's dir +;================================================= +PfxEdAsm EQU * + jsr PRODOS8 ;SET_PREFIX + DB $C6 + DW EdAsmPfxP + rts +;================================================= +; Set prefix to current prefix +;================================================= +S2CurrPfx EQU * + jsr PRODOS8 ;SET_PREFIX + DB $C6 + DW SCurrPfx + rts +;================================================= +; EDASM Editor's parameter blocks +;================================================= +EditorS STR 'EDASM.ED' + DB $00 +; +OpenEdP DB $03 + DW EditorS + DW XA900 ;1024-byte buffer +EdRefNbr DB $CB +; +RdEdP DB $04 +RdEdRefNbr DB $D0 +EdLoadAdr DW $A0A0 +EdRdLen DW $A0D3 ;Caller must set this + DW $CBA0 ;actual len read +; +EdAsmPfxP DB $01 + DW EdAsmDir +; +SCurrPfx DB $01 + DW CurrPfxB +;================================================= +; Move a block of src code fr one mem location to +; another mem location (not including byte @ +; location (Z80) +; Input +; SrcP - Start addr of data +; Z80 - End addr of data +; Z82 - Destination addr +; Output +; (Z82) +; (SrcP) +; (Y)=0 +; +MovData EQU * + ldy #0 +MovLoop3 lda (SrcP),y + sta (Z82),y + inc Z82 + bne Bump2 + inc Z82+1 +Bump2 lda SrcP ;Copy until + cmp Z80 + lda SrcP+1 + sbc Z80+1 ; (Z80)=(SrcP) + inc SrcP + bne Bump3 + inc SrcP+1 +Bump3 bcc MovLoop3 + rts +;================================================= +; This rtns adjust the ptrs to the next +; element of their respective arrays +; +IncrXtnP EQU * + pha ;Save + lda #8 ;rec size + ldx #XtnRecP ;EXTRN table + jmp IncRecP +; +IncrEntP EQU * + pha + lda #24 + ldx #EntRecP ;ENTRY table + jmp IncRecP +; +IncrSymP EQU * + pha ;Save + lda #16 + ldx #SymP ;SymbolicName table +; +; (A)=# to add to pointer stored in 2 consecutive mem locations +; (X)=offset into zero page +; +IncRecP EQU * + clc + adc $00,x + sta $00,x + lda #0 + adc $01,x + sta $01,x + pla ;Restore + rts + REP 50 +; +; Input +; (A)=# to add to pointer stored in 2 consecutive mem locations +; (X)=offset into zero page +; Output +; Same logic as above except (X) can be an index into +; ANY zeropage location +; +IncRecPZ pha + jmp IncRecP + REP 50 +; +; Advance SrcP to next ESD record +; Input +; Output +; X - unchanged +; +NxtESDRec EQU * + ldy #0 +BumpLoop lda (SrcP),y ;symbolicname + bpl GotLastCh ;Got last char + iny + jmp BumpLoop +; +GotLastCh iny + iny + iny + iny + tya + clc + adc SrcP ;SrcP now pointing @ next ESD + sta SrcP + lda #0 + adc SrcP+1 ; record in the curr src file + sta SrcP+1 + rts +;================================================= +; There are 3 entry points in this part of the code +; Input +; OpSrcFP+c.outRef - file ref # of src (REL) file +; Output +; C=0 - Last chunk of data had been read +; C=1 & (A)=$10 - Not EOF +; C=1 & (A)=$4C - EOF +; (SrcP) points to BO SrcDBuf +;================================================= +L3348 EQU * + lda OpSrcFP+c.outRef + sta RWFileP+c.refNum +; +; Use this entry point to attempt to read a fixed chunk +; of data (equal to the size of the data buffer) fr a +; ANY file into the beginning of the Data Buffer ($0C00) +; (SrcP) points to BO of this data buf (SrcDBuf) +; +L334E EQU * + lda #>SrcDBuf + sta RWFileP+c.dataBuf + lda #FileDBSiz ;# of bytes to be read=5K + sta RWFileP+c.reqCnt + lda #SrcDBuf + sta SrcP + lda # last chunk of data read + rts ; since NumRead < ReqLen +L3384 lda #$10 ;= but not EOF, so use $10 to flag it +ReadErrs sec + rts +;================================================= +; Print Message +; The terminating char of each message in +; this table is a backslash +; Input +; Output +; (Y)=index into Message Table whose addresses +; are split into 2 sub-tables +; +DspMsg EQU * + lda MsgTLo,y + sta MsgP + lda MsgTHi,y + sta MsgP+1 + ldy #0 +DspLoop lda (MsgP),y + cmp #'\' ;terminator + beq DspMsgX + jsr CharOut + iny + jmp DspLoop +DspMsgX rts +;================================================= +; Setup the filename using a cmd line +; Input +; Output +; +GetSrcPN EQU * + ldy #-1 +MovLoop4 iny + lda (cp),y + and #$7F + sta PathNameB+1,y + cmp #CR ;CR + bne MovLoop4 + sty PathNameB ;len byte + rts +;================================================= +; Open a src file by getting its filename from +; the command file +; Get len of its code image and compute the +; addr past its last byte. +; Input +; Output +; C=1 - err +; (A)=err code +; (Z9E)=$80 - src file will be read but EXTRN records will +; not be created fr its ESD. Its code will not be included into +; the OBJECT file. ENTRY and SymbolicName records are created. +; This may be used to facilitate overlays rather than +; hand-patching JSR/JMP etc addresses +; Todo: Check it +; NB: SymbolicName records are created fr info in the +; appended ESD of all src files. +; +OpenSrc EQU * + ldy #0 + sty Z9E + lda (cp),y + cmp #'*' + bne L33C8 + inc cp ;Skip to next char + bne L33C4 + inc cp+1 +L33C4 lda #$80 ;Flag code from src file + sta Z9E ; will NOT be included in OBJ file +; +L33C8 jsr GetSrcPN ;First get the src file's name + jsr PRODOS8 ;OPEN + DB $C8 + DW OpSrcFP + bne L341F +; + jsr PRODOS8 ;GET_FILE_INFO + DB $C4 + DW GFISrcFP + bne L341F +; + lda #$11 ;Check filetype + ldy SrcType + cpy #RELtype + bne L341F ;filetype mismatch +; + lda OpSrcFP+c.outRef;Prepare to read 1st 2 bytes of this + sta RCodeLenP+c.refNum; file which is len of code image + jsr PRODOS8 ;READ + DB $CA + DW RCodeLenP + bne L341F +; + lda SrcCodeLen + clc + adc SrcORG ;Value of last ORG in this src file + sta L3806 ; Addr+1 of last byte of code image + lda SrcCodeLen+1 + adc SrcORG+1 + sta L3806+1 +; + lda SrcORG ;Perform 2's complement of the + eor #$FF + sta NegSrcOrg ; the Last ORG adr of src file + lda SrcORG+1 + eor #$FF + sta NegSrcOrg+1 + inc NegSrcOrg + bne L341D + inc NegSrcOrg+1 +L341D clc + rts +L341F sec + rts + REP 50 +; ($3421) Read in a line of text from command file +; See description below +; +Read1Cmd EQU * + jsr PRODOS8 ;READ + DB $CA + DW RdCmdFP + beq L3446 +; + cmp #$4C ;Is it EOF? + beq L3430 ;Yes + jsr ErrHndlr ;Don't come back +; +L3430 jsr L343B ;Reset file posn to BO src file + lda #CR ;Store CR @ BO buffer to + sta CmdLineB ; denote an empty (blank) line + jmp L3446 ;Set cp to point @ cmd line buf + REP 50 +; ($343B) Reset file position to BO of command file +; Output +; cp - ptr to 1st char of Cmd Line +; (A) - 1st char +; Z=1 - 1st char is CR/SPACE +; Z=0 - Otherwise +; +L343B EQU * + jsr PRODOS8 ;SET_MARK + DB $CE + DW SMCmdFP + beq L3446 + jsr ErrHndlr ;Don't come back +; +L3446 EQU * + lda #>CmdLineB + sta cp + lda #255 EXTRN's + jmp GoShowMsg +; +CmdSynErr ldy #$01 +GoShowMsgZ jmp GoShowMsg +; +GoShowMsg jsr DspMsg +; +; All errors above will come here +; Close all files. Check for a ctrl-B +; If so, exit to monitor else re-load EdAsm.ED +; & transfer control to the editor +; ($3613) +; Input +; Output +; +DoBreak EQU * + lda CMDADR ;last MLI call return address + pha + lda CMDADR+1 + pha +; + lda #$01 + sta ClsAllP + lda #$00 + sta ClsAllP+c.refNum + jsr PRODOS8 ;CLOSE + DB $CC + DW ClsAllP +; + pla + sta CMDADR+1 + pla + sta CMDADR ;last MLI call return address +; + bit KBDSTROBE ;turn off keypressed flag + bit RDROM2 ;Read ROM; no write + jsr RDKEY ;Input char with cursor + cmp #CTRLB+$80 + bne Abort +; + tsx + stx StackP + ldx #$80 + txs + lda ROMIN2 ;read ROM/write LCbank2 (RR) + lda ROMIN2 + jmp MON ;std monitor entry w/beep +; +Abort jsr SetupED ;Proceed to load & xfer control to EdAsm.Ed + jmp USRADR ;ctl-Y vector +;================================================= +; Put everything back in order +; Input +; Output +; Currently EI's ctrl-Y vector points @ $B198 +; If exec mode is on, the entry is modified to +; $B1AB +; +;================================================= +DoExit EQU * + lda OpCmdFP+c.outRef + jsr ClsFile ;Close the command file + jsr SetupED + bit ExecMode ;Was cmd file EXEC fr Editor? + bmi L3665 ;Yes (Qn: how to do this since we have to enter MON) + jmp USRADR ;Exit via ctl-Y vector +; +L3665 clc + lda USRADR+1 ;ctl-Y vector + adc #$13 ;$B1AB-$B198 + sta L367F+1 ;Self-modifying code + lda USRADR+2 + adc #$00 + sta L367F+2 + bit ROMIN2 ;read ROM/write LCbank2 (RR) + bit ROMIN2 + ldx #$F8 + txs +L367F jmp USRADR ;ctl-Y vector + REP 50 +; Input +; Output +; Load EDASM's Editor +; +SetupED EQU * + jsr LoadED ;Load EDASM.ED + lda #%01111111 ;$7F + sta BitMap+22 ;P8 memory bitmap + lda #%10000001 ;$81 + sta BitMap+23 ;P8 memory bitmap + lda TxtBgn ;No file in mem + sta TxtEnd + lda TxtBgn+1 + sta TxtEnd+1 + rts + REP 50 +; +; Phase 1 use 2 bytes of this table. However, the +; locations accessed should be $3698 and $369A +; & not $3697 and $3699. The bytes should be +; addr hi of the EXTRN & ENTRY tables +; +L3698 DB $71 ;ENTRY table must be < $7100 + DB $00 + DB $91 ;EXTRN table must be < $9100 +; +BitsT DB $80,$40,$20,$10,$08,$04,$02,$01 +; +; Default filenames of workfiles +; +AutoLnkS STR 'EDASM.AUTOLINK' + DB $00 +TempESD STR 'EDASM.TEMPESD' + DB $00 +TempRLD STR 'EDASM.TEMPRLD' + DB $00 +;================================================= +DirectvT EQU * + ASC 'BIN ' + ASC 'REL ' + ASC 'SYS ' + ASC 'ORG ' + ASC 'OPT ' + ASC 'ALN ' + DB $00 ;Marks end of table +; +; JMP table +; +L36EA DB >CmdBin-1 ;Lo + DB >CmdRel-1 + DB >CmdSys-1 + DB >CmdOrg-1 + DB >CmdOptn-1 + DB >CmdAln-1 +; +L36F0 DB L3ADE + DB >L3B02 + DB >L3B1F + DB >L3BB7 + DB >L3BDD + DB >L3BFF + DB >L3C1E + DB >L3C3F + DB >L3C63 + DB >L3C83 + DB >L3CA0 + DB >L3CB7 + DB >L3CCF + DB >L3CEB + DB >L3B55 + DB >L3B7B + DB >L3BA0 + DB >L3D06 + DB >L3D22 + DB >L3D3F + DB >L3D4B + DB >L3D58 + DB >L3D8D + DB >L3D9A + DB >L3DBE + DB >L3DD6 + DB >L3DEE + DB >L3B3A + DB >L3AB4 + DB >L3D75 +; +MsgTHi DB 255 EXTRN's in REL output ESD| + ASC '\' +L3DBE ASC 'MOD ORG END MODULE' + DB CR + ASC '\' +L3DD6 ASC ' # ADRS ADRS NAME ' + DB CR + ASC '\' +L3DEE ASC ' ADRS M# SYMBOL MODULE' + ASC ' X-REF LIST ' + ASC ' PAGE ' + ASC '\' + ASC '14-MAR-84' + ASC '23:42 ' +; +FileDBSiz EQU AsmLinker-SrcDBuf;20 mempages=5K \ No newline at end of file diff --git a/EDASM_SRC.2mg b/EDASM_SRC.2mg index 33a4267..dd9e883 100755 Binary files a/EDASM_SRC.2mg and b/EDASM_SRC.2mg differ diff --git a/README.MD b/README.MD index 89fd55a..82cf749 100644 --- a/README.MD +++ b/README.MD @@ -1,7 +1,7 @@ The disassembled source code of the programs of the PRODOS ASSEMBLER TOOLS RELEASE 1.1 are -distributed in the form of an 800K Universal disk image (.2mg). +distributed in the form of an 800K Universal disk image (.2mg). The relevant source files are in the EDASM.SRC folder and are meant for viewing purposes only. -This disassembled source codes are arranged in 5 folders. +The disassembled source codes are arranged in 5 folders. If you wish to assemble any of the 5 programs, 1) you should have a copy of the PRODOS Assembler Tools,