%begin
!ATVARSCAN: scans .MOB files for references to absolute variables
!adapted from HMD's M68000 Disassembler
!RWT Aug 1986

%include "INC:UTIL.IMP"

%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,ok=0,disp
%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
ok=1; disp = halfinteger(fr)
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
ok=1; disp = integer(fr)
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

%string(15)mnem
%routine check out at address
%integer i
%constinteger maxat=61
%consthalfarray ataddr(1:maxat+1)=-
16_1000,16_10c0,16_11c0,16_1340,16_3400,
16_3510,16_3550,16_3564,16_35a8,16_35b8,
16_35c4,16_35c6,16_35ca,16_35ce,16_360e,
16_364e,16_3652,16_3654,16_3656,16_3658,
16_365a,16_365c,16_365e,16_3660,16_36c4,
16_3720,16_3724,16_3728,16_372c,16_372d,
16_372e,16_3730,16_3734,16_3738,16_373c,
16_3740,16_3744,16_3748,16_374c,16_3750,
16_3754,16_3758,16_375c,16_3f98,16_3f9c,
16_3fa0,16_3fa1,16_3fa2,16_3fa8,16_3fa9,
16_3faa,16_3fab,16_3fac,16_3fb0,16_3fc0,
16_3fd0,16_3fe0,16_3ff0,16_3ff4,16_3ff8,
16_3ffc,16_4000
%conststring(15)%array atname(1:maxat)=-
"vectors","oldextracode","oldEXTRAcode","supervisorcode","oldevent_?",
"oldevcontext","oldevhandler","trapcontext","breakpoint","obsolete",
"userno","curin","curout","instreams","outstreams",
"promptaddr","kbmode","vdiscard","vquota","kbin",
"kbex","lpos","lend","kbbuffer","linebuffer",
"vep","exemptmask","millisecs","cylock","oldfsport",
"station","etherr","dtxin","rdyin","stxin",
"ackin","nakin","dsqint","dsqwai","dtxast",
"dtxa6","dtxmask","void","mainprog","globalbase",
"screenrows","screencols","screenput","ldte","lsap",
"rdte","rsap","cliparamad","comdict","fildict",
"sysdict","extdict","freebot","freetop","membot",
"memtop"
  %if disp<16_1000 %or disp>=16_4000 %start
    ok = 0 {Out of bounds}; %return
  %finish
  %for i = 1,1,maxat %cycle
    mnem = atname(i) %andreturnif ataddr(i)<=disp<ataddr(i+1)
  %repeat
  ok=0 {Unknown}
%end
  
!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('?')
%constinteger jsr=16_4eb8,jmp=16_4ef8
%unless ok=0 %start
  ok = 0 %if code=jsr %or code=jmp
  checkout ataddress %unless ok=0
%finish
%unless ok=0 %start
!   %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
    spaces(65-26-bp-1); space; printstring(mnem)
    newline
    newline %if shortinteger(fr-2) = 16_4E75;  !rts
ok = 0
%finishelse from=fr
  %repeat %until from >= upto
%end

%integer start,size,codestart,codelimit
%recordformat f(%half tyver,flags,export,import,
  %integer codesize,%half reset,main,
  %integer ownsize,stacksize,spare1,spare2)
%record(f)%name header

%routine file(%string(255)infile)
  %onevent 3,9 %start
    printstring(event_message); newlines(2)
    release; %return
  %finish
  mark
  printstring("File ".infile); spaces(21-length(infile))
  connectfile(infile,0,start,size)
  printstring("Size="); phex(size)
  header == record(start)
  %if header_tyver=16_fe02 %start
    codestart = start+sizeof(header)+header_export+header_import
    codelimit = codestart+header_codesize
    start = codestart
    printstring("  Reset="); phex4(header_reset<<1)
    printstring("  Main="); phex4(header_main<<1); newline
    decode(start,codestart,codelimit)
  %else
    printstring("  not FE02"); newline
  %finish
  newline; release
%end

%include "inc:fs.imp"
%include "inc:fsutil.imp"
%include "inc:wild.imp"

%string(255)dir,fil,par
%record(cellfm)%name dl,fl

  set terminalmode(nopage)
  fil = cliparam
  dir = current directory %unless fil -> dir.(":").fil
  fil = "*" %if fil=""
  fil = fil.".mob"
  dl == dirlist(dir)
  %while dl##nil %cycle
    printstring("Directory ".dl_datum); newlines(2)
    mark; fl == fileslist(dl_datum.":".fil)
    %while fl##nil %cycle
      file(fl_datum); fl == fl_link
    %repeat
    release; dl == dl_link
  %repeat

%endofprogram