def __init__(
self,
cx,
lo,
siz=None,
hi=None,
prefixed=False,
compact=False,
):
self.lo = lo
self.name = self.__class__.__name__
if siz:
assert hi == None or hi == lo + siz
hi = lo + siz
self.hi = hi
self.prefixed = prefixed
self.compact = compact
if compact:
if prefixed:
self.y = data.Data(cx.m, self.lo - 5, self.hi)
else:
self.y = data.Data(cx.m, self.lo, self.hi)
self.y.rendered = str(self)
self.y.compact = True
elif prefixed:
self.pfx = data.Data(cx.m, self.lo - 5, self.lo)
c = PFXS.get(cx.m.le(self.lo - 5, 5))
t = "$" + self.__class__.__name__.upper()
if c:
pc = '$' + c.__name__.upper()
if pc != t:
t = pc + " (" + t + ")"
self.pfx.rendered = t
if hi:
self.set_hi(cx, hi)
def one_eprom(cx, start, eprom_size):
# Calculate checksum
j = 0 ^ cx.m.bu16(start)
for jj in range(2, eprom_size):
j += cx.m[start + jj]
j &= 0xffff
if j == 0xffff:
j = "OK"
else:
print("NB: Bad Eprom checksum @%x" % start)
j = "BAD"
c = cx.m.add_range(start, start + eprom_size, txt="EPROM")
c = data.Data(cx.m, start, start + 2, "u16")
c.rendered = ".WORD 0x%04x" % cx.m.bu16(start)
c.lcmt = "EPROM checksum (%s)" % j
c = data.Data(cx.m, start + 2, start + 3, "byte")
c.rendered = ".BYTE 0x%02x" % cx.m[start + 2]
c.lcmt = "EPROM ID"
# Jump table at front of EPROM
for ax in range(start + 3, start + eprom_size, 3):
if cx.m[ax] != 0x7e:
break
cx.disass(ax)
def __init__(self, cx, lo, **kwargs):
# print("LIB 0x%05x" % lo)
cx.m.set_block_comment(lo, "Library")
super().__init__(cx, lo, **kwargs)
self.links = self.names = self.msgs = self.config = None
b = lo + 5
nl = Const(cx.m, b, 2, "Name Length")
b = nl.hi
if nl.val:
y = data.Data(cx.m, b, b + nl.val * 2)
y.rendered = "'" + text(cx.m, b, nl.val) + "'"
y.compact = True
b = y.hi
nl = Const(cx.m, b, 2, "Name Length")
b = nl.hi
ln = Const(cx.m, b, 3, "Library Number")
b = ln.hi
self.libno = ln.val
y = Relptr(cx.m, b, "Name Table")
b = y.hi
if y.dst:
self.names = Obj(cx, y.dst, cls=NameTable)
cx.m.set_label(self.names.lo, "LIB_%03x_NAMES" % self.libno)
y = Relptr(cx.m, b, "Message Table")
b = y.hi
if y.dst:
self.msgs = Obj(cx, y.dst)
cx.m.set_label(self.msgs.lo, "LIB_%03x_MESSAGES" % self.libno)
y = Relptr(cx.m, b, "Link Table")
b = y.hi
if y.dst:
self.links = Obj(cx, y.dst, cls=LinkTable)
cx.m.set_label(self.links.lo, "LIB_%03x_LINKS" % self.libno)
y = Relptr(cx.m, b, "Config object")
b = y.hi
if y.dst:
self.config = Obj(cx, y.dst)
cx.m.set_label(self.config.lo, "LIB_%03x_CONFIG" % self.libno)
if self.links:
for n, i in enumerate(self.links.links):
cx.libobj[(self.libno, n)] = i
if self.names:
t = self.names.names.get(n)
else:
t = None
if t:
cx.m.set_label(i, "LIB_%03x_%03x_%s" % (self.libno, n, t))
else:
cx.m.set_label(i, "LIB_%03x_%03x" % (self.libno, n))
n1 = cx.m.le(i - 3, 3)
n2 = cx.m.le(i - 6, 3)
if n1 == n and n2 == self.libno:
Const(cx.m, i - 6, 6)
cx.m.set_line_comment(i - 6, "XYZZY")
cx.m.q.queue(PRI_RPN, Obj, cx, i)
def __init__(self, cx, lo, lbl=None):
self.cx = cx
self.lo = lo
self.lbl = lbl
if self.lbl:
self.cx.m.set_label(self.lo, self.lbl)
else:
self.cx.m.set_label(self.lo, "BITSPEC_%04x" % self.lo)
adr = self.lo
while self.cx.m[adr] != 0xff:
item = data.Data(self.cx.m, adr, adr + 9)
tbl = []
for _j in range(8):
j = self.cx.m[adr]
adr += 1
if j != 0x1f:
tbl.append("+0x%02x.%d" % (j & 0x1f, 7 - (j >> 5)))
else:
tbl.append("NOP ")
tbl.append("0x%02x" % self.cx.m[adr])
adr += 1
item.rendered = ".BITPOS\t" + ", ".join(tbl)
item.compact = True
data.Const(self.cx.m, adr, adr + 1)
def example():
m = mem.Stackup((FILENAME,), nextto=__file__)
m2 = mem.WordMem(0, m.hi >> 1, bits=16)
for a in range(m.lo, m.hi, 2):
m2[a >> 1] = m.bu16(a)
cx = hp_hybrid.hp_hybrid()
cx.m.map(m2, 0x20, offset=0x20)
cx.flow_check.append(fc_call)
rom_checksum(cx.m)
for a, b in SYMBOLS.items():
if b[0] == '_':
cx.m.set_label(a, b[1:])
cx.disass(a)
elif b[0] == '#':
cx.m.set_label(a, b[1:])
y = data.Data(cx.m, a, a + 1)
y.rendered = ".CONST\t0x%04x" % cx.m[a]
else:
cx.m.set_label(a, b)
pat4244024.appendix_b_1(cx, 0x3a49)
pat4244024.appendix_b_2(cx, 0x3ac2)
pat4244024.appendix_b_3(cx, 0x3ca5)
pat4244024.appendix_b_4(cx, 0x3d2c)
pat4244024.appendix_b_5(cx, 0x3d4b)
pat4244024.appendix_b_7(cx, 0x3df0)
pat4244024.appendix_b_8(cx, 0x3e02)
pat4244024.appendix_b_9(cx, 0x3e13)
pat4244024.appendix_b_10(cx, 0x3e30)
pat4244024.appendix_b_11(cx, 0x3e4a)
pat4244024.appendix_b_12(cx, 0x3e6c)
pat4244024.appendix_b_13(cx, 0x3e78)
pat4244024.appendix_b_15(cx, 0x3e86)
pat4244024.appendix_b_16(cx, 0x3ebc)
pat4244024.appendix_b_17(cx, 0x3ebf)
pat4244024.appendix_b_18(cx, 0x3ec2)
pat4244024.appendix_b_21(cx, 0x3a35)
pat4244024.appendix_b_28a(cx, 0x0020)
pat4244024.appendix_b_28b(cx, 0x0200)
if True:
for a in range(0x3ef, 0x40a):
data.Const(cx.m, a, a + 1)
y = wgstring(cx.m, cx.m[a])
y.compact = True
for a in range(0x1ebb, 0x1ec6):
data.Const(cx.m, a, a + 1)
y = wgstring(cx.m, cx.m[a])
y.compact = True
cx.disass(0x20)
code.lcmt_flows(cx.m)
return NAME, (cx.m,)
def square_tbl(asp):
for i in range(256):
x = asp[0x6e00 + i]
y = (i * i) & 0xff
assert x == y
x = asp[0x6f00 + i]
y = (i * i) >> 8
assert x == y
x = data.Data(asp, 0x6e00, 0x6f00, "TBL_6E00")
x.rendered = "FOR I (0..255):\n .BYTE ((I * I) & 0xff)"
x.compact = True
asp.set_label(0x6e00, "SQUARE_TBL_LO")
x = data.Data(asp, 0x6f00, 0x7000, "TBL_6F00")
x.rendered = "FOR I (0..255):\n .BYTE ((I * I) >> 8)"
x.compact = True
asp.set_label(0x6f00, "SQUARE_TBL_HI")
def symb(cx, a, b):
if b[0] == '_':
cx.m.set_label(a, b[1:])
cx.disass(a)
elif b[0] == '#':
cx.m.set_label(a, b[1:])
y = data.Data(cx.m, a, a + 1)
y.rendered = ".CONST\t0x%04x" % cx.m[a]
else:
cx.m.set_label(a, b)
def switch(cx, lo, hi):
y = data.Data(cx.m, lo, hi)
y.fmt = ""
n = 0
for a in range(lo, hi, 2):
o = cx.m.bs16(a)
y.fmt += "[%d] -> 0x%x\n" % (n, lo + o)
cx.disass(lo + o)
cx.m.set_label(lo + o, "CASE_%x_%d" % (lo, n))
n += 1
def char_def(pj, a): for i in range(8): y = data.Data(pj, a + i, a + i + 1) x = pj.m[a + i] y.fmt = ".BITS\t" for j in range(8): if x & 0x80: y.fmt += "#" else: y.fmt += "-" x = x << 1
def wordtable(self):
self.lang.m.set_label(self.hi, self.nm + '_TAB')
hh = self.hi
for j in range(self.low, self.high + 1):
o = self.lang.m.bs16(hh) + self.hi
self.dst(self.lang, j, o)
y = data.Data(self.lang.m,
hh,
hh + 2,
fmt=self.nm + '_TAB[%d] = 0x%x' % (j, o))
hh = y.hi
def tblx(a):
c = data.Data(cx.m, a, a + 16, "tblx")
s = ""
for i in range(10):
v = cx.m[a + i]
s += " %02x" % v
s += " "
for i in range(10, 16):
v = cx.m[a + i]
s += " %02x" % v
c.rendered = "TBLX " + s
c.compact = True
def switchblock_16(adr, nswitch, lang):
asp = lang.m
nswitch += 1
tl = (nswitch * 2 + 3) & ~3
a = adr
txt = ''
for i in range(nswitch):
o = asp.lu16(a) * 4
d = adr + 4 + o
asp.set_label(d, "switch_0x%x_%d" % (adr, i))
lang.disass(d)
txt += '[%d] .+0x%x (0x%x)\n' % (i, o, d)
a += 2
y = data.Data(asp, adr, adr + tl, fmt=txt)
def __init__(self, cx, lo, **kwargs):
super().__init__(cx, lo, **kwargs)
b = lo + 5
for i in range(16):
y = Relptr(cx.m, b, "NamLen=%d" % (i + 1))
b = y.hi
y = Relptr(cx.m, b, "End")
b = y.hi
e = y.dst
h = {}
while b < e:
x = cx.m.le(b, 2)
c = b + 2
t = text(cx.m, c, x)
h[b] = t
c += 2 * x
z = cx.m.le(c, 3)
c += 3
y = data.Data(cx.m, b, c)
y.rendered = ".NAME\t0x%03x, 0x%x, '%s'" % (z, x, t)
y.compact = True
b = c
self.names = {}
n = 0
y = data.Data(cx.m, b, self.hi)
r = []
while b < self.hi:
x = cx.m.le(b, 5)
if x:
nm = h[b - x]
self.names[n] = nm
r.append(".IDX\t0x%03x: '%s'" % (n, nm))
n += 1
b += 5
y.rendered = "\n".join(r)
y.compact = True
assert b == self.hi
def data_float(pj, a): y = data.Data(pj, a, a + 4) x = pj.m.bu32(a) e = x & 0xff if e & 0x80: e -= 0x100 m = x >> 8 s = m >> 23 m &= 0x7fffff y.val = m * (2.0 ** (e - 22.0)) if s: y.val *= -1 y.fmt = ".FLOAT\t%g" % y.val y.lcmt = "s=%d m=0x%06x e=%d" % (s,m,e) return y
def __init__(self, cx, lo, **kwargs):
super().__init__(cx, lo, **kwargs)
y = Const(cx.m, lo + 5, 5, "Rows")
b = y.hi
self.rows = y.val
y = Const(cx.m, b, 5, "Cols")
b = y.hi
self.cols = y.val
if self.rows and self.cols:
b2, bm = do_bitmap(cx.m, b, self.cols, self.rows)
y = data.Data(cx.m, b, b2)
y.rendered = str(bm)
y.compact = True
def arg_range(cx, cmds, start, end):
x = cx.m.add_range(start, end, txt="ARG_RANGE")
cx.m.set_label(start, "ARG_RANGE")
l = list()
n = 0
for a in range(start, end, 2):
c = cmds[n]
n += 1
lo = cx.m[a]
hi = cx.m[a + 1]
x = data.Data(cx.m, a, a + 2, "byte")
x.rendered = ".BYTE\t0x%02x, 0x%02x" % (lo, hi)
x.lcmt = c + "[%d" % lo + "-%d]" % hi
for j in range(lo, hi + 1):
l.append(c + "%d" % j)
for j in cmds[n:]:
l.append(j)
return l
def data_float(asp, a):
y = DATA.get(a)
if not y:
y = data.Data(asp, a, a + 4)
x = asp.bu32(a)
e = x & 0xff
if e & 0x80:
e -= 0x100
m = x >> 8
s = m >> 23
m &= 0x7fffff
y.val = m * (2.0**(e - 22.0))
if s:
y.val *= -1
y.fmt = ".FLOAT\t%g" % y.val
y.lcmt = "s=%d m=0x%06x e=%d" % (s, m, e)
DATA[a] = y
return y
def from_asp(self, asp, lo, wfunc=None, render=True):
''' Read record from address-space '''
if not wfunc:
wfunc = asp.lu16
while not asp[lo]:
lo += 1
self.lo = lo
for i in range(6):
self.words.append(wfunc(lo))
lo += 2
for i in range(self.words[1], 65536):
self.words.append(wfunc(lo))
lo += 2
if sum(self.words) & 0xffff:
raise Exception("Checksum error")
self.hi = lo
if render:
y = data.Data(asp, self.lo, self.hi)
y.rendered = self.relrec()
y.compact = True
if self.words[0] == 7:
y.lcmt = b40(self.words[6:8])
return self, lo
def assy_dst(self, cde=True):
a = self['adr']
if a & 0x200:
a -= 0x400
if self['c']:
a += self.lo
dd = (a + (1 << 16)) & 0x7fff
if not self['d']:
if cde:
self.dstadr = dd
return assy.Arg_dst(self.lang.m, dd)
try:
d = self.lang.m[dd]
y = data.Data(self.lang.m, dd, dd + 1)
y.rendered = ".REF\t0x%04x" % d
if cde:
self.dstadr = d
return [assy.Arg_dst(self.lang.m, d), assy.Arg_verbatim("[Via 0x%04x]" % dd)]
except mem.MemError:
pass
if cde:
self.dstadr = dd
return [assy.Arg_dst(self.lang.m, dd), assy.Arg_verbatim("I")]
def __init__(self, cx, lo, **kwargs):
super().__init__(cx, lo, **kwargs)
b = self.lo + 5
self.ny = cx.m.le(b, 2)
b += 2
self.nx = cx.m.le(b, 2)
b += 2
self.sx = self.nx // 4
fbuf = []
while b < self.hi:
cmd = cx.m.le(b, 2)
b += 2
if cmd & 0x80:
fbuf += [cx.m[b]] * (cmd - 0x7f)
b += 1
else:
while cmd >= 0:
fbuf.append(cx.m[b])
b += 1
cmd -= 1
bm = bitmap.BitMap(self.nx, self.ny)
for i, n in enumerate(fbuf):
i *= 4
y = i // self.nx
x = i % self.nx
for b in (1, 2, 4, 8):
if n & b:
bm.set(x ^ 4, y)
x += 1
y = data.Data(cx.m, self.lo + 5, self.hi)
y.rendered = ".RLLBITMAP\n" + str(bm)
y.compact = True
def example():
m = mem.Stackup(
FILENAMES,
nextto=__file__,
)
cx = mc6800.mc6800()
cx.m.map(m, 0x6800)
nmi = m.bu16(m.hi - 4)
print("NMI %x" % nmi)
cx.m.map(m, 0x8000 | nmi, 0x10000, offset=nmi - 0x6800)
for a, l in SYMBOLS.items():
cx.m.set_label(a, l)
def rom(lo, hi):
cx.m.add_range(lo, hi, txt="ROM")
s = 0
for a in range(lo, hi):
s += cx.m[a]
s &= 0xff
if s == 0:
print("ROM %04x-%04x sum good (%02x)" % (lo, hi, s))
else:
print("ROM %04x-%04x sum BAD (%02x)" % (lo, hi, s))
rom(0x6800, 0x7000)
rom(0x7000, 0x7800)
rom(0x7800, 0x8000)
for i in (0x6fff, 0x77ff, 0x7ff7):
c = data.Data(cx.m, i, i + 1, "csum")
c.rendered = c.tag
cx.vectors()
def jmptbl(lo, hi, x=None):
c = cx.m.add_range(lo, hi, txt="jmptbl (%04x-%04x)" % (lo, hi))
# c.rendered = c.tag
n = 0
for a in range(lo, hi, 2):
y = cx.codeptr(a)
if x != None and len(x) > n:
cx.m.set_label(y.dst, "CMD_" + x[n])
n += 1
jmptbl(0x7768, 0x77b6, '9876543210.-@ABCDEFGHIJKLMNOPQRSTUVWXYZ')
jmptbl(0x7860, 0x787c)
jmptbl(0x78a0, 0x78bc)
jmptbl(0x78c0, 0x78dc)
#######################################################################
def tblx(a):
c = data.Data(cx.m, a, a + 16, "tblx")
s = ""
for i in range(10):
v = cx.m[a + i]
s += " %02x" % v
s += " "
for i in range(10, 16):
v = cx.m[a + i]
s += " %02x" % v
c.rendered = "TBLX " + s
c.compact = True
for a in range(0x7000, 0x70a0, 16):
tblx(a)
for a in range(0x7100, 0x71a0, 16):
tblx(a)
#######################################################################
seven_segment.table(cx.m,
0x7800,
0x7810,
drive=(128, 64, 32, 16, 8, 4, 2, 1, 0),
inv=True,
verbose=False)
return NAME, (cx.m, )
def example():
m = mem.Stackup((FILENAME,), nextto=__file__)
cx = mcs51.I8032()
cx.m.map(m, 0)
cx.disass(0xb)
cx.vectors(which=("RESET", "TF0"))
cx.disass(0x600)
for a, b in SYMBOLS.items():
cx.m.set_label(a, b)
for a, b in BIT_SYMBOLS.items():
cx.as_bit.set_label(a, b)
for a, b in DATA_SYMBOLS.items():
cx.as_data.set_label(a, b)
cx.m.set_line_comment(0xa31, "Mask Left/Right Buttons")
cx.m.set_line_comment(0xa47, "Mask Left/Right Buttons")
cx.m.set_line_comment(0xa67, "Mask Dials")
for i in range(0, 0x18, 8):
data.Txt(cx.m, 0x0a2 + i, 0x0a2 + i + 0x08, label=False)
for i in range(0, 0x18, 8):
data.Txt(cx.m, 0x78a + i, 0x78a + i + 0x08, label=False)
#######################################################################
def cmd_func(a1, a2, n):
cx.m.set_label(a1, "DO_CMD%d" % n)
a = a2
while True:
if cx.m[a] != 0xb4:
break
c = cx.m[a + 1]
d = cx.m[a + 2]
cx.m.set_label(a, "CMD%d_%02x" % (n, c))
a += 3 + d
cmd_func(0xbf3, 0xbf7, 1)
cmd_func(0x823, 0x827, 2)
cmd_func(0x84f, 0x851, 3)
#######################################################################
#######################################################################
for a in range(0xba, 0x100, 2):
x = data.Const(cx.m, a, a + 2)
x.typ = ".WORD"
x.val = cx.m.lu16(a)
x.fmt = "0x%04x" % x.val
#######################################################################
x = data.Data(cx.m, 0x100, 0x600, "chargen")
x.rendered = "*CHARGEN*"
x.compact = True
cs = chargen.SVG_Charset(
fn="/tmp/" + NAME + "_charset.svg",
char_w = 5,
char_h = 7,
imargin = 1,
)
for n in range(0x100):
ll = [0] * 7
for i in range(7):
for j in range(5):
ll[6-i] |= ((cx.m[0x100 + j * 0x100 + n] >> i) & 1) << (4-j)
cs.set_char(n // 16, n % 16, ll)
cs.render()
#######################################################################
return NAME, (cx.m,)
def task(pj, cx):
cx.register_labels(pj)
cx.vectors(pj)
def cbyte(pj, a):
c = data.Const(pj, a, a + 1)
c.val = pj.m.rd(a)
c.typ = ".BYTE"
c.fmt = "0x%02x" % c.val
return c
def cword(pj, a):
c = data.Const(pj, a, a + 2)
c.val = pj.m.bu16(a)
c.typ = ".WORD"
c.fmt = "0x%04x" % c.val
return c
class d_chain(data.Data):
def __init__(self, pj, a):
super(d_chain, self).__init__(pj, a, a + 4)
self.num = '%c%c%c' % (
pj.m.rd(self.lo),
pj.m.rd(self.lo + 1),
pj.m.rd(self.lo + 2),
)
def render(self, pj):
return ".STRUCT chain { '%c%c%c', %d }" % (
pj.m.rd(self.lo),
pj.m.rd(self.lo + 1),
pj.m.rd(self.lo + 2),
pj.m.rd(self.lo + 3),
)
class d_asf(data.Data):
def __init__(self, pj, a):
super(d_asf, self).__init__(pj, a, a + 16)
def render(self, pj):
s = ".STRUCT asf {"
t = " "
for i in range(0, 16, 2):
s += t + "%6d" % pj.m.bu16(self.lo + i)
t = ", "
s += "}"
return s
class d_q(data.Data):
"""
Numbers are sign + 31 bit binary q-complement fractions:
[Sign][31 bit fraction]
"""
def __init__(self, pj, a, lbl=True):
if pj.find(a, ".D4") != None:
return
super(d_q, self).__init__(pj, a, a + 4, ".D4")
self.val = pj.m.bu32(a)
self.dec = self.val
if self.dec & 0x80000000:
self.dec &= 0x7fffffff
self.dec *= -1
self.dec *= 2**-31
if lbl:
pj.set_label(self.lo, "Q_%04x_%g" % (self.lo, self.dec))
def render(self, pj):
if self.dec != 0.0:
b = 1.0 / self.dec
else:
b = 0.
return ".D4 %12g = 1/%g" % (self.dec, b)
#######################################################################
led_map = [1, 2, 4, 128, 64, 16, 32, 8, 0]
seven_segment.table(pj, 0xecb4, 0xecd4, map=led_map, verbose=False)
pj.set_label(0xecb4, "7SEG_TBL")
LED_lbl = {
0xf94d: "_PL-99___LORAN-C",
0xf95d: "__Progr____PL-15",
0xf96d: "_Please___Choose",
0xf97d: "Lat-Lon___or_Gri",
0xf98d: "__L-L=4____Gri=7",
0xf99d: "Enter____Gri____",
0xf9ad: "Enter____Lat-Lon",
0xf9bd: "________________",
0xf9cd: "_Enter___Fn_no__",
0xf9dd: "_______A_Gri___0",
0xf9ed: "Search_A_Gri___0",
0xf9fd: "SAVE_in_____no__",
0xfa0d: "___no_______Fn__",
0xfa1d: "_________CAL____",
0xfa2d: "Enter______deg__",
0xfa3d: "8888888888888888",
0xfa4d: "Oscil___________",
0xfa5d: "__AREA____CHANGE",
0xfa6d: "__Pri=1____Alt=4",
0xfa7d: "_reset___spd_fil",
0xfa8d: "__speed___filter",
0xfa9d: "__slo_____15_set",
0xfaad: "regular___15_set",
0xfabd: "___fast___15_set",
0xfacd: "__slo=1____reg=2",
0xfadd: "_fast=3__A5_15=C",
0xfaed: "display_____no__",
0xfafd: "_Go_to______no__",
0xfb0d: "no_ASF___Entered",
0xfb1d: "__ASF____Entered",
0xfb2d: "CHANGE_____by__0",
0xfb3d: "Enter____ASF____",
0xfb4d: "Enter_______no__",
0xfb5d: "1_For0___2_For00",
0xfb6d: "Start_______no__",
0xfb7d: "__L-L=4____tds=7",
0xfb8d: "________________",
0xfb9d: "_fast____Average",
0xfbad: "regular__Average",
0xfbbd: "__Light_____on__",
0xfbcd: "__Light_____off_",
0xfbdd: "_dest_______no__",
0xfbed: "Select______no__",
0xfbfd: "__________Cntr__",
0xfc0d: "_____00__set_CL_",
0xfc1d: "_____00_____CL0C",
0xfc2d: "_____00__set_ttG",
0xfc3d: "_____00______ttG",
0xfc4d: "ASF______Entr___",
0xfc5d: "Arr_0____dist___",
0xfc6d: "Anchor______no__",
0xfc7d: "Anchor____dist__",
0xfc8d: "set_0____d55____",
0xfc9d: "Clr_cyc___Error_",
0xfcad: "__Plan______Fn__",
0xfcbd: "_CHANGE____Gri__",
0xfccd: "_Cold_____Start_",
0xfcdd: "reStart_________",
0xfced: "__YE5=1_____no=4",
0xfcfd: "reset____hot_t__",
0xfd0d: "reset____cold_t_",
0xfd1d: "__route_____no__",
0xfd2d: "__route_____no-_",
0xfd3d: "__Use=1__displ=4",
0xfd4d: "Pt___15___done=4",
0xfd5d: "__End=1___Cont=4",
0xfd6d: "speed____display",
0xfd7d: "_Crse=1___Grnd=4",
0xfd8d: "set_brg___corr=0",
0xfd9d: "_Seed____Lat-Lon",
0xfdad: "_Output__data_on",
0xfdbd: "_Output__dataoff",
0xfdcd: "_Auto=1____not=4",
0xfddd: "_Clear_____ASF__",
0xfded: "Input____OSC____",
0xfdfd: "___SELF_____TRAC",
}
for a in range(0xf94d, 0xfdfe, 16):
c = seven_segment.table(pj, a, a + 16, map=led_map, verbose=False)
t = LED_lbl.get(a)
assert t != None
if t == None:
# Try to construct a string ourselves...
t = ""
for i in c:
if i == None:
t += "?"
elif len(i) == 1:
t += i
elif i == "blank":
t += "_"
else:
t += "?"
pj.set_label(a, "MSG_" + t)
#######################################################################
def post_arg_func(pj, ins):
post_arg_funcs = {
0xb80c: "WB",
0xb821: "WB",
0xb836: "W",
0xb846: "WWW",
0xb86c: "WWW",
0xb892: "WWW",
0xb989: "WWW",
0xbabc: "WW",
0xbb60: "WWW",
0xbca1: "WWW",
0xbdeb: "WW",
}
for f in ins.flow_out:
i = post_arg_funcs.get(f.to)
if i == None:
continue
ins.flow_out = []
ins.add_flow(pj, "C", True, f.to)
a = ins.hi
for j in i:
if j == "W":
d = pj.m.bu16(a)
data.Dataptr(pj, a, a + 2, d)
a += 2
if d >= 0x8000:
d_q(pj, d)
elif j == "B":
cbyte(pj, a)
# data.Data(pj, a, a + 1)
a += 1
else:
assert False
ins.add_flow(pj, ">", True, a)
return
cx.flow_check.append(post_arg_func)
#######################################################################
def bogo_flow(pj, ins):
for f in ins.flow_out:
if f.to == None:
pass
elif f.to < 0x8000 or f.to > 0xffff:
print("BOGO", ins)
cx.flow_check.append(bogo_flow)
#######################################################################
chains = []
x = pj.add(0x9d20, 0x9d68, "chain-tbl")
pj.set_label(x.lo, "CHAINS")
for a in range(x.lo, x.hi, 4):
chains.append("GRI_" + d_chain(pj, a).num + "0")
"""
This is probably ASF data
(Based partially on number of records = 204)
"""
x = pj.add(0x9d68, 0xaa28, "asf-tbl")
for a in range(x.lo, x.hi, 16):
d_asf(pj, a)
# ON_KEY table
x = pj.add(0xe072, 0xe0e2, "on-key-tbl")
pj.set_label(x.lo, "ON_KEY_TBL")
n = 0x80
for a in range(x.lo, x.hi, 2):
x = cx.codeptr(pj, a)
pj.set_label(x.dst, "ON_KEY_0x%02x" % n)
n += 1
# CMD table
x = pj.add(0x9b81, 0x9bff, "cmd-tbl")
pj.set_label(x.lo, "CMDTBL")
for a in range(x.lo, x.hi, 3):
y = data.Txt(pj, a, a + 1, label=False)
z = cx.codeptr(pj, a + 1)
if y.txt == " ":
pj.set_label(z.dst, "CMD_SP")
else:
pj.set_label(z.dst, "CMD_%s" % y.txt)
# FN table
x = pj.add(0xf885, 0xf94d, "fn-tbl")
pj.set_label(x.lo, "FN_TBL")
d = dict()
n = 0
for a in range(x.lo, x.hi, 2):
y = cx.codeptr(pj, a)
if not y.dst in d:
d[y.dst] = []
d[y.dst].append(n)
n += 1
for i in d:
e = d[i]
if len(e) == 1:
pj.set_label(i, "FN_%02d" % e[0])
elif len(e) > 10:
pj.set_label(i, "FN_UNDEF")
else:
pj.set_label(i, "FN_%02d_%02d" % (e[0], e[-1]))
def longitude(pj, a):
"""
This gives values closely matching table values
"""
x = d_q(pj, a, lbl=False)
s = ""
v = x.dec * 180.
if v < 0:
v *= -1
s += "W"
v = 180. - v
else:
s += "E"
deg = v.__trunc__()
v -= deg
s += "%4d" % deg
v *= 60
mi = v.__trunc__()
v -= mi
s += " %2d'" % mi
v *= 60
s += ' %2.3f"' % v
x.lcmt = s
return x
def lattitude(pj, a):
"""
This calculation is not quite right.
"""
x = d_q(pj, a, lbl=False)
s = ""
v = x.dec * 90.
v = 108 - v
if v < 0:
v *= -1
s += "S"
v = 180. - v
else:
s += "N"
deg = v.__trunc__()
v -= deg
s += "%4d" % deg
v *= 60
mi = v.__trunc__()
v -= mi
s += " %2d'" % mi
v *= 60
s += ' %2.3f"' % v
x.lcmt = s
return x
#
# Chain data, idx'ed by 0x9d20
#
x = pj.add(0xaa29, 0xb131, "tbl")
n = 0
for a in range(x.lo, x.hi, 100):
x = pj.add(a, a + 100, "chain-tbl")
pj.set_label(a, "CHAIN_" + chains[n])
x = cword(pj, a)
x.lcmt = "GRI %d * 5" % (x.val / 5)
#data.Data(pj, a, a + 100)
x = pj.add(a + 0x02, a + 0x02 + 5 * 4, "alpha-tbl")
x = pj.add(a + 0x16, a + 0x16 + 5 * 4, "beta-tbl")
x = pj.add(a + 0x2a, a + 0x2a + 5 * 4, "gamma-tbl")
for c in range(5):
d_q(pj, a + 0x02 + c * 4, lbl=False)
lat = lattitude(pj, a + 0x16 + c * 4)
lon = longitude(pj, a + 0x2a + c * 4)
x = pj.add(a + 0x3e, a + 0x3e + 4 * 4, "rho-tbl")
x = pj.add(a + 0x4e, a + 0x4e + 4 * 4, "sigma-tbl")
for c in range(4):
x = d_q(pj, a + 0x3e + c * 4, lbl=False)
x.lcmt = "%.3f us / 2^23" % (x.dec * 2**23)
d_q(pj, a + 0x4e + c * 4, lbl=False)
x = pj.add(a + 0x5e, a + 0x5e + 5, "epsilon-tbl")
for c in range(5):
cbyte(pj, a + 0x5e + c)
x = cbyte(pj, a + 99)
x.lcmt = "# slaves"
n += 1
for a in range(0xc2fe, 0xc38e, 4):
d_q(pj, a)
# idx into tbl at b156
# Chain data (18 pieces)
#
x = pj.add(0xb132, 0xb155, "tbl")
n = 0
for a in range(x.lo, x.hi, 2):
y = cword(pj, a)
y.lcmt = chains[n]
pj.set_label(0xb156 + y.val, "CHAIN_I_" + chains[n])
n += 1
x = pj.add(0xb156, 0xb43e, "tbl")
for a in range(x.lo, x.hi, 4):
#data.Data(pj, a, a + 4)
d_q(pj, a, lbl=False)
for a in range(0xc3a6, 0xc41e, 4):
d_q(pj, a)
for a in range(0x906f, 0x9087, 2):
c = cword(pj, a)
c.fmt = "%d" % c.val
x = pj.add(0x9d00, 0x9d20, "tbl")
x.lcmt += "accessed via 0x9cc2 pointer"
for a in range(x.lo, x.hi, 2):
c = cword(pj, a)
pj.todo(0x9102, cx.disass)
pj.todo(0x95da, cx.disass)
pj.todo(0x9b29, cx.disass)
pj.todo(0x9a96, cx.disass)
pj.todo(0x9b44, cx.disass)
pj.todo(0x9b57, cx.disass)
pj.todo(0xdda1, cx.disass)
pj.todo(0xdde0, cx.disass)
pj.todo(0xde00, cx.disass)
pj.todo(0xde20, cx.disass)
pj.todo(0xf719, cx.disass)
for a in range(0x9789, 0x97a5, 4):
d_q(pj, a)
for i in range(0xf220, 0xf226, 2):
data.Dataptr(pj, i, i + 2, pj.m.bu16(i))
cword(pj, i + 6)
#for i in range(0x89d8, 0x8a20, 2):
# data.Dataptr(pj, i, i + 2, pj.m.bu16(i))
for i in range(0xe363, 0xe369, 2):
x = cx.codeptr(pj, i)
x = pj.add(0xb963, 0xb975, "tbl")
for i in range(x.lo, x.hi):
cbyte(pj, i)
data.Data(pj, 0xca73, 0xca7c)
data.Data(pj, 0xec7c, 0xec81)
data.Data(pj, 0xec81, 0xec85)
data.Data(pj, 0xec85, 0xec8b)
data.Data(pj, 0xec8b, 0xec91)
d_q(pj, 0xcb70)
d_q(pj, 0xd4f5)
d_q(pj, 0xd4f9)
d_q(pj, 0xd4fd)
d_q(pj, 0xd501)
while pj.run():
pass
pj.set_label(0x6489, "CHAIN_PTR")
pj.set_label(0xb800, "MEMCPY(X, Y, B)")
pj.set_label(0xb80c, "SHR_Q")
pj.set_label(0xb821, "SHL_Q")
pj.set_label(0xb836, "COM_Q")
pj.set_label(0xb846, "ADD_Q")
pj.set_label(0xb86c, "SUB_Q")
pj.set_label(0xb892, "MUL_Q")
pj.set_label(0xec91, "7SEG_XLAT(0x66a9)")
pj.set_label(0xecaa, "7SEG_DIG(B)")
pj.set_label(0xecd4, "DISPLAY(Y)")
pj.set_label(0xf1a9, "DISPLAY_YES_NO(Y)")
pj.set_label(0xf1b7, "IS_YES()")
pj.set_label(0xf878, "PAUSE()")
pj.set_label(0xfe5c, "Analog_Capture")
pj.set_label(0xfe6e, "Capture_One_Analog")
pj.set_label(0xf9, "ON_KEY")
def example():
m = []
for fn, csum in FILES:
i = mem.Stackup(files=(fn,), nextto=__file__,)
assert sum(i.bytearray(i.lo, i.hi)) & 0xffff == csum
m.append(i)
charrom(m[3], m[4])
cpu = z80.z80()
cpu.m.map(m[0], 0x0000)
cpu.m.map(m[1], 0x4000)
cpu.m.map(m[2], 0xa000)
cpu.flow_check.append(fc)
for a, b in SYMBOLS.items():
cpu.m.set_label(a, b)
for a, b in IO_SYMBOLS.items():
cpu.as_io.set_label(a, b)
for a in range(0x3d, 0x60, 2):
x = cpu.codeptr(a)
cpu.m.set_line_comment(x.dst, "From tbl@0x003d")
for a in range(0x0700, 0x0728, 2):
x = cpu.codeptr(a)
cpu.m.set_line_comment(x.dst, "From tbl@0x0700")
for a in range(0x0800, 0x0810, 2):
x = cpu.codeptr(a)
cpu.m.set_line_comment(x.dst, "From tbl@0x0800")
for a in range(0x0900, 0x0908, 2):
x = cpu.codeptr(a)
cpu.m.set_line_comment(x.dst, "From tbl@0x0900")
for a in range(0xe00, 0xfa0, 2):
x = cpu.codeptr(a)
cpu.m.set_line_comment(x.dst, "From tbl@0x0e00")
for a in range(0x0810, 0x0900, 2):
x = cpu.dataptr(a)
y = data.Txt(cpu.m, x.dst, term=(0x81,), label=False)
x.lcmt = y.txt
for a in range(0x0a45, 0x0be3, 2):
x = cpu.dataptr(a)
y = data.Txt(cpu.m, x.dst, term=(0x80,), label=False)
x.lcmt = y.txt
for a in range(0x3bb1, 0x3bd1, 2):
x = cpu.dataptr(a)
cpu.m.set_label(x.dst, "KBD_%x" % a)
for i in range(29):
try:
y = data.Pstruct(cpu.m, x.dst + i * 5, "B" * 5, fmt=", ".join(["0x%02x"] * 5))
y.compact = True
except:
pass
hack(cpu, 0x264b)
a = 0xa51a
b = 0xa539
while cpu.m[a] != 0xff:
x = data.Pstruct(cpu.m, a, "BBB", fmt=", ".join(["0x%02x"] * 3))
a = x.hi
y = data.Txt(cpu.m, b, b + 0x1e, label=False)
b = y.hi
data.Const(cpu.m, a, a + 1)
x = data.Pstruct(cpu.m, 0x54a7, "B" * 12, fmt=", ".join(["0x%02x"] * 12))
x = data.Pstruct(cpu.m, 0xaddd, "B" * 12, fmt=", ".join(["0x%02x"] * 12))
x = data.Pstruct(cpu.m, 0xa392, "B" * 12, fmt=", ".join(["0x%02x"] * 12))
x = data.Pstruct(cpu.m, 0xa39e, "B" * 12, fmt=", ".join(["0x%02x"] * 12))
x = data.Pstruct(cpu.m, 0xacb0, "B" * 10, fmt=", ".join(["0x%02x"] * 10))
cpu.m.set_label(0xa2c4, "TestNames")
for a in range(0xa2c4, 0xa384, 0x10):
x = data.Txt(cpu.m, a, a + 0x10, label=False)
for a in range(0xade9, 0xae21, 7):
x = data.Txt(cpu.m, a, a + 0x7, label=True)
menu_desc(cpu, 0x7103)
menu_desc(cpu, 0x742b)
menu_desc(cpu, 0x7689)
for a, l in (
(0xa384, 0x7),
(0xa38b, 0x7),
(0xae21, 0xa),
(0xae2c, 0xc),
(0xae38, 0x7),
(0xae40, 0x9),
(0xae4a, 0xa),
(0xae54, 0xb),
(0xae5f, 0xf),
(0xae6f, 0x7),
(0xae76, 0xb),
(0xae81, 0x7),
):
x = data.Txt(cpu.m, a, a + l)
cpu.vectors(
(
"RESET",
"RST08",
"RST10",
"RST18",
"RST28",
"IRQ",
"NMI",
)
)
# switch_tbl(cpu.m, 0x0dc0, cpu)
switch_tbl(cpu.m, 0x32f8, cpu)
switch_tbl(cpu.m, 0x334a, cpu)
switch_tbl(cpu.m, 0x33c1, cpu)
switch_tbl(cpu.m, 0x5328, cpu)
switch_tbl(cpu.m, 0x5383, cpu)
switch_tbl(cpu.m, 0x53b9, cpu)
switch_tbl(cpu.m, 0x53a2, cpu)
switch_tbl(cpu.m, 0x53af, cpu)
for a in range(0x789b, 0x78bb, 2):
y = cpu.dataptr(a)
data.Txt(cpu.m, y.dst, term=(0x80,))
for a in (
0x7926,
0x7cf7,
0x7d03,
):
data.Txt(cpu.m, a, term=(0x80,))
if False:
# See 0x43cc
for a in range(0x3d, 0x58, 2):
y = cpu.codeptr(a)
cpu.m.set_line_comment(y.dst, "MANUAL from tbl@0x3c")
if False:
# See 0x493e
for a in range(0x800, 0x900, 2):
y = cpu.codeptr(a)
cpu.m.set_line_comment(y.dst, "MANUAL from tbl@0x800")
data.Pstruct(cpu.m, 0x89, "2B", fmt=", ".join(["0x%02x"] * 2))
for a in range(0x524, 0x56c, 4):
data.Pstruct(cpu.m, a, "4B", fmt=", ".join(["0x%02x"] * 4))
for a, b in (
(0x008b, "via IY"),
(0x04f6, "via IY"),
(0x0506, "via IY"),
(0x0518, "via IY"),
(0x0fc7, "via xfa0"),
(0x0fe5, "via xfa0"),
(0x1006, "via xfa0"),
(0x1397, None),
(0x5c03, "via 0xc296"),
(0x5df9, "via 0xc296"),
(0x5e25, "via 0xc296"),
(0x5ecb, "via 0xc296"),
(0x5f7f, "via 0xc296"),
(0x5fbc, "via 0xc296"),
(0xac5a, None),
(0xb800, None),
(0xb874, "via 0xc1da ptr"),
(0xb8db, "via 0xc1d8 ptr"),
(0xb8e2, "via 0xc1d8 ptr"),
(0xb8e9, "via 0xc1d8 ptr"),
(0xb8f0, "via 0xc1d8 ptr"),
(0xb8f7, "via 0xc1d8 ptr"),
(0xb844, None),
(0x3916, "via 0xcf58 ptr"),
(0x3936, "via 0xcf58 ptr"),
(0x3948, "via 0xcf58 ptr"),
(0x39d8, "via 0xcf58 ptr"),
):
cpu.disass(a)
if not b:
b = "MANUAL"
cpu.m.set_line_comment(a, b)
y = data.Data(cpu.m, 0x4707, 0x4707 + 0x15e)
if False:
discover.Discover(cpu)
return NAME, (cpu.m,)
def misc_stuff(cx):
for a in range(0xc2fe, 0xc38e, 4):
d_q(cx.m, a)
# idx into tbl at b156
# Chain data (18 pieces)
#
x = cx.m.add_range(0xb132, 0xb155, txt="tbl")
n = 0
for a in range(x.lo, x.hi, 2):
y = cword(cx.m, a)
y.lcmt = CHAINS[n]
cx.m.set_label(0xb156 + y.val, "CHAIN_I_" + CHAINS[n])
n += 1
x = cx.m.add_range(0xb156, 0xb43e, txt="tbl")
for a in range(x.lo, x.hi, 4):
#data.Data(cx.m, a, a + 4)
d_q(cx.m, a, lbl=False)
for a in range(0xc3a6, 0xc41e, 4):
d_q(cx.m, a)
for a in range(0x906f, 0x9087, 2):
c = cword(cx.m, a)
c.fmt = "%d" % c.val
x = cx.m.add_range(0x9d00, 0x9d20, txt="tbl")
cx.m.set_line_comment(x.lo, "accessed via 0x9cc2 pointer")
for a in range(x.lo, x.hi, 2):
c = cword(cx.m, a)
cx.disass(0x9102)
cx.disass(0x95da)
cx.disass(0x9b29)
cx.disass(0x9a96)
cx.disass(0x9b44)
cx.disass(0x9b57)
cx.disass(0xdda1)
cx.disass(0xdde0)
cx.disass(0xde00)
cx.disass(0xde20)
cx.disass(0xf719)
for a in range(0x9789, 0x97a5, 4):
d_q(cx.m, a)
for i in range(0xf220, 0xf226, 2):
data.Dataptr(cx.m, i, i + 2, cx.m.bu16(i))
cword(cx.m, i + 6)
#for i in range(0x89d8, 0x8a20, 2):
# data.Dataptr(cx.m, i, i + 2, cx.m.bu16(i))
for i in range(0xe363, 0xe369, 2):
x = cx.codeptr(i)
x = cx.m.add_range(0xb963, 0xb975, txt="tbl")
for i in range(x.lo, x.hi):
cbyte(cx.m, i)
data.Data(cx.m, 0xca73, 0xca7c)
data.Data(cx.m, 0xec7c, 0xec81)
data.Data(cx.m, 0xec81, 0xec85)
data.Data(cx.m, 0xec85, 0xec8b)
data.Data(cx.m, 0xec8b, 0xec91)
d_q(cx.m, 0xcb70)
d_q(cx.m, 0xd4f5)
d_q(cx.m, 0xd4f9)
d_q(cx.m, 0xd4fd)
d_q(cx.m, 0xd501)
def task(pj, cpu):
# Where ?
# y = data.Const(pj, 0xfffe, 0x10000)
# pj.set_label(y.lo, "eprom_lo_chksum")
y = data.Const(pj, 0x19854, 0x19856)
pj.set_label(y.lo, "eprom_hi_chksum")
###############################################################
###############################################################
# Functions taking arguments after call instruction
post_arg = {
0x1bc8: ("BCD_CMP", "brel", "D01"),
0x1bcc: ("BCD_CMP", "babs", "D01"),
0x1bd0: ("BCD_CMP", "bA6rel", "D01"),
0x1bdc: ("BCD_CMP", "D01", "babs"),
0x1be0: ("BCD_CMP", "D01", "bA6rel"),
0x1c52: ("BCD_ADD", "brel", "D01"),
0x1c56: ("BCD_ADD", "babs", "D01"),
0x1c5a: ("BCD_ADD", "bA6rel", "D01"),
0x1c5e: ("BCD_ADD", "stk", "D01"),
0x1c76: ("BCD_SUB", "brel", "D01"),
0x1c7a: ("BCD_SUB", "babs", "D01"),
0x1c7e: ("BCD_SUB", "bA6rel", "D01"),
0x1c88: ("BCD_SUB", "brel", "D01"),
0x1c8c: ("BCD_SUB", "babs", "D01"),
0x1c90: ("BCD_SUB", "bA6rel", "D01"),
0x1ccc: ("", "dabs", "FPXXX"),
0x2218: ("BCD_LD_D01", "bcd"),
0x223c: ("BCD_LD_D23", "bcd"),
0x238e: ("", "drel", "FPXXX"),
0x239a: ("", "dA6rel", "FPXXX"),
0x23f6: ("", "drel", "FPXXX"),
0x2402: ("", "D0+D1", "dA6rel"),
0x24ac: ("", "drel", "FPXXX"),
0x24b8: ("", "dA6rel", "FPXXX"),
0x24c4: ("", "drel", "FPXXX"),
0x25b0: ("", "drel", "FPXXX"),
0x25c8: ("", "drel", "FPXXX"),
0x25fa: ("", "dA6rel", "FPXXX"),
0x27ee: ("", "lrel", "FPXXX"),
0x2862: ("", "lrel", "LFXXX"),
0x28c2: ("", "lrel", "LFXXX"),
0x28ce: ("", "fabs", "LFXXX"),
0x297c: ("", "fA6rel", "LFXXX"),
0x2982: ("", "fabs", "LFXXX"),
0x2988: ("", "frel", "FFXXX"),
0x29ba: ("", "fA6rel", "LFXXX"),
0x29c6: ("", "frel", "FFXXX"),
0x29ea: ("", "fA6rel", "LFXXX"),
0x29f6: ("", "frel", "FFXXX"),
0x2a02: ("", "fA6rel", "LFXXX"),
0x2a0e: ("", "frel", "FFXXX"),
0x2a34: ("", "frel", "FFXXX"),
0x2a6e: ("", "frel", "FFXXX"),
0x2b08: ("", "fA6rel", "LFXXX"),
0x2b14: ("", "frel", "FFXXX"),
0x2b2c: ("", "frel", "FFXXX"),
}
for i in post_arg:
j = post_arg[i]
if len(j) > 0 and j[0] != "":
pj.set_label(i, j[0])
def flow_post_arg(pj, ins):
z = post_arg.get(ins.dstadr)
if z == None:
return
ins.flow_out.pop(-1)
if len(z) <= 1:
a = data.Pstruct(pj, ins.hi, ">h", "%d", ".INFIX").hi
ins.add_flow(pj, ">", True, a)
return
l = []
for i in z[1:]:
if i[1:] == "A6rel":
r = pj.m.bs16(ins.hi)
ins.hi += 2
if r < 0:
l.append("(A6-0x%x)" % -r)
else:
l.append("(A6+0x%x)" % r)
elif i[1:] == "abs":
r = pj.m.bu16(ins.hi)
if r & 0x8000:
r |= 0xffff0000
ins.hi += 2
l.append("0x%08x" % r)
elif i == "drel":
r = ins.hi + pj.m.bs16(ins.hi)
ins.hi += 2
ins.lcmt += " @0x%x\n" % r
y = data_double(pj, r)
l.append("%g" % y.data[0])
elif i == "brel":
r = ins.hi + pj.m.bs16(ins.hi)
ins.hi += 2
ins.lcmt += " @0x%x\n" % r
y = data_bcd(pj, r);
l.append("%x" % y.data[0])
elif i == "lrel":
r = ins.hi + pj.m.bs16(ins.hi)
ins.hi += 2
ins.lcmt += " @0x%x\n" % r
y = data.Pstruct(pj, r, ">L", "%d", ".LONG")
l.append("%d" % y.data[0])
elif i == "frel":
r = ins.hi + pj.m.bs16(ins.hi)
ins.hi += 2
ins.lcmt += " @0x%x\n" % r
y = data_float(pj, r)
l.append("%g" % y.val)
elif i == "bcd":
r = pj.m.bu16(ins.hi)
y = data.Pstruct(pj, ins.hi, ">H", "%x", ".BCD")
l.append("%04x" % r)
ins.hi += 2
else:
l.append(i)
ins.oper.append(assy.Arg_verbatim(pj, "(" + ",".join(l) + ")"))
ins.add_flow(pj, True, True, ins.hi)
cpu.flow_check.append(flow_post_arg)
###############################################################
switches = {
0x13624: {
0: "ALL",
1: "ONEOS",
2: "ONSWP",
3: "TRMATH",
},
}
def flow_switch(pj, ins):
if ins.dstadr != 0x2f38:
return
ins.flow_out.pop(0)
ins.add_flow(pj, ">", "?", ins.hi)
pj.set_label(ins.hi, "break_%04x" % ins.lo)
y = data.Const(pj, ins.lo - 2, ins.lo)
ncase = pj.m.bu16(ins.lo - 2)
y.typ = ".NCASE"
y.fmt = "%d" % ncase
cs = switches.get(ins.lo)
if cs == None:
cs = {}
a = ins.lo - 2
for i in range(ncase):
a -= 2
ct = cs.get(i)
if ct == None:
ct = "_%d" % i
w = data.Const(pj, a, a + 2)
z = pj.m.bs16(a)
w.typ = ".CASE"
w.fmt = "0x%x, %d" % (i,z)
w.fmt += ", 0x%04x" % (ins.hi + z)
ins.add_flow(pj, ">", "0x%x" % i, ins.hi + z)
if z < 0:
pj.set_label(ins.hi + z, ".case_%04x_%s" % (ins.lo, ct))
cpu.flow_check.append(flow_switch)
pj.todo(0x2f38, cpu.disass)
###############################################################
keyboard = (
# Row, Column, Text
( 0, 0, "HZ_UV_USEC"),
( 0, 3, "MHZ_DBM_SEC"),
( 0, 5, "BACK_SPACE"),
( 0, 6, "KHZ_MV_MSEC"),
( 1, 0, "SAVE"),
( 1, 1, "RECALL"),
( 1, 2, "HOLD"),
( 1, 4, "0_1_5_GHZ"),
( 1, 6, "POINT"),
( 1, 7, "GHZ_DBM_DB"),
( 2, 0, "DIG_0"),
( 2, 1, "DIG_1"),
( 2, 2, "DIG_2"),
( 2, 3, "DIG_3"),
( 2, 4, "DIG_4"),
( 2, 5, "DIG_5"),
( 2, 6, "DIG_6"),
( 2, 7, "DIG_7"),
( 3, 0, "DIG_8"),
( 3, 1, "DIG_9"),
( 3, 4, "INPUT_1"),
( 3, 5, "FREQ_COUNT"),
( 3, 6, "INPUT_1"),
( 4, 1, "AUTO_RES_BW"),
( 4, 2, "AUTO_VIDEO_BW"),
( 4, 3, "AUTO_SWEEP_TIME"),
( 4, 4, "AUTO_ATTEN"),
( 4, 5, "AUTO_CF_STEP"),
( 4, 6, "RES_BW"),
( 4, 7, "VIDEO_BW"),
( 5, 0, "SWEEP_TIME"),
( 5, 1, "ATTEN"),
( 5, 2, "CF_STEP"),
( 5, 3, "PEAK_SEARCH"),
( 5, 4, "MARKER_OFF"),
( 5, 5, "MARKER_NORMAL"),
( 5, 6, "MARKER_CF"),
( 5, 7, "MARKER_DELTA"),
( 6, 0, "ZOOM"),
( 6, 1, "MKR_DELTA_STP_SIZE"),
( 6, 2, "MKR_REF_LVL"),
( 6, 3, "SIGNAL_TRACK"),
( 6, 4, "DOWN"),
( 6, 5, "UP"),
( 6, 6, "CENTER_FREQ"),
( 6, 7, "FREQ_SPAN"),
( 7, 0, "START_FREQ"),
( 7, 1, "STOP_FREQ"),
( 7, 2, "REF_LEVEL"),
( 8, 0, "NORMAL"),
( 8, 1, "CLEAR_A"),
( 8, 2, "MAX_A"),
( 8, 3, "OFF_A_B"),
( 8, 4, "VIEW_A"),
( 8, 5, "BLANK_A"),
( 8, 6, "A_B"),
( 8, 7, "CLEAR_B"),
( 9, 0, "MAX_B"),
( 9, 1, "A_EX_B"),
( 9, 2, "VIEW_B"),
( 9, 3, "BLANK_B"),
( 9, 4, "B-DL-B"),
( 9, 5, "LINE_OFF"),
( 9, 6, "LINE_ENTER"),
( 9, 7, "THRSH_OFF"),
( 10, 0, "THRSH_ENTER"),
( 10, 1, "ENTER_DB"),
( 10, 2, "LIN"),
( 10, 3, "SHIFT"),
( 10, 4, "CONT"),
( 10, 5, "SINGLE"),
( 10, 6, "TRIG_FREE_RUN"),
( 10, 7, "TRIG_LINE"),
( 11, 0, "TRIG_EXT"),
( 11, 1, "TRIG_VIDEO"),
( 11, 2, "LOWER_LEFT"),
( 11, 4, "LOWER_RIGHT"),
)
keynos = {}
for r,c,t in keyboard:
n = 0x20 + r * 8 + c
keynos[n] = t
###############################################################
class params(data.Data):
def __init__(self, pj, nm, i, j):
self.nm = nm
self.b = 0x195c4
self.i = i
self.j = j
self.fi = pj.m.rd(self.b + i)
self.args = []
for a in range(j):
self.args.append(pj.m.rd(self.b + i + 1 + a))
super(params, self).__init__(pj, self.b + i, self.b + i + 1 + j)
self.fp = 0x196b6 + self.fi * 4
self.fa = pj.m.bu32(self.fp)
pj.todo(self.fa, cpu.disass)
data.Codeptr(pj, self.fp, self.fp + 4, self.fa)
pj.set_label(self.fa, "F_" + nm + "(" + self.summ() + ")")
def render(self, pj):
t = ".PARAM\t"
t += "func=%d" % self.fi
t += " call=%s" % self.nm
t += "(" + self.summ() + ")"
return t
def summ(self):
t = []
for i in self.args:
if i == 0x03:
t.append("STR")
elif i == 0x16:
t.append("int")
elif i == 0x18:
t.append("INT")
elif i == 0x19:
t.append("REAL")
else:
t.append("0x%02x" % i)
return ",".join(t)
def funcidx(self):
return self.fi
class mnem(data.Data):
def __init__(self, pj, hi):
lo = hi
lo -= 2
self.c = pj.m.bu16(lo)
lo -= 2
self.b = pj.m.bu16(lo)
lo -= 2
self.a = pj.m.bu16(lo)
self.len = self.c & 0xfff
self.type = self.c >> 12
lo -= (self.len + 1) & 0xffe
super(mnem, self).__init__(pj, lo, hi)
self.compact = True
a,b,c = data.stringify(pj, self.lo, self.len)
self.string = b
self.hash = 0
for i in bytearray(self.string, 'ascii'):
self.hash += i
self.hash %= 13
self.pp = None
self.args = None
if self.type == 3:
self.pp = params(pj, self.string, self.b, self.a >> 8)
if self.type == 1:
if self.b not in keynos:
keynos[self.b] = "CMD_" + self.string
def render(self, pj):
t = ".MNEM\t"
t += "0x%04x" % self.a
t += ", 0x%04x" % self.b
t += ", 0x%x" % self.type
t += ", len=0x%03x" % self.len
t += ", hash=%2d" % self.hash
t += ", '" + self.string + "'"
return t
if True:
pj.set_label(0x18c3a, "MNETABLE")
a = 0x193a0
while a > 0x18c3a:
y = mnem(pj, a)
x = pj.m.bu16(y.lo - 2)
a = y.lo
###############################################################
class oldcmd(data.Data):
def __init__(self, pj, lo, n):
super(oldcmd, self).__init__(pj, lo, lo + 2)
x,self.name,y = data.stringify(pj, self.lo, 2)
self.key = pj.m.rd(0x194b2 + n)
self.imm = (pj.m.rd(0x1951e + (n >> 3)) >> (n & 7)) & 1
if not self.imm:
self.svf1 = pj.m.bu16(0x1952c + self.key * 4)
self.svf2 = pj.m.bu16(0x1952c + self.key * 4 + 2)
if not self.svf2 in keynos:
keynos[self.svf2] = "CMD_" + self.name
def render(self, pj):
t = ".OLDCMD\t"
t += "'" + self.name + "'"
t += " imm=%x" % self.imm
t += " key=%02x" % self.key
if self.imm and self.key in keynos:
t += " ('" + keynos[self.key] + "')"
if not self.imm:
t += " svf=0x%04x,0x%04x" % (self.svf1, self.svf2)
t += " xxx=%02x" % (self.svf1 & 0x1e)
return t
if True:
pj.set_label(0x193da, "OLDCMDS")
n = 0
for a in range(0x193da, 0x194b2, 2):
y = oldcmd(pj, a, n)
n += 1
# print("OLDCMDS %d" % ((0x194b2-0x193da)/2))
pj.set_label(0x194b2, "KEYTAB")
for a in range(0x194b2, 0x1951e, 8):
y = data.Const(pj, a, min(a + 8, 0x1951e), fmt="0x%02x")
# print("KEYTAB %d" % ((0x1951e-0x194b2)/1))
pj.set_label(0x1951e, "IMEDBITS")
for a in range(0x1951e, 0x1952c, 8):
y = data.Const(pj, a, min(a + 8, 0x1952c), fmt="0x%02x")
# print("IMEDBITS %d" % ((0x1952c-0x1951e)/1))
pj.set_label(0x1952c, "SFLGVAL")
for a in range(0x1952c, 0x195c4, 16):
y = data.Const(pj, a, min(a + 16, 0x195c4),
"0x%08x", pj.m.bu32, 4)
# print("SFLGVAL %d" % ((0x195c4-0x1952c)/2))
###############################################################
switches[0x09ae8] = {}
switches[0x09d78] = {}
switches[0x0a5de] = {}
switches[0x0af5c] = {}
switches[0x0b5ec] = {}
switches[0x0bb4e] = {}
switches[0x0bd5a] = {}
switches[0x0bd6e] = {
0: "KEYS_00_1f",
1: "KEYS_20_3f",
2: "KEYS_40_5f",
3: "KEYS_60_7f",
4: "KEYS_80_9f",
5: "KEYS_a0_bf",
}
for n in keynos:
t = keynos[n]
# print("KEY_%02x" % n, t)
sk = "KS%c" % n
ksk = hp856x_cmds.cmds.get(sk)
if ksk != None and type(ksk) != str:
ksk = ksk[1]
if ksk == None:
ksk = "==" + t
if n < 0x20:
switches[0x9ae8][n] = "KEY_%02x_" % n + t
if n >= 0x20 and n < 0x30:
switches[0x9d78][n - 0x20] = "KEY_%02x_" % n + t
if n >= 0x40 and n < 0x60:
switches[0xa5de][n - 0x41] = "KEY_%02x_" % n + t
switches[0xaf5c][n - 0x41] = "KEY_S%02x_KS%c_" % (n, n) + ksk
if n >= 0x60 and n < 0x80:
switches[0xb5ec][n - 0x61] = "KEY_%02x_" % n + t
switches[0xbb4e][n - 0x60] = "KEY_S%02x_KS%c_" % (n, n) + ksk
if n >= 0xa0 and n <= 0xbf:
switches[0xbd5a][n - 0xa0] = "KEY_%02x_" % n + t
if True:
for b,e in (
( 0x0e750, 0x0e778),
( 0x15ca4, 0x15cb4),
):
for a in range(b, e, 8):
data_double(pj, a)
###############################################################
if True:
cpu.vectors(pj, hi = 0xc0)
#######################################################
for b,e in (
(0x06936, 0x0693a),
(0x06a2c, 0x06b84),
(0x070ca, 0x070d6),
(0x081ae, 0x081ba),
(0x1357a, 0x1358a),
(0x13e58, 0x13e70),
(0x14960, 0x1497c),
(0x14c94, 0x14cb4),
(0x14f98, 0x14fa8),
(0x15094, 0x150a4),
(0x15140, 0x15150),
(0x15e0e, 0x15e32),
(0x172b8, 0x172c4),
(0x17dbe, 0x17dce),
):
for a in range(b, e, 4):
x = pj.m.bu32(a)
data.Dataptr(pj, a, a + 4, x)
data.Txt(pj, x, pfx=1, align=2)
data.Txt(pj, 0x15dfc, pfx=1, align=2)
#######################################################
for a in (
0x0e2fa,
0x0e308,
0x0e318,
0x12986,
0x12988,
0x1298c,
0x12990,
0x1694e,
0x16954,
):
y = data.Txt(pj, a, pfx=1, align=2)
#######################################################
data.Dataptr(pj, 0xe39a, 0xe39a + 4, pj.m.bu32(0xe39a))
data.Const(pj, 0x2140, 0x2148, "%d", pj.m.bu64, 8)
data.Const(pj, 0x2148, 0x214c, "%d", pj.m.bu32, 4)
for a in (
0x0645e,
0x06476,
0x0647e,
0x0648a,
0x06492,
0x0649a,
0x064a6,
0x064be,
0x0e2c4,
0x0e2d4,
0x0e2cc,
0x0e32a,
0x0e332,
0x0e37c,
0x0e384,
0x128ca,
0x15da0,
):
y = data_bcd(pj, a)
pj.set_label(a, "BCD_%x" % y.data[0])
#######################################################
pj.set_label(0x0693c, "MSG_ADR_X_Y")
for a in range(0x693c, 0x6a2c, 6):
data.Const(pj, a, a+6, "0x%04x", pj.m.bu16, 2)
#######################################################
pj.set_label(0x6b84, "G_CTRL")
pj.set_label(0x6ba8, "G_CENTER")
pj.set_label(0x6bcc, "G_MARKER")
pj.set_label(0x6be2, "G_DSP_LINE")
pj.set_label(0x6bf8, "G_GRATICULE")
pj.set_label(0x6c4c, "G_HP_LOGO")
pj.set_label(0x6c5e, "G_ACT_FUNC")
a = 0x6b84
dsp = hp85662a.hp85662a()
while a < 0x6c98:
x = pj.m.bs16(a)
if x < 0:
y = data.Data(pj, a, a + 2)
y.fmt = ".DSPLOC\t0x%04x" % -x
y.lcmt = "adr=%d" % -x
dsp = hp85662a.hp85662a()
else:
y = dsp.disass(pj, a)
a = y.hi
#######################################################
pj.set_label(0x0e3be, "UNITS")
for a in range(0x0e3be, 0x0e3d4, 2):
data.Txt(pj, a, a + 2, label=False)
#######################################################
# 0ee98 00 01 93 be
# 0eeaa 00 01 93 da | |
# 0ee8e 00 01 da ee | |
#######################################################
# Orphans ?
if False:
pj.todo(0x01b88, cpu.disass)
pj.todo(0x01b8e, cpu.disass)
pj.todo(0x01b94, cpu.disass)
pj.todo(0x01b9a, cpu.disass)
pj.todo(0x01b9e, cpu.disass)
pj.todo(0x01ba2, cpu.disass)
pj.todo(0x01ba8, cpu.disass)
pj.todo(0x01c76, cpu.disass)
pj.todo(0x01c82, cpu.disass)
pj.todo(0x01c90, cpu.disass)
pj.todo(0x01cd2, cpu.disass)
pj.todo(0x01d14, cpu.disass)
pj.todo(0x01578, cpu.disass)
pj.todo(0x01594, cpu.disass)
pj.todo(0x0171a, cpu.disass)
pj.todo(0x01906, cpu.disass)
pj.todo(0x02dee, cpu.disass)
pj.todo(0x02df4, cpu.disass)
pj.todo(0x03412, cpu.disass)
pj.todo(0x11e74, cpu.disass)
# from 0x2272
pj.todo(0x2282, cpu.disass)
# filled in 0xffffabd2
pj.todo(0x0ed98, cpu.disass)
pj.todo(0x0df5e, cpu.disass) # Arg to 0x802
pj.todo(0x3292, cpu.disass) # 0x3284
#######################################################
# pat 4,244,024 pg 262 lin 3700
pj.set_label(0x4fac, "SCANTAB")
for a in range(0x4fac, 0x4fec, 2):
y = data.Const(pj, a, a+2, "0x%04x", pj.m.bu16, 2)
#######################################################
y = data.Const(pj, 0x193a2, 0x193be, "%d", pj.m.bu16, 2)
pj.set_label(y.lo, "HASHPTR2")
y = data.Const(pj, 0x193be, 0x193da, "%d", pj.m.bu16, 2)
pj.set_label(y.lo, "HASHPTR")
#######################################################
pj.set_label(0x19826, "PFXSCALE")
for a in range(0x19826, 0x19853, 1):
y = data.Const(pj, a, a + 1, fmt="0x%02x")
# print("PFXSCALE %d" % ((0x19853-0x19826)/1))
else:
y = cpu.disass(pj, 0xda1e)
for i in y.__dict__:
print("\t", i, y.__dict__[i])
while pj.run():
pass
for i in pj.t:
if i.tag != "m68000":
continue
if i.dstadr in (0x940c, 0xed54):
y = pj.t.find_hi(i.lo)
if len(y) != 1:
continue
y = y[0]
if pj.m.rd(y.lo) == 0x70:
k = pj.m.rd(y.lo + 1)
elif pj.m.bu16(y.lo) == 0x103c:
k = pj.m.bu16(y.lo + 2)
else:
continue
if not k in keynos:
continue
y.oper[0].txt = "#KEY_" + keynos[k]
if i.dstadr in (0xe4e8,):
y = pj.t.find_hi(i.lo)
if len(y) != 1:
continue
y = y[0]
if y.mne != "PEA.L":
continue
z = data.Txt(pj, y.dstadr, pfx=1, align=2)
y.lcmt = "'" + z.txt + "'"
if i.dstadr in (0xe718, 0x3456, 0x6ce0):
y = pj.t.find_hi(i.lo)
if len(y) != 1:
continue
y = y[0]
if pj.m.bu16(y.lo) != 0x203c:
continue
a = pj.m.bu32(y.lo + 2)
z = data.Txt(pj, a, pfx=1, align=2)
y.lcmt = "'" + z.txt + "'"
if i.dstadr == 0xe718:
w = pj.t.find_hi(y.lo)
if len(w) != 1:
continue
w = w[0]
if w.mne != "PEA.L":
continue
z = data.Txt(pj, w.dstadr, pfx=1, align=2)
w.lcmt = "'" + z.txt + "'"
y = data.Const(pj, 0x693a, 0x693c, "%d", pj.m.bu16, 2)
pj.set_label(0x009b8, "RESET")
pj.set_label(0x00c2e, "SELFTEST")
pj.set_label(0x00d7a, "CPUTEST_FAIL")
pj.set_label(0x00e9a, "epromsize")
y = data.Const(pj, 0x00e9a, 0x00e9e, "%d", pj.m.bu32, 4)
pj.set_label(0x00ef2, "ramaddress")
y = data.Const(pj, 0x00ef2, 0x00efe, "0x%08x", pj.m.bu32, 4)
pj.set_label(0x00e9e, "ROMSUM")
pj.set_label(0x00ec0, "ROMTEST")
pj.set_label(0x01ae2, "BCD_FMT(BCD, PTR)")
pj.set_label(0x01b34, "BCD_ABS(BCD)")
pj.set_label(0x01b38, "BCD_NEG(BCD)")
pj.set_label(0x01be6, "BCD_CMP(R01,R23)")
pj.set_label(0x01bea, "BCD_CMP(R23,R01)")
pj.set_label(0x01c00, "stk_64")
pj.set_label(0x01c14, "rel_64")
pj.set_label(0x01c28, "abs_64")
pj.set_label(0x01c3c, "loc_64")
pj.set_label(0x01b48, "BCD_NEG8(&A0)")
pj.set_label(0x01b62, "BCD_NEG(D23)")
pj.set_label(0x01b72, "BCD_ADD8(&A0,&A1)")
pj.set_label(0x01c60, "BCD_ADD(D01, D23)")
pj.set_label(0x01c98, "BCD_SUBR(D23, D01(order?)")
pj.set_label(0x01c9c, "BCD_SUB(D01, D23(order?)")
pj.set_label(0x01cb0, "BCD_SUB8(&A0,&A1)")
pj.set_label(0x0214c, "BCD_MUL5(D01)")
pj.set_label(0x0217e, "BCD_MUL3(D01)")
pj.set_label(0x0218c, "BCD_MUL6(D01)")
pj.set_label(0x021be, "BCD_MUL8(D01)")
pj.set_label(0x021c0, "BCD_MUL4(D01)")
pj.set_label(0x021c4, "BCD_MUL2(D01)")
pj.set_label(0x021f6, "BCD_DIV2(D01)")
pj.set_label(0x02224, "BCD_LD(D0.W)")
pj.set_label(0x0222c, "BCD_LD(D0.L)")
pj.set_label(0x023ec, "FD_ABS(R2+R3)")
pj.set_label(0x0287e, "rel_32")
pj.set_label(0x02892, "abs_32")
pj.set_label(0x028a4, "loc_32")
pj.set_label(0x02f38, "SWITCH")
pj.set_label(0x0320e, "BZERO(PTR,INT)")
pj.set_label(0x033fc, "SHOW_CHAR")
pj.set_label(0x03412, "SHOW_SEMI")
pj.set_label(0x0341a, "SHOW_COMMA")
pj.set_label(0x03422, "SHOW_CRNL")
pj.set_label(0x03428, "SHOW_NL")
pj.set_label(0x03430, "SHOW_MINUS")
pj.set_label(0x03438, "SHOW_2CHAR")
pj.set_label(0x03498, "SHOW_INT")
pj.set_label(0x03932, "DISP_RD(INT ADR)")
pj.set_label(0x03958, "SHOW_TXT_AT(ADR,STR)")
pj.set_label(0x03906, "DISP_WR(INT ADR, INT DATA)")
pj.set_label(0x039b0, "SHOW_WORD(INT)")
pj.set_label(0x03c0a, "FREQ_CNT_SET_PERIOD(INT)")
pj.set_label(0x03c26, "FREQ_CNT_WAIT()")
pj.set_label(0x03c3a, "FREQ_CNT_10MHZ(INT)")
pj.set_label(0x06936, "REVISION")
pj.set_label(0x0693a, "MODEL")
pj.set_label(0x06a2c, "MSG_TXT")
pj.set_label(0x06ce0, "SHOW_TXT(STR)")
pj.set_label(0x06cf2, "SHOW_CRNL")
pj.set_label(0x06cfc, "SET_IF_LEDS(INT)")
pj.set_label(0x06d20, "SHOW_MSG")
pj.set_label(0x070be, "UPD_DETECTOR")
pj.set_label(0x07b4e, "FILL_DISPLAY")
pj.set_label(0x08164, "SHOW_CR[NL]")
pj.set_label(0x0940c, "EXEC(INT KEY)")
pj.set_label(0x0e39a, "VAR_HEAD")
pj.set_label(0x0ed54, "EXEC2(INT KEY)")
pj.set_label(0x0eddc, "SEARCH(NAMLEN.W, CHAIN.L, HASH.L, NAME.L)")
pj.set_label(0x0ee6a, "FIND_OLDCMD(INT)")
pj.set_label(0x0f72c, "NAME2TRACE")
pj.set_label(0x0a986, "CALIBRATING")
pj.set_label(0x0aa7a, "AUTOCAL")
pj.set_label(0x13092, "WHICH(PTR TABLE, STR KEY, INT N)")
pj.set_label(0x14158, "TRACE_MATH(LONG, INT, STR, STR, STR)")
pj.set_label(0x17dce, "SHOW_COMMA")
pj.set_label(0x17e9e, "PL_MOVE")
pj.set_label(0x17eac, "PL_LINE")
#pj.set_label(0x18d24, "MNEM")
#pj.set_label(0x195c4, "PARMTYPE")
#pj.set_label(0x196b6, "PRCADRS")
# 0xffff0005
# 0xffff0007
# 0xffff0009
# 0xffff0013
# 0xffff0019
# 0xffff0021
# 0xffff0027
# 0xffff0035
#pj.set_label(0xffff4000, "PIT_PGCR")
#pj.set_label(0xffff4002, "PIT_PSRR")
#pj.set_label(0xffff4004, "PIT_PADDR")
#pj.set_label(0xffff4006, "PIT_PBDDR")
#pj.set_label(0xffff4008, "PIT_PCDDR")
#pj.set_label(0xffff4010, "PIT_PADR")
#pj.set_label(0xffff4012, "PIT_PBDR")
# 0xffff8000
# 0xffffa6ae = stack
# 0xffffa6ae
# 0xffffa6b2
# 0xffffa6b6
# 0xffffa6ba
# 0xffffa6bc
# 0xffffa6be
# 0xffffa6c2
# 0xffffa6c6
# 0xffffa6ca
# 0xffffa6ce
pj.set_label(0xffffa6d2, "ram_var_hash")
# 0xffffa6ec
# 0xffffa6f0
# 0xffffa6f2
# 0xffffa6f8
# 0xffffa6fe
# 0xffffa704
# 0xffffa707
# 0xffffa708
# 0xffffa70a
# 0xffffa70c
# 0xffffa70e
# 0xffffa710
# 0xffffa712
# 0xffffa714
# 0xffffa716
# 0xffffa71a
# 0xffffa71c
# 0xffffa890
# 0xffffa89e
# 0xffffa8a0
# 0xffffa8a4
# 0xffffa8a6
# 0xffffa8a8
# 0xffffa972
# 0xffffa973
# 0xffffa974
# 0xffffa975
# 0xffffa976
# 0xffffa9af
# 0xffffa9b0
# 0xffffa9b2
# 0xffffa9b4
# 0xffffa9b6
# 0xffffa9ba
# 0xffffa9bb
# 0xffffa9bc
# 0xffffa9be
# 0xffffa9c0
# 0xffffa9f4
# 0xffffa9f6
# 0xffffa9f8
# 0xffffa9fa
# 0xffffa9fc
# 0xffffaa1e
# 0xffffaa20
# 0xffffaa24
# 0xffffaa26
# 0xffffaa28
# 0xffffaa29
# 0xffffaa2a
pj.set_label(0xffffaa2c, "ram_center_freq")
# 0xffffaa2d
pj.set_label(0xffffaa34, "ram_freq_span")
# 0xffffaa38
pj.set_label(0xffffaa3c, "ram_rf_fp_leds")
pj.set_label(0xffffaa3e, "ram_if_fp_leds")
# 0xffffaa3f
# 0xffffaa40 if_scale_gain copy
# 0xffffaa41
# 0xffffaa42
# 0xffffaa44
# 0xffffaa46
# 0xffffaa47
# 0xffffaa48
# 0xffffaa4a
# 0xffffaa4c
# 0xffffaa4e
# 0xffffaa50
# 0xffffaa51
# 0xffffaa58
# 0xffffaa59
# 0xffffaa60
# 0xffffaa62
# 0xffffaa64
# 0xffffaa66
# 0xffffaa68
# 0xffffaa69
# 0xffffaa6a
# 0xffffaa6b
# 0xffffaa72
# 0xffffaa73
# 0xffffaa74
# 0xffffaa76
# 0xffffaa78
# 0xffffaa79
# 0xffffaa82
# 0xffffaa84
# 0xffffaa8a
# 0xffffaa8e
# 0xffffaa92
# 0xffffaa9a
# 0xffffaaa2
# 0xffffaaa6
# 0xffffaaaa
# 0xffffaaae
# 0xffffaab2
# 0xffffaaba
# 0xffffaabc
# 0xffffaabe
# 0xffffaac0
# 0xffffaac2
# 0xffffaaca
# 0xffffaad2
# 0xffffaad4
# 0xffffaad6
# 0xffffaad8
# 0xffffaad9
# 0xffffaada
# 0xffffaadc
# 0xffffaade
# 0xffffaae0
# 0xffffaae2
# 0xffffaae4
# 0xffffaae6
# 0xffffaae8
# 0xffffaaea
# 0xffffaaeb
# 0xffffaaec
# 0xffffaaed
# 0xffffaaee
# 0xffffaaef
# 0xffffaaf0
# 0xffffaaf1
# 0xffffaaf2
# 0xffffaaf4
# 0xffffaaf6
pj.set_label(0xffffaaf8, "ram_kbd_row")
# 0xffffaafa
# 0xffffaafc
# 0xffffaafe
# 0xffffaaff
# 0xffffab00
# 0xffffab02
# 0xffffab04
# 0xffffab06
# 0xffffab07
# 0xffffab08
# 0xffffab0a
# 0xffffab0c
# 0xffffab0e
# 0xffffab10
# 0xffffab11
# 0xffffab12
# 0xffffab13
# 0xffffab14
# 0xffffab16
# 0xffffab18
# 0xffffab1a
# 0xffffab9a
# 0xffffaba8
# 0xffffabb0
# 0xffffabba
# 0xffffabbc
# 0xffffabbe
# 0xffffabc8
# 0xffffabce
# 0xffffabd0
pj.set_label(0xffffabd2, "func_ptr+a6+a7")
# 0xffffabd6
# 0xffffabda
# 0xffffabde
# 0xffffabe2
# 0xffffabe4
# 0xffffabe6
# 0xffffabe8
# 0xffffabea
# 0xffffabec
# 0xffffabee
# 0xffffabf0
# 0xffffabf2
# 0xffffabfa
# 0xffffae24
# 0xffffb628
# 0xffffb62a
# 0xffffb630
# 0xffffbe2c
# 0xffffbe2e
# 0xffffbe30
# 0xffffbe32
# 0xffffbe34
# 0xffffbe38
# 0xffffbe3c
# 0xffffbe40
# 0xffffbe42
# 0xffffbe44
# 0xffffbe46
# 0xffffbe48
# 0xffffbe50
# 0xffffbe54
# 0xffffbe5c
# 0xffffbe5e
# 0xffffbe60
# 0xffffbe62
# 0xffffbe64
# 0xffffbe68
# 0xffffbe6a
# 0xffffbe78
# 0xffffbe86
# 0xffffbe88
# 0xffffbe8c
# 0xffffbe8e
# 0xffffbe9c
# 0xffffbeaa
# 0xffffbeac
# 0xffffbeb0
# 0xffffbeb2
# 0xffffbec0
# 0xffffbf1f
# 0xffffbf7e
# 0xffffbfde
# 0xffffbfdf
# 0xffffbfe0
# 0xffffbfe1
pj.set_label(0xffffbfe2, "ram_hpib_address")
pj.set_label(0xffffbfe3, "ram_not_hpib_address")
# 0xffffbfe4
# 0xffffbfe5
# 0xffffbfe6
# 0xffffbfe7
# 0xffffbfe8
# 0xffffbfe9
# 0xffffbfea
# 0xffffbfec
# 0xffffbff0
# 0xffffbff4
# 0xffffbff8
# 0xffffbffc
# 0xffffbffd
# 0xffffbffe
# I/O Decoding on A15
#####################
# 0x...00 BIO - BOTTOM/RF
# 0x...20 DBCLK #2
# 0x...40 TIO - TOP/IF
# 0x...64 LDBTEST #7
# 0x...80 LHPIB
# 0x...a4 LDBTEST #7
# 0x...c0 LBUS
# 0x...e0 HPIBSW #1
# 0x...e4 LATR #5
# BIO/BOTTOM/RF
###############
pj.set_label(0xffffc000, "rf_50vto_lo_dac")
pj.set_label(0xffffc002, "rf_50vto_hi_dac")
pj.set_label(0xffffc006, "rf_yig_dac")
pj.set_label(0xffffc008, "rf_scan_atten_vto")
pj.set_label(0xffffc00a, "rf_scantime")
pj.set_label(0xffffc00c, "rf_yig_lock_scan")
pj.set_label(0xffffc00e, "rf_scan_mode")
# A12
pj.set_label(0xffffc010, "rf_fp_leds")
pj.set_label(0xffffc012, "rf_kbd_row")
pj.set_label(0xffffc014, "rf_kbd_col")
pj.set_label(0xffffc016, "rf_rpg")
pj.set_label(0xffffc018, "rf_srq_resets")
pj.set_label(0xffffc01a, "rf_phase_lock")
pj.set_label(0xffffc01c, "rf_245_lock")
pj.set_label(0xffffc01e, "rf_attn")
# A15
pj.set_label(0xffffc020, "dbus_test_0")
pj.set_label(0xffffc022, "dbus_test_2")
pj.set_label(0xffffc025, "dbus_test_5")
# A17
pj.set_label(0xffffc028, "rf_freqcnt_ctrl")
pj.set_label(0xffffc02a, "rf_freqcnt_msb")
pj.set_label(0xffffc02c, "rf_freqcnt_lsb")
#
pj.set_label(0xffffc030, "rf_inputs_atten_20")
pj.set_label(0xffffc032, "rf_vunit_atten_30")
pj.set_label(0xffffc034, "rf_atten_40")
pj.set_label(0xffffc034, "rf_atten_50")
pj.set_label(0xffffc034, "rf_atten_60")
pj.set_label(0xffffc034, "rf_atten_70")
# TIO/TOP/IF
############
pj.set_label(0xffffc040, "display_address")
pj.set_label(0xffffc042, "display_rd_store")
pj.set_label(0xffffc044, "display_wr_store")
pj.set_label(0xffffc046, "display_wr_offset")
pj.set_label(0xffffc048, "display_control")
pj.set_label(0xffffc04a, "display_rd_scan")
pj.set_label(0xffffc04c, "display_wr_marker")
pj.set_label(0xffffc04e, "display_wr_scan")
# SWEEP
pj.set_label(0xffffc064, "if_sweep_src_trig")
pj.set_label(0xffffc066, "if_sweep_time")
pj.set_label(0xffffc068, "if_scale_gain")
pj.set_label(0xffffc06a, "if_bw_fine")
pj.set_label(0xffffc06c, "if_fp_leds")
# HPIB
######
# 0xffffc081
# 0xffffc083
# 0xffffc085
# 0xffffc087
# 0xffffc089
# 0xffffc08b
# 0xffffc08d
# 0xffffc08f
# LBUS
######
# 0xffffc0e0 ?
# HPIBSW
pj.set_label(0xffffc0e1, "adrsw_srq_display_ready")
pj.set_label(0xffffc0e5, "latr_test")
###############################################################
if False:
for a in (
0x01298,
0x013a8,
0x013d8,
0x013de,
0x013e4,
0x01e12,
0x01e94,
0x0217e,
0x0218c,
0x02194,
0x021a8,
0x02268,
):
# print("ORPHAN %x" % a)
y = cpu.disass(pj, a)
y.lcmt = "ORPHAN - "
nondisc = {
0x14ce: 0,
}
while True:
l = []
for b,e in pj.gaps():
if b in nondisc:
continue
if e - b < 2:
continue
if pj.m.bu16(b) in (0x4eb8, 0x4e56):
l.append(b)
elif pj.m.rd(b) in (0x61,):
l.append(b)
# print(l)
for i in l:
y = cpu.disass(pj, i)
y.lcmt = "DISCOVER - "
while pj.run():
pass
if len(l) == 0:
break
def example():
l = []
for fw, vf in (
(FIRMWARE_K, version_k),
(FIRMWARE_R, version_r),
):
cy = common(fw)
l.append(cy.m)
vf(cy)
a = 0x15b4c
while True:
y = Dataptr(cy.m, a)
if not y.dst:
break
a += 5
y = Dataptr(cy.m, a)
cy.m.q.queue(PRI_RPN, Obj, cy, y.dst)
a += 5
y = Dataptr(cy.m, a)
cy.m.q.queue(PRI_RPN, Obj, cy, y.dst)
a += 5
for a in (
0x21de7,
0x3858e,
0x385e8,
0x648bd,
0x72e87,
):
Obj(cy, a)
cy.m.set_line_comment(a, "Manual")
for a in (
0x0be2d,
0x0c114,
0x0c1d4,
0x0c1e9,
0x80000,
0x8011c,
0x80126,
0x80133,
0x80167,
0x801a5,
0x80215,
0x80804,
0x80821,
0x80832,
0x80965,
0x80974,
0x809d5,
0x80a54,
0x80a73,
0x80b2d,
0x80b43,
0x80c20,
0x80ec3,
0x80f79,
0x8107d,
0x81374,
0x818cb,
0x81944,
# see GOSUB 0x26ca
0x81cad,
0x81cbc,
0x81ce2,
0x81cfc,
0x81d24,
):
cy.m.q.queue(PRI_ASSY, cy.disass, a)
for a in range(0x70601, 0x706a1, 5):
y = Dataptr(cy.m, a)
cy.disass(y.dst)
# Table of week-days
for a in range(0x0cf31, 0x0cf5b, 6):
y = data.Data(cy.m, a, a + 6)
t = text(cy.m, a, 3)
y.rendered = ".TXT\t「" + t + "」"
while True:
cy.m.q.run()
if hunt_objects(cy):
break
if True:
edb = entrydatabase.RPN_EDB()
edb.decorate(cy.m, "48G")
return "HP48GX", l
def example():
m = mem.Stackup((
("85680-80115.BIN", "85680-80116.BIN"),
("85680-80113.BIN", "85680-80114.BIN"),
),
nextto=__file__)
# Checum EPROMS
# See 00e9e/ROMSUM
s = [0xff, 0xff, 0xff, 0xff]
for a in range(32768):
s[0] += m[a * 2]
s[1] += m[a * 2 + 1]
s[2] += m[a * 2 + 65536]
s[3] += m[a * 2 + 65536 + 1]
for i in s:
assert i & 0xff == 0
cx = mycpu()
cx.m.map(m, 0)
cx.macro("DISPLAY_READY()", "0838 0007 c0e1 66f8")
cx.flow_check.append(flow_post_arg)
for a, b in SYMBOLS.items():
cx.m.set_label(a, b)
# Where ?
# y = data.Const(cx.m, 0xfffe, 0x10000)
# cx.m.set_label(y.lo, "eprom_lo_chksum")
y = data.Const(cx.m, 0x19854, 0x19856)
cx.m.set_label(y.lo, "eprom_hi_chksum")
for i in post_arg:
j = post_arg[i]
if j and j[0] != "":
cx.m.set_label(i, j[0])
if True:
for b, e in (
(0x06936, 0x0693a),
(0x06a2c, 0x06b84),
(0x070ca, 0x070d6),
(0x081ae, 0x081ba),
(0x1357a, 0x1358a),
(0x13e58, 0x13e70),
(0x14960, 0x1497c),
(0x14c94, 0x14cb4),
(0x14f98, 0x14fa8),
(0x15094, 0x150a4),
(0x15140, 0x15150),
(0x15e0e, 0x15e32),
(0x172b8, 0x172c4),
(0x17dbe, 0x17dce),
):
for a in range(b, e, 4):
x = cx.m.bu32(a)
data.Dataptr(cx.m, a, a + 4, x)
if not cx.m.occupied(x):
data.Txt(cx.m, x, pfx=1, align=2)
data.Txt(cx.m, 0x15dfc, pfx=1, align=2)
cx.flow_check.append(flow_switch)
cx.vectors(hi=0xc0)
if True:
n = 0
for a in range(0x193da, 0x194b2, 2):
y = oldcmd(cx.m, a, n)
n += 1
# print("OLDCMDS %d" % ((0x194b2-0x193da)/2))
for a in range(0x194b2, 0x1951e, 8):
y = data.Const(cx.m, a, min(a + 8, 0x1951e), fmt="0x%02x")
# print("KEYTAB %d" % ((0x1951e-0x194b2)/1))
for a in range(0x1951e, 0x1952c, 8):
y = data.Const(cx.m, a, min(a + 8, 0x1952c), fmt="0x%02x")
# print("IMEDBITS %d" % ((0x1952c-0x1951e)/1))
for a in range(0x1952c, 0x195c4, 16):
y = data.Const(cx.m, a, min(a + 16, 0x195c4), "0x%08x", cx.m.bu32,
4)
# print("SFLGVAL %d" % ((0x195c4-0x1952c)/2))
if True:
a = 0x193a0
while a > 0x18c3a:
y = mnem(cx, a)
x = cx.m.bu16(y.lo - 2)
a = y.lo
###############################################################
switches[0x09ae8] = {}
switches[0x09d78] = {}
switches[0x0a5de] = {}
switches[0x0af5c] = {}
switches[0x0b5ec] = {}
switches[0x0bb4e] = {}
switches[0x0bd5a] = {}
switches[0x0bd6e] = {
0: "KEYS_00_1f",
1: "KEYS_20_3f",
2: "KEYS_40_5f",
3: "KEYS_60_7f",
4: "KEYS_80_9f",
5: "KEYS_a0_bf",
}
for n in KEYNOS:
t = KEYNOS[n]
# print("KEY_%02x" % n, t)
sk = "KS%c" % n
ksk = hp856x_cmds.cmds.get(sk)
if ksk is not None and type(ksk) != str:
ksk = ksk[1]
if ksk is None:
ksk = "==" + t
if n < 0x20:
switches[0x9ae8][n] = "KEY_%02x_" % n + t
if n >= 0x20 and n < 0x30:
switches[0x9d78][n - 0x20] = "KEY_%02x_" % n + t
if n >= 0x40 and n < 0x60:
switches[0xa5de][n - 0x41] = "KEY_%02x_" % n + t
switches[0xaf5c][n - 0x41] = "KEY_S%02x_KS%c_" % (n, n) + ksk
if n >= 0x60 and n < 0x80:
switches[0xb5ec][n - 0x61] = "KEY_%02x_" % n + t
switches[0xbb4e][n - 0x60] = "KEY_S%02x_KS%c_" % (n, n) + ksk
if n >= 0xa0 and n <= 0xbf:
switches[0xbd5a][n - 0xa0] = "KEY_%02x_" % n + t
if True:
for b, e in (
(0x0e750, 0x0e778),
(0x15ca4, 0x15cb4),
):
for a in range(b, e, 8):
data_double(cx.m, a)
###############################################################
if True:
cx.disass(0x2f38)
#######################################################
#######################################################
for a in (
0x0e2fa,
0x0e308,
0x0e318,
0x12986,
0x12988,
0x1298c,
0x12990,
0x1694e,
0x16954,
):
y = data.Txt(cx.m, a, pfx=1, align=2)
#######################################################
data.Dataptr(cx.m, 0xe39a, 0xe39a + 4, cx.m.bu32(0xe39a))
data.Const(cx.m, 0x2140, 0x2148, "%d", cx.m.bu64, 8)
data.Const(cx.m, 0x2148, 0x214c, "%d", cx.m.bu32, 4)
for a in (
0x0645e,
0x06476,
0x0647e,
0x0648a,
0x06492,
0x0649a,
0x064a6,
0x064be,
0x0e2c4,
0x0e2d4,
0x0e2cc,
0x0e32a,
0x0e332,
0x0e37c,
0x0e384,
0x128ca,
0x15da0,
):
if not cx.m.occupied(a):
y = data_bcd(cx.m, a)
cx.m.set_label(a, "BCD_%x" % y.data[0])
#######################################################
for a in range(0x693c, 0x6a2c, 6):
data.Const(cx.m, a, a + 6, "0x%04x", cx.m.bu16, 2)
#######################################################
a = 0x6b84
dsp = hp85662a.hp85662a()
while a < 0x6c98:
x = cx.m.bs16(a)
if x < 0:
y = data.Data(cx.m, a, a + 2)
y.fmt = ".DSPLOC\t0x%04x" % -x
y.lcmt = "adr=%d" % -x
dsp = hp85662a.hp85662a()
else:
y = dsp.disass(a, cx.m)
a = y.hi
#######################################################
for a in range(0x0e3be, 0x0e3d4, 2):
data.Txt(cx.m, a, a + 2, label=False)
#######################################################
# 0ee98 00 01 93 be
# 0eeaa 00 01 93 da | |
# 0ee8e 00 01 da ee | |
#######################################################
# Orphans ?
if False:
cx.disass(0x01b88)
cx.disass(0x01b8e)
cx.disass(0x01b94)
cx.disass(0x01b9a)
cx.disass(0x01b9e)
cx.disass(0x01ba2)
cx.disass(0x01ba8)
cx.disass(0x01c76)
cx.disass(0x01c82)
cx.disass(0x01c90)
cx.disass(0x01cd2)
cx.disass(0x01d14)
cx.disass(0x01578)
cx.disass(0x01594)
cx.disass(0x0171a)
cx.disass(0x01906)
cx.disass(0x02dee)
cx.disass(0x02df4)
cx.disass(0x03412)
cx.disass(0x11e74)
# from 0x2272
cx.disass(0x2282)
# filled in 0xffffabd2
cx.disass(0x0ed98)
cx.disass(0x0df5e) # Arg to 0x802
cx.disass(0x3292) # 0x3284
#######################################################
# pat 4,244,024 pg 262 lin 3700
for a in range(0x4fac, 0x4fec, 2):
y = data.Const(cx.m, a, a + 2, "0x%04x", cx.m.bu16, 2)
#######################################################
y = data.Const(cx.m, 0x193a2, 0x193be, "%d", cx.m.bu16, 2)
cx.m.set_label(y.lo, "HASHPTR2")
y = data.Const(cx.m, 0x193be, 0x193da, "%d", cx.m.bu16, 2)
cx.m.set_label(y.lo, "HASHPTR")
#######################################################
for a in range(0x19826, 0x19853, 1):
y = data.Const(cx.m, a, a + 1, fmt="0x%02x")
else:
y = cx.disass(0xda1e)
for i in y.__dict__:
print("\t", i, y.__dict__[i])
for i in cx.m:
if i.tag != "m68000":
continue
if i.dstadr in (0x940c, 0xed54):
y = list(cx.m.find(hi=i.lo))
if len(y) != 1:
continue
y = y[0]
if cx.m[y.lo] == 0x70:
k = cx.m[y.lo + 1]
elif cx.m.bu16(y.lo) == 0x103c:
k = cx.m.bu16(y.lo + 2)
else:
continue
if not k in KEYNOS:
continue
y.oper[0].txt = "#KEY_" + KEYNOS[k]
if i.dstadr in (0xe4e8, ):
y = list(cx.m.find(hi=i.lo))
if len(y) != 1:
continue
y = y[0]
if y.mne != "PEA.L":
continue
z = data.Txt(cx.m, y.dstadr, pfx=1, align=2)
y.lcmt = "'" + z.txt + "'"
if i.dstadr in (0xe718, 0x3456, 0x6ce0):
y = list(cx.m.find(hi=i.lo))
if len(y) != 1:
continue
y = y[0]
if cx.m.bu16(y.lo) != 0x203c:
continue
a = cx.m.bu32(y.lo + 2)
z = data.Txt(cx.m, a, pfx=1, align=2)
y.lcmt = "'" + z.txt + "'"
if i.dstadr == 0xe718:
w = list(cx.m.find(hi=y.lo))
if len(w) != 1:
continue
w = w[0]
if w.mne != "PEA.L":
continue
z = list(cx.m.find(w.dstadr))
if not z:
z = [data.Txt(cx.m, w.dstadr, pfx=1, align=2)]
w.lcmt = "'" + z[0].txt + "'"
y = data.Const(cx.m, 0x693a, 0x693c, "%d", cx.m.bu16, 2)
y = data.Const(cx.m, 0x00e9a, 0x00e9e, "%d", cx.m.bu32, 4)
y = data.Const(cx.m, 0x00ef2, 0x00efe, "0x%08x", cx.m.bu32, 4)
#cx.m.set_label(0x18d24, "MNEM")
#cx.m.set_label(0x195c4, "PARMTYPE")
#cx.m.set_label(0x196b6, "PRCADRS")
# 0xffff0005
# 0xffff0007
# 0xffff0009
# 0xffff0013
# 0xffff0019
# 0xffff0021
# 0xffff0027
# 0xffff0035
#cx.m.set_label(0xffff4000, "PIT_PGCR")
#cx.m.set_label(0xffff4002, "PIT_PSRR")
#cx.m.set_label(0xffff4004, "PIT_PADDR")
#cx.m.set_label(0xffff4006, "PIT_PBDDR")
#cx.m.set_label(0xffff4008, "PIT_PCDDR")
#cx.m.set_label(0xffff4010, "PIT_PADR")
#cx.m.set_label(0xffff4012, "PIT_PBDR")
# 0xffff8000
# 0xffffa6ae = stack
# I/O Decoding on A15
#####################
# 0x...00 BIO - BOTTOM/RF
# 0x...20 DBCLK #2
# 0x...40 TIO - TOP/IF
# 0x...64 LDBTEST #7
# 0x...80 LHPIB
# 0x...a4 LDBTEST #7
# 0x...c0 LBUS
# 0x...e0 HPIBSW #1
# 0x...e4 LATR #5
# HPIB
######
# 0xffffc081
# 0xffffc083
# 0xffffc085
# 0xffffc087
# 0xffffc089
# 0xffffc08b
# 0xffffc08d
# 0xffffc08f
# LBUS
######
# 0xffffc0e0 ?
###############################################################
if False:
for a in (
0x01298,
0x013a8,
0x013d8,
0x013de,
0x013e4,
0x01e12,
0x01e94,
0x0217e,
0x0218c,
0x02194,
0x021a8,
0x02268,
):
# print("ORPHAN %x" % a)
y = cx.disass(a)
y.lcmt = "ORPHAN - "
nondisc = {
0x14ce: 0,
}
while True:
l = []
for b, e in cx.m.gaps():
if b in nondisc:
continue
if e - b < 2:
continue
if cx.m.bu16(b) in (0x4eb8, 0x4e56):
l.append(b)
elif cx.m[b] in (0x61, ):
l.append(b)
# print(l)
for i in l:
y = cx.disass(i)
y.lcmt = "DISCOVER - "
if l:
break
###############################################################
return NAME, (cx.m, )
