1991-02-19 08:39:46 -04:00
|
|
|
/***********************************************************
|
2000-06-30 20:50:40 -03:00
|
|
|
Copyright (c) 2000, BeOpen.com.
|
|
|
|
Copyright (c) 1995-2000, Corporation for National Research Initiatives.
|
|
|
|
Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
|
|
|
|
All rights reserved.
|
1996-10-25 11:44:06 -03:00
|
|
|
|
2000-06-30 20:50:40 -03:00
|
|
|
See the file "Misc/COPYRIGHT" for information on usage and
|
|
|
|
redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
1991-02-19 08:39:46 -04:00
|
|
|
******************************************************************/
|
|
|
|
|
1990-10-14 09:07:46 -03:00
|
|
|
/* Float object implementation */
|
|
|
|
|
1990-10-21 19:15:08 -03:00
|
|
|
/* XXX There should be overflow checks here, but it's hard to check
|
|
|
|
for any kind of float exception without losing portability. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
#include "Python.h"
|
1990-10-14 09:07:46 -03:00
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
#include <ctype.h>
|
1995-02-27 06:13:37 -04:00
|
|
|
#include "mymath.h"
|
1990-10-14 09:07:46 -03:00
|
|
|
|
1993-04-07 11:06:14 -03:00
|
|
|
#ifdef i860
|
|
|
|
/* Cray APP has bogus definition of HUGE_VAL in <math.h> */
|
|
|
|
#undef HUGE_VAL
|
|
|
|
#endif
|
|
|
|
|
1996-06-26 15:27:19 -03:00
|
|
|
#if defined(HUGE_VAL) && !defined(CHECK)
|
1991-12-16 11:43:14 -04:00
|
|
|
#define CHECK(x) if (errno != 0) ; \
|
|
|
|
else if (-HUGE_VAL <= (x) && (x) <= HUGE_VAL) ; \
|
|
|
|
else errno = ERANGE
|
1996-06-26 15:27:19 -03:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef CHECK
|
1991-12-16 11:43:14 -04:00
|
|
|
#define CHECK(x) /* Don't know how to check */
|
|
|
|
#endif
|
|
|
|
|
1994-09-28 12:51:32 -03:00
|
|
|
#ifdef HAVE_LIMITS_H
|
|
|
|
#include <limits.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef LONG_MAX
|
2000-06-29 16:17:04 -03:00
|
|
|
#if SIZEOF_LONG == 4
|
1994-09-28 12:51:32 -03:00
|
|
|
#define LONG_MAX 0X7FFFFFFFL
|
2000-06-29 16:17:04 -03:00
|
|
|
#elif SIZEOF_LONG == 8
|
|
|
|
#define LONG_MAX 0X7FFFFFFFFFFFFFFFL
|
|
|
|
#else
|
|
|
|
#error "could not set LONG_MAX"
|
|
|
|
#endif
|
1994-09-28 12:51:32 -03:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef LONG_MIN
|
|
|
|
#define LONG_MIN (-LONG_MAX-1)
|
|
|
|
#endif
|
|
|
|
|
1995-02-13 12:38:41 -04:00
|
|
|
#ifdef __NeXT__
|
|
|
|
#ifdef __sparc__
|
|
|
|
/*
|
|
|
|
* This works around a bug in the NS/Sparc 3.3 pre-release
|
|
|
|
* limits.h header file.
|
|
|
|
* 10-Feb-1995 bwarsaw@cnri.reston.va.us
|
|
|
|
*/
|
|
|
|
#undef LONG_MIN
|
|
|
|
#define LONG_MIN (-LONG_MAX-1)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
1995-02-27 06:13:37 -04:00
|
|
|
#if !defined(__STDC__) && !defined(macintosh)
|
1997-05-02 00:12:38 -03:00
|
|
|
extern double fmod Py_PROTO((double, double));
|
|
|
|
extern double pow Py_PROTO((double, double));
|
1990-11-02 13:50:43 -04:00
|
|
|
#endif
|
|
|
|
|
1997-10-31 13:00:30 -04:00
|
|
|
#ifdef sun
|
|
|
|
/* On SunOS4.1 only libm.a exists. Make sure that references to all
|
|
|
|
needed math functions exist in the executable, so that dynamic
|
|
|
|
loading of mathmodule does not fail. */
|
|
|
|
double (*_Py_math_funcs_hack[])() = {
|
|
|
|
acos, asin, atan, atan2, ceil, cos, cosh, exp, fabs, floor,
|
|
|
|
fmod, log, log10, pow, sin, sinh, sqrt, tan, tanh
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
1997-05-13 18:00:42 -03:00
|
|
|
/* Special free list -- see comments for same code in intobject.c. */
|
|
|
|
#define BLOCK_SIZE 1000 /* 1K less typical malloc overhead */
|
1999-03-12 15:43:17 -04:00
|
|
|
#define BHEAD_SIZE 8 /* Enough for a 64-bit pointer */
|
1999-03-11 20:12:21 -04:00
|
|
|
#define N_FLOATOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyFloatObject))
|
1999-03-12 15:43:17 -04:00
|
|
|
|
|
|
|
struct _floatblock {
|
|
|
|
struct _floatblock *next;
|
|
|
|
PyFloatObject objects[N_FLOATOBJECTS];
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct _floatblock PyFloatBlock;
|
|
|
|
|
|
|
|
static PyFloatBlock *block_list = NULL;
|
|
|
|
static PyFloatObject *free_list = NULL;
|
|
|
|
|
1997-05-13 18:00:42 -03:00
|
|
|
static PyFloatObject *
|
|
|
|
fill_free_list()
|
|
|
|
{
|
|
|
|
PyFloatObject *p, *q;
|
2000-05-03 20:44:39 -03:00
|
|
|
/* XXX Float blocks escape the object heap. Use PyObject_MALLOC ??? */
|
|
|
|
p = (PyFloatObject *) PyMem_MALLOC(sizeof(PyFloatBlock));
|
1997-05-13 18:00:42 -03:00
|
|
|
if (p == NULL)
|
2000-05-03 20:44:39 -03:00
|
|
|
return (PyFloatObject *) PyErr_NoMemory();
|
1999-03-12 15:43:17 -04:00
|
|
|
((PyFloatBlock *)p)->next = block_list;
|
|
|
|
block_list = (PyFloatBlock *)p;
|
|
|
|
p = &((PyFloatBlock *)p)->objects[0];
|
1997-05-13 18:00:42 -03:00
|
|
|
q = p + N_FLOATOBJECTS;
|
|
|
|
while (--q > p)
|
1999-03-11 20:12:21 -04:00
|
|
|
q->ob_type = (struct _typeobject *)(q-1);
|
|
|
|
q->ob_type = NULL;
|
1997-05-13 18:00:42 -03:00
|
|
|
return p + N_FLOATOBJECTS - 1;
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
1995-02-27 06:13:37 -04:00
|
|
|
#ifdef __SC__
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloat_FromDouble(double fval)
|
1995-02-27 06:13:37 -04:00
|
|
|
#else
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloat_FromDouble(fval)
|
1990-10-14 09:07:46 -03:00
|
|
|
double fval;
|
1995-02-27 06:13:37 -04:00
|
|
|
#endif
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-05-13 18:00:42 -03:00
|
|
|
register PyFloatObject *op;
|
|
|
|
if (free_list == NULL) {
|
|
|
|
if ((free_list = fill_free_list()) == NULL)
|
|
|
|
return NULL;
|
|
|
|
}
|
2000-05-03 20:44:39 -03:00
|
|
|
/* PyObject_New is inlined */
|
1997-05-13 18:00:42 -03:00
|
|
|
op = free_list;
|
1999-03-11 20:12:21 -04:00
|
|
|
free_list = (PyFloatObject *)op->ob_type;
|
2000-05-03 20:44:39 -03:00
|
|
|
PyObject_INIT(op, &PyFloat_Type);
|
1990-10-21 19:15:08 -03:00
|
|
|
op->ob_fval = fval;
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *) op;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1999-10-12 16:54:53 -03:00
|
|
|
PyObject *
|
|
|
|
PyFloat_FromString(v, pend)
|
|
|
|
PyObject *v;
|
|
|
|
char **pend;
|
|
|
|
{
|
|
|
|
extern double strtod Py_PROTO((const char *, char **));
|
2000-03-10 18:55:18 -04:00
|
|
|
const char *s, *last, *end;
|
1999-10-12 16:54:53 -03:00
|
|
|
double x;
|
|
|
|
char buffer[256]; /* For errors */
|
2000-03-10 18:55:18 -04:00
|
|
|
int len;
|
1999-10-12 16:54:53 -03:00
|
|
|
|
2000-03-10 18:55:18 -04:00
|
|
|
if (PyString_Check(v)) {
|
|
|
|
s = PyString_AS_STRING(v);
|
|
|
|
len = PyString_GET_SIZE(v);
|
|
|
|
}
|
2000-04-05 17:11:21 -03:00
|
|
|
else if (PyUnicode_Check(v)) {
|
|
|
|
char s_buffer[256];
|
|
|
|
|
|
|
|
if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"float() literal too large to convert");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v),
|
|
|
|
PyUnicode_GET_SIZE(v),
|
|
|
|
s_buffer,
|
|
|
|
NULL))
|
|
|
|
return NULL;
|
|
|
|
s = s_buffer;
|
|
|
|
len = strlen(s);
|
|
|
|
}
|
2000-03-10 18:55:18 -04:00
|
|
|
else if (PyObject_AsCharBuffer(v, &s, &len)) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"float() needs a string argument");
|
1999-10-12 16:54:53 -03:00
|
|
|
return NULL;
|
2000-03-10 18:55:18 -04:00
|
|
|
}
|
1999-10-12 16:54:53 -03:00
|
|
|
|
2000-03-10 18:55:18 -04:00
|
|
|
last = s + len;
|
1999-10-12 16:54:53 -03:00
|
|
|
while (*s && isspace(Py_CHARMASK(*s)))
|
|
|
|
s++;
|
|
|
|
if (s[0] == '\0') {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "empty string for float()");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
errno = 0;
|
|
|
|
PyFPE_START_PROTECT("PyFloat_FromString", return 0)
|
2000-03-10 18:55:18 -04:00
|
|
|
x = strtod((char *)s, (char **)&end);
|
1999-10-12 16:54:53 -03:00
|
|
|
PyFPE_END_PROTECT(x)
|
|
|
|
/* Believe it or not, Solaris 2.6 can move end *beyond* the null
|
|
|
|
byte at the end of the string, when the input is inf(inity) */
|
|
|
|
if (end > last)
|
|
|
|
end = last;
|
|
|
|
while (*end && isspace(Py_CHARMASK(*end)))
|
|
|
|
end++;
|
|
|
|
if (*end != '\0') {
|
|
|
|
sprintf(buffer, "invalid literal for float(): %.200s", s);
|
|
|
|
PyErr_SetString(PyExc_ValueError, buffer);
|
|
|
|
return NULL;
|
|
|
|
}
|
2000-03-10 18:55:18 -04:00
|
|
|
else if (end != last) {
|
1999-10-12 16:54:53 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"null byte in argument for float()");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
else if (errno != 0) {
|
|
|
|
sprintf(buffer, "float() literal too large: %.200s", s);
|
|
|
|
PyErr_SetString(PyExc_ValueError, buffer);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (pend)
|
2000-03-10 18:55:18 -04:00
|
|
|
*pend = (char *)end;
|
1999-10-12 16:54:53 -03:00
|
|
|
return PyFloat_FromDouble(x);
|
|
|
|
}
|
|
|
|
|
1993-06-17 09:35:49 -03:00
|
|
|
static void
|
1992-03-27 13:28:44 -04:00
|
|
|
float_dealloc(op)
|
1997-05-13 18:00:42 -03:00
|
|
|
PyFloatObject *op;
|
1992-03-27 13:28:44 -04:00
|
|
|
{
|
1999-03-11 20:12:21 -04:00
|
|
|
op->ob_type = (struct _typeobject *)free_list;
|
1997-05-13 18:00:42 -03:00
|
|
|
free_list = op;
|
1992-03-27 13:28:44 -04:00
|
|
|
}
|
|
|
|
|
1990-10-14 09:07:46 -03:00
|
|
|
double
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloat_AsDouble(op)
|
|
|
|
PyObject *op;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
PyNumberMethods *nb;
|
|
|
|
PyFloatObject *fo;
|
1994-08-01 08:34:53 -03:00
|
|
|
double val;
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
if (op && PyFloat_Check(op))
|
|
|
|
return PyFloat_AS_DOUBLE((PyFloatObject*) op);
|
1994-08-01 08:34:53 -03:00
|
|
|
|
|
|
|
if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
|
|
|
|
nb->nb_float == NULL) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_BadArgument();
|
1990-10-14 09:07:46 -03:00
|
|
|
return -1;
|
|
|
|
}
|
1994-08-01 08:34:53 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
fo = (PyFloatObject*) (*nb->nb_float) (op);
|
1994-08-01 08:34:53 -03:00
|
|
|
if (fo == NULL)
|
|
|
|
return -1;
|
1997-05-02 00:12:38 -03:00
|
|
|
if (!PyFloat_Check(fo)) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"nb_float should return float object");
|
1994-08-01 08:34:53 -03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
val = PyFloat_AS_DOUBLE(fo);
|
|
|
|
Py_DECREF(fo);
|
1994-08-01 08:34:53 -03:00
|
|
|
|
|
|
|
return val;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Methods */
|
|
|
|
|
1991-06-04 16:42:53 -03:00
|
|
|
void
|
1999-12-23 15:00:28 -04:00
|
|
|
PyFloat_AsStringEx(buf, v, precision)
|
1990-10-14 09:07:46 -03:00
|
|
|
char *buf;
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1999-12-23 15:00:28 -04:00
|
|
|
int precision;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
|
|
|
register char *cp;
|
|
|
|
/* Subroutine for float_repr and float_print.
|
|
|
|
We want float numbers to be recognizable as such,
|
|
|
|
i.e., they should contain a decimal point or an exponent.
|
|
|
|
However, %g may print the number as an integer;
|
|
|
|
in such cases, we append ".0" to the string. */
|
1999-12-23 15:00:28 -04:00
|
|
|
sprintf(buf, "%.*g", precision, v->ob_fval);
|
1990-10-14 09:07:46 -03:00
|
|
|
cp = buf;
|
|
|
|
if (*cp == '-')
|
|
|
|
cp++;
|
|
|
|
for (; *cp != '\0'; cp++) {
|
|
|
|
/* Any non-digit means it's not an integer;
|
|
|
|
this takes care of NAN and INF as well. */
|
1995-02-10 13:00:37 -04:00
|
|
|
if (!isdigit(Py_CHARMASK(*cp)))
|
1990-10-14 09:07:46 -03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (*cp == '\0') {
|
|
|
|
*cp++ = '.';
|
|
|
|
*cp++ = '0';
|
|
|
|
*cp++ = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-12-23 15:00:28 -04:00
|
|
|
/* Precisions used by repr() and str(), respectively.
|
|
|
|
|
|
|
|
The repr() precision (17 significant decimal digits) is the minimal number
|
|
|
|
that is guaranteed to have enough precision so that if the number is read
|
|
|
|
back in the exact same binary value is recreated. This is true for IEEE
|
|
|
|
floating point by design, and also happens to work for all other modern
|
|
|
|
hardware.
|
|
|
|
|
|
|
|
The str() precision is chosen so that in most cases, the rounding noise
|
|
|
|
created by various operations is suppressed, while giving plenty of
|
|
|
|
precision for practical use.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define PREC_REPR 17
|
|
|
|
#define PREC_STR 12
|
|
|
|
|
|
|
|
void
|
|
|
|
PyFloat_AsString(buf, v)
|
|
|
|
char *buf;
|
|
|
|
PyFloatObject *v;
|
|
|
|
{
|
|
|
|
PyFloat_AsStringEx(buf, v, PREC_STR);
|
|
|
|
}
|
|
|
|
|
1992-03-27 13:28:44 -04:00
|
|
|
/* ARGSUSED */
|
1991-06-07 13:10:43 -03:00
|
|
|
static int
|
1990-10-14 09:07:46 -03:00
|
|
|
float_print(v, fp, flags)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1990-10-14 09:07:46 -03:00
|
|
|
FILE *fp;
|
1992-03-27 13:28:44 -04:00
|
|
|
int flags; /* Not used but required by interface */
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
|
|
|
char buf[100];
|
1999-12-23 15:00:28 -04:00
|
|
|
PyFloat_AsStringEx(buf, v, flags&Py_PRINT_RAW ? PREC_STR : PREC_REPR);
|
1990-10-14 09:07:46 -03:00
|
|
|
fputs(buf, fp);
|
1991-06-07 13:10:43 -03:00
|
|
|
return 0;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_repr(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
|
|
|
char buf[100];
|
1999-12-23 15:00:28 -04:00
|
|
|
PyFloat_AsStringEx(buf, v, PREC_REPR);
|
|
|
|
return PyString_FromString(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
float_str(v)
|
|
|
|
PyFloatObject *v;
|
|
|
|
{
|
|
|
|
char buf[100];
|
|
|
|
PyFloat_AsStringEx(buf, v, PREC_STR);
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyString_FromString(buf);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
float_compare(v, w)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v, *w;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
|
|
|
double i = v->ob_fval;
|
|
|
|
double j = w->ob_fval;
|
|
|
|
return (i < j) ? -1 : (i > j) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2000-06-29 16:17:04 -03:00
|
|
|
|
1993-03-29 06:43:31 -04:00
|
|
|
static long
|
|
|
|
float_hash(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1993-03-29 06:43:31 -04:00
|
|
|
{
|
|
|
|
double intpart, fractpart;
|
|
|
|
long x;
|
|
|
|
/* This is designed so that Python numbers with the same
|
|
|
|
value hash to the same value, otherwise comparisons
|
|
|
|
of mapping keys will turn out weird */
|
1994-08-01 08:34:53 -03:00
|
|
|
|
|
|
|
#ifdef MPW /* MPW C modf expects pointer to extended as second argument */
|
|
|
|
{
|
|
|
|
extended e;
|
|
|
|
fractpart = modf(v->ob_fval, &e);
|
|
|
|
intpart = e;
|
|
|
|
}
|
|
|
|
#else
|
1993-03-29 06:43:31 -04:00
|
|
|
fractpart = modf(v->ob_fval, &intpart);
|
1994-08-01 08:34:53 -03:00
|
|
|
#endif
|
|
|
|
|
1993-03-29 06:43:31 -04:00
|
|
|
if (fractpart == 0.0) {
|
2000-06-29 16:17:04 -03:00
|
|
|
if (intpart > LONG_MAX || -intpart > LONG_MAX) {
|
1993-03-29 06:43:31 -04:00
|
|
|
/* Convert to long int and use its hash... */
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *w = PyLong_FromDouble(v->ob_fval);
|
1993-03-29 06:43:31 -04:00
|
|
|
if (w == NULL)
|
|
|
|
return -1;
|
1997-05-02 00:12:38 -03:00
|
|
|
x = PyObject_Hash(w);
|
|
|
|
Py_DECREF(w);
|
1993-03-29 06:43:31 -04:00
|
|
|
return x;
|
|
|
|
}
|
|
|
|
x = (long)intpart;
|
|
|
|
}
|
|
|
|
else {
|
1997-01-11 15:26:21 -04:00
|
|
|
/* Note -- if you change this code, also change the copy
|
|
|
|
in complexobject.c */
|
2000-06-29 16:17:04 -03:00
|
|
|
x = _Py_HashDouble(v->ob_fval);
|
|
|
|
if (x == -1)
|
|
|
|
return -1;
|
1993-03-29 06:43:31 -04:00
|
|
|
}
|
|
|
|
if (x == -1)
|
|
|
|
x = -2;
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_add(v, w)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
|
|
|
PyFloatObject *w;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-02-14 18:54:21 -04:00
|
|
|
double result;
|
|
|
|
PyFPE_START_PROTECT("add", return 0)
|
|
|
|
result = v->ob_fval + w->ob_fval;
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(result)
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(result);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_sub(v, w)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
|
|
|
PyFloatObject *w;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-02-14 18:54:21 -04:00
|
|
|
double result;
|
|
|
|
PyFPE_START_PROTECT("subtract", return 0)
|
|
|
|
result = v->ob_fval - w->ob_fval;
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(result)
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(result);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_mul(v, w)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
|
|
|
PyFloatObject *w;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-02-14 18:54:21 -04:00
|
|
|
double result;
|
|
|
|
|
|
|
|
PyFPE_START_PROTECT("multiply", return 0)
|
|
|
|
result = v->ob_fval * w->ob_fval;
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(result)
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(result);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_div(v, w)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
|
|
|
PyFloatObject *w;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-02-14 18:54:21 -04:00
|
|
|
double result;
|
1992-01-26 14:16:35 -04:00
|
|
|
if (w->ob_fval == 0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ZeroDivisionError, "float division");
|
1990-10-14 09:07:46 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-02-14 18:54:21 -04:00
|
|
|
PyFPE_START_PROTECT("divide", return 0)
|
|
|
|
result = v->ob_fval / w->ob_fval;
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(result)
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(result);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_rem(v, w)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
|
|
|
PyFloatObject *w;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1992-01-26 14:16:35 -04:00
|
|
|
double vx, wx;
|
1999-05-06 11:26:34 -03:00
|
|
|
double mod;
|
1992-01-26 14:16:35 -04:00
|
|
|
wx = w->ob_fval;
|
1990-10-14 09:07:46 -03:00
|
|
|
if (wx == 0.0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ZeroDivisionError, "float modulo");
|
1990-10-14 09:07:46 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-02-14 18:54:21 -04:00
|
|
|
PyFPE_START_PROTECT("modulo", return 0)
|
1992-01-26 14:16:35 -04:00
|
|
|
vx = v->ob_fval;
|
|
|
|
mod = fmod(vx, wx);
|
1999-05-06 11:26:34 -03:00
|
|
|
/* note: checking mod*wx < 0 is incorrect -- underflows to
|
|
|
|
0 if wx < sqrt(smallest nonzero double) */
|
|
|
|
if (mod && ((wx < 0) != (mod < 0))) {
|
1992-01-26 14:16:35 -04:00
|
|
|
mod += wx;
|
|
|
|
}
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(mod)
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(mod);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1991-05-05 17:07:00 -03:00
|
|
|
float_divmod(v, w)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
|
|
|
PyFloatObject *w;
|
1991-05-05 17:07:00 -03:00
|
|
|
{
|
1991-10-20 17:16:45 -03:00
|
|
|
double vx, wx;
|
1999-05-06 11:26:34 -03:00
|
|
|
double div, mod, floordiv;
|
1992-01-26 14:16:35 -04:00
|
|
|
wx = w->ob_fval;
|
1991-10-20 17:16:45 -03:00
|
|
|
if (wx == 0.0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
|
1991-10-20 17:16:45 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-02-14 18:54:21 -04:00
|
|
|
PyFPE_START_PROTECT("divmod", return 0)
|
1991-10-20 17:16:45 -03:00
|
|
|
vx = v->ob_fval;
|
|
|
|
mod = fmod(vx, wx);
|
1999-05-06 11:26:34 -03:00
|
|
|
/* fmod is typically exact, so vx-mod is *mathemtically* 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.
|
|
|
|
*/
|
1991-10-20 17:16:45 -03:00
|
|
|
div = (vx - mod) / wx;
|
1999-05-06 11:26:34 -03:00
|
|
|
/* note: checking mod*wx < 0 is incorrect -- underflows to
|
|
|
|
0 if wx < sqrt(smallest nonzero double) */
|
|
|
|
if (mod && ((wx < 0) != (mod < 0))) {
|
1991-10-20 17:16:45 -03:00
|
|
|
mod += wx;
|
|
|
|
div -= 1.0;
|
|
|
|
}
|
1999-05-06 11:26:34 -03:00
|
|
|
/* snap quotient to nearest integral value */
|
|
|
|
floordiv = floor(div);
|
|
|
|
if (div - floordiv > 0.5)
|
|
|
|
floordiv += 1.0;
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(div)
|
1999-05-06 11:26:34 -03:00
|
|
|
return Py_BuildValue("(dd)", floordiv, mod);
|
1991-05-05 17:07:00 -03:00
|
|
|
}
|
|
|
|
|
1996-05-24 17:45:01 -03:00
|
|
|
static double powu(x, n)
|
1996-01-11 21:22:56 -04:00
|
|
|
double x;
|
|
|
|
long n;
|
|
|
|
{
|
|
|
|
double r = 1.;
|
|
|
|
double p = x;
|
|
|
|
long mask = 1;
|
|
|
|
while (mask > 0 && n >= mask) {
|
|
|
|
if (n & mask)
|
|
|
|
r *= p;
|
|
|
|
mask <<= 1;
|
|
|
|
p *= p;
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1994-08-12 09:52:35 -03:00
|
|
|
float_pow(v, w, z)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
|
|
|
PyObject *w;
|
|
|
|
PyFloatObject *z;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
|
|
|
double iv, iw, ix;
|
1996-01-11 21:22:56 -04:00
|
|
|
long intw;
|
1994-08-12 09:52:35 -03:00
|
|
|
/* XXX Doesn't handle overflows if z!=None yet; it may never do so :(
|
|
|
|
* The z parameter is really only going to be useful for integers and
|
|
|
|
* long integers. Maybe something clever with logarithms could be done.
|
|
|
|
* [AMK]
|
|
|
|
*/
|
1996-01-11 21:22:56 -04:00
|
|
|
iv = v->ob_fval;
|
1997-05-02 00:12:38 -03:00
|
|
|
iw = ((PyFloatObject *)w)->ob_fval;
|
1996-01-11 21:22:56 -04:00
|
|
|
intw = (long)iw;
|
1996-08-16 17:42:57 -03:00
|
|
|
if (iw == intw && -10000 < intw && intw < 10000) {
|
1996-01-11 21:22:56 -04:00
|
|
|
/* Sort out special cases here instead of relying on pow() */
|
1996-08-09 17:50:14 -03:00
|
|
|
if (intw == 0) { /* x**0 is 1, even 0**0 */
|
1997-02-14 18:54:21 -04:00
|
|
|
PyFPE_START_PROTECT("pow", return 0)
|
1997-05-02 00:12:38 -03:00
|
|
|
if ((PyObject *)z!=Py_None) {
|
1996-01-11 21:22:56 -04:00
|
|
|
ix=fmod(1.0, z->ob_fval);
|
|
|
|
if (ix!=0 && z->ob_fval<0) ix+=z->ob_fval;
|
|
|
|
}
|
|
|
|
else ix=1.0;
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(ix)
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(ix);
|
1996-01-11 21:22:56 -04:00
|
|
|
}
|
1996-08-09 17:50:14 -03:00
|
|
|
errno = 0;
|
1997-02-14 18:54:21 -04:00
|
|
|
PyFPE_START_PROTECT("pow", return 0)
|
1996-08-16 17:42:57 -03:00
|
|
|
if (intw > 0)
|
|
|
|
ix = powu(iv, intw);
|
|
|
|
else
|
|
|
|
ix = 1./powu(iv, -intw);
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(ix)
|
1996-08-09 17:50:14 -03:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Sort out special cases here instead of relying on pow() */
|
1996-01-11 21:22:56 -04:00
|
|
|
if (iv == 0.0) {
|
|
|
|
if (iw < 0.0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError,
|
1996-08-16 17:42:57 -03:00
|
|
|
"0.0 to a negative power");
|
1996-01-11 21:22:56 -04:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(0.0);
|
1991-05-28 18:57:39 -03:00
|
|
|
}
|
1996-08-16 17:42:57 -03:00
|
|
|
if (iv < 0.0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError,
|
1996-08-16 17:42:57 -03:00
|
|
|
"negative number to a float power");
|
|
|
|
return NULL;
|
|
|
|
}
|
1996-01-11 21:22:56 -04:00
|
|
|
errno = 0;
|
1997-02-14 18:54:21 -04:00
|
|
|
PyFPE_START_PROTECT("pow", return 0)
|
1996-01-11 21:22:56 -04:00
|
|
|
ix = pow(iv, iw);
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(ix)
|
1991-05-28 18:57:39 -03:00
|
|
|
}
|
1991-12-16 11:43:14 -04:00
|
|
|
CHECK(ix);
|
1990-10-21 19:15:08 -03:00
|
|
|
if (errno != 0) {
|
|
|
|
/* XXX could it be another type of error? */
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetFromErrno(PyExc_OverflowError);
|
1990-10-14 09:07:46 -03:00
|
|
|
return NULL;
|
1990-10-21 19:15:08 -03:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
if ((PyObject *)z!=Py_None) {
|
1997-02-14 18:54:21 -04:00
|
|
|
PyFPE_START_PROTECT("pow", return 0)
|
1994-08-12 09:52:35 -03:00
|
|
|
ix=fmod(ix, z->ob_fval); /* XXX To Be Rewritten */
|
|
|
|
if ( ix!=0 &&
|
|
|
|
((iv<0 && z->ob_fval>0) || (iv>0 && z->ob_fval<0) )) {
|
|
|
|
ix+=z->ob_fval;
|
|
|
|
}
|
1997-03-14 00:32:50 -04:00
|
|
|
PyFPE_END_PROTECT(ix)
|
1994-08-12 09:52:35 -03:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(ix);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_neg(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(-v->ob_fval);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1990-10-14 09:07:46 -03:00
|
|
|
float_pos(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_INCREF(v);
|
|
|
|
return (PyObject *)v;
|
1991-05-05 17:07:00 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1991-05-05 17:07:00 -03:00
|
|
|
float_abs(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1991-05-05 17:07:00 -03:00
|
|
|
{
|
|
|
|
if (v->ob_fval < 0)
|
|
|
|
return float_neg(v);
|
|
|
|
else
|
|
|
|
return float_pos(v);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
1991-05-14 08:57:01 -03:00
|
|
|
static int
|
|
|
|
float_nonzero(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyFloatObject *v;
|
1991-05-14 08:57:01 -03:00
|
|
|
{
|
|
|
|
return v->ob_fval != 0.0;
|
|
|
|
}
|
|
|
|
|
1993-06-17 09:35:49 -03:00
|
|
|
static int
|
1992-08-14 09:06:52 -03:00
|
|
|
float_coerce(pv, pw)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject **pv;
|
|
|
|
PyObject **pw;
|
1992-08-14 09:06:52 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
if (PyInt_Check(*pw)) {
|
|
|
|
long x = PyInt_AsLong(*pw);
|
|
|
|
*pw = PyFloat_FromDouble((double)x);
|
|
|
|
Py_INCREF(*pv);
|
1992-08-14 09:06:52 -03:00
|
|
|
return 0;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
else if (PyLong_Check(*pw)) {
|
|
|
|
*pw = PyFloat_FromDouble(PyLong_AsDouble(*pw));
|
|
|
|
Py_INCREF(*pv);
|
1992-08-14 09:06:52 -03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1; /* Can't do it */
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1992-09-12 08:09:23 -03:00
|
|
|
float_int(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *v;
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
double x = PyFloat_AsDouble(v);
|
1994-09-28 12:51:32 -03:00
|
|
|
if (x < 0 ? (x = ceil(x)) < (double)LONG_MIN
|
|
|
|
: (x = floor(x)) > (double)LONG_MAX) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"float too large to convert");
|
1994-09-28 12:51:32 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyInt_FromLong((long)x);
|
1992-09-12 08:09:23 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1992-09-12 08:09:23 -03:00
|
|
|
float_long(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *v;
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
double x = PyFloat_AsDouble(v);
|
|
|
|
return PyLong_FromDouble(x);
|
1992-09-12 08:09:23 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
1992-09-12 08:09:23 -03:00
|
|
|
float_float(v)
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *v;
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_INCREF(v);
|
1992-09-12 08:09:23 -03:00
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyNumberMethods float_as_number = {
|
1994-08-01 08:34:53 -03:00
|
|
|
(binaryfunc)float_add, /*nb_add*/
|
|
|
|
(binaryfunc)float_sub, /*nb_subtract*/
|
|
|
|
(binaryfunc)float_mul, /*nb_multiply*/
|
|
|
|
(binaryfunc)float_div, /*nb_divide*/
|
|
|
|
(binaryfunc)float_rem, /*nb_remainder*/
|
|
|
|
(binaryfunc)float_divmod, /*nb_divmod*/
|
1994-08-12 09:52:35 -03:00
|
|
|
(ternaryfunc)float_pow, /*nb_power*/
|
1994-08-01 08:34:53 -03:00
|
|
|
(unaryfunc)float_neg, /*nb_negative*/
|
|
|
|
(unaryfunc)float_pos, /*nb_positive*/
|
|
|
|
(unaryfunc)float_abs, /*nb_absolute*/
|
|
|
|
(inquiry)float_nonzero, /*nb_nonzero*/
|
1991-10-24 11:55:28 -03:00
|
|
|
0, /*nb_invert*/
|
|
|
|
0, /*nb_lshift*/
|
|
|
|
0, /*nb_rshift*/
|
|
|
|
0, /*nb_and*/
|
|
|
|
0, /*nb_xor*/
|
|
|
|
0, /*nb_or*/
|
1994-08-01 08:34:53 -03:00
|
|
|
(coercion)float_coerce, /*nb_coerce*/
|
|
|
|
(unaryfunc)float_int, /*nb_int*/
|
|
|
|
(unaryfunc)float_long, /*nb_long*/
|
|
|
|
(unaryfunc)float_float, /*nb_float*/
|
1992-09-12 08:09:23 -03:00
|
|
|
0, /*nb_oct*/
|
|
|
|
0, /*nb_hex*/
|
1990-10-14 09:07:46 -03:00
|
|
|
};
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyTypeObject PyFloat_Type = {
|
|
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
1990-10-14 09:07:46 -03:00
|
|
|
0,
|
|
|
|
"float",
|
1997-05-02 00:12:38 -03:00
|
|
|
sizeof(PyFloatObject),
|
1990-10-14 09:07:46 -03:00
|
|
|
0,
|
1994-08-01 08:34:53 -03:00
|
|
|
(destructor)float_dealloc, /*tp_dealloc*/
|
|
|
|
(printfunc)float_print, /*tp_print*/
|
1990-10-14 09:07:46 -03:00
|
|
|
0, /*tp_getattr*/
|
|
|
|
0, /*tp_setattr*/
|
1994-08-01 08:34:53 -03:00
|
|
|
(cmpfunc)float_compare, /*tp_compare*/
|
1999-12-23 15:00:28 -04:00
|
|
|
(reprfunc)float_repr, /*tp_repr*/
|
1990-10-14 09:07:46 -03:00
|
|
|
&float_as_number, /*tp_as_number*/
|
|
|
|
0, /*tp_as_sequence*/
|
|
|
|
0, /*tp_as_mapping*/
|
1999-12-23 15:00:28 -04:00
|
|
|
(hashfunc)float_hash, /*tp_hash*/
|
|
|
|
0, /*tp_call*/
|
|
|
|
(reprfunc)float_str, /*tp_str*/
|
1990-10-14 09:07:46 -03:00
|
|
|
};
|
1997-08-04 23:16:08 -03:00
|
|
|
|
|
|
|
void
|
|
|
|
PyFloat_Fini()
|
|
|
|
{
|
1999-03-12 15:43:17 -04:00
|
|
|
PyFloatObject *p;
|
|
|
|
PyFloatBlock *list, *next;
|
1999-03-11 20:12:21 -04:00
|
|
|
int i;
|
|
|
|
int bc, bf; /* block count, number of freed blocks */
|
|
|
|
int frem, fsum; /* remaining unfreed floats per block, total */
|
|
|
|
|
|
|
|
bc = 0;
|
|
|
|
bf = 0;
|
|
|
|
fsum = 0;
|
|
|
|
list = block_list;
|
|
|
|
block_list = NULL;
|
1999-03-19 16:59:40 -04:00
|
|
|
free_list = NULL;
|
1999-03-11 20:12:21 -04:00
|
|
|
while (list != NULL) {
|
|
|
|
bc++;
|
|
|
|
frem = 0;
|
1999-03-19 16:59:40 -04:00
|
|
|
for (i = 0, p = &list->objects[0];
|
|
|
|
i < N_FLOATOBJECTS;
|
|
|
|
i++, p++) {
|
1999-03-11 20:12:21 -04:00
|
|
|
if (PyFloat_Check(p) && p->ob_refcnt != 0)
|
|
|
|
frem++;
|
|
|
|
}
|
1999-03-12 15:43:17 -04:00
|
|
|
next = list->next;
|
1999-03-11 20:12:21 -04:00
|
|
|
if (frem) {
|
1999-03-12 15:43:17 -04:00
|
|
|
list->next = block_list;
|
|
|
|
block_list = list;
|
1999-03-19 16:59:40 -04:00
|
|
|
for (i = 0, p = &list->objects[0];
|
|
|
|
i < N_FLOATOBJECTS;
|
|
|
|
i++, p++) {
|
|
|
|
if (!PyFloat_Check(p) || p->ob_refcnt == 0) {
|
|
|
|
p->ob_type = (struct _typeobject *)
|
|
|
|
free_list;
|
|
|
|
free_list = p;
|
|
|
|
}
|
|
|
|
}
|
1999-03-11 20:12:21 -04:00
|
|
|
}
|
|
|
|
else {
|
2000-05-03 20:44:39 -03:00
|
|
|
PyMem_FREE(list); /* XXX PyObject_FREE ??? */
|
1999-03-11 20:12:21 -04:00
|
|
|
bf++;
|
|
|
|
}
|
|
|
|
fsum += frem;
|
1999-03-12 15:43:17 -04:00
|
|
|
list = next;
|
1999-03-11 20:12:21 -04:00
|
|
|
}
|
1999-03-12 15:43:17 -04:00
|
|
|
if (!Py_VerboseFlag)
|
|
|
|
return;
|
|
|
|
fprintf(stderr, "# cleanup floats");
|
|
|
|
if (!fsum) {
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fprintf(stderr,
|
|
|
|
": %d unfreed float%s in %d out of %d block%s\n",
|
|
|
|
fsum, fsum == 1 ? "" : "s",
|
|
|
|
bc - bf, bc, bc == 1 ? "" : "s");
|
|
|
|
}
|
|
|
|
if (Py_VerboseFlag > 1) {
|
|
|
|
list = block_list;
|
|
|
|
while (list != NULL) {
|
1999-03-19 16:59:40 -04:00
|
|
|
for (i = 0, p = &list->objects[0];
|
|
|
|
i < N_FLOATOBJECTS;
|
|
|
|
i++, p++) {
|
1999-03-12 15:43:17 -04:00
|
|
|
if (PyFloat_Check(p) && p->ob_refcnt != 0) {
|
|
|
|
char buf[100];
|
|
|
|
PyFloat_AsString(buf, p);
|
|
|
|
fprintf(stderr,
|
2000-06-30 12:01:00 -03:00
|
|
|
"# <float at %p, refcnt=%d, val=%s>\n",
|
|
|
|
p, p->ob_refcnt, buf);
|
1999-03-12 15:43:17 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
list = list->next;
|
1999-03-11 20:12:21 -04:00
|
|
|
}
|
|
|
|
}
|
1997-08-04 23:16:08 -03:00
|
|
|
}
|