smallworld-re 1.0.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

smallworld/state/models/armhf/systemv/c99/string.py

@@ -0,0 +1,139 @@
+from ....c99 import (
+    Memchr,
+    Memcmp,
+    Memcpy,
+    Memmove,
+    Memset,
+    Strcat,
+    Strchr,
+    Strcmp,
+    Strcoll,
+    Strcpy,
+    Strcspn,
+    Strerror,
+    Strlen,
+    Strncat,
+    Strncmp,
+    Strncpy,
+    Strpbrk,
+    Strrchr,
+    Strspn,
+    Strstr,
+    Strtok,
+    Strxfrm,
+)
+from ..systemv import ArmHFSysVModel
+
+
+class ArmHFSysVMemcpy(Memcpy, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMemmove(Memmove, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrcpy(Strcpy, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrncpy(Strncpy, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrcat(Strcat, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrncat(Strncat, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMemcmp(Memcmp, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrncmp(Strncmp, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrcmp(Strcmp, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrcoll(Strcoll, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrxfrm(Strxfrm, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMemchr(Memchr, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrchr(Strchr, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrcspn(Strcspn, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrpbrk(Strpbrk, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrrchr(Strrchr, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrspn(Strspn, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrstr(Strstr, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrtok(Strtok, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMemset(Memset, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrerror(Strerror, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrlen(Strlen, ArmHFSysVModel):
+    pass
+
+
+__all__ = [
+    "ArmHFSysVMemcpy",
+    "ArmHFSysVMemmove",
+    "ArmHFSysVStrcpy",
+    "ArmHFSysVStrncpy",
+    "ArmHFSysVStrcat",
+    "ArmHFSysVStrncat",
+    "ArmHFSysVMemcmp",
+    "ArmHFSysVStrncmp",
+    "ArmHFSysVStrcmp",
+    "ArmHFSysVStrcoll",
+    "ArmHFSysVStrxfrm",
+    "ArmHFSysVMemchr",
+    "ArmHFSysVStrchr",
+    "ArmHFSysVStrcspn",
+    "ArmHFSysVStrpbrk",
+    "ArmHFSysVStrrchr",
+    "ArmHFSysVStrspn",
+    "ArmHFSysVStrstr",
+    "ArmHFSysVStrtok",
+    "ArmHFSysVMemset",
+    "ArmHFSysVStrerror",
+    "ArmHFSysVStrlen",
+]

smallworld/state/models/armhf/systemv/c99/time.py

@@ -0,0 +1,61 @@
+from ....c99 import (
+    Asctime,
+    Clock,
+    Ctime,
+    Difftime,
+    Gmtime,
+    Localtime,
+    Mktime,
+    Strftime,
+    Time,
+)
+from ..systemv import ArmHFSysVModel
+
+
+class ArmHFSysVTime(Time, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVLocaltime(Localtime, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVGmtime(Gmtime, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVCtime(Ctime, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVAsctime(Asctime, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVStrftime(Strftime, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVDifftime(Difftime, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMktime(Mktime, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVClock(Clock, ArmHFSysVModel):
+    pass
+
+
+__all__ = [
+    "ArmHFSysVTime",
+    "ArmHFSysVLocaltime",
+    "ArmHFSysVGmtime",
+    "ArmHFSysVCtime",
+    "ArmHFSysVAsctime",
+    "ArmHFSysVStrftime",
+    "ArmHFSysVDifftime",
+    "ArmHFSysVMktime",
+    "ArmHFSysVClock",
+]

smallworld/state/models/armhf/systemv/posix/__init__.py

@@ -0,0 +1,6 @@
+from .libgen import *  # noqa: F401, F403
+from .libgen import __all__ as __libgen__
+from .signal import *  # noqa: F401, F403
+from .signal import __all__ as __signal__
+
+__all__ = __libgen__ + __signal__

smallworld/state/models/armhf/systemv/posix/libgen.py

@@ -0,0 +1,16 @@
+from ....posix.libgen import Basename, Dirname
+from ..systemv import ArmHFSysVModel
+
+
+class ArmHFSysVBasename(Basename, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVDirname(Dirname, ArmHFSysVModel):
+    pass
+
+
+__all__ = [
+    "ArmHFSysVBasename",
+    "ArmHFSysVDirname",
+]

smallworld/state/models/armhf/systemv/posix/signal.py

@@ -0,0 +1,157 @@
+from ....posix.signal import (
+    BsdSignal,
+    Kill,
+    Killpg,
+    PthreadKill,
+    PthreadSigmask,
+    Sigaction,
+    Sigaddset,
+    Sigaltstack,
+    Sigdelset,
+    Sigemptyset,
+    Sigfillset,
+    Sighold,
+    Sigignore,
+    Siginterrupt,
+    Sigismember,
+    Sigpause,
+    Sigpending,
+    Sigprocmask,
+    Sigqueue,
+    Sigrelse,
+    Sigset,
+    Sigsuspend,
+    Sigtimedwait,
+    Sigwait,
+    Sigwaitinfo,
+)
+from ..systemv import ArmHFSysVModel
+
+
+class ArmHFSysVBsdSignal(BsdSignal, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVKill(Kill, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVKillpg(Killpg, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVPthreadKill(PthreadKill, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVPthreadSigmask(PthreadSigmask, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigaction(Sigaction, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigaddset(Sigaddset, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigaltstack(Sigaltstack, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigdelset(Sigdelset, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigemptyset(Sigemptyset, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigfillset(Sigfillset, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSighold(Sighold, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigignore(Sigignore, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSiginterrupt(Siginterrupt, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigismember(Sigismember, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigpause(Sigpause, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigpending(Sigpending, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigprocmask(Sigprocmask, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigqueue(Sigqueue, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigrelse(Sigrelse, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigset(Sigset, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigsuspend(Sigsuspend, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigtimedwait(Sigtimedwait, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigwait(Sigwait, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSigwaitinfo(Sigwaitinfo, ArmHFSysVModel):
+    pass
+
+
+__all__ = [
+    "ArmHFSysVBsdSignal",
+    "ArmHFSysVKill",
+    "ArmHFSysVKillpg",
+    "ArmHFSysVPthreadKill",
+    "ArmHFSysVPthreadSigmask",
+    "ArmHFSysVSigaction",
+    "ArmHFSysVSigaddset",
+    "ArmHFSysVSigaltstack",
+    "ArmHFSysVSigdelset",
+    "ArmHFSysVSigemptyset",
+    "ArmHFSysVSigfillset",
+    "ArmHFSysVSighold",
+    "ArmHFSysVSigignore",
+    "ArmHFSysVSiginterrupt",
+    "ArmHFSysVSigismember",
+    "ArmHFSysVSigpause",
+    "ArmHFSysVSigpending",
+    "ArmHFSysVSigprocmask",
+    "ArmHFSysVSigqueue",
+    "ArmHFSysVSigrelse",
+    "ArmHFSysVSigset",
+    "ArmHFSysVSigsuspend",
+    "ArmHFSysVSigtimedwait",
+    "ArmHFSysVSigwait",
+    "ArmHFSysVSigwaitinfo",
+]

smallworld/state/models/armhf/systemv/systemv.py

@@ -0,0 +1,77 @@
+import struct
+
+from ..... import emulators, platforms
+from ...cstd import ArgumentType, CStdModel
+
+
+class ArmHFSysVModel(CStdModel):
+    """Base class for C models using the ARM32 GNU EABI
+
+    This is a specific ARM System V ABI.
+    It generally applies to ARMv5t or ARMv6.
+    """
+
+    platform = platforms.Platform(
+        platforms.Architecture.ARM_V7A, platforms.Byteorder.LITTLE
+    )
+    abi = platforms.ABI.SYSTEMV
+
+    _int_sign_mask = 0x80000000
+    _int_inv_mask = 0xFFFFFFFF
+    _long_sign_mask = 0x80000000
+    _long_inv_mask = 0xFFFFFFFF
+    _long_long_sign_mask = 0x8000000000000000
+    _long_long_inv_mask = 0xFFFFFFFFFFFFFFFF
+
+    _four_byte_types = {
+        ArgumentType.INT,
+        ArgumentType.UINT,
+        ArgumentType.LONG,
+        ArgumentType.ULONG,
+        ArgumentType.SIZE_T,
+        ArgumentType.SSIZE_T,
+        ArgumentType.POINTER,
+    }
+
+    _eight_byte_types = {
+        ArgumentType.LONGLONG,
+        ArgumentType.ULONGLONG,
+    }
+
+    _four_byte_arg_regs = ["r0", "r1", "r2", "r3"]
+    _eight_byte_arg_regs = ["r0", "r1", "r2", "r3"]
+
+    _soft_float = False
+    _variadic_soft_float = True
+    _floats_are_doubles = False
+    _float_arg_regs = ["s0", "s1", "s2", "s3", "s4", "s5", "s6"]
+    _double_arg_regs = ["d0", "d1", "d2", "d3", "d4", "d5", "d6"]
+
+    _init_stack_offset = 0
+    _align_stack = True
+    _eight_byte_reg_size = 2
+    _double_reg_size = 1
+    _four_byte_stack_size = 4
+    _eight_byte_stack_size = 8
+    _float_stack_size = 4
+    _double_stack_size = 8
+
+    def _return_4_byte(self, emulator: emulators.Emulator, val: int) -> None:
+        emulator.write_register("r0", val)
+
+    def _return_8_byte(self, emulator: emulators.Emulator, val: int) -> None:
+        lo = val & self._int_inv_mask
+        hi = val >> 32 & self._int_inv_mask
+
+        emulator.write_register("r0", lo)
+        emulator.write_register("r1", hi)
+
+    def _return_float(self, emulator: emulators.Emulator, val: float) -> None:
+        data = struct.pack("<f", val)
+        intval = int.from_bytes(data, "little")
+        emulator.write_register("s0", intval)
+
+    def _return_double(self, emulator: emulators.Emulator, val: float) -> None:
+        data = struct.pack("<d", val)
+        intval = int.from_bytes(data, "little")
+        emulator.write_register("d0", intval)

smallworld/state/models/c99/__init__.py

@@ -0,0 +1,12 @@
+from .signal import *  # noqa: F401, F403
+from .signal import __all__ as __signal__
+from .stdio import *  # noqa: F401, F403
+from .stdio import __all__ as __stdio__
+from .stdlib import *  # noqa: F401, F403
+from .stdlib import __all__ as __stdlib__
+from .string import *  # noqa: F401, F403
+from .string import __all__ as __string__
+from .time import *  # noqa: F401, F403
+from .time import __all__ as __time__
+
+__all__ = __signal__ + __stdlib__ + __string__ + __stdio__ + __time__