PyNerva 0.0.5__py3-none-any.whl

nervapy/formats/mscoff/section.py

@@ -0,0 +1,181 @@
+# 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
+
+
+class SectionFlags:
+    # Section contains executable code
+    code = 0x00000020
+    # Section contains initialized data
+    initialized_data = 0x00000040
+    # Section contains uninitialized data
+    uninitialized_data = 0x00000080
+    # Section contains extended relocations
+    extended_relocations = 0x01000000
+    # Section can be discarded as needed
+    discardable = 0x02000000
+    # Section can not be cached
+    uncached = 0x04000000
+    # Section can not be pageable
+    unpaged = 0x08000000
+    # Section data can be shared between process instances
+    shared = 0x10000000
+    # Section contains executable data during process execution
+    executable = 0x20000000
+    # Section contains readable data during process execution
+    readable = 0x40000000
+    # Section contains writable data during process execution
+    writable = 0x80000000
+
+
+class Section(object):
+    header_size = 40
+
+    _alignment_flag_map = {
+        1: 0x00100000,
+        2: 0x00200000,
+        4: 0x00300000,
+        8: 0x00400000,
+        16: 0x00500000,
+        32: 0x00600000,
+        64: 0x00700000,
+        128: 0x00800000,
+        256: 0x00900000,
+        512: 0x00A00000,
+        1024: 0x00B00000,
+        2048: 0x00C00000,
+        4096: 0x00D00000,
+        8192: 0x00E00000,
+    }
+
+    _flag_alignment_map = {
+        flag: alignment for (alignment, flag) in six.iteritems(_alignment_flag_map)
+    }
+
+    _alignment_mask = 0x00F00000
+
+    def __init__(self, name, flags, alignment=None):
+        from nervapy.util import is_uint32
+
+        if not isinstance(name, str):
+            raise TypeError("Section name %s is not a string" % str(name))
+        if not is_uint32(flags):
+            raise TypeError(
+                "Flags %s are not representable as a 32-bit unsigned integer"
+                % str(flags)
+            )
+
+        super(Section, self).__init__()
+        # Section name
+        self.name = name
+        # Flags for the section
+        self.flags = (flags & ~Section._alignment_mask) | Section._alignment_flag_map[1]
+        if alignment is not None:
+            self.alignment = alignment
+
+        self.relocations = list()
+        self.content = bytearray()
+
+    @property
+    def content_size(self):
+        return len(self.content)
+
+    @property
+    def alignment(self):
+        return Section._flag_alignment_map.get(self.flags & Section._alignment_mask, 1)
+
+    @alignment.setter
+    def alignment(self, alignment):
+        from nervapy.util import is_int
+
+        if not is_int(alignment):
+            raise TypeError("Alignment %s is not an integer" % str(alignment))
+        if alignment < 0:
+            raise ValueError("Alignment %d is not a positive integer" % alignment)
+        if alignment & (alignment - 1) != 0:
+            raise ValueError("Alignment %d is not a power of 2" % alignment)
+        if alignment not in Section._alignment_flag_map:
+            raise ValueError(
+                "Alignment %d exceeds maximum alignment (8192)" % alignment
+            )
+        self.flags = (
+            self.flags & ~Section._alignment_mask
+        ) | Section._alignment_flag_map[alignment]
+
+    def encode_header(
+        self, encoder, name_index_map, offset, relocations_offset=None, address=None
+    ):
+        from nervapy.encoder import Encoder
+
+        assert isinstance(encoder, Encoder)
+        assert isinstance(name_index_map, dict)
+
+        if address is None:
+            address = 0
+        if relocations_offset is None:
+            relocations_offset = 0
+        line_numbers_offset = 0
+        line_numbers_count = 0
+        try:
+            name_8_bytes = encoder.fixed_string(self.name, 8)
+        except ValueError:
+            name_index = name_index_map[self.name]
+            name_8_bytes = encoder.fixed_string("/" + str(name_index), 8)
+        return (
+            name_8_bytes
+            + encoder.uint32(self.content_size)
+            + encoder.uint32(address)
+            + encoder.uint32(self.content_size)
+            + encoder.uint32(offset)
+            + encoder.uint32(relocations_offset)
+            + encoder.uint32(line_numbers_offset)
+            + encoder.uint16(len(self.relocations))
+            + encoder.uint16(line_numbers_count)
+            + encoder.uint32(self.flags)
+        )
+
+
+class TextSection(Section):
+    def __init__(self, name=".text", alignment=None):
+        super(TextSection, self).__init__(
+            name,
+            SectionFlags.code | SectionFlags.readable | SectionFlags.executable,
+            alignment,
+        )
+
+
+class ReadOnlyDataSection(Section):
+    def __init__(self, name=".rdata", alignment=None):
+        super(ReadOnlyDataSection, self).__init__(
+            name, SectionFlags.initialized_data | SectionFlags.readable, alignment
+        )
+
+
+class StringTable:
+    def __init__(self):
+        self._strings = dict()
+        self.size = 4
+
+    def add(self, string):
+        import codecs
+
+        if string in self._strings:
+            return self._strings[string]
+        else:
+            string_index = self.size
+            self._strings[string] = string_index
+            bytestring = codecs.encode(string, "utf-8")
+            self.size += len(bytestring) + 1
+            return string_index
+
+    def encode(self):
+        import codecs
+
+        import nervapy.encoder
+
+        bytestring = nervapy.encoder.Encoder.uint32le(self.size)
+        for string in sorted(self._strings, key=self._strings.get):
+            bytestring += codecs.encode(string, "utf8") + b"\x00"
+        return bytestring

nervapy/formats/mscoff/symbol.py

@@ -0,0 +1,148 @@
+# 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 enum import IntEnum
+
+
+class StorageClass(IntEnum):
+    """
+    External symbol. If section number is undefined (0), value specifies symbol size. Otherwise value specifies offset
+    within section.
+    """
+
+    external = 2
+
+    """Static symbol. value specifies offset within section. value of 0 means that symbol represents section name."""
+    static = 3
+
+    """A function .bf (beginning of function), .ef (end of function) or .lf (lines in function record) """
+    function = 101
+    """Source-file symbol record. Followed by auxiliary records that name the file"""
+    file = 103
+
+
+class SymbolType(IntEnum):
+    non_function = 0
+    function = 0x20
+
+
+class Symbol:
+    entry_size = 18
+
+    def __init__(self):
+        # Name of the symbol
+        self.name = None
+        # Value of the symbol. Interpretation depends on section_index and storage_class
+        self.value = None
+        # Relevant section
+        self.section = None
+        # Symbol type. Microsoft tools use only 0x20 (function) or 0x0 (not a function)
+        self.symbol_type = None
+        # Storage class
+        self.storage_class = None
+
+    def encode_entry(self, encoder, name_index_map, section_index_map):
+        from nervapy.encoder import Encoder
+
+        assert isinstance(encoder, Encoder)
+
+        try:
+            name_8_bytes = encoder.fixed_string(self.name, 8)
+        except ValueError:
+            name_index = name_index_map[self.name]
+            name_8_bytes = encoder.uint32(0) + encoder.uint32(name_index)
+        section_index = section_index_map[self.section]
+        auxiliary_entries = 0
+        return (
+            name_8_bytes
+            + encoder.uint32(self.value)
+            + encoder.uint16(section_index)
+            + encoder.uint16(self.symbol_type)
+            + encoder.uint8(self.storage_class)
+            + encoder.uint8(auxiliary_entries)
+        )
+
+
+class RelocationType(IntEnum):
+    # Relocation is ignored
+    absolute = 0
+
+    # 32-bit address
+    x86_address32 = 6
+    # 32-bit offset relative to image base
+    x86_imagebase_offset32 = 7
+    # 16-bit section index
+    x86_section_index = 10
+    # 32-bit offset relative to the section
+    x86_section_offset32 = 11
+    # CLR token
+    x86_clr_token = 12
+    # Unsigned 7-bit offset relative to the section
+    x86_section_offset7 = 13
+    # 32-bit offset relative to the end of relocation
+    x86_relocation_offset32 = 14
+
+    # 64-bit address
+    x86_64_address64 = 1
+    # 32-bit address
+    x86_64_address32 = 2
+    # 32-bit offset relative to image base
+    x86_64_imagebase_offset32 = 3
+    # 32-bit offset relative to the end of relocation
+    x86_64_relocation_offset32 = 4
+    # 32-bit offset relative to the end of relocation + 1 byte
+    x86_64_relocation_plus_1_offset32 = 5
+    # 32-bit offset relative to the end of relocation + 2 bytes
+    x86_64_relocation_plus_2_offset32 = 6
+    # 32-bit offset relative to the end of relocation + 3 bytes
+    x86_64_relocation_plus_3_offset32 = 7
+    # 32-bit offset relative to the end of relocation + 4 bytes
+    x86_64_relocation_plus_4_offset32 = 8
+    # 32-bit offset relative to the end of relocation + 5 bytes
+    x86_64_relocation_plus_5_offset32 = 9
+    # 16-bit section index
+    x86_64_section_index = 10
+    # 32-bit offset relative to the section
+    x86_64_section_offset32 = 11
+    # Unsigned 7-bit offset relative to the section
+    x86_64_section_offset7 = 12
+    # CLR token
+    x86_64_clr_token = 13
+
+
+class Relocation:
+    entry_size = 10
+
+    def __init__(self, type, offset, symbol):
+        from nervapy.util import is_int, is_uint32
+
+        if not isinstance(type, RelocationType):
+            raise TypeError(
+                "Relocation type %s is not in RelocationType enumeration" % str(type)
+            )
+        if not is_int(offset):
+            raise TypeError("Offset %s is not an integer" % str(offset))
+        if not is_uint32(offset):
+            raise ValueError(
+                "Offset %d can not be represented as a 32-bit unsigned integer" % offset
+            )
+        if not isinstance(symbol, Symbol):
+            raise TypeError("Symbol %s is not an instance of Symbol type" % str(symbol))
+
+        self.type = type
+        self.offset = offset
+        self.symbol = symbol
+
+    def encode_entry(self, encoder, symbol_index_map, section_address=0):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert self.symbol in symbol_index_map
+
+        symbol_index = symbol_index_map[self.symbol]
+        return (
+            encoder.uint32(section_address + self.offset)
+            + encoder.uint32(symbol_index)
+            + encoder.uint16(self.type)
+        )

nervapy/function.py

@@ -0,0 +1,136 @@
+# 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.
+
+
+class Argument(object):
+    """
+    Function argument.
+
+    An argument must have a C type and a name.
+
+    :ivar c_type: the type of the argument in C
+    :type c_type: :class:`nervapy.c.types.Type`
+
+    :ivar name: the name of the argument
+    :type name: str
+    """
+
+    def __init__(self, c_type, name=None):
+        """
+        :param nervapy.c.types.Type c_type: the type of the argument in C.
+            When Go function is generated, the type is automatically converted to similar Go type.
+            Note that the ``short``, ``int``, ``long``, and ``long long`` types do not have an equivalents in Go.
+            In particular, C's ``int`` type is not an equivalent of Go's ``int`` type. To get Go's ``int`` and ``uint``
+            types use ``ptrdiff_t`` and ``size_t`` correspondingly.
+
+        :param str name: the name of the argument. If the name is not provided explicitly, PeachPy tries to parse it
+            from the caller code. The name must follow the C rules for identifiers:
+
+            - It can contain only Latin letters, digits, and underscore symbol
+            - It can not start with a digit
+            - It can not start with double underscore (these names are reserved for PeachPy)
+            - Name must be unique among the function arguments
+        """
+
+        from nervapy.c.types import Type
+
+        if not isinstance(c_type, Type):
+            raise TypeError("%s is not a C type" % str(c_type))
+        self.c_type = c_type
+
+        if name is None:
+            import inspect
+            import re
+
+            _, _, _, _, caller_lines, _ = inspect.stack()[1]
+            if caller_lines is None:
+                raise ValueError(
+                    "Argument name is not specified and the caller context is not available"
+                )
+            source_line = caller_lines[0].strip()
+            match = re.match(
+                "(?:\\w+\\.)*(\\w+)\\s*=\\s*(?:\\w+\\.)*Argument\\(.+\\)", source_line
+            )
+            if match:
+                name = match.group(1)
+                while name.startswith("_"):
+                    name = name[1:]
+                if name.endswith("argument") or name.endswith("Argument"):
+                    name = name[: -len("argument")]
+                if name.endswith("arg") or name.endswith("Arg"):
+                    name = name[: -len("arg")]
+                while name.endswith("_"):
+                    name = name[:-1]
+            if not name:
+                raise ValueError(
+                    "Argument name is not specified and can not be parsed from the code"
+                )
+
+        from nervapy.name import Name
+
+        Name.check_name(name)
+        self.name = name
+
+    def __str__(self):
+        return str(self.c_type) + " " + self.name
+
+    def __repr__(self):
+        return str(self)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Argument)
+            and self.c_type == other.c_type
+            and self.name == other.name
+        )
+
+    def __ne__(self, other):
+        return (
+            not isinstance(other, Argument)
+            or self.c_type != other.c_type
+            or self.name != other.name
+        )
+
+    @property
+    def is_floating_point(self):
+        return self.c_type.is_floating_point
+
+    @property
+    def is_codeunit(self):
+        return self.c_type.is_codeunit
+
+    @property
+    def is_integer(self):
+        return self.c_type.is_integer
+
+    @property
+    def is_unsigned_integer(self):
+        return self.c_type.is_unsigned_integer
+
+    @property
+    def is_signed_integer(self):
+        return self.c_type.is_signed_integer
+
+    @property
+    def is_size_integer(self):
+        return self.c_type.is_size_integer
+
+    @property
+    def is_pointer_integer(self):
+        return self.c_type.is_pointer_integer
+
+    @property
+    def is_pointer(self):
+        return self.c_type.is_pointer
+
+    @property
+    def is_vector(self):
+        return self.c_type.is_vector
+
+    @property
+    def is_mask(self):
+        return self.c_type.is_mask
+
+    @property
+    def size(self):
+        return self.c_type.size