Quickly renamed the last directory.
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 72b68a9..d66bf85 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -34,10 +34,8 @@
/* XXX There should be overflow checks here, but it's hard to check
for any kind of float exception without losing portability. */
-#include "allobjects.h"
-#include "modsupport.h"
+#include "Python.h"
-#include <errno.h>
#include <ctype.h>
#include "mymath.h"
@@ -81,62 +79,64 @@
#endif
#if !defined(__STDC__) && !defined(macintosh)
-extern double fmod PROTO((double, double));
-extern double pow PROTO((double, double));
+extern double fmod Py_PROTO((double, double));
+extern double pow Py_PROTO((double, double));
#endif
-object *
+PyObject *
#ifdef __SC__
-newfloatobject(double fval)
+PyFloat_FromDouble(double fval)
#else
-newfloatobject(fval)
+PyFloat_FromDouble(fval)
double fval;
#endif
{
/* For efficiency, this code is copied from newobject() */
- register floatobject *op = (floatobject *) malloc(sizeof(floatobject));
+ register PyFloatObject *op =
+ (PyFloatObject *) malloc(sizeof(PyFloatObject));
if (op == NULL)
- return err_nomem();
- op->ob_type = &Floattype;
+ return PyErr_NoMemory();
+ op->ob_type = &PyFloat_Type;
op->ob_fval = fval;
- NEWREF(op);
- return (object *) op;
+ _Py_NewReference(op);
+ return (PyObject *) op;
}
static void
float_dealloc(op)
- object *op;
+ PyObject *op;
{
- DEL(op);
+ PyMem_DEL(op);
}
double
-getfloatvalue(op)
- object *op;
+PyFloat_AsDouble(op)
+ PyObject *op;
{
- number_methods *nb;
- floatobject *fo;
+ PyNumberMethods *nb;
+ PyFloatObject *fo;
double val;
- if (op && is_floatobject(op))
- return GETFLOATVALUE((floatobject*) op);
+ if (op && PyFloat_Check(op))
+ return PyFloat_AS_DOUBLE((PyFloatObject*) op);
if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
nb->nb_float == NULL) {
- err_badarg();
+ PyErr_BadArgument();
return -1;
}
- fo = (floatobject*) (*nb->nb_float) (op);
+ fo = (PyFloatObject*) (*nb->nb_float) (op);
if (fo == NULL)
return -1;
- if (!is_floatobject(fo)) {
- err_setstr(TypeError, "nb_float should return float object");
+ if (!PyFloat_Check(fo)) {
+ PyErr_SetString(PyExc_TypeError,
+ "nb_float should return float object");
return -1;
}
- val = GETFLOATVALUE(fo);
- DECREF(fo);
+ val = PyFloat_AS_DOUBLE(fo);
+ Py_DECREF(fo);
return val;
}
@@ -144,9 +144,9 @@
/* Methods */
void
-float_buf_repr(buf, v)
+PyFloat_AsString(buf, v)
char *buf;
- floatobject *v;
+ PyFloatObject *v;
{
register char *cp;
/* Subroutine for float_repr and float_print.
@@ -174,28 +174,28 @@
/* ARGSUSED */
static int
float_print(v, fp, flags)
- floatobject *v;
+ PyFloatObject *v;
FILE *fp;
int flags; /* Not used but required by interface */
{
char buf[100];
- float_buf_repr(buf, v);
+ PyFloat_AsString(buf, v);
fputs(buf, fp);
return 0;
}
-static object *
+static PyObject *
float_repr(v)
- floatobject *v;
+ PyFloatObject *v;
{
char buf[100];
- float_buf_repr(buf, v);
- return newstringobject(buf);
+ PyFloat_AsString(buf, v);
+ return PyString_FromString(buf);
}
static int
float_compare(v, w)
- floatobject *v, *w;
+ PyFloatObject *v, *w;
{
double i = v->ob_fval;
double j = w->ob_fval;
@@ -204,7 +204,7 @@
static long
float_hash(v)
- floatobject *v;
+ PyFloatObject *v;
{
double intpart, fractpart;
int expo;
@@ -226,11 +226,11 @@
if (fractpart == 0.0) {
if (intpart > 0x7fffffffL || -intpart > 0x7fffffffL) {
/* Convert to long int and use its hash... */
- object *w = dnewlongobject(v->ob_fval);
+ PyObject *w = PyLong_FromDouble(v->ob_fval);
if (w == NULL)
return -1;
- x = hashobject(w);
- DECREF(w);
+ x = PyObject_Hash(w);
+ Py_DECREF(w);
return x;
}
x = (long)intpart;
@@ -252,69 +252,69 @@
return x;
}
-static object *
+static PyObject *
float_add(v, w)
- floatobject *v;
- floatobject *w;
+ PyFloatObject *v;
+ PyFloatObject *w;
{
double result;
PyFPE_START_PROTECT("add", return 0)
result = v->ob_fval + w->ob_fval;
PyFPE_END_PROTECT(result)
- return newfloatobject(result);
+ return PyFloat_FromDouble(result);
}
-static object *
+static PyObject *
float_sub(v, w)
- floatobject *v;
- floatobject *w;
+ PyFloatObject *v;
+ PyFloatObject *w;
{
double result;
PyFPE_START_PROTECT("subtract", return 0)
result = v->ob_fval - w->ob_fval;
PyFPE_END_PROTECT(result)
- return newfloatobject(result);
+ return PyFloat_FromDouble(result);
}
-static object *
+static PyObject *
float_mul(v, w)
- floatobject *v;
- floatobject *w;
+ PyFloatObject *v;
+ PyFloatObject *w;
{
double result;
PyFPE_START_PROTECT("multiply", return 0)
result = v->ob_fval * w->ob_fval;
PyFPE_END_PROTECT(result)
- return newfloatobject(result);
+ return PyFloat_FromDouble(result);
}
-static object *
+static PyObject *
float_div(v, w)
- floatobject *v;
- floatobject *w;
+ PyFloatObject *v;
+ PyFloatObject *w;
{
double result;
if (w->ob_fval == 0) {
- err_setstr(ZeroDivisionError, "float division");
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
return NULL;
}
PyFPE_START_PROTECT("divide", return 0)
result = v->ob_fval / w->ob_fval;
PyFPE_END_PROTECT(result)
- return newfloatobject(result);
+ return PyFloat_FromDouble(result);
}
-static object *
+static PyObject *
float_rem(v, w)
- floatobject *v;
- floatobject *w;
+ PyFloatObject *v;
+ PyFloatObject *w;
{
double vx, wx;
double /* div, */ mod;
wx = w->ob_fval;
if (wx == 0.0) {
- err_setstr(ZeroDivisionError, "float modulo");
+ PyErr_SetString(PyExc_ZeroDivisionError, "float modulo");
return NULL;
}
PyFPE_START_PROTECT("modulo", return 0)
@@ -326,19 +326,19 @@
/* div -= 1.0; */
}
PyFPE_END_PROTECT(mod)
- return newfloatobject(mod);
+ return PyFloat_FromDouble(mod);
}
-static object *
+static PyObject *
float_divmod(v, w)
- floatobject *v;
- floatobject *w;
+ PyFloatObject *v;
+ PyFloatObject *w;
{
double vx, wx;
double div, mod;
wx = w->ob_fval;
if (wx == 0.0) {
- err_setstr(ZeroDivisionError, "float divmod()");
+ PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
return NULL;
}
PyFPE_START_PROTECT("divmod", return 0)
@@ -350,7 +350,7 @@
div -= 1.0;
}
PyFPE_END_PROTECT(div)
- return mkvalue("(dd)", div, mod);
+ return Py_BuildValue("(dd)", div, mod);
}
static double powu(x, n)
@@ -369,11 +369,11 @@
return r;
}
-static object *
+static PyObject *
float_pow(v, w, z)
- floatobject *v;
- object *w;
- floatobject *z;
+ PyFloatObject *v;
+ PyObject *w;
+ PyFloatObject *z;
{
double iv, iw, ix;
long intw;
@@ -383,19 +383,19 @@
* [AMK]
*/
iv = v->ob_fval;
- iw = ((floatobject *)w)->ob_fval;
+ iw = ((PyFloatObject *)w)->ob_fval;
intw = (long)iw;
if (iw == intw && -10000 < intw && intw < 10000) {
/* Sort out special cases here instead of relying on pow() */
if (intw == 0) { /* x**0 is 1, even 0**0 */
PyFPE_START_PROTECT("pow", return 0)
- if ((object *)z!=None) {
+ if ((PyObject *)z!=Py_None) {
ix=fmod(1.0, z->ob_fval);
if (ix!=0 && z->ob_fval<0) ix+=z->ob_fval;
}
else ix=1.0;
PyFPE_END_PROTECT(ix)
- return newfloatobject(ix);
+ return PyFloat_FromDouble(ix);
}
errno = 0;
PyFPE_START_PROTECT("pow", return 0)
@@ -409,14 +409,14 @@
/* Sort out special cases here instead of relying on pow() */
if (iv == 0.0) {
if (iw < 0.0) {
- err_setstr(ValueError,
+ PyErr_SetString(PyExc_ValueError,
"0.0 to a negative power");
return NULL;
}
- return newfloatobject(0.0);
+ return PyFloat_FromDouble(0.0);
}
if (iv < 0.0) {
- err_setstr(ValueError,
+ PyErr_SetString(PyExc_ValueError,
"negative number to a float power");
return NULL;
}
@@ -428,10 +428,10 @@
CHECK(ix);
if (errno != 0) {
/* XXX could it be another type of error? */
- err_errno(OverflowError);
+ PyErr_SetFromErrno(PyExc_OverflowError);
return NULL;
}
- if ((object *)z!=None) {
+ if ((PyObject *)z!=Py_None) {
PyFPE_START_PROTECT("pow", return 0)
ix=fmod(ix, z->ob_fval); /* XXX To Be Rewritten */
if ( ix!=0 &&
@@ -440,27 +440,27 @@
}
PyFPE_END_PROTECT(ix)
}
- return newfloatobject(ix);
+ return PyFloat_FromDouble(ix);
}
-static object *
+static PyObject *
float_neg(v)
- floatobject *v;
+ PyFloatObject *v;
{
- return newfloatobject(-v->ob_fval);
+ return PyFloat_FromDouble(-v->ob_fval);
}
-static object *
+static PyObject *
float_pos(v)
- floatobject *v;
+ PyFloatObject *v;
{
- INCREF(v);
- return (object *)v;
+ Py_INCREF(v);
+ return (PyObject *)v;
}
-static object *
+static PyObject *
float_abs(v)
- floatobject *v;
+ PyFloatObject *v;
{
if (v->ob_fval < 0)
return float_neg(v);
@@ -470,61 +470,62 @@
static int
float_nonzero(v)
- floatobject *v;
+ PyFloatObject *v;
{
return v->ob_fval != 0.0;
}
static int
float_coerce(pv, pw)
- object **pv;
- object **pw;
+ PyObject **pv;
+ PyObject **pw;
{
- if (is_intobject(*pw)) {
- long x = getintvalue(*pw);
- *pw = newfloatobject((double)x);
- INCREF(*pv);
+ if (PyInt_Check(*pw)) {
+ long x = PyInt_AsLong(*pw);
+ *pw = PyFloat_FromDouble((double)x);
+ Py_INCREF(*pv);
return 0;
}
- else if (is_longobject(*pw)) {
- *pw = newfloatobject(dgetlongvalue(*pw));
- INCREF(*pv);
+ else if (PyLong_Check(*pw)) {
+ *pw = PyFloat_FromDouble(PyLong_AsDouble(*pw));
+ Py_INCREF(*pv);
return 0;
}
return 1; /* Can't do it */
}
-static object *
+static PyObject *
float_int(v)
- object *v;
+ PyObject *v;
{
- double x = getfloatvalue(v);
+ double x = PyFloat_AsDouble(v);
if (x < 0 ? (x = ceil(x)) < (double)LONG_MIN
: (x = floor(x)) > (double)LONG_MAX) {
- err_setstr(OverflowError, "float too large to convert");
+ PyErr_SetString(PyExc_OverflowError,
+ "float too large to convert");
return NULL;
}
- return newintobject((long)x);
+ return PyInt_FromLong((long)x);
}
-static object *
+static PyObject *
float_long(v)
- object *v;
+ PyObject *v;
{
- double x = getfloatvalue(v);
- return dnewlongobject(x);
+ double x = PyFloat_AsDouble(v);
+ return PyLong_FromDouble(x);
}
-static object *
+static PyObject *
float_float(v)
- object *v;
+ PyObject *v;
{
- INCREF(v);
+ Py_INCREF(v);
return v;
}
-static number_methods float_as_number = {
+static PyNumberMethods float_as_number = {
(binaryfunc)float_add, /*nb_add*/
(binaryfunc)float_sub, /*nb_subtract*/
(binaryfunc)float_mul, /*nb_multiply*/
@@ -550,11 +551,11 @@
0, /*nb_hex*/
};
-typeobject Floattype = {
- OB_HEAD_INIT(&Typetype)
+PyTypeObject PyFloat_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
0,
"float",
- sizeof(floatobject),
+ sizeof(PyFloatObject),
0,
(destructor)float_dealloc, /*tp_dealloc*/
(printfunc)float_print, /*tp_print*/