| From 16b95113bd94a4a722dad1edc55bde645d40dae0 Mon Sep 17 00:00:00 2001 |
| From: Benjamin Pollack <benjamin@bitquabit.com> |
| Date: Mon, 20 Mar 2017 15:16:08 -0400 |
| Subject: [PATCH] Fix the more egregious PEP-8 violations |
| |
| --- |
| scripts/ud_itab.py | 118 +++++++++++++++++++++---------------------- |
| scripts/ud_opcode.py | 73 +++++++++++--------------- |
| 2 files changed, 86 insertions(+), 105 deletions(-) |
| |
| diff --git a/scripts/ud_itab.py b/scripts/ud_itab.py |
| index 31d859e..63de355 100644 |
| --- a/scripts/ud_itab.py |
| +++ b/scripts/ud_itab.py |
| @@ -195,8 +195,8 @@ class UdItabGenerator: |
| "cast" : "P_cast", |
| } |
| |
| - MnemonicAliases = ( "invalid", "3dnow", "none", "db", "pause" ) |
| - |
| + MnemonicAliases = ("invalid", "3dnow", "none", "db", "pause") |
| + |
| def __init__(self, tables): |
| self.tables = tables |
| self._insnIndexMap, i = {}, 0 |
| @@ -221,15 +221,15 @@ def getTableName(self, table): |
| def genOpcodeTable(self, table, isGlobal=False): |
| """Emit Opcode Table in C. |
| """ |
| - self.ItabC.write( "\n" ); |
| + self.ItabC.write("\n") |
| if not isGlobal: |
| self.ItabC.write('static ') |
| - self.ItabC.write( "const uint16_t %s[] = {\n" % self.getTableName(table)) |
| + self.ItabC.write("const uint16_t %s[] = {\n" % self.getTableName(table)) |
| for i in range(table.size()): |
| - if i > 0 and i % 4 == 0: |
| - self.ItabC.write( "\n" ) |
| + if i > 0 and i % 4 == 0: |
| + self.ItabC.write("\n") |
| if i % 4 == 0: |
| - self.ItabC.write( " /* %2x */" % i) |
| + self.ItabC.write(" /* %2x */" % i) |
| e = table.entryAt(i) |
| if e is None: |
| self.ItabC.write("%12s," % "INVALID") |
| @@ -237,35 +237,32 @@ def genOpcodeTable(self, table, isGlobal=False): |
| self.ItabC.write("%12s," % ("GROUP(%d)" % self.getTableIndex(e))) |
| elif isinstance(e, UdInsnDef): |
| self.ItabC.write("%12s," % self.getInsnIndex(e)) |
| - self.ItabC.write( "\n" ) |
| - self.ItabC.write( "};\n" ) |
| - |
| + self.ItabC.write("\n") |
| + self.ItabC.write("};\n") |
| |
| def genOpcodeTables(self): |
| tables = self.tables.getTableList() |
| for table in tables: |
| self.genOpcodeTable(table, table is self.tables.root) |
| |
| - |
| def genOpcodeTablesLookupIndex(self): |
| - self.ItabC.write( "\n\n" ); |
| - self.ItabC.write( "struct ud_lookup_table_list_entry ud_lookup_table_list[] = {\n" ) |
| + self.ItabC.write("\n\n") |
| + self.ItabC.write("struct ud_lookup_table_list_entry ud_lookup_table_list[] = {\n") |
| for table in self.tables.getTableList(): |
| f0 = self.getTableName(table) + "," |
| f1 = table.label() + "," |
| f2 = "\"%s\"" % table.meta() |
| - self.ItabC.write(" /* %03d */ { %s %s %s },\n" % |
| + self.ItabC.write(" /* %03d */ { %s %s %s },\n" % |
| (self.getTableIndex(table), f0, f1, f2)) |
| - self.ItabC.write( "};" ) |
| + self.ItabC.write("};") |
| |
| - |
| - def genInsnTable( self ): |
| - self.ItabC.write( "struct ud_itab_entry ud_itab[] = {\n" ); |
| + def genInsnTable(self): |
| + self.ItabC.write("struct ud_itab_entry ud_itab[] = {\n") |
| for insn in self.tables.getInsnList(): |
| - opr_c = [ "O_NONE", "O_NONE", "O_NONE", "O_NONE" ] |
| + opr_c = ["O_NONE", "O_NONE", "O_NONE", "O_NONE"] |
| pfx_c = [] |
| - opr = insn.operands |
| - for i in range(len(opr)): |
| + opr = insn.operands |
| + for i in range(len(opr)): |
| if not (opr[i] in self.OperandDict.keys()): |
| print("error: invalid operand declaration: %s\n" % opr[i]) |
| opr_c[i] = "O_" + opr[i] |
| @@ -273,18 +270,17 @@ def genInsnTable( self ): |
| opr_c[2] + ",", opr_c[3]) |
| |
| for p in insn.prefixes: |
| - if not ( p in self.PrefixDict.keys() ): |
| + if not (p in self.PrefixDict.keys()): |
| print("error: invalid prefix specification: %s \n" % pfx) |
| - pfx_c.append( self.PrefixDict[p] ) |
| + pfx_c.append(self.PrefixDict[p]) |
| if len(insn.prefixes) == 0: |
| - pfx_c.append( "P_none" ) |
| - pfx = "|".join( pfx_c ) |
| + pfx_c.append("P_none") |
| + pfx = "|".join(pfx_c) |
| |
| - self.ItabC.write( " /* %04d */ { UD_I%s %s, %s },\n" \ |
| - % ( self.getInsnIndex(insn), insn.mnemonic + ',', opr, pfx ) ) |
| - self.ItabC.write( "};\n" ) |
| + self.ItabC.write(" /* %04d */ { UD_I%s %s, %s },\n" \ |
| + % (self.getInsnIndex(insn), insn.mnemonic + ',', opr, pfx)) |
| + self.ItabC.write("};\n") |
| |
| - |
| def getMnemonicsList(self): |
| mnemonics = self.tables.getMnemonicsList() |
| mnemonics.extend(self.MnemonicAliases) |
| @@ -292,88 +288,88 @@ def getMnemonicsList(self): |
| |
| def genMnemonicsList(self): |
| mnemonics = self.getMnemonicsList() |
| - self.ItabC.write( "\n\n" ); |
| - self.ItabC.write( "const char* ud_mnemonics_str[] = {\n " ) |
| - self.ItabC.write( ",\n ".join( [ "\"%s\"" % m for m in mnemonics ] ) ) |
| - self.ItabC.write( "\n};\n" ) |
| - |
| + self.ItabC.write("\n\n") |
| + self.ItabC.write("const char* ud_mnemonics_str[] = {\n ") |
| + self.ItabC.write(",\n ".join(["\"%s\"" % m for m in mnemonics])) |
| + self.ItabC.write("\n};\n") |
| |
| - def genItabH( self, filePath ): |
| - self.ItabH = open( filePath, "w" ) |
| + def genItabH(self, filePath): |
| + self.ItabH = open(filePath, "w") |
| |
| # Generate Table Type Enumeration |
| - self.ItabH.write( "#ifndef UD_ITAB_H\n" ) |
| - self.ItabH.write( "#define UD_ITAB_H\n\n" ) |
| + self.ItabH.write("#ifndef UD_ITAB_H\n") |
| + self.ItabH.write("#define UD_ITAB_H\n\n") |
| |
| self.ItabH.write("/* itab.h -- generated by udis86:scripts/ud_itab.py, do no edit */\n\n") |
| |
| # table type enumeration |
| - self.ItabH.write( "/* ud_table_type -- lookup table types (see decode.c) */\n" ) |
| - self.ItabH.write( "enum ud_table_type {\n " ) |
| + self.ItabH.write("/* ud_table_type -- lookup table types (see decode.c) */\n") |
| + self.ItabH.write("enum ud_table_type {\n ") |
| enum = UdOpcodeTable.getLabels() |
| - self.ItabH.write( ",\n ".join( enum ) ) |
| - self.ItabH.write( "\n};\n\n" ); |
| + self.ItabH.write(",\n ".join(enum)) |
| + self.ItabH.write("\n};\n\n") |
| |
| # mnemonic enumeration |
| - self.ItabH.write( "/* ud_mnemonic -- mnemonic constants */\n" ) |
| - enum = "enum ud_mnemonic_code {\n " |
| - enum += ",\n ".join( [ "UD_I%s" % m for m in self.getMnemonicsList() ] ) |
| + self.ItabH.write("/* ud_mnemonic -- mnemonic constants */\n") |
| + enum = "enum ud_mnemonic_code {\n " |
| + enum += ",\n ".join(["UD_I%s" % m for m in self.getMnemonicsList()]) |
| enum += ",\n UD_MAX_MNEMONIC_CODE" |
| enum += "\n};\n" |
| - self.ItabH.write( enum ) |
| - self.ItabH.write( "\n" ) |
| + self.ItabH.write(enum) |
| + self.ItabH.write("\n") |
| |
| - self.ItabH.write( "extern const char * ud_mnemonics_str[];\n" ) |
| + self.ItabH.write("extern const char * ud_mnemonics_str[];\n") |
| |
| - self.ItabH.write( "\n#endif /* UD_ITAB_H */\n" ) |
| - |
| - self.ItabH.close() |
| + self.ItabH.write("\n#endif /* UD_ITAB_H */\n") |
| |
| + self.ItabH.close() |
| |
| def genItabC(self, filePath): |
| self.ItabC = open(filePath, "w") |
| self.ItabC.write("/* itab.c -- generated by udis86:scripts/ud_itab.py, do no edit") |
| - self.ItabC.write(" */\n"); |
| - self.ItabC.write("#include \"decode.h\"\n\n"); |
| + self.ItabC.write(" */\n") |
| + self.ItabC.write("#include \"decode.h\"\n\n") |
| |
| self.ItabC.write("#define GROUP(n) (0x8000 | (n))\n") |
| self.ItabC.write("#define INVALID %d\n\n" % self.getInsnIndex(self.tables.invalidInsn)) |
| |
| - self.genOpcodeTables() |
| + self.genOpcodeTables() |
| self.genOpcodeTablesLookupIndex() |
| |
| # |
| # Macros defining short-names for operands |
| # |
| - self.ItabC.write("\n\n/* itab entry operand definitions (for readability) */\n"); |
| + self.ItabC.write("\n\n/* itab entry operand definitions (for readability) */\n") |
| operands = self.OperandDict.keys() |
| operands = sorted(operands) |
| for o in operands: |
| self.ItabC.write("#define O_%-7s { %-12s %-8s }\n" % |
| - (o, self.OperandDict[o][0] + ",", self.OperandDict[o][1])); |
| - self.ItabC.write("\n"); |
| + (o, self.OperandDict[o][0] + ",", self.OperandDict[o][1])) |
| + self.ItabC.write("\n") |
| |
| self.genInsnTable() |
| self.genMnemonicsList() |
| |
| self.ItabC.close() |
| |
| - def genItab( self, location ): |
| + def genItab(self, location): |
| self.genItabC(os.path.join(location, "itab.c")) |
| self.genItabH(os.path.join(location, "itab.h")) |
| |
| + |
| def usage(): |
| print("usage: ud_itab.py <optable.xml> <output-path>") |
| |
| -def main(): |
| |
| +def main(): |
| if len(sys.argv) != 3: |
| usage() |
| sys.exit(1) |
| - |
| + |
| tables = UdOpcodeTables(xml=sys.argv[1]) |
| - itab = UdItabGenerator(tables) |
| + itab = UdItabGenerator(tables) |
| itab.genItab(sys.argv[2]) |
| |
| + |
| if __name__ == '__main__': |
| main() |
| diff --git a/scripts/ud_opcode.py b/scripts/ud_opcode.py |
| index fe1833d..4495883 100644 |
| --- a/scripts/ud_opcode.py |
| +++ b/scripts/ud_opcode.py |
| @@ -52,7 +52,6 @@ def lookupPrefix(self, pfx): |
| """Lookup prefix (if any, None otherwise), by name""" |
| return True if pfx in self.prefixes else None |
| |
| - |
| @property |
| def vendor(self): |
| return self._opcexts.get('/vendor', None) |
| @@ -87,9 +86,9 @@ class IndexError(Exception): |
| |
| @classmethod |
| def vendor2idx(cls, v): |
| - return (0 if v == 'amd' |
| - else (1 if v == 'intel' |
| - else 2)) |
| + return (0 if v == 'amd' |
| + else (1 if v == 'intel' |
| + else 2)) |
| |
| @classmethod |
| def vex2idx(cls, v): |
| @@ -166,13 +165,11 @@ def vex2idx(cls, v): |
| '/vexl' : { 'label' : 'UD_TAB__OPC_VEX_L', 'size' : 2 }, |
| } |
| |
| - |
| def __init__(self, typ): |
| assert typ in self._TableInfo |
| - self._typ = typ |
| + self._typ = typ |
| self._entries = {} |
| |
| - |
| def size(self): |
| return self._TableInfo[self._typ]['size'] |
| |
| @@ -191,11 +188,9 @@ def typ(self): |
| def meta(self): |
| return self._typ |
| |
| - |
| def __str__(self): |
| return "table-%s" % self._typ |
| |
| - |
| def add(self, opc, obj): |
| typ = UdOpcodeTable.getOpcodeTyp(opc) |
| idx = UdOpcodeTable.getOpcodeIdx(opc) |
| @@ -203,7 +198,6 @@ def add(self, opc, obj): |
| raise CollisionError() |
| self._entries[idx] = obj |
| |
| - |
| def lookup(self, opc): |
| typ = UdOpcodeTable.getOpcodeTyp(opc) |
| idx = UdOpcodeTable.getOpcodeIdx(opc) |
| @@ -211,7 +205,6 @@ def lookup(self, opc): |
| raise UdOpcodeTable.CollisionError("%s <-> %s" % (self._typ, typ)) |
| return self._entries.get(idx, None) |
| |
| - |
| def entryAt(self, index): |
| """Returns the entry at a given index of the table, |
| None if there is none. Raises an exception if the |
| @@ -234,7 +227,6 @@ def getOpcodeTyp(cls, opc): |
| else: |
| return 'opctbl' |
| |
| - |
| @classmethod |
| def getOpcodeIdx(cls, opc): |
| if opc.startswith('/'): |
| @@ -244,7 +236,6 @@ def getOpcodeIdx(cls, opc): |
| # plain opctbl opcode |
| return int(opc, 16) |
| |
| - |
| @classmethod |
| def getLabels(cls): |
| """Returns a list of all labels""" |
| @@ -282,7 +273,7 @@ def walk(self, tbl, opcodes): |
| to walk, the object at the leaf otherwise. |
| """ |
| opc = opcodes[0] |
| - e = tbl.lookup(opc) |
| + e = tbl.lookup(opc) |
| if e is None: |
| return None |
| elif isinstance(e, UdOpcodeTable) and len(opcodes[1:]): |
| @@ -295,7 +286,7 @@ def map(self, tbl, opcodes, obj): |
| needed. |
| """ |
| opc = opcodes[0] |
| - e = tbl.lookup(opc) |
| + e = tbl.lookup(opc) |
| if e is None: |
| tbl.add(opc, self.mkTrie(opcodes[1:], obj)) |
| else: |
| @@ -304,16 +295,16 @@ def map(self, tbl, opcodes, obj): |
| self.map(e, opcodes[1:], obj) |
| |
| def __init__(self, xml): |
| - self._tables = [] |
| - self._insns = [] |
| + self._tables = [] |
| + self._insns = [] |
| self._mnemonics = {} |
| |
| # The root table is always a 256 entry opctbl, indexed |
| # by a plain opcode byte |
| - self.root = self.newTable('opctbl') |
| + self.root = self.newTable('opctbl') |
| |
| if os.getenv("UD_OPCODE_DEBUG"): |
| - self._logFh = open("opcodeTables.log", "w") |
| + self._logFh = open("opcodeTables.log", "w") |
| |
| # add an invalid instruction entry without any mapping |
| # in the opcode tables. |
| @@ -333,7 +324,6 @@ def log(self, s): |
| if os.getenv("UD_OPCODE_DEBUG"): |
| self._logFh.write(s + "\n") |
| |
| - |
| def mergeSSENONE(self): |
| """Merge sse tables with only one entry for /sse=none |
| """ |
| @@ -345,6 +335,7 @@ def mergeSSENONE(self): |
| if sse: |
| table.setEntryAt(k, sse) |
| uniqTables = {} |
| + |
| def genTableList(tbl): |
| if tbl not in uniqTables: |
| self._tables.append(tbl) |
| @@ -352,9 +343,9 @@ def genTableList(tbl): |
| for k, e in tbl.entries(): |
| if isinstance(e, UdOpcodeTable): |
| genTableList(e) |
| + |
| self._tables = [] |
| genTableList(self.root) |
| - |
| |
| def patchAvx2byte(self): |
| # create avx tables |
| @@ -371,7 +362,6 @@ def patchAvx2byte(self): |
| table = self.walk(self.root, ('c4', '/vex=' + vex)) |
| self.map(self.root, ('c5', '/vex=' + vex), table) |
| |
| - |
| def addInsn(self, **insnDef): |
| |
| # Canonicalize opcode list |
| @@ -409,14 +399,13 @@ def addInsn(self, **insnDef): |
| self._insns.append(insn) |
| # add to lookup by mnemonic structure |
| if insn.mnemonic not in self._mnemonics: |
| - self._mnemonics[insn.mnemonic] = [ insn ] |
| + self._mnemonics[insn.mnemonic] = [insn] |
| else: |
| self._mnemonics[insn.mnemonic].append(insn) |
| |
| - |
| def addInsnDef(self, insnDef): |
| - opcodes = [] |
| - opcexts = {} |
| + opcodes = [] |
| + opcexts = {} |
| |
| # pack plain opcodes first, and collect opcode |
| # extensions |
| @@ -454,7 +443,7 @@ def addInsnDef(self, insnDef): |
| # Construct a long-form definition of the avx instruction |
| opcodes.insert(0, 'c4') |
| elif (opcodes[0] == '0f' and opcodes[1] != '0f' and |
| - '/sse' not in opcexts): |
| + '/sse' not in opcexts): |
| # Make all 2-byte opcode form isntructions play nice with sse |
| # opcode maps. |
| opcexts['/sse'] = 'none' |
| @@ -471,7 +460,6 @@ def addInsnDef(self, insnDef): |
| operands = insnDef['operands'], |
| cpuid = insnDef['cpuid']) |
| |
| - |
| def addSSE2AVXInsn(self, **insnDef): |
| """Add an instruction definition containing an avx cpuid bit, but |
| declared in its legacy SSE form. The function splits the |
| @@ -481,20 +469,20 @@ def addSSE2AVXInsn(self, **insnDef): |
| |
| # SSE |
| ssemnemonic = insnDef['mnemonic'] |
| - sseopcodes = insnDef['opcodes'] |
| + sseopcodes = insnDef['opcodes'] |
| # remove vex opcode extensions |
| - sseopcexts = dict([(e, v) for e, v in itemslist(insnDef['opcexts']) |
| - if not e.startswith('/vex')]) |
| + sseopcexts = dict([(e, v) for e, v in itemslist(insnDef['opcexts']) |
| + if not e.startswith('/vex')]) |
| # strip out avx operands, preserving relative ordering |
| # of remaining operands |
| sseoperands = [opr for opr in insnDef['operands'] |
| - if opr not in ('H', 'L')] |
| + if opr not in ('H', 'L')] |
| # strip out avx prefixes |
| sseprefixes = [pfx for pfx in insnDef['prefixes'] |
| - if not pfx.startswith('vex')] |
| + if not pfx.startswith('vex')] |
| # strip out avx bits from cpuid |
| - ssecpuid = [flag for flag in insnDef['cpuid'] |
| - if not flag.startswith('avx')] |
| + ssecpuid = [flag for flag in insnDef['cpuid'] |
| + if not flag.startswith('avx')] |
| |
| self.addInsn(mnemonic = ssemnemonic, |
| prefixes = sseprefixes, |
| @@ -521,8 +509,8 @@ def addSSE2AVXInsn(self, **insnDef): |
| if o in ('V', 'W', 'H', 'U'): |
| o = o + 'x' |
| vexoperands.append(o) |
| - vexcpuid = [flag for flag in insnDef['cpuid'] |
| - if not flag.startswith('sse')] |
| + vexcpuid = [flag for flag in insnDef['cpuid'] |
| + if not flag.startswith('sse')] |
| |
| self.addInsn(mnemonic = vexmnemonic, |
| prefixes = vexprefixes, |
| @@ -535,7 +523,6 @@ def getInsnList(self): |
| """Returns a list of all instructions in the collection""" |
| return self._insns |
| |
| - |
| def getTableList(self): |
| """Returns a list of all tables in the collection""" |
| return self._tables |
| @@ -544,7 +531,6 @@ def getMnemonicsList(self): |
| """Returns a sorted list of mnemonics""" |
| return sorted(self._mnemonics.keys()) |
| |
| - |
| def pprint(self): |
| def printWalk(tbl, indent=""): |
| entries = tbl.entries() |
| @@ -554,8 +540,8 @@ def printWalk(tbl, indent=""): |
| printWalk(e, indent + " |") |
| elif isinstance(e, UdInsnDef): |
| self.log("%s |-<%02x> %s" % (indent, k, e)) |
| - printWalk(self.root) |
| |
| + printWalk(self.root) |
| |
| def printStats(self): |
| tables = self.getTableList() |
| @@ -574,7 +560,6 @@ def printStats(self): |
| |
| self.pprint() |
| |
| - |
| @staticmethod |
| def parseOptableXML(xml): |
| """Parse udis86 optable.xml file and return list of |
| @@ -584,9 +569,9 @@ def parseOptableXML(xml): |
| |
| xmlDoc = minidom.parse(xml) |
| tlNode = xmlDoc.firstChild |
| - insns = [] |
| + insns = [] |
| |
| - while tlNode and tlNode.localName != "x86optable": |
| + while tlNode and tlNode.localName != "x86optable": |
| tlNode = tlNode.nextSibling |
| |
| for insnNode in tlNode.childNodes: |
| @@ -605,7 +590,7 @@ def parseOptableXML(xml): |
| |
| for node in insnNode.childNodes: |
| if node.localName == 'def': |
| - insnDef = { 'pfx' : [] } |
| + insnDef = {'pfx': []} |
| for node in node.childNodes: |
| if not node.localName: |
| continue |
