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

smallworld/state/models/c99/math.py

@@ -0,0 +1,362 @@
+from .... import emulators
+from ..cstd import CStdModel
+
+
+class Acos(CStdModel):
+    name = "acos"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double acos(double x);
+        raise NotImplementedError()
+
+
+class Acosf(CStdModel):
+    name = "acosf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float acosf(float x);
+        raise NotImplementedError()
+
+
+class Acosl(CStdModel):
+    name = "acosl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double acosl(long double x);
+        raise NotImplementedError()
+
+
+class Asin(CStdModel):
+    name = "asin"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double asin(double x);
+        raise NotImplementedError()
+
+
+class Asinf(CStdModel):
+    name = "asinf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float asinf(float x);
+        raise NotImplementedError()
+
+
+class Asinl(CStdModel):
+    name = "asinl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double asinl(long double x);
+        raise NotImplementedError()
+
+
+class Asinh(CStdModel):
+    name = "asinh"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double asinh(double x);
+        raise NotImplementedError()
+
+
+class Asinhf(CStdModel):
+    name = "asinhf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float asinhf(float x);
+        raise NotImplementedError()
+
+
+class Asinhl(CStdModel):
+    name = "asinhl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double asinhl(long double x);
+        raise NotImplementedError()
+
+
+class Atan(CStdModel):
+    name = "atan"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double atan(double x);
+        raise NotImplementedError()
+
+
+class Atanf(CStdModel):
+    name = "atanf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float atanf(double x);
+        raise NotImplementedError()
+
+
+class Atanl(CStdModel):
+    name = "atanl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double atanl(long double x);
+        raise NotImplementedError()
+
+
+class Atan2(CStdModel):
+    name = "atan2"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double atan2(double x, double y);
+        raise NotImplementedError()
+
+
+class Atan2f(CStdModel):
+    name = "atan2f"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float atan2(float x, float y);
+        raise NotImplementedError()
+
+
+class Atan2l(CStdModel):
+    name = "atan2l"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double atan2l(long double x, long double y);
+        raise NotImplementedError()
+
+
+class Atanh(CStdModel):
+    name = "atanh"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double atanh(double x);
+        raise NotImplementedError()
+
+
+class Atanhf(CStdModel):
+    name = "atanhf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float atanhf(float x);
+        raise NotImplementedError()
+
+
+class Atanhl(CStdModel):
+    name = "atanhl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double atanhl(long double x);
+        raise NotImplementedError()
+
+
+class Cbrt(CStdModel):
+    name = "cbrt"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double cbrt(double x);
+        raise NotImplementedError()
+
+
+class Cbrtf(CStdModel):
+    name = "cbrtf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float cbrtf(float x);
+        raise NotImplementedError()
+
+
+class Cbrtl(CStdModel):
+    name = "cbrtl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double long cbrtl(double x);
+        raise NotImplementedError()
+
+
+class Ceil(CStdModel):
+    name = "ceil"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double ceil(double x);
+        raise NotImplementedError()
+
+
+class Ceilf(CStdModel):
+    name = "ceilf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float ceilf(float x);
+        raise NotImplementedError()
+
+
+class Ceill(CStdModel):
+    name = "ceill"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double ceill(long double x);
+        raise NotImplementedError()
+
+
+class Copysign(CStdModel):
+    name = "copysign"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double copysign(double x, double y);
+        raise NotImplementedError()
+
+
+class Copysignf(CStdModel):
+    name = "copysignf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float copysignf(float x, float y);
+        raise NotImplementedError()
+
+
+class Copysignl(CStdModel):
+    name = "copysignl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double copysignl(long double x, long double y);
+        raise NotImplementedError()
+
+
+class Cos(CStdModel):
+    name = "cos"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double cos(double x);
+        raise NotImplementedError()
+
+
+class Cosf(CStdModel):
+    name = "cosf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float cosf(float x);
+        raise NotImplementedError()
+
+
+class Cosl(CStdModel):
+    name = "cosl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double cosl(long double x);
+        raise NotImplementedError()
+
+
+class Cosh(CStdModel):
+    name = "cosh"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double cosh(double x);
+        raise NotImplementedError()
+
+
+class Coshf(CStdModel):
+    name = "coshf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float coshf(float x);
+        raise NotImplementedError()
+
+
+class Coshl(CStdModel):
+    name = "coshl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double coshl(long double x);
+        raise NotImplementedError()
+
+
+class Exp(CStdModel):
+    name = "exp"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double exp(double x);
+        raise NotImplementedError()
+
+
+class Expf(CStdModel):
+    name = "expf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float expf(float x);
+        raise NotImplementedError()
+
+
+class Expl(CStdModel):
+    name = "expl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double expl(long double x);
+        raise NotImplementedError()
+
+
+class Exp2(CStdModel):
+    name = "exp2"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double exp2(double x);
+        raise NotImplementedError()
+
+
+class Exp2f(CStdModel):
+    name = "exp2f"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float exp2f(float x);
+        raise NotImplementedError()
+
+
+class Exp2l(CStdModel):
+    name = "exp2l"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double exp2l(long double x);
+        raise NotImplementedError()
+
+
+class Expm1(CStdModel):
+    name = "expm1"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double expm1(double x);
+        raise NotImplementedError()
+
+
+class Expm1f(CStdModel):
+    name = "expm1f"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float expm1f(float x);
+        raise NotImplementedError()
+
+
+class Expm1l(CStdModel):
+    name = "expm1l"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double expm1l(long double x);
+        raise NotImplementedError()
+
+
+class Erf(CStdModel):
+    name = "erf"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # double erf(double x);
+        raise NotImplementedError()
+
+
+class Erff(CStdModel):
+    name = "erff"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # float erff(float x);
+        raise NotImplementedError()
+
+
+class Erfl(CStdModel):
+    name = "erfl"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        # long double erfl(long double x);
+        raise NotImplementedError()

smallworld/state/models/c99/signal.py

@@ -0,0 +1,71 @@
+import typing
+
+from .... import emulators
+from ..cstd import ArgumentType, CStdModel
+
+# NOTE: Most of signal.h is not defined in C99
+#
+# If you're familiar with Linux,
+# the rest of the functions you're looking for
+# are part of the POSIX standard.
+#
+# Windows only implements the C99 API;
+# I suspect it keeps most process lifecycle controls
+# internal to its own application runtimes.
+
+
+class Raise(CStdModel):
+    name = "raise"
+
+    # int raise(int sig);
+    argument_types = [ArgumentType.INT]
+    return_type = ArgumentType.INT
+
+    # Most of our emulators can't model signals.
+    # I'm not sure it's possible to model raising one.
+    imprecise = True
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        super().model(emulator)
+
+        # Not really modeled; just return success
+        self.set_return_value(emulator, 0)
+
+
+class Signal(CStdModel):
+    name = "signal"
+
+    # typedef void (*sighandler_t)(int);
+    # sighandler_t signal(int sig, sighandler_t func);
+    argument_types = [ArgumentType.INT, ArgumentType.POINTER]
+    return_type = ArgumentType.POINTER
+
+    # Most of our emulators can't model signals.
+    imprecise = True
+
+    def __init__(self, address: int):
+        super().__init__(address)
+        # Track any registered handlers.
+        # Sometimes programs care about this.
+        self.handlers: typing.Dict[int, int] = dict()
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        super().model(emulator)
+
+        sig = self.get_arg1(emulator)
+        func = self.get_arg2(emulator)
+
+        assert isinstance(sig, int)
+        assert isinstance(func, int)
+
+        # Get the old handler.  Default to SIG_DFL, or NULL.
+        old_func = self.handlers.get(sig, 0)
+        self.handlers[sig] = func
+
+        self.set_return_value(emulator, old_func)
+
+
+__all__ = [
+    "Raise",
+    "Signal",
+]