Function npy_longdouble_from_PyLong

numpy/core/src/common/npy_longdouble.c:123–175

* TODO: currently a hack that converts the long through a string. This is * correct, but slow. * * Another approach would be to do this numerically, in a similar way to * PyLong_AsDouble. * However, in order to respect rounding modes correctly, this needs to know * the size of the mantissa, which is platform-dependent. */

 * the size of the mantissa, which is platform-dependent.
 */
NPY_VISIBILITY_HIDDEN npy_longdouble
npy_longdouble_from_PyLong(PyObject *long_obj) {
    npy_longdouble result = 1234;
    char *end;
    char *cstr;
    PyObject *bytes;

    /* convert the long to a string */
    bytes = _PyLong_Bytes(long_obj);
    if (bytes == NULL) {
        return -1;
    }

    cstr = PyBytes_AsString(bytes);
    if (cstr == NULL) {
        goto fail;
    }
    end = NULL;

    /* convert the string to a long double and capture errors */
    errno = 0;
    result = NumPyOS_ascii_strtold(cstr, &end);
    if (errno == ERANGE) {
        /* strtold returns INFINITY of the correct sign. */
        if (PyErr_Warn(PyExc_RuntimeWarning,
                "overflow encountered in conversion from python long") < 0) {
            goto fail;
        }
    }
    else if (errno) {
        PyErr_Format(PyExc_RuntimeError,
                     "Could not parse python long as longdouble: %s (%s)",
                     cstr,
                     strerror(errno));
        goto fail;
    }

    /* Extra characters at the end of the string, or nothing parsed */
    if (end == cstr || *end != '\0') {
        PyErr_Format(PyExc_RuntimeError,
                     "Could not parse long as longdouble: %s",
                     cstr);
        goto fail;
    }

    /* finally safe to decref now that we're done with `end` */
    Py_DECREF(bytes);
    return result;

fail:
    Py_DECREF(bytes);
    return -1;
}