jaclang 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypyc/lib-rt/exc_ops.c

@@ -0,0 +1,259 @@
+// Exception related primitive operations
+//
+// These are registered in mypyc.primitives.exc_ops.
+
+#include <Python.h>
+#include "CPy.h"
+
+void CPy_Raise(PyObject *exc) {
+    if (PyObject_IsInstance(exc, (PyObject *)&PyType_Type)) {
+        PyObject *obj = PyObject_CallNoArgs(exc);
+        if (!obj)
+            return;
+        PyErr_SetObject(exc, obj);
+        Py_DECREF(obj);
+    } else {
+        PyErr_SetObject((PyObject *)Py_TYPE(exc), exc);
+    }
+}
+
+void CPy_Reraise(void) {
+    PyObject *p_type, *p_value, *p_traceback;
+    PyErr_GetExcInfo(&p_type, &p_value, &p_traceback);
+    PyErr_Restore(p_type, p_value, p_traceback);
+}
+
+void CPyErr_SetObjectAndTraceback(PyObject *type, PyObject *value, PyObject *traceback) {
+    if (!PyType_Check(type) && value == Py_None) {
+        // The first argument must be an exception instance
+        value = type;
+        type = (PyObject *)Py_TYPE(value);
+    }
+
+    // Set the value and traceback of an error. Because calling
+    // PyErr_Restore takes away a reference to each object passed in
+    // as an argument, we manually increase the reference count of
+    // each argument before calling it.
+    Py_INCREF(type);
+    Py_INCREF(value);
+    Py_INCREF(traceback);
+    PyErr_Restore(type, value, traceback);
+}
+
+tuple_T3OOO CPy_CatchError(void) {
+    // We need to return the existing sys.exc_info() information, so
+    // that it can be restored when we finish handling the error we
+    // are catching now. Grab that triple and convert NULL values to
+    // the ExcDummy object in order to simplify refcount handling in
+    // generated code.
+    tuple_T3OOO ret;
+    PyErr_GetExcInfo(&ret.f0, &ret.f1, &ret.f2);
+    _CPy_ToDummy(&ret.f0);
+    _CPy_ToDummy(&ret.f1);
+    _CPy_ToDummy(&ret.f2);
+
+    if (!PyErr_Occurred()) {
+        PyErr_SetString(PyExc_RuntimeError, "CPy_CatchError called with no error!");
+    }
+
+    // Retrieve the error info and normalize it so that it looks like
+    // what python code needs it to be.
+    PyObject *type, *value, *traceback;
+    PyErr_Fetch(&type, &value, &traceback);
+    // Could we avoid always normalizing?
+    PyErr_NormalizeException(&type, &value, &traceback);
+    if (traceback != NULL) {
+        PyException_SetTraceback(value, traceback);
+    }
+    // Indicate that we are now handling this exception by stashing it
+    // in sys.exc_info().  mypyc routines that need access to the
+    // exception will read it out of there.
+    PyErr_SetExcInfo(type, value, traceback);
+    // Clear the error indicator, since the exception isn't
+    // propagating anymore.
+    PyErr_Clear();
+
+    return ret;
+}
+
+void CPy_RestoreExcInfo(tuple_T3OOO info) {
+    PyErr_SetExcInfo(_CPy_FromDummy(info.f0), _CPy_FromDummy(info.f1), _CPy_FromDummy(info.f2));
+}
+
+bool CPy_ExceptionMatches(PyObject *type) {
+    return PyErr_GivenExceptionMatches((PyObject *)Py_TYPE(CPy_ExcState()->exc_value), type);
+}
+
+PyObject *CPy_GetExcValue(void) {
+    PyObject *exc = CPy_ExcState()->exc_value;
+    Py_INCREF(exc);
+    return exc;
+}
+
+static inline void _CPy_ToNone(PyObject **p) {
+    if (*p == NULL) {
+        Py_INCREF(Py_None);
+        *p = Py_None;
+    }
+}
+
+void _CPy_GetExcInfo(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) {
+    PyErr_GetExcInfo(p_type, p_value, p_traceback);
+    _CPy_ToNone(p_type);
+    _CPy_ToNone(p_value);
+    _CPy_ToNone(p_traceback);
+}
+
+tuple_T3OOO CPy_GetExcInfo(void) {
+    tuple_T3OOO ret;
+    _CPy_GetExcInfo(&ret.f0, &ret.f1, &ret.f2);
+    return ret;
+}
+
+void CPyError_OutOfMemory(void) {
+    fprintf(stderr, "fatal: out of memory\n");
+    fflush(stderr);
+    abort();
+}
+
+// Construct a nicely formatted type name based on __module__ and __name__.
+static PyObject *CPy_GetTypeName(PyObject *type) {
+    PyObject *module = NULL, *name = NULL;
+    PyObject *full = NULL;
+
+    module = PyObject_GetAttrString(type, "__module__");
+    if (!module || !PyUnicode_Check(module)) {
+        goto out;
+    }
+    name = PyObject_GetAttrString(type, "__qualname__");
+    if (!name || !PyUnicode_Check(name)) {
+        goto out;
+    }
+
+    if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) {
+        Py_INCREF(name);
+        full = name;
+    } else {
+        full = PyUnicode_FromFormat("%U.%U", module, name);
+    }
+
+out:
+    Py_XDECREF(module);
+    Py_XDECREF(name);
+    return full;
+}
+
+// Get the type of a value as a string, expanding tuples to include
+// all the element types.
+static PyObject *CPy_FormatTypeName(PyObject *value) {
+    if (Py_IsNone(value)) {
+        return PyUnicode_FromString("None");
+    }
+
+    if (!PyTuple_CheckExact(value)) {
+        return CPy_GetTypeName((PyObject *)Py_TYPE(value));
+    }
+
+    if (PyTuple_GET_SIZE(value) > 10) {
+        return PyUnicode_FromFormat("tuple[<%d items>]", PyTuple_GET_SIZE(value));
+    }
+
+    // Most of the logic is all for tuples, which is the only interesting case
+    PyObject *output = PyUnicode_FromString("tuple[");
+    if (!output) {
+        return NULL;
+    }
+    /* This is quadratic but if that ever matters something is really weird. */
+    int i;
+    for (i = 0; i < PyTuple_GET_SIZE(value); i++) {
+        PyObject *s = CPy_FormatTypeName(PyTuple_GET_ITEM(value, i));
+        if (!s) {
+            Py_DECREF(output);
+            return NULL;
+        }
+        PyObject *next = PyUnicode_FromFormat("%U%U%s", output, s,
+                                              i + 1 == PyTuple_GET_SIZE(value) ? "]" : ", ");
+        Py_DECREF(output);
+        Py_DECREF(s);
+        if (!next) {
+            return NULL;
+        }
+        output = next;
+    }
+    return output;
+}
+
+CPy_NOINLINE
+void CPy_TypeError(const char *expected, PyObject *value) {
+    PyObject *out = CPy_FormatTypeName(value);
+    if (out) {
+        PyErr_Format(PyExc_TypeError, "%s object expected; got %U", expected, out);
+        Py_DECREF(out);
+    } else {
+        PyErr_Format(PyExc_TypeError, "%s object expected; and errored formatting real type!",
+                     expected);
+    }
+}
+
+// The PyFrameObject type definition (struct _frame) has been moved
+// to the internal C API: to the pycore_frame.h header file.
+// https://github.com/python/cpython/pull/31530
+#if PY_VERSION_HEX >= 0x030b00a6
+#include "internal/pycore_frame.h"
+#endif
+
+// This function is basically exactly the same with _PyTraceback_Add
+// which is available in all the versions we support.
+// We're continuing to use this because we'll probably optimize this later.
+void CPy_AddTraceback(const char *filename, const char *funcname, int line, PyObject *globals) {
+    PyObject *exc, *val, *tb;
+    PyThreadState *thread_state = PyThreadState_GET();
+    PyFrameObject *frame_obj;
+
+    // We need to save off the exception state because in 3.8,
+    // PyFrame_New fails if there is an error set and it fails to look
+    // up builtins in the globals. (_PyTraceback_Add documents that it
+    // needs to do it because it decodes the filename according to the
+    // FS encoding, which could have a decoder in Python. We don't do
+    // that so *that* doesn't apply to us.)
+    PyErr_Fetch(&exc, &val, &tb);
+    PyCodeObject *code_obj = PyCode_NewEmpty(filename, funcname, line);
+    if (code_obj == NULL) {
+        goto error;
+    }
+
+    frame_obj = PyFrame_New(thread_state, code_obj, globals, 0);
+    if (frame_obj == NULL) {
+        Py_DECREF(code_obj);
+        goto error;
+    }
+    frame_obj->f_lineno = line;
+    PyErr_Restore(exc, val, tb);
+    PyTraceBack_Here(frame_obj);
+    Py_DECREF(code_obj);
+    Py_DECREF(frame_obj);
+
+    return;
+
+error:
+#if CPY_3_12_FEATURES
+    _PyErr_ChainExceptions1(exc);
+#else
+    _PyErr_ChainExceptions(exc, val, tb);
+#endif
+}
+
+CPy_NOINLINE
+void CPy_TypeErrorTraceback(const char *filename, const char *funcname, int line,
+                            PyObject *globals, const char *expected, PyObject *value) {
+    CPy_TypeError(expected, value);
+    CPy_AddTraceback(filename, funcname, line, globals);
+}
+
+void CPy_AttributeError(const char *filename, const char *funcname, const char *classname,
+                        const char *attrname, int line, PyObject *globals) {
+    char buf[500];
+    snprintf(buf, sizeof(buf), "attribute '%.200s' of '%.200s' undefined", attrname, classname);
+    PyErr_SetString(PyExc_AttributeError, buf);
+    CPy_AddTraceback(filename, funcname, line, globals);
+}

jaclang/vendor/mypyc/lib-rt/float_ops.c

@@ -0,0 +1,192 @@
+// Float primitive operations
+//
+// These are registered in mypyc.primitives.float_ops.
+
+#include <Python.h>
+#include "CPy.h"
+
+
+static double CPy_DomainError(void) {
+    PyErr_SetString(PyExc_ValueError, "math domain error");
+    return CPY_FLOAT_ERROR;
+}
+
+static double CPy_MathRangeError(void) {
+    PyErr_SetString(PyExc_OverflowError, "math range error");
+    return CPY_FLOAT_ERROR;
+}
+
+double CPyFloat_FromTagged(CPyTagged x) {
+    if (CPyTagged_CheckShort(x)) {
+        return CPyTagged_ShortAsSsize_t(x);
+    }
+    double result = PyFloat_AsDouble(CPyTagged_LongAsObject(x));
+    if (unlikely(result == -1.0) && PyErr_Occurred()) {
+        return CPY_FLOAT_ERROR;
+    }
+    return result;
+}
+
+double CPyFloat_Sin(double x) {
+    double v = sin(x);
+    if (unlikely(isnan(v)) && !isnan(x)) {
+        return CPy_DomainError();
+    }
+    return v;
+}
+
+double CPyFloat_Cos(double x) {
+    double v = cos(x);
+    if (unlikely(isnan(v)) && !isnan(x)) {
+        return CPy_DomainError();
+    }
+    return v;
+}
+
+double CPyFloat_Tan(double x) {
+    if (unlikely(isinf(x))) {
+        return CPy_DomainError();
+    }
+    return tan(x);
+}
+
+double CPyFloat_Sqrt(double x) {
+    if (x < 0.0) {
+        return CPy_DomainError();
+    }
+    return sqrt(x);
+}
+
+double CPyFloat_Exp(double x) {
+    double v = exp(x);
+    if (unlikely(v == INFINITY) && x != INFINITY) {
+        return CPy_MathRangeError();
+    }
+    return v;
+}
+
+double CPyFloat_Log(double x) {
+    if (x <= 0.0) {
+        return CPy_DomainError();
+    }
+    return log(x);
+}
+
+CPyTagged CPyFloat_Floor(double x) {
+    double v = floor(x);
+    return CPyTagged_FromFloat(v);
+}
+
+CPyTagged CPyFloat_Ceil(double x) {
+    double v = ceil(x);
+    return CPyTagged_FromFloat(v);
+}
+
+bool CPyFloat_IsInf(double x) {
+    return isinf(x) != 0;
+}
+
+bool CPyFloat_IsNaN(double x) {
+    return isnan(x) != 0;
+}
+
+// From CPython 3.10.0, Objects/floatobject.c
+static void
+_float_div_mod(double vx, double wx, double *floordiv, double *mod)
+{
+    double div;
+    *mod = fmod(vx, wx);
+    /* fmod is typically exact, so vx-mod is *mathematically* an
+       exact multiple of wx.  But this is fp arithmetic, and fp
+       vx - mod is an approximation; the result is that div may
+       not be an exact integral value after the division, although
+       it will always be very close to one.
+    */
+    div = (vx - *mod) / wx;
+    if (*mod) {
+        /* ensure the remainder has the same sign as the denominator */
+        if ((wx < 0) != (*mod < 0)) {
+            *mod += wx;
+            div -= 1.0;
+        }
+    }
+    else {
+        /* the remainder is zero, and in the presence of signed zeroes
+           fmod returns different results across platforms; ensure
+           it has the same sign as the denominator. */
+        *mod = copysign(0.0, wx);
+    }
+    /* snap quotient to nearest integral value */
+    if (div) {
+        *floordiv = floor(div);
+        if (div - *floordiv > 0.5) {
+            *floordiv += 1.0;
+        }
+    }
+    else {
+        /* div is zero - get the same sign as the true quotient */
+        *floordiv = copysign(0.0, vx / wx); /* zero w/ sign of vx/wx */
+    }
+}
+
+double CPyFloat_FloorDivide(double x, double y) {
+    double mod, floordiv;
+    if (y == 0) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "float floor division by zero");
+        return CPY_FLOAT_ERROR;
+    }
+    _float_div_mod(x, y, &floordiv, &mod);
+    return floordiv;
+}
+
+// Adapted from CPython 3.10.7
+double CPyFloat_Pow(double x, double y) {
+    if (!isfinite(x) || !isfinite(y)) {
+        if (isnan(x))
+            return y == 0.0 ? 1.0 : x; /* NaN**0 = 1 */
+        else if (isnan(y))
+            return x == 1.0 ? 1.0 : y; /* 1**NaN = 1 */
+        else if (isinf(x)) {
+            int odd_y = isfinite(y) && fmod(fabs(y), 2.0) == 1.0;
+            if (y > 0.0)
+                return odd_y ? x : fabs(x);
+            else if (y == 0.0)
+                return 1.0;
+            else /* y < 0. */
+                return odd_y ? copysign(0.0, x) : 0.0;
+        }
+        else if (isinf(y)) {
+            if (fabs(x) == 1.0)
+                return 1.0;
+            else if (y > 0.0 && fabs(x) > 1.0)
+                return y;
+            else if (y < 0.0 && fabs(x) < 1.0) {
+                #if PY_VERSION_HEX < 0x030B0000
+                if (x == 0.0) { /* 0**-inf: divide-by-zero */
+                    return CPy_DomainError();
+                }
+                #endif
+                return -y; /* result is +inf */
+            } else
+                return 0.0;
+        }
+    }
+    double r = pow(x, y);
+    if (!isfinite(r)) {
+        if (isnan(r)) {
+            return CPy_DomainError();
+        }
+        /*
+           an infinite result here arises either from:
+           (A) (+/-0.)**negative (-> divide-by-zero)
+           (B) overflow of x**y with x and y finite
+        */
+        else if (isinf(r)) {
+            if (x == 0.0)
+                return CPy_DomainError();
+            else
+                return CPy_MathRangeError();
+        }
+    }
+    return r;
+}

jaclang/vendor/mypyc/lib-rt/generic_ops.c

@@ -0,0 +1,64 @@
+// Generic primitive operations
+//
+// These are registered in mypyc.primitives.generic_ops.
+
+#include <Python.h>
+#include "CPy.h"
+
+CPyTagged CPyObject_Hash(PyObject *o) {
+    Py_hash_t h = PyObject_Hash(o);
+    if (h == -1) {
+        return CPY_INT_TAG;
+    } else {
+        // This is tragically annoying. The range of hash values in
+        // 64-bit python covers 64-bits, and our short integers only
+        // cover 63. This means that half the time we are boxing the
+        // result for basically no good reason. To add insult to
+        // injury it is probably about to be immediately unboxed by a
+        // tp_hash wrapper.
+        return CPyTagged_FromSsize_t(h);
+    }
+}
+
+PyObject *CPyObject_GetAttr3(PyObject *v, PyObject *name, PyObject *defl)
+{
+    PyObject *result = PyObject_GetAttr(v, name);
+    if (!result && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        Py_INCREF(defl);
+        result = defl;
+    }
+    return result;
+}
+
+PyObject *CPyIter_Next(PyObject *iter)
+{
+    return (*Py_TYPE(iter)->tp_iternext)(iter);
+}
+
+PyObject *CPyNumber_Power(PyObject *base, PyObject *index)
+{
+    return PyNumber_Power(base, index, Py_None);
+}
+
+PyObject *CPyNumber_InPlacePower(PyObject *base, PyObject *index)
+{
+    return PyNumber_InPlacePower(base, index, Py_None);
+}
+
+PyObject *CPyObject_GetSlice(PyObject *obj, CPyTagged start, CPyTagged end) {
+    PyObject *start_obj = CPyTagged_AsObject(start);
+    PyObject *end_obj = CPyTagged_AsObject(end);
+    if (unlikely(start_obj == NULL || end_obj == NULL)) {
+        return NULL;
+    }
+    PyObject *slice = PySlice_New(start_obj, end_obj, NULL);
+    Py_DECREF(start_obj);
+    Py_DECREF(end_obj);
+    if (unlikely(slice == NULL)) {
+        return NULL;
+    }
+    PyObject *result = PyObject_GetItem(obj, slice);
+    Py_DECREF(slice);
+    return result;
+}