Use max line length.

Author: windelbouwman

ppci/arch/encoding.py

@@ -140,13 +140,15 @@ def __init__(self, *args, **kwargs):
             # Set parameters:
             if len(args) != len(formal_args):
                 raise TypeError(
-                    f"{len(args)} arguments given, but {self.__class__} expects {len(formal_args)}"
+                    f"{len(args)} arguments given, but "
+                    + f"{self.__class__} expects {len(formal_args)}"
                 )
             for farg, arg in zip(formal_args, args):
                 if not isinstance(arg, farg._cls):  # pragma: no cover
                     # Create some nice looking error:
                     raise TypeError(
-                        f'{type(self)} expected {farg._cls}, but got "{arg}" of type {type(arg)}'
+                        f"{type(self)} expected {farg._cls}, "
+                        + f'but got "{arg}" of type {type(arg)}'
                     )
                 setattr(self, farg._name, arg)
 

ppci/arch/jvm/nodes.py

@@ -129,7 +129,10 @@ def __init__(self, opcode, args):
         self.args = args
 
     def __repr__(self):
-        return f"instruction(opcode={self.mnemonic} (0x{self.opcode:0X}), args={self.args})"
+        return (
+            f"instruction(opcode={self.mnemonic} (0x{self.opcode:0X}), "
+            + f"args={self.args})"
+        )
 
 
 class Manifest:

ppci/binutils/dbg/cli.py

@@ -61,10 +61,16 @@ def print_file_line(stdout, filename, lineno):
         elif i > len(lines):
             stdout.write("\n")
         elif i == lineno:
-            s = f"\033[33m\033[1m{str(i).rjust(4)}\033[32m->{lines[i - 1]}\033[0m\033[39m\n"
+            s = (
+                f"\033[33m\033[1m{str(i).rjust(4)}\033[32m->"
+                + f"{lines[i - 1]}\033[0m\033[39m\n"
+            )
             stdout.write(s)
         else:
-            s = f"\033[33m\033[1m{str(i).rjust(4)}\033[0m\033[39m  {lines[i - 1]}\n"
+            s = (
+                f"\033[33m\033[1m{str(i).rjust(4)}\033[0m\033[39m  "
+                + f"{lines[i - 1]}\n"
+            )
             stdout.write(s)
 
 

ppci/binutils/dbg/ptcli.py

@@ -6,9 +6,7 @@
 
 # Check version of prompt toolkit:
 if not ptk_version.startswith("3."):
-    print(
-        f"We require prompt toolkit version 3.x, we currently have: {ptk_version}"
-    )
+    print(f"We require prompt toolkit 3.x, we have: {ptk_version}")
 
 from prompt_toolkit import Application
 from prompt_toolkit.buffer import Buffer

ppci/binutils/debuginfo.py

@@ -229,7 +229,10 @@ def __init__(
         self.variables = list(variables)
 
     def __repr__(self):
-        return f"DBGFNC[ {self.name} {self.loc} begin={self.begin}, end={self.end} ]"
+        return (
+            f"DBGFNC[ {self.name} {self.loc} "
+            + f"begin={self.begin}, end={self.end} ]"
+        )
 
     def add_variable(self, variable):
         self.variables.append(variable)

ppci/binutils/objectfile.py

@@ -63,7 +63,11 @@ def is_function(self):
         return self.typ == "func"
 
     def __repr__(self):
-        return f"Symbol({self.name}, binding={self.binding}, val={self.value} section={self.section} typ={self.typ} size={self.size})"
+        return (
+            f"Symbol({self.name}, binding={self.binding}, "
+            + f"val={self.value} section={self.section} "
+            + f"typ={self.typ} size={self.size})"
+        )
 
     def __eq__(self, other):
         return (
@@ -125,7 +129,10 @@ def size(self):
         return len(self.data)
 
     def __repr__(self):
-        return f"SECTION {self.name} size=0x{self.size:x} address=0x{self.address:x}"
+        return (
+            f"SECTION {self.name} size=0x{self.size:x} "
+            + f"address=0x{self.address:x}"
+        )
 
     def __eq__(self, other):
         return (

ppci/cli/base.py

@@ -12,7 +12,11 @@
 from ..utils.reporting import TextReportGenerator
 
 
-version_text = f"ppci {__version__} on {platform.python_implementation()} {platform.python_version()} on {platform.platform()}"
+version_text = (
+    f"ppci {__version__}"
+    + f" on {platform.python_implementation()} {platform.python_version()}"
+    + f" on {platform.platform()}"
+)
 
 
 def log_level(s):

ppci/codegen/burg.py

@@ -343,9 +343,8 @@ def emit_record(self, rule, state_var):
         )
         self.print(
             4,
-            (
-                f"c = sum(x.state.get_cost(y) for x, y in zip(kids, nts)) + {rule.cost}"
-            ),
+            "c = sum(x.state.get_cost(y) for x, y in zip(kids, nts)) "
+            + f"+ {rule.cost}",
         )
         self.print(
             4,
@@ -355,7 +354,8 @@ def emit_record(self, rule, state_var):
             self.print(4, f"# Chain rule: {cr}")
             self.print(
                 4,
-                f'tree.state.set_cost("{cr.non_term}", c + {cr.cost}, {cr.nr})',
+                f'tree.state.set_cost("{cr.non_term}", c'
+                + f" + {cr.cost}, {cr.nr})",
             )
 
     def emit_state(self):

ppci/codegen/registerallocator.py

@@ -264,7 +264,7 @@ def alloc_frame(self, frame: Frame):
                 max_spill_rounds = 30
                 if spill_rounds > max_spill_rounds:
                     raise RuntimeError(
-                        f"Give up: more than {max_spill_rounds} spill rounds done!"
+                        f"Give up after {max_spill_rounds} spill rounds!"
                     )
 
                 # Rewrite program now.
@@ -724,15 +724,15 @@ def rewrite_program(self, node):
                     code = self.spill_gen.gen_load(self.frame, vreg2, slot)
                     if self.verbose:
                         self.reporter.message(
-                            f"Load code before instruction: {list(map(str, code))}"
+                            f"Load code before: {list(map(str, code))}"
                         )
                     self.frame.insert_code_before(instruction, code)
 
                 if instruction.writes_register(vreg2):
                     code = self.spill_gen.gen_store(self.frame, vreg2, slot)
                     if self.verbose:
                         self.reporter.message(
-                            f"Store code after instruction: {list(map(str, code))}"
+                            f"Store code after: {list(map(str, code))}"
                         )
                     self.frame.insert_code_after(instruction, code)
 

ppci/ir.py

@@ -223,7 +223,10 @@ def stats(self):
         num_functions = len(self.functions)
         num_blocks = sum(len(f.blocks) for f in self.functions)
         num_instructions = sum(f.num_instructions() for f in self.functions)
-        return f"functions: {num_functions}, blocks: {num_blocks}, instructions: {num_instructions}"
+        return (
+            f"functions: {num_functions}, blocks: {num_blocks}, "
+            + f"instructions: {num_instructions}"
+        )
 
 
 class Value:
@@ -965,7 +968,10 @@ def __init__(self, a, operation, b, name, ty):
         self.operation = operation
 
     def __str__(self):
-        return f"{self.ty} {self.name} = {self.a.name} {self.operation} {self.b.name}"
+        return (
+            f"{self.ty} {self.name} = "
+            + f"{self.a.name} {self.operation} {self.b.name}"
+        )
 
 
 def add(a, b, name, ty):
@@ -1059,7 +1065,10 @@ def __init__(self, name: str, amount: int, alignment: int):
         self.alignment = alignment
 
     def __str__(self):
-        return f"{self.ty} {self.name} = alloc {self.amount} bytes aligned at {self.alignment}"
+        return (
+            f"{self.ty} {self.name} = "
+            + f"alloc {self.amount} bytes aligned at {self.alignment}"
+        )
 
 
 class CopyBlob(Instruction):
@@ -1105,7 +1114,10 @@ def __init__(self, name, binding, amount, alignment, value=None):
         self.value = value
 
     def __str__(self):
-        return f"{self.binding} variable {self.name} ({self.amount} bytes aligned at {self.alignment})"
+        return (
+            f"{self.binding} variable {self.name} "
+            + f"({self.amount} bytes aligned at {self.alignment})"
+        )
 
 
 class Parameter(LocalValue):
@@ -1337,7 +1349,10 @@ def __init__(self, a, cond, b, lab_yes, lab_no):
         self.lab_no = lab_no
 
     def __str__(self):
-        return f"cjmp {self.a.name} {self.cond} {self.b.name} ? {self.lab_yes.name} : {self.lab_no.name}"
+        return (
+            f"cjmp {self.a.name} {self.cond} {self.b.name} ? "
+            + f"{self.lab_yes.name} : {self.lab_no.name}"
+        )
 
 
 class JumpTable(JumpBase):