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

smallworld/state/models/loongarch64/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 LoongArch64SysVModel
+
+
+class LoongArch64SysVMemcpy(Memcpy, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVMemmove(Memmove, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrcpy(Strcpy, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrncpy(Strncpy, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrcat(Strcat, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrncat(Strncat, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVMemcmp(Memcmp, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrncmp(Strncmp, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrcmp(Strcmp, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrcoll(Strcoll, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrxfrm(Strxfrm, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVMemchr(Memchr, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrchr(Strchr, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrcspn(Strcspn, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrpbrk(Strpbrk, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrrchr(Strrchr, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrspn(Strspn, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrstr(Strstr, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrtok(Strtok, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVMemset(Memset, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrerror(Strerror, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrlen(Strlen, LoongArch64SysVModel):
+    pass
+
+
+__all__ = [
+    "LoongArch64SysVMemcpy",
+    "LoongArch64SysVMemmove",
+    "LoongArch64SysVStrcpy",
+    "LoongArch64SysVStrncpy",
+    "LoongArch64SysVStrcat",
+    "LoongArch64SysVStrncat",
+    "LoongArch64SysVMemcmp",
+    "LoongArch64SysVStrncmp",
+    "LoongArch64SysVStrcmp",
+    "LoongArch64SysVStrcoll",
+    "LoongArch64SysVStrxfrm",
+    "LoongArch64SysVMemchr",
+    "LoongArch64SysVStrchr",
+    "LoongArch64SysVStrcspn",
+    "LoongArch64SysVStrpbrk",
+    "LoongArch64SysVStrrchr",
+    "LoongArch64SysVStrspn",
+    "LoongArch64SysVStrstr",
+    "LoongArch64SysVStrtok",
+    "LoongArch64SysVMemset",
+    "LoongArch64SysVStrerror",
+    "LoongArch64SysVStrlen",
+]

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

@@ -0,0 +1,61 @@
+from ....c99 import (
+    Asctime,
+    Clock,
+    Ctime,
+    Difftime,
+    Gmtime,
+    Localtime,
+    Mktime,
+    Strftime,
+    Time,
+)
+from ..systemv import LoongArch64SysVModel
+
+
+class LoongArch64SysVTime(Time, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVLocaltime(Localtime, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVGmtime(Gmtime, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVCtime(Ctime, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVAsctime(Asctime, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVStrftime(Strftime, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVDifftime(Difftime, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVMktime(Mktime, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVClock(Clock, LoongArch64SysVModel):
+    pass
+
+
+__all__ = [
+    "LoongArch64SysVTime",
+    "LoongArch64SysVLocaltime",
+    "LoongArch64SysVGmtime",
+    "LoongArch64SysVCtime",
+    "LoongArch64SysVAsctime",
+    "LoongArch64SysVStrftime",
+    "LoongArch64SysVDifftime",
+    "LoongArch64SysVMktime",
+    "LoongArch64SysVClock",
+]

smallworld/state/models/loongarch64/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/loongarch64/systemv/posix/libgen.py

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

smallworld/state/models/loongarch64/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 LoongArch64SysVModel
+
+
+class LoongArch64SysVBsdSignal(BsdSignal, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVKill(Kill, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVKillpg(Killpg, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVPthreadKill(PthreadKill, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVPthreadSigmask(PthreadSigmask, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigaction(Sigaction, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigaddset(Sigaddset, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigaltstack(Sigaltstack, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigdelset(Sigdelset, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigemptyset(Sigemptyset, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigfillset(Sigfillset, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSighold(Sighold, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigignore(Sigignore, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSiginterrupt(Siginterrupt, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigismember(Sigismember, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigpause(Sigpause, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigpending(Sigpending, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigprocmask(Sigprocmask, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigqueue(Sigqueue, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigrelse(Sigrelse, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigset(Sigset, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigsuspend(Sigsuspend, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigtimedwait(Sigtimedwait, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigwait(Sigwait, LoongArch64SysVModel):
+    pass
+
+
+class LoongArch64SysVSigwaitinfo(Sigwaitinfo, LoongArch64SysVModel):
+    pass
+
+
+__all__ = [
+    "LoongArch64SysVBsdSignal",
+    "LoongArch64SysVKill",
+    "LoongArch64SysVKillpg",
+    "LoongArch64SysVPthreadKill",
+    "LoongArch64SysVPthreadSigmask",
+    "LoongArch64SysVSigaction",
+    "LoongArch64SysVSigaddset",
+    "LoongArch64SysVSigaltstack",
+    "LoongArch64SysVSigdelset",
+    "LoongArch64SysVSigemptyset",
+    "LoongArch64SysVSigfillset",
+    "LoongArch64SysVSighold",
+    "LoongArch64SysVSigignore",
+    "LoongArch64SysVSiginterrupt",
+    "LoongArch64SysVSigismember",
+    "LoongArch64SysVSigpause",
+    "LoongArch64SysVSigpending",
+    "LoongArch64SysVSigprocmask",
+    "LoongArch64SysVSigqueue",
+    "LoongArch64SysVSigrelse",
+    "LoongArch64SysVSigset",
+    "LoongArch64SysVSigsuspend",
+    "LoongArch64SysVSigtimedwait",
+    "LoongArch64SysVSigwait",
+    "LoongArch64SysVSigwaitinfo",
+]

smallworld/state/models/loongarch64/systemv/systemv.py

@@ -0,0 +1,83 @@
+import struct
+
+from ..... import emulators, platforms
+from ...cstd import ArgumentType, CStdModel
+
+
+class LoongArch64SysVModel(CStdModel):
+    """Base class for C models using the LoongArch64 System V ABI"""
+
+    platform = platforms.Platform(
+        platforms.Architecture.LOONGARCH64, platforms.Byteorder.LITTLE
+    )
+    abi = platforms.ABI.SYSTEMV
+
+    _int_sign_mask = 0x80000000
+    _int_inv_mask = 0xFFFFFFFF
+    _long_sign_mask = 0x8000000000000000
+    _long_inv_mask = 0xFFFFFFFFFFFFFFFF
+    _long_long_sign_mask = 0x8000000000000000
+    _long_long_inv_mask = 0xFFFFFFFFFFFFFFFF
+
+    _four_byte_types = {ArgumentType.INT, ArgumentType.UINT}
+
+    _eight_byte_types = {
+        ArgumentType.LONG,
+        ArgumentType.ULONG,
+        ArgumentType.LONGLONG,
+        ArgumentType.ULONGLONG,
+        ArgumentType.SIZE_T,
+        ArgumentType.SSIZE_T,
+        ArgumentType.POINTER,
+    }
+
+    _four_byte_arg_regs = ["a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7"]
+
+    _eight_byte_arg_regs = [
+        "a0",
+        "a1",
+        "a2",
+        "a3",
+        "a4",
+        "a5",
+        "a6",
+        "a7",
+    ]
+
+    _soft_float = False
+    _variadic_soft_float = False
+    _floats_are_doubles = False
+    _float_arg_regs = ["fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7"]
+    _double_arg_regs = ["fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7"]
+
+    _init_stack_offset = 0
+    _align_stack = True
+    _eight_byte_reg_size = 1
+    _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:
+        """Return a four-byte type"""
+        val &= self._int_inv_mask
+        if val & self._int_sign_mask != 0:
+            val |= self._int_signext_mask
+        emulator.write_register("a0", val)
+
+    def _return_8_byte(self, emulator: emulators.Emulator, val: int) -> None:
+        """Return an eight-byte type"""
+        emulator.write_register("a0", val)
+
+    def _return_float(self, emulator: emulators.Emulator, val: float) -> None:
+        """Return a float"""
+        data = struct.pack("<f", val)
+        intval = int.from_bytes(data, "little")
+        emulator.write_register("fa0", intval)
+
+    def _return_double(self, emulator: emulators.Emulator, val: float) -> None:
+        """Return a double"""
+        data = struct.pack("<d", val)
+        intval = int.from_bytes(data, "little")
+        emulator.write_register("fa0", intval)

smallworld/state/models/mips/__init__.py

@@ -0,0 +1 @@
+from .systemv import __all__ as __sysv__  # noqa: F401

smallworld/state/models/mips/systemv/__init__.py

@@ -0,0 +1,6 @@
+from .c99 import *  # noqa: F401,F403
+from .c99 import __all__ as __c99__
+from .posix import *  # noqa: F401,F403
+from .posix import __all__ as __posix__
+
+__all__ = __c99__ + __posix__

smallworld/state/models/mips/systemv/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__

smallworld/state/models/mips/systemv/c99/signal.py

@@ -0,0 +1,16 @@
+from ....c99.signal import Raise, Signal
+from ..systemv import MIPSSysVModel
+
+
+class MIPSSysVRaise(Raise, MIPSSysVModel):
+    pass
+
+
+class MIPSSysVSignal(Signal, MIPSSysVModel):
+    pass
+
+
+__all__ = [
+    "MIPSSysVRaise",
+    "MIPSSysVSignal",
+]