xasm 1.2.0__py310-none-any.whl → 1.2.1__py310-none-any.whl

xasm/assemble.py

@@ -1,27 +1,35 @@
 #!/usr/bin/env python
-import ast, re, xdis
-from xdis.opcodes.base import cmp_op
+import ast
+import re
+from typing import Any, List, Optional
+
+import xdis
 from xdis import get_opcode, load_module
+from xdis.opcodes.base import cmp_op
 from xdis.version_info import PYTHON_VERSION_TRIPLE, version_str_to_tuple
 
 # import xdis.bytecode as Mbytecode
 
-class Instruction(object):  # (Mbytecode.Instruction):
-    def __repr__(self):
-        s = ""
+
+class Instruction:  # (Mbytecode.Instruction):
+    line_no: Optional[int]
+    opname: str
+    arg: Optional[int]
+
+    def __repr__(self) -> str:
         if self.line_no:
             s = "%4d: " % self.line_no
         else:
             s = " " * 6
-        s += "%-15s" % self.opname
+        s += f"{self.opname:15}"
         if self.arg is not None:
-            s += "\t%s" % self.arg
+            s += f"\t{self.arg}"
         return s
 
     pass
 
 
-def is_int(s):
+def is_int(s: Any) -> bool:
     try:
         int(s)
         return True
@@ -29,11 +37,11 @@ def is_int(s):
         return False
 
 
-def is_lineno(s):
+def match_lineno(s: str):
     return re.match(r"^\d+:", s)
 
 
-def get_opname_operand(opc, fields):
+def get_opname_operand(opc, fields: List[str]):
     assert len(fields) > 0
     opname = fields[0]
     if opc.opmap[opname] < opc.HAVE_ARGUMENT:
@@ -42,9 +50,9 @@ def get_opname_operand(opc, fields):
         if is_int(fields[1]):
             operand = int(fields[1])
         else:
-            operand = ' '.join(fields[1:])
+            operand = " ".join(fields[1:])
             if operand.startswith("(to "):
-                int_val = operand[len("(to "):]
+                int_val = operand[len("(to ") :]
                 # In xasm format this shouldn't appear
                 if is_int(int_val):
                     operand = int(int_val)
@@ -54,12 +62,12 @@ def get_opname_operand(opc, fields):
         return opname, None
 
 
-class Assembler(object):
-    def __init__(self, python_version, is_pypy):
+class Assembler:
+    def __init__(self, python_version, is_pypy) -> None:
         self.opc = get_opcode(python_version, is_pypy)
         self.code_list = []
         self.codes = []  # FIXME use a better name
-        self.status = "unfinished"
+        self.status: str = "unfinished"
         self.size = 0  # Size of source code. Only relevant in version 3 and above
         self.python_version = python_version
         self.timestamp = None
@@ -68,8 +76,7 @@ class Assembler(object):
         self.code = None
         self.siphash = None
 
-    def code_init(self, python_version=None):
-
+    def code_init(self, python_version=None) -> None:
         if self.python_version is None and python_version:
             self.python_version = python_version
 
@@ -95,50 +102,70 @@ class Assembler(object):
 
         self.code.instructions = []
 
-    def update_lists(self, co, label, backpatch):
+    def update_lists(self, co, label, backpatch) -> None:
         self.code_list.append(co)
         self.codes.append(self.code)
         self.label.append(label)
         self.backpatch.append(backpatch)
 
-    def print_instructions(self):
+    def print_instructions(self) -> None:
         for inst in self.code.instructions:
             if inst.line_no:
                 print()
             print(inst)
 
-    def err(self, mess):
-        print(mess)
+    def warn(self, mess: str) -> None:
+        """
+        Print an error message and record that we warned, unless we have already errored.
+        """
+        print("Warning: ", mess)
+        if self.status != "errored":
+            self.status = "warning"
+
+    def err(self, mess: str) -> None:
+        """
+        Print an error message and record that we errored.
+        """
+        print("Error: ", mess)
         self.status = "errored"
 
 
-def asm_file(path):
+def asm_file(path) -> Optional[Assembler]:
     offset = 0
     methods = {}
     method_name = None
     asm = None
     backpatch_inst = set([])
     label = {}
-    python_version = None
+    python_bytecode_version = None
     lines = open(path).readlines()
     i = 0
     bytecode_seen = False
     while i < len(lines):
         line = lines[i]
         i += 1
+        if line.startswith("##"):
+            # comment line
+            continue
         if line.startswith(".READ"):
             match = re.match("^.READ (.+)$", line)
             if match:
                 input_pyc = match.group(1)
                 print(f"Reading {input_pyc}")
-                (version, timestamp, magic_int, co, is_pypy, source_size, sip_hash) = load_module(
-                    input_pyc
-                )
-                if python_version and python_version != version:
+                (
+                    version,
+                    timestamp,
+                    magic_int,
+                    co,
+                    is_pypy,
+                    source_size,
+                    sip_hash,
+                ) = load_module(input_pyc)
+                if python_bytecode_version and python_bytecode_version != version:
                     TypeError(
-                        f"We previously saw Python version {python_version} but we just loaded {version}.\n"
+                        f"We previously saw Python version {python_bytecode_version} but we just loaded {version}.\n"
                     )
-                python_version = version
+                python_bytecode_version = version
                 # FIXME: extract all code options below the top-level and asm.code_list
 
         elif line.startswith("#"):
@@ -151,15 +178,18 @@ def asm_file(path):
                     is_pypy = False
                     pypy_str = ""
 
-                version = (
+                python_bytecode_version = (
                     line[len("# Python bytecode " + pypy_str) :].strip().split()[0]
                 )
 
-                python_version_pair = version_str_to_tuple(python_version, len=2)
+                python_version_pair = version_str_to_tuple(
+                    python_bytecode_version, length=2
+                )
                 asm = Assembler(python_version_pair, is_pypy)
                 if python_version_pair >= (3, 10):
                     TypeError(
-                        f"Creating Python version {python_version} not supported yet. Feel free to fix and put in a PR.\n"
+                        f"Creating Python version {python_bytecode_version} not supported yet. "
+                        "Feel free to fix and put in a PR.\n"
                     )
                 asm.code_init(python_version_pair)
                 bytecode_seen = True
@@ -170,15 +200,25 @@ def asm_file(path):
                     asm.timestamp = int(time_str)
             elif line.startswith("# Method Name: "):
                 if method_name:
-                    co = create_code(asm, label, backpatch_inst)
+                    co, is_valid = create_code(asm, label, backpatch_inst)
+                    if not is_valid:
+                        return
                     asm.update_lists(co, label, backpatch_inst)
                     label = {}
                     backpatch_inst = set([])
                     methods[method_name] = co
                     offset = 0
-                python_version_pair = version_str_to_tuple(python_version, len=2)
+                if python_bytecode_version is None:
+                    raise TypeError(
+                        f'Line {i}: "Python bytecode" not seen before "Method Name:"; please set this.'
+                    )
+                python_version_pair = version_str_to_tuple(
+                    python_bytecode_version, length=2
+                )
                 asm.code_init(python_version_pair)
-                asm.code.co_name = line[len("# Method Name: ") :].strip()
+                asm.code.co_qual_name = asm.code.co_name = line[
+                    len("# Method Name: ") :
+                ].strip()
                 method_name = asm.code.co_name
             elif line.startswith("# SipHash: "):
                 siphash = line[len("# ShipHash: ") :].strip().split()[0]
@@ -227,9 +267,8 @@ def asm_file(path):
                     if match:
                         index = int(match.group(1))
                         assert index == count, (
-                            "Constant index {%d} found on line {%d}"
-                            "doesn't match expected constant index {%d}."
-                            % (index, i, count)
+                            f"Constant index {index} found on line {i} "
+                            f"doesn't match expected constant index {count}."
                         )
                         expr = match.group(2)
                         match = re.match(
@@ -239,7 +278,7 @@ def asm_file(path):
                             name = match.group(1)
                             m2 = re.match("^<(.+)>$", name)
                             if m2:
-                                name = "%s_%s" % (m2.group(1), match.group(2))
+                                name = f"{m2.group(1)}_{match.group(2)}"
                             if name in methods:
                                 asm.code.co_consts.append(methods[name])
                             else:
@@ -248,7 +287,7 @@ def asm_file(path):
                                 )
                                 bogus_name = f"**bogus {name}**"
                                 print(f"\t appending {bogus_name} to list of constants")
-                                asm.code.co_consts.append()
+                                asm.code.co_consts.append(bogus_name)
                         else:
                             asm.code.co_consts.append(ast.literal_eval(expr))
                         count += 1
@@ -276,46 +315,73 @@ def asm_file(path):
             if not line.strip():
                 continue
 
-            match = re.match(r"^([^\s]+):$", line)
+            match = re.match(r"^(\S+):$", line)
             if match:
-                label[match.group(1)] = offset
-                continue
+                label_value = match.group(1)
+                # All-numeric labels, i.e. line numbers, are handled below
+                if not re.match(r"^(\d+)$", label_value):
+                    label[label_value] = offset
+                    continue
+
+            line_no = None
+
+            match = re.match(r"^\s*(\d+):\s*", line)
+
+            # Sanity checking: make sure we have seen
+            # proper header lines
+            if i == 1:
+                assert bytecode_seen, (
+                    f"Improper beginning:\n{line}"
+                    "\nLine should begin with '#' "
+                    "and contain header bytecode header information."
+                )
+            assert bytecode_seen, (
+                f"Error translating line {i}: "
+                "a line before this should include: \n"
+                "# Python bytecode <version>"
+            )
 
-            match = re.match(r"^\s*([\d]+):\s*$", line)
             if match:
                 line_no = int(match.group(1))
-                asm.code.co_lnotab[offset] = line_no
-                continue
+                linetable_field = (
+                    "co_lnotab" if python_version_pair < (3, 10) else "co_linetable"
+                )
+                assert asm is not None
+                linetable = getattr(asm.code, linetable_field)
+                linetable[offset] = line_no
 
             # Opcode section
-            assert (
-                bytecode_seen
-            ), "File needs to start out with: # Python bytecode <version>"
             fields = line.strip().split()
-            line_no = None
             num_fields = len(fields)
 
-            if num_fields > 1:
-                if fields[0] == ">>":
-                    fields = fields[1:]
-                    num_fields -= 1
-                if is_lineno(fields[0]) and is_int(fields[1]):
-                    line_no = int(fields[0][:-1])
-                    opname, operand = get_opname_operand(asm.opc, fields[2:])
-                elif is_lineno(fields[0]):
-                    line_no = int(fields[0][:-1])
-                    fields = fields[1:]
+            if num_fields == 1 and line_no is not None:
+                continue
+
+            try:
+                if num_fields > 1:
                     if fields[0] == ">>":
                         fields = fields[1:]
-                        if is_int(fields[0]):
+                        num_fields -= 1
+                    if match_lineno(fields[0]) and is_int(fields[1]):
+                        line_no = int(fields[0][:-1])
+                        opname, operand = get_opname_operand(asm.opc, fields[2:])
+                    elif match_lineno(fields[0]):
+                        line_no = int(fields[0][:-1])
+                        fields = fields[1:]
+                        if fields[0] == ">>":
                             fields = fields[1:]
-                    opname, operand = get_opname_operand(asm.opc, fields)
-                elif is_int(fields[0]):
-                    opname, operand = get_opname_operand(asm.opc, fields[1:])
+                            if is_int(fields[0]):
+                                fields = fields[1:]
+                        opname, operand = get_opname_operand(asm.opc, fields)
+                    elif is_int(fields[0]):
+                        opname, operand = get_opname_operand(asm.opc, fields[1:])
+                    else:
+                        opname, operand = get_opname_operand(asm.opc, fields)
                 else:
-                    opname, operand = get_opname_operand(asm.opc, fields)
-            else:
-                opname, _ = get_opname_operand(asm.opc, fields)
+                    opname, _ = get_opname_operand(asm.opc, fields)
+            except Exception as e:
+                print(f"Line {i}: {e}")
+                raise
 
             if opname in asm.opc.opname:
                 inst = Instruction()
@@ -332,19 +398,22 @@ def asm_file(path):
                         backpatch_inst.add(inst)
                 offset += xdis.op_size(inst.opcode, asm.opc)
             else:
-                raise RuntimeError("Illegal opname %s in:\n%s" % (opname, line))
+                raise RuntimeError(f"Illegal opname {opname} in:\n{line}")
             pass
         pass
-    # print(asm.code.co_lnotab)
-    if asm:
-        co = create_code(asm, label, backpatch_inst)
+
+    if asm is not None:
+        # print(linetable)
+
+        co, is_valid = create_code(asm, label, backpatch_inst)
         asm.update_lists(co, label, backpatch_inst)
-    asm.code_list.reverse()
-    asm.status = "finished"
+        asm.code_list.reverse()
+        asm.status = "finished"
+
     return asm
 
 
-def member(fields, match_value):
+def member(fields, match_value) -> int:
     for i, v in enumerate(fields):
         if v == match_value and type(v) == type(match_value):
             return i
@@ -352,7 +421,7 @@ def member(fields, match_value):
     return -1
 
 
-def update_code_field(field_name, value, inst, opc):
+def update_code_field(field_name: str, value, inst, opc) -> None:
     field_values = getattr(opc, field_name)
     # Can't use "in" because True == 1 and False == 0
     # if value in l:
@@ -364,7 +433,7 @@ def update_code_field(field_name, value, inst, opc):
         field_values.append(value)
 
 
-def update_code_tuple_field(field_name, code, lines, i):
+def update_code_tuple_field(field_name: str, code, lines: List[str], i: int):
     count = 0
     while i < len(lines):
         line = lines[i]
@@ -372,7 +441,9 @@ def update_code_tuple_field(field_name, code, lines, i):
         match = re.match(r"^#\s+(\d+): (.+)$", line)
         if match:
             index = int(match.group(1))
-            assert index == count
+            assert (
+                index == count
+            ), f'In field" "{field_name}", line {i}, number {index} is expected to have value {count}.'
             field_values = getattr(code, field_name)
             field_values.append(match.group(2))
             count += 1
@@ -380,17 +451,26 @@ def update_code_tuple_field(field_name, code, lines, i):
             i -= 1
             break
         pass
-    pass
     return i
 
 
-def err(msg, inst, i):
+def err(msg: str, inst, i: int):
     msg += ". Instruction %d:\n%s" % (i, inst)
     raise RuntimeError(msg)
 
 
-def decode_lineno_tab(lnotab, first_lineno):
+def warn(mess: str) -> None:
+    """
+    Print an error message and record that we warned.
+    """
+    print("Warning: ", mess)
+
 
+def decode_lineno_tab_old(lnotab, first_lineno: int) -> dict:
+    """
+    Uncompresses line number table for Python versions before
+    3.10
+    """
     line_number, line_number_diff = first_lineno, 0
     offset, offset_diff = 0, 0
     uncompressed_lnotab = {}
@@ -409,28 +489,138 @@ def decode_lineno_tab(lnotab, first_lineno):
             continue
         line_number += line_number_diff
         offset += offset_diff
-        line_number_diff, offset_diff = 0, 0
         uncompressed_lnotab[offset] = line_number
 
     return uncompressed_lnotab
 
 
-def create_code(asm, label, backpatch):
+def is_code_ok(asm: Assembler) -> bool:
+    """
+    Performs some sanity checks on code.
+    """
+
+    is_valid: bool = True
+
+    code = asm.code
+    last_instruction = code.instructions[-1]
+    last_offset = last_instruction.offset
+    if last_instruction.opname not in ("RETURN_VALUE", "RERAISE", "RAISE_VARARGS"):
+        warn(
+            f"Last instruction of at offset {last_offset} of {code.co_name}"
+            f' should be "RETURN_VALUE", is "{last_instruction.opname}"'
+        )
+        is_valid = False
+
+    cells_free_len = len(code.co_freevars) + len(code.co_cellvars)
+    consts_len = len(code.co_consts)
+    names_len = len(code.co_names)
+    varnames_len = len(code.co_varnames)
+
+    for i, inst in enumerate(code.instructions):
+        if xdis.op_has_argument(inst.opcode, asm.opc):
+            if is_int(inst.arg):
+                if inst.opcode == asm.opc.EXTENDED_ARG:
+                    continue
+                operand = inst.arg
+                if inst.opcode in asm.opc.CONST_OPS:
+                    # FIXME: DRY operand check
+                    if operand >= consts_len:
+                        print(inst)
+                        warn(
+                            f"Constant operand index {operand} at offset {inst.offset} of {code.co_name} "
+                            f"is too large; it should be less than {consts_len}."
+                        )
+                        is_valid = False
+                elif inst.opcode in asm.opc.LOCAL_OPS:
+                    if operand >= varnames_len:
+                        print(inst)
+                        warn(
+                            f"Variable operand index {operand} at offset {inst.offset} of {code.co_name} "
+                            f"is too large; it should be less than {varnames_len}."
+                        )
+                        is_valid = False
+                elif inst.opcode in asm.opc.NAME_OPS:
+                    if operand >= names_len:
+                        print(inst)
+                        warn(
+                            f"Name operand index {operand} at offset {inst.offset} of {code.co_name} "
+                            f"is too large; it should be less than {names_len}."
+                        )
+                        is_valid = False
+                elif inst.opcode in asm.opc.FREE_OPS:
+                    # FIXME: is this right?
+                    if operand >= cells_free_len:
+                        print(inst)
+                        warn(
+                            f"Free operand index {operand} at offset {inst.offset} of {code.co_name} "
+                            f"is too large; it should be less than {cells_free_len}."
+                        )
+                        is_valid = False
+
+    return is_valid
+
+
+def append_operand(
+    bytecode: list, arg_value, extended_arg_shift, arg_max_value, extended_arg_op
+) -> None:
+    """
+    Write instruction operand adding EXTENDED_ARG instructions
+    when necessary.
+    """
+    arg_shifts = []
+    shift_value = 1
+
+    while arg_value > arg_max_value:
+        shift_value <<= extended_arg_shift
+        ext_arg_value, arg_value = divmod(arg_value, shift_value)
+        arg_shifts.append(ext_arg_value)
+
+    while arg_shifts:
+        bytecode.append(extended_arg_op)
+        ext_arg_value = arg_shifts.pop()
+        bytecode.append(ext_arg_value)
+
+    bytecode.append(arg_value)
+
+
+def create_code(asm: Assembler, label, backpatch) -> tuple:
+    """
+    Turn ``asm`` assembler text into a code object and
+    return that.
+    """
     # print('label: ', asm.label)
     # print('backpatch: ', asm.backpatch_inst)
 
-    bcode = []
+    bytecode = []
     # print(asm.code.instructions)
 
     offset = 0
-    extended_value = 0
     offset2label = {label[j]: j for j in label}
+    is_valid = True
 
     for i, inst in enumerate(asm.code.instructions):
-        bcode.append(inst.opcode)
+        # Strip out extended arg instructions.
+        # Operands in the input can be arbitary numbers.
+        # In this loop we will figure out whether
+        # or not to add EXTENDED_ARG
+        if inst.opcode == asm.opc.EXTENDED_ARG:
+            print(
+                f"Line {i}: superflous EXTENDED_ARG instruction removed;"
+                " this code decides when they are needed."
+            )
+            continue
+
+        bytecode.append(inst.opcode)
         if offset in offset2label:
             if is_int(offset2label[offset]):
                 inst.line_no = int(offset2label[offset])
+                if (
+                    inst.line_no in asm.code.co_lnotab.values()
+                    and asm.python_version < (3, 10)
+                ):
+                    print(
+                        f"Line {i}: this is not the first we encounter source-code line {inst.line_no}."
+                    )
                 asm.code.co_lnotab[offset] = inst.line_no
 
         inst.offset = offset
@@ -447,17 +637,13 @@ def create_code(asm, label, backpatch):
                         inst.arg = label[target] - offset
                     else:
                         inst.arg = label[target]
-                        pass
+                    if asm.opc.version_tuple >= (3, 10):
+                        inst.arg >>= 1
                     pass
                 except KeyError:
                     err(f"Label {target} not found.\nI know about {backpatch}", inst, i)
+                    is_valid = False
             elif is_int(inst.arg):
-                if inst.opcode == asm.opc.EXTENDED_ARG:
-                    extended_value += inst.arg
-                    if asm.opc.version >= 3.6:
-                        extended_value <<= 8
-                    else:
-                        extended_value <<= 16
                 pass
             elif inst.arg.startswith("(") and inst.arg.endswith(")"):
                 operand = inst.arg[1:-1]
@@ -465,11 +651,13 @@ def create_code(asm, label, backpatch):
                     if operand in cmp_op:
                         inst.arg = cmp_op.index(operand)
                     else:
-                        err("Can't handle compare operand %s" % inst.arg, inst, i)
+                        err(f"Can't handle compare operand {inst.arg}", inst, i)
+                        is_valid = False
+                        break
 
                     pass
                 elif inst.opcode in asm.opc.CONST_OPS:
-                    if not operand.startswith("<Code"):
+                    if not (operand.startswith("<Code") or operand.startswith("<code")):
                         operand = ast.literal_eval(operand)
                     update_code_field("co_consts", operand, inst, asm.code)
                 elif inst.opcode in asm.opc.LOCAL_OPS:
@@ -483,47 +671,52 @@ def create_code(asm, label, backpatch):
                         update_code_field("co_freevars", operand, inst, asm.code)
                 else:
                     # from trepan.api import debug; debug()
-                    err("Can't handle operand %s" % inst.arg, inst, i)
+                    err(f"Can't handle operand {inst.arg}", inst, i)
+                    is_valid = False
+                    break
             else:
                 # from trepan.api import debug; debug()
                 err(
-                    "Don't understand operand %s expecting int or (..)" % inst.arg,
+                    f"Don't understand operand {inst.arg} expecting int or (..)",
                     inst,
                     i,
                 )
 
-            if asm.opc.version_tuple < (3, 6):
-                if inst.opcode == asm.opc.EXTENDED_ARG:
-                    arg_tup = xdis.util.num2code(inst.arg)
-                else:
-                    arg_tup = xdis.util.num2code(inst.arg - extended_value)
-                    extended_value = 0
-                bcode += arg_tup
-            # 3.6
-            else:
-                if inst.opcode == asm.opc.EXTENDED_ARG:
-                    bcode.append(inst.arg)
-                else:
-                    bcode.append(inst.arg - extended_value)
-                    extended_value = 0
+            append_operand(
+                bytecode,
+                inst.arg,
+                asm.opc.EXTENDED_ARG_SHIFT,
+                asm.opc.ARG_MAX_VALUE,
+                asm.opc.EXTENDED_ARG,
+            )
+
         elif asm.opc.version_tuple >= (3, 6):
-            bcode.append(0)
+            # instructions with no operand, or one-byte instructions, are padded
+            # to two bytes in 3.6 and later.
+            bytecode.append(0)
+
+    if not is_valid:
+        return None, False
 
     if asm.opc.version_tuple >= (3, 0):
         co_code = bytearray()
-        for j in bcode:
+        for j in bytecode:
             co_code.append(j % 255)
         asm.code.co_code = bytes(co_code)
     else:
-        asm.code.co_code = "".join([chr(j) for j in bcode])
+        asm.code.co_code = "".join([chr(j) for j in bytecode])
+
+    # FIXME: get
+    is_code_ok(asm)
 
     # Stamp might be added here
     if asm.python_version[:2] == PYTHON_VERSION_TRIPLE[:2]:
         code = asm.code.to_native()
     else:
         code = asm.code.freeze()
+
     # asm.print_instructions()
 
     # print (*args)
     # co = self.Code(*args)
-    return code
+    return code, is_valid

xasm/pyc_convert.py

@@ -2,28 +2,29 @@
 """Convert Python Bytecode from one version to another for
 some limited set of Python bytecode versions
 """
-from xdis import disassemble_file, load_module, magic2int, write_bytecode_file
-from xasm.write_pyc import write_pycfile
-import xdis
-from xdis.opcodes import opcode_33, opcode_27
-from tempfile import NamedTemporaryFile
-import os.path as osp
 import os
+import os.path as osp
 from copy import copy
+from tempfile import NamedTemporaryFile
+
+import click
+import xdis
+from xdis import disassemble_file, load_module, magic2int, write_bytecode_file
+from xdis.magics import magics
+from xdis.opcodes import opcode_27, opcode_33
+
 from xasm.assemble import (
-    asm_file,
     Assembler,
-    create_code,
     Instruction,
-    decode_lineno_tab,
+    asm_file,
+    create_code,
+    decode_lineno_tab_old,
 )
-from xdis.magics import magics
-import click
-
 from xasm.version import __version__
+from xasm.write_pyc import write_pycfile
 
 
-def add_credit(asm, src_version, dest_version):
+def add_credit(asm, src_version, dest_version) -> None:
     stamp = "Converted from Python %s to %s by %s version %s" % (
         src_version,
         dest_version,
@@ -34,20 +35,20 @@ def add_credit(asm, src_version, dest_version):
     return
 
 
-def copy_magic_into_pyc(input_pyc, output_pyc, src_version, dest_version):
+def copy_magic_into_pyc(input_pyc, output_pyc, src_version, dest_version) -> None:
     """Bytecodes are the same except the magic number, so just change
     that"""
     (version, timestamp, magic_int, co, is_pypy, source_size) = load_module(input_pyc)
     assert version == float(
         src_version
-    ), "Need Python %s bytecode; got bytecode for version %s" % (src_version, version)
+    ), f"Need Python {src_version} bytecode; got bytecode for version {version}"
     magic_int = magic2int(magics.magics[dest_version])
     write_bytecode_file(output_pyc, co, magic_int)
-    print("Wrote %s" % output_pyc)
+    print(f"Wrote {output_pyc}")
     return
 
 
-def xlate26_27(inst):
+def xlate26_27(inst) -> None:
     """Between 2.6 and 2.7 opcode values changed
     Adjust for the differences by using the opcode name
     """
@@ -145,9 +146,10 @@ def transform_33_32(inst, new_inst, i, n, offset, instructions, new_asm):
     return 0
 
 
-def transform_asm(asm, conversion_type, src_version, dest_version):
-
-    new_asm = Assembler(dest_version)
+def transform_asm(
+    asm: Assembler | None, conversion_type, src_version, dest_version
+) -> Assembler:
+    new_asm = Assembler(dest_version, is_pypy=False)
     for field in "code size".split():
         setattr(new_asm, field, copy(getattr(asm, field)))
 
@@ -158,13 +160,15 @@ def transform_asm(asm, conversion_type, src_version, dest_version):
     elif conversion_type == "33-32":
         transform_fn = transform_33_32
     else:
-        raise RuntimeError("Don't know how to covert %s " % conversion_type)
+        raise RuntimeError(f"Don't know how to convert {conversion_type} ")
     for j, code in enumerate(asm.code_list):
         offset2label = {v: k for k, v in asm.label[j].items()}
         new_asm.backpatch.append(copy(asm.backpatch[j]))
         new_asm.label.append(copy(asm.label[j]))
         new_asm.codes.append(copy(code))
-        new_asm.code.co_lnotab = decode_lineno_tab(code.co_lnotab, code.co_firstlineno)
+        new_asm.code.co_lnotab = decode_lineno_tab_old(
+            code.co_lnotab, code.co_firstlineno
+        )
         instructions = asm.codes[j].instructions
         new_asm.code.instructions = []
         i, offset, n = 0, 0, len(instructions)
@@ -182,14 +186,14 @@ def transform_asm(asm, conversion_type, src_version, dest_version):
             i += 1
             pass
 
-    co = create_code(new_asm, new_asm.label[-1], new_asm.backpatch[-1])
+    co, is_valid = create_code(new_asm, new_asm.label[-1], new_asm.backpatch[-1])
     new_asm.code_list.append(co)
     new_asm.code_list.reverse()
-    new_asm.finished = "finished"
+    new_asm.status = "finished" if is_valid else "invalid"
     return new_asm
 
 
-UPWARD_COMPATABLE = tuple("20-21 21-22 23-24 24-23".split())
+UPWARD_COMPATIBLE = tuple("20-21 21-22 23-24 24-23".split())
 
 
 @click.command()
@@ -212,15 +216,15 @@ UPWARD_COMPATABLE = tuple("20-21 21-22 23-24 24-23".split())
     help="specify conversion from/to bytecode",
     default="26-27",
 )
-@click.argument("input_pyc", type=click.Path("r"), nargs=1)
+@click.argument("input_pyc", type=click.Path(writable=True), nargs=1)
 @click.argument(
-    "output_pyc", type=click.Path("w"), required=False, nargs=1, default=None
+    "output_pyc", type=click.Path(writable=True), required=False, nargs=1, default=None
 )
-def main(conversion_type, input_pyc, output_pyc):
+def main(conversion_type, input_pyc, output_pyc) -> None:
     """Convert Python bytecode from one version to another.
 
     INPUT_PYC contains the input bytecode path name
-    OUTPUT_PYC  contians the output bytecode path name if supplied
+    OUTPUT_PYC  contains the output bytecode path name if supplied
     The --conversion type option specifies what conversion to do.
 
     Note: there are a very limited set of conversions currently supported.
@@ -232,9 +236,9 @@ def main(conversion_type, input_pyc, output_pyc):
     src_version = conversion_to_version(conversion_type, is_dest=False)
     dest_version = conversion_to_version(conversion_type, is_dest=True)
     if output_pyc is None:
-        output_pyc = "%s-%s.pyc" % (shortname, dest_version)
+        output_pyc = f"{shortname}-{dest_version}.pyc"
 
-    if conversion_type in UPWARD_COMPATABLE:
+    if conversion_type in UPWARD_COMPATIBLE:
         copy_magic_into_pyc(input_pyc, output_pyc, src_version, dest_version)
         return
     temp_asm = NamedTemporaryFile("w", suffix=".pyasm", prefix=shortname, delete=False)
@@ -244,7 +248,7 @@ def main(conversion_type, input_pyc, output_pyc):
     temp_asm.close()
     assert version == float(
         src_version
-    ), "Need Python %s bytecode; got bytecode for version %s" % (src_version, version)
+    ), f"Need Python {src_version} bytecode; got bytecode for version {version}"
     asm = asm_file(temp_asm.name)
     new_asm = transform_asm(asm, conversion_type, src_version, dest_version)
     os.unlink(temp_asm.name)

xasm/version.py

@@ -5,4 +5,4 @@
 # space around "=" below.
 
 # fmt: off
-__version__="1.2.0"  # noqa
+__version__="1.2.1"  # noqa

xasm/write_pyc.py

@@ -1,14 +1,16 @@
+import time
+from struct import pack
+
 import xdis
 from xdis import magic2int
-from xdis.marsh import dumps
 from xdis.magics import magics
-from struct import pack
+from xdis.marsh import dumps
 from xdis.version_info import PYTHON3, version_tuple_to_str
-import time
 
 
-def write_pycfile(fp, code_list, timestamp=None, version_triple=xdis.PYTHON_VERSION_TRIPLE):
+def write_pycfile(fp, code_list, timestamp=None, version_triple=xdis.PYTHON_VERSION_TRIPLE) -> int:
 
+    rc = 0
     version_str = version_tuple_to_str(version_triple, end=2)
     magic_bytes = magics[version_str]
     magic_int = magic2int(magic_bytes)
@@ -40,5 +42,7 @@ def write_pycfile(fp, code_list, timestamp=None, version_triple=xdis.PYTHON_VERS
                 pass
 
             fp.write(co_obj)
-        except:  # noqa
-            pass
+        except Exception as e:
+            print(f"error dumping {co}: {e}; ignoring")
+            rc = 1
+    return rc

xasm/xasm_cli.py

@@ -1,15 +1,20 @@
 #!/usr/bin/env python
-import click, os, sys
-from xasm.assemble import asm_file
-from xasm.write_pyc import write_pycfile
+import os
+import sys
+from typing import List
+
+import click
 import xdis
 from xdis.version_info import version_tuple_to_str
 
+from xasm.assemble import asm_file
+from xasm.write_pyc import write_pycfile
+
 
 @click.command()
 @click.option("--pyc-file", default=None)
 @click.argument("asm-path", type=click.Path(exists=True, readable=True), required=True)
-def main(pyc_file, asm_path):
+def main(pyc_file: List[str], asm_path):
     """
     Create Python bytecode from a Python assembly file.
 
@@ -23,12 +28,15 @@ def main(pyc_file, asm_path):
     for how to write a Python assembler file.
     """
     if os.stat(asm_path).st_size == 0:
-        print("Size of assembly file %s is zero" % asm_path)
+        print(f"Size of assembly file {asm_path} is zero")
         sys.exit(1)
     asm = asm_file(asm_path)
 
-    if not pyc_file and asm_path.endswith(".pyasm"):
-        pyc_file = asm_path[: -len(".pyasm")] + ".pyc"
+    if not pyc_file:
+        if asm_path.endswith(".pyasm"):
+            pyc_file = asm_path[: -len(".pyasm")] + ".pyc"
+        elif not pyc_file and asm_path.endswith(".xasm"):
+            pyc_file = asm_path[: -len(".xasm")] + ".pyc"
 
     if xdis.PYTHON3:
         file_mode = "wb"
@@ -36,13 +44,17 @@ def main(pyc_file, asm_path):
         file_mode = "w"
 
     with open(pyc_file, file_mode) as fp:
-        write_pycfile(fp, asm.code_list, asm.timestamp, asm.python_version)
+        rc = write_pycfile(fp, asm.code_list, asm.timestamp, asm.python_version)
         size = fp.tell()
     print(
         f"""Wrote Python {version_tuple_to_str(asm.python_version)} bytecode file "{pyc_file}"; {size} bytes."""
     )
     if size <= 16:
-        print("Warning: bytecode file is too small to be usuable.")
+        print("Warning: bytecode file is too small to be usable.")
+        rc = 2
+    if rc != 0:
+        print(f"Exiting with return code {rc}")
+    sys.exit(rc)
 
 
 if __name__ == "__main__":

{xasm-1.2.0.dist-info → xasm-1.2.1.dist-info}/METADATA

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: xasm
-Version: 1.2.0
+Version: 1.2.1
 Summary: Python cross-version byte-code assembler
 Home-page: https://github.com/rocky/python-xasm/
 Author: Rocky Bernstein
 Author-email: rb@dustyfeet.com
 License: GPL-2.0
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -19,48 +18,63 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Debuggers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Description-Content-Type: text/x-rst
 License-File: LICENSE.gpl2
+Requires-Dist: xdis>=6.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 |Pypi Installs| |Latest Version| |Supported Python Versions|
 
 xasm
 ====
 
-*NOTE: this is in beta*
+*NOTE: this is in beta.*
 
-A Cross-Python bytecode Assembler
+A cross-version Python bytecode assembler
 
 
 Introduction
 ------------
 
-The Python `xasm` module has routines for assembly, and has a command to
+The Python ``xasm`` module has routines for assembly, and has a command to
 assemble bytecode for several different versions of Python.
 
 Here are some potential uses:
 
-* Make small patches to existing Python bytecode when you don’t have source
+* Make small changes to existing Python bytecode when you don’t have source
 * Craft custom and efficient bytecode
 * Write an instruction-level optimizing compiler
 * Experiment with and learn about Python bytecode
-* Foil uncompyle6_ so that it can’t disassemble bytecode (at least for now)
+* Foil decompilers like uncompyle6_ so that they can’t disassemble bytecode (at least for now)
 
-This will support bytecodes from Python version 1.0 to 3.8 or so.
+This support the same kinds of bytecode that xdis_ supports. This is
+pretty much all released bytecode before Python 3.11. We tend to lag behind the
+latest Python releases.
 
-The code requires Python 2.7 or later.
+The code requires Python 3.6 or later.
 
 Assembly files
 --------------
 
-More detail will be filled in, but some principles:
+See how-to-use_ for more detail. Some general some principles:
 
-* Preferred extension for Python assembly is `.pyasm`
-* assembly is designed to work with the output of `pydisasm --asm`
+* Preferred extension for Python assembly is ``.pyasm``
+* assembly is designed to work with the output of ``pydisasm -F xasm``
 * Assembly file labels are at the beginning of the line
-  and end in a colon, e.g. `END_IF`
+  and end in a colon, e.g. ``END_IF:``
 * instruction offsets in the assembly file are ignored and don't need
   to be entered
 * in those instructions that refer to offsets, if the if the
@@ -71,17 +85,30 @@ More detail will be filled in, but some principles:
 Installation
 ------------
 
-The standard Python routine:
+*If you are using Python 3.11 or later*, you can install from PyPI using the name ``xasm``::
 
-::
-
-    pip install -e .
-    pip install -r requirements-dev.txt
+    pip install xasm
 
-A GNU makefile is also provided so :code:`make install` (possibly as root or
+A GNU makefile is also provided so ``make install`` (possibly as root or
 sudo) will do the steps above.
 
 
+*If you are using Python before 3.11*, do not install using PyPI, but instead install using a file in the `GitHub Releases section <https://github.com/rocky/python-xasm/releases>`_. Older Python used to use `easy_install <https://python101.pythonlibrary.org/chapter29_pip.html#using-easy-install>`_. But this is no longer supported in PyPi or newer Python versions. And vice versa, *poetry* nor *pip*, (the newer ways) are not supported on older Pythons.
+
+If the Python version you are running xasm is between Python 3.6 through 3.11, use a tarball called xasm_36-*x.y.z*.tar.gz.
+
+If the Python version you are running xasm is 3.11 or later, use a file called xasm-*x.y.z*.tar.gz.
+
+Similarly, a tarball with or without the underscore *xx*,  e.g., xasm_36-*x.y.z*.tar.gz. works only from Python 3.11 or greater.
+
+Rationale for using Git Branches
+++++++++++++++++++++++++++++++++
+
+It is currently impossible (if not impractical) to have one Python source code of this complexity and with this many features that can run both Python 3.6 and Python 3.13+. The languages have drifted so much, and packaging is vastly different.
+
+A GNU makefile is also provided so :code:`make install` (possibly as root or sudo) will do the steps above.
+
+
 Testing
 -------
 
@@ -161,14 +188,14 @@ Here is an assembly for the above:
                 RETURN_VALUE
 
 
-The above can be created automatically from Python source code using the `pydisasm`
-command from `xdis`:
+The above can be created automatically from Python source code using the ``pydisasm``
+command from ``xdis``:
 
 ::
 
     pydisasm --format xasm /tmp/five.pyc
 
-In the example above though, I have shortend and simplified the result.
+In the example above though, I have shortened and simplified the result.
 
 
 Usage
@@ -181,7 +208,7 @@ To create a python bytecode file from an assemble file, run:
    pyc-xasm [OPTIONS] ASM_PATH
 
 
-For usage help, type  `pyc-xasm --help`.
+For usage help, type:  ``pyc-xasm --help``.
 
 
 To convert a python bytecode from one bytecode to another, run:
@@ -191,7 +218,7 @@ To convert a python bytecode from one bytecode to another, run:
    pyc-convert [OPTIONS] INPUT_PYC [OUTPUT_PYC]
 
 
-For usage help, type  `pyc-convert --help`.
+For usage help, type:  ``pyc-convert --help``.
 
 
 See Also
@@ -204,11 +231,11 @@ See Also
 
 
 .. _uncompyle6: https://github.com/rocky/python-uncompyle6
+.. _how-to-use: https://github.com/rocky/python-xasm/blob/master/HOW-TO-USE.rst
+.. _xdis: https://github.com/rocky/xdis
 .. |Latest Version| image:: https://badge.fury.io/py/xasm.svg
 		 :target: https://badge.fury.io/py/xasm
 .. |Pypi Installs| image:: https://pepy.tech/badge/xasm
 .. |Supported Python Versions| image:: https://img.shields.io/pypi/pyversions/xasm.svg
 .. _remake: http://bashdb.sf.net/remake
 
-
-

xasm-1.2.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+xasm/__init__.py,sha256=gz94OZ_Jc1WozfOYH1pjQeg7IgB1L9wv5fyytJ2XgZU,174
+xasm/assemble.py,sha256=GIf2cfvHa8QFyq0w820-c__Wpj5DeOtKtgicg9XbEjU,26420
+xasm/pyc_convert.py,sha256=s2UixbgUQZFHv9nmtvOV7TYohLBev2lcet0GIE9g6GM,9177
+xasm/version.py,sha256=xEuuftKJb_Pe2D5lJpTv3HxDgx6Bd1-lH_6HBGWFguw,206
+xasm/write_pyc.py,sha256=ZoqjupN9rEjJ5o49SZcX9rbEhaImnqsJKkNzLnT9j4c,1455
+xasm/xasm_cli.py,sha256=4EYRZVejspzBvoNaXsWgGbN7qRU5p-MPrt05IYu1kGc,1789
+xasm-1.2.1.dist-info/licenses/LICENSE.gpl2,sha256=2ylvL381vKOhdO-w6zkrOxe9lLNBhRQpo9_0EbHC_HM,18046
+xasm-1.2.1.dist-info/METADATA,sha256=ttOzLNtFPOn_c015VJhuv-E9sNCXsYGiojLM23FAZ8k,7429
+xasm-1.2.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+xasm-1.2.1.dist-info/entry_points.txt,sha256=Ypclbf0sCcywW8uPxxHAQv2pUujiKHx5OfcAYbSks98,84
+xasm-1.2.1.dist-info/top_level.txt,sha256=24UNOItB5o_EJoJ9nqhPZEC5GiSaYtHll3F6mJXzOkA,5
+xasm-1.2.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+xasm-1.2.1.dist-info/RECORD,,

{xasm-1.2.0.dist-info → xasm-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

xasm-1.2.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pyc-convert = xasm.pyc_convert:main
+pyc-xasm = xasm.xasm_cli:main

xasm-1.2.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-xasm/__init__.py,sha256=gz94OZ_Jc1WozfOYH1pjQeg7IgB1L9wv5fyytJ2XgZU,174
-xasm/assemble.py,sha256=SMLDowOTUyX5WW1F1MxVgVW8PABo0Q2i_qIQwrIA2VI,19603
-xasm/pyc_convert.py,sha256=onWRcmEhqpQi1Pf-lvPeun8qxPKmTWJEqLBGUW6aH28,9029
-xasm/version.py,sha256=DbW6-QjmrYtEr06qLRCM9LzccIv-54mBuJWsQ6fclI0,206
-xasm/write_pyc.py,sha256=LJKDKg8WGS9zzXIilY8keW3NJU2N2Kf_murjIVv1_IY,1357
-xasm/xasm_cli.py,sha256=cw2TY6kYOU50xC-czeLEGMBnCuYOjaV3mMuX75QKKnI,1514
-xasm-1.2.0.dist-info/LICENSE.gpl2,sha256=2ylvL381vKOhdO-w6zkrOxe9lLNBhRQpo9_0EbHC_HM,18046
-xasm-1.2.0.dist-info/METADATA,sha256=nGfVdYl1WaSq_dbbq3YlWwND39mzo_C5KuXOu5CHVfw,5571
-xasm-1.2.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-xasm-1.2.0.dist-info/entry_points.txt,sha256=ddG5Ud4yX9DHkME_98f0fEHp4X-_6nipBUq0IADDBfg,119
-xasm-1.2.0.dist-info/top_level.txt,sha256=24UNOItB5o_EJoJ9nqhPZEC5GiSaYtHll3F6mJXzOkA,5
-xasm-1.2.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-xasm-1.2.0.dist-info/RECORD,,

xasm-1.2.0.dist-info/entry_points.txt

@@ -1,5 +0,0 @@
-
-        [console_scripts]
-        pyc-xasm    = xasm.xasm_cli:main
-        pyc-convert = xasm.pyc_convert:main
-