begin ; !M68000 Disassembler
!HD Feb 1982 - revised May 83 - re-written Aug 1983
!
!!!!!!!!!!! File and control initialisation !!!!!!!!!!!!!
!$IF VAX
{%include "DR0:[HMD]PAM.INC"
{%ownstring(127) infile="TT:",
{ outfile="TT:"
!$IF APM
include "INC:UTIL.IMP"
string (255) parm
ownstring (127) infile="",
outfile=":"
!$FINISH
!Control parameters:
owninteger LO=0, HI=999999
ownbyte BINARY=1, BRIEF=0
!
constinteger STOREMAX=32767
short integerarray STORE(0:storemax)
!
routine DECODE(integer BASE, integername FROM, integer UPTO)
!The array DEF defines the format of M68000 opcodes as pairs
! of 32-bit words: the first word is a packed mnemonic and
! the second is an interpretation code consisting of two 16-bit halves.
! The high-order 16-bits are the fixed part of the op-code.
! The low-order value has flag bits in the most significant 6 bits
! and two 5-bit fields defining the types of up to two operands
! for the op-code. These fields are used (a) to index the array MASK
! to establish which bits the field corresponds to and (b) to
! control interpretation of the corresponding operand.
! There are some arbitrary choices regarding what is part of the
! fixed op-code and what is variable.
! The area is ordered by op-code group (high-order 4 bits) and
! within each group in accordance with REVERSE search order:
! hence the relative position of eg SUB, SUBX, SUBA.
constinteger SIZED=1<<15, MSIZED=1<<14, ASIZED=3<<14,
WLSIZED=1<<13,
COND=1<<12
constinteger REG=1, AREG=2,
AT=3, SREG=4, WLREG=5,
TQUICK=6,
EA=7, SEA=8, WLSEA=9,
MQUICK=10, REL=11,
IMM=12, XIMM=13, USPSR=14, CCR=15,
DEA=16,
REG9=17, AREG9=18, QREG9=19,
QUICK9=20, AT9=21,
CEA=22, CREG=23, CREL=24,
SPOST=25, POST9=26, SPRE=27, PRE9=28,
ADISP=29, SAREG9=30
!
constshortintegerarray MASK(0:31) <-
16_FFFF,
16_FFF8{REG}, 16_FFF8{AREG},
16_FFF8{AT}, 16_FF38{SREG}, 16_FFB8{WLREG},
16_FFF0{TQUICK},
16_FFC0{EA}, 16_FF00{SEA}, 16_FF80{WLSEA},
16_FF00{MQUICK}, 16_FF00{REL},
16_FFFF{IMM}, 16_FFFF{XIMM}, 16_FFFF{USPSR}, 16_FFFF{CCR},
16_F03F{DEA},
16_F1FF{REG9}, 16_F1FF{AREG9}, 16_F1DF{QREG9}, 16_F1FF{QUICK9},
16_F1FF{AT9},
16_F0C0{CEA}, 16_F0F8{CREG}, 16_F000{CREL},
16_FF38{SPOST}, 16_F1FF{POST9}, 16_FF38{SPRE}, 16_F1FF{PRE9},
16_FFB8{ADISP}, 16_F0FF{SAREG9},
0
constinteger DEFMAX=110
constbyteintegerarray LIMIT(0:15) =
45, 47, 49, 51, 121, 131, 135, 137,
151, 161, 161, 171, 189, 217, defmax+defmax+1, defmax+defmax+1
constintegerarray DEF(1:defmax+defmax) = c
{BTST} 'b'<<25+('t'&31)<<20+('s'&31)<<15+('t'&31)<<10,
16_01000000+ reg9<<5+ea,
{BCHG} 'b'<<25+('c'&31)<<20+('h'&31)<<15+('g'&31)<<10,
16_01400000+ reg9<<5+ea,
{BCLR} 'b'<<25+('c'&31)<<20+('l'&31)<<15+('r'&31)<<10,
16_01800000+ reg9<<5+ea,
{BSET} 'b'<<25+('s'&31)<<20+('e'&31)<<15+('t'&31)<<10,
16_01C00000+ reg9<<5+ea,
{BTST} 'b'<<25+('t'&31)<<20+('s'&31)<<15+('t'&31)<<10,
16_08000000+ imm<<5+ea,
{BCHG} 'b'<<25+('c'&31)<<20+('h'&31)<<15+('g'&31)<<10,
16_08400000+ imm<<5+ea,
{BCLR} 'b'<<25+('c'&31)<<20+('l'&31)<<15+('r'&31)<<10,
16_08800000+ imm<<5+ea,
{BSET} 'b'<<25+('s'&31)<<20+('e'&31)<<15+('t'&31)<<10,
16_08C00000+ imm<<5+ea,
{MOVEP} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10+('p'&31)<<5,
16_01080000+ wlsized+reg9<<5+adisp,
{MOVEP} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10+('p'&31)<<5,
16_01880000+ wlsized+adisp<<5+reg9,
{ORI} 'o'<<25+('r'&31)<<20+('i'&31)<<15,
16_00000000+ sized+imm<<5+sea,
{ORI} 'o'<<25+('r'&31)<<20+('i'&31)<<15,
16_003C0000+ imm<<5+ccr,
{ORI} 'o'<<25+('r'&31)<<20+('i'&31)<<15,
16_007C0000+ imm<<5+uspsr,
{ANDI} 'a'<<25+('n'&31)<<20+('d'&31)<<15+('i'&31)<<10,
16_02000000+ sized+imm<<5+sea,
{ANDI TO CCR} 'a'<<25+('n'&31)<<20+('d'&31)<<15+('i'&31)<<10,
16_023C0000+ imm<<5+ccr,
{ANDI} 'a'<<25+('n'&31)<<20+('d'&31)<<15+('i'&31)<<10,
16_027C0000+ imm<<5+uspsr,
{SUBI} 's'<<25+('u'&31)<<20+('b'&31)<<15+('i'&31)<<10,
16_04000000+ sized+imm<<5+sea,
{ADDI} 'a'<<25+('d'&31)<<20+('d'&31)<<15+('i'&31)<<10,
16_06000000+ sized+imm<<5+sea,
{EORI} 'e'<<25+('o'&31)<<20+('r'&31)<<15+('i'&31)<<10,
16_0A000000+ sized+imm<<5+sea,
{EORI} 'e'<<25+('o'&31)<<20+('r'&31)<<15+('i'&31)<<10,
16_0A3C0000+ imm<<5+ccr,
{EORI} 'e'<<25+('o'&31)<<20+('r'&31)<<15+('i'&31)<<10,
16_0A7C0000+ imm<<5+uspsr,
{CMPI} 'c'<<25+('m'&31)<<20+('p'&31)<<15+('i'&31)<<10,
16_0C000000+ sized+imm<<5+sea,
{MOVEB} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_10000000+ msized+ea<<5+dea,
{MOVEL} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_20000000+ msized+ea<<5+dea,
{MOVEW} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_30000000+ msized+ea<<5+dea,
{NEGX} 'n'<<25+('e'&31)<<20+('g'&31)<<15+('x'&31)<<10,
16_40000000+ ea,
{MOVE from SR} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_40C00000+ uspsr<<5+ea,
{CLR} 'c'<<25+('l'&31)<<20+('r'&31)<<15,
16_42000000+ sized+sea,
{NEG} 'n'<<25+('e'&31)<<20+('g'&31)<<15,
16_44000000+ sized+sea,
{MOVE to CCR} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_44C00000+ ea<<5+ccr,
{NOT} 'n'<<25+('o'&31)<<20+('t'&31)<<15,
16_46000000+ sized+sea,
{MOVE to SR} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_46C00000+ ea<<5+uspsr,
{NBCD} 'n'<<25+('b'&31)<<20+('c'&31)<<15+('d'&31)<<10,
16_48000000+ ea,
{PEA} 'p'<<25+('e'&31)<<20+('a'&31)<<15,
16_48400000+ ea,
{SWAP} 's'<<25+('w'&31)<<20+('a'&31)<<15+('p'&31)<<10,
16_48400000+ reg,
{MOVEM} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10+('m'&31)<<5,
16_48800000+ wlsized+ximm<<5+wlsea,
{MOVEM} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10+('m'&31)<<5,
16_4C800000+ wlsized+wlsea<<5+ximm,
{EXTW} 'e'<<25+('x'&31)<<20+('t'&31)<<15+('w'&31)<<10,
16_48800000+ reg,
{EXTL} 'e'<<25+('x'&31)<<20+('t'&31)<<15+('l'&31)<<10,
16_48C00000+ reg,
{TST} 't'<<25+('s'&31)<<20+('t'&31)<<15,
16_4A000000+ sized+sea,
{TAS} 't'<<25+('a'&31)<<20+('s'&31)<<15,
16_4AC00000+ ea,
{TRAP} 't'<<25+('r'&31)<<20+('a'&31)<<15+('p'&31)<<10,
16_4E400000+ tquick,
{LINK} 'l'<<25+('i'&31)<<20+('n'&31)<<15+('k'&31)<<10,
16_4E500000+ areg<<5+imm,
{UNLK} 'u'<<25+('n'&31)<<20+('l'&31)<<15+('k'&31)<<10,
16_4E580000+ areg,
{MOVE to USP} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_4E600000+ areg<<5+uspsr,
{MOVE from USP} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10,
16_4E680000+ uspsr<<5+areg,
{RESET} 'r'<<25+('e'&31)<<20+('s'&31)<<15+('e'&31)<<10+('t'&31)<<5,
16_4E700000,
{NOP} 'n'<<25+('o'&31)<<20+('p'&31)<<15,
16_4E710000,
{STOP} 's'<<25+('t'&31)<<20+('o'&31)<<15+('p'&31)<<10,
16_4E720000 +imm,
{RTE} 'r'<<25+('t'&31)<<20+('e'&31)<<15,
16_4E730000,
{RTS} 'r'<<25+('t'&31)<<20+('s'&31)<<15,
16_4E750000,
{TRAPV} 't'<<25+('r'&31)<<20+('a'&31)<<15+('p'&31)<<10+('v'&31)<<5,
16_4E760000,
{RTR} 'r'<<25+('t'&31)<<20+('r'&31)<<15,
16_4E770000,
{JSR} 'j'<<25+('s'&31)<<20+('r'&31)<<15,
16_4E800000+ ea,
{JMP} 'j'<<25+('m'&31)<<20+('p'&31)<<15,
16_4EC00000+ ea,
{CHK} 'c'<<25+('h'&31)<<20+('k'&31)<<15,
16_41800000+ ea<<5+reg9,
{LEA} 'l'<<25+('e'&31)<<20+('a'&31)<<15,
16_41C00000+ ea<<5+areg9,
{ADDQ} 'a'<<25+('d'&31)<<20+('d'&31)<<15+('q'&31)<<10,
16_50000000+ sized+quick9<<5+sea,
{SUBQ} 's'<<25+('u'&31)<<20+('b'&31)<<15+('q'&31)<<10,
16_51000000+ sized+quick9<<5+sea,
{S} 's'<<25,
16_50C00000+ cond+cea,
{DB} 'd'<<25+('b'&31)<<20,
16_50C80000+ cond+creg<<5+imm,
{DBRA} 'd'<<25+('b'&31)<<20+('r'&31)<<15+('a'&31)<<10,
16_51C80000+ reg<<5+imm,
{B} 'b'<<25,
16_60000000+ cond+crel,
{BRA} 'b'<<25+('r'&31)<<20+('a'&31)<<15,
16_60000000+ rel,
{MOVEQ} 'm'<<25+('o'&31)<<20+('v'&31)<<15+('e'&31)<<10+('q'&31)<<5,
16_70000000+ mquick<<5+reg9,
{OR} 'o'<<25+('r'&31)<<20,
16_80000000+ sized+sea<<5+reg9,
{OR} 'o'<<25+('r'&31)<<20,
16_81000000+ sized+reg9<<5+sea,
{DIVU} 'd'<<25+('i'&31)<<20+('v'&31)<<15+('u'&31)<<10,
16_80C00000+ ea<<5+reg9,
{DIVS} 'd'<<25+('i'&31)<<20+('v'&31)<<15+('s'&31)<<10,
16_81C00000+ ea<<5+reg9,
{SBCD} 's'<<25+('b'&31)<<20+('c'&31)<<15+('d'&31)<<10,
16_81000000+ reg9<<5+reg,
{SBCD} 's'<<25+('b'&31)<<20+('c'&31)<<15+('d'&31)<<10,
16_81080000+ spre<<5+pre9,
{SUB} 's'<<25+('u'&31)<<20+('b'&31)<<15,
16_90000000+ sized+sea<<5+reg9,
{SUB} 's'<<25+('u'&31)<<20+('b'&31)<<15,
16_91000000+ sized+reg9<<5+sea,
{SUBX} 's'<<25+('u'&31)<<20+('b'&31)<<15+('x'&31)<<10,
16_91000000+ sized+sreg<<5+reg9,
{SUBX} 's'<<25+('u'&31)<<20+('b'&31)<<15+('x'&31)<<10,
16_91080000+ sized+spre<<5+pre9,
{SUBA} 's'<<25+('u'&31)<<20+('b'&31)<<15+('a'&31)<<10,
16_90C00000+ asized+ea<<5+sareg9,
{CMP} 'c'<<25+('m'&31)<<20+('p'&31)<<15,
16_B0000000+ sized+sea<<5+reg9,
{EOR} 'e'<<25+('o'&31)<<20+('r'&31)<<15,
16_B1000000+ sized+reg9<<5+sea,
{CMPM} 'c'<<25+('m'&31)<<20+('p'&31)<<15+('m'&31)<<10,
16_B1080000+ sized+spost<<5+post9,
{CMPA} 'c'<<25+('m'&31)<<20+('p'&31)<<15+('a'&31)<<10,
16_B0C00000+ asized+ea<<5+sareg9,
{AND} 'a'<<25+('n'&31)<<20+('d'&31)<<15,
16_C0000000+ sized+sea<<5+reg9,
{AND} 'a'<<25+('n'&31)<<20+('d'&31)<<15,
16_C1000000+ sized+reg9<<5+sea,
{MULU} 'm'<<25+('u'&31)<<20+('l'&31)<<15+('u'&31)<<10,
16_C0C00000+ ea<<5+reg9,
{MULS} 'm'<<25+('u'&31)<<20+('l'&31)<<15+('s'&31)<<10,
16_C1C00000+ ea<<5+reg9,
{ABCD} 'a'<<25+('b'&31)<<20+('c'&31)<<15+('d'&31)<<10,
16_C1000000+ reg<<5+reg9,
{ABCD} 'a'<<25+('b'&31)<<20+('c'&31)<<15+('d'&31)<<10,
16_C1080000+ spre<<5+pre9,
{EXG} 'e'<<25+('x'&31)<<20+('g'&31)<<15,
16_C1400000+ reg9<<5+reg,
{EXG} 'e'<<25+('x'&31)<<20+('g'&31)<<15,
16_C1480000+ areg9<<5+areg,
{EXG} 'e'<<25+('x'&31)<<20+('g'&31)<<15,
16_C1880000+ reg9<<5+areg,
{ADD} 'a'<<25+('d'&31)<<20+('d'&31)<<15,
16_D0000000+ sized+sea<<5+reg9,
{ADD} 'a'<<25+('d'&31)<<20+('d'&31)<<15,
16_D1000000+ sized+reg9<<5+sea,
{ADDX} 'a'<<25+('d'&31)<<20+('d'&31)<<15+('x'&31)<<10,
16_D1000000+ sized+sreg<<5+reg9,
{ADDX} 'a'<<25+('d'&31)<<20+('d'&31)<<15+('x'&31)<<10,
16_D1080000+ sized+spre<<5+pre9,
{ADDA} 'a'<<25+('d'&31)<<20+('d'&31)<<15+('a'&31)<<10,
16_D0C00000+ asized+ea<<5+sareg9,
{ASR} 'a'<<25+('s'&31)<<20+('r'&31)<<15,
16_E0000000+ sized+qreg9<<5+sreg,
{ASL} 'a'<<25+('s'&31)<<20+('l'&31)<<15,
16_E1000000+ sized+qreg9<<5+sreg,
{LSR} 'l'<<25+('s'&31)<<20+('r'&31)<<15,
16_E0080000+ sized+qreg9<<5+sreg,
{LSL} 'l'<<25+('s'&31)<<20+('l'&31)<<15,
16_E1080000+ sized+qreg9<<5+sreg,
{ROXR} 'r'<<25+('o'&31)<<20+('x'&31)<<15+('r'&31)<<10,
16_E0100000+ sized+qreg9<<5+sreg,
{ROXL} 'r'<<25+('o'&31)<<20+('x'&31)<<15+('l'&31)<<10,
16_E1100000+ sized+qreg9<<5+sreg,
{ROR} 'r'<<25+('o'&31)<<20+('r'&31)<<15,
16_E0180000+ sized+qreg9<<5+sreg,
{ROL} 'r'<<25+('o'&31)<<20+('l'&31)<<15,
16_E1180000+ sized+qreg9<<5+sreg,
{ASRM} 'a'<<25+('s'&31)<<20+('r'&31)<<15,
16_E0C00000 +ea,
{ASLM} 'a'<<25+('s'&31)<<20+('l'&31)<<15,
16_E1C00000 +ea,
{LSRM} 'l'<<25+('s'&31)<<20+('r'&31)<<15,
16_E2C00000 +ea,
{LSLM} 'l'<<25+('s'&31)<<20+('l'&31)<<15,
16_E3C00000 +ea,
{ROXRM} 'r'<<25+('o'&31)<<20+('x'&31)<<15,
16_E4C00000 +ea,
{ROXLM} 'r'<<25+('o'&31)<<20+('x'&31)<<15,
16_E5C00000 +ea,
{RORM} 'r'<<25+('o'&31)<<20+('r'&31)<<15,
16_E6C00000 +ea,
{ROLM} 'r'<<25+('o'&31)<<20+('l'&31)<<15,
16_E7C00000 +ea
constbyteintegerarray SSYM(0:3) = 'B','W','L','?'
constshortintegerarray CPAIR(0:15) = c
m'??', m'SR', m'HI', m'LS', m'CC', m'CS', m'NE', m'EQ',
m'VC', m'VS', m'PL', m'MI', m'GE', m'LT', m'GT', m'LE'
integer CODE,FORMAT,T1,T2,PCREL,SIZE,REGS,NCODE,P,I,FR
owninteger BP,OUTCOL
ownbyteintegerarray BUFF(1:60)
constbyteintegerarray HEXSYM(0:15) = c
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
routine PHEX(integer val)
integer i
print symbol(hexsym(val>>i&15)) for i = 12,-4,0
end
routine PUT SYM(integer k)
bp = bp+1; buff(bp) = k
end
routine PUT HEX(integer val)
integer i
put sym(hexsym(val>>i&15)) for i = 12,-4,0
end
routine PUT DEC(integer val)
put sym('-') and val = -val if val < 0
put dec(val//10) and val = val-val//10*10 if val >= 10
put sym(val+'0')
end
routine PUT STRING(string (255) s)
integer i
put sym(charno(s,i)) for i = 1,1,length(s)
end
routine INTERPRET(integer type)
integer i,j,m,v,v9
switch s(0:31), e(0:7), ex(0:7)
m = code>>3&7; v = code&7; v9 = code>>9&7
->s(type)
s(quick9):
put sym('#')
v9 = 8 if v9 = 0
put sym(v9+'0')
s(0):
return
s(tquick): !Trap vector
v = code&15
put sym('#')
put dec(v)
if v = 15 and shortinteger(fr)&16_F000 = 0 start
put sym(',')
put dec(shortinteger(fr)); fr = fr+2
finish
return
s(rel): s(crel):
pcrel = fr-base
v = code&255
if v = 0 start
v = shortinteger(fr); fr = fr+2
else
v = v-256 if v&128 # 0
finish
put dec(v)
pcrel = pcrel+v
return
s(mquick):
v = code&255
v = v-256 if v&128 # 0
put sym('#')
put dec(v)
return
s(ximm):
put sym('#'); put sym('$')
put hex(regs)
return
s(dea): !dest EA (reg:mode)
m = code>>6&7; v = v9
s(ea): s(cea): s(sea): s(wlsea):
->e(m)
s(qreg9):
->s(quick9) if code&16_0020 = 0
s(reg9):
v = v9
e(0): !EA mode 000: D
s(reg): s(creg): s(sreg): s(wlreg):
put sym('D')
put sym(v+'0')
return
s(areg9): s(sareg9):
v = v9
e(1): !EA mode 001: A
s(areg):
put sym('A')
put sym(v+'0')
return
s(at9):
v = v9
e(2): !EA mode 010: (A)
s(at):
put sym('(')
put sym('A'); put sym(v+'0')
put sym(')')
return
s(post9):
v = v9
s(spost):
e(3): !EA mode 011: (A)+
put string("(A")
put sym(v+'0')
put sym(')')
put sym('+')
return
s(pre9):
v = v9
s(spre):
e(4): !EA mode 100: -(A)
put sym('-')
->s(at)
s(adisp):
e(5): !EA mode 101: d(A)
put dec(shortinteger(fr))
fr = fr+2
->s(at)
ex(3): !EA mode 111 011
v = 8
e(6): !EA mode 110: d(A,R)
i = shortinteger(fr); fr = fr+2
j = i&255; j = j-256 if j&128 # 0
put dec(j); !displacement
put sym('(')
if v # 8 then put sym('A') and put sym(v+'0') c
else put string("PC")
put sym(',')
if i&(1<<15) = 0 then put sym('D') c
else put sym('A')
put sym(i>>12&7+'0')
put sym('.')
if i&(1<<11) = 0 then put sym('W') c
else put sym('L')
put sym(')')
return
e(7): !EA mode 111
->ex(v)
ex(0): !EA mode 111 000
word:
v = shortinteger(fr); fr = fr+2
if -9 <= v <= 9 then put dec(v) c
else put sym('$') and put hex(v)
return
ex(1): !EA mode 111 001
long:
put sym('$')
put hex(shortinteger(fr)); fr = fr+2
put hex(shortinteger(fr)); fr = fr+2
return
ex(2): !EA mode 111 010
v = shortinteger(fr)
pcrel = fr-base+v
put dec(v)
fr = fr+2
put string("(PC)")
return
ex(4): !EA mode 111 100
s(imm): !immediate
put sym('#')
->word if size = 1
->long if size = 2
v = shortinteger(fr)&255; fr = fr+2
v = v-256 if v&128 # 0
put dec(v)
return
ex(5): !EA mode 111 101
put string("111101")
return
ex(6): !EA mode 111 110
put string("111110")
return
ex(7): !EA mode 111 111
put string("111111")
return
s(uspsr):
if code&16_FFF0 = 16_4E60 then put string("USP") c
else put string("SR")
return
s(ccr):
put string("CCR")
return
s(*):
write(type,0)
end ; !interpret
!To verify group limits:
! %for p = 0,1,13 %cycle
! i = def(limit(p))<<2; !print mnemonic
! print symbol(i>>27+'A'-1) %and i = i<<5 %until i = 0
! newline
! %repeat
cycle
fr = from
code = shortinteger(fr)&16_FFFF; fr = fr+2
p = limit(code>>12)
ncode = (¬code)<<16
p = 1 if code&16_FF00 = 0; !00xx usually not instr
cycle
p = p-2
exit if p < 0
format = def(p+1)
if format&ncode = 0 start ; !quick check
t1 = format>>5&31; t2 = format&31
exit if code&mask(t1)&mask(t2) = format>>16
finish
repeat
bp = 0
pcrel = 1
if p > 0 start
i = def(p)<<2; !print mnemonic
put sym(i>>27+'A'-1) and i = i<<5 until i = 0
if format&cond # 0 start ; !condition mask present
i = cpair(code>>8&15)
put sym(i>>8); put sym(i&255)
finish
size = 1; !Word-size (for immediate)
if format&(sized+msized+wlsized) # 0 start
if format&sized # 0 start
size = code>>6&3
size = code>>8&1+1 if format&(sized>>1) # 0; !ASIZED
else if format&msized # 0; !MOVE
size = code>>12&3; size = size>>1 if size&1 # 0
else ; !WLSIZED (MOVEM,MOVEP)
size = code>>6&1+1
if code > 16_4000 start ; !MOVEM
regs = shortinteger(fr); fr = fr+2; !reg mask
finish
finish
put sym('.')
put sym(ssym(size))
finish
if t2 # 0 start
put sym(' ')
if t1 # 0 start
interpret(t1)
put sym(',')
finish
interpret(t2)
finish
finish else put sym('?')
if brief = 0 start
phex(from-base); space
outcol = 5
cycle
space; phex(shortinteger(from))
outcol = outcol+5
from = from+2
repeat until from = fr
if pcrel # 1 start
printstring(" ["); phex(pcrel); printsymbol(']')
outcol = outcol+7
finish
spaces(26-outcol)
finish else from = fr
print symbol(buff(p)) for p = 1,1,bp
newline
newline if shortinteger(fr-2) = 16_4E75; !rts
repeat until from >= upto
end
routine READ AND DECODE(integer lo,hi)
integer P,Q,K,V,BUFF,LIM
on 9 start
q = buff; decode(lo,q,p) if p > q
return
finish
buff = addr(store(0)); lo = buff-lo; hi = hi+lo
lim = addr(store(storemax))+2
cycle
p = buff; lim = hi if hi < lim
k = nl
cycle
v = 0; q = buff
if binary = 0 start
read symbol(k) while k < '0'
exit if k = ':'
cycle
k = k-'a'+'A' if k > 'Z'
k = k-'0'
k = k-7 if k > 9
v = v<<4+k; q = q+1
read symbol(k)
repeat until k < '0' or q = 4
else
!$IF VAX
{ read ch(v); %signal 9 %if v&(¬255) # 0
{ read ch(k); %signal 9 %if k&(¬255) # 0
!$IF APM
read symbol(v); read symbol(k)
!$FINISH
v = v<<8+k
finish
!$IF VAX
{ v = v!16_FFFF0000 %if v&16_8000 # 0
!$FINISH
shortinteger(p) <- v if p >= buff
p = p+2
repeat until p >= lim
q = buff; decode(lo,q,p) if p > q
exit if p >= hi
hi = hi-(p-buff)
repeat
end
parm = cliparam
define param("CODEFILE",infile,0)
define param("LISTING",outfile,pamoutfile+pamnewgroup)
define int param("FROM - Start address",lo,0)
define int param("TO - Final address",hi,0)
define enum param("Hex,BINARY",binary,0)
define enum param("FULL,BRief",brief,0)
process parameters(cliparam)
select output(1)
if infile # "" or binary = 0 start
if infile # "" start
open input(1,infile)
select input(1)
finish
read and decode(lo,hi)
else
prompt("Lo(hex):"); rhex(lo)
prompt("Hi(hex):"); rhex(hi); hi = lo+256 if hi < lo
decode(lo&(¬16_FFFF),lo,hi)
finish
endofprogram