PyNerva 0.0.5__py3-none-any.whl

nervapy/constant_data.py

@@ -0,0 +1,282 @@
+"""
+ConstantData - Extended Constant class that generates .data sections
+
+This module provides ConstantData class that automatically:
+1. Creates a Constant with metadata
+2. Registers itself with the active Function
+3. Generates .data section entries
+4. Provides a label/address for use with LDR instructions
+
+Usage:
+    from nervapy.constant_data import ConstantData
+    
+    with Function("my_func", ...) as func:
+        # Create constant data - automatically added to function
+        magic = ConstantData.uint32(0x11111111, name="magic_number")
+        
+        # Use with LDR (label will be generated)
+        # Note: You'll need to use raw assembly for LDR =label
+        # Or manually construct the address loading
+        
+    # Assembly will include .data section automatically
+    print(func.assembly)
+"""
+
+from nervapy.literal import Constant
+
+
+class ConstantData(Constant):
+    """Extended Constant that registers with Function for .data generation"""
+
+    # Class-level registry of constants per function
+    _function_constants: dict[int, list["ConstantData"]] = {}
+
+    def __init__(self, size, repeats, data, element_ctype, name):
+        super().__init__(size, repeats, data, element_ctype, name)
+
+        # Register with active function
+        self._register_with_function()
+
+    def _register_with_function(self):
+        """Register this constant with the active function"""
+        from nervapy.arm.function import active_function
+
+        if active_function is not None:
+            func_id = id(active_function)
+            if func_id not in ConstantData._function_constants:
+                ConstantData._function_constants[func_id] = []
+            ConstantData._function_constants[func_id].append(self)
+
+    def get_label(self):
+        """Return the label name for this constant"""
+        if self.name and len(self.name) > 0:
+            if hasattr(self.name[0], 'name'):
+                return self.name[0].name
+            return str(self.name[0])
+        return f"const_{id(self)}"
+
+    def generate_data_section(self):
+        """Generate .data section assembly for this constant"""
+        lines = []
+        label = self.get_label()
+        lines.append(f"\t.global {label}")
+        lines.append(f"\t.type {label}, %object")
+        lines.append(f"{label}:")
+
+        # Determine word size based on element type
+        from nervapy.c.types import int64_t, uint64_t
+
+        if self.element_ctype in [uint64_t, int64_t]:
+            # 64-bit values - use .quad or two .word directives
+            if self.repeats == 1:
+                # Single 64-bit value - split into two 32-bit words (little-endian)
+                low = self.data[0] & 0xFFFFFFFF
+                high = (self.data[0] >> 32) & 0xFFFFFFFF
+                lines.append(f"\t.word 0x{low:08X}, 0x{high:08X}")
+            else:
+                # Multiple 64-bit values
+                words = []
+                for val in self.data:
+                    low = val & 0xFFFFFFFF
+                    high = (val >> 32) & 0xFFFFFFFF
+                    words.extend([f"0x{low:08X}", f"0x{high:08X}"])
+                lines.append(f"\t.word {', '.join(words)}")
+        else:
+            # 32-bit or smaller values
+            if self.repeats == 1:
+                lines.append(f"\t.word 0x{self.data[0]:08X}")
+            else:
+                words = ", ".join(f"0x{v:08X}" for v in self.data)
+                lines.append(f"\t.word {words}")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def get_function_constants(function):
+        """Get all constants registered with a function"""
+        func_id = id(function)
+        return ConstantData._function_constants.get(func_id, [])
+
+    @staticmethod
+    def clear_function_constants(function):
+        """Clear constants for a function (called after generation)"""
+        func_id = id(function)
+        if func_id in ConstantData._function_constants:
+            del ConstantData._function_constants[func_id]
+
+    @staticmethod
+    def generate_all_data_sections(function):
+        """Generate complete .data section for all constants in a function"""
+        constants = ConstantData.get_function_constants(function)
+        if not constants:
+            return ""
+
+        lines = ["\n\t.data", "\t.align 4"]
+        for const in constants:
+            lines.append(const.generate_data_section())
+
+        return "\n".join(lines) + "\n"
+
+    # Factory methods (same as Constant but return ConstantData)
+
+    @staticmethod
+    def uint32(number, name=None):
+        """Create a 32-bit unsigned integer constant with .data section"""
+        from nervapy.name import Name
+        from nervapy.parse import parse_assigned_variable_name
+        from nervapy.util import is_int, is_int32
+
+        if not is_int(number):
+            raise TypeError(f"The value {number} is not an integer")
+        if not is_int32(number):
+            raise ValueError(f"The number {number} is not a 32-bit integer")
+
+        if number < 0:
+            number += 0x100000000
+
+        if name is not None:
+            Name.check_name(name)
+            name_obj = Name(name=name)
+        else:
+            import inspect
+            name_obj = Name(
+                prename=parse_assigned_variable_name(inspect.stack(), "ConstantData.uint32")
+            )
+
+        from nervapy.c.types import uint32_t
+        return ConstantData(4, 1, (number,), uint32_t, name_obj)
+
+    @staticmethod
+    def uint32x4(number1, number2=None, number3=None, number4=None, name=None):
+        """Create a 4-element 32-bit unsigned integer array constant"""
+        from nervapy.c.types import uint32_t
+        from nervapy.name import Name
+        from nervapy.parse import parse_assigned_variable_name
+        from nervapy.util import is_int, is_int32
+
+        args = [arg for arg in [number1, number2, number3, number4] if arg is not None]
+        if len(args) == 0:
+            raise ValueError("At least one constant value must be specified")
+        if len(args) != 1 and len(args) != 4:
+            raise ValueError("Either 1 or 4 values must be specified")
+
+        for i, num in enumerate(args):
+            if not is_int(num):
+                raise TypeError(f"The value {num} is not an integer")
+            if not is_int32(num):
+                raise ValueError(f"The number {num} is not a 32-bit integer")
+            if num < 0:
+                args[i] += 0x100000000
+
+        if len(args) == 1:
+            args = [args[0]] * 4
+
+        if name is not None:
+            Name.check_name(name)
+            name_obj = Name(name=name)
+        else:
+            import inspect
+            name_obj = Name(
+                prename=parse_assigned_variable_name(inspect.stack(), "ConstantData.uint32x4")
+            )
+
+        return ConstantData(16, 4, tuple(args), uint32_t, name_obj)
+
+    @staticmethod
+    def uint64(number, name=None):
+        """Create a 64-bit unsigned integer constant with .data section"""
+        from nervapy.c.types import uint64_t
+        from nervapy.name import Name
+        from nervapy.parse import parse_assigned_variable_name
+        from nervapy.util import is_int, is_int64
+
+        if not is_int(number):
+            raise TypeError(f"The value {number} is not an integer")
+        if not is_int64(number):
+            raise ValueError(f"The number {number} is not a 64-bit integer")
+
+        if number < 0:
+            number += 0x10000000000000000
+
+        if name is not None:
+            Name.check_name(name)
+            name_obj = Name(name=name)
+        else:
+            import inspect
+            name_obj = Name(
+                prename=parse_assigned_variable_name(inspect.stack(), "ConstantData.uint64")
+            )
+
+        return ConstantData(8, 1, (number,), uint64_t, name_obj)
+
+
+# Note: Auto-patching is done when Function is imported via __init__.py
+# For manual usage, call install_constant_data_support() after importing Function
+
+
+def install_constant_data_support():
+    """Install ConstantData support by patching the Function class
+    
+    This enables automatic .data section generation for ConstantData objects.
+    Call this after importing Function but before creating any functions.
+    
+    Example:
+        from nervapy import *
+        from nervapy.arm import *
+        from nervapy.constant_data import ConstantData, install_constant_data_support
+        
+        install_constant_data_support()  # Enable automatic .data sections
+        
+        with Function(...) as func:
+            const = ConstantData.uint32(111, name="my_const")
+            ...
+    """
+    from nervapy.arm.function import Function
+
+    # Check if already patched
+    if hasattr(Function, '_constant_data_patched'):
+        return
+
+    # Save original methods
+    original_assembly = Function.assembly.fget
+    original_exit = Function.__exit__
+
+    def patched_assembly(self):
+        """Patched assembly property that appends .data sections"""
+        # Get original assembly
+        asm = original_assembly(self)
+
+        # Append .data section if there are constants
+        # Note: We check for constants stored on the function instance
+        # because they may have been cleared from the global registry
+        if hasattr(self, '_constant_data_list'):
+            constants = self._constant_data_list
+        else:
+            constants = ConstantData.get_function_constants(self)
+
+        if constants:
+            lines = ["\n\t.data", "\t.align 4"]
+            for const in constants:
+                lines.append(const.generate_data_section())
+            asm += "\n".join(lines) + "\n"
+
+        return asm
+
+    def patched_exit(self, exc_type, exc_value, traceback):
+        """Patched __exit__ that saves constants before cleanup"""
+        # Save constants to function instance before clearing global registry
+        self._constant_data_list = list(ConstantData.get_function_constants(self))
+
+        # Call original __exit__
+        result = original_exit(self, exc_type, exc_value, traceback)
+
+        # Clear from global registry (but kept in _constant_data_list)
+        ConstantData.clear_function_constants(self)
+
+        return result
+
+    # Apply patches
+    Function.assembly = property(patched_assembly)
+    Function.__exit__ = patched_exit
+    Function._constant_data_patched = True
+

nervapy/encoder.py

@@ -0,0 +1,246 @@
+# 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.
+
+import six
+
+from nervapy.abi import Endianness
+
+
+class Encoder:
+    def __init__(self, endianness, bitness=None):
+        assert endianness in {Endianness.Little, Endianness.Big}
+        if endianness == Endianness.Little:
+            self.int16 = Encoder.int16le
+            self.uint16 = Encoder.uint16le
+            self.int32 = Encoder.int32le
+            self.uint32 = Encoder.uint32le
+            self.int64 = Encoder.int64le
+            self.uint64 = Encoder.uint64le
+        else:
+            self.int16 = Encoder.int16be
+            self.uint16 = Encoder.uint16be
+            self.int32 = Encoder.int32be
+            self.uint32 = Encoder.uint32be
+            self.int64 = Encoder.int64be
+            self.uint64 = Encoder.uint64be
+        self.bitness = bitness
+        if bitness is not None:
+            assert bitness in {32, 64}, "Only 32-bit and 64-bit encoders are supported"
+            if bitness == 32:
+                self.signed_offset = self.int32
+                self.unsigned_offset = self.uint32
+            else:
+                self.signed_offset = self.int64
+                self.unsigned_offset = self.uint64
+
+    @staticmethod
+    def int8(n):
+        """Converts signed 8-bit integer to bytearray representation"""
+        assert -128 <= n <= 127, (
+            "%u can not be represented as an 8-bit signed integer" % n
+        )
+        return bytearray([n & 0xFF])
+
+    @staticmethod
+    def uint8(n):
+        """Converts unsigned 8-bit integer to bytearray representation"""
+        assert 0 <= n <= 255, (
+            "%u can not be represented as an 8-bit unsigned integer" % n
+        )
+        return bytearray([n])
+
+    @staticmethod
+    def int16le(n):
+        """Converts signed 16-bit integer to little-endian bytearray representation"""
+        assert -32768 <= n <= 32767, (
+            "%u can not be represented as a 16-bit signed integer" % n
+        )
+        return bytearray([n & 0xFF, (n >> 8) & 0xFF])
+
+    @staticmethod
+    def int16be(n):
+        """Converts signed 16-bit integer to big-endian bytearray representation"""
+        assert -32768 <= n <= 32767, (
+            "%u can not be represented as a 16-bit signed integer" % n
+        )
+        return bytearray([n >> 8, (n & 0xFF) & 0xFF])
+
+    @staticmethod
+    def uint16le(n):
+        """Converts unsigned 16-bit integer to little-endian bytearray representation"""
+        assert 0 <= n <= 65535, (
+            "%u can not be represented as a 16-bit unsigned integer" % n
+        )
+        return bytearray([n & 0xFF, n >> 8])
+
+    @staticmethod
+    def uint16be(n):
+        """Converts unsigned 16-bit integer to big-endian bytearray representation"""
+        assert 0 <= n <= 65535, (
+            "%u can not be represented as a 16-bit unsigned integer" % n
+        )
+        return bytearray([n >> 8, n & 0xFF])
+
+    @staticmethod
+    def int32le(n):
+        """Converts signed 32-bit integer to little-endian bytearray representation"""
+        assert -2147483648 <= n <= 2147483647, (
+            "%u can not be represented as a 32-bit signed integer" % n
+        )
+        return bytearray(
+            [n & 0xFF, (n >> 8) & 0xFF, (n >> 16) & 0xFF, (n >> 24) & 0xFF]
+        )
+
+    @staticmethod
+    def int32be(n):
+        """Converts signed 32-bit integer to big-endian bytearray representation"""
+        assert -2147483648 <= n <= 2147483647, (
+            "%u can not be represented as a 32-bit signed integer" % n
+        )
+        return bytearray(
+            [(n >> 24) & 0xFF, (n >> 16) & 0xFF, (n >> 8) & 0xFF, n & 0xFF]
+        )
+
+    @staticmethod
+    def uint32le(n):
+        """Converts unsigned 32-bit integer to little-endian bytearray representation"""
+        assert 0 <= n <= 4294967295, (
+            "%u can not be represented as a 32-bit unsigned integer" % n
+        )
+        return bytearray([n & 0xFF, (n >> 8) & 0xFF, (n >> 16) & 0xFF, n >> 24])
+
+    @staticmethod
+    def uint32be(n):
+        """Converts unsigned 32-bit integer to big-endian bytearray representation"""
+        assert 0 <= n <= 4294967295, (
+            "%u can not be represented as a 32-bit unsigned integer" % n
+        )
+        return bytearray([n >> 24, (n >> 16) & 0xFF, (n >> 8) & 0xFF, n & 0xFF])
+
+    @staticmethod
+    def int64le(n):
+        """Converts signed 64-bit integer to little-endian bytearray representation"""
+        assert -9223372036854775808 <= n <= 9223372036854775807, (
+            "%u can not be represented as a 64-bit signed integer" % n
+        )
+        return bytearray(
+            [
+                n & 0xFF,
+                (n >> 8) & 0xFF,
+                (n >> 16) & 0xFF,
+                (n >> 24) & 0xFF,
+                (n >> 32) & 0xFF,
+                (n >> 40) & 0xFF,
+                (n >> 48) & 0xFF,
+                (n >> 56) & 0xFF,
+            ]
+        )
+
+    @staticmethod
+    def int64be(n):
+        """Converts signed 64-bit integer to big-endian bytearray representation"""
+        assert -9223372036854775808 <= n <= 9223372036854775807, (
+            "%u can not be represented as a 64-bit signed integer" % n
+        )
+        return bytearray(
+            [
+                (n >> 56) & 0xFF,
+                (n >> 48) & 0xFF,
+                (n >> 40) & 0xFF,
+                (n >> 32) & 0xFF,
+                (n >> 24) & 0xFF,
+                (n >> 16) & 0xFF,
+                (n >> 8) & 0xFF,
+                n & 0xFF,
+            ]
+        )
+
+    @staticmethod
+    def uint64le(n):
+        """Converts unsigned 64-bit integer to little-endian bytearray representation"""
+        assert 0 <= n <= 18446744073709551615, (
+            "%u can not be represented as a 64-bit unsigned integer" % n
+        )
+        return bytearray(
+            [
+                n & 0xFF,
+                (n >> 8) & 0xFF,
+                (n >> 16) & 0xFF,
+                (n >> 24) & 0xFF,
+                (n >> 32) & 0xFF,
+                (n >> 40) & 0xFF,
+                (n >> 48) & 0xFF,
+                (n >> 56) & 0xFF,
+            ]
+        )
+
+    @staticmethod
+    def uint64be(n):
+        """Converts unsigned 64-bit integer to big-endian bytearray representation"""
+        assert 0 <= n <= 18446744073709551615, (
+            "%u can not be represented as a 64-bit unsigned integer" % n
+        )
+        return bytearray(
+            [
+                (n >> 56) & 0xFF,
+                (n >> 48) & 0xFF,
+                (n >> 40) & 0xFF,
+                (n >> 32) & 0xFF,
+                (n >> 24) & 0xFF,
+                (n >> 16) & 0xFF,
+                (n >> 8) & 0xFF,
+                n & 0xFF,
+            ]
+        )
+
+    def int16(self, n):
+        """Converts signed 16-bit integer to bytearray representation according to encoder endianness"""
+        pass
+
+    def uint16(self, n):
+        """Converts unsigned 16-bit integer to bytearray representation according to encoder endianness"""
+        pass
+
+    def int32(self, n):
+        """Converts signed 32-bit integer to bytearray representation according to encoder endianness"""
+        pass
+
+    def uint32(self, n):
+        """Converts unsigned 32-bit integer to bytearray representation according to encoder endianness"""
+        pass
+
+    def int64(self, n):
+        """Converts signed 64-bit integer to bytearray representation according to encoder endianness"""
+        pass
+
+    def uint64(self, n):
+        """Converts unsigned 64-bit integer to bytearray representation according to encoder endianness"""
+        pass
+
+    @staticmethod
+    def fixed_string(string, size):
+        """Converts string to fixed-length bytearray representation"""
+        assert isinstance(size, six.integer_types) and size > 0, (
+            "size %u is not a positive integer" % size
+        )
+        if string is None:
+            return bytearray(size)
+        import codecs
+
+        byte_string = codecs.encode(string, "utf8")
+        if len(byte_string) > size:
+            raise ValueError("The length of %s exceeds the target %d" % (string, size))
+        elif len(byte_string) == size:
+            return byte_string
+        else:
+            return byte_string + bytearray(size - len(byte_string))
+
+    def signed_offset(self, n):
+        """Converts signed integer offset to bytearray representation according to encoder bitness and endianness"""
+        raise ValueError("Can not encode signed offset: encoder bitness not specified")
+
+    def unsigned_offset(self, n):
+        """Converts unsigned integer offset to bytearray representation according to encoder bitness and endianness"""
+        raise ValueError(
+            "Can not encode unsigned offset: encoder bitness not specified"
+        )

nervapy/formats/__init__.py

@@ -0,0 +1,2 @@
+# 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.

nervapy/formats/elf/__init__.py

@@ -0,0 +1,4 @@
+# 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 nervapy.formats.elf.section import DataSection, TextSection