File automated-convertion-form-2to3.patch of Package python-PeachPy

Overview Repositories Revisions Requests Users Attributes Meta

File automated-convertion-form-2to3.patch of Package python-PeachPy

From f4eb6bb74d7e99733f9a273f212dc51ea1e4f915 Mon Sep 17 00:00:00 2001
From: Christian Goll <cgoll@suse.de>
Date: Mon, 9 Sep 2019 11:49:04 +0200
Subject: [PATCH] automated convertion form 2to3

---
 codegen/x86_64.py               | 44 +++++++++++++++++------------------------
 codegen/x86_64_nacl_test.py     | 12 ++++++-----
 codegen/x86_64_test_encoding.py |  7 ++++---
 3 files changed, 29 insertions(+), 34 deletions(-)

diff --git a/codegen/x86_64.py b/codegen/x86_64.py
index 82a4fee..a4c9d74 100644
--- a/codegen/x86_64.py
+++ b/codegen/x86_64.py
@@ -1,6 +1,7 @@
 # This file is part of PeachPy package and is licensed under the Simplified BSD license.
 #    See license.rst for the full text of the license.
 
+
 from __future__ import print_function
 import opcodes
 import copy
@@ -81,8 +82,7 @@ def aggregate_instruction_forms(instruction_forms):
         if len(form.operands) != len(other_form.operands):
             return None
         different_operand_numbers = \
-            list(filter(lambda n: form.operands[n].type != other_form.operands[n].type,
-                        range(len(form.operands))))
+            list([n for n in range(len(form.operands)) if form.operands[n].type != other_form.operands[n].type])
         if len(different_operand_numbers) == 1:
             return different_operand_numbers[0]
         else:
@@ -616,7 +616,7 @@ def get_out_operands(instruction_form):
 
 def get_isa_extensions(instruction_form):
     """Returns a hashable immutable set with names of ISA extensions required for this instructions form"""
-    return frozenset(map(operator.attrgetter("name"), instruction_form.isa_extensions))
+    return frozenset(list(map(operator.attrgetter("name"), instruction_form.isa_extensions)))
 
 
 def go_name_init(code, instruction_form):
@@ -729,8 +729,7 @@ def instruction_branch_label_form_init(code, instruction_form, instruction_subfo
         gas_name_init(code, instruction_form)
 
     for form in ([instruction_form] + list(map(operator.itemgetter(1), instruction_subforms))):
-        encoding_lambdas = list(map(lambda e: generate_encoding_lambda(e, form.operands, use_off_argument=True),
-                                    form.encodings))
+        encoding_lambdas = list([generate_encoding_lambda(e, form.operands, use_off_argument=True) for e in form.encodings])
         assert len(encoding_lambdas) == 1, \
             "Branch label instructions are expected to have only one encoding for each operand type"
         flags, encoding_lambda = encoding_lambdas[0]
@@ -769,8 +768,7 @@ def instruction_form_init(code, instruction_form, instruction_subforms,
         code.line("if %s:" % operand_check)
         with CodeBlock():
             # Record lambda functions that encode the instruction subform
-            encoding_lambdas = map(lambda e: generate_encoding_lambda(e, instruction_subform.operands),
-                                   instruction_subform.encodings)
+            encoding_lambdas = [generate_encoding_lambda(e, instruction_subform.operands) for e in instruction_subform.encodings]
             flags = 0
             if instruction_subform.operands[operand_number].is_variable:
                 assert instruction_subform.operands[operand_number].type in {"al", "ax", "eax", "rax"}, \
@@ -782,7 +780,7 @@ def instruction_form_init(code, instruction_form, instruction_subforms,
                 code.line("self.encodings.append((0x%02X, %s))" % (flags | encoding_flags, encoding_lambda))
 
     # Record lambda functions that encode the most generic instruction form
-    encodings = map(lambda e: generate_encoding_lambda(e, instruction_form.operands), instruction_form.encodings)
+    encodings = [generate_encoding_lambda(e, instruction_form.operands) for e in instruction_form.encodings]
     for (flags, encoding_lambda) in encodings:
         code.line("self.encodings.append((0x%02X, %s))" % (flags, encoding_lambda))
 
@@ -836,8 +834,7 @@ def reduce_operand_types(operand_types_list):
             if len(operand_types) != len(other_operand_types):
                 continue
             different_operand_numbers = \
-                list(filter(lambda n: operand_types[n] != other_operand_types[n],
-                            range(len(operand_types))))
+                list([n for n in range(len(operand_types)) if operand_types[n] != other_operand_types[n]])
             if len(different_operand_numbers) == 1:
                 operand_number = different_operand_numbers[0]
                 if (operand_types[operand_number], other_operand_types[operand_number]) in nested_operand_types:
@@ -878,8 +875,7 @@ def reduce_operand_types(operand_types_list):
             if len(operand_types) != len(other_operand_types):
                 continue
             different_operand_numbers = \
-                list(filter(lambda n: operand_types[n] != other_operand_types[n],
-                       range(len(operand_types))))
+                list([n for n in range(len(operand_types)) if operand_types[n] != other_operand_types[n]])
             if len(different_operand_numbers) == 1:
                 operand_number = different_operand_numbers[0]
                 if (other_operand_types[operand_number], operand_types[operand_number]) in mergeble_operand_types:
@@ -897,7 +893,7 @@ def reduce_operand_types(operand_types_list):
 
 def score_isa_extensions(isa_extensions):
     if isa_extensions:
-        return max(map(operator.attrgetter("score"), isa_extensions))
+        return max(list(map(operator.attrgetter("score"), isa_extensions)))
     return 0
 
 
@@ -920,12 +916,12 @@ def supported_forms_comment(code, instruction_forms):
         return reduce_operand_types(operand_types_list)
 
     def get_isa_extensions(instruction_forms):
-        isa_extensions = map(operator.attrgetter("isa_extensions"), instruction_forms)
-        isa_extensions = map(lambda ext: sorted(ext, key=operator.attrgetter("score")), isa_extensions)
+        isa_extensions = list(map(operator.attrgetter("isa_extensions"), instruction_forms))
+        isa_extensions = [sorted(ext, key=operator.attrgetter("score")) for ext in isa_extensions]
         return isa_extensions
 
     form_descriptions = format_form_descriptions(instruction_forms[0].name, get_operand_types_list(instruction_forms))
-    padding_length = max(map(len, form_descriptions))
+    padding_length = max(list(map(len, form_descriptions)))
 
     form_isa_extensions_options = sorted(set(map(tuple, get_isa_extensions(instruction_forms))),
                                          key=lambda isa_tuple: score_isa_extensions(isa_tuple))
@@ -933,7 +929,7 @@ def supported_forms_comment(code, instruction_forms):
         isa_description = ""
         if isa_extensions_option:
             isa_description = "[" + " and ".join(map(str, isa_extensions_option)) + "]"
-        isa_forms = list(filter(lambda form: tuple(sorted(form.isa_extensions, key=operator.attrgetter("score"))) == isa_extensions_option, instruction_forms))
+        isa_forms = list([form for form in instruction_forms if tuple(sorted(form.isa_extensions, key=operator.attrgetter("score"))) == isa_extensions_option])
         for form_description in format_form_descriptions(instruction_forms[0].name, get_operand_types_list(isa_forms)):
             if isa_description:
                 padding = " " * (4 + padding_length - len(form_description))
@@ -974,7 +970,7 @@ def main(package_root="."):
                 code.line()
                 for name in instruction_names:
                     # Instructions with `name` name
-                    name_instructions = list(filter(lambda i: i.name == name, instruction_set))
+                    name_instructions = list([i for i in instruction_set if i.name == name])
                     if not name_instructions:
                         print("No forms for instruction: " + name)
                         continue
@@ -1043,9 +1039,7 @@ def main(package_root="."):
                                     code.line("%s len(self.operands) == %d:" % ("if" if index == 0 else "elif", count))
                                 with CodeBlock(consider_operand_count):
                                     # Consider only instruction forms that have exactly `count` operands
-                                    count_operand_form_trees = list(filter(lambda form_subforms:
-                                                                           len(form_subforms[0].operands) == count,
-                                                                           six.iteritems(instruction_forms)))
+                                    count_operand_form_trees = list([form_subforms for form_subforms in six.iteritems(instruction_forms) if len(form_subforms[0].operands) == count])
                                     # Make sure operand forms with simpler ISA are checked first.
                                     # This is needed because AVX instructions can be encoded as AVX-512 instructions.
                                     # Thus, we should first check if operands match AVX specification, and only if that
@@ -1065,10 +1059,10 @@ def main(package_root="."):
                                     out_operands_options = set(map(get_out_operands, count_operand_forms))
                                     common_out_operands = combine_attrs and len(out_operands_options) == 1
                                     # Check how many gas names exist
-                                    gas_names = set(map(lambda form: form.gas_name, count_operand_forms))
+                                    gas_names = set([form.gas_name for form in count_operand_forms])
                                     common_gas_name = combine_attrs and len(gas_names) == 1
                                     # Check how many go names exist
-                                    go_names = set(map(lambda form: str(form.go_name), count_operand_forms))
+                                    go_names = set([str(form.go_name) for form in count_operand_forms])
                                     common_go_name = combine_attrs and len(go_names) == 1
                                     # Check how many mmx modes exist
                                     mmx_modes = set(map(operator.attrgetter("mmx_mode"), count_operand_forms))
@@ -1108,9 +1102,7 @@ def main(package_root="."):
                                         for (form_index, (instruction_form, instruction_subforms)) \
                                                 in enumerate(count_operand_form_trees):
                                             is_avx512 = is_avx512_instruction_form(instruction_form)
-                                            operand_checks = map(
-                                                lambda o: generate_operand_check(o[0], o[1], evex_form=is_avx512),
-                                                enumerate(instruction_form.operands))
+                                            operand_checks = [generate_operand_check(o[0], o[1], evex_form=is_avx512) for o in enumerate(instruction_form.operands)]
                                             code.line("%s %s:" % ("if" if form_index == 0 else "elif", " and ".join(operand_checks)))
                                             with CodeBlock():
                                                 instruction_form_init(code, instruction_form, instruction_subforms,
diff --git a/codegen/x86_64_nacl_test.py b/codegen/x86_64_nacl_test.py
index c2b1374..36fcfd8 100644
--- a/codegen/x86_64_nacl_test.py
+++ b/codegen/x86_64_nacl_test.py
@@ -1,11 +1,13 @@
 # This file is part of PeachPy package and is licensed under the Simplified BSD license.
 #    See license.rst for the full text of the license.
 
+
 from __future__ import print_function
 from opcodes.x86_64 import *
 from codegen.code import CodeWriter, CodeBlock
 import operator
 import json
+import os
 
 
 instruction_set = read_instruction_set()
@@ -69,13 +71,13 @@ from peachpy.x86_64 import *\n\
 \n\
 instruction_list = []\n\
 ", file=out)
-    for group, instruction_names in instruction_groups.iteritems():
+    for group, instruction_names in instruction_groups.items():
         with CodeWriter() as code:
             code.line("# " + group)
             for name in instruction_names:
 
                 # Instructions with `name` name
-                name_instructions = filter(lambda i: i.name == name, instruction_set)
+                name_instructions = [i for i in instruction_set if i.name == name]
                 if not name_instructions:
                     print("No forms for instruction: " + name)
                     continue
@@ -84,8 +86,8 @@ instruction_list = []\n\
 
                 code.line()
                 for instruction_form in filter_instruction_forms(name_instruction.forms):
-                    operands = map(generate_operand, instruction_form.operands)
-                    if not any(map(lambda op: op is None, operands)):
+                    operands = list(map(generate_operand, instruction_form.operands))
+                    if not any([op is None for op in operands]):
                         instruction_text = "%s(%s)" % (instruction_form.name, ", ".join(operands))
                         if any(map(operator.attrgetter("is_memory"), instruction_form.operands)):
                             code.line("instruction_list.append((\"%s\", (MOV(esi, esi), %s)))" % (str(instruction_form), instruction_text))
@@ -111,4 +113,4 @@ for (text, instructions) in instruction_list:\n\
     print(\"\\t\\\"%s\\\",\" % text, file=names)\n\
 \n\
 print(\"};\\n\", file=names)\n\
-print(\"};\\n\", file=bundles)", file=out)
\ No newline at end of file
+print(\"};\\n\", file=bundles)", file=out)
diff --git a/codegen/x86_64_test_encoding.py b/codegen/x86_64_test_encoding.py
index d0d097f..a5246e1 100644
--- a/codegen/x86_64_test_encoding.py
+++ b/codegen/x86_64_test_encoding.py
@@ -1,6 +1,7 @@
 # This file is part of PeachPy package and is licensed under the Simplified BSD license.
 #    See license.rst for the full text of the license.
 
+
 from __future__ import print_function
 from opcodes.x86_64 import *
 from codegen.code import CodeWriter, CodeBlock
@@ -200,7 +201,7 @@ def generate_operand(operand, operand_number, peachpy=True, evex=False):
 tab = " " * 4
 
 def main(package_root="."):
-    for group, instruction_names in instruction_groups.items():
+    for group, instruction_names in list(instruction_groups.items()):
         with open(os.path.join (package_root, "test", "x86_64", "encoding", "test_%s.py" % group), "w") as out:
             with CodeWriter() as code:
                 code.line("# This file is auto-generated by /codegen/x86_64_test_encoding.py")
@@ -217,7 +218,7 @@ def main(package_root="."):
                         code.line("def runTest(self):")
                         with CodeBlock():
                             # Instructions with `name` name
-                            name_instructions = list(filter(lambda i: i.name == name, instruction_set))
+                            name_instructions = list([i for i in instruction_set if i.name == name])
                             if not name_instructions:
                                 print("No forms for instruction: " + name)
                                 continue
@@ -231,7 +232,7 @@ def main(package_root="."):
                                                     in enumerate(instruction_form.operands)]
                                 gas_operands = [generate_operand(o, i, peachpy=False, evex=is_avx512) for (i, o)
                                                 in enumerate(instruction_form.operands)]
-                                if not any(map(lambda op: op is None, gas_operands)):
+                                if not any([op is None for op in gas_operands]):
                                     gas_assembly = "%s %s" % (instruction_form.name, ", ".join(gas_operands))
                                     peachpy_assembly = "%s(%s)" % (instruction_form.name, ", ".join(peachpy_operands))
                                     reference_bytecode = binutils_encode(gas_assembly)
-- 
2.16.4

Places

File automated-convertion-form-2to3.patch of Package python-PeachPy

Places