Objects/floatobject.c

   1
   2 /* Float object implementation */
   3
   4 /* XXX There should be overflow checks here, but it's hard to check
   5    for any kind of float exception without losing portability. */
   6
   7 #include "Python.h"
   8
   9 #include <ctype.h>
  10
  11 #if !defined(__STDC__) && !defined(macintosh)
  12 extern double fmod(double, double);
  13 extern double pow(double, double);
  14 #endif
  15
  16 #if defined(sun) && !defined(__SVR4)
  17 /* On SunOS4.1 only libm.a exists. Make sure that references to all
  18    needed math functions exist in the executable, so that dynamic
  19    loading of mathmodule does not fail. */
  20 double (*_Py_math_funcs_hack[])() = {
  21         acos, asin, atan, atan2, ceil, cos, cosh, exp, fabs, floor,
  22         fmod, log, log10, pow, sin, sinh, sqrt, tan, tanh
  23 };
  24 #endif
  25
  26 /* Special free list -- see comments for same code in intobject.c. */
  27 #define BLOCK_SIZE      1000    /* 1K less typical malloc overhead */
  28 #define BHEAD_SIZE      8       /* Enough for a 64-bit pointer */
  29 #define N_FLOATOBJECTS  ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyFloatObject))
  30
  31 struct _floatblock {
  32         struct _floatblock *next;
  33         PyFloatObject objects[N_FLOATOBJECTS];
  34 };
  35
  36 typedef struct _floatblock PyFloatBlock;
  37
  38 static PyFloatBlock *block_list = NULL;
  39 static PyFloatObject *free_list = NULL;
  40
  41 static PyFloatObject *
  42 fill_free_list(void)
  43 {
  44         PyFloatObject *p, *q;
  45         /* XXX Float blocks escape the object heap. Use PyObject_MALLOC ??? */
  46         p = (PyFloatObject *) PyMem_MALLOC(sizeof(PyFloatBlock));
  47         if (p == NULL)
  48                 return (PyFloatObject *) PyErr_NoMemory();
  49         ((PyFloatBlock *)p)->next = block_list;
  50         block_list = (PyFloatBlock *)p;
  51         p = &((PyFloatBlock *)p)->objects[0];
  52         q = p + N_FLOATOBJECTS;
  53         while (--q > p)
  54                 q->ob_type = (struct _typeobject *)(q-1);
  55         q->ob_type = NULL;
  56         return p + N_FLOATOBJECTS - 1;
  57 }
  58
  59 PyObject *
  60 PyFloat_FromDouble(double fval)
  61 {
  62         register PyFloatObject *op;
  63         if (free_list == NULL) {
  64                 if ((free_list = fill_free_list()) == NULL)
  65                         return NULL;
  66         }
  67         /* PyObject_New is inlined */
  68         op = free_list;
  69         free_list = (PyFloatObject *)op->ob_type;
  70         PyObject_INIT(op, &PyFloat_Type);
  71         op->ob_fval = fval;
  72         return (PyObject *) op;
  73 }
  74
  75 /**************************************************************************
  76 RED_FLAG 22-Sep-2000 tim
  77 PyFloat_FromString's pend argument is braindead.  Prior to this RED_FLAG,
  78
  79 1.  If v was a regular string, *pend was set to point to its terminating
  80     null byte.  That's useless (the caller can find that without any
  81     help from this function!).
  82
  83 2.  If v was a Unicode string, or an object convertible to a character
  84     buffer, *pend was set to point into stack trash (the auto temp
  85     vector holding the character buffer).  That was downright dangerous.
  86
  87 Since we can't change the interface of a public API function, pend is
  88 still supported but now *officially* useless:  if pend is not NULL,
  89 *pend is set to NULL.
  90 **************************************************************************/
  91 PyObject *
  92 PyFloat_FromString(PyObject *v, char **pend)
  93 {
  94         const char *s, *last, *end;
  95         double x;
  96         char buffer[256]; /* for errors */
  97 #ifdef Py_USING_UNICODE
  98         char s_buffer[256]; /* for objects convertible to a char buffer */
  99 #endif
 100         int len;
 101
 102         if (pend)
 103                 *pend = NULL;
 104         if (PyString_Check(v)) {
 105                 s = PyString_AS_STRING(v);
 106                 len = PyString_GET_SIZE(v);
 107         }
 108 #ifdef Py_USING_UNICODE
 109         else if (PyUnicode_Check(v)) {
 110                 if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) {
 111                         PyErr_SetString(PyExc_ValueError,
 112                                 "Unicode float() literal too long to convert");
 113                         return NULL;
 114                 }
 115                 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v),
 116                                             PyUnicode_GET_SIZE(v),
 117                                             s_buffer,
 118                                             NULL))
 119                         return NULL;
 120                 s = s_buffer;
 121                 len = (int)strlen(s);
 122         }
 123 #endif
 124         else if (PyObject_AsCharBuffer(v, &s, &len)) {
 125                 PyErr_SetString(PyExc_TypeError,
 126                                 "float() needs a string argument");
 127                 return NULL;
 128         }
 129
 130         last = s + len;
 131         while (*s && isspace(Py_CHARMASK(*s)))
 132                 s++;
 133         if (*s == '\0') {
 134                 PyErr_SetString(PyExc_ValueError, "empty string for float()");
 135                 return NULL;
 136         }
 137         /* We don't care about overflow or underflow.  If the platform supports
 138          * them, infinities and signed zeroes (on underflow) are fine.
 139          * However, strtod can return 0 for denormalized numbers, where atof
 140          * does not.  So (alas!) we special-case a zero result.  Note that
 141          * whether strtod sets errno on underflow is not defined, so we can't
 142          * key off errno.
 143          */
 144         PyFPE_START_PROTECT("strtod", return NULL)
 145         x = strtod(s, (char **)&end);
 146         PyFPE_END_PROTECT(x)
 147         errno = 0;
 148         /* Believe it or not, Solaris 2.6 can move end *beyond* the null
 149            byte at the end of the string, when the input is inf(inity). */
 150         if (end > last)
 151                 end = last;
 152         if (end == s) {
 153                 PyOS_snprintf(buffer, sizeof(buffer),
 154                               "invalid literal for float(): %.200s", s);
 155                 PyErr_SetString(PyExc_ValueError, buffer);
 156                 return NULL;
 157         }
 158         /* Since end != s, the platform made *some* kind of sense out
 159            of the input.  Trust it. */
 160         while (*end && isspace(Py_CHARMASK(*end)))
 161                 end++;
 162         if (*end != '\0') {
 163                 PyOS_snprintf(buffer, sizeof(buffer),
 164                               "invalid literal for float(): %.200s", s);
 165                 PyErr_SetString(PyExc_ValueError, buffer);
 166                 return NULL;
 167         }
 168         else if (end != last) {
 169                 PyErr_SetString(PyExc_ValueError,
 170                                 "null byte in argument for float()");
 171                 return NULL;
 172         }
 173         if (x == 0.0) {
 174                 /* See above -- may have been strtod being anal
 175                    about denorms. */
 176                 PyFPE_START_PROTECT("atof", return NULL)
 177                 x = atof(s);
 178                 PyFPE_END_PROTECT(x)
 179                 errno = 0;    /* whether atof ever set errno is undefined */
 180         }
 181         return PyFloat_FromDouble(x);
 182 }
 183
 184 static void
 185 float_dealloc(PyFloatObject *op)
 186 {
 187         if (PyFloat_CheckExact(op)) {
 188                 op->ob_type = (struct _typeobject *)free_list;
 189                 free_list = op;
 190         }
 191         else
 192                 op->ob_type->tp_free((PyObject *)op);
 193 }
 194
 195 double
 196 PyFloat_AsDouble(PyObject *op)
 197 {
 198         PyNumberMethods *nb;
 199         PyFloatObject *fo;
 200         double val;
 201
 202         if (op && PyFloat_Check(op))
 203                 return PyFloat_AS_DOUBLE((PyFloatObject*) op);
 204
 205         if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
 206             nb->nb_float == NULL) {
 207                 PyErr_BadArgument();
 208                 return -1;
 209         }
 210
 211         fo = (PyFloatObject*) (*nb->nb_float) (op);
 212         if (fo == NULL)
 213                 return -1;
 214         if (!PyFloat_Check(fo)) {
 215                 PyErr_SetString(PyExc_TypeError,
 216                                 "nb_float should return float object");
 217                 return -1;
 218         }
 219
 220         val = PyFloat_AS_DOUBLE(fo);
 221         Py_DECREF(fo);
 222
 223         return val;
 224 }
 225
 226 /* Methods */
 227
 228 static void
 229 format_float(char *buf, size_t buflen, PyFloatObject *v, int precision)
 230 {
 231         register char *cp;
 232         /* Subroutine for float_repr and float_print.
 233            We want float numbers to be recognizable as such,
 234            i.e., they should contain a decimal point or an exponent.
 235            However, %g may print the number as an integer;
 236            in such cases, we append ".0" to the string. */
 237
 238         assert(PyFloat_Check(v));
 239         PyOS_snprintf(buf, buflen, "%.*g", precision, v->ob_fval);
 240         cp = buf;
 241         if (*cp == '-')
 242                 cp++;
 243         for (; *cp != '\0'; cp++) {
 244                 /* Any non-digit means it's not an integer;
 245                    this takes care of NAN and INF as well. */
 246                 if (!isdigit(Py_CHARMASK(*cp)))
 247                         break;
 248         }
 249         if (*cp == '\0') {
 250                 *cp++ = '.';
 251                 *cp++ = '0';
 252                 *cp++ = '\0';
 253         }
 254 }
 255
 256 /* XXX PyFloat_AsStringEx should not be a public API function (for one
 257    XXX thing, its signature passes a buffer without a length; for another,
 258    XXX it isn't useful outside this file).
 259 */
 260 void
 261 PyFloat_AsStringEx(char *buf, PyFloatObject *v, int precision)
 262 {
 263         format_float(buf, 100, v, precision);
 264 }
 265
 266 /* Macro and helper that convert PyObject obj to a C double and store
 267    the value in dbl; this replaces the functionality of the coercion
 268    slot function.  If conversion to double raises an exception, obj is
 269    set to NULL, and the function invoking this macro returns NULL.  If
 270    obj is not of float, int or long type, Py_NotImplemented is incref'ed,
 271    stored in obj, and returned from the function invoking this macro.
 272 */
 273 #define CONVERT_TO_DOUBLE(obj, dbl)                     \
 274         if (PyFloat_Check(obj))                         \
 275                 dbl = PyFloat_AS_DOUBLE(obj);           \
 276         else if (convert_to_double(&(obj), &(dbl)) < 0) \
 277                 return obj;
 278
 279 static int
 280 convert_to_double(PyObject **v, double *dbl)
 281 {
 282         register PyObject *obj = *v;
 283
 284         if (PyInt_Check(obj)) {
 285                 *dbl = (double)PyInt_AS_LONG(obj);
 286         }
 287         else if (PyLong_Check(obj)) {
 288                 *dbl = PyLong_AsDouble(obj);
 289                 if (*dbl == -1.0 && PyErr_Occurred()) {
 290                         *v = NULL;
 291                         return -1;
 292                 }
 293         }
 294         else {
 295                 Py_INCREF(Py_NotImplemented);
 296                 *v = Py_NotImplemented;
 297                 return -1;
 298         }
 299         return 0;
 300 }
 301
 302 /* Precisions used by repr() and str(), respectively.
 303
 304    The repr() precision (17 significant decimal digits) is the minimal number
 305    that is guaranteed to have enough precision so that if the number is read
 306    back in the exact same binary value is recreated.  This is true for IEEE
 307    floating point by design, and also happens to work for all other modern
 308    hardware.
 309
 310    The str() precision is chosen so that in most cases, the rounding noise
 311    created by various operations is suppressed, while giving plenty of
 312    precision for practical use.
 313
 314 */
 315
 316 #define PREC_REPR       17
 317 #define PREC_STR        12
 318
 319 /* XXX PyFloat_AsString and PyFloat_AsReprString should be deprecated:
 320    XXX they pass a char buffer without passing a length.
 321 */
 322 void
 323 PyFloat_AsString(char *buf, PyFloatObject *v)
 324 {
 325         format_float(buf, 100, v, PREC_STR);
 326 }
 327
 328 void
 329 PyFloat_AsReprString(char *buf, PyFloatObject *v)
 330 {
 331         format_float(buf, 100, v, PREC_REPR);
 332 }
 333
 334 /* ARGSUSED */
 335 static int
 336 float_print(PyFloatObject *v, FILE *fp, int flags)
 337 {
 338         char buf[100];
 339         format_float(buf, sizeof(buf), v,
 340                      (flags & Py_PRINT_RAW) ? PREC_STR : PREC_REPR);
 341         fputs(buf, fp);
 342         return 0;
 343 }
 344
 345 static PyObject *
 346 float_repr(PyFloatObject *v)
 347 {
 348         char buf[100];
 349         format_float(buf, sizeof(buf), v, PREC_REPR);
 350         return PyString_FromString(buf);
 351 }
 352
 353 static PyObject *
 354 float_str(PyFloatObject *v)
 355 {
 356         char buf[100];
 357         format_float(buf, sizeof(buf), v, PREC_STR);
 358         return PyString_FromString(buf);
 359 }
 360
 361 static int
 362 float_compare(PyFloatObject *v, PyFloatObject *w)
 363 {
 364         double i = v->ob_fval;
 365         double j = w->ob_fval;
 366         return (i < j) ? -1 : (i > j) ? 1 : 0;
 367 }
 368
 369 static long
 370 float_hash(PyFloatObject *v)
 371 {
 372         return _Py_HashDouble(v->ob_fval);
 373 }
 374
 375 static PyObject *
 376 float_add(PyObject *v, PyObject *w)
 377 {
 378         double a,b;
 379         CONVERT_TO_DOUBLE(v, a);
 380         CONVERT_TO_DOUBLE(w, b);
 381         PyFPE_START_PROTECT("add", return 0)
 382         a = a + b;
 383         PyFPE_END_PROTECT(a)
 384         return PyFloat_FromDouble(a);
 385 }
 386
 387 static PyObject *
 388 float_sub(PyObject *v, PyObject *w)
 389 {
 390         double a,b;
 391         CONVERT_TO_DOUBLE(v, a);
 392         CONVERT_TO_DOUBLE(w, b);
 393         PyFPE_START_PROTECT("subtract", return 0)
 394         a = a - b;
 395         PyFPE_END_PROTECT(a)
 396         return PyFloat_FromDouble(a);
 397 }
 398
 399 static PyObject *
 400 float_mul(PyObject *v, PyObject *w)
 401 {
 402         double a,b;
 403         CONVERT_TO_DOUBLE(v, a);
 404         CONVERT_TO_DOUBLE(w, b);
 405         PyFPE_START_PROTECT("multiply", return 0)
 406         a = a * b;
 407         PyFPE_END_PROTECT(a)
 408         return PyFloat_FromDouble(a);
 409 }
 410
 411 static PyObject *
 412 float_div(PyObject *v, PyObject *w)
 413 {
 414         double a,b;
 415         CONVERT_TO_DOUBLE(v, a);
 416         CONVERT_TO_DOUBLE(w, b);
 417         if (b == 0.0) {
 418                 PyErr_SetString(PyExc_ZeroDivisionError, "float division");
 419                 return NULL;
 420         }
 421         PyFPE_START_PROTECT("divide", return 0)
 422         a = a / b;
 423         PyFPE_END_PROTECT(a)
 424         return PyFloat_FromDouble(a);
 425 }
 426
 427 static PyObject *
 428 float_classic_div(PyObject *v, PyObject *w)
 429 {
 430         double a,b;
 431         CONVERT_TO_DOUBLE(v, a);
 432         CONVERT_TO_DOUBLE(w, b);
 433         if (Py_DivisionWarningFlag >= 2 &&
 434             PyErr_Warn(PyExc_DeprecationWarning, "classic float division") < 0)
 435                 return NULL;
 436         if (b == 0.0) {
 437                 PyErr_SetString(PyExc_ZeroDivisionError, "float division");
 438                 return NULL;
 439         }
 440         PyFPE_START_PROTECT("divide", return 0)
 441         a = a / b;
 442         PyFPE_END_PROTECT(a)
 443         return PyFloat_FromDouble(a);
 444 }
 445
 446 static PyObject *
 447 float_rem(PyObject *v, PyObject *w)
 448 {
 449         double vx, wx;
 450         double mod;
 451         CONVERT_TO_DOUBLE(v, vx);
 452         CONVERT_TO_DOUBLE(w, wx);
 453         if (wx == 0.0) {
 454                 PyErr_SetString(PyExc_ZeroDivisionError, "float modulo");
 455                 return NULL;
 456         }
 457         PyFPE_START_PROTECT("modulo", return 0)
 458         mod = fmod(vx, wx);
 459         /* note: checking mod*wx < 0 is incorrect -- underflows to
 460            0 if wx < sqrt(smallest nonzero double) */
 461         if (mod && ((wx < 0) != (mod < 0))) {
 462                 mod += wx;
 463         }
 464         PyFPE_END_PROTECT(mod)
 465         return PyFloat_FromDouble(mod);
 466 }
 467
 468 static PyObject *
 469 float_divmod(PyObject *v, PyObject *w)
 470 {
 471         double vx, wx;
 472         double div, mod, floordiv;
 473         CONVERT_TO_DOUBLE(v, vx);
 474         CONVERT_TO_DOUBLE(w, wx);
 475         if (wx == 0.0) {
 476                 PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
 477                 return NULL;
 478         }
 479         PyFPE_START_PROTECT("divmod", return 0)
 480         mod = fmod(vx, wx);
 481         /* fmod is typically exact, so vx-mod is *mathematically* an
 482            exact multiple of wx.  But this is fp arithmetic, and fp
 483            vx - mod is an approximation; the result is that div may
 484            not be an exact integral value after the division, although
 485            it will always be very close to one.
 486         */
 487         div = (vx - mod) / wx;
 488         if (mod) {
 489                 /* ensure the remainder has the same sign as the denominator */
 490                 if ((wx < 0) != (mod < 0)) {
 491                         mod += wx;
 492                         div -= 1.0;
 493                 }
 494         }
 495         else {
 496                 /* the remainder is zero, and in the presence of signed zeroes
 497                    fmod returns different results across platforms; ensure
 498                    it has the same sign as the denominator; we'd like to do
 499                    "mod = wx * 0.0", but that may get optimized away */
 500                 mod *= mod;  /* hide "mod = +0" from optimizer */
 501                 if (wx < 0.0)
 502                         mod = -mod;
 503         }
 504         /* snap quotient to nearest integral value */
 505         if (div) {
 506                 floordiv = floor(div);
 507                 if (div - floordiv > 0.5)
 508                         floordiv += 1.0;
 509         }
 510         else {
 511                 /* div is zero - get the same sign as the true quotient */
 512                 div *= div;     /* hide "div = +0" from optimizers */
 513                 floordiv = div * vx / wx; /* zero w/ sign of vx/wx */
 514         }
 515         PyFPE_END_PROTECT(floordiv)
 516         return Py_BuildValue("(dd)", floordiv, mod);
 517 }
 518
 519 static PyObject *
 520 float_floor_div(PyObject *v, PyObject *w)
 521 {
 522         PyObject *t, *r;
 523
 524         t = float_divmod(v, w);
 525         if (t == NULL || t == Py_NotImplemented)
 526                 return t;
 527         assert(PyTuple_CheckExact(t));
 528         r = PyTuple_GET_ITEM(t, 0);
 529         Py_INCREF(r);
 530         Py_DECREF(t);
 531         return r;
 532 }
 533
 534 static PyObject *
 535 float_pow(PyObject *v, PyObject *w, PyObject *z)
 536 {
 537         double iv, iw, ix;
 538
 539         if ((PyObject *)z != Py_None) {
 540                 PyErr_SetString(PyExc_TypeError, "pow() 3rd argument not "
 541                         "allowed unless all arguments are integers");
 542                 return NULL;
 543         }
 544
 545         CONVERT_TO_DOUBLE(v, iv);
 546         CONVERT_TO_DOUBLE(w, iw);
 547
 548         /* Sort out special cases here instead of relying on pow() */
 549         if (iw == 0) {          /* v**0 is 1, even 0**0 */
 550                 PyFPE_START_PROTECT("pow", return NULL)
 551                 if ((PyObject *)z != Py_None) {
 552                         double iz;
 553                         CONVERT_TO_DOUBLE(z, iz);
 554                         ix = fmod(1.0, iz);
 555                         if (ix != 0 && iz < 0)
 556                                 ix += iz;
 557                 }
 558                 else
 559                         ix = 1.0;
 560                 PyFPE_END_PROTECT(ix)
 561                 return PyFloat_FromDouble(ix);
 562         }
 563         if (iv == 0.0) {  /* 0**w is error if w<0, else 1 */
 564                 if (iw < 0.0) {
 565                         PyErr_SetString(PyExc_ZeroDivisionError,
 566                                         "0.0 cannot be raised to a negative power");
 567                         return NULL;
 568                 }
 569                 return PyFloat_FromDouble(0.0);
 570         }
 571         if (iv < 0.0 && iw != floor(iw)) {
 572                 PyErr_SetString(PyExc_ValueError,
 573                                 "negative number cannot be raised to a fractional power");
 574                 return NULL;
 575         }
 576         errno = 0;
 577         PyFPE_START_PROTECT("pow", return NULL)
 578         ix = pow(iv, iw);
 579         PyFPE_END_PROTECT(ix)
 580         Py_SET_ERANGE_IF_OVERFLOW(ix);
 581         if (errno != 0) {
 582                 /* XXX could it be another type of error? */
 583                 PyErr_SetFromErrno(PyExc_OverflowError);
 584                 return NULL;
 585         }
 586         return PyFloat_FromDouble(ix);
 587 }
 588
 589 static PyObject *
 590 float_neg(PyFloatObject *v)
 591 {
 592         return PyFloat_FromDouble(-v->ob_fval);
 593 }
 594
 595 static PyObject *
 596 float_pos(PyFloatObject *v)
 597 {
 598         if (PyFloat_CheckExact(v)) {
 599                 Py_INCREF(v);
 600                 return (PyObject *)v;
 601         }
 602         else
 603                 return PyFloat_FromDouble(v->ob_fval);
 604 }
 605
 606 static PyObject *
 607 float_abs(PyFloatObject *v)
 608 {
 609         return PyFloat_FromDouble(fabs(v->ob_fval));
 610 }
 611
 612 static int
 613 float_nonzero(PyFloatObject *v)
 614 {
 615         return v->ob_fval != 0.0;
 616 }
 617
 618 static int
 619 float_coerce(PyObject **pv, PyObject **pw)
 620 {
 621         if (PyInt_Check(*pw)) {
 622                 long x = PyInt_AsLong(*pw);
 623                 *pw = PyFloat_FromDouble((double)x);
 624                 Py_INCREF(*pv);
 625                 return 0;
 626         }
 627         else if (PyLong_Check(*pw)) {
 628                 *pw = PyFloat_FromDouble(PyLong_AsDouble(*pw));
 629                 Py_INCREF(*pv);
 630                 return 0;
 631         }
 632         else if (PyFloat_Check(*pw)) {
 633                 Py_INCREF(*pv);
 634                 Py_INCREF(*pw);
 635                 return 0;
 636         }
 637         return 1; /* Can't do it */
 638 }
 639
 640 static PyObject *
 641 float_int(PyObject *v)
 642 {
 643         double x = PyFloat_AsDouble(v);
 644         double wholepart;       /* integral portion of x, rounded toward 0 */
 645         long aslong;            /* (long)wholepart */
 646
 647         (void)modf(x, &wholepart);
 648 #ifdef RISCOS
 649         /* conversion from floating to integral type would raise exception */
 650         if (wholepart>LONG_MAX || wholepart<LONG_MIN) {
 651                 PyErr_SetString(PyExc_OverflowError, "float too large to convert");
 652                 return NULL;
 653         }
 654 #endif
 655         /* doubles may have more bits than longs, or vice versa; and casting
 656            to long may yield gibberish in either case.  What really matters
 657            is whether converting back to double again reproduces what we
 658            started with. */
 659         aslong = (long)wholepart;
 660         if ((double)aslong == wholepart)
 661                 return PyInt_FromLong(aslong);
 662         PyErr_SetString(PyExc_OverflowError, "float too large to convert");
 663         return NULL;
 664 }
 665
 666 static PyObject *
 667 float_long(PyObject *v)
 668 {
 669         double x = PyFloat_AsDouble(v);
 670         return PyLong_FromDouble(x);
 671 }
 672
 673 static PyObject *
 674 float_float(PyObject *v)
 675 {
 676         Py_INCREF(v);
 677         return v;
 678 }
 679
 680
 681 staticforward PyObject *
 682 float_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
 683
 684 static PyObject *
 685 float_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 686 {
 687         PyObject *x = Py_False; /* Integer zero */
 688         static char *kwlist[] = {"x", 0};
 689
 690         if (type != &PyFloat_Type)
 691                 return float_subtype_new(type, args, kwds); /* Wimp out */
 692         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:float", kwlist, &x))
 693                 return NULL;
 694         if (PyString_Check(x))
 695                 return PyFloat_FromString(x, NULL);
 696         return PyNumber_Float(x);
 697 }
 698
 699 /* Wimpy, slow approach to tp_new calls for subtypes of float:
 700    first create a regular float from whatever arguments we got,
 701    then allocate a subtype instance and initialize its ob_fval
 702    from the regular float.  The regular float is then thrown away.
 703 */
 704 static PyObject *
 705 float_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 706 {
 707         PyObject *tmp, *new;
 708
 709         assert(PyType_IsSubtype(type, &PyFloat_Type));
 710         tmp = float_new(&PyFloat_Type, args, kwds);
 711         if (tmp == NULL)
 712                 return NULL;
 713         assert(PyFloat_CheckExact(tmp));
 714         new = type->tp_alloc(type, 0);
 715         if (new == NULL)
 716                 return NULL;
 717         ((PyFloatObject *)new)->ob_fval = ((PyFloatObject *)tmp)->ob_fval;
 718         Py_DECREF(tmp);
 719         return new;
 720 }
 721
 722 static char float_doc[] =
 723 "float(x) -> floating point number\n\
 724 \n\
 725 Convert a string or number to a floating point number, if possible.";
 726
 727
 728 static PyNumberMethods float_as_number = {
 729         (binaryfunc)float_add, /*nb_add*/
 730         (binaryfunc)float_sub, /*nb_subtract*/
 731         (binaryfunc)float_mul, /*nb_multiply*/
 732         (binaryfunc)float_classic_div, /*nb_divide*/
 733         (binaryfunc)float_rem, /*nb_remainder*/
 734         (binaryfunc)float_divmod, /*nb_divmod*/
 735         (ternaryfunc)float_pow, /*nb_power*/
 736         (unaryfunc)float_neg, /*nb_negative*/
 737         (unaryfunc)float_pos, /*nb_positive*/
 738         (unaryfunc)float_abs, /*nb_absolute*/
 739         (inquiry)float_nonzero, /*nb_nonzero*/
 740         0,              /*nb_invert*/
 741         0,              /*nb_lshift*/
 742         0,              /*nb_rshift*/
 743         0,              /*nb_and*/
 744         0,              /*nb_xor*/
 745         0,              /*nb_or*/
 746         (coercion)float_coerce, /*nb_coerce*/
 747         (unaryfunc)float_int, /*nb_int*/
 748         (unaryfunc)float_long, /*nb_long*/
 749         (unaryfunc)float_float, /*nb_float*/
 750         0,              /* nb_oct */
 751         0,              /* nb_hex */
 752         0,              /* nb_inplace_add */
 753         0,              /* nb_inplace_subtract */
 754         0,              /* nb_inplace_multiply */
 755         0,              /* nb_inplace_divide */
 756         0,              /* nb_inplace_remainder */
 757         0,              /* nb_inplace_power */
 758         0,              /* nb_inplace_lshift */
 759         0,              /* nb_inplace_rshift */
 760         0,              /* nb_inplace_and */
 761         0,              /* nb_inplace_xor */
 762         0,              /* nb_inplace_or */
 763         float_floor_div, /* nb_floor_divide */
 764         float_div,      /* nb_true_divide */
 765         0,              /* nb_inplace_floor_divide */
 766         0,              /* nb_inplace_true_divide */
 767 };
 768
 769 PyTypeObject PyFloat_Type = {
 770         PyObject_HEAD_INIT(&PyType_Type)
 771         0,
 772         "float",
 773         sizeof(PyFloatObject),
 774         0,
 775         (destructor)float_dealloc,              /* tp_dealloc */
 776         (printfunc)float_print,                 /* tp_print */
 777         0,                                      /* tp_getattr */
 778         0,                                      /* tp_setattr */
 779         (cmpfunc)float_compare,                 /* tp_compare */
 780         (reprfunc)float_repr,                   /* tp_repr */
 781         &float_as_number,                       /* tp_as_number */
 782         0,                                      /* tp_as_sequence */
 783         0,                                      /* tp_as_mapping */
 784         (hashfunc)float_hash,                   /* tp_hash */
 785         0,                                      /* tp_call */
 786         (reprfunc)float_str,                    /* tp_str */
 787         PyObject_GenericGetAttr,                /* tp_getattro */
 788         0,                                      /* tp_setattro */
 789         0,                                      /* tp_as_buffer */
 790         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
 791                 Py_TPFLAGS_BASETYPE,            /* tp_flags */
 792         float_doc,                              /* tp_doc */
 793         0,                                      /* tp_traverse */
 794         0,                                      /* tp_clear */
 795         0,                                      /* tp_richcompare */
 796         0,                                      /* tp_weaklistoffset */
 797         0,                                      /* tp_iter */
 798         0,                                      /* tp_iternext */
 799         0,                                      /* tp_methods */
 800         0,                                      /* tp_members */
 801         0,                                      /* tp_getset */
 802         0,                                      /* tp_base */
 803         0,                                      /* tp_dict */
 804         0,                                      /* tp_descr_get */
 805         0,                                      /* tp_descr_set */
 806         0,                                      /* tp_dictoffset */
 807         0,                                      /* tp_init */
 808         0,                                      /* tp_alloc */
 809         float_new,                              /* tp_new */
 810 };
 811
 812 void
 813 PyFloat_Fini(void)
 814 {
 815         PyFloatObject *p;
 816         PyFloatBlock *list, *next;
 817         int i;
 818         int bc, bf;     /* block count, number of freed blocks */
 819         int frem, fsum; /* remaining unfreed floats per block, total */
 820
 821         bc = 0;
 822         bf = 0;
 823         fsum = 0;
 824         list = block_list;
 825         block_list = NULL;
 826         free_list = NULL;
 827         while (list != NULL) {
 828                 bc++;
 829                 frem = 0;
 830                 for (i = 0, p = &list->objects[0];
 831                      i < N_FLOATOBJECTS;
 832                      i++, p++) {
 833                         if (PyFloat_CheckExact(p) && p->ob_refcnt != 0)
 834                                 frem++;
 835                 }
 836                 next = list->next;
 837                 if (frem) {
 838                         list->next = block_list;
 839                         block_list = list;
 840                         for (i = 0, p = &list->objects[0];
 841                              i < N_FLOATOBJECTS;
 842                              i++, p++) {
 843                                 if (!PyFloat_CheckExact(p) ||
 844                                     p->ob_refcnt == 0) {
 845                                         p->ob_type = (struct _typeobject *)
 846                                                 free_list;
 847                                         free_list = p;
 848                                 }
 849                         }
 850                 }
 851                 else {
 852                         PyMem_FREE(list); /* XXX PyObject_FREE ??? */
 853                         bf++;
 854                 }
 855                 fsum += frem;
 856                 list = next;
 857         }
 858         if (!Py_VerboseFlag)
 859                 return;
 860         fprintf(stderr, "# cleanup floats");
 861         if (!fsum) {
 862                 fprintf(stderr, "\n");
 863         }
 864         else {
 865                 fprintf(stderr,
 866                         ": %d unfreed float%s in %d out of %d block%s\n",
 867                         fsum, fsum == 1 ? "" : "s",
 868                         bc - bf, bc, bc == 1 ? "" : "s");
 869         }
 870         if (Py_VerboseFlag > 1) {
 871                 list = block_list;
 872                 while (list != NULL) {
 873                         for (i = 0, p = &list->objects[0];
 874                              i < N_FLOATOBJECTS;
 875                              i++, p++) {
 876                                 if (PyFloat_CheckExact(p) &&
 877                                     p->ob_refcnt != 0) {
 878                                         char buf[100];
 879                                         PyFloat_AsString(buf, p);
 880                                         fprintf(stderr,
 881                              "#   <float at %p, refcnt=%d, val=%s>\n",
 882                                                 p, p->ob_refcnt, buf);
 883                                 }
 884                         }
 885                         list = list->next;
 886                 }
 887         }
 888 }