Mercurial > hg > Members > kono > nitros9-code
changeset 2172:2801ef7aff80
Corrections to BAM routines to incorporate DD.BIT. Selection of cluster/sector mode. Removal of unused previous version tacked onto end of source code.
| author | robertgault |
|---|---|
| date | Sun, 01 Jun 2008 10:40:08 +0000 |
| parents | a7ab256f65b9 |
| children | 5daef7cf8a1b |
| files | level1/cmds/ded.asm |
| diffstat | 1 files changed, 2113 insertions(+), 4237 deletions(-) [+] |
line wrap: on
line diff
--- a/level1/cmds/ded.asm Thu May 29 12:12:16 2008 +0000 +++ b/level1/cmds/ded.asm Sun Jun 01 10:40:08 2008 +0000 @@ -1,5 +1,4 @@ - IFNE 1 - nam dEd OS-9 Disk Editor Version ??? + nam dEd OS-9 Disk Editor Version 2.06 ttl Copyright 1987 Doug DeMartinis ******************************************************* * Copyright 1987 Doug DeMartinis; All Rights Reserved * @@ -41,8 +40,16 @@ * 06/01/11 Robert Gault * * Corrected BAM to sector calculation. * * No attempt has been made to comment code. * +******************************************************* +* 08/05/27 Robert Gault * +* Corrected BAM presentation with drives having* +* more than $##0000 sectors and/or DD.BIT >1. * +* Converted all u and L addressing to normal * +* lables. * +* Added cluster/sector toggle. +******************************************************* +* Disassembled 2006/01/10 00:57:52 by Disasm v1.5 (C) 1988 by RML and RG -* Disassembled 2006/01/10 00:57:52 by Disasm v1.5 (C) 1988 by RML and RG ifp1 use defsfile @@ -51,133 +58,119 @@ atrv set ReEnt+rev rev set $02 top mod eom,name,tylg,atrv,start,size -u0000 rmb 1 -u0001 rmb 1 -u0002 rmb 1 -u0003 rmb 1 -u0004 rmb 1 -u0005 rmb 1 -u0006 rmb 1 -u0007 rmb 1 -u0008 rmb 2 -u000A rmb 4 -u000E rmb 1 -u000F rmb 1 -u0010 rmb 1 -u0011 rmb 1 -u0012 rmb 2 -u0014 rmb 2 -u0016 rmb 1 -u0017 rmb 1 -u0018 rmb 1 -u0019 rmb 1 -u001A rmb 1 -u001B rmb 2 -u001D rmb 2 -u001F rmb 1 -u0020 rmb 1 -u0021 rmb 2 -u0023 rmb 2 -u0025 rmb 2 -u0027 rmb 2 -u0029 rmb 1 -u002A rmb 1 -u002B rmb 1 -u002C rmb 1 -u002D rmb 1 -u002E rmb 1 -u002F rmb 1 -u0030 rmb 1 find hex/ascii flag -u0031 rmb 17 string to find -u0042 rmb 2 -u0044 rmb 1 -u0045 rmb 1 -u0046 rmb 1 -u0047 rmb 2 -u0049 rmb 1 -u004A rmb 1 -u004B rmb 1 -u004C rmb 1 -u004D rmb 30 linked module name -u006B rmb 30 output filename -u0089 rmb 1 -u008A rmb 1 -u008B rmb 1 -u008C rmb 1 -u008D rmb 2 -u008F rmb 2 -u0091 rmb 1 -u0092 rmb 1 -u0093 rmb 1 -u0094 rmb 1 -u0095 rmb 1 -u0096 rmb 1 -u0097 rmb 1 -u0098 rmb 1 -u0099 rmb 1 -u009A rmb 1 -u009B rmb 1 -u009C rmb 1 +inpath rmb 1 +outpath rmb 1 +lsn rmb 3 +oldlsn rmb 3 +offset rmb 2 +cursor rmb 4 +hexcol rmb 1 +rownum rmb 1 +asciicol rmb 1 +lastflag rmb 1 +buffptr rmb 2 +edbufptr rmb 2 +edpos rmb 1 +hexascii rmb 1 +zeroflag rmb 1 +oldecho rmb 1 +echobyte rmb 1 +Usave rmb 2 +Ssave rmb 2 +seclen rmb 2 +vmodlen rmb 2 +lmodlen rmb 2 +fileln rmb 2 +bytsread rmb 2 +crc rmb 3 +modnmlen rmb 1 +wrtflag rmb 1 +xprtflag rmb 1 +FHexAsc rmb 1 +TargLen rmb 1 +findstr rmb 17 +findptr rmb 2 +FBytes rmb 1 +HexBuff rmb 4 +FileLen rmb 4 +infile rmb 30 linked module name +outfile rmb 30 output filename +CrsrCnt rmb 1 +CrsrFlg rmb 1 +SgnlCode rmb 1 +rawflg rmb 1 +clustflg rmb 1 flag for cluster/sector +ddmap rmb 2 +mappags rmb 2 sectors per Allocation Map +ddbit rmb 2 copy of DD.BIT +ddbitcalc rmb 2 calculation of sectors per map page +newBAM rmb 3 +nBAMstp rmb 3 +BAMstart rmb 3 +BAMstop rmb 3 u009D rmb 8 -u00A5 rmb 1 -u00A6 rmb 48 -u00D6 rmb 256 -u01D6 rmb 320 +StackCnt rmb 1 +Stack rmb 48 +inbuff rmb 256 +i.o.buff rmb 320 size equ . -L000D fcb $0C clear screen -L000E fcb $1F,$20,0 reverse video on -L0011 fcb $1F,$21,0 reverse video off -L0014 fcb $04 erase from current character to end of line -L0015 fcb $0B erase from current character to end of screen -L0016 fcb $05,$21,0 turns on cursor -L0019 fcb $05,$20,0 turns off cursor +cls fcb $0C clear screen +revvid fcb $1F,$20,0 reverse video on +normvid fcb $1F,$21,0 reverse video off +eraselin fcb $04 erase from current character to end of line +erasescr fcb $0B erase from current character to end of screen +curon fcb $05,$21,0 turns on cursor +curoff fcb $05,$20,0 turns off cursor name equ * fcs /dEd/ - fcb $05 + fcb $06 fcc /Copyright 1987 Doug DeMartinis/ -L003E fcs /LSN=$/ -L0043 fcs /SECTOR = $/ -L004D fcc / 0 1 2 3 4 5 6 7 8 9 A B C D E F/ +lsntitle fcs /LSN=$/ +sect fcs /SECTOR = $/ +header fcc / 0 1 2 3 4 5 6 7 8 9 A B C D E F/ fcc / 0 2 4 6 8 A C E / fcb $0D -L0096 fcs /CMD: / -L009B fcc "<BREAK> toggles HEX/ASCII edit modes " +command fcs /CMD: / +edprompt fcc "<BREAK> toggles HEX/ASCII edit modes " fcs /<ENTER> exits edit mode/ -L00DB fcs /Zap / -L00DF fcs /byte: / -L00E5 fcs /char: / -L00EB fcs "Are you sure? (Y/N) " -L00FF fcs /Writing sector.../ -L0110 fcs /OUTFILE: / -L0119 fcs /Verifying.../ -L0125 fcs /Verify aborted.../ -L0136 fcs /shell/ -L013B fcs /Link to which module? / -L0151 fcc /Off Len Name/ +zaprompt fcs /Zap / +byte fcs /byte: / +char fcs /char: / +sure fcs "Are you sure? (Y/N) " +writing fcs /Writing sector.../ +out$ fcs /OUTFILE: / +vrfymess fcs /Verifying.../ +verrmess fcs /Verify aborted.../ +shell$ fcs /shell/ +linkmess fcs /Link to which module? / +linkhdr fcc /Off Len Name/ fcb $0A fcc /---- ---- ----/ fcb $0D -L016F fcs /MODULE: / -L0178 fcs /OFFSET: $/ -L0181 fcb $1F,$24 blink on +modnmhdr fcs /MODULE: / +offmess fcs /OFFSET: $/ +xprtmess fcb $1F,$24 blink on fcc /- Expert Mode -/ fcb $1F,$25+$80 blink off -L0194 fcs /Find byte string $/ -L01A6 fcs /Find char string: / -L01B8 fcs /Searching.../ -L01C4 fcs /Current File Length $/ -L01D9 fcs /New Length? $/ -L01E6 fcs /** RESTART, Enter pathname: / -L0202 fcs /BAM: From Sector:$ to $ / -L0226 fcs /Bits:/ -L022B fcb $07 - fcs /Sector Stack Full / -L023E fcc " Up/Down Arrows Read & display Next/Previous sector" +findbyte fcs /Find byte string $/ +findchar fcs /Find char string: / +srchmess fcs /Searching.../ +lenmess fcs /Current File Length $/ +newmess fcs /New Length? $/ +bootmess fcs /** RESTART, Enter pathname: / +BAMmess1 fcs /BAM: From Sector:$ to $ / +BAMmess2 fcs /BAM: From Cluster:$ to $ / +BITmess fcs /Bits:/ +bell fcb $07 +fullmess fcs /Sector Stack Full / +helper fcc " Up/Down Arrows Read & display Next/Previous sector" fcb $0A fcc / <CR> Clean up the screen display/ fcb $0A fcc / * Restart/ fcb $0A + fcc " ! Toggle BAM Cluster/Sector" + fcb $0A fcc / $ Fork a SHELL (Ctrl-BREAK to return)/ fcb $0A fcc / A Append displayed sector to output file/ @@ -218,9 +211,10 @@ fcb $0A fcb $0A fcc / (Press any key to return to command prompt):/ -L05AC fcc /Use: dEd <pathlist>/ +helpchrs equ *-helper +usemess fcc /Use: dEd <pathlist>/ fcb $0D -L05C1 fcb $98,$96,$80 decimal 10,000,000 +decimals fcb $98,$96,$80 decimal 10,000,000 fcb $0F,$42,$40 decimal 1,000,000 fcb $01,$86,$A0 decimal 100,000 fcb $00,$27,$10 decimal 10,000 @@ -229,3340 +223,1182 @@ fcb $00,$00,$0A decimal 10 fcb $00,$00,$01 decimal 1 * Command jump table -L05D9 fcb $0C up arrow - fdb L0A40 +commands fcb $0C up arrow + fdb nxtsec fcb $0A down arrow - fdb L0A4E - fcb '* ????? - fdb L0627 ????? + fdb prevsec + fcb '* + fdb restart Restart program with new file/disk + fcb '! + fdb togCS Toggle cluster/sector fcb '$ shell - fdb L10BD + fdb goshell fcb $0D CR - fdb L10EF + fdb cReturn fcb 's LSN change - fdb L0A67 + fdb changLSN fcb 'z Zap - fdb L0B23 + fdb zap fcb 'w Write sector - fdb L0BD4 + fdb writesec fcb 'o Open output file - fdb L0C26 + fdb openout fcb 'a Append to file - fdb L0CAD + fdb append fcb 'c Close output file - fdb L0C97 + fdb closeout fcb 'e Edit sector - fdb L0D37 + fdb edit fcb 'q Quit - fdb L0D22 + fdb quit fcb 'v Verify - fdb L1116 + fdb verify fcb 'l Link - fdb L1223 + fdb linker fcb 'u Unlink - fdb L13CA + fdb unlinker fcb 'x eXpert mode - fdb L13EB + fdb expert fcb 'h help - fdb L1413 + fdb help fcb '? help - fdb L1413 + fdb help fcb 'f Find - fdb L142B + fdb find fcb 'n Next find - fdb L15F9 + fdb next fcb 'd Diddle length - fdb L1612 + fdb diddle fcb 'p Push - fdb L16A9 + fdb push fcb 'r Restore (Pop) - fdb L16E2 - fcb $00 -L0622 stb u008B,u + fdb restore + fcb $00 + +* Intercept signals +* modification by BRI +icept stb SgnlCode,u rti -L0627 lds <u001D - ldu <u001B - com <u001A - lbsr L10F5 - lbsr L078F - leax L01E6,pcr - lbsr L0759 - lbsr L07B0 - leax u01D6,u - stx <u00D6 +* end modification + +restart lds <Ssave + ldu <Usave + com <echobyte + lbsr echo + lbsr movecmd + leax bootmess,pcr + lbsr pstring + lbsr clrline + leax i.o.buff,u + stx <inbuff ldy #$50 clra os9 I$ReadLn - lbcs L0CB6 + lbcs error cmpy #1 - bne L065E - clr <u001A - lbsr L10F5 - lbra L070B -L065E lda <u0000 + bne newdata + clr <echobyte + lbsr echo + lbra getcmd +newdata lda <inpath os9 I$Close - bra L0672 + bra softstrt start equ * - stx <u00D6 - leax >L0622,pcr + stx <inbuff pointer to param + leax >icept,pcr intercept routine addr os9 F$Icpt - lbcs L0CB6 -L0672 clra - ldb #$D6 - leax ,u -L0677 sta ,x+ + lbcs error +* Initialize data area +softstrt clra + ldb #inbuff + leax ,u point to data area +init sta ,x+ clear memory decb - bne L0677 - stu <u001B - sts <u001D - ldd #$0002 - std <u000A - leas <-$20,s - leax ,s - clra - clrb + bne init + com clustflg set default to show clusters + stu <Usave + sts <Ssave + ldd #$0002 cursor move code + std <cursor store it for output + leas <-$20,s make room for terminal options + leax ,s point regX to temp buffer + clra stdin path# + clrb SS.OPT os9 I$GetStt - lbcs L0CB6 - lda $04,x - sta <u0019 - leas <$20,s - ldx <u00D6 + lbcs error + lda $04,x get echo status byte + sta <oldecho + leas <$20,s reset stack +* Open file + ldx <inbuff point to file name pshs x - clr <u008C -L06A1 lda ,x+ + clr <rawflg raw disk edit open flag +opfLoop lda ,x+ find CR cmpa #$0D - beq L06AD - cmpa #$40 - bne L06A1 - com <u008C -L06AD puls x - lda #$03 + beq noraw @ not found + cmpa #'@ open raw option + bne opfLoop + com <rawflg flag the option +noraw puls x + lda #$03 update mode os9 I$Open - bcc L06C7 - cmpb #$D6 - lbne L0D34 - ldx <u00D6 - lda #$83 + bcc openOK + cmpb #$D7 bad pathname + lbeq hints + cmpb #$D6 no permission + lbne bye exit with error + ldx <inbuff point to file name + lda #$83 mode=Dir + Update os9 I$Open - lbcs L0D34 -L06C7 sta <u0000 - ldb #$02 + lbcs bye exit with error +openOK sta <inpath path# + ldb #$02 ss.size os9 I$GetStt - stx <u0049 - stu <u004B - ldu <u001B - clr <u001A - lbsr L10F5 - lbsr L07BA - tst <u008C - beq L06F5 - lbsr L07C4 - ldx <u0012 - ldd $04,x - std <u008D + stx <FileLen msw of file size (in bytes?) + stu <FileLen+2 lsw + ldu <Usave + clr <echobyte + lbsr echo set no echo + lbsr clrscr clear the screen + tst <rawflg + beq readloop go if not raw + lbsr seeksec read LSN0 of disk + ldx <buffptr point regX to sector image +* Get DD.BIT RG + ldd 6,x get DD.BIT + std <ddbit save new data + ldd 4,x get DD.MAP + std <ddmap save copy * Next line converts DD.MAP to base0 numbering. * (DD.MAP-1)/$100+1=sectors in map. Original was DD.MAP/$100+1 RG - subd #1 needed to correctly convert DD.MAP to sectors, RG + subd #1 needed to correctly convert DD.MAP to sectors in allocation, RG tfr d,x - ldd #$0100 - lbsr L1728 - leax $01,x - stx <u008F -L06F5 lbsr L07C4 - sty <u001F - ldd <u0002 - std <u0005 - lda <u0004 - sta <u0007 - ldd #$0000 - std <u0042 -L0708 lbsr L081F -L070B lbsr L078F - leax >L0096,pcr - bsr L0759 - leax >L0015,pcr - ldy #$0001 + ldd #$100 bytes per sector of map + lbsr mul16B + leax 1,x + stx <mappags pages in allocation map +readloop lbsr seeksec + sty <seclen either $100 or number of bytes left in file + ldd <lsn get lsn just read + std <oldlsn + lda <lsn+2 + sta <oldlsn+2 + ldd #0 signal Next + std <findptr +disploop lbsr display display the sector +getcmd lbsr movecmd move cursor to + leax >command,pcr CMD: + bsr pstring + leax >erasescr,pcr erase to end of string + ldy #$0001 era2chrs os9 I$Write - lbcs L0CB6 - leax >u01D6,u - lbsr L07E8 + lbcs error + leax >i.o.buff,u + lbsr read1 read one char lda ,x - cmpa #$41 - bcs L0732 - ora #$20 -L0732 leax >L05D9,pcr -L0736 cmpa ,x+ - beq L0742 - leax $02,x - tst ,x - bne L0736 - bra L070B -L0742 tst <u002E - beq L0751 - tst <u002D - beq L0751 + cmpa #'A is it ascii? + bcs srchtabl if not skip + ora #$20 upper -> lower +srchtabl leax >commands,pcr point to command table +findcmd cmpa ,x+ found it? + beq gotcmd go if yes + leax $02,x else + tst ,x end of table? + bne findcmd loop + bra getcmd invalid key +gotcmd tst <xprtflag using expert mode? + beq jmpcmd no, then go + tst <wrtflag are we writing? + beq jmpcmd n, then go pshs x,a - lbsr L0BF0 + lbsr xprtwrt write sector puls x,a -L0751 ldd ,x - leax top,pcr - jmp d,x -L0759 leay >u01D6,u - clrb -L075E incb - lda ,x+ - bmi L0767 - sta ,y+ - bra L075E -L0767 anda #$7F - sta ,y - leax >u01D6,u +jmpcmd ldd ,x get address offset + leax top,pcr start of module + jmp d,x jump to address +* Print string of characters in fcs mode +pstring leay >i.o.buff,u + clrb counter +xfer incb + lda ,x+ get shar + bmi lstchar if bit7 set,go + sta ,y+ put in buffer + bra xfer +lstchar anda #$7F clear bit7 + sta ,y put in buffer + leax >i.o.buff,u point to string clra - tfr d,y - bra L0778 -L0774 ldy #$0078 -L0778 lda #$01 -L077A os9 I$WritLn - lbcs L0CB6 + tfr d,y length of string to print + bra writeout +wrtlin1 ldy #$78 #bufsiz 120 chars max +writeout lda #$01 stdout +wrtlin2 os9 I$WritLn + lbcs error rts - ldy #$0003 -L0786 clra - os9 I$ReadLn - lbcs L0CB6 +readlin3 ldy #3 chars to read +readlin clra stdin + os9 I$ReadLn get 2 chars + CR + lbcs error rts -L078F ldd #$2036 move command -L0792 leax u000A,u - std $02,x - ldy #$0004 - bra L0778 -L079C leax >L000E,pcr - ldy #$0002 - bra L0778 -L07A6 leax >L0011,pcr - ldy #$0002 - bra L0778 -L07B0 leax >L0014,pcr - ldy #$0001 - bra L0778 -L07BA leax >L000D,pcr - ldy #$0001 - bra L0778 -L07C4 bsr L07F1 - leax >u00D6,u - stx <u0012 - tst <u004D - beq L07DA - ldd <u0023 - suba <u0004 - bne L07DA - tfr d,y - bra L07DE -L07DA ldy #$0100 -L07DE lda <u0000 - os9 I$Read - lbcs L0CB6 +movecmd ldd #$2036 #cmdpos +movecurs leax cursor,u cursor move code + std 2,x row/col + ldy #4 # chars + bra writeout + +* Set reverse video code +revdisp leax >revvid,pcr + ldy #2 chars to write + bra writeout + +* Set normal video code +normdisp leax >normvid,pcr + ldy #2 normchrs + bra writeout + +clrline leax >eraselin,pcr + ldy #1 + bra writeout + +clrscr leax >cls,pcr + ldy #1 eraschrs + bra writeout + +seeksec bsr lsnseek seek to sector + leax >inbuff,u + stx <buffptr + tst <infile is module linked? + beq read256 on not linked + ldd <lmodlen get module length + suba <lsn+2 are more than $100 bytes left? + bne read256 yes, then go + tfr d,y no so setup smaller read + bra readsome +read256 ldy #$100 256 bytes +readsome lda <inpath + os9 I$Read + lbcs error rts -L07E8 clra - ldy #$0001 - os9 I$Read - rts -L07F1 tst <u004D - bne L0808 - ldx <u0002 - lda <u0004 + +****************************** +* changed to ignore errors 01/09/90 (RAK) +* +read1 clra stdin + ldy #1 + os9 I$Read + rts +*********************** End of mod +lsnseek tst <infile is module linked? + bne offchk yes so go + ldx <lsn + lda <lsn+2 clrb -L07FA tfr d,u - lda <u0000 +lsnseek1 tfr d,u + lda <inpath os9 I$Seek - lbcs L0CB6 - ldu <u001B -L0807 rts -L0808 ldd <u0023 - subd #$0001 - cmpa <u0004 - bcc L0816 - ldb #$D3 - lbra L0CB6 -L0816 ldd <u0008 - adda <u0004 - ldx #$0000 - bra L07FA -L081F ldd #$2020 - lbsr L0792 - leax >L003E,pcr - lbsr L0759 - bsr L07B0 - lbsr L08E6 - leax >u01D6,u - lbsr L0774 - tst <u004D - beq L083F - lbsr L139A -L083F tst <u0001 - beq L0846 - lbsr L0C77 -L0846 ldd #$2022 - lbsr L0792 - leax >L000E,pcr - ldy #$0002 - lbsr L077A - leax >L004D,pcr - lbsr L0774 - leax >L0011,pcr - ldy #$0002 - lbsr L077A -L0869 lbsr L098C - lda <u000F - adda #$10 - sta <u000F - bne L0869 - leax >u00D6,u - stx <u0012 - tst <u008C - beq L08CA - ldd <u0003 - cmpd #$0001 - bcs L08CA - cmpd <u008F - bhi L08CA - ldd <u0003 might this be map size in bytes? - subd #$0001 assumes allocation map starts at LSN1 - ldx #$0800 8 bits/byte x $100 to convert to position - lbsr L16FE - tfr y,d - stb <u0091 result of conversion. - stu <u0092 - leau >$07FF,u - cmpu <u004A - bls L08AF - cmpb <u0049 - bcs L08AF - ldb <u0049 - ldu <u004A - leau -u0001,u -L08AF stb <u0094 - stu <u0095 - ldu <u001B - ldx <u0091 - ldb <u0093 - stx <u0097 - stb <u0099 - ldx <u0094 - ldb <u0096 - stx <u009A - stb <u009C - lbsr L1748 - bra L08D3 -L08CA ldd #$2034 - lbsr L0792 - lbsr L07B0 -L08D3 tst <u002E - lbeq L0807 - ldd #$5933 - lbsr L0792 - leax >L0181,pcr - lbra L0759 -L08E6 ldd <u0002 - com <u0018 - leay >u01D6,u - bsr L095D - tfr b,a - bsr L095D - clr <u0018 - lda <u0004 - bsr L095D - ldd #$2020 - std ,y++ - ldd #$0008 + lbcs error + ldu <Usave +lsnrts rts + +offchk ldd <lmodlen linked module length + subd #1 base0 on sector + cmpa <lsn+2 reading past last sector? + bcc offseek no then go + ldb #$D3 e$eof + lbra error +* If module is 'linked' add offset for good seek +offseek ldd <offset + adda <lsn+2 + ldx #0 + bra lsnseek1 + +display ldd #$2020 + lbsr movecurs + leax >lsntitle,pcr + lbsr pstring + bsr clrline + lbsr convert3 hex to ascii for lsn + leax >i.o.buff,u + lbsr wrtlin1 + tst <infile link test + beq nolink + lbsr prntmod +nolink tst <outpath is an output path open + beq noout no, then go + lbsr prntout display name +noout ldd #$2022 hedrpos + lbsr movecurs + leax >revvid,pcr reverse video code + ldy #2 # of revchrs + lbsr wrtlin2 + leax >header,pcr + lbsr wrtlin1 + leax >normvid,pcr normal video code + ldy #2 normchrs + lbsr wrtlin2 +disp lbsr dsplylin + lda <rownum get row # + adda #$10 next row + sta <rownum + bne disp do 16 rows + leax >inbuff,u + stx <buffptr reset buffer pointer + tst <rawflg edit flag + beq contin if not raw +* New lines handle disks with $xx0000 sectors where xx>00. RG + tst <lsn look at LSN msb + bne contin we're not looking at the map if not $00 + ldd <lsn+1 get LSN lsw + cmpd #1 first page of map? + bcs contin go if lsn0 + cmpd <mappags + bhi contin lsnrts, go if not map +* ldd <lsn+1 we don't need this as it already is loaded. RG + subd #1 setup to calc first sector +* Big error as it ignores DD.BIT New lines added. RG + ldx #$800 8 bits/byte x $100 bytes per page if DD.BIT=1 + + tst clustflg + bne csf1 no calc if in cluster mode + pshs d save LSN + ldd <ddbit sectors per bit + lbsr mulDbyX mul regD * regX + stu <ddbitcalc sectors per page of allocation map, hope for no overflow + puls d recover LSN + +csf1 lbsr mulDbyX mul regD*regX = value first sector on this page allocation map + tfr y,d + stb <newBAM msb + stu <newBAM+1 lsw +* leau >$7FF,u this assumes DD.BIT = 1 + + tst clustflg + bne csf2 no calc if in cluster mode + pshs d + bsr ddbitfix calculate -sectors per map byte + addd <ddbitcalc regD = value of last bit on first allocation map page + leau d,u add starting value of page + puls d + bra csf3 +csf2 leau $7ff,u this is fixed in cluster mode +csf3 cmpu <FileLen+1 file length times $100 + bls notshort + cmpb <FileLen file length times $100 + bcs notshort + ldu <FileLen+1 + tst clustflg + bne csf4 no calc in cluster mode + bsr ddbitfix calc -sectors per map byte + leau d,u + bra csf5 +csf4 leau -1,u fixed in cluster mode + +csf5 ldb <FileLen +notshort stb <nBAMstp + stu <nBAMstp+1 + ldu <Usave + ldx <newBAM + ldb <newBAM+2 + stx <BAMstart + stb <BAMstart+2 + ldx <nBAMstp + ldb <nBAMstp+2 + stx <BAMstop + stb <BAMstop+2 + lbsr prntBAM + bra moredisp + +ddbitfix clra does a neg(ddbit) + clrb + subd <ddbit + rts +* End of BAM mod + +* Continue the normal display. +contin ldd #$2034 clear BAM line + lbsr movecurs + lbsr clrline +moredisp tst <xprtflag + lbeq lsnrts go if not expert + ldd #$5933 xprtpos + lbsr movecurs + leax >xprtmess,pcr + lbra pstring +convert3 ldd <lsn + com <zeroflag to suppress leading zeros + leay >i.o.buff,u + bsr convert1 + tfr b,a + bsr convert1 + clr <zeroflag print leading zeros + lda <lsn+2 + bsr convert1 + ldd #$2020 space space + std ,y++ move to buffer + ldd #8 8 decimal digits pshs b,a - com <u0018 - leax >L05C1,pcr -L090A clr ,s -L090C ldd <u0003 - subd $01,x - pshs cc - std <u0003 - lda <u0002 - clrb - suba ,x - bcc L091C - incb -L091C puls cc - bcc L0922 - suba #$01 -L0922 sta <u0002 - bcc L0927 + com <zeroflag suppress leading zeros + leax >decimals,pcr conversion table pointer +initsub1 clr ,s +subdec1 ldd <lsn+1 + subd $01,x lsb from table + pshs cc save carry + std <lsn+1 + lda <lsn + clrb flag + suba ,x -msb of lsn + bcc LSBorrow incb -L0927 tstb - bne L092E - inc ,s - bra L090C -L092E ldd <u0003 - addd $01,x - std <u0003 - lda <u0002 - bcc L0939 - inca -L0939 adda ,x - sta <u0002 - leax $03,x - bsr L0984 - dec $01,s - beq L094F - lda $01,s - cmpa #$02 - bne L090A - clr <u0018 - bra L090A -L094F lda #$0D - sta ,y - ldd <u0006 - std <u0003 - lda <u0005 - sta <u0002 - puls pc,b,a -L095D pshs a convert hex to ascii +LSBorrow puls cc + bcc savemsb + suba #$01 +savemsb sta <lsn + bcc chekenuf + incb set flag +chekenuf tstb enough? + bne enufsub1 go if yes + inc ,s + bra subdec1 +enufsub1 ldd <lsn+1 get lsw + addd 1,x make it positive + std <lsn+1 lsn+1 + lda <lsn + bcc addmsb + inca get the carry +addmsb adda ,x make rest of remainder positive + sta <lsn + leax 3,x point to next table entry + bsr decascii + dec $01,s 8 digits? + beq getCR go if 8 + lda 1,s get last two digits? + cmpa #2 + bne initsub1 if no then loop + clr <zeroflag enable leading zeros + bra initsub1 + +getCR lda #$0D + sta ,y put into out string + ldd <oldlsn+1 + std <lsn+1 + lda <oldlsn + sta <lsn + puls d,pc + +* Convert hex byte in regA to ascii and put in buffer +convert1 pshs a hex to ascii + lsra shift msn to lsnibble lsra lsra lsra - lsra - bsr L096C - puls a - anda #$0F - bsr L096C + bsr objasc + puls a recover byte + anda #$0F mask off msnibble + bsr objasc rts -L096C cmpa #$09 - ble L0972 - adda #$07 -L0972 adda #$30 - sta ,y+ - tst <u0018 - beq L0980 - cmpa #$30 - beq L0981 - clr <u0018 -L0980 rts -L0981 leay -$01,y +objasc cmpa #$09 is a digit? + ble asciify + adda #$07 +asciify adda #$30 add '0 + sta ,y+ put it into buffer + tst <zeroflag + beq convdone go if not + cmpa #'0 + beq suppres0 erase if yes + clr <zeroflag stop suppression +convdone rts +suppres0 leay -$01,y rts -L0984 pshs a - lda $03,s - bsr L0972 + +* Convert decimal# on stack to ascii and add to buffer +decascii pshs a + lda $03,s get decimal counter + bsr asciify puls pc,a -L098C leay >u01D6,u - leax >L000E,pcr - lbsr L0A31 - lda <u0020 - beq L09A5 - anda #$F0 - cmpa <u000F - bne L09A5 + +dsplylin leay >i.o.buff,u + leax >revvid,pcr + lbsr transfer reverse video code + lda <seclen+1 + beq notlast + anda #$F0 mask off lsn + cmpa <rownum + bne notlast lda #$FF - sta <u0011 -L09A5 lda <u000F - bsr L095D - lda #$3A + sta <lastflag +notlast lda <rownum + bsr convert1 make it hex + lda #': sta ,y+ - leax >L0011,pcr - bsr L0A31 - ldd #$2020 + leax >normvid,pcr + bsr transfer + ldd #$2020 2 spaces std ,y++ - ldx <u0012 - ldb #$10 - tst <u0011 - beq L09C8 - ldb <u0020 - andb #$0F - beq L0A3A + ldx <buffptr + ldb #$10 16 bytes + tst <lastflag + beq cnvtbyt go if not + ldb <seclen+1 + andb #$0F regB= bytes for last line + beq noline pshs b -L09C8 lda ,x+ - bsr L095D - lda #$20 +cnvtbyt lda ,x+ + bsr convert1 + lda #$20 space sta ,y+ decb - bne L09C8 - tst <u0011 - beq L09E4 - ldd #$0310 - subb ,s - mul - lda #$20 -L09DF sta ,y+ + bne cnvtbyt + tst <lastflag + beq addspc2 + ldd #$310 regB=max bytes per line + subb ,s regB=bytes to null out + mul 3 spaces per byte + lda #$20 space +addspc1 sta ,y+ decb - bne L09DF -L09E4 ldb #$20 + bne addspc1 +addspc2 ldb #$20 std ,y++ sta ,y+ - ldx <u0012 - asrb - tst <u0011 - beq L09F3 + ldx <buffptr + asrb regB=15 + tst <lastflag + beq ascichar ldb ,s -L09F3 lda ,x+ - anda #$7F - cmpa #$20 - bcc L09FD - lda #$2E -L09FD sta ,y+ +ascichar lda ,x+ + anda #$7F clear bit7 + cmpa #$20 32 + bcc printabl +notascii lda #$2E notascii '. +printabl sta ,y+ decb - bne L09F3 - stx <u0012 - tst <u0011 - beq L0A26 - ldb #$10 - subb ,s+ - lda #$20 -L0A0E sta ,y+ + bne ascichar + stx <buffptr + tst <lastflag + beq addCR + ldb #$10 max bytes per line + subb ,s+ regB=bytes to null + lda #$20 space +addspc3 sta ,y+ put in buffer decb - bne L0A0E - lda #$F0 - sta <u000F - bsr L0A26 -L0A19 clr <u0011 - leax >L0015,pcr - ldy #$0001 - lbra L0778 -L0A26 lda #$0D + bne addspc3 + lda #$F0 last row + sta <rownum + bsr addCR display line +resetlst clr <lastflag + leax >erasescr,pcr erase to end of screen code + ldy #1 era2chrs + lbra writeout +addCR lda #$0D CR sta ,y - leax >u01D6,u - lbra L0774 -L0A31 lda ,x+ - beq L0A39 + leax >i.o.buff,u + lbra wrtlin1 + +transfer lda ,x+ + beq trandone sta ,y+ - bra L0A31 -L0A39 rts -L0A3A lda #$F0 - sta <u000F - bra L0A19 -L0A40 ldd <u0003 - addd #$0001 - std <u0003 - bne L0A4B - inc <u0002 -L0A4B lbra L06F5 -L0A4E ldd <u0003 - bne L0A58 - tst <u0002 - lbeq L070B -L0A58 subd #$0001 - std <u0003 - cmpd #$FFFF - bne L0A4B - dec <u0002 - bra L0A4B -L0A67 lbsr L078F - leax >L0043,pcr - lbsr L0759 - ldy #$0007 - bsr L0A89 - bcs L0A84 - ldd <u0047 - std <u0003 - lda <u0046 - sta <u0002 - lbra L06F5 -L0A84 lbsr L1535 - bra L0A67 -L0A89 pshs y - clr <u001A - com <u001A - lbsr L10F5 + bra transfer +trandone rts + +noline lda #$F0 signal last row + sta <rownum + bra resetlst + +* Point to net LSN in file +nxtsec ldd <lsn+1 nxtsec + addd #1 + std <lsn+1 + bne readsec + inc <lsn +readsec lbra readloop + +* Point to previous LSN unless at LSN0 +prevsec ldd <lsn+1 + bne notfirst + tst <lsn + lbeq getcmd +notfirst subd #1 + std <lsn+1 + cmpd #$FFFF borrow if LSN was $xx0000 + bne readsec + dec <lsn + bra readsec + +* Change LSN +changLSN lbsr movecmd + leax sect,pcr + lbsr pstring + ldy #7 + bsr MakeHex + bcs BadLSN + ldd <HexBuff+2 + std <lsn+1 + lda <HexBuff+1 + sta <lsn + lbra readloop + +BadLSN lbsr beep + bra changLSN + +MakeHex pshs y save # of bytes to read + clr <echobyte + com <echobyte + lbsr echo puls y - leax >u01D6,u - lbsr L0786 - clr <u001A - lbsr L10F5 - leay -$01,y - beq L0AEE - tfr y,d -L0AA6 lda ,x+ - bsr L0AF3 - bcs L0AEB - decb - bne L0AA6 - sty <u0045 -L0AB2 lda #$30 - ldb ,-x - leay -$01,y - beq L0ABE - lda ,-x + leax >i.o.buff,u + lbsr readlin + clr <echobyte + lbsr echo leay -$01,y -L0ABE bsr L0B09 + beq ExitHex + tfr y,d +CheckHex lda ,x+ + bsr hexdigit + bcs invalid + decb + bne CheckHex + sty <HexBuff +getascii lda #'0 + ldb ,-x + leay -1,y + beq convrt2 + lda ,-x + leay -1,y +convrt2 bsr asciihex pshs b - cmpy #$0000 - bne L0AB2 - ldb <u0046 - incb - lsrb - clra - leax <u0045,u - cmpb #$04 - beq L0AE2 + cmpy #0 + bne getascii + ldb <HexBuff+1 + incb prep for badfind + lsrb # of hex bytes + clra leading 0 + leax <HexBuff,u + cmpb #4 four bytes on stack? + beq hexstack sta ,x+ - cmpb #$03 - beq L0AE2 + cmpb #3 + beq hexstack sta ,x+ - cmpb #$02 - beq L0AE2 + cmpb #2 + beq hexstack sta ,x+ -L0AE2 puls a +hexstack puls a sta ,x+ decb - bne L0AE2 + bne hexstack clrb rts -L0AEB lbsr L1535 -L0AEE leas $02,s - lbra L06F5 -L0AF3 cmpa #$30 - bcs L0B07 - cmpa #$39 - bls L0B05 - anda #$5F - cmpa #$46 - bhi L0B07 - cmpa #$41 - bcs L0B07 -L0B05 clra + +invalid lbsr beep +ExitHex leas 2,s + lbra readloop + +hexdigit cmpa #'0 + bcs nothex + cmpa #'9 + bls ishex + anda #$5F lower to upper + cmpa #'F + bhi nothex + cmpa #'A + bcs nothex +ishex clra rts -L0B07 coma - rts -L0B09 bsr L0B18 +nothex coma + rts + +asciihex bsr hexnib pshs b tfr a,b - bsr L0B18 + bsr hexnib lslb lslb lslb lslb orb ,s+ rts -L0B18 subb #$30 - cmpb #$09 - bls L0B22 + +hexnib subb #$30 + cmpb #9 + bls nowhex andb #$5F subb #$07 -L0B22 rts -L0B23 clr <u001A - com <u001A - lbsr L10F5 - lbsr L078F - lbsr L07B0 - leax >L00DB,pcr - lbsr L0759 - tst <u0017 - bne L0B81 - leax >L00DF,pcr - lbsr L0759 - ldy #$0003 - bsr L0B62 - bsr L0B96 - bcs L0B79 -L0B4C leax >u00D6,u - stx <u0012 - clrb -L0B53 sta ,x+ +nowhex rts + +* Zap sector +zap clr <echobyte + com <echobyte + lbsr echo + lbsr movecmd + lbsr clrline + leax >zaprompt,pcr + lbsr pstring + tst <hexascii + bne zapascii + leax >byte,pcr + lbsr pstring + ldy #3 + bsr zapread + bsr hexobjct + bcs exitzap +zapstart leax >inbuff,u + stx <buffptr + clrb counter +zapbuff sta ,x+ decb - bne L0B53 - clr <u001A - lbsr L10F5 - inc <u002D - lbra L0708 -L0B62 clra - leax >u01D6,u + bne zapbuff + clr <echobyte + lbsr echo + inc <wrtflag + lbra disploop + +zapread clra + leax >i.o.buff,u os9 I$ReadLn - bcs L0B6D + bcs cheksig1 rts -L0B6D cmpb #$02 - lbne L0CB6 - com <u0017 - leas $02,s - bra L0B23 -L0B79 clr <u001A - lbsr L10F5 - lbra L070B -L0B81 leax >L00E5,pcr - lbsr L0759 - ldy #$0002 - bsr L0B62 +cheksig1 cmpb #2 break key signal + lbne error + com <hexascii + leas 2,s + bra zap + +exitzap clr <echobyte + lbsr echo + lbra getcmd + +zapascii leax >char,pcr + lbsr pstring + ldy #2 + bsr zapread lda ,x cmpa #$20 - bcs L0B79 - bra L0B4C -L0B96 bsr L0BAA - bcs L0BC9 + bcs exitzap + bra zapstart + +* Convert 2 hex chars in buffer (x) to object byte +hexobjct bsr cnvrtnib + bcs badrts tfr a,b - bsr L0BAA - bcs L0BC9 + bsr cnvrtnib + bcs badrts lslb lslb lslb lslb pshs b ora ,s+ - bra L0BC4 -L0BAA bsr L0BB0 - bcs L0BC9 - bra L0BCA -L0BB0 lda ,x+ - cmpa #$30 - bcs L0BC7 - cmpa #$39 - bls L0BC4 - anda #$5F - cmpa #$41 - bcs L0BC7 - cmpa #$46 - bhi L0BC7 -L0BC4 andcc #$FE + bra goodhex + +cnvrtnib bsr isithex + bcs badrts + bra cnvrthex + +isithex lda ,x+ + cmpa #'0 + bcs badhex + cmpa #'9 + bls goodhex + anda #$5F lower to upper + cmpa #'A + bcs badhex + cmpa #'F + bhi badhex +goodhex andcc #$FE rts -L0BC7 orcc #$01 -L0BC9 rts -L0BCA suba #$30 - cmpa #$09 - bls L0BD2 - suba #$07 -L0BD2 bra L0BC4 -L0BD4 tst <u002E - lbne L070B - bsr L0BFF - lbne L070B - lbsr L078F - lbsr L07B0 - lbsr L078F - leax >L00FF,pcr - lbsr L0759 -L0BF0 lbsr L07F1 - lda <u0000 - lbsr L0C8A - tst <u002E - beq L0C74 - clr <u002D +badhex orcc #1 +badrts rts + +cnvrthex suba #$30 + cmpa #9 + bls nowobjct + suba #7 +nowobjct bra goodhex + +* Write current sector back to disk +writesec tst <xprtflag is expert mode on + lbne getcmd yes, then go + bsr rusure no, are you sure + lbne getcmd Y or N + lbsr movecmd + lbsr clrline + lbsr movecmd + leax >writing,pcr + lbsr pstring +xprtwrt lbsr lsnseek seek to start of sector + lda <inpath path# + lbsr write100 write 256 bytes + tst <xprtflag + beq opendone + clr <wrtflag clear auto-write rts -L0BFF lbsr L078F -L0C02 clr <u001A - com <u001A - lbsr L10F5 - leax >L00EB,pcr - lbsr L0759 - lbsr L07B0 - leax >u01D6,u - lbsr L07E8 - clr <u001A - lbsr L10F5 + +* Ask Are you sure? And get response +rusure lbsr movecmd +rusure10 clr <echobyte + com <echobyte + lbsr echo + leax >sure,pcr + lbsr pstring + lbsr clrline + leax >i.o.buff,u + lbsr read1 + clr <echobyte + lbsr echo lda ,x - anda #$5F - cmpa #$59 + anda #$5F lower to upper + cmpa #'Y rts -L0C26 tst <u0001 - bne L0C74 - clr <u001A - com <u001A - lbsr L10F5 - lbsr L078F - leax >L0110,pcr - lbsr L0759 - lbsr L07B0 - leax >u01D6,u - ldy #$001E - lbsr L0786 - clr <u001A - lbsr L10F5 - cmpy #$0001 - beq L0C74 + +* Open output file +openout tst <outpath + bne opendone + clr <echobyte + com <echobyte + lbsr echo + lbsr movecmd + leax >out$,pcr + lbsr pstring + lbsr clrline + leax >i.o.buff,u + ldy #30 29 char + CR + lbsr readlin + clr <echobyte + lbsr echo +*********************************************** +* Return to command prompt if no filename given +* Added 01/09/90 (RAK) +* + cmpy #1 + beq opendone +********************************** END modification pshs x - leay <u006B,u -L0C59 lda ,x+ + leay <outfile,u +savname lda ,x+ get name sta ,y+ - cmpa #$20 - bhi L0C59 - lda #$0D - sta -$01,y + cmpa #$20 space + bhi savname + lda #$0D CR + sta -1,y delimit puls x - lda #$02 - ldb #$0B + lda #2 write + ldb #$0B attributes read+write os9 I$Create - bcs L0CB6 - sta <u0001 - bsr L0C77 -L0C74 lbra L070B -L0C77 ldd #$3021 - lbsr L0792 - leax >L0110,pcr - lbsr L0759 - leax <u006B,u - lbra L0774 -L0C8A leax >u00D6,u - ldy <u001F + bcs error + sta <outpath + bsr prntout +opendone lbra getcmd + +* move cursor & print 'Outout pathlist' +prntout ldd #$3021 out position + lbsr movecurs + leax >out$,pcr + lbsr pstring + leax <outfile,u + lbra wrtlin1 + +* Write out a sector +write100 leax >inbuff,u + ldy <seclen os9 I$Write - bcs L0CB6 + bcs error rts -L0C97 lda <u0001 - beq L0C74 + +* Close output file +closeout lda <outpath + beq opendone os9 I$Close - bcs L0CB6 + bcs error ldd #$3021 - lbsr L0792 - lbsr L07B0 - clr <u0001 -L0CAB bra L0C74 -L0CAD lda <u0001 - beq L0CAB - bsr L0C8A - lbra L0A40 -L0CB6 pshs b - clr <u008B - ldd <u0005 - std <u0002 - lda <u0007 - sta <u0004 + lbsr movecurs + lbsr clrline + clr <outpath +closed bra opendone + +* Append sector to output file +append lda <outpath + beq closed + bsr write100 + lbra nxtsec + +* main error routine +error pshs b +* modification by BRI + clr <SgnlCode +* end modification + ldd <oldlsn + std <lsn + lda <oldlsn+2 + sta <lsn+2 puls b - lds <u001D - cmpb #$02 - beq L0CD7 - cmpb #$03 - bne L0CD3 - clr <u002D - bra L0CD7 -L0CD3 cmpb #$D3 - bne L0CDA -L0CD7 lbra L0B79 -L0CDA cmpb #$CD - bne L0CF2 - tst <u004D - bne L0CF2 - bsr L0D01 - leax >L000D,pcr - ldy #$0001 - lbsr L0778 - lbra L0708 -L0CF2 pshs b - lbsr L078F - lbsr L07B0 + lds <Ssave + cmpb #2 break + beq error2 + cmpb #3 shift break + bne eofchk + clr <wrtflag + bra error2 +eofchk cmpb #$D3 + bne truerr +error2 lbra exitzap + +truerr cmpb #$CD bad module ID + bne othererr +* If module is linked, BMID error must come from trying to Verify modules +* use standard error reporting routine. Otherwise BMID error occurs when +* trying to link (or list names of) modules; need to clear screen after these. + tst <infile module linked? + bne othererr yes, use standard error + bsr prterr display error # + leax >cls,pcr + ldy #1 + lbsr writeout + lbra disploop +othererr pshs b + lbsr movecmd + lbsr clrline puls b - bsr L0D01 - lbra L070B -L0D01 lda #$02 + bsr prterr + lbra getcmd + +* display error # +prterr lda #$02 error path os9 F$PErr - clr <u001A - lbsr L10F5 - leax >u01D6,u - lbra L07E8 - lda #$02 - leax >L05AC,pcr - ldy #$0078 - lbsr L077A + clr <echobyte + lbsr echo + leax >i.o.buff,u + lbra read1 + +* use with ded and no path list +hints lda #2 Now this is used + leax >usemess,pcr + ldy #$78 + lbsr wrtlin2 clrb - bra L0D34 -L0D22 lbsr L0BFF - lbne L070B - lbsr L07BA - lda <u0019 - sta <u001A - lbsr L10F5 + bra bye + +* Exit to OS-9 +quit lbsr rusure + lbne getcmd + lbsr clrscr + lda <oldecho + sta <echobyte + lbsr echo clrb -L0D34 os9 F$Exit -L0D37 lbsr L078F - leax >L009B,pcr - lbsr L0759 -L0D41 leax >u00D6,u - stx <u0014 - lda #$01 - sta <u0016 - lda #$23 - sta <u000F - lda #$25 - sta <u000E - lda #$58 - sta <u0010 -L0D57 lbsr L079C - lbsr L0E47 -L0D5D lda <u000E - ldb <u000F - tst <u0017 - beq L0D67 - lda <u0010 -L0D67 tst <u008C - lbeq L0E37 - ldx <u0003 +bye os9 F$Exit + +* Edit sector +edit lbsr movecmd + leax >edprompt,pcr + lbsr pstring +topleft leax >inbuff,u + stx <edbufptr + lda #1 + sta <edpos + lda #$23 top row code + sta <rownum + lda #$25 hex dump col# + sta <hexcol + lda #$58 ascii dump col# + sta <asciicol +revbyte lbsr revdisp + lbsr eddisply +edinput lda <hexcol + ldb <rownum + tst <hexascii + beq hexin + lda <asciicol +hexin tst <rawflg + lbeq edcont + ldx <lsn+1 cmpx #$0001 - lbcs L0E37 - cmpx <u008F - lbhi L0E37 + lbcs edcont not BAM + cmpx <mappags + lbhi edcont not BAM pshs b,a - ldx <u0091 - ldb <u0093 - stx <u0097 - stb <u0099 - ldx <u0094 - ldb <u0096 - stx <u009A - stb <u009C - clra - ldb <u000F + ldx <newBAM + ldb <newBAM+2 + stx <BAMstart + stb <BAMstart+2 + ldx <nBAMstp + ldb <nBAMstp+2 + stx <BAMstop + stb <BAMstop+2 + clra calc byte to cluster + ldb <rownum subb #$23 lda #$10 mul pshs b,a clra - ldb <u000E + ldb <hexcol subb #$25 - beq L0DA9 + beq hexin2 tfr d,x ldd #$0003 - lbsr L1728 + lbsr mul16B tfr x,d -L0DA9 addd ,s++ - ldx <u0003 - cmpx <u008F - bcs L0DC3 +hexin2 addd ,s++ + ldx <lsn+1 + cmpx <mappags + bcs hexin3 edit inside of BAM range pshs b,a - ldd <u008D + ldd <ddmap clra tfr d,x puls b,a leax -$01,x pshs x cmpd ,s++ - bhi L0DDD -L0DC3 ldx #$0008 - lbsr L16FE + bhi hexin4 edit outside of BAM range +hexin3 ldx #$0008 + tst clustflg using clusters or sectors + bne csf6 go if clusters + pshs d + ldd ddbit + lbsr mulDbyX + tfr u,x + puls d +csf6 lbsr mulDbyX + tfr u,d + addd <BAMstart+1 + std <BAMstart+1 + tst clustflg + bne csf7 go if cluster mode + pshs d + ldx #7 + ldd ddbit + lbsr mulDbyX tfr u,d - addd <u0098 - std <u0098 - addd #$0007 - cmpd <u0095 - bls L0DD9 - ldd <u0095 -L0DD9 std <u009B - bra L0DE3 -L0DDD clr <u009A - clr <u009B - clr <u009C -L0DE3 ldu <u001B - lbsr L07A6 - tst <u009C - bne L0DFF - tst <u009B - bne L0DFF - tst <u009A - bne L0DFF + addd ,s++ + bra csf8 +csf7 addd #$0007 fixed if clusters +csf8 cmpd <nBAMstp+1 + bls hexin5 + ldd <nBAMstp+1 +hexin5 std <BAMstop+1 + bra hexin6 +hexin4 clr <BAMstop + clr <BAMstop+1 + clr <BAMstop+2 +hexin6 ldu <Usave + lbsr normdisp + tst <BAMstop+2 + bne prtbmess + tst <BAMstop+1 + bne prtbmess + tst <BAMstop + bne prtbmess ldd #$2034 - lbsr L0792 - lbsr L07B0 - bra L0E32 -L0DFF lbsr L1748 + lbsr movecurs + lbsr clrline + bra hexin7 +prtbmess lbsr prntBAM ldd #$4934 - lbsr L0792 - leax >L0226,pcr - lbsr L0759 + lbsr movecurs + leax >BITmess,pcr Bits: + lbsr pstring leax >u009D,u - lda [<u0014,u] - ldb #$08 + lda [<edbufptr,u] + ldb #8 pshs x,a -L0E1A lsl ,s - bcs L0E22 - lda #$30 - bra L0E24 -L0E22 lda #$31 -L0E24 sta ,x+ +bmess2 lsl ,s + bcs bmess3 + lda #'0 + bra bmess4 +bmess3 lda #'1 +bmess4 sta ,x+ decb - bne L0E1A + bne bmess2 puls x,a - ldy #$0008 - lbsr L0778 -L0E32 lbsr L079C + ldy #8 + lbsr writeout +hexin7 lbsr revdisp puls b,a -L0E37 lbsr L0792 - leax >u01D6,u - tst <u0017 - lbne L0F38 - lbra L0EFE -L0E47 lda <u000E - ldb <u000F - lbsr L0792 - leay >u01D6,u - lda [<u0014,u] +************ End of BAM mod +edcont lbsr movecurs + leax >i.o.buff,u + tst <hexascii test for hex/ascii mode + lbne inputchr +* modification by BRI +* bra inputbyt + lbra inputbyt +* end mod +eddisply lda <hexcol + ldb <rownum + lbsr movecurs + leay >i.o.buff,u + lda [<edbufptr,u] pshs a - lbsr L095D - leax -$02,y - ldy #$0002 - lda #$01 - lbsr L077A - lda <u0010 - ldb <u000F - lbsr L0792 + lbsr convert1 + leax -2,y + ldy #2 + lda #1 + lbsr wrtlin2 + lda <asciicol + ldb <rownum + lbsr movecurs puls a anda #$7F cmpa #$20 - bcc L0E76 + bcc prntabl1 lda #$2E -L0E76 leax >u01D6,u +prntabl1 leax >i.o.buff,u sta ,x - ldy #$0001 - lbra L0778 -L0E83 pshs x,b -L0E85 clra - ldb #$01 + ldy #1 + lbra writeout + +* read in char, check for break key +* modification by BRI +* toggles cursor on/off if enabled, checks for character +*readit ldy #1 1 char +readit pshs x,b +CFlash1 clra + ldb #1 os9 I$GetStt - bcc L0ED6 - cmpb #$F6 - bne L0EBF - ldx #$0001 + bcc CFExit + cmpb #$F6 not ready + bne CrsrErr + ldx #1 os9 F$Sleep - bcs L0EBF - dec <u0089 - lda <u0089 - eora <u008A - anda #$40 - beq L0EB5 - com <u008A - beq L0EAB - bsr L0EC7 - bra L0EB5 -L0EAB leax >L0019,pcr - ldy #$0002 - bsr L0ECF -L0EB5 ldb <u008B - cmpb #$02 - beq L0EBF - cmpb #$03 - bne L0E85 -L0EBF stb ,s - bsr L0EC7 + bcs CrsrErr + dec <CrsrCnt + lda <CrsrCnt + eora <CrsrFlg + anda #$40 keep active counter bit + beq SigChk + com <CrsrFlg + beq CrsrOff + bsr CrsrOn + bra SigChk +CrsrOff leax >curoff,pcr + ldy #2 + bsr WritCrsr +SigChk ldb <SgnlCode + cmpb #2 abort code + beq CrsrErr + cmpb #$03 shift break + bne CFlash1 +CrsrErr stb ,s + bsr CrsrOn puls x,b - bra L0EE5 -L0EC7 leax >L0016,pcr - ldy #$0002 -L0ECF lda #$01 + bra cheksig2 +CrsrOn leax >curon,pcr + ldy #2 cursor on number of bytes +WritCrsr lda #1 os9 I$Write clrb rts -L0ED6 bsr L0EC7 +CFExit bsr CrsrOn puls x,b - ldy #$0001 + ldy #1 +* end of mod clra os9 I$Read - bcs L0EE5 - rts -L0EE5 leas $02,s - clr <u008B - cmpb #$02 - beq L0EF9 - pshs b - lbsr L101A - clr <u000F - puls b - lbra L0CB6 -L0EF9 com <u0017 - lbra L0D5D -L0EFE bsr L0E83 - bsr L0F1E - bcs L0F4A - lbsr L0778 - ldb ,x - lbsr L0E83 - bsr L0F1E - bcs L0F4A - exg a,b - lbsr L0B09 - stb [<u0014,u] - lda #$01 - sta <u002D - bra L0F75 -L0F1E lda ,x - cmpa #$30 - bcs L0F35 - cmpa #$39 - bls L0F32 - anda #$5F - cmpa #$46 - bhi L0F35 - cmpa #$41 - bcs L0F35 -L0F32 andcc #$FE - rts -L0F35 orcc #$01 - rts -L0F38 lbsr L0E83 - lda ,x - cmpa #$20 - bcs L0F4A - sta [<u0014,u] - lda #$01 - sta <u002D - bra L0F75 -L0F4A cmpa #$09 - beq L0F75 - cmpa #$08 - beq L0FB3 - cmpa #$0C - lbeq L1020 - cmpa #$0A - lbeq L1076 - cmpa #$0D - lbne L0D5D - lbsr L101A - ldd #$4934 - lbsr L0792 - lbsr L07B0 - clr <u000F - lbra L070B -L0F75 lbsr L101A - tst <u0020 - beq L0F84 - lda <u0016 - cmpa <u0020 - lbeq L0D41 -L0F84 ldd <u0014 - addd #$0001 - std <u0014 - inc <u0016 - inc <u0010 - lda <u0010 - cmpa #$68 - bcc L0F9E - lda <u000E - adda #$03 - sta <u000E - lbra L0D57 -L0F9E inc <u000F - lda <u000F - cmpa #$32 - lbhi L0D41 - lda #$25 - sta <u000E - lda #$58 - sta <u0010 - lbra L0D57 -L0FB3 bsr L101A - ldd <u0014 - subd #$0001 - std <u0014 - dec <u0016 - dec <u0010 - lda <u0010 - cmpa #$58 - bcs L0FCF - lda <u000E - suba #$03 - sta <u000E - lbra L0D57 -L0FCF dec <u000F - lda #$52 - sta <u000E - lda #$67 - sta <u0010 - lda <u000F - cmpa #$23 - bcs L0FE2 - lbra L0D57 -L0FE2 ldx <u0014 - ldb <u0020 - beq L100D - stb <u0016 - clra - leax d,x - decb - pshs b - lsrb - lsrb - lsrb - lsrb - addb #$23 - stb <u000F - lda ,s+ - anda #$0F - pshs a - adda #$58 - sta <u0010 - puls a - ldb #$03 - mul - addb #$25 - stb <u000E - bra L1015 -L100D lda #$32 - sta <u000F - leax >$0100,x -L1015 stx <u0014 - lbra L0D57 -L101A lbsr L07A6 - lbra L0E47 -L1020 bsr L101A - ldb <u0020 - beq L102C - lda <u000F - cmpa #$23 - beq L104F -L102C ldd <u0014 - subd #$0010 - std <u0014 - ldb <u0016 - subb #$10 - stb <u0016 - dec <u000F - lda <u000F - cmpa #$23 - bcc L104C - lda #$32 - sta <u000F - ldd <u0014 - addd #$0100 - std <u0014 -L104C lbra L0D57 -L104F andb #$F0 - lda <u0020 - anda #$0F - cmpa <u0016 - bcc L105B - subb #$10 -L105B clra - pshs b,a - ldd <u0014 - addd ,s+ - std <u0014 - ldb <u0016 - addb ,s - stb <u0016 - puls b - lsrb - lsrb - lsrb - lsrb - addb #$23 - stb <u000F - bra L104C -L1076 bsr L101A - ldb <u0020 - beq L1082 - subb <u0016 - cmpb #$10 - bcs L10A7 -L1082 ldd <u0014 - addd #$0010 - std <u0014 - lda <u0016 - adda #$10 - sta <u0016 - inc <u000F - lda <u000F - cmpa #$32 - lbls L0D57 - ldd <u0014 - subd #$0100 - std <u0014 -L10A0 lda #$23 - sta <u000F - lbra L0D57 -L10A7 clra - ldb <u0016 - decb - andb #$F0 - pshs b,a - ldd <u0014 - subd ,s+ - std <u0014 - ldb <u0016 - subb ,s+ - stb <u0016 - bra L10A0 -L10BD lbsr L07BA - lda <u0019 - sta <u001A - bsr L10F5 - leax >L0136,pcr - ldy #$0010 - leau >u01D6,u - lda #$0D - sta ,u - ldd #$0000 - os9 F$Fork - lbcs L0CB6 - os9 F$Wait - ldu <u001B - leax >u00D6,u - stx <u0012 - clr <u001A - bsr L10F5 -L10EF lbsr L07BA - lbra L0708 -L10F5 pshs x - leas <-$20,s - leax ,s - clra - clrb - os9 I$GetStt - lbcs L0CB6 - lda <u001A - sta $04,x - clra - os9 I$SetStt - lbcs L0CB6 - leas <$20,s - puls pc,x -L1116 lbsr L078F - leax >L0119,pcr - lbsr L0759 - ldu #$0000 - ldx #$0000 - stx <u0025 - lda <u0000 - os9 I$Seek - lbcs L0CB6 - ldu <u001B -L1133 ldd #$FFFF - std <u0029 - stb <u002B - leax >u01D6,u - ldy #$0008 - lda <u0000 - os9 I$Read - lbcs L0CB6 - cmpy #$0008 - lbne L120E - ldd ,x - cmpa #$87 - lbne L120E - cmpb #$CD - lbne L120E - ldd $02,x - cmpd #$000F - lbls L120E - subd #$0003 - std <u0021 - addd <u0025 - std <u0025 - clra - ldb #$08 -L1177 eora ,x+ - decb - bne L1177 - coma - sta ,x - ldy #$0001 - lda <u0000 - os9 I$Write - lbcs L0CB6 - ldd <u0021 - subd #$0009 - std <u0021 - leax >u01D6,u - ldy #$0009 - bsr L1201 -L119D lda <u0000 - ldy #$0078 - cmpy <u0021 - bls L11AB - ldy <u0021 -L11AB os9 I$Read - bcs L120E - sty <u0027 - bsr L1201 - ldd <u0021 - subd <u0027 - std <u0021 - bne L119D - lda <u0000 - ldb #$05 - os9 I$GetStt - tfr u,d - ldu <u001B - cmpd <u0025 - bne L120E - com <u0029 - com <u002A - com <u002B - leax <u0029,u - ldy #$0003 - lda <u0000 - os9 I$Write - lbcs L0CB6 - ldd #$0003 - addd <u0025 - std <u0025 - ldb #$06 - lda <u0000 - os9 I$GetStt - lbcc L1133 - cmpb #$D3 - lbne L0CB6 - lbsr L07C4 - lbra L0708 -L1201 leau <u0029,u - os9 F$CRC - lbcs L0CB6 - ldu <u001B - rts -L120E ldd #$2036 - lbsr L0792 - leax >L0125,pcr - lbsr L0759 - ldb #$CD - lbsr L0D01 - lbra L070B -L1223 tst <u004D - lbne L070B - ldd #$0000 - std <u0025 - std <u0023 - clr <u001A - com <u001A - lbsr L10F5 - lbsr L078F - lbsr L07B0 - leax >L013B,pcr - lbsr L0759 - leax <u004D,u - ldy #$001E - lbsr L0786 - clr <u001A - lbsr L10F5 - cmpy #$0001 - lbne L130C - lbsr L07BA - clr <u004D - leax >L0151,pcr - lbsr L0774 -L1267 ldd <u0023 - addd <u0025 - std <u0025 - tfr d,u - ldx #$0000 - lda <u0000 - os9 I$Seek - bcs L12F8 - ldu <u001B - leax >u01D6,u - ldy #$0006 - os9 I$Read - bcs L12F8 - ldd ,x++ - cmpa #$87 - bne L12F6 - cmpb #$CD - bne L12F6 - leay >u01D6,u - ldd ,x++ - std <u0023 - ldd ,x++ - pshs b,a - ldd <u0025 - bsr L12E6 - lda #$20 - sta ,y+ - ldd <u0023 - bsr L12E6 - lda #$20 - sta ,y+ - ldd <u0025 - addd ,s++ - tfr d,u - ldx #$0000 - lda <u0000 - os9 I$Seek - lbcs L0CB6 - ldu <u001B - tfr y,x - ldy #$001D - lda <u0000 - os9 I$Read - lbcs L0CB6 -L12D1 lda ,x+ - bpl L12D1 - anda #$7F - sta -$01,x - lda #$0D - sta ,x - leax >u01D6,u - lbsr L0774 - bra L1267 -L12E6 lbsr L095D - tfr b,a - lbra L095D -L12EE cmpb #$D3 - bne L12F8 - ldb #$DD - bra L12F8 -L12F6 ldb #$CD -L12F8 clr <u004D - cmpb #$D3 - lbne L0CB6 - lbsr L07E8 - leax >u00D6,u - stx <u0012 - lbra L10EF -L130C os9 F$PrsNam - lbcs L0CB6 - stb <u002C - decb - lda b,x - ora #$80 - sta b,x - stx <u0029 - ldu #$0000 -L1321 ldx #$0000 - lda <u0000 - os9 I$Seek - lbcs L0CB6 - ldu <u001B - leax >u01D6,u - ldy #$0006 - os9 I$Read - bcs L12EE - ldd ,x++ - cmpa #$87 - bne L12F6 - cmpb #$CD - bne L12F6 - ldd ,x++ - std <u0023 - ldd ,x - addd <u0025 - tfr d,u - ldx #$0000 - lda <u0000 - os9 I$Seek - bcs L12EE - ldu <u001B - leax >u01D6,u - ldy #$001D - os9 I$Read - bcs L12EE - tfr x,y - ldx <u0029 - ldb <u002C - os9 F$CmpNam - bcc L137E - ldd <u0023 - addd <u0025 - std <u0025 - tfr d,u - bra L1321 -L137E lda #$0D - sta b,x - decb - lda b,x - anda #$7F - sta b,x - ldd <u0025 - std <u0008 - ldd #$0006 - leax u0002,u -L1392 sta ,x+ - decb - bne L1392 - lbra L06F5 -L139A ldd #$3020 - lbsr L0792 - leax >L016F,pcr - lbsr L0759 - leax <u004D,u - lbsr L0774 - ldd #$5820 - lbsr L0792 - leax >L0178,pcr - lbsr L0759 - leay >u01D6,u - ldd <u0008 - lbsr L12E6 - lda #$0D - sta ,y - lbra L0778 -L13CA tst <u004D - lbeq L070B - ldd #$0008 - leax u0002,u -L13D5 sta ,x+ - decb - bne L13D5 - ldd #$3020 - lbsr L0792 - lbsr L07B0 - lbsr L07B0 - clr <u004D - lbra L06F5 -L13EB tst <u002E - beq L13FD - clr <u002E - ldd #$5933 - lbsr L0792 - lbsr L07B0 -L13FA lbra L070B -L13FD lbsr L0BFF - bne L13FA - com <u002E - ldd #$5933 - lbsr L0792 - leax >L0181,pcr - lbsr L0759 - bra L13FA -L1413 lbsr L07BA - leax >L023E,pcr - ldy #$036E - lbsr L077A - leax >u01D6,u - lbsr L07E8 - lbra L10EF -L142B clr <u001A - com <u001A - lbsr L10F5 - lbsr L078F - lbsr L07B0 - tst <u002F - bne L1471 - leax >L0194,pcr - lbsr L0759 - ldy #$0021 - lbsr L1514 - cmpy #$0001 - lbeq L1559 - leay -$01,y - tfr y,d - lsrb - lbcs L152E - stb <u0030 - leau <u0031,u -L1460 lbsr L0B96 - lbcs L152E - sta ,u+ - leay -$02,y - bne L1460 - ldu <u001B - bra L1496 -L1471 leax >L01A6,pcr - lbsr L0759 - ldy #$0011 - lbsr L1514 - cmpy #$0001 - lbeq L1559 - tfr y,d - decb - stb <u0030 - leay <u0031,u -L148F lda ,x+ - sta ,y+ - decb - bne L148F -L1496 clr <u001A - lbsr L10F5 - leax >u00D6,u -L149F ldb <u0020 - leay <u0031,u -L14A4 lda ,y - eora ,x+ - lbeq L155C - tst <u002F - beq L14B6 - bita #$5F - lbeq L155C -L14B6 decb -L14B7 bne L14A4 - pshs y,x,b,a - clra - ldb #$01 - os9 I$GetStt - bcs L14D0 - leax >u01D6,u - lbsr L07E8 - lda ,x - cmpa #$05 - beq L1546 -L14D0 puls y,x,b,a - bsr L14D6 - bra L149F -L14D6 tst <u004D - beq L14E3 - ldd <u0023 - subd #$0001 - cmpa <u0004 - beq L1546 -L14E3 ldd <u0003 - addd #$0001 - std <u0003 - bne L14EE - inc <u0002 -L14EE lbsr L07F1 - leax >u00D6,u - stx <u0012 - tst <u004D - beq L1505 - ldd <u0023 - suba <u0004 - bne L1505 - tfr d,y - bra L1509 -L1505 ldy #$0100 -L1509 lda <u0000 - os9 I$Read - bcs L1540 - sty <u001F - rts -L1514 leax >u01D6,u - clra - os9 I$ReadLn - bcs L151F - rts -L151F leas $02,s - clr <u008B - cmpb #$02 - lbne L0CB6 - com <u002F - lbra L142B -L152E ldu <u001B - bsr L1535 - lbra L142B -L1535 leax >L022B,pcr - ldy #$0001 - lbra L0778 -L1540 cmpb #$D3 - lbne L0CB6 -L1546 lds <u001D - ldd <u0005 - std <u0002 - lda <u0007 - sta <u0004 - lbsr L07C4 - sty <u001F - bsr L1535 -L1559 lbra L0B79 -L155C pshs b - decb - stb <u0044 - stx <u0042 - ldb <u0030 -L1565 decb - beq L1597 - dec ,s - beq L1588 -L156C leay $01,y - lda ,y - eora ,x+ - beq L1565 - tst <u002F - beq L157C - bita #$5F - beq L1565 -L157C leas $01,s - ldx <u0042 -L1580 leay <u0031,u - ldb <u0044 - lbra L14B7 -L1588 leas $01,s - pshs y,b - lbsr L14D6 - puls y,b - lda <u0020 - pshs a - bra L156C -L1597 leas $01,s - lda <u0004 - cmpa <u0007 - beq L15C0 - cmpx <u0042 - bcc L15B8 - ldd <u0003 - subd #$0001 - std <u0003 - cmpd #$FFFF - bne L15B2 - dec <u0002 -L15B2 lbsr L07C4 - sty <u001F -L15B8 ldd <u0002 - std <u0005 - lda <u0004 - sta <u0007 -L15C0 lbsr L081F - ldd <u0042 - subd #$0001 - std <u0014 - subd <u0012 - pshs b - andb #$0F - pshs b - addb #$58 - stb <u0010 - puls b - lda #$03 - mul - addb #$25 - stb <u000E - puls b - andb #$F0 - lsrb - lsrb - lsrb - lsrb - addb #$23 - stb <u000F - lbsr L079C - lbsr L0E47 - lbsr L07A6 - clr <u000F - lbra L1559 -L15F9 tst <u0030 - lbeq L070B - lbsr L078F - leax >L01B8,pcr - lbsr L0759 - ldx <u0042 - lbeq L1496 - lbra L1580 -L1612 lbsr L078F - leax >L01C4,pcr - lbsr L0759 - com <u0018 - leay >u01D6,u - ldd <u0049 - lbsr L095D - tfr b,a - lbsr L095D - ldd <u004B - lbsr L095D - clr <u0018 - tfr b,a - lbsr L095D - ldd #$2020 - std ,y++ - std ,y++ - leax >u01D6,u - stx <u0027 - tfr y,d - subd <u0027 - tfr d,y - lbsr L0778 - leax >L01D9,pcr - lbsr L0759 - ldy #$0009 - lbsr L0A89 - bcs L1612 - ldd #$2037 - lbsr L0792 - lbsr L0C02 - lbne L070B - ldx <u0045 - ldu <u0047 - ldb #$02 - lda <u0000 - os9 I$SetStt - lbcs L0CB6 - stx <u0049 - stu <u004B - ldu <u001B - lda <u0049 - cmpa <u0002 - bcs L1692 - bne L168F - ldd <u004A - cmpd <u0003 - bls L1696 -L168F lbra L06F5 -L1692 sta <u0002 - ldd <u004A -L1696 tst <u004C - bne L169D - subd #$0001 -L169D std <u0003 - cmpd #$FFFF - bne L168F - dec <u0002 - bra L168F -L16A9 lda <u00A5 - cmpa #$10 - bcc L16D3 - ldb #$03 - mul - leax >u00A6,u - leax b,x - ldd <u0002 - std ,x++ - lda <u0004 - sta ,x - tst <u00A5 - beq L16CE - cmpa -$03,x - bne L16CE - ldd <u0002 - cmpa -$05,x - beq L16D0 -L16CE inc <u00A5 -L16D0 lbra L070B -L16D3 lbsr L078F - leax >L022B,pcr - lbsr L0759 - lbsr L07E8 - bra L16D0 -L16E2 lda <u00A5 - beq L16D0 - ldb #$03 - mul - subb #$03 - leax >u00A6,u - leax b,x - ldd ,x++ - std <u0002 - lda ,x - sta <u0004 - dec <u00A5 - lbra L06F5 -* I think this is a general purpose 16x16 bit multiplication. -* regD is first number, regX is second number. -* Returns answer in regY and regU. -L16FE pshs u,y,x,b,a - clr $04,s - lda $03,s lower word of regX times regB - mul - std $06,s - ldd $01,s upper word of regX times regB - mul - addb $06,s - adca #$00 - std $05,s - ldb ,s original regA - lda $03,s upper word regX - mul - addd $05,s - std $05,s - bcc L171D - inc $04,s -L171D lda ,s - ldb $02,s - mul - addd $04,s - std $04,s - puls pc,u,y,x,b,a -L1728 pshs x,b,a - lda #$10 - pshs a - clra - clrb -L1730 lsl $04,s - rol $03,s - rolb - rola - cmpd $01,s - bcs L173F - subd $01,s - inc $04,s -L173F dec ,s - bne L1730 - ldx $03,s - leas $05,s - rts -L1748 ldd #$2034 - lbsr L0792 - leax >L0202,pcr BAM message - lbsr L0759 - leay >u01D6,u - pshs y - ldd <u0097 get 3 byte address and display it - lbsr L095D convert hex to ascii - tfr b,a - lbsr L095D convert hex to ascii - lda <u0099 - lbsr L095D convert hex to ascii - lda ,-y - ora #$80 - sta ,y - ldd #$3234 - lbsr L0792 - ldx ,s - lbsr L0759 - ldy ,s - ldd <u009A - lbsr L095D - tfr b,a - lbsr L095D - lda <u009C - lbsr L095D - lda ,-y - ora #$80 - sta ,y - ldd #$3D34 - lbsr L0792 - puls x - lbsr L0759 - rts - emod -eom equ * - - ELSE - - nam dEd OS-9 Disk Editor Version 2.01 - ttl Copyright 1987 Doug DeMartinis - -******************************************************* -* Copyright 1987 Doug DeMartinis; All Rights Reserved * -* CIS: 72245,1400 * -* Delphi: DOUGLASD * -* Personal use and uploading of code, source and docs * -* to BBS's, as well as customization of the terminal * -* display codes, is permitted only if the copyright * -* notice and docs remain intact. * -* * -* 10/87 Various mods & fixes by Bruce Isted (BRI) * -* 11/87 Added Diddle, Find, Push, Remove routines. * -* Fixed bug throwing stack off by going in and * -* out of various error routines. * -* * -******************************************************* -* * -* Mods by Roger A. Krupski (HARDWAREHACK) * -* * -* 02/88 -Added "enter" command which cleans up the * -* screen by running the REDO subroutine. (RAK) * -* * -* 01/90 -Added a check for the break key which allows * -* aborting the <F>ind function. (RAK) * -* -Added a check for null filename in OUTFILE: * -* and bypass I$Create if so. * -* -Other minor bugs fixed / errors trapped. * -******************************************************* - - ifp1 - use defsfile - endc - -type set prgrm+objct -revs set reent+1 - -top mod dEdend,dEdnam,type,revs,start,size - -************************************************************************** -* To customize dEd for another driver, change the value of 'xyflipr', * -* change co380 to FALSE and OTHER to TRUE, and make the appropriate * -* changes to the display codes in the block that begins 'ifne OTHER'. * -* WordPak users only need to change co380 to FALSE and WPAK to TRUE. * -************************************************************************** - -* Set xyflipr to 1 if XY cursor move code has form: row,col -* Set " to 0 " " " " " " " col,row -xyflipr set 0 co380 uses $2,Col,Row to position cursor - -* Change one of the following lines to TRUE and others to FALSE, -* depending on which 80 column display you're using. - -co380 set FALSE Set to TRUE if using Mike Dziedzic's co380 driver -WPAK set FALSE Set to TRUE if using WordPak -OTHER set TRUE Set to TRUE for another driver and change codes below - -* Conditional assembly of terminal commands depending on previous choices: - - ifne OTHER -* e.g. CoCo 3, OS-9 Level II -* Change the appropriate byte strings below for another driver - -xyflipr set 0 Change to 1 if XY Cursor move code wants form Row,Col -curscode set $2 XY Cursor move code (max length=2 bytes) -cls fcb $c Clear Screen byte string -clschrs equ *-cls Don't change this. -revvid fcb $1F,$20,0 Reverse Video byte string. Must end with a 0. -revchrs equ *-revvid-1 Don't change this. -normvid fcb $1F,$21,0 Normal Video byte string. MUST end with a 0. -normchrs equ *-normvid-1 Don't change this. -eraselin fcb 4 Erase to End of Line byte string. -eraschrs equ *-eraselin Don't change this. -erasescr fcb $b Erase to End of Screen byte string. -era2chrs equ *-erasescr Don't change this. - -* modification by BRI -* adds cursor on/off strings & string lengths -CursrOn fcb $05,$21,0 Cursor on string. MUST end with a 0. -CursOn equ *-CursrOn-1 Don't change this. -CursrOff fcb $05,$20,0 Cursor off string. MUST end with a 0. -CursOff equ *-CursrOff-1 Don't change this. -* end modification - - endc - - ifne WPAK -* This is for WordPak driver - -xyflipr set 1 cursor move wants row,col -curscode set $2 XY cursor move code -cls fcb $c clear screen code -clschrs equ *-cls -revvid fcb $1b,$53,$21,0 reverse video toggle -revchrs equ *-revvid-1 # chars in code string -normvid fcb $1b,$53,$20,0 normal video toggle -normchrs equ *-normvid-1 -eraselin fcb $1b,$41 erase to end of line -eraschrs equ *-eraselin -erasescr fcb $1b,$42 erase to end of screen -era2chrs equ *-erasescr - -* modification by BRI -* adds cursor on/off strings & string lengths -CursrOn fcb 0 Cursor on string. MUST end with a 0. -CursOn equ *-CursrOn-1 Don't change this. -CursrOff fcb 0 Cursor off string. MUST end with a 0. -CursOff equ *-CursrOff-1 Don't change this. -* end modification - - endc - - ifne co380 -* This is for co380 driver for CoCo3 -xyflipr set 0 cursor move wants col,row -curscode set $2 1st byte of move cursor code -cls fcb $c clear screen code -clschrs equ *-cls -revvid fcb 0 reverse video not supported by co380 -revchrs equ *-revvid-1 # chars in code string -normvid fcb 0 Reverse video off not supported by co380 -normchrs equ *-normvid-1 -eraselin fcb 4 erase to end of line -eraschrs equ *-eraselin -erasescr fcb $b erase to end of screen -era2chrs equ *-erasescr - -* modification by BRI -* adds cursor on/off strings & string lengths -CursrOn fcb 0 Cursor on string. MUST end with a 0. -CursOn equ *-CursrOn-1 Don't change this. -CursrOff fcb 0 Cursor off string. MUST end with a 0. -CursOff equ *-CursrOff-1 Don't change this. -* end modification - - endc - -*********************************************************************** -* All the changes for customizing dEd should be done above this line. * -*********************************************************************** - - -* Don't change the following 2 blocks. -* X,Y coordinates of various screen prompts - ifne xyflipr -hedrpos set $2220 Header position (row/col) -cmdpos set $3620 Command position -cmd1pos set $3720 Command position + 1 row -outpos set $2130 Output pathlist position -modpos set $2030 Module name position -offpos set $2058 Offset position -xprtpos set $3435 EXPERT position - - else - -hedrpos set $2022 -cmdpos set $2036 Command position -cmd1pos set $2037 Command position + 1 row -outpos set $3021 Output pathlist position -modpos set $3020 Module name position -offpos set $5820 Offset position -xprtpos set $3534 EXPERT position - endc - -**************************** -* Variable Storage -**************************** - -bufsiz equ 120 -MaxStack equ 16 maximum # sectors that can be 'pushed' onto stack - -inpath rmb 1 input path # -outpath rmb 1 output path # -lsn rmb 3 Logical Sector number -oldlsn rmb 3 LSN backup -offset rmb 2 'Linked' module offset -cursor rmb 4 Move cursor code -hexcol rmb 1 Hex dump column # -rownum rmb 1 Row number (Hex 0-f) -asciicol rmb 1 ASCII dump col # -lastflag rmb 1 Flag for last line display -buffptr rmb 2 Pointer for input buffer -edbufptr rmb 2 Edit buffer pointer -edpos rmb 1 Edit position counter for partial sector reads -hexascii rmb 1 hex/ascii edit mode flag; 0=>Hex, FF=>ASCII -zeroflag rmb 1 leading zero suppression flag, $FF=>Suppress -oldecho rmb 1 original echo status -echobyte rmb 1 current echo status -Usave rmb 2 U register storage -Ssave rmb 2 S register storage -seclen rmb 2 sector length ($100 unless last LSN in file) -vmodlen rmb 2 Verify module length -lmodlen rmb 2 'Linked' module length -fileln rmb 2 cumulative file length -bytsread rmb 2 bytes read during verify -CRC rmb 3 CRC accumulator for verify -modnmlen rmb 1 'Link' module name length -wrtflag rmb 1 Flag to auto-write sector -xprtflag rmb 1 Expert mode flag -FHexAsc rmb 1 'Find' Hex/Ascii mode flag -targlen rmb 1 length of string to find -findstr rmb 17 string to 'Find' -FindPtr rmb 2 pointer to byte to start next search at -FBytes rmb 1 # bytes left in target string -HexBuff rmb 4 scratch area for ASCII to Hex conversions -FileLen rmb 4 File length -infile rmb 30 linked module name -outfile rmb 30 Output filename - -* modification by BRI -CrsrCnt rmb 1 8-bit cursor toggle counter (bit 3 active) -CrsrFlg rmb 1 cursor toggle (initialized to 0) -SgnlCode rmb 1 intercept routine signal code -* end modification - -StackCnt rmb 1 # sectors on stack -Stack rmb 3*MaxStack room for 16 LSN's - -inbuff rmb 256 input buffer -i.o.buff rmb bufsiz input/output buffer - rmb 200 stack storage -size equ . end of data area - -dEdnam fcs /dEd/ - fcb 3 version - fcc /Copyright 1987 Doug DeMartinis/ - -* Display messages - -lsntitle fcs /LSN=$/ -sect fcs /SECTOR = $/ -header fcc / 0 1 2 3 4 5 6 7 8 9 A B C D E F 0 2 4 6 8 A C E / - fcb $d -command fcs /CMD: / -edprompt fcs "<BREAK> toggles HEX/ASCII edit modes <ENTER> exits edit mode" -zaprompt fcs /Zap / -byte fcs /byte: / -char fcs /char: / -sure fcs "Are you sure? (Y/N) " -writing fcs /Writing sector.../ -out$ fcs /OUTFILE: / -vrfymess fcs /Verifying.../ -verrmess fcs /Verify aborted.../ -shell$ fcs /shell/ -linkmess fcs /Link to which module? / -linkhdr fcc /Off Len Name/ - fcb $a - fcc /---- ---- ----/ - fcb $d -modnmhdr fcs /MODULE: / -offmess fcs /OFFSET: $/ -xprtmess fcb $1f,$24 cc3 blink on - fcc /- Expert Mode -/ - fcb $1f,$25+$80 blink off -findbyte fcs /Find byte string $/ -findchar fcs /Find char string: / -srchmess fcs /Searching.../ -lenmess fcs /Current File Length $/ -newmess fcs /New Length? $/ -fullmess equ * -bell fcb 7 - fcs /Sector Stack Full / - -* modification by BRI -* alphabetized help list, -* removed redundant 'Close' message, -* added prompt at end -helper fcc " Up/Down Arrows Read & display Next/Previous sector" - fcb $a,$a - fcc / <CR> Clean up the screen display/ - fcb $a - fcc / $ Fork a SHELL (Ctrl-BREAK to return)/ - fcb $a - fcc / A Append displayed sector to output file/ - fcb $a - fcc / C Close output file/ - fcb $a - fcc / D Diddle (adjust) file length/ - fcb $a - fcc / E Edit the displayed sector/ - fcb $a - fcc / F Find a byte or text string (BREAK aborts)/ - fcb $a - fcc / H Help screen (also use '?')/ - fcb $a - fcc / L Link to a module - List all modules/ - fcb $a - fcc / N Next occurrence of byte(s) or string (Find)/ - fcb $a - fcc / O Open a file for output (use with Append)/ - fcb $a - fcc / P Push current sector onto stack/ - fcb $a - fcc / Q Quit dEd - Exit to OS9/ - fcb $a - fcc / R Remove and display a sector from stack/ - fcb $a - fcc / S Skip to given sector (sector # in hex)/ - fcb $a - fcc / U Unlink from module/ - fcb $a - fcc / V Verify all modules in file/ - fcb $a - fcc / W Write the sector back to the disk/ - fcb $a - fcc " X eXpert mode toggle on/off" - fcb $a - fcc / Z Zap (fill in) the sector displayed/ - fcb $a,$a - fcc / (Press any key to return to command prompt):/ -*fcb $a -helpchrs equ *-helper -* end modifications - -hints fcc /Use: dEd <pathlist>/ - fcb $0d - -* Table for converting Hex to Decimal - -decimals fcb $98,$96,$80 Decimal 10,000,000 - fcb $0f,$42,$40 Decimal 1,000,000 - fcb $01,$86,$A0 Decimal 100,000 - fcb $00,$27,$10 Decinal 10,000 - fcb $00,$03,$E8 Decimal 1,000 - fcb $00,$00,$64 Decimal 100 - fcb $00,$00,$0A Decimal 10 - fcb $00,$00,$01 etc. - -commands fcb $c up arrow - fdb nxtsec - fcb $a down arrow - fdb prevsec - fcb '$ shell - fdb goshell - fcb $d c/r clean up screen - fdb redo - fcb 's LSN change - fdb changLSN - fcb 'z zap - fdb zap - fcb 'w write sector - fdb writesec - fcb 'o open output file - fdb openout - fcb 'a append to out file - fdb append - fcb 'c close out file - fdb closeout - fcb 'e edit sector - fdb edit - fcb 'q quit - fdb quit - fcb 'v verify - fdb verify - fcb 'l 'link' to module - fdb linker - fcb 'u 'unlink' module - fdb unlinker - fcb 'x Expert mode - fdb expert - fcb 'h Help - fdb help - fcb '? - fdb help - fcb 'f - fdb find - fcb 'n - fdb next - fcb 'd - fdb diddle - fcb 'p - fdb push - fcb 'r - fdb remove - fcb 0 end of table - -* Intercept signals -* modification by BRI -*icept rti -icept stb SgnlCode,u save signal code - rti -* end modification - - -start equ * entry point - - stx inbuff save pointer to param - leax icept,pcr intercept routine addr - os9 f$icpt set up intercept - lbcs error - -* Initialize data area - - clra - ldb #inbuff # bytes to clear - leax ,u point X to start of data area -init sta ,x+ zero memory - decb dec counter - bne init loop if not done - stu Usave save U register - sts Ssave save Stack pointer - -setcurs ldd #curscode cursor move code - std cursor save it for output - leas -32,s make room for terminal options - leax ,s point x to 32 byte buffer - clra path = 0 (stdin) - clrb (SS.OPT - option status) - os9 i$getstt read in option table - lbcs error - lda 4,x get echo status byte - sta oldecho save it - leas 32,s reset stack - -* Open file - - ldx inbuff pointer to file name - lda #updat. mode=update - os9 i$open open file - -* modification by BRI -* lbcs bye exit if error - bcc OpenOK - cmpb #E$FNA no permission? - lbne bye no, go exit with error - ldx inbuff pointer to file name - lda #DIR.+UPDAT. mode=directory+update - os9 I$Open open file - lbcs bye exit if error -OpenOK equ * -* end modification - - sta inpath save input path # - ldb #ss.size - os9 i$getstt get file size - stx FileLen save - stu FileLen+2 - ldu Usave restore U - clr echobyte no echo flag - lbsr echo set echo status - lbsr clrscr go clear screen - -* Main Read/Display loop - -readloop lbsr seeksec find sector & read it - sty seclen bytes read ($100 unless last LSN in file) - ldd lsn get lsn just read - std oldlsn & save it - lda lsn+2 for retrieval - sta oldlsn+2 after read errors - ldd #0 Signal 'Next' command to start - std findptr search at start of LSN -disploop lbsr display go display sector -getcmd lbsr movecmd move cursor - leax command,pcr point to 'CMD: ' - bsr pstring display line - leax erasescr,pcr erase to end of screen - ldy #era2chrs - os9 i$write - lbcs error - leax i.o.buff,u point to buffer to read into - lbsr read1 read a char from stdin - lda ,x get char read - cmpa #'A alpha char? - blo srchtabl no, leave it alone - ora #$20 else UPPER -> lower case -srchtabl leax commands,pcr point to command table -findcmd cmpa ,x+ got command? - beq gotcmd yes, bra - leax 2,x else, skip address - tst ,x end of table? - bne findcmd no, loop back - bra getcmd key invalid, exit -gotcmd tst xprtflag expert mode? - beq jmpcmd no, bra - tst wrtflag need to write buffer out - beq jmpcmd no, bra - pshs x,a - lbsr xprtwrt write sector - puls a,x -jmpcmd ldd ,x get address offset - leax top,pcr start of module - jmp d,x jump to offset addr - - -* Print string of characters having bit 7 of last char set - -pstring leay i.o.buff,u output buffer - clrb counter -xfer incb - lda ,x+ get char - bmi lstchar bra if bit 7 set - sta ,y+ put in buffer - bra xfer get more -lstchar anda #$7f clr bit 7 - sta ,y put in buffer - leax i.o.buff,u point to char string - clra - tfr d,y y= length of string - bra writeout - -wrtlin1 ldy #bufsiz write 200 chars max -writeout lda #1 stdout -wrtlin2 os9 i$writln write line - lbcs error - rts - -readlin3 ldy #3 # chars to read -readlin clra stdin - os9 i$readln read in Y-1 chars + CR - lbcs error - rts - -movecmd ldd #cmdpos -movecurs leax cursor,u point to cursor move code - std 2,x save row/col - ldy #4 4 chars - bra writeout - -* Set display to reverse video - -revdisp leax revvid,pcr point to code - ldy #revchrs # chars - bra writeout write to stdout - -* Set display to normal video - -normdisp leax normvid,pcr point to code - ldy #normchrs # chars - bra writeout write to stdout - - -clrline leax eraselin,pcr point to erase line code - ldy #eraschrs # chars - bra wrtlin2 go erase rest of line & return - -clrscr leax cls,pcr point to clear screen code - ldy #clschrs #chars - bra writeout clear screen & return - -seeksec bsr lsnseek seek to sector - leax inbuff,u point to buffer - stx buffptr save pointer - tst infile module linked? - beq read256 no, bra - ldd lmodlen linked mod length - suba lsn+2 >$100 bytes left? - bne read256 yes, bra - tfr d,y no, set up for smaller read - bra readsome -read256 ldy #$100 read 256 bytes -readsome lda inpath path # -read os9 i$read read them in - lbcs error - rts - -****************************** -* changed to ignore errors 01/09/90 (RAK) -* -read1 - clra stdin - ldy #1 get 1 byte - os9 I$Read get 1 byte - rts ignore any errors -* bra read -****************************** END of modification - -lsnseek tst infile module linked? - bne offchk yes, bra - ldx lsn x=lsn MS 16 bits - lda lsn+2 get 3rd byte of lsn - clrb -lsnseek1 tfr d,u u=LS 16 bits - lda inpath get input path # - os9 i$seek seek lsn - lbcs error - ldu usave restore U -lsnrts rts - -offchk ldd lmodlen linked mod length - subd #1 now A=LSN of last sector - cmpa LSN+2 trying to read past last sector? - bhs offseek no, bra - ldb #e$eof yes, set EOF error - lbra error -* If module is 'linked' must add offset to functional LSN ->true seek count -offseek ldd offset - adda lsn+2 offset + 'LSN' - ldx #0 - bra lsnseek1 seek to 'LSN' - -display ldd #$2020 - lbsr movecurs - leax lsntitle,pcr point to "lsn..." - lbsr pstring - bsr clrline clear rest of line - bsr convert3 convert lsn to ascii/dec - leax i.o.buff,u - lbsr wrtlin1 - - tst infile is a module 'linked'? - beq nolink no, bra - lbsr prntmod yes, display name - -nolink tst outpath is an output file open? - beq noout no, bra - lbsr prntout yes, print name - -noout ldd #hedrpos get header row/col - lbsr movecurs move cursor - leax revvid,pcr point to reverse video code - ldy #revchrs # chars - lbsr wrtlin2 - leax header,pcr point to header - lbsr wrtlin1 display it - leax normvid,pcr point to normal vid code - ldy #normchrs # chars - lbsr wrtlin2 write code out -disp lbsr dsplylin - lda rownum get row # - adda #$10 next row - sta rownum save it - bne disp do 16 rows - leax inbuff,u - stx buffptr reset buffer pointer - tst xprtflag Expert mode? - beq lsnrts no, return - ldd #xprtpos - lbsr movecurs - leax xprtmess,pcr - lbra pstring display 'EXPERT' & return - -* Convert 3 HEX bytes to ASCII - -convert3 ldd lsn get 2 MSB's of LSN - com zeroflag suppresw leading zeroes - leay i.o.buff,u point to output buffer - bsr convert1 convert byte in A to ascii - tfr b,a - bsr convert1 and convert 2nd byte - clr zeroflag stop suppressing leading 0's - lda lsn+2 get LSB of LSN - bsr convert1 and convert it - ldd #$2020 2 space - std ,y++ put in out buffer - -* Output LSN as decimal number - - ldd #$0008 8 dec digits max, 0=counter - pshs d save them - com zeroflag suppress leading zeroes - leax decimals,pcr point to conversion table -initsub1 clr ,s set counter = 0 -subdec1 ldd lsn+1 get LSB's of LSN - subd 1,x subtract LSB's of table entry - pshs cc save 'carry' - std lsn+1 save result - lda lsn get MSB - clrb flag for enough subtractions - suba ,x subtract MSB of LSN - bcc LSBborow if no 'borrow', see if LSB sub needed borrow - incb else, enough subs done -LSBborow puls cc restore LSB 'borrow' flag - bcc savemsb save byte if borrow not needed - suba #1 else do borrow, setting flags -savemsb sta lsn save MSB - bcc chekenuf bra if no borrow needed by last dec - incb else set flag ->enuf subs done -chekenuf tstb enuf subs done? - bne enufsub1 Yes, bra - inc ,s else, inc decimal counter - bra subdec1 and do more subtractions -enufsub1 ldd lsn+1 get value - addd 1,x make it positive again - std lsn+1 and save - lda lsn get MSB - bcc addmsb 'Carry' bit still valid from 'addd 1,x' - inca do carry from LSB's -addmsb adda ,x make rest of remainder positive - sta lsn and save it for next round of sub - leax 3,x point X to next table entry - bsr decascii go convert decimal counter to ascii - dec 1,s dec counter (8 digits) - beq getCR Yes, exit - lda 1,s down to last 2 digits? - cmpa #2 - bne initsub1 no, loop back - clr zeroflag else stop suppressing leading 0's - bra initsub1 - -getCR lda #$d <CR> - sta ,y put in out string - ldd oldlsn+1 restore LSN - std lsn+1 - lda oldlsn - sta lsn - puls d,pc - -* Convert HEX byte in A to ASCII and put in buffer (Y) - -convert1 pshs a save byte - lsra shift msn to lsnibble - lsra - lsra - lsra - bsr objasc - puls a get byte back - anda #$0f mask off msb - bsr objasc convert if to ascii - rts -objasc cmpa #9 digit? - ble asciify yes, make it ascii - adda #7 -asciify adda #$30 makes it ascii - sta ,y+ and put it in buffer - tst zeroflag suppressing leading zeroes? - beq convdone no, exit - cmpa #'0 was it a zero? - beq suppres0 Yes, go 'erase' it - clr zeroflag No, so stop suppressing 0's -convdone rts -suppres0 leay -1,y reset pointer back over zero - rts - -* Convert object decimal # on stack to ASCII & put in buffer (Y) - -decascii pshs a save this - lda 3,s get decimal counter - bsr asciify make it ascii - puls a,pc get byte back & return - - -dsplylin leay i.o.buff,u point to output buffer - leax revvid,pcr - lbsr transfer put in reverse video code - lda seclen+1 LSB of # bytes read - beq notlast skip ahead if 0 (seclen=$100) - anda #$f0 mask off LSB - cmpa rownum current display row = last? - bne notlast no, go on - lda #$ff - sta lastflag signal last line -notlast lda rownum get row number - bsr convert1 convert it to hex byte - lda #': - sta ,y+ - leax normvid,pcr point to code - bsr transfer move code to buffer - ldd #$2020 spaces - std ,y++ - ldx buffptr get buffer pointer - ldb #$10 16 bytes - tst lastflag last line? - beq cnvrtbyt no, bra - ldb seclen+1 bytes read - andb #$0f now B=bytes for lst line - beq noline bra if no bytes left - pshs b save this -cnvrtbyt lda ,x+ get byte from buffer - bsr convert1 convert it to hex - lda #$20 space - sta ,y+ put in output buffer - decb done? - bne cnvrtbyt No, do more - tst lastflag lst line? - beq addspc2 no, bra - ldd #$0310 B=max bytes on line - subb ,s b=# bytes to null out - mul 3 spaces per byte - lda #$20 space -addspc1 sta ,y+ put in buffer - decb done? - bne addspc1 -addspc2 ldb #$20 space - std ,y++ - sta ,y+ output spaces - ldx buffptr get buff pointer again - asrb b=$10 (16 bytes) - tst lastflag lst line? - beq ascichar no, bra - ldb ,s yes, get # bytes from prior calc -ascichar lda ,x+ get byte - anda #$7f clear bit 7 - cmpa #$20 <32? - bhs printabl yes, print as is -notascii lda #'. Non-ascii char -printabl sta ,y+ put in buff - decb done? - bne ascichar - stx buffptr save new buffer pointer - tst lastflag last line? - beq addCR no, bra - ldb #$10 max bytes per line - subb ,s+ b=bytes to null out - lda #$20 space -addspc3 sta ,y+ put in buffer - decb - bne addspc3 - lda #$f0 last row num - sta rownum -> displays no more rows - bsr addCR display line -resetlst clr lastflag reset flag - leax erasescr,pcr point to erase to end of screen code - ldy #era2chrs length of string - lbra writeout erase end of screen & return -addCR lda #$d <CR> - sta ,y - leax i.o.buff,u - lbra wrtlin1 go display this line & return - -transfer lda ,x+ get byte - beq trandone exit if done - sta ,y+ move it - bra transfer do more -trandone rts return - -noline lda #$f0 - sta rownum signal last row - bra resetlst go erase rest of screen - - -* Point to next LSN in file - -nxtsec ldd lsn+1 get 2 lower bytes of lsn - addd #1 next lsn - std lsn+1 save it - bne readsec d<>0 => carry not needed - inc lsn else add carry to MSB of LSN -readsec lbra readloop go read next sector - -* Point to previous LSN unless at LSN 0 now - -prevsec ldd lsn+1 get lsn - bne notfirst <>0 => not LSN 0 - tst lsn LSN 0? - lbeq getcmd yes, exit -notfirst subd #1 else dec LSN - std lsn+1 save it - cmpd #$ffff borrow needed if LSN was $xx0000 - bne readsec if not, go read - dec lsn do 'borrow' - bra readsec go read previous sector - - -* Change LSN sub - -changLSN lbsr movecmd - leax sect,pcr display message - lbsr pstring - ldy #7 max # chars to read - bsr MakeHex read & convert them - bcs BadLSN - ldd HexBuff+2 get new LSN from buffer - std lsn+1 - lda HexBuff+1 - sta lsn - lbra readloop go read/display new LSN - -BadLSN lbsr beep - bra changLSN - -MakeHex pshs y save # bytes to read - clr echobyte - com echobyte echo on - lbsr echo set echo - puls y - leax i.o.buff,u point to buffer - lbsr readlin read chars from keyboard - clr echobyte - lbsr echo echo off - leay -1,y strip off CR - beq ExitHex exit if no chars input - tfr y,d # of bytes read -> B -CheckHex lda ,x+ get char - bsr hexdigit see if it's valid char - bcs invalid if not, beep & redo - decb done? - bne CheckHex - sty HexBuff save counter for now -getascii lda #'0 leading zero, if needed - ldb ,-x get a char - leay -1,y last one? - beq cnvrt2 yes, bra - lda ,-x else, get next char in A - leay -1,y dec counter -cnvrt2 bsr asciihex convert ascii chars in A/B to hex byte - pshs b save hex byte - cmpy #0 all done? - bne getascii no, do more - ldb HexBuff+1 else, get # ascii chars 1st read - incb get ready for divide - lsrb divide by 2 -># of HEX bytes - clra leading 0 - leax HexBuff,u point to storage - cmpb #4 4 hex bytes on stack? - beq hexstack yes, no leading zeroes needed - sta ,x+ else, put in leading 0 - cmpb #3 3 hex bytes on stack? - beq hexstack yes, no more 0's needed - sta ,x+ else, put in 0 - cmpb #2 2 hex bytes? - beq hexstack yes, bra - sta ,x+ else, put in another 0 -hexstack puls a get a hex byte off stack - sta ,x+ and put in templsn - decb done? - bne hexstack no, bra - clrb clear carry bit - rts - -invalid lbsr beep -coma set carry bit -rts - -ExitHex leas 2,s strip off return address - lbra readloop exit - -hexdigit cmpa #'0 char <0? - blo nothex yes, bra - cmpa #'9 char <9 (digit)? - bls ishex yes, bra - anda #$5f lower->UPPER case - cmpa #'F char >F? - bhi nothex yes, bra - cmpa #'A char <A? - blo nothex yes, bra -ishex clra clear carry bit if char is hex - rts -nothex coma set carry bit if not hex char - rts - -asciihex bsr hexnib convert B to LSNibble - pshs b save LSNib - tfr a,b get ready for MSN - bsr hexnib convert it - aslb shift LSNib to MSN - aslb - aslb - aslb - orb ,s+ add in LSNib from stack - rts - -hexnib subb #$30 convert asci # to hex - cmpb #$9 <=9? - bls nowhex yes, bra - andb #$5f lower->UPPER case - subb #7 else sub 7 or $A$F -nowhex rts - -* Zap sector sub - -zap - clr echobyte - com echobyte echo on - lbsr echo set echo - lbsr movecmd - lbsr clrline clear line - leax zaprompt,pcr point to 'Zap ' - lbsr pstring print it - tst hexascii ascii mode? - bne zapascii yes, bra - leax byte,pcr point to 'byte: ' - lbsr pstring print it - ldy #3 2 chars + CR - bsr zapread read in chars - bsr hexobjct convert to object - bcs exitzap exit if invalid chars -zapstart leax inbuff,u point to data buffer - stx buffptr new pointer - clrb counter -zapbuff sta ,x+ do zap - decb done? - bne zapbuff no, loop - clr echobyte echo off - lbsr echo set echo - inc wrtflag signal for auto-write if expert mode - lbra disploop display zapped buffer - -zapread clra stdin - leax i.o.buff,u point to buffer - os9 i$readln read in line - bcs cheksig1 check for break key if error - rts else return -cheksig1 cmpb #2 break key signal? - lbne error no, process error - com hexascii yes, toggle hex/ascii flag - leas 2,s pull return addr off stack - bra zap redo routine - -exitzap clr echobyte echo off - lbsr echo - lbra getcmd get new command - -zapascii leax char,pcr point to 'char: ' - lbsr pstring print it - ldy #2 1 char + CR - bsr zapread read in char - lda ,x get char - cmpa #$20 valid ascii char? - blo exitzap no, exit - bra zapstart go do zap - -* Convert 2 hex chars in buffer (X) to object byte - -hexobjct bsr cnvrtnib convert 1st nibble - bcs badrts exit if bad char - tfr a,b save 1st byte (MS nibble) - bsr cnvrtnib convert 2nd nibble - bcs badrts exit if bad char - aslb shift LS nib to MS nib - aslb - aslb - aslb - pshs b save - ora ,s+ add MS nib to LS nib - bra goodhex exit - -cnvrtnib bsr isithex is it valid char? - bcs badrts no, exit - bra cnvrthex yes, convert it to object - -isithex lda ,x+ - cmpa #'0 <0? - blo badhex yes, bra - cmpa #'9 <9? - bls goodhex yes, bra - anda #$5F lower->UPPER case - cmpa #'A <A? - blo badhex yes, bra - cmpa #'F >F? - bhi badhex yes, bra -goodhex andcc #$FE clear carry bit if valid - rts -badhex orcc #1 set carry bit if invalid -badrts rts - -cnvrthex suba #$30 convert char to object - cmpa #9 decimal digit? - bls nowobjct yes, done - suba #7 else, A-F -nowobjct bra goodhex clear carry & return - -* Write current sector back to disk - -writesec tst xprtflag expert mode on? - lbne getcmd yes, exit - bsr rusure Sure? - lbne getcmd no, exit - lbsr movecmd - lbsr clrline clear line - lbsr movecmd - leax writing,pcr point to message - lbsr pstring display it -xprtwrt lbsr lsnseek seek to start of sector - lda inpath get path # - lbsr write100 write out sector - tst xprtflag doing auto-write - beq opendone no, go to getcmd - clr wrtflag signal no more auto-write - rts else & return to caller - -* Ask 'Are you sure?' and get response - -rusure lbsr movecmd -rusure10 - clr echobyte - com echobyte echo on - lbsr echo set echo - leax sure,pcr point to 'Sure? ' - lbsr pstring print it - lbsr clrline blank rest of line - leax i.o.buff,u input buffer - lbsr read1 read answer - clr echobyte echo off - lbsr echo set echo - lda ,x get response - anda #$5f lower->UPPER case - cmpa #'Y set flags - rts - -* Open output file sub - -openout tst outpath is a file open already? - bne opendone yes, exit - clr echobyte - com echobyte echo on - lbsr echo set echo - lbsr movecmd position cursor - leax out$,pcr point to prompt - lbsr pstring print it - lbsr clrline clear rest of line - leax i.o.buff,u point to input buffer - ldy #30 29 chars + CR - lbsr readlin read in a line (pathlist) - clr echobyte echo off - lbsr echo set echo - -*********************************************** -* Return to command prompt if no filename given -* Added 01/09/90 (RAK) -* - cmpy #1 <enter> only pressed? - beq opendone yes, abort -* -********************************** END modification - - pshs x save pointer to pathlist - leay outfile,u point to storage area -savname lda ,x+ get a char from name - sta ,y+ save it - cmpa #$20 space or CR? - bhi savname - lda #$0d CR - sta -1,y delimit filename - puls x restore pointer to name - lda #write. Access mode = Write - ldb #%00001011 attr ----R-wr - os9 I$Create create & open file - bcs error exit if error - sta outpath save output path # - bsr prntout -opendone lbra getcmd exit - -* move cursor & print 'Output pathlist' - -prntout ldd #outpos - lbsr movecurs - leax out$,pcr point to 'OUTFILE:' - lbsr pstring print it - leax outfile,u point to name - lbra wrtlin1 write name & return - - -* Write out a sector - -write100 leax inbuff,u point to data - ldy seclen # chars in sector - os9 i$write write sector - bcs error - rts - -* Close output file sub - -closeout lda outpath get output path # - beq opendone exit if none open - os9 i$close close it - bcs error - ldd #outpos - lbsr movecurs - lbsr clrline - clr outpath flag no output file open -closed bra opendone exit - -* Append sector to output file sub - -append lda outpath get output path # - beq closed exit if no file open - bsr write100 write sector out - lbra nxtsec read in next sector & display it - - -* ERROR handling routine - -error pshs b save error code - -* modification by BRI - clr <SgnlCode clear intercept routine signal code -* end modification - - ldd oldlsn MSBs of last LSN read - std lsn make it current LSN - lda oldlsn+2 LSB of last LSN - sta lsn+2 move it - puls b error code - lds Ssave restore Stack pointer - cmpb #2 break? - beq endexit yes, don't worry - cmpb #3 shift break? - bne eofchk no check if EOF - clr wrtflag cancel auto-write - bra endexit -eofchk cmpb #e$eof EOF error? - bne true.err exit -endexit lbra exitzap -true.err cmpb #e$bmid bad module ID error? - bne othererr no, bra -* If module is linked, BMID error must come from trying to Verify modules -* use standard error reporting routine. Otherwise BMID error occurs when -* trying to link (or list names of) modules; need to clear screen after these. - tst infile module linked? - bne othererr yes, use std error routine - bsr prterr else display error # - leax cls,pcr - ldy #clschrs - lbsr writeout clear screen - lbra disploop & redisplay sector -othererr pshs b save error code - lbsr movecmd position cursor - lbsr clrline - puls b pull error code - bsr prterr print error # on cmd line - lbra getcmd - -* Display error # - -prterr lda #2 error out path - os9 f$perr print error # - clr echobyte echo off - lbsr echo - - leax i.o.buff,u point to input buffer - lbra read1 wait for keypress & return - -* Exit with usage prompt if no pathname called - -badcall - lda #2 errout - leax hints,pcr - ldy #bufsiz - lbsr wrtlin2 - ldb #e$bpnam set bad path error - bra bye - -* Exit to OS9 - -quit lda oldecho get original echo status - sta echobyte reset echo - lbsr echo to original status - clrb no error -bye os9 f$exit exit program - -* Edit sector sub - -edit lbsr movecmd - leax edprompt,pcr point to prompt - lbsr pstring -topleft leax inbuff,u point to data buffer - stx edbufptr save pointer - lda #1 init position counter - sta edpos - lda #$23 top row code - sta rownum save - lda #$25 1st hex dump col # - sta hexcol save - lda #$58 1st ascii dump col - sta asciicol - -revbyte lbsr revdisp set reverse video - bsr eddisply display byte - - ifne xyflipr -edinput lda rownum A=row - ldb hexcol B=col - else - -edinput lda hexcol A=col - ldb rownum B=row - endc - - tst hexascii Hex mode? - beq hexin yes, bra - - ifne xyflipr - ldb asciicol else B= ASCII col - else - - lda asciicol A= ASCII col - endc - -hexin lbsr movecurs position cursor - leax i.o.buff,u - tst hexascii ascii mode? - lbne inputchr yes, bra - -* modification by BRI -* bra inputbyt - lbra inputbyt -* end modification - -* Sub to do Hex and ASCII dump for byte to be editted - - ifne xyflipr -eddisply lda rownum A=row - ldb hexcol b= hex column - else - -eddisply lda hexcol A=Hex column - ldb rownum B=row - endc - - lbsr movecurs position cursor - leay i.o.buff,u point to output buff - lda [edbufptr,u] get byte - pshs a save it - lbsr convert1 convert to hex, put in buff - leax -2,y reset pointer to hex chars - ldy #2 2chars - lda #1 stdout - lbsr wrtlin2 display chars - - ifne xyflipr - lda rownum same row - ldb asciicol get ascii dump col # - else - - lda asciicol ascii dump col # - ldb rownum same row - endc - - lbsr movecurs position cursor - puls a get byte again - anda #$7F clear bit 7 for ascii dump - cmpa #$20 printable? - - bhs prntabl1 yes, bra - lda #'. else print as '.' -prntabl1 leax i.o.buff,u ouput buffer - sta ,x put char in buff - ldy #1 1 char - lbra writeout display char & return - -* Read in a character; check for BREAK key - -* modification by BRI -* toggles cursor on/off if enabled, checks for character -*readit ldy #1 1 char -readit pshs b,x save previous char, input buffer pointer -CFlsh01 clra std. input - ldb #SS.Ready - os9 I$GetStt - bcc CFExit character ready, go get it - cmpb #E$NotRdy no character ready? - bne CrsrErr no, go check other errors - ldx #$0001 give up remainder of tick - os9 F$Sleep - bcs CrsrErr go clean up & check error - dec <CrsrCnt decrement cursor toggle counter - lda <CrsrCnt get new counter value - eora <CrsrFlg cursor toggle required? - anda #%01000000 clear all but active counter bit - beq SigChk no, go check for signal - com <CrsrFlg toggle cursor on or off? - beq CrsrOff go toggle cursor off - bsr CrsrOn go toggle cursor on - bra SigChk go check intercept routine signal code -CrsrOff leax CursrOff,pc point [X] to cursor off string - ldy #CursOff number of bytes in string - bsr WritCrsr go write cursor off string -SigChk ldb <SgnlCode get intercept routine signal code - cmpb #S$Abort keyboard abort signal? (error #2) - beq CrsrErr yes, go report it - cmpb #S$Intrpt keyboard interrupt signal? (error #3) - bne CFlsh01 no, go check for data again -CrsrErr stb ,s save error code for sigchek2 - bsr CrsrOn go make sure cursor is on - puls b,x recover error code, input buffer pointer - bra cheksig2 -CrsrOn leax CursrOn,pc point [X] to cursor on string - ldy #CursOn number of bytes in string -WritCrsr lda #1 std. output - os9 I$Write - clrb ignore any/all errors - rts -CFExit bsr CrsrOn go make sure cursor is on - puls b,x recover previous char, input buffer pointer - ldy #1 1 char -* end modification - - clra stdin - os9 i$read read in char - bcs cheksig2 chek for BREAK if error - rts else return - + bcs cheksig2 + rts + * modification by BRI * clears old signal, traps BREAK, * cleans up before reporting other errors @@ -3573,1032 +1409,1072 @@ * com hexascii yes, toggle hex/ascii flag * leas 2,s pull return addr off stack * bra edinput loop back -cheksig2 leas 2,s dump return address - clr <SgnlCode clear old signal - cmpb #2 keyboard abort? (BREAK) - beq TrapSgnl yes, trap it & toggle hex/ascii - pshs b save error code - lbsr reset reset reversed chars - clr <rownum reset row # - puls b recover error code - lbra error go process error -TrapSgnl com <hexascii yes, toggle hex/ascii flag - lbra edinput loop back -* end modification +cheksig2 leas $02,s + clr <SgnlCode + cmpb #2 break key + beq TrapSgnl + pshs b + lbsr reset + clr <rownum + puls b + lbra error +TrapSgnl com <hexascii + lbra edinput +* end of mod - -* Input a hex byte - -inputbyt bsr readit read in a char - bsr digit is it valid hex digit? - bcs edcurs no, see if it's arrow key - lbsr writeout yes, display char - ldb ,x save char - +* input a hex byte +inputbyt bsr readit + bsr digit + bcs edcurs + lbsr writeout + ldb ,x * modification by BRI * bsr readit read another char - lbsr readit read another char + lbsr readit * end modification - - bsr digit is it valid? - bcs edcurs no, check for arrows - exg a,b A= 1st char - lbsr asciihex change 2 ascii chars to hex byte - stb [edbufptr,u] put new byte in buffer - lda #1 - sta wrtflag signal auto-write - bra movert move to next byte + bsr digit + bcs edcurs + exg a,b + lbsr asciihex + stb [<edbufptr,u] + lda #1 + sta <wrtflag + bra movert * Check to see if char is valid hex digit. * Exit with Carry set if not valid. - -digit lda ,x get char from buffer - cmpa #'0 < 0? - blo notdig YES, set carry - cmpa #'9 Between 0 & 9? - bls gotnib Yes, return - anda #$5F Lowercase -> Upper - cmpa #'F > F? - bhi notdig Yes, set carry - cmpa #'A Between A & F? - blo notdig No, set carry -gotnib andcc #$fe clear carry bit - rts -notdig orcc #1 set carry bit - rts +digit lda ,x + cmpa #'0 + bcs notdig + cmpa #'9 + bls gotdig + anda #$5F lower to upper + cmpa #'F + bhi notdig + cmpa #'A + bcs notdig +gotdig andcc #$FE + rts +notdig orcc #1 + rts * Input single ASCII character * modification by BRI *inputchr bsr readit read char -inputchr lbsr readit read char -* end modification - - lda ,x get char - cmpa #$20 valid ascii char? - blo edcurs no, check for arrows - sta [edbufptr,u] yes, put in buffer - lda #1 - sta wrtflag signal auto-write - bra movert go do next byte - -* Check if char is arrow (for cursor moves) +inputchr lbsr readit +* end of mod + lda ,x + cmpa #$20 + bcs edcurs + sta [<edbufptr,u] + lda #1 + sta <wrtflag + bra movert -edcurs cmpa #9 Right arrow? - beq movert - cmpa #8 Left arrow? - beq movelt - cmpa #$c Up arrow? - lbeq moveup - cmpa #$a Down arrow? - lbeq movedn - cmpa #$d CR? - lbne edinput no, get another key - -* Exit edit routine - lbsr reset reset reversed chars - clr rownum reset row # - lbra getcmd return to command level +* check if char is an arrow +edcurs cmpa #9 right arrow + beq movert + cmpa #8 left arrow + beq movelt + cmpa #$0C up arrow + lbeq moveup + cmpa #$0A down arrow + lbeq movedn + cmpa #$0D CR + lbne edinput +* exit edit routine + lbsr reset + ldd #$4934 + lbsr movecurs + lbsr clrline + clr <rownum + lbra getcmd -* Move to next byte on screen - -movert lbsr reset reset display byte - tst seclen+1 editting partial (last) sec? - beq rtptr no, bra - lda edpos position # in sector - cmpa seclen+1 last byte? - lbeq topleft yes, bra -rtptr ldd edbufptr get pointer - addd #1 set to next byte - std edbufptr save - inc edpos - -displyrt inc asciicol inc display counter - lda asciicol get counter - cmpa #$68 at end of screen row? - bhs rowdn yes, move down a row - lda hexcol no, inc hex display counter - adda #3 3 screen columns per byte - sta hexcol save - lbra revbyte go do next byte -rowdn inc rownum next row - lda rownum get row # - cmpa #$32 past bottom row? - lbhi topleft yes, go to top row - lda #$25 1st hex column # - sta hexcol reset counter - lda #$58 1st ascii col # - sta asciicol reset counter - lbra revbyte go do display +* move to next screen byte +movert lbsr reset + tst <seclen+1 + beq rtptr + lda <edpos + cmpa <seclen+1 + lbeq topleft +rtptr ldd <edbufptr + addd #1 + std <edbufptr + inc <edpos +displyrt inc <asciicol + lda <asciicol + cmpa #$68 end of row + bcc rowdn + lda <hexcol + adda #3 3 columns used per byte + sta <hexcol + lbra revbyte +rowdn inc <rownum + lda <rownum + cmpa #$32 + lbhi topleft + lda #$25 + sta <hexcol + lda #$58 + sta <asciicol + lbra revbyte -* Move to previous byte on screen +* move to previous byte +movelt bsr reset + ldd <edbufptr + subd #1 + std <edbufptr + dec <edpos + dec <asciicol + lda <asciicol + cmpa #$58 + bcs rowup + lda <hexcol + suba #3 + sta <hexcol + lbra revbyte +rowup dec <rownum + lda #$52 + sta <hexcol + lda #$67 + sta <asciicol + lda <rownum + cmpa #$23 + bcs gobot + lbra revbyte +gobot ldx <edbufptr + ldb <seclen+1 + beq botptr + stb <edpos + clra + leax d,x + decb + pshs b + lsrb + lsrb + lsrb + lsrb + addb #$23 + stb <rownum + lda ,s+ + anda #$0F + pshs a + adda #$58 + sta <asciicol + puls a + ldb #3 + mul + addb #$25 + stb <hexcol + bra savebot +botptr lda #$32 bottom row + sta <rownum + leax $100,x +savebot stx <edbufptr + lbra revbyte -movelt bsr reset reset displayed byte - ldd edbufptr get data pointer - subd #1 dec it - std edbufptr - dec edpos & position counter - dec asciicol dec display counter - lda asciicol get col # - cmpa #$58 past left end of row? - blo rowup yes, move up a row - lda hexcol get hex col # - suba #3 move left 3 columns - sta hexcol save - lbra revbyte -rowup dec rownum move up a row - lda #$52 col # of right end of hex dump - sta hexcol save - lda #$67 col # of right end of ascii dump - sta asciicol save - lda rownum get row # - cmpa #$23 past top row? - blo gobot yes, go to bottom row - lbra revbyte no, display next byte -gobot ldx edbufptr old pointer - ldb seclen+1 partial (last) sec? - beq botptr no, bra - stb edpos new last position - clra - leax d,x new pointer with partial sector - decb offset to byte in buffer - pshs b -* MSN of B is last row-1 with partial sector - lsrb - lsrb - lsrb - lsrb Now B is last row-1 - addb #$23 - stb rownum - lda ,s+ offset - anda #$0f A=last col - pshs a - adda #$58 left most ASCII column - sta asciicol new ASCII col - puls a - ldb #3 3 columns per hex byte - mul - addb #$25 1st hex col - stb hexcol - bra savebot -botptr lda #$32 bottom row # - sta rownum save - leax $100,x new pointer -savebot stx edbufptr save new pointer - lbra revbyte do next byte - -* Reset byte displayed in reverse video to normal video - -reset lbsr normdisp set normal video - lbra eddisply go display byte - -* Move up a row on screen +* reset from reverse video to normal +reset lbsr normdisp + lbra eddisply -moveup bsr reset reset reversed byte - ldb seclen+1 partial sector? - beq moveup1 no, bra - lda rownum - cmpa #$23 at top row now? - beq moveup2 yes, bra -moveup1 ldd edbufptr get data pointer - subd #$10 move back 16 bytes - std edbufptr save new pointer - ldb edpos - subb #$10 dec position counter by $10 - stb edpos - dec rownum move up a row - lda rownum get new row # - cmpa #$23 above top row - bhs updone no, go display next byte - lda #$32 set to bottom row - sta rownum - ldd edbufptr get data pointer - addd #$100 point to new byte - std edbufptr and save -updone lbra revbyte display next byte +* move up a row +moveup bsr reset + ldb <seclen+1 + beq moveup1 + lda <rownum + cmpa #$23 + beq moveup2 +moveup1 ldd <edbufptr + subd #$10 + std <edbufptr + ldb <edpos + subb #$10 + stb <edpos + dec <rownum + lda <rownum + cmpa #$23 + bcc updone + lda #$32 + sta <rownum + ldd <edbufptr + addd #$100 + std <edbufptr +updone lbra revbyte -moveup2 andb #$f0 MSN=row offset - lda seclen+1 bytes read - anda #$0f last col in last row - cmpa edpos to left of current position? - bhs moveup3 yes, bra - subb #$10 else correct row offset -moveup3 clra - pshs b,a - ldd edbufptr - addd ,s+ add offset - std edbufptr - ldb edpos - addb ,s - stb edpos new position - puls b - lsrb - lsrb - lsrb - lsrb row offset in LSNib - addb #$23 calc new rownum - stb rownum - bra updone - -* Move down a row on screen - -movedn bsr reset reset reversed byte - ldb seclen+1 partial sector? - beq movedn1 - subb edpos - cmpb #$10 - blo movedn2 -movedn1 ldd edbufptr get data pointer - addd #$10 point 16 bytes ahead - std edbufptr and save - lda edpos - adda #$10 - sta edpos - inc rownum move down a row - lda rownum check to see if below - cmpa #$32 bottom row? - lbls revbyte no, display next byte - ldd edbufptr get data pointer - subd #$100 reset to new byte - std edbufptr save -topptr lda #$23 yes, set for top row - sta rownum save - lbra revbyte display next byte +moveup2 andb #$F0 + lda <seclen+1 + anda #$0F + cmpa <edpos + bcc moveup3 + subb #$10 +moveup3 clra + pshs b,a + ldd <edbufptr + addd ,s+ + std <edbufptr + ldb <edpos + addb ,s + stb <edpos + puls b + lsrb + lsrb + lsrb + lsrb + addb #$23 + stb <rownum + bra updone -movedn2 clra - ldb edpos - decb - andb #$f0 B = offset to first row - pshs b,a - ldd edbufptr - subd ,s+ reset pointer - std edbufptr - ldb edpos - subb ,s+ reset position counter - stb edpos - bra topptr - - -* Start new SHELL - -goshell lda oldecho get original echo status - sta echobyte set up for change - bsr echo set echo - leax shell$,pcr point to 'SHELL' text - ldy #$10 # pages in new param area - leau i.o.buff,u new param area - lda #$0d CR to - sta ,u init param area - ldd #$0000 language/type - os9 f$fork fork to new shell - lbcs error - os9 f$wait wait for shell to die - ldu usave pull data pointer - leax inbuff,u - stx buffptr reset buffer pointer - clr echobyte echo off - bsr echo set echo -redo lbsr clrscr clear screen - lbra disploop redo display - -* Read in option section (32 bytes) of stdin path descriptor & turn echo on/off +movedn bsr reset + ldb <seclen+1 + beq movedn1 + subb <edpos + cmpb #$10 + bcs movedn2 +movedn1 ldd <edbufptr + addd #$0010 + std <edbufptr + lda <edpos + adda #$10 + sta <edpos + inc <rownum + lda <rownum + cmpa #$32 + lbls revbyte + ldd <edbufptr + subd #$100 + std <edbufptr +topptr lda #$23 + sta <rownum + lbra revbyte +movedn2 clra + ldb <edpos + decb + andb #$F0 + pshs b,a + ldd <edbufptr + subd ,s+ + std <edbufptr + ldb <edpos + subb ,s+ + stb <edpos + bra topptr -echo pshs x save - leas -32,s make room for data - leax ,s point to buffer - clra path = 0 - clrb SS.OPT - os9 i$getstt read in 32 bytes - lbcs error - lda echobyte new echo status byte - sta 4,x set echo - clra path =0 - os9 i$setstt set new status - lbcs error - leas 32,s reset stack - puls x,pc pull x & return - -* Verify CRC on file, if it's a valid module. +* start a temporary shell +goshell lbsr clrscr + lda <oldecho + sta <echobyte + bsr echo + leax >shell$,pcr + ldy #$10 + leau >i.o.buff,u + lda #$0D + sta ,u + ldd #0 + os9 F$Fork + lbcs error + os9 F$Wait + ldu <Usave + leax >inbuff,u + stx <buffptr + clr <echobyte + bsr echo +cReturn lbsr clrscr + lbra disploop -verify lbsr movecmd position cursor - leax vrfymess,pcr display message - lbsr pstring - ldu #$0000 - ldx #$0000 - stx fileln init file length - lda inpath path # - os9 i$seek rewind to LSN 0 - lbcs error - ldu Usave restore U -initCRC ldd #$FFFF initialize CRC bytes - std crc - stb crc+2 - leax i.o.buff,u input buffer - ldy #8 8 bytes to read - lda inpath path # - os9 i$read read in 8 header bytes - lbcs error exit on error - cmpy #8 all read in ok? - lbne verr no, error - ldd ,x get 1st 2 bytes read in - cmpa #$87 module sync byte? - lbne verr no, error - cmpb #$CD module sync byte? - lbne verr no, error - ldd 2,x get module length - cmpd #$f minimum module length - lbls verr exit if less - subd #3 omit old CRC bytes - std vmodlen module length less CRC - addd fileln update file length - std fileln read so far - -* Check header parity by EOR'ing 1st 8 bytes to themselves, then taking -* the one's complement. This is the 9th header byte, the parity check. +* read in option section of path and toggle echo +echo pshs x + leas <-$20,s + leax ,s + clra + clrb + os9 I$GetStt + lbcs error + lda <echobyte + sta $04,x + clra + os9 I$SetStt + lbcs error + leas <$20,s + puls pc,x - clra prepare for EORs - ldb #8 # header bytes to EOR -hedpar eora ,x+ EOR bytes read in - decb done? - bne hedpar no, bra - coma A now is header parity - sta ,x put in buffer - ldy #1 1 char to write - lda inpath path # - os9 i$write write parity byte out - lbcs error - ldd vmodlen get # byte in module - subd #9 9 bytes already read - std vmodlen save - leax i.o.buff,u start of header bytes - ldy #9 - bsr CRCcal calculate CRC on 1st 9 bytes -bytsleft lda inpath path # - ldy #bufsiz # chars to read - cmpy vmodlen buffer <= # bytes left to read? - bls readmod yes, bra - ldy vmodlen else, get exact # chars left to read -readmod os9 i$read read in Y chars - bcs verr exit on error - sty bytsread save # bytes read in - bsr CRCcal calc CRC on bytes just read in - ldd vmodlen # bytes - subd bytsread minus # bytes just read in - std vmodlen save # byte left - bne bytsleft do more if some left -* Compare current position in file with # of bytes in module header -* to prevent overwriting next module, in case module length changed. - lda inpath path number - ldb #ss.pos file position code - os9 i$getstt get position in file - tfr u,d D = position - ldu Usave restore U - cmpd fileln same as bytes read so far? - bne verr no, exit - com crc do one's - com crc+1 complement on - com crc+2 CRC accumulator - leax crc,u point to accumulator - ldy #3 3 bytes to write - lda inpath path # - os9 i$write write out 3 CRC bytes - lbcs error - ldd #3 update # bytes read/written - addd fileln - std fileln - ldb #ss.eof test for EOF - lda inpath - os9 i$getstt - lbcc initCRC bra if not EOF - cmpb #e$eof EOF? - lbne error no, exit -* Redisplay LSN (may have changed with verify) - lbsr seeksec read in sector again - lbra disploop redo display - -* Calculate CRC sub. Enter with Y = # of bytes to calculate CRC over. -* X = address of 1st byte - -CRCcal leau crc,u point to CRC bytes - os9 f$crc calc CRC - lbcs error - ldu Usave restore U - rts - -* Verify error display sub - -verr ldd #cmdpos position cursor - lbsr movecurs at cmd position - leax verrmess,pcr point to message - lbsr pstring display it - ldb #e$bmid bad module ID - lbsr prterr display error # - lbra getcmd exit - -* 'Link' to a given module or display all modules if no name is input +* verify CRC if valid module +verify lbsr movecmd + leax >vrfymess,pcr + lbsr pstring + ldu #0 + ldx #0 + stx <fileln + lda <inpath + os9 I$Seek + lbcs error + ldu <Usave +initCRC ldd #$FFFF + std <crc + stb <crc+2 + leax >i.o.buff,u + ldy #8 + lda <inpath + os9 I$Read + lbcs error + cmpy #8 + lbne verr + ldd ,x + cmpa #$87 module sync byte + lbne verr + cmpb #$CD "" + lbne verr + ldd 2,x + cmpd #$0F minimum module length + lbls verr + subd #3 omit old CRC + std <vmodlen + addd <fileln + std <fileln +* check header parity + clra + ldb #8 +hedpar eora ,x+ + decb + bne hedpar + coma + sta ,x + ldy #1 + lda <inpath + os9 I$Write + lbcs error + ldd <vmodlen + subd #9 + std <vmodlen + leax >i.o.buff,u + ldy #9 + bsr CRCcal +bytsleft lda <inpath + ldy #$78 + cmpy <vmodlen + bls readmod + ldy <vmodlen +readmod os9 I$Read + bcs verr + sty <bytsread + bsr CRCcal + ldd <vmodlen + subd <bytsread + std <vmodlen + bne bytsleft +* compare current position with header to +* prevent overwriting next module + lda <inpath + ldb #5 + os9 I$GetStt + tfr u,d + ldu <Usave + cmpd <fileln + bne verr + com <crc + com <crc+1 + com <crc+2 + leax <crc,u + ldy #3 + lda <inpath + os9 I$Write + lbcs error + ldd #3 + addd <fileln + std <fileln + ldb #6 test for EOF + lda <inpath + os9 I$GetStt + lbcc initCRC + cmpb #$D3 EOF + lbne error +* redisplay LSN + lbsr seeksec + lbra disploop -linker tst infile linked already? - lbne getcmd yes, exit - ldd #0 - std fileln init vars - std lmodlen " - clr echobyte - com echobyte - lbsr echo echo on - lbsr movecmd - lbsr clrline - leax linkmess,pcr prompt - lbsr pstring print it - leax infile,u point to buffer for module name - ldy #30 max name length+1 - lbsr readlin read in module name - clr echobyte - lbsr echo echo off - cmpy #1 any name entered? - lbne parsmod yes, go find it -* else list all module names - clr infile flag => no modules linked - leax linkhdr,pcr point to header - lbsr wrtlin1 write it -nxtmod ldd lmodlen current mod length - addd fileln + cummulative lengths - std fileln save - tfr d,u point u to next module - ldx #0 - lda inpath - os9 i$seek - bcs moderr - ldu Usave restore U - leax i.o.buff,u - ldy #6 bytes to read - os9 i$read - bcs moderr - ldd ,x++ get sync bytes - cmpa #$87 OK? - bne moderr1 no, exit - cmpb #$CD OK? - bne moderr1 no, exit - leay i.o.buff,u - ldd ,x++ get module length - std lmodlen save - ldd ,x++ offset to module name - pshs d save - ldd fileln current offset - bsr convert2 convert D to ASCII - lda #$20 space - sta ,y+ put in buffer - ldd lmodlen current module length - bsr convert2 convert to ASCII - lda #$20 - sta ,y+ insert space - ldd fileln offset to mod start - addd ,s++ add mod name offset - tfr d,u U = offset to name - ldx #0 - lda inpath - os9 i$seek seek to module name - lbcs error - ldu Usave restore U - tfr y,x point x to buffer - ldy #29 max chars in name - lda inpath - os9 i$read - lbcs error -namend lda ,x+ find char w/ bit 7 set - bpl namend - anda #$7f clear bit 7 - sta -1,x - lda #$0d CR - sta ,x end output line - leax i.o.buff,u buffer start - lbsr wrtlin1 - bra nxtmod +* calculate CRC, regY=# of bytes to use for CRC +CRCcal leau <crc,u + os9 F$CRC + lbcs error + ldu <Usave + rts -convert2 lbsr convert1 put ASCII val of A in Y - tfr b,a repeat for B - lbra convert1 and return +* error with verify +verr ldd #$2036 cmd position + lbsr movecurs + leax >verrmess,pcr + lbsr pstring + ldb #$CD + lbsr prterr + lbra getcmd -moderr2 cmpb #e$eof - bne moderr - ldb #e$MNF module not found error - bra moderr -moderr1 ldb #E$BMID bad module ID error -moderr clr infile flag => not linked - cmpb #e$eof end of file? - lbne error no, print error - lbsr read1 wait for keypress - leax inbuff,u - stx buffptr reset buffer pointer for display - lbra redo redo display +* Link to a module or display all in merged file +linker tst <infile + lbne getcmd + ldd #0 + std <fileln + std <lmodlen + clr <echobyte + com <echobyte + lbsr echo + lbsr movecmd + lbsr clrline + leax >linkmess,pcr + lbsr pstring + leax <infile,u + ldy #$1E + lbsr readlin + clr <echobyte + lbsr echo + cmpy #1 + lbne parsmod + lbsr clrscr + clr <infile list all module names + leax >linkhdr,pcr + lbsr wrtlin1 +nxtmod ldd <lmodlen + addd <fileln + std <fileln + tfr d,u + ldx #0 + lda <inpath + os9 I$Seek + bcs moderr + ldu <Usave + leax >i.o.buff,u + ldy #6 + os9 I$Read + bcs moderr + ldd ,x++ + cmpa #$87 + bne moderr1 + cmpb #$CD + bne moderr1 + leay >i.o.buff,u + ldd ,x++ + std <lmodlen + ldd ,x++ + pshs d + ldd <fileln + bsr convert2 + lda #$20 + sta ,y+ + ldd <lmodlen + bsr convert2 + lda #$20 + sta ,y+ + ldd <fileln + addd ,s++ + tfr d,u + ldx #0 + lda <inpath + os9 I$Seek + lbcs error + ldu <Usave + tfr y,x + ldy #$1D + lda <inpath + os9 I$Read + lbcs error +namend lda ,x+ + bpl namend + anda #$7F look for fcs delimiter + sta -1,x + lda #$0D CR + sta ,x + leax >i.o.buff,u + lbsr wrtlin1 + bra nxtmod -parsmod os9 f$prsnam - lbcs error - stb modnmlen save length of name - decb name len -1 - lda b,x last char of name - ora #$80 set bit 7 - sta b,x - stx CRC save pointer - ldu #0 -modloop ldx #0 - lda inpath - os9 i$seek go to start of file - lbcs error - ldu Usave restore U - leax i.o.buff,u buffer - ldy #6 bytes to read in - os9 i$read - bcs moderr2 - ldd ,x++ sync bytes - cmpa #$87 OK? - bne moderr1 - cmpb #$CD OK? - bne moderr1 - ldd ,x++ module length - std lmodlen save - ldd ,x mod name offset - addd fileln d=true offset to name - tfr d,u - ldx #0 - lda inpath - os9 i$seek seek to mod name - bcs moderr2 - ldu Usave restore U - leax i.o.buff,u buffer - ldy #29 max chars in name - os9 i$read read in name - bcs moderr2 - tfr x,y - ldx CRC point to desired name - ldb modnmlen get len of name - os9 f$cmpnam do they match? - bcc newbase yes, bra - ldd lmodlen no, check next - addd fileln new offset - std fileln - tfr d,u - bra modloop +convert2 lbsr convert1 + tfr b,a + lbra convert1 -* Set Offset to module. LSN is functionally set to 0. - -newbase lda #$0d CR - sta b,x delimit name - decb - lda b,x last char - anda #$7f clr bit 7 - sta b,x - ldd fileln get offset - std offset - ldd #0006 - leax LSN,u -nbloop sta ,x+ - decb - bne nbloop - lbra readloop go read 1st 'LSN' - -* Display module name and offset +moderr2 cmpb #$D3 e$e0f + bne moderr + ldb #$DD module not found + bra moderr +moderr1 ldb #$CD bad module ID +moderr clr <infile + cmpb #$D3 end of file + lbne error + lbsr read1 + leax >inbuff,u + stx <buffptr + lbra cReturn -prntmod ldd #modpos - lbsr movecurs point to screen position - leax modnmhdr,pcr mod name header - lbsr pstring print it - leax infile,u point to name - lbsr wrtlin1 print it - ldd #offpos 'offset' screen postion - lbsr movecurs - leax offmess,pcr - lbsr pstring print 'Offset' label - leay i.o.buff,u - ldd offset - lbsr convert2 convert offset to ASCII - lda #$0d - sta ,y delimit offset - lbra writeout display it & return - -* 'Unlink' named module and restore LSN to original file's LSN +parsmod os9 F$PrsNam + lbcs error + stb <modnmlen + decb + lda b,x + ora #$80 fcs format + sta b,x + stx <crc + ldu #0 +modloop ldx #0 + lda <inpath + os9 I$Seek + lbcs error + ldu <Usave + leax >i.o.buff,u + ldy #6 + os9 I$Read + bcs moderr2 + ldd ,x++ + cmpa #$87 module sync code + bne moderr1 + cmpb #$CD "" + bne moderr1 + ldd ,x++ + std <lmodlen + ldd ,x + addd <fileln + tfr d,u + ldx #0 + lda <inpath + os9 I$Seek + bcs moderr2 + ldu <Usave + leax >i.o.buff,u + ldy #$1D + os9 I$Read + bcs moderr2 + tfr x,y + ldx <crc + ldb <modnmlen + os9 F$CmpNam + bcc newbase + ldd <lmodlen + addd <fileln + std <fileln + tfr d,u + bra modloop -unlinker tst infile linked? - lbeq getcmd no, exit - ldd #0008 - leax LSN,u -unloop sta ,x+ - decb - bne unloop - ldd #modpos position cursor - lbsr movecurs - lbsr clrline erase module name - lbsr clrline erase offset - clr infile flag => no modules linked - lbra readloop - -* Toggle expert mode - edits and zaps of buffer are automatically written +* set offset to module so effective LSN is $00 +newbase lda #$0D CR + sta b,x delimit name + decb + lda b,x last character + anda #$7F clear marker + sta b,x + ldd <fileln + std <offset + ldd #6 + leax lsn,u +nbloop sta ,x+ + decb + bne nbloop + lbra readloop -expert tst xprtflag in expert mode now? - beq xprton no, go turn it on - clr xprtflag signal mode off - ldd #xprtpos - lbsr movecurs - lbsr clrline erase label -xprtout lbra getcmd -xprton lbsr rusure Sure? - bne xprtout no, exit - com xprtflag signal xpert mode - ldd #xprtpos - lbsr movecurs position cursor - leax xprtmess,pcr - lbsr pstring display 'EXPERT' - bra xprtout +* display module name and offset +prntmod ldd #$3020 mod position + lbsr movecurs + leax >modnmhdr,pcr + lbsr pstring + leax <infile,u + lbsr wrtlin1 + ldd #$5820 offset position + lbsr movecurs + leax >offmess,pcr + lbsr pstring + leay >i.o.buff,u + ldd <offset + lbsr convert2 + lda #$0D CR + sta ,y + lbra writeout -help lbsr clrscr clear screen - leax helper,pcr point to help message - ldy #helpchrs length of message - lbsr wrtlin2 print it - leax i.o.buff,u - lbsr Read1 get 1 byte - lbra redo redo display +* unlink module and restore LSN to that of file +unlinker tst <infile + lbeq getcmd + ldd #8 + leax lsn,u +unloop sta ,x+ + decb + bne unloop + ldd #$3020 mod position + lbsr movecurs + lbsr clrline + lbsr clrline + clr <infile + lbra readloop + +* toggle expert mode - edits and zaps are auto-written +expert tst <xprtflag + beq xprton turn flag on if not on + clr <xprtflag + ldd #$5933 expert position + lbsr movecurs + lbsr clrline +xprtout lbra getcmd +xprton lbsr rusure + bne xprtout + com <xprtflag + ldd #$5933 expert position + lbsr movecurs + leax >xprtmess,pcr display EXPERT + lbsr pstring + bra xprtout + +help lbsr clrscr + leax >helper,pcr + ldy #helpchrs + lbsr wrtlin2 + leax >i.o.buff,u + lbsr read1 + lbra cReturn -find - clr echobyte - com echobyte echo on - lbsr echo - lbsr movecmd - lbsr clrline - tst FHexAsc Hex or Ascii mode? - bne charfind bra if Ascii - leax findbyte,pcr - lbsr pstring display prompt - ldy #33 max chars to read + 1 - lbsr FRead - cmpy #1 blank line entered? - lbeq exitfind yes, exit find mode - leay -1,y get rid of CR - tfr y,d - lsrb divide # bytes read by 2 - lbcs badfind bra if odd # read - stb TargLen save # bytes in find string - leau findstr,u point to storage area -* Convert 2 bytes pointed to by X to object byte in A -FConvert lbsr hexobjct - lbcs badfind bra if invalid char - sta ,u+ save byte - leay -2,y all chars converted? - bne FConvert no, bra - ldu Usave restore U - bra gofind +find clr <echobyte + com <echobyte + lbsr echo + lbsr movecmd + lbsr clrline + tst <FhexAsc hex or ascii mode? + bne charfind go if ascii + leax >findbyte,pcr + lbsr pstring + ldy #$21 + lbsr FRead + cmpy #1 + lbeq exitfind + leay -1,y + tfr y,d + lsrb + lbcs badfind + stb <TargLen + leau <findstr,u +* convert 2 bytes pointed to by regX, store in regA +FConvert lbsr hexobjct + lbcs badfind + sta ,u+ + leay -2,y + bne FConvert + ldu <Usave + bra gofind -* Input a string of ASCII characters to search for - -charfind leax findchar,pcr - lbsr pstring display prompt - ldy #17 max # of chars + 1 - lbsr FRead - cmpy #1 only CR entered? - lbeq exitfind yes, exit find mode - tfr y,d # bytes read - decb dump CR - stb TargLen save length of target string - leay findstr,u -find20 lda ,x+ move target - sta ,y+ string to storage area - decb done? - bne find20 +* input string of ascii chars +charfind leax >findchar,pcr + lbsr pstring + ldy #$11 + lbsr FRead + cmpy #1 + lbeq exitfind + tfr y,d + decb dump CR + stb <TargLen + leay <findstr,u +find20 lda ,x+ + sta ,y+ + decb + bne find20 * Check if byte from target string matches byte in buffer by EOR'ing the two. * If they match exactly, result is 0. If in 'char' search mode, EOR results * in bits 5 and/or 7 being set if 2 bytes differ only by case or bit 7 status -gofind ***************************** * Added 01/08/90 (RAK) * - clr echobyte echo off - lbsr echo +* clr echobyte echo off +* lbsr echo * * END of modification ***************************** - leax inbuff,u point to sector buffer -find30 ldb seclen+1 # bytes in this sector - leay findstr,u point to target string -find50 lda ,y get 1st target byte - eora ,x+ does it match? - lbeq found1 yes, bra - tst FHexAsc in 'char' search mode? - beq find60 no, bra - bita #%01011111 else, only bits 5 &/or 7 set? - lbeq found1 bra if so -find60 decb whole sector checked? -find70 bne find50 no, bra -* No match in this sector. Read in next sector. - -**************************************************** +gofind clr <echobyte + lbsr echo + leax >inbuff,u +find30 ldb <seclen+1 + leay <findstr,u +find50 lda ,y + eora ,x+ + lbeq found1 + tst <FHexAsc + beq find60 + bita #$5F %01011111 + lbeq found1 +find60 decb +find70 bne find50 no match in this sector * Modification (addition) by RAK 01/08/90 * Read a character from std in to catch a break * key which allows aborting a <F>IND. * Note: "finderr2" resets the stack. -* - pshs d,x,y save registers - clra std in - ldb #SS.Ready - os9 I$GetStt was there a key press? - bcs NoKey no, skip read - leax i.o.buff,u point to buffer - lbsr Read1 get a key - lda ,x get the key - cmpa #5 break key? - beq finderr2 yes, stop <F>ind -NoKey puls d,x,y no, restore registers -* -* End of modification -**************************************************** - - bsr FNxtsec get next sector - bra find30 back to loop + pshs y,x,b,a + clra + ldb #1 SS.Ready + os9 I$GetStt + bcs NoKey + leax >i.o.buff,u + lbsr read1 + lda ,x + cmpa #5 catch key to abort find + beq finderr2 +NoKey puls y,x,b,a +* end of mod + bsr FNxtSec + bra find30 -FNxtSec tst infile module linked? - beq find75 no, bra - ldd lmodlen else, get module length - subd #1 now A = LSN of last sector - cmpa LSN+2 was this last sector? - beq finderr2 yes, bra -find75 ldd lsn+1 else, get next sector - addd #1 inc lsn - std lsn+1 - bne find80 bra if no carry needed - inc lsn else, do add in carry -find80 lbsr lsnseek seek to next sector - leax inbuff,u point to sector buffer - stx buffptr save - tst infile module linked? - beq find256 no, bra - ldd lmodlen linked mod length - suba lsn+2 > $100 bytes left? - bne find256 yes, bra - tfr d,y else, set up for smaller read - bra FRdSome -find256 ldy #$100 -FRdSome lda inpath - os9 i$read - bcs finderr - sty seclen save # bytes read - rts +FNxtSec tst <infile + beq find75 + ldd <lmodlen + subd #1 + cmpa <lsn+2 + beq finderr2 +find75 ldd <lsn+1 + addd #1 + std <lsn+1 + bne find80 + inc <lsn +find80 lbsr lsnseek + leax >inbuff,u + stx <buffptr + tst <infile + beq find256 + ldd <lmodlen + suba <lsn+2 + bne find256 + tfr d,y + bra FRdSome +find256 ldy #$100 +FRdSome lda <inpath + os9 I$Read + bcs finderr + sty <seclen + rts -* Input byte or char string to find - -FRead leax i.o.buff,u - clra stdin - os9 i$readln - bcs cheksig3 - rts +* Get byte/char to find +FRead leax >i.o.buff,u + clra + os9 I$ReadLn + bcs cheksig3 + rts +cheksig3 leas 2,s + clr <SgnlCode + cmpb #2 break key? + lbne error + com <FHexAsc + lbra find +badfind ldu <Usave + bsr beep + lbra find -ChekSig3 leas 2,s scratch return addr - clr SgnlCode clear old signal - cmpb #2 BREAK key? - lbne error no, exit - com FHexAsc yes, toggle Hex/Ascii flag - lbra find - -badfind ldu Usave restore U - bsr beep - lbra find - -* Make a beep -beep leax bell,pcr - ldy #1 - lbra writeout beep & return +* make a beep +beep leax >bell,pcr + ldy #1 + lbra writeout * If error reading next sector was EOF, then find was unsuccessful. * Re-read original sector and return to CMD: prompt +finderr cmpb #$D3 EOF + lbne error +finderr2 lds <Ssave + ldd <oldlsn + std <lsn + lda <oldlsn+2 + sta <lsn+2 + lbsr seeksec + sty <seclen + bsr beep +exitfind lbra exitzap -finderr cmpb #e$eof EOF? - lbne error no, exit -finderr2 lds Ssave dump return addr - ldd oldlsn original LSN - std lsn - lda oldlsn+2 - sta lsn+2 - lbsr seeksec read original LSN - sty seclen save bytes read - bsr beep - -exitfind lbra exitzap exit - -found1 pshs b # bytes left in sector + 1 - decb # save bytes left if this search unsuccessful - stb FBytes and for 'Next' command +found1 pshs b + decb + stb <Fbytes * Save pointer (X) to next byte in buffer for search to resume if this search * is unsuccessful or for 'Next' command - stx findptr pointer for next search - ldb TargLen #bytes in target string -find90 decb whole string checked? - beq matched yes, match found - dec ,s else, more bytes left in sector? - beq find130 no, read in next -find100 leay 1,y else, point to next target byte - lda ,y target byte - eora ,x+ match? - beq find90 yes, loop back for more - tst FhexAsc in 'char' search mode? - beq find110 no, bra - bita #%01011111 only bits 5 &/or 7 set? - beq find90 yes, bra -find110 leas 1,s else, dump counter + stx <findptr + ldb <TargLen +find90 decb + beq matched + dec ,s + beq find130 +find100 leay 1,y + lda ,y + eora ,x+ + beq find90 + tst <FHexAsc + beq find110 + bita #$5F + beq find90 +find110 leas 1,s * Restore buffer pointer (X) to byte after 1st byte found that matched in -* search just completed (unsuccessfully). Restore B to # bytes left in -* sector at that point. Y = start of target string. - ldx findptr ready for new search -find120 leay findstr,u - ldb FBytes bytes left in sector - lbra find70 - +* search just completed (unsuccessfully). Restore B to # bytes left in +* sector at that point. Y = start of target string. + ldx <findptr +find120 leay <findstr,u + ldb <FBytes + lbra find70 * Read in next sector to complete test for match -find130 leas 1,s dump counter - pshs b,y save counter & target pointer - lbsr FNxtSec read in next sector - puls b,y restore counter & target pointer - lda seclen+1 # bytes in this sector - pshs a save - bra find100 continue search +find130 leas 1,s + pshs y,b + lbsr FNxtSec + puls y,b + lda <seclen+1 + pshs a + bra find100 * Successful Find -* Must determine whether target string starts in last LSN read or -* next-to-last, for display. - -matched leas 1,s dump counter - lda lsn+2 - cmpa oldlsn+2 did we have to read a new sector? - beq match40 no, bra - cmpx findptr does target start in last sector read? - bhs match30 yes, bra -match10 ldd lsn+1 else, set to re-read previous LSN - subd #1 - std lsn+1 - cmpd #$ffff - bne match20 - dec lsn -match20 lbsr seeksec re-read sector - sty seclen save bytes read ($100) -match30 ldd lsn update 'oldlsn' - std oldlsn - lda lsn+2 - sta oldlsn+2 -match40 lbsr display (re)display sector +* Must determine whether target string starts in last LSN read or +* next-to-last, for display +matched leas 1,s + lda <lsn+2 + cmpa <oldlsn+2 + beq match40 + cmpx <findptr + bcc match30 + ldd <lsn+1 + subd #1 + std <lsn+1 + cmpd #$FFFF + bne match20 + dec <lsn +match20 lbsr seeksec + sty <seclen +match30 ldd <lsn + std <oldlsn + lda <lsn+2 + sta <oldlsn+2 +match40 lbsr display * Get offset of found string from beginning of LSN - ldd findptr addr 1 byte past start of found string - subd #1 D = addr of string - std edbufptr save for display - subd buffptr D (B) = offset from buff start + ldd <findptr + subd #1 + std <edbufptr + subd <buffptr * Now LS nib of B = col #, MS nib = row # for display - pshs b - andb #$0f mask off MS nibble - pshs b - addb #$58 add offset for ascii dump column - stb asciicol - puls b - lda #3 3 screen columns per hex byte dump - mul - addb #$25 add offset for hex dump column - stb hexcol - puls b - andb #$f0 mask off LS nibble - lsrb - lsrb - lsrb - lsrb B now = row # - addb #$23 add offset - stb rownum - lbsr revdisp reverse video - lbsr eddisply display 1st byte in found string - lbsr normdisp normal video - clr rownum - lbra exitfind done *** This line changed from 'lbra getcmd' in Version 2.0 *** + pshs b + andb #$0F + pshs b + addb #$58 + stb <asciicol + puls b + lda #$03 + mul + addb #$25 + stb <hexcol + puls b + andb #$F0 + lsrb + lsrb + lsrb + lsrb + addb #$23 + stb <rownum + lbsr revdisp + lbsr eddisply + lbsr normdisp + clr <rownum +*** This line changed from 'lbra getcmd' in Version 2.0 *** + lbra exitfind -* Locate next occurrence of string located with 'Find' command. -* Search starts where 'Find' left off, unless LSN has since changed, -* in which case search starts at start of present LSN - -next tst TargLen is there a string to find? - lbeq getcmd no, exit - lbsr movecmd - leax srchmess,pcr - lbsr pstring display "Searching" - ldx findptr pointer into buffer where 'find' left off - lbeq gofind 0 => begin at start of LSN - lbra find120 - -* Display file size and input new value +* Next Search starts from Find unless LSN changed +next tst <TargLen + lbeq getcmd + lbsr movecmd + leax >srchmess,pcr + lbsr pstring + ldx <findptr + lbeq gofind + lbra find120 -diddle lbsr movecmd - leax lenmess,pcr - lbsr pstring - com zeroflag suppress leading zeroes - leay i.o.buff,u - ldd FileLen MSB of file length - lbsr convert1 convert 1st nibble to ascii - tfr b,a - lbsr convert1 do 2nd nibble - ldd FileLen+2 LSB of file length - lbsr convert1 do 3rd nibble - clr zeroflag stop suppressing leading zeroes - tfr b,a - lbsr convert1 - ldd #$2020 - std ,y++ - std ,y++ - leax i.o.buff,u - stx bytsread temp storage - tfr y,d - subd bytsread get # chars to display - tfr d,y setup for i$writln - lbsr writeout - leax newmess,pcr - lbsr pstring display message - ldy #9 max chars to read - lbsr MakeHex convert them to object - bcs diddle - ldd #cmd1pos - lbsr movecurs - lbsr rusure10 ask 'Sure?' - lbne getcmd - ldx HexBuff MSB of new file length - ldu HexBuff+2 LSB "" - ldb #ss.size - lda inpath - os9 i$setstt set new file length - lbcs error - stx FileLen - stu FileLen+2 - ldu Usave +* Display/change file size +diddle lbsr movecmd + leax >lenmess,pcr + lbsr pstring + com <zeroflag + leay >i.o.buff,u + ldd <FileLen + lbsr convert1 nibble to ascii + tfr b,a + lbsr convert1 second nibble + ldd <FileLen+2 + lbsr convert1 third nibble + clr <zeroflag + tfr b,a + lbsr convert1 + ldd #$2020 + std ,y++ + std ,y++ + leax >i.o.buff,u + stx <bytsread + tfr y,d + subd <bytsread chars to display + tfr d,y + lbsr writeout + leax >newmess,pcr + lbsr pstring + ldy #9 + lbsr MakeHex + bcs diddle + ldd #$2037 command1 position + lbsr movecurs + lbsr rusure10 + lbne getcmd + ldx <HexBuff + ldu <HexBuff+2 + ldb #2 size + lda <inpath + os9 I$SetStt + lbcs error + stx <FileLen + stu <FileLen+2 + ldu <Usave * Make sure LSN displayed is still within file (in case file shortened). -* If not, reset display to show last LSN with new file length. - lda FileLen MSB of file length - cmpa lsn is max LSN > current LSN? - blo RstLSN no, bra - bne diddled else, bra if LSN not last - ldd FileLen+1 check LSB's (MSB's equal) - cmpd lsn+1 - bls RstLSN10 -diddled lbra readloop re-read sector & display +* If not, reset display to show last LSN with new file length. + lda <FileLen + cmpa <lsn + bcs RstLSN + bne diddled + ldd <FileLen+1 + cmpd <lsn+1 + bls RstLSN10 +diddled lbra readloop -RstLSN sta lsn reset MSB of lsn - ldd FileLen+1 get LSB's of last sector -RstLSN10 tst FileLen+3 need to correct? - bne RstLSN20 - subd #1 -RstLSN20 std lsn+1 reset LSB's of lsn -* If D was 0, need to 'borrow' - cmpd #$ffff was D 0? - bne diddled no, bra - dec lsn else, correct LSB of LSN - bra diddled +RstLSN sta <lsn + ldd <FileLen+1 +RstLSN10 tst <FileLen+3 + bne RstLSN20 + subd #1 +RstLSN20 std <lsn+1 + cmpd #$FFFF + bne diddled + dec <lsn + bra diddled -push lda StackCnt # of LSN's on stack - cmpa #MaxStack more room? - bhs full no, bra - ldb #3 3 bytes per entry - mul - leax Stack,u start of stack - leax b,x add offset - ldd lsn - std ,x++ put current LSN on stack - lda lsn+2 - sta ,x +push lda <StackCnt + cmpa #$10 + bcc full + ldb #$03 + mul + leax >Stack,u + leax b,x + ldd <lsn + std ,x++ + lda <lsn+2 + sta ,x * Now that LSN is on stack, check to make sure it isn't the last one -* pushed, as well. If so, don't increment StackCnt, which effectively -* cancels the Push operation. - tst StackCnt any sectors thus far? - beq pushOK no, do push - cmpa -3,x Is LSB of LSN the same as previous LSN pushed? - bne pushOK no, bra - ldd lsn check MS bytes of LSN - cmpa -5,x do they match? - beq pushed yes, exit without completing push -pushOK inc StackCnt complete push -pushed lbra getcmd exit +* pushed, as well. If so, don't increment StackCnt, which effectively +* cancels the Push operation. + tst <StackCnt + beq pushOK + cmpa -$03,x + bne pushOK + ldd <lsn + cmpa -5,x + beq pushed +pushOK inc <StackCnt +pushed lbra getcmd * Stack is full - display message -full lbsr movecmd - leax fullmess,pcr - lbsr pstring display - lbsr read1 wait for keypress - bra pushed +full lbsr movecmd + leax >bell,pcr + lbsr pstring full message + lbsr read1 + bra pushed + +restore lda <StackCnt + beq pushed + ldb #3 + mul + subb #3 + leax >Stack,u + leax b,x + ldd ,x++ + std <lsn + lda ,x + sta <lsn+2 + dec <StackCnt + lbra readloop + +* This is a general purpose 16x16 bit multiplication. +* regD is first number, regX is second number. +* Returns answer in regY and regU. +mulDbyX pshs u,y,x,b,a + clr 4,s + lda 3,s lower word of regX times regB + mul + std 6,s + ldd 1,s upper word of regX times regB + mul + addb 6,s + adca #$00 + std 5,s + ldb ,s original regA + lda 3,s upper word regX + mul + addd 5,s + std 5,s + bcc mulDX2 L171D + inc 4,s +mulDX2 lda ,s + ldb 2,s + mul + addd 4,s + std 4,s + puls pc,u,y,x,b,a -remove lda StackCnt # sectors on stack - beq pushed exit if none - ldb #3 3 bytes per entry - mul offset to END of entry - subb #3 no B = offset to entry - leax Stack,u - leax b,x point to entry - ldd ,x++ get MS bytes of LSN - std lsn - lda ,x get LS byte of LSN - sta lsn+2 reset LSN - dec StackCnt 1 less sector on stack - lbra readloop and go read in new sector +* Looks like 16*regX +mul16B pshs x,b,a + lda #$10 + pshs a + clra + clrb +mul16B2 lsl 4,s + rol 3,s + rolb + rola + cmpd 1,s + bcs mul16B3 + subd 1,s + inc 4,s +mul16B3 dec ,s + bne mul16B2 + ldx 3,s + leas 5,s + rts - emod -dEDend equ * +prntBAM ldd #$2034 + lbsr movecurs + tst clustflg + bne csf9 + leax BAMmess1,pcr + bra csf10 +csf9 leax BAMmess2,pcr +csf10 lbsr pstring + leay >i.o.buff,u + pshs y + ldd <BAMstart get 3 byte address and display it + lbsr convert1 convert hex to ascii + tfr b,a + lbsr convert1 convert hex to ascii + lda <BAMstart+2 + lbsr convert1 convert hex to ascii + lda ,-y + ora #$80 + sta ,y + ldd #$3234 + lbsr movecurs + ldx ,s + lbsr pstring + ldy ,s + ldd <BAMstop + lbsr convert1 + tfr b,a + lbsr convert1 + lda <BAMstop+2 + lbsr convert1 + lda ,-y + ora #$80 + sta ,y + ldd #$3D34 + lbsr movecurs + puls x + lbsr pstring + rts - ENDC +togCS com <clustflg + lbra cReturn + + emod +eom equ * end