cpython-lru_cache-weakref: Objects/floatobject.c annotate

annotate Objects/floatobject.c @ 42477:e7fd327e0c19

Kill all uses and definitions of tp_print under Objects/. (Others will follow.) Finally kill intobject.c, which was #ifdef'ed out a long time ago.

author	Guido van Rossum <guido@python.org>
date	Tue, 07 Aug 2007 19:51:00 +0000
parents	d3a5c796c8ba
children	e781085ac989

rev	line source
145 853b736a6a9e Added copyright notice. Guido van Rossum <guido@python.org> parents: 91 diff changeset	1
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2 /* Float object implementation */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3
27 82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	4 /* XXX There should be overflow checks here, but it's hard to check
82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	5 for any kind of float exception without losing portability. */
82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	6
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	7 #include "Python.h"
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	8
86 a6934380c6e7 "Compiling" version Guido van Rossum <guido@python.org> parents: 60 diff changeset	9 #include <ctype.h>
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	10
30979 86fdf8fe7f17 Getting rid of all the code inside #ifdef macintosh too. Jack Jansen <jack.jansen@cwi.nl> parents: 29641 diff changeset	11 #if !defined(__STDC__)
13447 a89f7f268de4 Nuke all remaining occurrences of Py_PROTO and Py_FPROTO. Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	12 extern double fmod(double, double);
a89f7f268de4 Nuke all remaining occurrences of Py_PROTO and Py_FPROTO. Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	13 extern double pow(double, double);
60 4f593b38d061 Moved prototyes for fmod and pow, and don't use them for THINK C. Guido van Rossum <guido@python.org> parents: 46 diff changeset	14 #endif
4f593b38d061 Moved prototyes for fmod and pow, and don't use them for THINK C. Guido van Rossum <guido@python.org> parents: 46 diff changeset	15
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	16 /* Special free list -- see comments for same code in intobject.c. */
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	17 #define BLOCK_SIZE 1000 /* 1K less typical malloc overhead */
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	18 #define BHEAD_SIZE 8 /* Enough for a 64-bit pointer */
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	19 #define N_FLOATOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyFloatObject))
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	20
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	21 struct _floatblock {
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	22 struct _floatblock *next;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	23 PyFloatObject objects[N_FLOATOBJECTS];
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	24 };
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	25
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	26 typedef struct _floatblock PyFloatBlock;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	27
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	28 static PyFloatBlock *block_list = NULL;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	29 static PyFloatObject *free_list = NULL;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	30
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	31 static PyFloatObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	32 fill_free_list(void)
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	33 {
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	34 PyFloatObject p, q;
12576 1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring. Guido van Rossum <guido@python.org> parents: 12248 diff changeset	35 /* XXX Float blocks escape the object heap. Use PyObject_MALLOC ??? */
1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring. Guido van Rossum <guido@python.org> parents: 12248 diff changeset	36 p = (PyFloatObject *) PyMem_MALLOC(sizeof(PyFloatBlock));
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	37 if (p == NULL)
12576 1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring. Guido van Rossum <guido@python.org> parents: 12248 diff changeset	38 return (PyFloatObject *) PyErr_NoMemory();
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	39 ((PyFloatBlock *)p)->next = block_list;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	40 block_list = (PyFloatBlock *)p;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	41 p = &((PyFloatBlock *)p)->objects[0];
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	42 q = p + N_FLOATOBJECTS;
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	43 while (--q > p)
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	44 Py_Type(q) = (struct _typeobject *)(q-1);
e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	45 Py_Type(q) = NULL;
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	46 return p + N_FLOATOBJECTS - 1;
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	47 }
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	48
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	49 PyObject *
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	50 PyFloat_FromDouble(double fval)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	51 {
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	52 register PyFloatObject *op;
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	53 if (free_list == NULL) {
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	54 if ((free_list = fill_free_list()) == NULL)
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	55 return NULL;
c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	56 }
24898 a869d2de536f Call me anal, but there was a particular phrase that was speading to Guido van Rossum <guido@python.org> parents: 24280 diff changeset	57 /* Inline PyObject_New */
5504 c88b9b868995 Faster floating point allocator, same idea as the int allocator. Guido van Rossum <guido@python.org> parents: 5396 diff changeset	58 op = free_list;
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	59 free_list = (PyFloatObject *)Py_Type(op);
12576 1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring. Guido van Rossum <guido@python.org> parents: 12248 diff changeset	60 PyObject_INIT(op, &PyFloat_Type);
27 82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	61 op->ob_fval = fval;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	62 return (PyObject *) op;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	63 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	64
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	65 PyObject *
41229 1f843890a4e6 Remove the deprecated and useless "pend" argument from Georg Brandl <georg@python.org> parents: 40626 diff changeset	66 PyFloat_FromString(PyObject *v)
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	67 {
11969 74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	68 const char s, last, *end;
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	69 double x;
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	70 char buffer[256]; /* for errors */
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	71 char *s_buffer = NULL;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36235 diff changeset	72 Py_ssize_t len;
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	73 PyObject *result = NULL;
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	74
11969 74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	75 if (PyString_Check(v)) {
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	76 s = PyString_AS_STRING(v);
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	77 len = PyString_GET_SIZE(v);
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	78 }
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11969 diff changeset	79 else if (PyUnicode_Check(v)) {
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	80 s_buffer = (char *)PyMem_MALLOC(PyUnicode_GET_SIZE(v)+1);
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	81 if (s_buffer == NULL)
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	82 return PyErr_NoMemory();
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	83 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v),
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11969 diff changeset	84 PyUnicode_GET_SIZE(v),
20823 c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0. Tim Peters <tim.peters@gmail.com> parents: 20654 diff changeset	85 s_buffer,
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11969 diff changeset	86 NULL))
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11969 diff changeset	87 return NULL;
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11969 diff changeset	88 s = s_buffer;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36235 diff changeset	89 len = strlen(s);
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11969 diff changeset	90 }
11969 74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	91 else if (PyObject_AsCharBuffer(v, &s, &len)) {
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	92 PyErr_SetString(PyExc_TypeError,
23344 bffc7236c4ba clarify message when raising TypeError to indicate that float() accepts Skip Montanaro <skip@pobox.com> parents: 22228 diff changeset	93 "float() argument must be a string or a number");
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	94 return NULL;
11969 74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	95 }
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	96
11969 74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	97 last = s + len;
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	98 while (s && isspace(Py_CHARMASK(s)))
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	99 s++;
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	100 if (*s == '\0') {
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	101 PyErr_SetString(PyExc_ValueError, "empty string for float()");
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	102 goto error;
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	103 }
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	104 /* We don't care about overflow or underflow. If the platform supports
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	105 * them, infinities and signed zeroes (on underflow) are fine.
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	106 * However, strtod can return 0 for denormalized numbers, where atof
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	107 * does not. So (alas!) we special-case a zero result. Note that
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	108 * whether strtod sets errno on underflow is not defined, so we can't
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	109 * key off errno.
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	110 */
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	111 PyFPE_START_PROTECT("strtod", goto error)
32305 13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic. Martin v. Löwis <martin@v.loewis.de> parents: 32150 diff changeset	112 x = PyOS_ascii_strtod(s, (char **)&end);
14851 5449302c4d2e Replace SIGFPE paranoia around strtod and atof. I don't believe these Tim Peters <tim.peters@gmail.com> parents: 14783 diff changeset	113 PyFPE_END_PROTECT(x)
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	114 errno = 0;
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	115 /* Believe it or not, Solaris 2.6 can move end beyond the null
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	116 byte at the end of the string, when the input is inf(inity). */
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	117 if (end > last)
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	118 end = last;
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	119 if (end == s) {
21079 8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for Barry Warsaw <barry@python.org> parents: 20829 diff changeset	120 PyOS_snprintf(buffer, sizeof(buffer),
8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for Barry Warsaw <barry@python.org> parents: 20829 diff changeset	121 "invalid literal for float(): %.200s", s);
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	122 PyErr_SetString(PyExc_ValueError, buffer);
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	123 goto error;
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	124 }
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	125 /* Since end != s, the platform made some kind of sense out
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	126 of the input. Trust it. */
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	127 while (end && isspace(Py_CHARMASK(end)))
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	128 end++;
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	129 if (*end != '\0') {
21079 8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for Barry Warsaw <barry@python.org> parents: 20829 diff changeset	130 PyOS_snprintf(buffer, sizeof(buffer),
8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for Barry Warsaw <barry@python.org> parents: 20829 diff changeset	131 "invalid literal for float(): %.200s", s);
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	132 PyErr_SetString(PyExc_ValueError, buffer);
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	133 goto error;
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	134 }
11969 74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg. Guido van Rossum <guido@python.org> parents: 11673 diff changeset	135 else if (end != last) {
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	136 PyErr_SetString(PyExc_ValueError,
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	137 "null byte in argument for float()");
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	138 goto error;
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	139 }
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	140 if (x == 0.0) {
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	141 /* See above -- may have been strtod being anal
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	142 about denorms. */
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	143 PyFPE_START_PROTECT("atof", goto error)
32305 13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic. Martin v. Löwis <martin@v.loewis.de> parents: 32150 diff changeset	144 x = PyOS_ascii_atof(s);
14851 5449302c4d2e Replace SIGFPE paranoia around strtod and atof. I don't believe these Tim Peters <tim.peters@gmail.com> parents: 14783 diff changeset	145 PyFPE_END_PROTECT(x)
14783 77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently. Tim Peters <tim.peters@gmail.com> parents: 14616 diff changeset	146 errno = 0; /* whether atof ever set errno is undefined */
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	147 }
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	148 result = PyFloat_FromDouble(x);
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	149 error:
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	150 if (s_buffer)
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	151 PyMem_FREE(s_buffer);
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	152 return result;
11383 aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	153 }
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log Barry Warsaw <barry@python.org> parents: 10833 diff changeset	154
1313 6ee380349c84 * Added gmtime/localtime/mktime and SYSV timezone globals to timemodule.c. Guido van Rossum <guido@python.org> parents: 1271 diff changeset	155 static void
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	156 float_dealloc(PyFloatObject *op)
745 c7b23cc8cded answer lint's complaints Guido van Rossum <guido@python.org> parents: 632 diff changeset	157 {
20277 2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 19976 diff changeset	158 if (PyFloat_CheckExact(op)) {
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	159 Py_Type(op) = (struct _typeobject *)free_list;
20277 2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 19976 diff changeset	160 free_list = op;
2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 19976 diff changeset	161 }
2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 19976 diff changeset	162 else
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	163 Py_Type(op)->tp_free((PyObject *)op);
745 c7b23cc8cded answer lint's complaints Guido van Rossum <guido@python.org> parents: 632 diff changeset	164 }
c7b23cc8cded answer lint's complaints Guido van Rossum <guido@python.org> parents: 632 diff changeset	165
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	166 double
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	167 PyFloat_AsDouble(PyObject *op)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	168 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	169 PyNumberMethods *nb;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	170 PyFloatObject *fo;
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	171 double val;
20823 c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0. Tim Peters <tim.peters@gmail.com> parents: 20654 diff changeset	172
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	173 if (op && PyFloat_Check(op))
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	174 return PyFloat_AS_DOUBLE((PyFloatObject*) op);
20823 c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0. Tim Peters <tim.peters@gmail.com> parents: 20654 diff changeset	175
26272 fbccef8b3153 Improve exception message raised by PyFloat_AsDouble if the object does not Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 24898 diff changeset	176 if (op == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	177 PyErr_BadArgument();
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	178 return -1;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	179 }
20823 c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0. Tim Peters <tim.peters@gmail.com> parents: 20654 diff changeset	180
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	181 if ((nb = Py_Type(op)->tp_as_number) == NULL \|\| nb->nb_float == NULL) {
26272 fbccef8b3153 Improve exception message raised by PyFloat_AsDouble if the object does not Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 24898 diff changeset	182 PyErr_SetString(PyExc_TypeError, "a float is required");
fbccef8b3153 Improve exception message raised by PyFloat_AsDouble if the object does not Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 24898 diff changeset	183 return -1;
fbccef8b3153 Improve exception message raised by PyFloat_AsDouble if the object does not Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 24898 diff changeset	184 }
fbccef8b3153 Improve exception message raised by PyFloat_AsDouble if the object does not Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 24898 diff changeset	185
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	186 fo = (PyFloatObject) (nb->nb_float) (op);
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	187 if (fo == NULL)
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	188 return -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	189 if (!PyFloat_Check(fo)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	190 PyErr_SetString(PyExc_TypeError,
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	191 "nb_float should return float object");
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	192 return -1;
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	193 }
20823 c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0. Tim Peters <tim.peters@gmail.com> parents: 20654 diff changeset	194
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	195 val = PyFloat_AS_DOUBLE(fo);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	196 Py_DECREF(fo);
20823 c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0. Tim Peters <tim.peters@gmail.com> parents: 20654 diff changeset	197
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	198 return val;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	199 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	200
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	201 /* Methods */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	202
21097 9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't Tim Peters <tim.peters@gmail.com> parents: 21079 diff changeset	203 static void
40527 195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	204 format_double(char *buf, size_t buflen, double ob_fval, int precision)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	205 {
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	206 register char *cp;
32305 13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic. Martin v. Löwis <martin@v.loewis.de> parents: 32150 diff changeset	207 char format[32];
42477 e7fd327e0c19 Kill all uses and definitions of tp_print under Objects/. (Others will follow.) Guido van Rossum <guido@python.org> parents: 42417 diff changeset	208 /* Subroutine for float_repr, float_str, and others.
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	209 We want float numbers to be recognizable as such,
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	210 i.e., they should contain a decimal point or an exponent.
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	211 However, %g may print the number as an integer;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	212 in such cases, we append ".0" to the string. */
21097 9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't Tim Peters <tim.peters@gmail.com> parents: 21079 diff changeset	213
32305 13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic. Martin v. Löwis <martin@v.loewis.de> parents: 32150 diff changeset	214 PyOS_snprintf(format, 32, "%%.%ig", precision);
40527 195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	215 PyOS_ascii_formatd(buf, buflen, format, ob_fval);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	216 cp = buf;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	217 if (*cp == '-')
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	218 cp++;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	219 for (; *cp != '\0'; cp++) {
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	220 /* Any non-digit means it's not an integer;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	221 this takes care of NAN and INF as well. */
2308 14b126d0b5be use Py_CHARMASK; and don't check for neg. float to the float power here Guido van Rossum <guido@python.org> parents: 2156 diff changeset	222 if (!isdigit(Py_CHARMASK(*cp)))
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	223 break;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	224 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	225 if (*cp == '\0') {
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	226 *cp++ = '.';
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	227 *cp++ = '0';
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	228 *cp++ = '\0';
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	229 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	230 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	231
40527 195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	232 static void
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	233 format_float(char buf, size_t buflen, PyFloatObject v, int precision)
21097 9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't Tim Peters <tim.peters@gmail.com> parents: 21079 diff changeset	234 {
40527 195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	235 assert(PyFloat_Check(v));
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	236 format_double(buf, buflen, PyFloat_AS_DOUBLE(v), precision);
21097 9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't Tim Peters <tim.peters@gmail.com> parents: 21079 diff changeset	237 }
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't Tim Peters <tim.peters@gmail.com> parents: 21079 diff changeset	238
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	239 /* Macro and helper that convert PyObject obj to a C double and store
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	240 the value in dbl; this replaces the functionality of the coercion
21354 fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	241 slot function. If conversion to double raises an exception, obj is
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	242 set to NULL, and the function invoking this macro returns NULL. If
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	243 obj is not of float, int or long type, Py_NotImplemented is incref'ed,
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	244 stored in obj, and returned from the function invoking this macro.
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	245 */
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	246 #define CONVERT_TO_DOUBLE(obj, dbl) \
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	247 if (PyFloat_Check(obj)) \
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	248 dbl = PyFloat_AS_DOUBLE(obj); \
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	249 else if (convert_to_double(&(obj), &(dbl)) < 0) \
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	250 return obj;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	251
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	252 static int
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19673 diff changeset	253 convert_to_double(PyObject *v, double dbl)
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	254 {
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	255 register PyObject obj = v;
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19673 diff changeset	256
40626 4aee3f672f77 Merged the int/long unification branch, by very crude means (sorry Thomas!). Guido van Rossum <guido@python.org> parents: 40527 diff changeset	257 if (PyLong_Check(obj)) {
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	258 *dbl = PyLong_AsDouble(obj);
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19673 diff changeset	259 if (*dbl == -1.0 && PyErr_Occurred()) {
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19673 diff changeset	260 *v = NULL;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19673 diff changeset	261 return -1;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19673 diff changeset	262 }
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	263 }
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	264 else {
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	265 Py_INCREF(Py_NotImplemented);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	266 *v = Py_NotImplemented;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	267 return -1;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	268 }
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	269 return 0;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	270 }
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	271
11631 cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	272 /* Precisions used by repr() and str(), respectively.
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	273
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	274 The repr() precision (17 significant decimal digits) is the minimal number
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	275 that is guaranteed to have enough precision so that if the number is read
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	276 back in the exact same binary value is recreated. This is true for IEEE
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	277 floating point by design, and also happens to work for all other modern
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	278 hardware.
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	279
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	280 The str() precision is chosen so that in most cases, the rounding noise
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	281 created by various operations is suppressed, while giving plenty of
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	282 precision for practical use.
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	283
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	284 */
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	285
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	286 #define PREC_REPR 17
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	287 #define PREC_STR 12
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	288
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	289 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	290 float_repr(PyFloatObject *v)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	291 {
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	292 char buf[100];
21097 9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't Tim Peters <tim.peters@gmail.com> parents: 21079 diff changeset	293 format_float(buf, sizeof(buf), v, PREC_REPR);
41769 b29d71d43c80 Add functions PyUnicode_Append() and PyUnicode_AppendAndDel() that mirror Walter Dörwald <walter@livinglogic.de> parents: 41725 diff changeset	294 return PyUnicode_FromString(buf);
11631 cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	295 }
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	296
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	297 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	298 float_str(PyFloatObject *v)
11631 cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	299 {
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g, Guido van Rossum <guido@python.org> parents: 11383 diff changeset	300 char buf[100];
21097 9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't Tim Peters <tim.peters@gmail.com> parents: 21079 diff changeset	301 format_float(buf, sizeof(buf), v, PREC_STR);
41920 71d861ee9ff0 Change float.__str__() and complex.__str__() to return Walter Dörwald <walter@livinglogic.de> parents: 41769 diff changeset	302 return PyUnicode_FromString(buf);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	303 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	304
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	305 /* Comparison is pretty much a nightmare. When comparing float to float,
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	306 * we do it as straightforwardly (and long-windedly) as conceivable, so
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	307 * that, e.g., Python x == y delivers the same result as the platform
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	308 * C x == y when x and/or y is a NaN.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	309 * When mixing float with an integer type, there's no good uniform approach.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	310 * Converting the double to an integer obviously doesn't work, since we
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	311 * may lose info from fractional bits. Converting the integer to a double
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	312 * also has two failure modes: (1) a long int may trigger overflow (too
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	313 * large to fit in the dynamic range of a C double); (2) even a C long may have
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	314 * more bits than fit in a C double (e.g., on a a 64-bit box long may have
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	315 * 63 bits of precision, but a C double probably has only 53), and then
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	316 * we can falsely claim equality when low-order integer bits are lost by
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	317 * coercion to double. So this part is painful too.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	318 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	319
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	320 static PyObject*
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	321 float_richcompare(PyObject v, PyObject w, int op)
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	322 {
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	323 double i, j;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	324 int r = 0;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	325
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	326 assert(PyFloat_Check(v));
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	327 i = PyFloat_AS_DOUBLE(v);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	328
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	329 /* Switch on the type of w. Set i and j to doubles to be compared,
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	330 * and op to the richcomp to use.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	331 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	332 if (PyFloat_Check(w))
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	333 j = PyFloat_AS_DOUBLE(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	334
38453 29ae5e0fc348 Much-needed merge (using svnmerge.py this time) of trunk changes into p3yk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	335 else if (!Py_IS_FINITE(i)) {
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	336 if (PyInt_Check(w) \|\| PyLong_Check(w))
33549 ecaf0e8fa737 float_richcompare(): Use the new Py_IS_NAN macro to ensure that, on Tim Peters <tim.peters@gmail.com> parents: 33547 diff changeset	337 /* If i is an infinity, its magnitude exceeds any
ecaf0e8fa737 float_richcompare(): Use the new Py_IS_NAN macro to ensure that, on Tim Peters <tim.peters@gmail.com> parents: 33547 diff changeset	338 * finite integer, so it doesn't matter which int we
ecaf0e8fa737 float_richcompare(): Use the new Py_IS_NAN macro to ensure that, on Tim Peters <tim.peters@gmail.com> parents: 33547 diff changeset	339 * compare i with. If i is a NaN, similarly.
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	340 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	341 j = 0.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	342 else
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	343 goto Unimplemented;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	344 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	345
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	346 else if (PyLong_Check(w)) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	347 int vsign = i == 0.0 ? 0 : i < 0.0 ? -1 : 1;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	348 int wsign = _PyLong_Sign(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	349 size_t nbits;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	350 int exponent;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	351
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	352 if (vsign != wsign) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	353 /* Magnitudes are irrelevant -- the signs alone
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	354 * determine the outcome.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	355 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	356 i = (double)vsign;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	357 j = (double)wsign;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	358 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	359 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	360 /* The signs are the same. */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	361 /* Convert w to a double if it fits. In particular, 0 fits. */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	362 nbits = _PyLong_NumBits(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	363 if (nbits == (size_t)-1 && PyErr_Occurred()) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	364 /* This long is so large that size_t isn't big enough
33549 ecaf0e8fa737 float_richcompare(): Use the new Py_IS_NAN macro to ensure that, on Tim Peters <tim.peters@gmail.com> parents: 33547 diff changeset	365 * to hold the # of bits. Replace with little doubles
ecaf0e8fa737 float_richcompare(): Use the new Py_IS_NAN macro to ensure that, on Tim Peters <tim.peters@gmail.com> parents: 33547 diff changeset	366 * that give the same outcome -- w is so large that
ecaf0e8fa737 float_richcompare(): Use the new Py_IS_NAN macro to ensure that, on Tim Peters <tim.peters@gmail.com> parents: 33547 diff changeset	367 * its magnitude must exceed the magnitude of any
ecaf0e8fa737 float_richcompare(): Use the new Py_IS_NAN macro to ensure that, on Tim Peters <tim.peters@gmail.com> parents: 33547 diff changeset	368 * finite float.
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	369 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	370 PyErr_Clear();
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	371 i = (double)vsign;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	372 assert(wsign != 0);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	373 j = wsign * 2.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	374 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	375 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	376 if (nbits <= 48) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	377 j = PyLong_AsDouble(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	378 /* It's impossible that <= 48 bits overflowed. */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	379 assert(j != -1.0 \|\| ! PyErr_Occurred());
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	380 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	381 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	382 assert(wsign != 0); /* else nbits was 0 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	383 assert(vsign != 0); /* if vsign were 0, then since wsign is
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	384 * not 0, we would have taken the
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	385 * vsign != wsign branch at the start */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	386 /* We want to work with non-negative numbers. */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	387 if (vsign < 0) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	388 /* "Multiply both sides" by -1; this also swaps the
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	389 * comparator.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	390 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	391 i = -i;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	392 op = _Py_SwappedOp[op];
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	393 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	394 assert(i > 0.0);
36235 9f66bdd5a061 Fix icc warnings: remove unused variable Neal Norwitz <nnorwitz@gmail.com> parents: 35999 diff changeset	395 (void) frexp(i, &exponent);
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	396 /* exponent is the # of bits in v before the radix point;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	397 * we know that nbits (the # of bits in w) > 48 at this point
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	398 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	399 if (exponent < 0 \|\| (size_t)exponent < nbits) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	400 i = 1.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	401 j = 2.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	402 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	403 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	404 if ((size_t)exponent > nbits) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	405 i = 2.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	406 j = 1.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	407 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	408 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	409 /* v and w have the same number of bits before the radix
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	410 * point. Construct two longs that have the same comparison
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	411 * outcome.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	412 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	413 {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	414 double fracpart;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	415 double intpart;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	416 PyObject *result = NULL;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	417 PyObject *one = NULL;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	418 PyObject *vv = NULL;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	419 PyObject *ww = w;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	420
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	421 if (wsign < 0) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	422 ww = PyNumber_Negative(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	423 if (ww == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	424 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	425 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	426 else
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	427 Py_INCREF(ww);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	428
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	429 fracpart = modf(i, &intpart);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	430 vv = PyLong_FromDouble(intpart);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	431 if (vv == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	432 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	433
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	434 if (fracpart != 0.0) {
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	435 /* Shift left, and or a 1 bit into vv
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	436 * to represent the lost fraction.
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	437 */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	438 PyObject *temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	439
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	440 one = PyInt_FromLong(1);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	441 if (one == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	442 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	443
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	444 temp = PyNumber_Lshift(ww, one);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	445 if (temp == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	446 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	447 Py_DECREF(ww);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	448 ww = temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	449
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	450 temp = PyNumber_Lshift(vv, one);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	451 if (temp == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	452 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	453 Py_DECREF(vv);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	454 vv = temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	455
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	456 temp = PyNumber_Or(vv, one);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	457 if (temp == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	458 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	459 Py_DECREF(vv);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	460 vv = temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	461 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	462
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	463 r = PyObject_RichCompareBool(vv, ww, op);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	464 if (r < 0)
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	465 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	466 result = PyBool_FromLong(r);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	467 Error:
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	468 Py_XDECREF(vv);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	469 Py_XDECREF(ww);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	470 Py_XDECREF(one);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	471 return result;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	472 }
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	473 } /* else if (PyLong_Check(w)) */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	474
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	475 else /* w isn't float, int, or long */
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	476 goto Unimplemented;
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	477
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	478 Compare:
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	479 PyFPE_START_PROTECT("richcompare", return NULL)
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	480 switch (op) {
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	481 case Py_EQ:
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	482 r = i == j;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	483 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	484 case Py_NE:
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	485 r = i != j;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	486 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	487 case Py_LE:
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	488 r = i <= j;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	489 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	490 case Py_GE:
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	491 r = i >= j;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	492 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	493 case Py_LT:
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	494 r = i < j;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	495 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	496 case Py_GT:
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	497 r = i > j;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	498 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	499 }
31589 ca3c998afa55 Pass a variable that actually exists to PyFPE_END_PROTECT in Michael W. Hudson <mwh@python.net> parents: 31553 diff changeset	500 PyFPE_END_PROTECT(r)
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	501 return PyBool_FromLong(r);
33547 702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	502
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	503 Unimplemented:
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	504 Py_INCREF(Py_NotImplemented);
702367da2c72 SF bug #513866: Float/long comparison anomaly. Tim Peters <tim.peters@gmail.com> parents: 32533 diff changeset	505 return Py_NotImplemented;
31553 a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	506 }
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including Michael W. Hudson <mwh@python.net> parents: 31384 diff changeset	507
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	508 static long
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	509 float_hash(PyFloatObject *v)
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	510 {
13976 5ada9fa54801 Fix for http://sourceforge.net/bugs/?func=detailbug&bug_id=111866&group_id=5470. Tim Peters <tim.peters@gmail.com> parents: 13944 diff changeset	511 return _Py_HashDouble(v->ob_fval);
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	512 }
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	513
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	514 static PyObject *
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	515 float_add(PyObject v, PyObject w)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	516 {
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	517 double a,b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	518 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	519 CONVERT_TO_DOUBLE(w, b);
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4933 diff changeset	520 PyFPE_START_PROTECT("add", return 0)
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	521 a = a + b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	522 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	523 return PyFloat_FromDouble(a);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	524 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	525
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	526 static PyObject *
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	527 float_sub(PyObject v, PyObject w)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	528 {
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	529 double a,b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	530 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	531 CONVERT_TO_DOUBLE(w, b);
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4933 diff changeset	532 PyFPE_START_PROTECT("subtract", return 0)
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	533 a = a - b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	534 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	535 return PyFloat_FromDouble(a);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	536 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	537
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	538 static PyObject *
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	539 float_mul(PyObject v, PyObject w)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	540 {
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	541 double a,b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	542 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	543 CONVERT_TO_DOUBLE(w, b);
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4933 diff changeset	544 PyFPE_START_PROTECT("multiply", return 0)
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	545 a = a * b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	546 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	547 return PyFloat_FromDouble(a);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	548 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	549
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	550 static PyObject *
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	551 float_div(PyObject v, PyObject w)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	552 {
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	553 double a,b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	554 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	555 CONVERT_TO_DOUBLE(w, b);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	556 if (b == 0.0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	557 PyErr_SetString(PyExc_ZeroDivisionError, "float division");
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	558 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	559 }
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4933 diff changeset	560 PyFPE_START_PROTECT("divide", return 0)
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	561 a = a / b;
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	562 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	563 return PyFloat_FromDouble(a);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	564 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	565
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	566 static PyObject *
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	567 float_rem(PyObject v, PyObject w)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	568 {
632 0c1938f2e0c0 Get rid of redundant type checks. Guido van Rossum <guido@python.org> parents: 496 diff changeset	569 double vx, wx;
10833 135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	570 double mod;
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	571 CONVERT_TO_DOUBLE(v, vx);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	572 CONVERT_TO_DOUBLE(w, wx);
632 0c1938f2e0c0 Get rid of redundant type checks. Guido van Rossum <guido@python.org> parents: 496 diff changeset	573 if (wx == 0.0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	574 PyErr_SetString(PyExc_ZeroDivisionError, "float modulo");
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	575 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	576 }
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4933 diff changeset	577 PyFPE_START_PROTECT("modulo", return 0)
632 0c1938f2e0c0 Get rid of redundant type checks. Guido van Rossum <guido@python.org> parents: 496 diff changeset	578 mod = fmod(vx, wx);
10833 135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	579 /* note: checking mod*wx < 0 is incorrect -- underflows to
135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	580 0 if wx < sqrt(smallest nonzero double) */
135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	581 if (mod && ((wx < 0) != (mod < 0))) {
632 0c1938f2e0c0 Get rid of redundant type checks. Guido van Rossum <guido@python.org> parents: 496 diff changeset	582 mod += wx;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	583 }
5197 74c12704a0bd New form of PyFPE_END_PROTECT macro. Guido van Rossum <guido@python.org> parents: 5118 diff changeset	584 PyFPE_END_PROTECT(mod)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	585 return PyFloat_FromDouble(mod);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	586 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	587
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	588 static PyObject *
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	589 float_divmod(PyObject v, PyObject w)
227 7ec6058b539b Added (dummy) divmod and (functional) abs. Guido van Rossum <guido@python.org> parents: 145 diff changeset	590 {
391 caf8466dcc9c Finally implemented divmod(). Guido van Rossum <guido@python.org> parents: 284 diff changeset	591 double vx, wx;
10833 135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	592 double div, mod, floordiv;
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	593 CONVERT_TO_DOUBLE(v, vx);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	594 CONVERT_TO_DOUBLE(w, wx);
391 caf8466dcc9c Finally implemented divmod(). Guido van Rossum <guido@python.org> parents: 284 diff changeset	595 if (wx == 0.0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	596 PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
391 caf8466dcc9c Finally implemented divmod(). Guido van Rossum <guido@python.org> parents: 284 diff changeset	597 return NULL;
caf8466dcc9c Finally implemented divmod(). Guido van Rossum <guido@python.org> parents: 284 diff changeset	598 }
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4933 diff changeset	599 PyFPE_START_PROTECT("divmod", return 0)
391 caf8466dcc9c Finally implemented divmod(). Guido van Rossum <guido@python.org> parents: 284 diff changeset	600 mod = fmod(vx, wx);
14616 284508c653c7 Fixed legit gripe from c.l.py that math.fmod docs aren't confusing enough. Tim Peters <tim.peters@gmail.com> parents: 14375 diff changeset	601 /* fmod is typically exact, so vx-mod is mathematically an
10833 135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	602 exact multiple of wx. But this is fp arithmetic, and fp
135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	603 vx - mod is an approximation; the result is that div may
135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	604 not be an exact integral value after the division, although
135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	605 it will always be very close to one.
135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	606 */
391 caf8466dcc9c Finally implemented divmod(). Guido van Rossum <guido@python.org> parents: 284 diff changeset	607 div = (vx - mod) / wx;
20827 95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	608 if (mod) {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	609 /* ensure the remainder has the same sign as the denominator */
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	610 if ((wx < 0) != (mod < 0)) {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	611 mod += wx;
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	612 div -= 1.0;
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	613 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	614 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	615 else {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	616 /* the remainder is zero, and in the presence of signed zeroes
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	617 fmod returns different results across platforms; ensure
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	618 it has the same sign as the denominator; we'd like to do
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	619 "mod = wx * 0.0", but that may get optimized away */
20829 14dc693af532 float_divmod(): the code wasn't sick enough to stop the MS optimizer Tim Peters <tim.peters@gmail.com> parents: 20827 diff changeset	620 mod = mod; / hide "mod = +0" from optimizer */
20827 95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	621 if (wx < 0.0)
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	622 mod = -mod;
391 caf8466dcc9c Finally implemented divmod(). Guido van Rossum <guido@python.org> parents: 284 diff changeset	623 }
10833 135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	624 /* snap quotient to nearest integral value */
20827 95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	625 if (div) {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	626 floordiv = floor(div);
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	627 if (div - floordiv > 0.5)
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	628 floordiv += 1.0;
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	629 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	630 else {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	631 /* div is zero - get the same sign as the true quotient */
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	632 div = div; / hide "div = +0" from optimizers */
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	633 floordiv = div * vx / wx; /* zero w/ sign of vx/wx */
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	634 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0 Tim Peters <tim.peters@gmail.com> parents: 20826 diff changeset	635 PyFPE_END_PROTECT(floordiv)
10833 135c1ec9636c Tim Peters writes: Guido van Rossum <guido@python.org> parents: 10432 diff changeset	636 return Py_BuildValue("(dd)", floordiv, mod);
227 7ec6058b539b Added (dummy) divmod and (functional) abs. Guido van Rossum <guido@python.org> parents: 145 diff changeset	637 }
7ec6058b539b Added (dummy) divmod and (functional) abs. Guido van Rossum <guido@python.org> parents: 145 diff changeset	638
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	639 static PyObject *
21353 257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	640 float_floor_div(PyObject v, PyObject w)
257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	641 {
257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	642 PyObject t, r;
257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	643
257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	644 t = float_divmod(v, w);
21354 fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	645 if (t == NULL \|\| t == Py_NotImplemented)
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	646 return t;
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	647 assert(PyTuple_CheckExact(t));
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	648 r = PyTuple_GET_ITEM(t, 0);
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	649 Py_INCREF(r);
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	650 Py_DECREF(t);
fbddb64d21c2 float_floor_div: An expression like 3.//1j crashed the interpreter, or Tim Peters <tim.peters@gmail.com> parents: 21353 diff changeset	651 return r;
21353 257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	652 }
257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	653
257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	654 static PyObject *
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	655 float_pow(PyObject v, PyObject w, PyObject *z)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	656 {
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	657 double iv, iw, ix;
19666 cf65ebf87560 New restriction on pow(x, y, z): If z is not None, x and y must be of Tim Peters <tim.peters@gmail.com> parents: 19633 diff changeset	658
cf65ebf87560 New restriction on pow(x, y, z): If z is not None, x and y must be of Tim Peters <tim.peters@gmail.com> parents: 19633 diff changeset	659 if ((PyObject *)z != Py_None) {
19719 cdfdd5359411 Make the error msgs in our pow() implementations consistent. Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	660 PyErr_SetString(PyExc_TypeError, "pow() 3rd argument not "
19753 c0580d8c193e Better error msg for 3-arg pow with a float argument. Tim Peters <tim.peters@gmail.com> parents: 19750 diff changeset	661 "allowed unless all arguments are integers");
19666 cf65ebf87560 New restriction on pow(x, y, z): If z is not None, x and y must be of Tim Peters <tim.peters@gmail.com> parents: 19633 diff changeset	662 return NULL;
cf65ebf87560 New restriction on pow(x, y, z): If z is not None, x and y must be of Tim Peters <tim.peters@gmail.com> parents: 19633 diff changeset	663 }
cf65ebf87560 New restriction on pow(x, y, z): If z is not None, x and y must be of Tim Peters <tim.peters@gmail.com> parents: 19633 diff changeset	664
15723 ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	665 CONVERT_TO_DOUBLE(v, iv);
ac7ae3ead88a Make float a new style number type. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	666 CONVERT_TO_DOUBLE(w, iw);
15041 7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	667
7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	668 /* Sort out special cases here instead of relying on pow() */
19457 6c2b7b624ef2 float_pow: Put all of the burden on the libm pow in normal Tim Peters <tim.peters@gmail.com> parents: 19343 diff changeset	669 if (iw == 0) { /* v0 is 1, even 00 */
41716 00c02c4488ce Merged revisions 55325-55327 via svnmerge from Guido van Rossum <guido@python.org> parents: 41587 diff changeset	670 return PyFloat_FromDouble(1.0);
15041 7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	671 }
19457 6c2b7b624ef2 float_pow: Put all of the burden on the libm pow in normal Tim Peters <tim.peters@gmail.com> parents: 19343 diff changeset	672 if (iv == 0.0) { /* 0*w is error if w<0, else 1 /
15041 7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	673 if (iw < 0.0) {
7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	674 PyErr_SetString(PyExc_ZeroDivisionError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15041 diff changeset	675 "0.0 cannot be raised to a negative power");
15041 7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	676 return NULL;
7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	677 }
7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	678 return PyFloat_FromDouble(0.0);
7eefde90ec0e SF bug 115831 and Ping's SF patch 101751, 0.0*-2.0 returns inf rather than Tim Peters <tim.peters@gmail.com>* parents: 14869 diff changeset	679 }
29252 0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	680 if (iv < 0.0) {
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	681 /* Whether this is an error is a mess, and bumps into libm
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	682 * bugs so we have to figure it out ourselves.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	683 */
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	684 if (iw != floor(iw)) {
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	685 PyErr_SetString(PyExc_ValueError, "negative number "
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	686 "cannot be raised to a fractional power");
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	687 return NULL;
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	688 }
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	689 /* iw is an exact integer, albeit perhaps a very large one.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	690 * -1 raised to an exact integer should never be exceptional.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	691 * Alas, some libms (chiefly glibc as of early 2003) return
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	692 * NaN and set EDOM on pow(-1, large_int) if the int doesn't
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	693 * happen to be representable in a C integer. That's a
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	694 * bug; we let that slide in math.pow() (which currently
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	695 * reflects all platform accidents), but not for Python's **.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	696 */
38453 29ae5e0fc348 Much-needed merge (using svnmerge.py this time) of trunk changes into p3yk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	697 if (iv == -1.0 && Py_IS_FINITE(iw)) {
29252 0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	698 /* Return 1 if iw is even, -1 if iw is odd; there's
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	699 * no guarantee that any C integral type is big
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	700 * enough to hold iw, so we have to check this
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	701 * indirectly.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	702 */
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	703 ix = floor(iw * 0.5) * 2.0;
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	704 return PyFloat_FromDouble(ix == iw ? 1.0 : -1.0);
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	705 }
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	706 /* Else iv != -1.0, and overflow or underflow are possible.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	707 * Unless we're to write pow() ourselves, we have to trust
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	708 * the platform to do this correctly.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	709 */
3984 0613f17dcfd8 Correct wrong calculation of pow(0.0, 0.0, negative_number) Guido van Rossum <guido@python.org> parents: 3704 diff changeset	710 }
19457 6c2b7b624ef2 float_pow: Put all of the burden on the libm pow in normal Tim Peters <tim.peters@gmail.com> parents: 19343 diff changeset	711 errno = 0;
6c2b7b624ef2 float_pow: Put all of the burden on the libm pow in normal Tim Peters <tim.peters@gmail.com> parents: 19343 diff changeset	712 PyFPE_START_PROTECT("pow", return NULL)
6c2b7b624ef2 float_pow: Put all of the burden on the libm pow in normal Tim Peters <tim.peters@gmail.com> parents: 19343 diff changeset	713 ix = pow(iv, iw);
6c2b7b624ef2 float_pow: Put all of the burden on the libm pow in normal Tim Peters <tim.peters@gmail.com> parents: 19343 diff changeset	714 PyFPE_END_PROTECT(ix)
22228 4b6eda7d0c8f backport tim_one's checkin of Michael W. Hudson <mwh@python.net> parents: 21354 diff changeset	715 Py_ADJUST_ERANGE1(ix);
27 82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	716 if (errno != 0) {
29252 0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	717 /* We don't expect any errno value other than ERANGE, but
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	718 * the range of libm bugs appears unbounded.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	719 */
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	720 PyErr_SetFromErrno(errno == ERANGE ? PyExc_OverflowError :
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts. Tim Peters <tim.peters@gmail.com> parents: 28368 diff changeset	721 PyExc_ValueError);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	722 return NULL;
27 82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	723 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	724 return PyFloat_FromDouble(ix);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	725 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	726
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	727 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	728 float_neg(PyFloatObject *v)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	729 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	730 return PyFloat_FromDouble(-v->ob_fval);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	731 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	732
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	733 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	734 float_abs(PyFloatObject *v)
227 7ec6058b539b Added (dummy) divmod and (functional) abs. Guido van Rossum <guido@python.org> parents: 145 diff changeset	735 {
20826 3751366c2f39 float_abs() again: Guido pointed out that this could screw up in the Tim Peters <tim.peters@gmail.com> parents: 20823 diff changeset	736 return PyFloat_FromDouble(fabs(v->ob_fval));
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	737 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	738
239 fda973f2a512 Added nonzero test Guido van Rossum <guido@python.org> parents: 227 diff changeset	739 static int
40401 88133417dfd0 - patch #1600346 submitted by Tomer Filiba Jack Diederich <jackdied@gmail.com> parents: 39603 diff changeset	740 float_bool(PyFloatObject *v)
239 fda973f2a512 Added nonzero test Guido van Rossum <guido@python.org> parents: 227 diff changeset	741 {
fda973f2a512 Added nonzero test Guido van Rossum <guido@python.org> parents: 227 diff changeset	742 return v->ob_fval != 0.0;
fda973f2a512 Added nonzero test Guido van Rossum <guido@python.org> parents: 227 diff changeset	743 }
fda973f2a512 Added nonzero test Guido van Rossum <guido@python.org> parents: 227 diff changeset	744
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	745 static PyObject *
26291 d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26272 diff changeset	746 float_long(PyObject *v)
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26272 diff changeset	747 {
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26272 diff changeset	748 double x = PyFloat_AsDouble(v);
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26272 diff changeset	749 return PyLong_FromDouble(x);
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26272 diff changeset	750 }
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26272 diff changeset	751
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26272 diff changeset	752 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	753 float_int(PyObject *v)
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	754 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	755 double x = PyFloat_AsDouble(v);
18838 a8575f358b9f SF bug #444510: int() should guarantee truncation. Tim Peters <tim.peters@gmail.com> parents: 17707 diff changeset	756 double wholepart; /* integral portion of x, rounded toward 0 */
a8575f358b9f SF bug #444510: int() should guarantee truncation. Tim Peters <tim.peters@gmail.com> parents: 17707 diff changeset	757
a8575f358b9f SF bug #444510: int() should guarantee truncation. Tim Peters <tim.peters@gmail.com> parents: 17707 diff changeset	758 (void)modf(x, &wholepart);
26328 f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	759 /* Try to get out cheap if this fits in a Python int. The attempt
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	760 * to cast to long must be protected, as C doesn't define what
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	761 * happens if the double is too big to fit in a long. Some rare
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	762 * systems raise an exception then (RISCOS was mentioned as one,
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	763 * and someone using a non-default option on Sun also bumped into
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	764 * that). Note that checking for >= and <= LONG_{MIN,MAX} would
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	765 * still be vulnerable: if a long has more bits of precision than
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	766 * a double, casting MIN/MAX to double may yield an approximation,
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	767 * and if that's rounded up, then, e.g., wholepart=LONG_MAX+1 would
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	768 * yield true from the C expression wholepart<=LONG_MAX, despite
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	769 * that wholepart is actually greater than LONG_MAX.
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	770 */
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	771 if (LONG_MIN < wholepart && wholepart < LONG_MAX) {
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	772 const long aslong = (long)wholepart;
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	773 return PyInt_FromLong(aslong);
20654 edd9d0b3c47e SF patch #474590 -- RISC OS support Guido van Rossum <guido@python.org> parents: 20277 diff changeset	774 }
26328 f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to Tim Peters <tim.peters@gmail.com> parents: 26291 diff changeset	775 return PyLong_FromDouble(wholepart);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	776 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	777
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	778 static PyObject *
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	779 float_float(PyObject *v)
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	780 {
34931 9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33549 diff changeset	781 if (PyFloat_CheckExact(v))
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33549 diff changeset	782 Py_INCREF(v);
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33549 diff changeset	783 else
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33549 diff changeset	784 v = PyFloat_FromDouble(((PyFloatObject *)v)->ob_fval);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	785 return v;
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	786 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	787
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 955 diff changeset	788
24280 1598a1e473e2 staticforward bites the dust. Jeremy Hylton <jeremy@alum.mit.edu> parents: 23832 diff changeset	789 static PyObject *
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	790 float_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds);
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	791
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	792 static PyObject *
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	793 float_new(PyTypeObject type, PyObject args, PyObject *kwds)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	794 {
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	795 PyObject x = Py_False; / Integer zero */
36675 dba6494735d0 Revert backwards-incompatible const changes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	796 static char *kwlist[] = {"x", 0};
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	797
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	798 if (type != &PyFloat_Type)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	799 return float_subtype_new(type, args, kwds); /* Wimp out */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	800 if (!PyArg_ParseTupleAndKeywords(args, kwds, "\|O:float", kwlist, &x))
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	801 return NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	802 if (PyString_Check(x))
41229 1f843890a4e6 Remove the deprecated and useless "pend" argument from Georg Brandl <georg@python.org> parents: 40626 diff changeset	803 return PyFloat_FromString(x);
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	804 return PyNumber_Float(x);
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	805 }
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	806
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	807 /* Wimpy, slow approach to tp_new calls for subtypes of float:
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	808 first create a regular float from whatever arguments we got,
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	809 then allocate a subtype instance and initialize its ob_fval
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	810 from the regular float. The regular float is then thrown away.
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	811 */
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	812 static PyObject *
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	813 float_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	814 {
37879 f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	815 PyObject tmp, newobj;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	816
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	817 assert(PyType_IsSubtype(type, &PyFloat_Type));
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	818 tmp = float_new(&PyFloat_Type, args, kwds);
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	819 if (tmp == NULL)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	820 return NULL;
19889 733314fcfdaa Again perhaps the end of [#460020] bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19879 diff changeset	821 assert(PyFloat_CheckExact(tmp));
37879 f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	822 newobj = type->tp_alloc(type, 0);
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	823 if (newobj == NULL) {
29641 4909aa64405f SF patch 703666: Several objects don't decref tmp on failure in subtype_new Raymond Hettinger <python@rcn.com> parents: 29252 diff changeset	824 Py_DECREF(tmp);
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	825 return NULL;
29641 4909aa64405f SF patch 703666: Several objects don't decref tmp on failure in subtype_new Raymond Hettinger <python@rcn.com> parents: 29252 diff changeset	826 }
37879 f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	827 ((PyFloatObject )newobj)->ob_fval = ((PyFloatObject )tmp)->ob_fval;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	828 Py_DECREF(tmp);
37879 f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	829 return newobj;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	830 }
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19457 diff changeset	831
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	832 static PyObject *
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	833 float_getnewargs(PyFloatObject *v)
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	834 {
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	835 return Py_BuildValue("(d)", v->ob_fval);
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	836 }
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	837
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	838 /* this is for the benefit of the pack/unpack routines below */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	839
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	840 typedef enum {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	841 unknown_format, ieee_big_endian_format, ieee_little_endian_format
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	842 } float_format_type;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	843
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	844 static float_format_type double_format, float_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	845 static float_format_type detected_double_format, detected_float_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	846
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	847 static PyObject *
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	848 float_getformat(PyTypeObject v, PyObject arg)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	849 {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	850 char* s;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	851 float_format_type r;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	852
41725 d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	853 if (PyUnicode_Check(arg)) {
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	854 arg = _PyUnicode_AsDefaultEncodedString(arg, NULL);
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	855 if (arg == NULL)
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	856 return NULL;
d1146d4db549 Make tset_float pass. float(<unicode>) was never very good -- it used Guido van Rossum <guido@python.org> parents: 41716 diff changeset	857 }
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	858 if (!PyString_Check(arg)) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	859 PyErr_Format(PyExc_TypeError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	860 "__getformat__() argument must be string, not %.500s",
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	861 Py_Type(arg)->tp_name);
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	862 return NULL;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	863 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	864 s = PyString_AS_STRING(arg);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	865 if (strcmp(s, "double") == 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	866 r = double_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	867 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	868 else if (strcmp(s, "float") == 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	869 r = float_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	870 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	871 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	872 PyErr_SetString(PyExc_ValueError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	873 "__getformat__() argument 1 must be "
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	874 "'double' or 'float'");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	875 return NULL;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	876 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	877
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	878 switch (r) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	879 case unknown_format:
42126 8fc93215c0cc Change float.__getformat__() to return a unicode string. Walter Dörwald <walter@livinglogic.de> parents: 41920 diff changeset	880 return PyUnicode_FromString("unknown");
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	881 case ieee_little_endian_format:
42126 8fc93215c0cc Change float.__getformat__() to return a unicode string. Walter Dörwald <walter@livinglogic.de> parents: 41920 diff changeset	882 return PyUnicode_FromString("IEEE, little-endian");
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	883 case ieee_big_endian_format:
42126 8fc93215c0cc Change float.__getformat__() to return a unicode string. Walter Dörwald <walter@livinglogic.de> parents: 41920 diff changeset	884 return PyUnicode_FromString("IEEE, big-endian");
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	885 default:
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	886 Py_FatalError("insane float_format or double_format");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	887 return NULL;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	888 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	889 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	890
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	891 PyDoc_STRVAR(float_getformat_doc,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	892 "float.__getformat__(typestr) -> string\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	893 "\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	894 "You probably don't want to use this function. It exists mainly to be\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	895 "used in Python's test suite.\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	896 "\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	897 "typestr must be 'double' or 'float'. This function returns whichever of\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	898 "'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	899 "format of floating point numbers used by the C type named by typestr.");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	900
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	901 static PyObject *
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	902 float_setformat(PyTypeObject v, PyObject args)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	903 {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	904 char* typestr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	905 char* format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	906 float_format_type f;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	907 float_format_type detected;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	908 float_format_type *p;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	909
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	910 if (!PyArg_ParseTuple(args, "ss:__setformat__", &typestr, &format))
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	911 return NULL;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	912
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	913 if (strcmp(typestr, "double") == 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	914 p = &double_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	915 detected = detected_double_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	916 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	917 else if (strcmp(typestr, "float") == 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	918 p = &float_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	919 detected = detected_float_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	920 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	921 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	922 PyErr_SetString(PyExc_ValueError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	923 "__setformat__() argument 1 must "
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	924 "be 'double' or 'float'");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	925 return NULL;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	926 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	927
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	928 if (strcmp(format, "unknown") == 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	929 f = unknown_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	930 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	931 else if (strcmp(format, "IEEE, little-endian") == 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	932 f = ieee_little_endian_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	933 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	934 else if (strcmp(format, "IEEE, big-endian") == 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	935 f = ieee_big_endian_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	936 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	937 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	938 PyErr_SetString(PyExc_ValueError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	939 "__setformat__() argument 2 must be "
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	940 "'unknown', 'IEEE, little-endian' or "
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	941 "'IEEE, big-endian'");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	942 return NULL;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	943
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	944 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	945
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	946 if (f != unknown_format && f != detected) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	947 PyErr_Format(PyExc_ValueError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	948 "can only set %s format to 'unknown' or the "
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	949 "detected platform value", typestr);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	950 return NULL;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	951 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	952
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	953 *p = f;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	954 Py_RETURN_NONE;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	955 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	956
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	957 PyDoc_STRVAR(float_setformat_doc,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	958 "float.__setformat__(typestr, fmt) -> None\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	959 "\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	960 "You probably don't want to use this function. It exists mainly to be\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	961 "used in Python's test suite.\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	962 "\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	963 "typestr must be 'double' or 'float'. fmt must be one of 'unknown',\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	964 "'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	965 "one of the latter two if it appears to match the underlying C reality.\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	966 "\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	967 "Overrides the automatic determination of C-level floating point type.\n"
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	968 "This affects how floats are converted to and from binary strings.");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	969
42417 d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	970 static PyObject *
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	971 float_getzero(PyObject v, void closure)
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	972 {
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	973 return PyFloat_FromDouble(0.0);
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	974 }
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	975
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	976 static PyMethodDef float_methods[] = {
42417 d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	977 {"conjugate", (PyCFunction)float_float, METH_NOARGS,
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	978 "Returns self, the complex conjugate of any float."},
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	979 {"__getnewargs__", (PyCFunction)float_getnewargs, METH_NOARGS},
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	980 {"__getformat__", (PyCFunction)float_getformat,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	981 METH_O\|METH_CLASS, float_getformat_doc},
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	982 {"__setformat__", (PyCFunction)float_setformat,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	983 METH_VARARGS\|METH_CLASS, float_setformat_doc},
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	984 {NULL, NULL} /* sentinel */
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	985 };
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	986
42417 d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	987 static PyGetSetDef float_getset[] = {
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	988 {"real",
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	989 (getter)float_float, (setter)NULL,
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	990 "the real part of a complex number",
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	991 NULL},
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	992 {"imag",
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	993 (getter)float_getzero, (setter)NULL,
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	994 "the imaginary part of a complex number",
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	995 NULL},
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	996 {NULL} /* Sentinel */
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	997 };
d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	998
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23344 diff changeset	999 PyDoc_STRVAR(float_doc,
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1000 "float(x) -> floating point number\n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1001 \n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23344 diff changeset	1002 Convert a string or number to a floating point number, if possible.");
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1003
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1004
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	1005 static PyNumberMethods float_as_number = {
37879 f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1006 float_add, /nb_add/
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1007 float_sub, /nb_subtract/
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1008 float_mul, /nb_multiply/
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1009 float_rem, /nb_remainder/
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1010 float_divmod, /nb_divmod/
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1011 float_pow, /nb_power/
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	1012 (unaryfunc)float_neg, /nb_negative/
42417 d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	1013 (unaryfunc)float_float, /nb_positive/
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1347 diff changeset	1014 (unaryfunc)float_abs, /nb_absolute/
40401 88133417dfd0 - patch #1600346 submitted by Tomer Filiba Jack Diederich <jackdied@gmail.com> parents: 39603 diff changeset	1015 (inquiry)float_bool, /nb_bool/
405 d3d328680328 Added NULL function pointers for shift and mask ops. Guido van Rossum <guido@python.org> parents: 391 diff changeset	1016 0, /nb_invert/
d3d328680328 Added NULL function pointers for shift and mask ops. Guido van Rossum <guido@python.org> parents: 391 diff changeset	1017 0, /nb_lshift/
d3d328680328 Added NULL function pointers for shift and mask ops. Guido van Rossum <guido@python.org> parents: 391 diff changeset	1018 0, /nb_rshift/
d3d328680328 Added NULL function pointers for shift and mask ops. Guido van Rossum <guido@python.org> parents: 391 diff changeset	1019 0, /nb_and/
d3d328680328 Added NULL function pointers for shift and mask ops. Guido van Rossum <guido@python.org> parents: 391 diff changeset	1020 0, /nb_xor/
d3d328680328 Added NULL function pointers for shift and mask ops. Guido van Rossum <guido@python.org> parents: 391 diff changeset	1021 0, /nb_or/
39603 40bbe669b089 Get rid of most of the rest of coerce (slot is still there for now). Neal Norwitz <nnorwitz@gmail.com> parents: 39222 diff changeset	1022 (coercion)0, /nb_coerce/
37879 f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1023 float_int, /nb_int/
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1024 float_long, /nb_long/
f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1025 float_float, /nb_float/
19051 f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1026 0, /* nb_oct */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1027 0, /* nb_hex */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1028 0, /* nb_inplace_add */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1029 0, /* nb_inplace_subtract */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1030 0, /* nb_inplace_multiply */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1031 0, /* nb_inplace_remainder */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1032 0, /* nb_inplace_power */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1033 0, /* nb_inplace_lshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1034 0, /* nb_inplace_rshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1035 0, /* nb_inplace_and */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1036 0, /* nb_inplace_xor */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1037 0, /* nb_inplace_or */
21353 257c938900a6 float_int_div(): For clarity, move this closer to the other float Tim Peters <tim.peters@gmail.com> parents: 21097 diff changeset	1038 float_floor_div, /* nb_floor_divide */
19051 f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1039 float_div, /* nb_true_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1040 0, /* nb_inplace_floor_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	1041 0, /* nb_inplace_true_divide */
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1042 };
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1043
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	1044 PyTypeObject PyFloat_Type = {
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	1045 PyVarObject_HEAD_INIT(&PyType_Type, 0)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1046 "float",
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	1047 sizeof(PyFloatObject),
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1048 0,
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1049 (destructor)float_dealloc, /* tp_dealloc */
42477 e7fd327e0c19 Kill all uses and definitions of tp_print under Objects/. (Others will follow.) Guido van Rossum <guido@python.org> parents: 42417 diff changeset	1050 0, /* tp_print */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1051 0, /* tp_getattr */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1052 0, /* tp_setattr */
32150 65f9ad9bc829 Remove float_compare as per Michael W. Hudson <mwh@python.net> parents: 31590 diff changeset	1053 0, /* tp_compare */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1054 (reprfunc)float_repr, /* tp_repr */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1055 &float_as_number, /* tp_as_number */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1056 0, /* tp_as_sequence */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1057 0, /* tp_as_mapping */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1058 (hashfunc)float_hash, /* tp_hash */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1059 0, /* tp_call */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1060 (reprfunc)float_str, /* tp_str */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1061 PyObject_GenericGetAttr, /* tp_getattro */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1062 0, /* tp_setattro */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1063 0, /* tp_as_buffer */
39222 b0cdcbcc5f45 Get rid of most of the flags (in tp_flags) that keep track of various Guido van Rossum <guido@python.org> parents: 38453 diff changeset	1064 Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1065 float_doc, /* tp_doc */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1066 0, /* tp_traverse */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1067 0, /* tp_clear */
37879 f731859e9b3b Merge p3yk branch with the trunk up to revision 45595. This breaks a fair Thomas Wouters <thomas@python.org> parents: 37191 diff changeset	1068 float_richcompare, /* tp_richcompare */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1069 0, /* tp_weaklistoffset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1070 0, /* tp_iter */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1071 0, /* tp_iternext */
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27484 diff changeset	1072 float_methods, /* tp_methods */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1073 0, /* tp_members */
42417 d3a5c796c8ba Changes to long and float by Jeffrey Jasskin to conform to PEP 3141. Guido van Rossum <guido@python.org> parents: 42334 diff changeset	1074 float_getset, /* tp_getset */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1075 0, /* tp_base */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1076 0, /* tp_dict */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1077 0, /* tp_descr_get */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1078 0, /* tp_descr_set */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1079 0, /* tp_dictoffset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1080 0, /* tp_init */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1081 0, /* tp_alloc */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18838 diff changeset	1082 float_new, /* tp_new */
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1083 };
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5504 diff changeset	1084
80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5504 diff changeset	1085 void
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1086 _PyFloat_Init(void)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1087 {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1088 /* We attempt to determine if this machine is using IEEE
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1089 floating point formats by peering at the bits of some
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1090 carefully chosen values. If it looks like we are on an
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1091 IEEE platform, the float packing/unpacking routines can
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1092 just copy bits, if not they resort to arithmetic & shifts
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1093 and masks. The shifts & masks approach works on all finite
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1094 values, but what happens to infinities, NaNs and signed
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1095 zeroes on packing is an accident, and attempting to unpack
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1096 a NaN or an infinity will raise an exception.
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1097
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1098 Note that if we're on some whacked-out platform which uses
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1099 IEEE formats but isn't strictly little-endian or big-
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1100 endian, we will fall back to the portable shifts & masks
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1101 method. */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1102
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1103 #if SIZEOF_DOUBLE == 8
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1104 {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1105 double x = 9006104071832581.0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1106 if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1107 detected_double_format = ieee_big_endian_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1108 else if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1109 detected_double_format = ieee_little_endian_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1110 else
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1111 detected_double_format = unknown_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1112 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1113 #else
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1114 detected_double_format = unknown_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1115 #endif
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1116
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1117 #if SIZEOF_FLOAT == 4
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1118 {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1119 float y = 16711938.0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1120 if (memcmp(&y, "\x4b\x7f\x01\x02", 4) == 0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1121 detected_float_format = ieee_big_endian_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1122 else if (memcmp(&y, "\x02\x01\x7f\x4b", 4) == 0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1123 detected_float_format = ieee_little_endian_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1124 else
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1125 detected_float_format = unknown_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1126 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1127 #else
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1128 detected_float_format = unknown_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1129 #endif
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1130
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1131 double_format = detected_double_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1132 float_format = detected_float_format;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1133 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1134
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1135 void
13454 fcc75a3748f5 ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13447 diff changeset	1136 PyFloat_Fini(void)
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5504 diff changeset	1137 {
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1138 PyFloatObject *p;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1139 PyFloatBlock list, next;
32533 201986d6d9d6 Fix a couple of signed/unsigned comparison warnings Neal Norwitz <nnorwitz@gmail.com> parents: 32305 diff changeset	1140 unsigned i;
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1141 int bc, bf; /* block count, number of freed blocks */
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1142 int frem, fsum; /* remaining unfreed floats per block, total */
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1143
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1144 bc = 0;
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1145 bf = 0;
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1146 fsum = 0;
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1147 list = block_list;
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1148 block_list = NULL;
10432 1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1149 free_list = NULL;
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1150 while (list != NULL) {
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1151 bc++;
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1152 frem = 0;
10432 1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1153 for (i = 0, p = &list->objects[0];
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1154 i < N_FLOATOBJECTS;
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1155 i++, p++) {
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	1156 if (PyFloat_CheckExact(p) && Py_Refcnt(p) != 0)
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1157 frem++;
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1158 }
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1159 next = list->next;
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1160 if (frem) {
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1161 list->next = block_list;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1162 block_list = list;
10432 1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1163 for (i = 0, p = &list->objects[0];
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1164 i < N_FLOATOBJECTS;
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1165 i++, p++) {
19865 f2a3009b528e Replace a few places where X->ob_type was compared to &PyXXX_Type with Guido van Rossum <guido@python.org> parents: 19753 diff changeset	1166 if (!PyFloat_CheckExact(p) \|\|
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	1167 Py_Refcnt(p) == 0) {
e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	1168 Py_Type(p) = (struct _typeobject *)
10432 1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1169 free_list;
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1170 free_list = p;
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1171 }
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1172 }
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1173 }
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1174 else {
12576 1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring. Guido van Rossum <guido@python.org> parents: 12248 diff changeset	1175 PyMem_FREE(list); /* XXX PyObject_FREE ??? */
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1176 bf++;
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1177 }
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1178 fsum += frem;
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1179 list = next;
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1180 }
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1181 if (!Py_VerboseFlag)
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1182 return;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1183 fprintf(stderr, "# cleanup floats");
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1184 if (!fsum) {
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1185 fprintf(stderr, "\n");
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1186 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1187 else {
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1188 fprintf(stderr,
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1189 ": %d unfreed float%s in %d out of %d block%s\n",
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1190 fsum, fsum == 1 ? "" : "s",
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1191 bc - bf, bc, bc == 1 ? "" : "s");
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1192 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1193 if (Py_VerboseFlag > 1) {
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1194 list = block_list;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1195 while (list != NULL) {
10432 1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1196 for (i = 0, p = &list->objects[0];
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1197 i < N_FLOATOBJECTS;
1cc5d20d2ed8 Fix a problem with Vladimir's PyFloat_Fini code: clear the free list; if Guido van Rossum <guido@python.org> parents: 10391 diff changeset	1198 i++, p++) {
19865 f2a3009b528e Replace a few places where X->ob_type was compared to &PyXXX_Type with Guido van Rossum <guido@python.org> parents: 19753 diff changeset	1199 if (PyFloat_CheckExact(p) &&
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	1200 Py_Refcnt(p) != 0) {
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1201 char buf[100];
40527 195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1202 format_float(buf, sizeof(buf), p, PREC_STR);
36759 83b860acfe95 Use %ld and casts to long for refcount printing, in absense of a universally Thomas Wouters <thomas@python.org> parents: 36675 diff changeset	1203 /* XXX(twouters) cast refcount to
83b860acfe95 Use %ld and casts to long for refcount printing, in absense of a universally Thomas Wouters <thomas@python.org> parents: 36675 diff changeset	1204 long until %zd is universally
83b860acfe95 Use %ld and casts to long for refcount printing, in absense of a universally Thomas Wouters <thomas@python.org> parents: 36675 diff changeset	1205 available
83b860acfe95 Use %ld and casts to long for refcount printing, in absense of a universally Thomas Wouters <thomas@python.org> parents: 36675 diff changeset	1206 */
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1207 fprintf(stderr,
36759 83b860acfe95 Use %ld and casts to long for refcount printing, in absense of a universally Thomas Wouters <thomas@python.org> parents: 36675 diff changeset	1208 "# <float at %p, refcnt=%ld, val=%s>\n",
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 42126 diff changeset	1209 p, (long)Py_Refcnt(p), buf);
10391 7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1210 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1211 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now Guido van Rossum <guido@python.org> parents: 10382 diff changeset	1212 list = list->next;
10382 e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1213 }
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error, Guido van Rossum <guido@python.org> parents: 10375 diff changeset	1214 }
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5504 diff changeset	1215 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1216
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1217 /*----------------------------------------------------------------------------
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1218 * _PyFloat_{Pack,Unpack}{4,8}. See floatobject.h.
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1219 *
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1220 * TODO: On platforms that use the standard IEEE-754 single and double
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1221 * formats natively, these routines could simply copy the bytes.
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1222 */
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1223 int
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1224 _PyFloat_Pack4(double x, unsigned char *p, int le)
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1225 {
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1226 if (float_format == unknown_format) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1227 unsigned char sign;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1228 int e;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1229 double f;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1230 unsigned int fbits;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1231 int incr = 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1232
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1233 if (le) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1234 p += 3;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1235 incr = -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1236 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1237
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1238 if (x < 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1239 sign = 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1240 x = -x;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1241 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1242 else
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1243 sign = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1244
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1245 f = frexp(x, &e);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1246
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1247 /* Normalize f to be in the range [1.0, 2.0) */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1248 if (0.5 <= f && f < 1.0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1249 f *= 2.0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1250 e--;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1251 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1252 else if (f == 0.0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1253 e = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1254 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1255 PyErr_SetString(PyExc_SystemError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1256 "frexp() result out of range");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1257 return -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1258 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1259
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1260 if (e >= 128)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1261 goto Overflow;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1262 else if (e < -126) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1263 /* Gradual underflow */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1264 f = ldexp(f, 126 + e);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1265 e = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1266 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1267 else if (!(e == 0 && f == 0.0)) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1268 e += 127;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1269 f -= 1.0; /* Get rid of leading 1 */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1270 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1271
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1272 f = 8388608.0; / 2*23 /
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1273 fbits = (unsigned int)(f + 0.5); /* Round */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1274 assert(fbits <= 8388608);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1275 if (fbits >> 23) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1276 /* The carry propagated out of a string of 23 1 bits. */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1277 fbits = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1278 ++e;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1279 if (e >= 255)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1280 goto Overflow;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1281 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1282
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1283 /* First byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1284 *p = (sign << 7) \| (e >> 1);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1285 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1286
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1287 /* Second byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1288 *p = (char) (((e & 1) << 7) \| (fbits >> 16));
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1289 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1290
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1291 /* Third byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1292 *p = (fbits >> 8) & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1293 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1294
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1295 /* Fourth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1296 *p = fbits & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1297
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1298 /* Done */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1299 return 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1300
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1301 Overflow:
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1302 PyErr_SetString(PyExc_OverflowError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1303 "float too large to pack with f format");
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1304 return -1;
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1305 }
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1306 else {
35178 cf7a849ce61f Apparently some compiler gives a warning on Michael W. Hudson <mwh@python.net> parents: 34972 diff changeset	1307 float y = (float)x;
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1308 const char s = (char)&y;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1309 int i, incr = 1;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1310
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1311 if ((float_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1312 \|\| (float_format == ieee_big_endian_format && le)) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1313 p += 3;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1314 incr = -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1315 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1316
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1317 for (i = 0; i < 4; i++) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1318 p = s++;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1319 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1320 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1321 return 0;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1322 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1323 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1324
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1325 int
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1326 _PyFloat_Pack8(double x, unsigned char *p, int le)
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1327 {
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1328 if (double_format == unknown_format) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1329 unsigned char sign;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1330 int e;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1331 double f;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1332 unsigned int fhi, flo;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1333 int incr = 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1334
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1335 if (le) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1336 p += 7;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1337 incr = -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1338 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1339
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1340 if (x < 0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1341 sign = 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1342 x = -x;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1343 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1344 else
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1345 sign = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1346
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1347 f = frexp(x, &e);
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1348
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1349 /* Normalize f to be in the range [1.0, 2.0) */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1350 if (0.5 <= f && f < 1.0) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1351 f *= 2.0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1352 e--;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1353 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1354 else if (f == 0.0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1355 e = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1356 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1357 PyErr_SetString(PyExc_SystemError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1358 "frexp() result out of range");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1359 return -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1360 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1361
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1362 if (e >= 1024)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1363 goto Overflow;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1364 else if (e < -1022) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1365 /* Gradual underflow */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1366 f = ldexp(f, 1022 + e);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1367 e = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1368 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1369 else if (!(e == 0 && f == 0.0)) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1370 e += 1023;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1371 f -= 1.0; /* Get rid of leading 1 */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1372 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1373
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1374 /* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1375 f = 268435456.0; / 2*28 /
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1376 fhi = (unsigned int)f; /* Truncate */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1377 assert(fhi < 268435456);
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1378
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1379 f -= (double)fhi;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1380 f = 16777216.0; / 2*24 /
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1381 flo = (unsigned int)(f + 0.5); /* Round */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1382 assert(flo <= 16777216);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1383 if (flo >> 24) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1384 /* The carry propagated out of a string of 24 1 bits. */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1385 flo = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1386 ++fhi;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1387 if (fhi >> 28) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1388 /* And it also progagated out of the next 28 bits. */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1389 fhi = 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1390 ++e;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1391 if (e >= 2047)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1392 goto Overflow;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1393 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1394 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1395
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1396 /* First byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1397 *p = (sign << 7) \| (e >> 4);
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1398 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1399
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1400 /* Second byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1401 *p = (unsigned char) (((e & 0xF) << 4) \| (fhi >> 24));
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1402 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1403
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1404 /* Third byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1405 *p = (fhi >> 16) & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1406 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1407
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1408 /* Fourth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1409 *p = (fhi >> 8) & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1410 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1411
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1412 /* Fifth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1413 *p = fhi & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1414 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1415
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1416 /* Sixth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1417 *p = (flo >> 16) & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1418 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1419
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1420 /* Seventh byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1421 *p = (flo >> 8) & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1422 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1423
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1424 /* Eighth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1425 *p = flo & 0xFF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1426 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1427
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1428 /* Done */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1429 return 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1430
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1431 Overflow:
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1432 PyErr_SetString(PyExc_OverflowError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1433 "float too large to pack with d format");
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1434 return -1;
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1435 }
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1436 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1437 const char s = (char)&x;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1438 int i, incr = 1;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1439
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1440 if ((double_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1441 \|\| (double_format == ieee_big_endian_format && le)) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1442 p += 7;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1443 incr = -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1444 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1445
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1446 for (i = 0; i < 8; i++) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1447 p = s++;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1448 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1449 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1450 return 0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1451 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1452 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1453
40527 195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1454 /* Should only be used by marshal. */
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1455 int
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1456 _PyFloat_Repr(double x, char *p, size_t len)
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1457 {
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1458 format_double(p, len, x, PREC_REPR);
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1459 return (int)strlen(p);
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1460 }
195f689af5af Remove PyFloat_AsReprString() and PyFloat_AsString() which should not Neal Norwitz <nnorwitz@gmail.com> parents: 40401 diff changeset	1461
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1462 double
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1463 _PyFloat_Unpack4(const unsigned char *p, int le)
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1464 {
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1465 if (float_format == unknown_format) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1466 unsigned char sign;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1467 int e;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1468 unsigned int f;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1469 double x;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1470 int incr = 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1471
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1472 if (le) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1473 p += 3;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1474 incr = -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1475 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1476
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1477 /* First byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1478 sign = (*p >> 7) & 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1479 e = (*p & 0x7F) << 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1480 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1481
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1482 /* Second byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1483 e \|= (*p >> 7) & 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1484 f = (*p & 0x7F) << 16;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1485 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1486
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1487 if (e == 255) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1488 PyErr_SetString(
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1489 PyExc_ValueError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1490 "can't unpack IEEE 754 special value "
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1491 "on non-IEEE platform");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1492 return -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1493 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1494
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1495 /* Third byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1496 f \|= *p << 8;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1497 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1498
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1499 /* Fourth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1500 f \|= *p;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1501
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1502 x = (double)f / 8388608.0;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1503
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1504 /* XXX This sadly ignores Inf/NaN issues */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1505 if (e == 0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1506 e = -126;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1507 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1508 x += 1.0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1509 e -= 127;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1510 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1511 x = ldexp(x, e);
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1512
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1513 if (sign)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1514 x = -x;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1515
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1516 return x;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1517 }
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1518 else {
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1519 float x;
8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1520
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1521 if ((float_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1522 \|\| (float_format == ieee_big_endian_format && le)) {
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1523 char buf[4];
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1524 char *d = &buf[3];
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1525 int i;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1526
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1527 for (i = 0; i < 4; i++) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1528 d-- = p++;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1529 }
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1530 memcpy(&x, buf, 4);
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1531 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1532 else {
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1533 memcpy(&x, p, 4);
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1534 }
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1535
8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1536 return x;
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1537 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1538 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1539
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1540 double
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1541 _PyFloat_Unpack8(const unsigned char *p, int le)
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1542 {
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1543 if (double_format == unknown_format) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1544 unsigned char sign;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1545 int e;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1546 unsigned int fhi, flo;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1547 double x;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1548 int incr = 1;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1549
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1550 if (le) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1551 p += 7;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1552 incr = -1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1553 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1554
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1555 /* First byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1556 sign = (*p >> 7) & 1;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1557 e = (*p & 0x7F) << 4;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1558
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1559 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1560
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1561 /* Second byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1562 e \|= (*p >> 4) & 0xF;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1563 fhi = (*p & 0xF) << 24;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1564 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1565
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1566 if (e == 2047) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1567 PyErr_SetString(
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1568 PyExc_ValueError,
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1569 "can't unpack IEEE 754 special value "
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1570 "on non-IEEE platform");
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1571 return -1.0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1572 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1573
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1574 /* Third byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1575 fhi \|= *p << 16;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1576 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1577
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1578 /* Fourth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1579 fhi \|= *p << 8;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1580 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1581
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1582 /* Fifth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1583 fhi \|= *p;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1584 p += incr;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1585
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1586 /* Sixth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1587 flo = *p << 16;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1588 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1589
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1590 /* Seventh byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1591 flo \|= *p << 8;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1592 p += incr;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1593
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1594 /* Eighth byte */
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1595 flo \|= *p;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1596
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1597 x = (double)fhi + (double)flo / 16777216.0; /* 2*24 /
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1598 x /= 268435456.0; /* 2*28 /
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1599
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1600 if (e == 0)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1601 e = -1022;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1602 else {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1603 x += 1.0;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1604 e -= 1023;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1605 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1606 x = ldexp(x, e);
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1607
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1608 if (sign)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1609 x = -x;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1610
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1611 return x;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1612 }
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1613 else {
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1614 double x;
8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1615
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1616 if ((double_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1617 \|\| (double_format == ieee_big_endian_format && le)) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1618 char buf[8];
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1619 char *d = &buf[7];
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1620 int i;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1621
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1622 for (i = 0; i < 8; i++) {
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1623 d-- = p++;
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1624 }
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1625 memcpy(&x, buf, 8);
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1626 }
1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1627 else {
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1628 memcpy(&x, p, 8);
34972 1dd8a0d64432 This is my patch: Michael W. Hudson <mwh@python.net> parents: 34931 diff changeset	1629 }
35987 8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1630
8eda1a58a490 Fix bug Michael W. Hudson <mwh@python.net> parents: 35178 diff changeset	1631 return x;
28335 70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1632 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	1633 }

Mercurial > cpython-lru_cache-weakref

annotate Objects/floatobject.c @ 42477:e7fd327e0c19