jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

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

@@ -1,259 +0,0 @@
-// 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

@@ -1,192 +0,0 @@
-// 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

@@ -1,64 +0,0 @@
-// 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;
-}