181 lines
4.7 KiB
Python
181 lines
4.7 KiB
Python
|
|
def stringify(v):
|
|
if type(v) == int:
|
|
if v < 0:
|
|
return "-" + hex(v)[3:]
|
|
return hex(v)[2:]
|
|
return v
|
|
|
|
def javascript(obj):
|
|
if type(obj) == int:
|
|
return str(obj)
|
|
if type(obj) == list:
|
|
return "[ " + ", ".join(javascript(i) for i in obj) + " ]";
|
|
if type(obj) == dict:
|
|
return "{ " + ", ".join(map(lambda k: ("%s: %s" % (stringify(k), javascript(obj[k]))), obj.keys())) + " }"
|
|
print obj
|
|
raise Exception("unsupported")
|
|
|
|
def javascript_table(obj):
|
|
keys = obj.keys();
|
|
keys.sort()
|
|
|
|
obj = [ [ k, obj[k] ] for k in keys ]
|
|
|
|
last = 0
|
|
for item in obj:
|
|
item[1] = stringify(item[1])
|
|
v = item[0]
|
|
item[0] -= last
|
|
last = v
|
|
|
|
return '"' + ",".join(("%s:%s" % (stringify(i[0]), i[1])) for i in obj) + '"'
|
|
|
|
weird = [ ];
|
|
lines = [ ]
|
|
for line in file("table.b.2.txt"):
|
|
comps = [ x.strip() for x in line.split(";") ]
|
|
if len(comps) != 3: raise Exception("bad line")
|
|
if len(comps[1].split(" ")) > 1:
|
|
weird.append(comps)
|
|
continue
|
|
lines.append(dict(
|
|
src = int(comps[0], 16),
|
|
dst = int(comps[1], 16),
|
|
reason = comps[2]
|
|
))
|
|
|
|
buckets = dict()
|
|
|
|
for p in lines:
|
|
delta = p["dst"] - p["src"];
|
|
special = ""
|
|
if delta not in buckets: buckets[delta] = [ ]
|
|
buckets[delta].append(p)
|
|
|
|
deltas = buckets.keys()
|
|
deltas.sort()
|
|
|
|
simple = dict()
|
|
simple_relative = dict()
|
|
debug = dict()
|
|
|
|
def add_simple(src, dst):
|
|
if len(str(dst - src)) < len(str(dst)):
|
|
simple_relative[src] = dst - src
|
|
debug[src] = "rel:" + str(dst - src)
|
|
else:
|
|
simple[src] = dst
|
|
debug[src] = "abs:" + str(dst)
|
|
|
|
def add_simple_data(data):
|
|
stride = 1
|
|
skip = [ ]
|
|
if "d" in data: stride = data["d"]
|
|
if "e" in data: skip = data["e"]
|
|
#print "ADD", data
|
|
for i in xrange(data["l"], data["l"] + data["h"] + 1, stride):
|
|
#print " ", i, data
|
|
if (i - data["l"]) in skip: continue
|
|
add_simple(i, i + data["s"])
|
|
|
|
mappings = [ ]
|
|
|
|
for delta in deltas:
|
|
bucket = buckets[delta]
|
|
|
|
if len(bucket) <= 7:
|
|
for p in bucket:
|
|
add_simple(p["src"], p["dst"])
|
|
continue
|
|
|
|
last = 0
|
|
|
|
# Compute the mode of the delta
|
|
mode = dict()
|
|
last = 0xffffffff
|
|
for p in buckets[delta]:
|
|
dl = p["src"] - last
|
|
if dl not in mode: mode[dl] = 0
|
|
mode[dl] += 1
|
|
last = p["src"]
|
|
mode = map(lambda k: (mode[k], k), mode.keys())
|
|
mode.sort()
|
|
mode = mode[-1][1]
|
|
|
|
data = None
|
|
|
|
for p in bucket:
|
|
leap = ""
|
|
dl = p["src"] - last
|
|
|
|
# Non-standard detla...
|
|
if dl != mode:
|
|
|
|
# But only a small gap; add exceptions
|
|
if data and (dl % mode) == 0 and (dl - mode) < 5:
|
|
if "e" not in data: data["e"] = [ ]
|
|
for i in xrange(last + mode, p["src"], mode):
|
|
data["e"].append(i - data["l"])
|
|
|
|
# Big gap; start a new range
|
|
else:
|
|
if data:
|
|
data["h"] -= data["l"]
|
|
|
|
# Small range, use simple LUT instead
|
|
if data["h"] <= 7:
|
|
add_simple_data(data)
|
|
else:
|
|
mappings.append(data)
|
|
debug[data["l"]] = "MAP:" + str(data)
|
|
|
|
# New range
|
|
data = dict(l = 0xffffffff, h = 0, s = delta)
|
|
if mode != 1: data["d"] = mode
|
|
|
|
# Indicate a new range started in the debug info
|
|
leap = "***"
|
|
|
|
# Update ranges
|
|
if p["src"] < data["l"]: data["l"] = p["src"]
|
|
if p["src"] > data["h"]: data["h"] = p["src"]
|
|
last = p["src"]
|
|
|
|
data["h"] -= data["l"]
|
|
if data["h"] <= 7:
|
|
add_simple_data(data)
|
|
else:
|
|
mappings.append(data)
|
|
debug[data["l"]] = "MAP:" + str(data)
|
|
|
|
complex = { }
|
|
for (src, dst, reason) in weird:
|
|
for word in dst.split(" "):
|
|
if len(word) != 4: raise Exception("hmmm")
|
|
complex[int(src, 16)] = dst.replace(" ", "")
|
|
mappings.sort(lambda a, b: cmp(a["l"], b["l"]))
|
|
|
|
debug_keys = debug.keys()
|
|
debug_keys.sort()
|
|
for d in debug_keys:
|
|
print d, debug[d]
|
|
|
|
#print mappings
|
|
|
|
last = 0
|
|
for item in mappings:
|
|
v = item["l"]
|
|
item["l"] -= last
|
|
last = v
|
|
|
|
print "const Table_B_2_ranges = ["
|
|
print ",\n".join((" " + javascript(m)) for m in mappings)
|
|
print "];"
|
|
|
|
print "SS", list(sorted(simple.keys())), simple[120763]
|
|
print "SS2", list(sorted(simple_relative.keys()))
|
|
print "const Table_B_2_lut_abs = createTable(" + javascript_table(simple) + ");"
|
|
print "const Table_B_2_lut_rel = createTable(" + javascript_table(simple_relative) + ");"
|
|
print "const Table_B_2_complex = createTable(" + javascript_table(complex) + ", bytes2);"
|