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

smallworld/state/models/armel/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 ArmELSysVModel
+
+
+class ArmELSysVBsdSignal(BsdSignal, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVKill(Kill, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVKillpg(Killpg, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVPthreadKill(PthreadKill, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVPthreadSigmask(PthreadSigmask, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigaction(Sigaction, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigaddset(Sigaddset, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigaltstack(Sigaltstack, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigdelset(Sigdelset, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigemptyset(Sigemptyset, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigfillset(Sigfillset, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSighold(Sighold, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigignore(Sigignore, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSiginterrupt(Siginterrupt, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigismember(Sigismember, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigpause(Sigpause, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigpending(Sigpending, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigprocmask(Sigprocmask, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigqueue(Sigqueue, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigrelse(Sigrelse, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigset(Sigset, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigsuspend(Sigsuspend, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigtimedwait(Sigtimedwait, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigwait(Sigwait, ArmELSysVModel):
+    pass
+
+
+class ArmELSysVSigwaitinfo(Sigwaitinfo, ArmELSysVModel):
+    pass
+
+
+__all__ = [
+    "ArmELSysVBsdSignal",
+    "ArmELSysVKill",
+    "ArmELSysVKillpg",
+    "ArmELSysVPthreadKill",
+    "ArmELSysVPthreadSigmask",
+    "ArmELSysVSigaction",
+    "ArmELSysVSigaddset",
+    "ArmELSysVSigaltstack",
+    "ArmELSysVSigdelset",
+    "ArmELSysVSigemptyset",
+    "ArmELSysVSigfillset",
+    "ArmELSysVSighold",
+    "ArmELSysVSigignore",
+    "ArmELSysVSiginterrupt",
+    "ArmELSysVSigismember",
+    "ArmELSysVSigpause",
+    "ArmELSysVSigpending",
+    "ArmELSysVSigprocmask",
+    "ArmELSysVSigqueue",
+    "ArmELSysVSigrelse",
+    "ArmELSysVSigset",
+    "ArmELSysVSigsuspend",
+    "ArmELSysVSigtimedwait",
+    "ArmELSysVSigwait",
+    "ArmELSysVSigwaitinfo",
+]

smallworld/state/models/armel/systemv/systemv.py

@@ -0,0 +1,82 @@
+import struct
+
+from ..... import emulators, platforms
+from ...cstd import ArgumentType, CStdModel
+
+
+class ArmELSysVModel(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_V5T, 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 = True
+    _variadic_soft_float = True
+    _floats_are_doubles = False
+    _float_arg_regs = []
+    _double_arg_regs = []
+
+    _init_stack_offset = 0
+    _align_stack = True
+    _eight_byte_reg_size = 2
+    _double_reg_size = 2
+    _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("r0", intval)
+
+    def _return_double(self, emulator: emulators.Emulator, val: float) -> None:
+        data = struct.pack("<d", val)
+        intval = int.from_bytes(data, "little")
+
+        lo = intval & self._int_inv_mask
+        hi = (intval >> 32) & self._int_inv_mask
+
+        emulator.write_register("r0", lo)
+        emulator.write_register("r1", hi)

smallworld/state/models/armhf/__init__.py

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

smallworld/state/models/armhf/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/armhf/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/armhf/systemv/c99/signal.py

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

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

@@ -0,0 +1,265 @@
+from ....c99 import (
+    Clearerr,
+    Fclose,
+    Feof,
+    Ferror,
+    Fflush,
+    Fgetc,
+    Fgetpos,
+    Fgets,
+    Fopen,
+    Fprintf,
+    Fputc,
+    Fputs,
+    Fread,
+    Freopen,
+    Fscanf,
+    Fseek,
+    Fsetpos,
+    Ftell,
+    Fwrite,
+    Getc,
+    Getchar,
+    Gets,
+    Printf,
+    Putc,
+    Putchar,
+    Puts,
+    Remove,
+    Rename,
+    Rewind,
+    Scanf,
+    Snprintf,
+    Sprintf,
+    Sscanf,
+    Tmpfile,
+    Tmpnam,
+    Ungetc,
+    Vfprintf,
+    Vfscanf,
+    Vprintf,
+    Vscanf,
+    Vsnprintf,
+    Vsprintf,
+    Vsscanf,
+)
+from ..systemv import ArmHFSysVModel
+
+
+class ArmHFSysVFclose(Fclose, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFeof(Feof, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFerror(Ferror, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFgetc(Fgetc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFgets(Fgets, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFopen(Fopen, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFprintf(Fprintf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFputc(Fputc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFputs(Fputs, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFread(Fread, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFscanf(Fscanf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFseek(Fseek, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFtell(Ftell, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFwrite(Fwrite, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVGetc(Getc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVGetchar(Getchar, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVGets(Gets, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVPrintf(Printf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVPutc(Putc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVPutchar(Putchar, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVPuts(Puts, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVRemove(Remove, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVRename(Rename, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVRewind(Rewind, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVScanf(Scanf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSnprintf(Snprintf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSprintf(Sprintf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSscanf(Sscanf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVClearerr(Clearerr, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFflush(Fflush, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFreopen(Freopen, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFgetpos(Fgetpos, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFsetpos(Fsetpos, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVTmpfile(Tmpfile, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVTmpnam(Tmpnam, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVUngetc(Ungetc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVVfprintf(Vfprintf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVVfscanf(Vfscanf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVVprintf(Vprintf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVVscanf(Vscanf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVVsnprintf(Vsnprintf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVVsprintf(Vsprintf, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVVsscanf(Vsscanf, ArmHFSysVModel):
+    pass
+
+
+__all__ = [
+    "ArmHFSysVFclose",
+    "ArmHFSysVFeof",
+    "ArmHFSysVFerror",
+    "ArmHFSysVFgetc",
+    "ArmHFSysVFgets",
+    "ArmHFSysVFopen",
+    "ArmHFSysVFprintf",
+    "ArmHFSysVFputc",
+    "ArmHFSysVFputs",
+    "ArmHFSysVFread",
+    "ArmHFSysVFscanf",
+    "ArmHFSysVFseek",
+    "ArmHFSysVFtell",
+    "ArmHFSysVFwrite",
+    "ArmHFSysVGetc",
+    "ArmHFSysVGetchar",
+    "ArmHFSysVGets",
+    "ArmHFSysVPrintf",
+    "ArmHFSysVPutc",
+    "ArmHFSysVPutchar",
+    "ArmHFSysVPuts",
+    "ArmHFSysVRemove",
+    "ArmHFSysVRename",
+    "ArmHFSysVRewind",
+    "ArmHFSysVScanf",
+    "ArmHFSysVSnprintf",
+    "ArmHFSysVSprintf",
+    "ArmHFSysVSscanf",
+    "ArmHFSysVClearerr",
+    "ArmHFSysVFflush",
+    "ArmHFSysVFreopen",
+    "ArmHFSysVFgetpos",
+    "ArmHFSysVFsetpos",
+    "ArmHFSysVTmpfile",
+    "ArmHFSysVTmpnam",
+    "ArmHFSysVUngetc",
+    "ArmHFSysVVfprintf",
+    "ArmHFSysVVfscanf",
+    "ArmHFSysVVprintf",
+    "ArmHFSysVVscanf",
+    "ArmHFSysVVsnprintf",
+    "ArmHFSysVVsprintf",
+    "ArmHFSysVVsscanf",
+]

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

@@ -0,0 +1,169 @@
+from ....c99 import (
+    Abort,
+    Abs,
+    Atexit,
+    Atof,
+    Atoi,
+    Atol,
+    Atoll,
+    Calloc,
+    Div,
+    Exit,
+    Free,
+    Getenv,
+    LAbs,
+    LDiv,
+    LLAbs,
+    LLDiv,
+    Malloc,
+    Mblen,
+    Mbstowcs,
+    Mbtowc,
+    QSort,
+    Rand,
+    Realloc,
+    Srand,
+    System,
+    Wcstombs,
+    Wctomb,
+)
+from ..systemv import ArmHFSysVModel
+
+
+class ArmHFSysVAbs(Abs, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVLAbs(LAbs, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVLLAbs(LLAbs, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVAtof(Atof, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVAtoi(Atoi, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVAtol(Atol, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVAtoll(Atoll, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVCalloc(Calloc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVDiv(Div, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVLDiv(LDiv, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVLLDiv(LLDiv, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVExit(Exit, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVFree(Free, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMalloc(Malloc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVQSort(QSort, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVRand(Rand, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVRealloc(Realloc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSrand(Srand, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVAbort(Abort, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVAtexit(Atexit, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVGetenv(Getenv, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMblen(Mblen, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMbstowcs(Mbstowcs, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVMbtowc(Mbtowc, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVSystem(System, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVWcstombs(Wcstombs, ArmHFSysVModel):
+    pass
+
+
+class ArmHFSysVWctomb(Wctomb, ArmHFSysVModel):
+    pass
+
+
+__all__ = [
+    "ArmHFSysVAbs",
+    "ArmHFSysVLAbs",
+    "ArmHFSysVLLAbs",
+    "ArmHFSysVAtof",
+    "ArmHFSysVAtoi",
+    "ArmHFSysVAtol",
+    "ArmHFSysVAtoll",
+    "ArmHFSysVCalloc",
+    "ArmHFSysVDiv",
+    "ArmHFSysVLDiv",
+    "ArmHFSysVLLDiv",
+    "ArmHFSysVExit",
+    "ArmHFSysVFree",
+    "ArmHFSysVMalloc",
+    "ArmHFSysVQSort",
+    "ArmHFSysVRand",
+    "ArmHFSysVRealloc",
+    "ArmHFSysVSrand",
+    "ArmHFSysVAbort",
+    "ArmHFSysVAtexit",
+    "ArmHFSysVGetenv",
+    "ArmHFSysVMblen",
+    "ArmHFSysVMbstowcs",
+    "ArmHFSysVMbtowc",
+    "ArmHFSysVSystem",
+    "ArmHFSysVWcstombs",
+    "ArmHFSysVWctomb",
+]