Mercurial > cpython-lru_cache-weakref

annotate Objects/floatobject.c @ 44825:ef859cd754a7 legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixed a wrong assumption in configure.in and Include/pyport.h. The is finite function is not called isfinite() but finite(). Sorry, my fault. :)
author Christian Heimes <christian@cheimes.de>
date Sun, 20 Jan 2008 14:28:28 +0000
parents d66e5837aa57
children 12099143724f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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"
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
8 #include "structseq.h"
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
9
86
a6934380c6e7 "Compiling" version
Guido van Rossum <guido@python.org>
parents: 60
diff changeset
10 #include <ctype.h>
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
11 #include <float.h>
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
12
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
13
30979
86fdf8fe7f17 Getting rid of all the code inside #ifdef macintosh too.
Jack Jansen <jack.jansen@cwi.nl>
parents: 29641
diff changeset
14 #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
15 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
16 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
17 #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
18
5504
c88b9b868995 Faster floating point allocator, same idea as the int allocator.
Guido van Rossum <guido@python.org>
parents: 5396
diff changeset
19 /* 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
20 #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
21 #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
22 #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
23
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
24 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
25 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
26 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
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
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
29 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
30
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
31 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
32 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
33
5504
c88b9b868995 Faster floating point allocator, same idea as the int allocator.
Guido van Rossum <guido@python.org>
parents: 5396
diff changeset
34 static PyFloatObject *
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
35 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
36 {
c88b9b868995 Faster floating point allocator, same idea as the int allocator.
Guido van Rossum <guido@python.org>
parents: 5396
diff changeset
37 PyFloatObject *p, *q;
12576
1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring.
Guido van Rossum <guido@python.org>
parents: 12248
diff changeset
38 /* 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
39 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
40 if (p == NULL)
12576
1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring.
Guido van Rossum <guido@python.org>
parents: 12248
diff changeset
41 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
42 ((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
43 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
44 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
45 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
46 while (--q > p)
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
47 Py_TYPE(q) = (struct _typeobject *)(q-1);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
48 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
49 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
50 }
c88b9b868995 Faster floating point allocator, same idea as the int allocator.
Guido van Rossum <guido@python.org>
parents: 5396
diff changeset
51
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
52 double
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
53 PyFloat_GetMax(void)
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
54 {
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
55 return DBL_MAX;
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
56 }
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
57
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
58 double
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
59 PyFloat_GetMin(void)
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
60 {
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
61 return DBL_MIN;
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
62 }
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
63
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
64 static PyTypeObject FloatInfoType = {0};
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
65
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
66 PyDoc_STRVAR(floatinfo__doc__,
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
67 "sys.floatinfo\n\
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
68 \n\
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
69 A structseq holding information about the float type. It contains low level\n\
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
70 information about the precision and internal representation. Please study\n\
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
71 your system's :file:`float.h` for more information.");
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
72
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
73 static PyStructSequence_Field floatinfo_fields[] = {
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
74 {"max", "DBL_MAX -- maximum representable finite float"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
75 {"max_exp", "DBL_MAX_EXP -- maximum int e such that radix**(e-1) "
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
76 "is representable"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
77 {"max_10_exp", "DBL_MAX_10_EXP -- maximum int e such that 10**e "
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
78 "is representable"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
79 {"min", "DBL_MIN -- Minimum positive normalizer float"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
80 {"min_exp", "DBL_MIN_EXP -- minimum int e such that radix**(e-1) "
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
81 "is a normalized float"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
82 {"min_10_exp", "DBL_MIN_10_EXP -- minimum int e such that 10**e is "
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
83 "a normalized"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
84 {"dig", "DBL_DIG -- digits"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
85 {"mant_dig", "DBL_MANT_DIG -- mantissa digits"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
86 {"epsilon", "DBL_EPSILON -- Difference between 1 and the next "
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
87 "representable float"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
88 {"radix", "FLT_RADIX -- radix of exponent"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
89 {"rounds", "FLT_ROUNDS -- addition rounds"},
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
90 {0}
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
91 };
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
92
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
93 static PyStructSequence_Desc floatinfo_desc = {
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
94 "sys.floatinfo", /* name */
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
95 floatinfo__doc__, /* doc */
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
96 floatinfo_fields, /* fields */
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
97 11
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
98 };
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
99
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
100 PyObject *
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
101 PyFloat_GetInfo(void)
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
102 {
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
103 static PyObject* floatinfo;
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
104 int pos = 0;
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
105
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
106 if (floatinfo != NULL) {
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
107 Py_INCREF(floatinfo);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
108 return floatinfo;
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
109 }
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
110 PyStructSequence_InitType(&FloatInfoType, &floatinfo_desc);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
111
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
112 floatinfo = PyStructSequence_New(&FloatInfoType);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
113 if (floatinfo == NULL) {
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
114 return NULL;
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
115 }
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
116
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
117 #define SetIntFlag(flag) \
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
118 PyStructSequence_SET_ITEM(floatinfo, pos++, PyInt_FromLong(flag))
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
119 #define SetDblFlag(flag) \
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
120 PyStructSequence_SET_ITEM(floatinfo, pos++, PyFloat_FromDouble(flag))
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
121
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
122 SetDblFlag(DBL_MAX);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
123 SetIntFlag(DBL_MAX_EXP);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
124 SetIntFlag(DBL_MAX_10_EXP);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
125 SetDblFlag(DBL_MIN);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
126 SetIntFlag(DBL_MIN_EXP);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
127 SetIntFlag(DBL_MIN_10_EXP);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
128 SetIntFlag(DBL_DIG);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
129 SetIntFlag(DBL_MANT_DIG);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
130 SetDblFlag(DBL_EPSILON);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
131 SetIntFlag(FLT_RADIX);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
132 SetIntFlag(FLT_ROUNDS);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
133 #undef SetIntFlag
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
134 #undef SetDblFlag
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
135
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
136 if (PyErr_Occurred()) {
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
137 Py_CLEAR(floatinfo);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
138 return NULL;
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
139 }
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
140
44670
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
141 Py_INCREF(floatinfo);
d66e5837aa57 Now that I've learnt about structseq objects I felt like converting sys.float_info to a structseq. It's
Christian Heimes <christian@cheimes.de>
parents: 44488
diff changeset
142 return floatinfo;
44085
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
143 }
c218d1ac916e Feature #1534
Christian Heimes <christian@cheimes.de>
parents: 43378
diff changeset
144
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
145 PyObject *
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
146 PyFloat_FromDouble(double fval)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
147 {
5504
c88b9b868995 Faster floating point allocator, same idea as the int allocator.
Guido van Rossum <guido@python.org>
parents: 5396
diff changeset
148 register PyFloatObject *op;
c88b9b868995 Faster floating point allocator, same idea as the int allocator.
Guido van Rossum <guido@python.org>
parents: 5396
diff changeset
149 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
150 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
151 return NULL;
c88b9b868995 Faster floating point allocator, same idea as the int allocator.
Guido van Rossum <guido@python.org>
parents: 5396
diff changeset
152 }
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
153 /* 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
154 op = free_list;
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
155 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
156 PyObject_INIT(op, &PyFloat_Type);
27
82c7bab78bb1 New errors.
Guido van Rossum <guido@python.org>
parents: 6
diff changeset
157 op->ob_fval = fval;
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
158 return (PyObject *) op;
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
159 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
160
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
161 /**************************************************************************
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
162 RED_FLAG 22-Sep-2000 tim
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
163 PyFloat_FromString's pend argument is braindead. Prior to this RED_FLAG,
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
164
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
165 1. If v was a regular string, *pend was set to point to its terminating
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
166 null byte. That's useless (the caller can find that without any
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
167 help from this function!).
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
168
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
169 2. If v was a Unicode string, or an object convertible to a character
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
170 buffer, *pend was set to point into stack trash (the auto temp
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
171 vector holding the character buffer). That was downright dangerous.
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
172
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
173 Since we can't change the interface of a public API function, pend is
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
174 still supported but now *officially* useless: if pend is not NULL,
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
175 *pend is set to NULL.
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
176 **************************************************************************/
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
177 PyObject *
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
178 PyFloat_FromString(PyObject *v, char **pend)
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
179 {
44344
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
180 const char *s, *last, *end, *sp;
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
181 double x;
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
182 char buffer[256]; /* for errors */
19343
7257e87e0720 Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents: 19051
diff changeset
183 #ifdef Py_USING_UNICODE
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
184 char s_buffer[256]; /* for objects convertible to a char buffer */
19343
7257e87e0720 Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents: 19051
diff changeset
185 #endif
36501
7fdc639bc5b4 Merge ssize_t branch.
Martin v. Löwis <martin@v.loewis.de>
parents: 36235
diff changeset
186 Py_ssize_t len;
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
187
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
188 if (pend)
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
189 *pend = NULL;
11969
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
190 if (PyString_Check(v)) {
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
191 s = PyString_AS_STRING(v);
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
192 len = PyString_GET_SIZE(v);
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
193 }
19343
7257e87e0720 Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents: 19051
diff changeset
194 #ifdef Py_USING_UNICODE
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
195 else if (PyUnicode_Check(v)) {
37815
20cb13bdf1f0 C++ compiler cleanup: bunch-o-casts, plus use of unsigned loop index var in a couple places
Skip Montanaro <skip@pobox.com>
parents: 37589
diff changeset
196 if (PyUnicode_GET_SIZE(v) >= (Py_ssize_t)sizeof(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
197 PyErr_SetString(PyExc_ValueError,
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
198 "Unicode float() literal too long to convert");
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
199 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
200 }
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
201 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
202 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
203 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
204 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
205 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
206 s = s_buffer;
36501
7fdc639bc5b4 Merge ssize_t branch.
Martin v. Löwis <martin@v.loewis.de>
parents: 36235
diff changeset
207 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
208 }
19343
7257e87e0720 Patch #445762: Support --disable-unicode
Martin v. Löwis <martin@v.loewis.de>
parents: 19051
diff changeset
209 #endif
11969
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
210 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
211 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
212 "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
213 return NULL;
11969
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
214 }
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
215
11969
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
216 last = s + len;
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
217 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
218 s++;
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
219 if (*s == '\0') {
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
220 PyErr_SetString(PyExc_ValueError, "empty string for float()");
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
221 return NULL;
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
222 }
44344
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
223 sp = s;
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
224 /* 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
225 * 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
226 * 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
227 * 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
228 * 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
229 * key off errno.
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
230 */
14851
5449302c4d2e Replace SIGFPE paranoia around strtod and atof. I don't believe these
Tim Peters <tim.peters@gmail.com>
parents: 14783
diff changeset
231 PyFPE_START_PROTECT("strtod", return NULL)
32305
13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic.
Martin v. Löwis <martin@v.loewis.de>
parents: 32150
diff changeset
232 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
233 PyFPE_END_PROTECT(x)
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
234 errno = 0;
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
235 /* 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
236 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
237 if (end > last)
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
238 end = last;
44344
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
239 /* Check for inf and nan. This is done late because it rarely happens. */
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
240 if (end == s) {
44344
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
241 char *p = (char*)sp;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
242 int sign = 1;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
243
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
244 if (*p == '-') {
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
245 sign = -1;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
246 p++;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
247 }
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
248 if (*p == '+') {
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
249 p++;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
250 }
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
251 if (PyOS_strnicmp(p, "inf", 4) == 0) {
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
252 return PyFloat_FromDouble(sign * Py_HUGE_VAL);
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
253 }
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
254 #ifdef Py_NAN
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
255 if(PyOS_strnicmp(p, "nan", 4) == 0) {
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
256 return PyFloat_FromDouble(Py_NAN);
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
257 }
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
258 #endif
21079
8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for
Barry Warsaw <barry@python.org>
parents: 20829
diff changeset
259 PyOS_snprintf(buffer, sizeof(buffer),
8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for
Barry Warsaw <barry@python.org>
parents: 20829
diff changeset
260 "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
261 PyErr_SetString(PyExc_ValueError, buffer);
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
262 return NULL;
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
263 }
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
264 /* 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
265 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
266 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
267 end++;
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
268 if (*end != '\0') {
21079
8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for
Barry Warsaw <barry@python.org>
parents: 20829
diff changeset
269 PyOS_snprintf(buffer, sizeof(buffer),
8cef75cacb01 PyFloat_FromString(): Conversion of sprintf() to PyOS_snprintf() for
Barry Warsaw <barry@python.org>
parents: 20829
diff changeset
270 "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
271 PyErr_SetString(PyExc_ValueError, buffer);
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
272 return NULL;
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
273 }
11969
74b7213fb609 Many changes for Unicode, by Marc-Andre Lemburg.
Guido van Rossum <guido@python.org>
parents: 11673
diff changeset
274 else if (end != last) {
11383
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
275 PyErr_SetString(PyExc_ValueError,
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
276 "null byte in argument for float()");
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
277 return NULL;
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
278 }
14783
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
279 if (x == 0.0) {
77eddddbb7cc Fix for SF bug 110624: float literals behave inconsistently.
Tim Peters <tim.peters@gmail.com>
parents: 14616
diff changeset
280 /* 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
281 about denorms. */
14851
5449302c4d2e Replace SIGFPE paranoia around strtod and atof. I don't believe these
Tim Peters <tim.peters@gmail.com>
parents: 14783
diff changeset
282 PyFPE_START_PROTECT("atof", return NULL)
32305
13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic.
Martin v. Löwis <martin@v.loewis.de>
parents: 32150
diff changeset
283 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
284 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
285 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
286 }
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
287 return PyFloat_FromDouble(x);
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
288 }
aca7b5eaf5e8 Mainlining the string_methods branch. See branch revision log
Barry Warsaw <barry@python.org>
parents: 10833
diff changeset
289
1313
6ee380349c84 * Added gmtime/localtime/mktime and SYSV timezone globals to timemodule.c.
Guido van Rossum <guido@python.org>
parents: 1271
diff changeset
290 static void
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
291 float_dealloc(PyFloatObject *op)
745
c7b23cc8cded answer lint's complaints
Guido van Rossum <guido@python.org>
parents: 632
diff changeset
292 {
20277
2983b54256c7 Enable GC for new-style instances. This touches lots of files, since
Guido van Rossum <guido@python.org>
parents: 19976
diff changeset
293 if (PyFloat_CheckExact(op)) {
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
294 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
295 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
296 }
2983b54256c7 Enable GC for new-style instances. This touches lots of files, since
Guido van Rossum <guido@python.org>
parents: 19976
diff changeset
297 else
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
298 Py_TYPE(op)->tp_free((PyObject *)op);
745
c7b23cc8cded answer lint's complaints
Guido van Rossum <guido@python.org>
parents: 632
diff changeset
299 }
c7b23cc8cded answer lint's complaints
Guido van Rossum <guido@python.org>
parents: 632
diff changeset
300
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
301 double
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
302 PyFloat_AsDouble(PyObject *op)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
303 {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
304 PyNumberMethods *nb;
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
305 PyFloatObject *fo;
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1347
diff changeset
306 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
307
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
308 if (op && PyFloat_Check(op))
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
309 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
310
26272
fbccef8b3153 Improve exception message raised by PyFloat_AsDouble if the object does not
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 24898
diff changeset
311 if (op == NULL) {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
312 PyErr_BadArgument();
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
313 return -1;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
314 }
20823
c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0.
Tim Peters <tim.peters@gmail.com>
parents: 20654
diff changeset
315
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
316 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
317 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
318 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
319 }
fbccef8b3153 Improve exception message raised by PyFloat_AsDouble if the object does not
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 24898
diff changeset
320
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
321 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
322 if (fo == NULL)
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1347
diff changeset
323 return -1;
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
324 if (!PyFloat_Check(fo)) {
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
325 PyErr_SetString(PyExc_TypeError,
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
326 "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
327 return -1;
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1347
diff changeset
328 }
20823
c7aa332a2ffa SF bug #477221: abs and divmod act oddly with -0.0.
Tim Peters <tim.peters@gmail.com>
parents: 20654
diff changeset
329
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
330 val = PyFloat_AS_DOUBLE(fo);
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
331 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
332
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1347
diff changeset
333 return val;
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
334 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
335
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
336 /* Methods */
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
337
21097
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
338 static void
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
339 format_float(char *buf, size_t buflen, PyFloatObject *v, int precision)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
340 {
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
341 register char *cp;
32305
13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic.
Martin v. Löwis <martin@v.loewis.de>
parents: 32150
diff changeset
342 char format[32];
44344
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
343 int i;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
344
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
345 /* Subroutine for float_repr and float_print.
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
346 We want float numbers to be recognizable as such,
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
347 i.e., they should contain a decimal point or an exponent.
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
348 However, %g may print the number as an integer;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
349 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
350
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
351 assert(PyFloat_Check(v));
32305
13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic.
Martin v. Löwis <martin@v.loewis.de>
parents: 32150
diff changeset
352 PyOS_snprintf(format, 32, "%%.%ig", precision);
13656d58d450 Patch #774665: Make Python LC_NUMERIC agnostic.
Martin v. Löwis <martin@v.loewis.de>
parents: 32150
diff changeset
353 PyOS_ascii_formatd(buf, buflen, format, v->ob_fval);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
354 cp = buf;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
355 if (*cp == '-')
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
356 cp++;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
357 for (; *cp != '\0'; cp++) {
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
358 /* Any non-digit means it's not an integer;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
359 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
360 if (!isdigit(Py_CHARMASK(*cp)))
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
361 break;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
362 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
363 if (*cp == '\0') {
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
364 *cp++ = '.';
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
365 *cp++ = '0';
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
366 *cp++ = '\0';
44344
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
367 return;
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
368 }
44344
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
369 /* Checking the next three chars should be more than enough to
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
370 * detect inf or nan, even on Windows. We check for inf or nan
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
371 * at last because they are rare cases.
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
372 */
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
373 for (i=0; *cp != '\0' && i<3; cp++, i++) {
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
374 if (isdigit(Py_CHARMASK(*cp)) || *cp == '.')
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
375 continue;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
376 /* found something that is neither a digit nor point
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
377 * it might be a NaN or INF
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
378 */
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
379 #ifdef Py_NAN
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
380 if (Py_IS_NAN(v->ob_fval)) {
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
381 strcpy(buf, "nan");
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
382 }
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
383 else
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
384 #endif
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
385 if (Py_IS_INFINITY(v->ob_fval)) {
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
386 cp = buf;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
387 if (*cp == '-')
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
388 cp++;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
389 strcpy(cp, "inf");
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
390 }
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
391 break;
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
392 }
1d69aabf6f7f Applied patch #1635: Float patch for inf and nan on Windows (and other platforms).
Christian Heimes <christian@cheimes.de>
parents: 44267
diff changeset
393
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
394 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
395
21097
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
396 /* XXX PyFloat_AsStringEx should not be a public API function (for one
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
397 XXX thing, its signature passes a buffer without a length; for another,
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
398 XXX it isn't useful outside this file).
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
399 */
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
400 void
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
401 PyFloat_AsStringEx(char *buf, PyFloatObject *v, int precision)
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
402 {
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
403 format_float(buf, 100, v, precision);
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
404 }
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
405
44267
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
406 #ifdef Py_BROKEN_REPR
44262
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
407 /* The following function is based on Tcl_PrintDouble,
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
408 * from tclUtil.c.
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
409 */
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
410
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
411 #define is_infinite(d) ( (d) > DBL_MAX || (d) < -DBL_MAX )
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
412 #define is_nan(d) ((d) != (d))
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
413
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
414 static void
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
415 format_double_repr(char *dst, double value)
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
416 {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
417 char *p, c;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
418 int exp;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
419 int signum;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
420 char buffer[30];
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
421
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
422 /*
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
423 * Handle NaN.
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
424 */
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
425
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
426 if (is_nan(value)) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
427 strcpy(dst, "nan");
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
428 return;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
429 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
430
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
431 /*
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
432 * Handle infinities.
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
433 */
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
434
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
435 if (is_infinite(value)) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
436 if (value < 0) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
437 strcpy(dst, "-inf");
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
438 } else {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
439 strcpy(dst, "inf");
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
440 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
441 return;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
442 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
443
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
444 /*
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
445 * Ordinary (normal and denormal) values.
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
446 */
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
447
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
448 exp = _PyFloat_Digits(buffer, value, &signum)+1;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
449 if (signum) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
450 *dst++ = '-';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
451 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
452 p = buffer;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
453 if (exp < -3 || exp > 17) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
454 /*
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
455 * E format for numbers < 1e-3 or >= 1e17.
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
456 */
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
457
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
458 *dst++ = *p++;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
459 c = *p;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
460 if (c != '\0') {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
461 *dst++ = '.';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
462 while (c != '\0') {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
463 *dst++ = c;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
464 c = *++p;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
465 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
466 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
467 sprintf(dst, "e%+d", exp-1);
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
468 } else {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
469 /*
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
470 * F format for others.
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
471 */
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
472
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
473 if (exp <= 0) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
474 *dst++ = '0';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
475 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
476 c = *p;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
477 while (exp-- > 0) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
478 if (c != '\0') {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
479 *dst++ = c;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
480 c = *++p;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
481 } else {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
482 *dst++ = '0';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
483 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
484 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
485 *dst++ = '.';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
486 if (c == '\0') {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
487 *dst++ = '0';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
488 } else {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
489 while (++exp < 0) {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
490 *dst++ = '0';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
491 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
492 while (c != '\0') {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
493 *dst++ = c;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
494 c = *++p;
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
495 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
496 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
497 *dst++ = '\0';
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
498 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
499 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
500
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
501 static void
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
502 format_float_repr(char *buf, PyFloatObject *v)
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
503 {
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
504 assert(PyFloat_Check(v));
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
505 format_double_repr(buf, PyFloat_AS_DOUBLE(v));
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
506 }
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
507
44267
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
508 #endif /* Py_BROKEN_REPR */
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
509
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
510 /* 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
511 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
512 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
513 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
514 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
515 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
516 */
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
517 #define CONVERT_TO_DOUBLE(obj, dbl) \
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
518 if (PyFloat_Check(obj)) \
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
519 dbl = PyFloat_AS_DOUBLE(obj); \
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
520 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
521 return obj;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
522
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
523 static int
19674
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of
Tim Peters <tim.peters@gmail.com>
parents: 19673
diff changeset
524 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
525 {
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
526 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
527
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
528 if (PyInt_Check(obj)) {
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
529 *dbl = (double)PyInt_AS_LONG(obj);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
530 }
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
531 else if (PyLong_Check(obj)) {
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
532 *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
533 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
534 *v = NULL;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of
Tim Peters <tim.peters@gmail.com>
parents: 19673
diff changeset
535 return -1;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of
Tim Peters <tim.peters@gmail.com>
parents: 19673
diff changeset
536 }
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
537 }
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
538 else {
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
539 Py_INCREF(Py_NotImplemented);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
540 *v = Py_NotImplemented;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
541 return -1;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
542 }
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
543 return 0;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
544 }
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
545
11631
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
546 /* 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
547
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
548 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
549 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
550 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
551 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
552 hardware.
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
553
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
554 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
555 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
556 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
557
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
558 */
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
559
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
560 #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
561 #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
562
21097
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
563 /* XXX PyFloat_AsString and PyFloat_AsReprString should be deprecated:
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
564 XXX they pass a char buffer without passing a length.
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
565 */
11631
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
566 void
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
567 PyFloat_AsString(char *buf, 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
568 {
21097
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
569 format_float(buf, 100, v, PREC_STR);
11631
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
570 }
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
571
17707
fe4c1034b480 SF bug #422177: Results from .pyc differs from .py
Tim Peters <tim.peters@gmail.com>
parents: 17029
diff changeset
572 void
fe4c1034b480 SF bug #422177: Results from .pyc differs from .py
Tim Peters <tim.peters@gmail.com>
parents: 17029
diff changeset
573 PyFloat_AsReprString(char *buf, PyFloatObject *v)
fe4c1034b480 SF bug #422177: Results from .pyc differs from .py
Tim Peters <tim.peters@gmail.com>
parents: 17029
diff changeset
574 {
21097
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
575 format_float(buf, 100, v, PREC_REPR);
17707
fe4c1034b480 SF bug #422177: Results from .pyc differs from .py
Tim Peters <tim.peters@gmail.com>
parents: 17029
diff changeset
576 }
fe4c1034b480 SF bug #422177: Results from .pyc differs from .py
Tim Peters <tim.peters@gmail.com>
parents: 17029
diff changeset
577
745
c7b23cc8cded answer lint's complaints
Guido van Rossum <guido@python.org>
parents: 632
diff changeset
578 /* ARGSUSED */
284
6ac402023cac printobject now returns an error code
Guido van Rossum <guido@python.org>
parents: 268
diff changeset
579 static int
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
580 float_print(PyFloatObject *v, FILE *fp, int flags)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
581 {
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
582 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
583 format_float(buf, sizeof(buf), v,
9ba3c82946b8 PyFloat_AsStringEx(): This function takes an output char* but doesn't
Tim Peters <tim.peters@gmail.com>
parents: 21079
diff changeset
584 (flags & Py_PRINT_RAW) ? PREC_STR : PREC_REPR);
43378
7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for
Brett Cannon <bcannon@gmail.com>
parents: 42333
diff changeset
585 Py_BEGIN_ALLOW_THREADS
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
586 fputs(buf, fp);
43378
7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for
Brett Cannon <bcannon@gmail.com>
parents: 42333
diff changeset
587 Py_END_ALLOW_THREADS
284
6ac402023cac printobject now returns an error code
Guido van Rossum <guido@python.org>
parents: 268
diff changeset
588 return 0;
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
589 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
590
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
591 static PyObject *
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
592 float_repr(PyFloatObject *v)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
593 {
44267
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
594 #ifdef Py_BROKEN_REPR
44262
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
595 char buf[30];
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
596 format_float_repr(buf, v);
44267
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
597 #else
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
598 char buf[100];
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
599 format_float(buf, sizeof(buf), v, PREC_REPR);
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
600 #endif
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
601
11631
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
602 return PyString_FromString(buf);
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
603 }
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
604
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
605 static PyObject *
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
606 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
607 {
cf7a0f1b7b48 Implement the other easy thing: repr() of a float now uses %.17g,
Guido van Rossum <guido@python.org>
parents: 11383
diff changeset
608 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
609 format_float(buf, sizeof(buf), v, PREC_STR);
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
610 return PyString_FromString(buf);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
611 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
612
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
613 /* 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
614 * 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
615 * 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
616 * 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
617 * 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
618 * 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
619 * 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
620 * 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
621 * 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
622 * 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
623 * 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
624 * 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
625 * 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
626 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
627
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
628 static PyObject*
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
629 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
630 {
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
631 double i, j;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
632 int r = 0;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
633
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
634 assert(PyFloat_Check(v));
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
635 i = PyFloat_AS_DOUBLE(v);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
636
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
637 /* 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
638 * 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
639 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
640 if (PyFloat_Check(w))
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
641 j = PyFloat_AS_DOUBLE(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
642
38293
688f25757104 Added a new macro, Py_IS_FINITE(X). On windows there is an intrinsic for this and it is more efficient than to use !Py_IS_INFINITE(X) && !Py_IS_NAN(X). No change on other platforms
Kristján Valur Jónsson <kristjan@ccpgames.com>
parents: 37815
diff changeset
643 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
644 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
645 /* 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
646 * 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
647 * 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
648 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
649 j = 0.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
650 else
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
651 goto Unimplemented;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
652 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
653
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
654 else if (PyInt_Check(w)) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
655 long jj = PyInt_AS_LONG(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
656 /* In the worst realistic case I can imagine, C double is a
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
657 * Cray single with 48 bits of precision, and long has 64
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
658 * bits.
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
659 */
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
660 #if SIZEOF_LONG > 6
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
661 unsigned long abs = (unsigned long)(jj < 0 ? -jj : jj);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
662 if (abs >> 48) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
663 /* Needs more than 48 bits. Make it take the
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
664 * PyLong path.
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
665 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
666 PyObject *result;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
667 PyObject *ww = PyLong_FromLong(jj);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
668
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
669 if (ww == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
670 return NULL;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
671 result = float_richcompare(v, ww, op);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
672 Py_DECREF(ww);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
673 return result;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
674 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
675 #endif
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
676 j = (double)jj;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
677 assert((long)j == jj);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
678 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
679
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
680 else if (PyLong_Check(w)) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
681 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
682 int wsign = _PyLong_Sign(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
683 size_t nbits;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
684 int exponent;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
685
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
686 if (vsign != wsign) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
687 /* Magnitudes are irrelevant -- the signs alone
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
688 * determine the outcome.
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
689 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
690 i = (double)vsign;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
691 j = (double)wsign;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
692 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
693 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
694 /* The signs are the same. */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
695 /* 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
696 nbits = _PyLong_NumBits(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
697 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
698 /* 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
699 * 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
700 * 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
701 * 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
702 * finite float.
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
703 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
704 PyErr_Clear();
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
705 i = (double)vsign;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
706 assert(wsign != 0);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
707 j = wsign * 2.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
708 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
709 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
710 if (nbits <= 48) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
711 j = PyLong_AsDouble(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
712 /* 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
713 assert(j != -1.0 || ! PyErr_Occurred());
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
714 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
715 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
716 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
717 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
718 * 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
719 * vsign != wsign branch at the start */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
720 /* 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
721 if (vsign < 0) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
722 /* "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
723 * comparator.
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
724 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
725 i = -i;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
726 op = _Py_SwappedOp[op];
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
727 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
728 assert(i > 0.0);
36235
9f66bdd5a061 Fix icc warnings: remove unused variable
Neal Norwitz <nnorwitz@gmail.com>
parents: 35999
diff changeset
729 (void) frexp(i, &exponent);
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
730 /* 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
731 * 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
732 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
733 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
734 i = 1.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
735 j = 2.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
736 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
737 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
738 if ((size_t)exponent > nbits) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
739 i = 2.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
740 j = 1.0;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
741 goto Compare;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
742 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
743 /* 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
744 * 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
745 * outcome.
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
746 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
747 {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
748 double fracpart;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
749 double intpart;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
750 PyObject *result = NULL;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
751 PyObject *one = NULL;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
752 PyObject *vv = NULL;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
753 PyObject *ww = w;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
754
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
755 if (wsign < 0) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
756 ww = PyNumber_Negative(w);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
757 if (ww == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
758 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
759 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
760 else
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
761 Py_INCREF(ww);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
762
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
763 fracpart = modf(i, &intpart);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
764 vv = PyLong_FromDouble(intpart);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
765 if (vv == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
766 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
767
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
768 if (fracpart != 0.0) {
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
769 /* 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
770 * to represent the lost fraction.
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
771 */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
772 PyObject *temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
773
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
774 one = PyInt_FromLong(1);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
775 if (one == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
776 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
777
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
778 temp = PyNumber_Lshift(ww, one);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
779 if (temp == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
780 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
781 Py_DECREF(ww);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
782 ww = temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
783
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
784 temp = PyNumber_Lshift(vv, one);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
785 if (temp == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
786 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
787 Py_DECREF(vv);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
788 vv = temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
789
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
790 temp = PyNumber_Or(vv, one);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
791 if (temp == NULL)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
792 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
793 Py_DECREF(vv);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
794 vv = temp;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
795 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
796
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
797 r = PyObject_RichCompareBool(vv, ww, op);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
798 if (r < 0)
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
799 goto Error;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
800 result = PyBool_FromLong(r);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
801 Error:
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
802 Py_XDECREF(vv);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
803 Py_XDECREF(ww);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
804 Py_XDECREF(one);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
805 return result;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
806 }
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
807 } /* else if (PyLong_Check(w)) */
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
808
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
809 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
810 goto Unimplemented;
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
811
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
812 Compare:
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
813 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
814 switch (op) {
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
815 case Py_EQ:
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
816 r = i == j;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
817 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
818 case Py_NE:
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
819 r = i != j;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
820 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
821 case Py_LE:
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
822 r = i <= j;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
823 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
824 case Py_GE:
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
825 r = i >= j;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
826 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
827 case Py_LT:
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
828 r = i < j;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
829 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
830 case Py_GT:
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
831 r = i > j;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
832 break;
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
833 }
31589
ca3c998afa55 Pass a variable that actually exists to PyFPE_END_PROTECT in
Michael W. Hudson <mwh@python.net>
parents: 31553
diff changeset
834 PyFPE_END_PROTECT(r)
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
835 return PyBool_FromLong(r);
33547
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
836
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
837 Unimplemented:
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
838 Py_INCREF(Py_NotImplemented);
702367da2c72 SF bug #513866: Float/long comparison anomaly.
Tim Peters <tim.peters@gmail.com>
parents: 32533
diff changeset
839 return Py_NotImplemented;
31553
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
840 }
a6d8d5ace6a7 "Fix" (for certain configurations of the planets, including
Michael W. Hudson <mwh@python.net>
parents: 31384
diff changeset
841
1257
1cabc2b6c970 * Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents: 1252
diff changeset
842 static long
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
843 float_hash(PyFloatObject *v)
1257
1cabc2b6c970 * Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents: 1252
diff changeset
844 {
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
845 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
846 }
1cabc2b6c970 * Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents: 1252
diff changeset
847
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
848 static PyObject *
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
849 float_add(PyObject *v, PyObject *w)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
850 {
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
851 double a,b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
852 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
853 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
854 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
855 a = a + b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
856 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
857 return PyFloat_FromDouble(a);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
858 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
859
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
860 static PyObject *
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
861 float_sub(PyObject *v, PyObject *w)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
862 {
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
863 double a,b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
864 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
865 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
866 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
867 a = a - b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
868 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
869 return PyFloat_FromDouble(a);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
870 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
871
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
872 static PyObject *
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
873 float_mul(PyObject *v, PyObject *w)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
874 {
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
875 double a,b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
876 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
877 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
878 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
879 a = a * b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
880 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
881 return PyFloat_FromDouble(a);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
882 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
883
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
884 static PyObject *
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
885 float_div(PyObject *v, PyObject *w)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
886 {
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
887 double a,b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
888 CONVERT_TO_DOUBLE(v, a);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
889 CONVERT_TO_DOUBLE(w, b);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
890 if (b == 0.0) {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
891 PyErr_SetString(PyExc_ZeroDivisionError, "float division");
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
892 return NULL;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
893 }
5118
002865af55e5 Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents: 4933
diff changeset
894 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
895 a = a / b;
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
896 PyFPE_END_PROTECT(a)
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
897 return PyFloat_FromDouble(a);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
898 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
899
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
900 static PyObject *
19633
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
901 float_classic_div(PyObject *v, PyObject *w)
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
902 {
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
903 double a,b;
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
904 CONVERT_TO_DOUBLE(v, a);
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
905 CONVERT_TO_DOUBLE(w, b);
19673
b3271297b984 PEP 238 documented -Qwarn as warning only for classic int or long
Guido van Rossum <guido@python.org>
parents: 19666
diff changeset
906 if (Py_DivisionWarningFlag >= 2 &&
19633
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
907 PyErr_Warn(PyExc_DeprecationWarning, "classic float division") < 0)
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
908 return NULL;
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
909 if (b == 0.0) {
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
910 PyErr_SetString(PyExc_ZeroDivisionError, "float division");
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
911 return NULL;
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
912 }
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
913 PyFPE_START_PROTECT("divide", return 0)
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
914 a = a / b;
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
915 PyFPE_END_PROTECT(a)
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
916 return PyFloat_FromDouble(a);
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
917 }
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
918
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in
Guido van Rossum <guido@python.org>
parents: 19590
diff changeset
919 static PyObject *
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
920 float_rem(PyObject *v, PyObject *w)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
921 {
632
0c1938f2e0c0 Get rid of redundant type checks.
Guido van Rossum <guido@python.org>
parents: 496
diff changeset
922 double vx, wx;
10833
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
923 double mod;
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
924 CONVERT_TO_DOUBLE(v, vx);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
925 CONVERT_TO_DOUBLE(w, wx);
632
0c1938f2e0c0 Get rid of redundant type checks.
Guido van Rossum <guido@python.org>
parents: 496
diff changeset
926 if (wx == 0.0) {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
927 PyErr_SetString(PyExc_ZeroDivisionError, "float modulo");
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
928 return NULL;
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
929 }
5118
002865af55e5 Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents: 4933
diff changeset
930 PyFPE_START_PROTECT("modulo", return 0)
632
0c1938f2e0c0 Get rid of redundant type checks.
Guido van Rossum <guido@python.org>
parents: 496
diff changeset
931 mod = fmod(vx, wx);
10833
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
932 /* note: checking mod*wx < 0 is incorrect -- underflows to
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
933 0 if wx < sqrt(smallest nonzero double) */
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
934 if (mod && ((wx < 0) != (mod < 0))) {
632
0c1938f2e0c0 Get rid of redundant type checks.
Guido van Rossum <guido@python.org>
parents: 496
diff changeset
935 mod += wx;
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
936 }
5197
74c12704a0bd New form of PyFPE_END_PROTECT macro.
Guido van Rossum <guido@python.org>
parents: 5118
diff changeset
937 PyFPE_END_PROTECT(mod)
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
938 return PyFloat_FromDouble(mod);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
939 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
940
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
941 static PyObject *
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
942 float_divmod(PyObject *v, PyObject *w)
227
7ec6058b539b Added (dummy) divmod and (functional) abs.
Guido van Rossum <guido@python.org>
parents: 145
diff changeset
943 {
391
caf8466dcc9c Finally implemented divmod().
Guido van Rossum <guido@python.org>
parents: 284
diff changeset
944 double vx, wx;
10833
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
945 double div, mod, floordiv;
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
946 CONVERT_TO_DOUBLE(v, vx);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
947 CONVERT_TO_DOUBLE(w, wx);
391
caf8466dcc9c Finally implemented divmod().
Guido van Rossum <guido@python.org>
parents: 284
diff changeset
948 if (wx == 0.0) {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
949 PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
391
caf8466dcc9c Finally implemented divmod().
Guido van Rossum <guido@python.org>
parents: 284
diff changeset
950 return NULL;
caf8466dcc9c Finally implemented divmod().
Guido van Rossum <guido@python.org>
parents: 284
diff changeset
951 }
5118
002865af55e5 Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents: 4933
diff changeset
952 PyFPE_START_PROTECT("divmod", return 0)
391
caf8466dcc9c Finally implemented divmod().
Guido van Rossum <guido@python.org>
parents: 284
diff changeset
953 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
954 /* 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
955 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
956 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
957 not be an exact integral value after the division, although
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
958 it will always be very close to one.
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
959 */
391
caf8466dcc9c Finally implemented divmod().
Guido van Rossum <guido@python.org>
parents: 284
diff changeset
960 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
961 if (mod) {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
962 /* 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
963 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
964 mod += wx;
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
965 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
966 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
967 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
968 else {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
969 /* 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
970 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
971 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
972 "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
973 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
974 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
975 mod = -mod;
391
caf8466dcc9c Finally implemented divmod().
Guido van Rossum <guido@python.org>
parents: 284
diff changeset
976 }
10833
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
977 /* 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
978 if (div) {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
979 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
980 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
981 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
982 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
983 else {
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
984 /* 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
985 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
986 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
987 }
95201153251c SF bug #477221: abs and divmod act oddly with -0.0
Tim Peters <tim.peters@gmail.com>
parents: 20826
diff changeset
988 PyFPE_END_PROTECT(floordiv)
10833
135c1ec9636c Tim Peters writes:
Guido van Rossum <guido@python.org>
parents: 10432
diff changeset
989 return Py_BuildValue("(dd)", floordiv, mod);
227
7ec6058b539b Added (dummy) divmod and (functional) abs.
Guido van Rossum <guido@python.org>
parents: 145
diff changeset
990 }
7ec6058b539b Added (dummy) divmod and (functional) abs.
Guido van Rossum <guido@python.org>
parents: 145
diff changeset
991
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
992 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
993 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
994 {
257c938900a6 float_int_div(): For clarity, move this closer to the other float
Tim Peters <tim.peters@gmail.com>
parents: 21097
diff changeset
995 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
996
257c938900a6 float_int_div(): For clarity, move this closer to the other float
Tim Peters <tim.peters@gmail.com>
parents: 21097
diff changeset
997 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
998 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
999 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
1000 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
1001 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
1002 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
1003 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
1004 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
1005 }
257c938900a6 float_int_div(): For clarity, move this closer to the other float
Tim Peters <tim.peters@gmail.com>
parents: 21097
diff changeset
1006
257c938900a6 float_int_div(): For clarity, move this closer to the other float
Tim Peters <tim.peters@gmail.com>
parents: 21097
diff changeset
1007 static PyObject *
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
1008 float_pow(PyObject *v, PyObject *w, PyObject *z)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1009 {
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1010 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
1011
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
1012 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
1013 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
1014 "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
1015 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
1016 }
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
1017
15723
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
1018 CONVERT_TO_DOUBLE(v, iv);
ac7ae3ead88a Make float a new style number type.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15318
diff changeset
1019 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
1020
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
1021 /* 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
1022 if (iw == 0) { /* v**0 is 1, even 0**0 */
41580
a68467cc06d3 Remove dead code. This code couldn't be reached because earlier in
Neal Norwitz <nnorwitz@gmail.com>
parents: 39642
diff changeset
1023 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
1024 }
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
1025 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
1026 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
1027 PyErr_SetString(PyExc_ZeroDivisionError,
15318
8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>:
Fred Drake <fdrake@acm.org>
parents: 15041
diff changeset
1028 "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
1029 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
1030 }
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
1031 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
1032 }
29252
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1033 if (iv < 0.0) {
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1034 /* 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
1035 * 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
1036 */
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1037 if (iw != floor(iw)) {
44488
94eeaeeb3ce9 Continue rolling back pep-3141 changes that changed behavior from 2.5. This
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44432
diff changeset
1038 PyErr_SetString(PyExc_ValueError, "negative number "
94eeaeeb3ce9 Continue rolling back pep-3141 changes that changed behavior from 2.5. This
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44432
diff changeset
1039 "cannot be raised to a fractional power");
94eeaeeb3ce9 Continue rolling back pep-3141 changes that changed behavior from 2.5. This
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44432
diff changeset
1040 return NULL;
29252
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1041 }
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1042 /* 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
1043 * -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
1044 * 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
1045 * 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
1046 * 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
1047 * 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
1048 * 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
1049 */
38293
688f25757104 Added a new macro, Py_IS_FINITE(X). On windows there is an intrinsic for this and it is more efficient than to use !Py_IS_INFINITE(X) && !Py_IS_NAN(X). No change on other platforms
Kristján Valur Jónsson <kristjan@ccpgames.com>
parents: 37815
diff changeset
1050 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
1051 /* 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
1052 * 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
1053 * 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
1054 * indirectly.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1055 */
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1056 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
1057 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
1058 }
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1059 /* 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
1060 * 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
1061 * the platform to do this correctly.
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1062 */
3984
0613f17dcfd8 Correct wrong calculation of pow(0.0, 0.0, negative_number)
Guido van Rossum <guido@python.org>
parents: 3704
diff changeset
1063 }
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
1064 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
1065 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
1066 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
1067 PyFPE_END_PROTECT(ix)
22228
4b6eda7d0c8f backport tim_one's checkin of
Michael W. Hudson <mwh@python.net>
parents: 21354
diff changeset
1068 Py_ADJUST_ERANGE1(ix);
39642
981181d2a4fe Reverting the patch that tried to fix the issue whereby x**2 raises
Alex Martelli <aleaxit@gmail.com>
parents: 39639
diff changeset
1069 if (errno != 0) {
29252
0b76679bf3f9 SF bug 705231: Assertion failed, python aborts.
Tim Peters <tim.peters@gmail.com>
parents: 28368
diff changeset
1070 /* 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
1071 * 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
1072 */
39642
981181d2a4fe Reverting the patch that tried to fix the issue whereby x**2 raises
Alex Martelli <aleaxit@gmail.com>
parents: 39639
diff changeset
1073 PyErr_SetFromErrno(errno == ERANGE ? PyExc_OverflowError :
981181d2a4fe Reverting the patch that tried to fix the issue whereby x**2 raises
Alex Martelli <aleaxit@gmail.com>
parents: 39639
diff changeset
1074 PyExc_ValueError);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1075 return NULL;
27
82c7bab78bb1 New errors.
Guido van Rossum <guido@python.org>
parents: 6
diff changeset
1076 }
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1077 return PyFloat_FromDouble(ix);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1078 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1079
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1080 static PyObject *
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
1081 float_neg(PyFloatObject *v)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1082 {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1083 return PyFloat_FromDouble(-v->ob_fval);
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1084 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1085
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1086 static PyObject *
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
1087 float_abs(PyFloatObject *v)
227
7ec6058b539b Added (dummy) divmod and (functional) abs.
Guido van Rossum <guido@python.org>
parents: 145
diff changeset
1088 {
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
1089 return PyFloat_FromDouble(fabs(v->ob_fval));
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1090 }
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1091
239
fda973f2a512 Added nonzero test
Guido van Rossum <guido@python.org>
parents: 227
diff changeset
1092 static int
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
1093 float_nonzero(PyFloatObject *v)
239
fda973f2a512 Added nonzero test
Guido van Rossum <guido@python.org>
parents: 227
diff changeset
1094 {
fda973f2a512 Added nonzero test
Guido van Rossum <guido@python.org>
parents: 227
diff changeset
1095 return v->ob_fval != 0.0;
fda973f2a512 Added nonzero test
Guido van Rossum <guido@python.org>
parents: 227
diff changeset
1096 }
fda973f2a512 Added nonzero test
Guido van Rossum <guido@python.org>
parents: 227
diff changeset
1097
1313
6ee380349c84 * Added gmtime/localtime/mktime and SYSV timezone globals to timemodule.c.
Guido van Rossum <guido@python.org>
parents: 1271
diff changeset
1098 static int
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
1099 float_coerce(PyObject **pv, PyObject **pw)
955
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1100 {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1101 if (PyInt_Check(*pw)) {
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1102 long x = PyInt_AsLong(*pw);
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1103 *pw = PyFloat_FromDouble((double)x);
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1104 Py_INCREF(*pv);
955
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1105 return 0;
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1106 }
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1107 else if (PyLong_Check(*pw)) {
27484
5ba7934a7ba0 Fix SF bug# 676155, RuntimeWarning with tp_compare
Neal Norwitz <nnorwitz@gmail.com>
parents: 26328
diff changeset
1108 double x = PyLong_AsDouble(*pw);
5ba7934a7ba0 Fix SF bug# 676155, RuntimeWarning with tp_compare
Neal Norwitz <nnorwitz@gmail.com>
parents: 26328
diff changeset
1109 if (x == -1.0 && PyErr_Occurred())
5ba7934a7ba0 Fix SF bug# 676155, RuntimeWarning with tp_compare
Neal Norwitz <nnorwitz@gmail.com>
parents: 26328
diff changeset
1110 return -1;
5ba7934a7ba0 Fix SF bug# 676155, RuntimeWarning with tp_compare
Neal Norwitz <nnorwitz@gmail.com>
parents: 26328
diff changeset
1111 *pw = PyFloat_FromDouble(x);
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1112 Py_INCREF(*pv);
955
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1113 return 0;
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1114 }
19976
da00188d5270 Add additional coercion support for "self subtypes" to int, long,
Guido van Rossum <guido@python.org>
parents: 19889
diff changeset
1115 else if (PyFloat_Check(*pw)) {
da00188d5270 Add additional coercion support for "self subtypes" to int, long,
Guido van Rossum <guido@python.org>
parents: 19889
diff changeset
1116 Py_INCREF(*pv);
da00188d5270 Add additional coercion support for "self subtypes" to int, long,
Guido van Rossum <guido@python.org>
parents: 19889
diff changeset
1117 Py_INCREF(*pw);
da00188d5270 Add additional coercion support for "self subtypes" to int, long,
Guido van Rossum <guido@python.org>
parents: 19889
diff changeset
1118 return 0;
da00188d5270 Add additional coercion support for "self subtypes" to int, long,
Guido van Rossum <guido@python.org>
parents: 19889
diff changeset
1119 }
955
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1120 return 1; /* Can't do it */
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1121 }
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c:
Guido van Rossum <guido@python.org>
parents: 795
diff changeset
1122
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1123 static PyObject *
44432
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1124 float_trunc(PyObject *v)
1049
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic.
Guido van Rossum <guido@python.org>
parents: 955
diff changeset
1125 {
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1126 double x = PyFloat_AsDouble(v);
18838
a8575f358b9f SF bug #444510: int() should guarantee truncation.
Tim Peters <tim.peters@gmail.com>
parents: 17707
diff changeset
1127 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
1128
a8575f358b9f SF bug #444510: int() should guarantee truncation.
Tim Peters <tim.peters@gmail.com>
parents: 17707
diff changeset
1129 (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
1130 /* 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
1131 * 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
1132 * 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
1133 * 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
1134 * 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
1135 * 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
1136 * 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
1137 * 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
1138 * 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
1139 * 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
1140 * 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
1141 */
f3a69037fdf0 float_int(): Some systems raise an exception if a double is cast to
Tim Peters <tim.peters@gmail.com>
parents: 26291
diff changeset
1142 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
1143 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
1144 return PyInt_FromLong(aslong);
20654
edd9d0b3c47e SF patch #474590 -- RISC OS support
Guido van Rossum <guido@python.org>
parents: 20277
diff changeset
1145 }
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
1146 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
1147 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic.
Guido van Rossum <guido@python.org>
parents: 955
diff changeset
1148
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1149 static PyObject *
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
1150 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
1151 {
34931
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type
Brett Cannon <bcannon@gmail.com>
parents: 33549
diff changeset
1152 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
1153 Py_INCREF(v);
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type
Brett Cannon <bcannon@gmail.com>
parents: 33549
diff changeset
1154 else
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type
Brett Cannon <bcannon@gmail.com>
parents: 33549
diff changeset
1155 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
1156 return v;
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic.
Guido van Rossum <guido@python.org>
parents: 955
diff changeset
1157 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic.
Guido van Rossum <guido@python.org>
parents: 955
diff changeset
1158
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic.
Guido van Rossum <guido@python.org>
parents: 955
diff changeset
1159
24280
1598a1e473e2 staticforward bites the dust.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 23832
diff changeset
1160 static PyObject *
19552
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1161 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
1162
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1163 static PyObject *
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1164 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
1165 {
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1166 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
1167 static char *kwlist[] = {"x", 0};
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1168
19552
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1169 if (type != &PyFloat_Type)
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1170 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
1171 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
1172 return NULL;
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1173 if (PyString_Check(x))
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1174 return PyFloat_FromString(x, NULL);
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1175 return PyNumber_Float(x);
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1176 }
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1177
19552
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1178 /* 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
1179 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
1180 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
1181 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
1182 */
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1183 static PyObject *
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1184 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
1185 {
37589
aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the
Anthony Baxter <anthonybaxter@gmail.com>
parents: 37304
diff changeset
1186 PyObject *tmp, *newobj;
19552
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1187
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1188 assert(PyType_IsSubtype(type, &PyFloat_Type));
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1189 tmp = float_new(&PyFloat_Type, args, kwds);
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1190 if (tmp == NULL)
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1191 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
1192 assert(PyFloat_CheckExact(tmp));
37589
aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the
Anthony Baxter <anthonybaxter@gmail.com>
parents: 37304
diff changeset
1193 newobj = type->tp_alloc(type, 0);
aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the
Anthony Baxter <anthonybaxter@gmail.com>
parents: 37304
diff changeset
1194 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
1195 Py_DECREF(tmp);
19552
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1196 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
1197 }
37589
aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the
Anthony Baxter <anthonybaxter@gmail.com>
parents: 37304
diff changeset
1198 ((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
1199 Py_DECREF(tmp);
37589
aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the
Anthony Baxter <anthonybaxter@gmail.com>
parents: 37304
diff changeset
1200 return newobj;
19552
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1201 }
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1202
27521
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1203 static PyObject *
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1204 float_getnewargs(PyFloatObject *v)
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1205 {
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1206 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
1207 }
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1208
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1209 /* 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
1210
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1211 typedef enum {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1212 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
1213 } float_format_type;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1214
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1215 static float_format_type double_format, float_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1216 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
1217
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1218 static PyObject *
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1219 float_getformat(PyTypeObject *v, PyObject* arg)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1220 {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1221 char* s;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1222 float_format_type r;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1223
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1224 if (!PyString_Check(arg)) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1225 PyErr_Format(PyExc_TypeError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1226 "__getformat__() argument must be string, not %.500s",
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
1227 Py_TYPE(arg)->tp_name);
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1228 return NULL;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1229 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1230 s = PyString_AS_STRING(arg);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1231 if (strcmp(s, "double") == 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1232 r = double_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1233 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1234 else if (strcmp(s, "float") == 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1235 r = float_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1236 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1237 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1238 PyErr_SetString(PyExc_ValueError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1239 "__getformat__() argument 1 must be "
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1240 "'double' or 'float'");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1241 return NULL;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1242 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1243
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1244 switch (r) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1245 case unknown_format:
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1246 return PyString_FromString("unknown");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1247 case ieee_little_endian_format:
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1248 return PyString_FromString("IEEE, little-endian");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1249 case ieee_big_endian_format:
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1250 return PyString_FromString("IEEE, big-endian");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1251 default:
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1252 Py_FatalError("insane float_format or double_format");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1253 return NULL;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1254 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1255 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1256
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1257 PyDoc_STRVAR(float_getformat_doc,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1258 "float.__getformat__(typestr) -> string\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1259 "\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1260 "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
1261 "used in Python's test suite.\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1262 "\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1263 "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
1264 "'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
1265 "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
1266
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1267 static PyObject *
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1268 float_setformat(PyTypeObject *v, PyObject* args)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1269 {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1270 char* typestr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1271 char* format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1272 float_format_type f;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1273 float_format_type detected;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1274 float_format_type *p;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1275
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1276 if (!PyArg_ParseTuple(args, "ss:__setformat__", &typestr, &format))
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1277 return NULL;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1278
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1279 if (strcmp(typestr, "double") == 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1280 p = &double_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1281 detected = detected_double_format;
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 else if (strcmp(typestr, "float") == 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1284 p = &float_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1285 detected = detected_float_format;
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 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1288 PyErr_SetString(PyExc_ValueError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1289 "__setformat__() argument 1 must "
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1290 "be 'double' or 'float'");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1291 return NULL;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1292 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1293
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1294 if (strcmp(format, "unknown") == 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1295 f = unknown_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1296 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1297 else if (strcmp(format, "IEEE, little-endian") == 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1298 f = ieee_little_endian_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1299 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1300 else if (strcmp(format, "IEEE, big-endian") == 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1301 f = ieee_big_endian_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1302 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1303 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1304 PyErr_SetString(PyExc_ValueError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1305 "__setformat__() argument 2 must be "
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1306 "'unknown', 'IEEE, little-endian' or "
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1307 "'IEEE, big-endian'");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1308 return NULL;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1309
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1310 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1311
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1312 if (f != unknown_format && f != detected) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1313 PyErr_Format(PyExc_ValueError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1314 "can only set %s format to 'unknown' or the "
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1315 "detected platform value", typestr);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1316 return NULL;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1317 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1318
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1319 *p = f;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1320 Py_RETURN_NONE;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1321 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1322
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1323 PyDoc_STRVAR(float_setformat_doc,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1324 "float.__setformat__(typestr, fmt) -> None\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1325 "\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1326 "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
1327 "used in Python's test suite.\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1328 "\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1329 "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
1330 "'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
1331 "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
1332 "\n"
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1333 "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
1334 "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
1335
44432
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1336 static PyObject *
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1337 float_getzero(PyObject *v, void *closure)
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1338 {
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1339 return PyFloat_FromDouble(0.0);
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1340 }
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1341
27521
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1342 static PyMethodDef float_methods[] = {
44432
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1343 {"conjugate", (PyCFunction)float_float, METH_NOARGS,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1344 "Returns self, the complex conjugate of any float."},
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1345 {"__trunc__", (PyCFunction)float_trunc, METH_NOARGS,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1346 "Returns the Integral closest to x between 0 and x."},
27521
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1347 {"__getnewargs__", (PyCFunction)float_getnewargs, METH_NOARGS},
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1348 {"__getformat__", (PyCFunction)float_getformat,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1349 METH_O|METH_CLASS, float_getformat_doc},
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1350 {"__setformat__", (PyCFunction)float_setformat,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1351 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
1352 {NULL, NULL} /* sentinel */
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1353 };
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1354
44432
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1355 static PyGetSetDef float_getset[] = {
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1356 {"real",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1357 (getter)float_float, (setter)NULL,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1358 "the real part of a complex number",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1359 NULL},
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1360 {"imag",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1361 (getter)float_getzero, (setter)NULL,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1362 "the imaginary part of a complex number",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1363 NULL},
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1364 {NULL} /* Sentinel */
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1365 };
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1366
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23344
diff changeset
1367 PyDoc_STRVAR(float_doc,
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1368 "float(x) -> floating point number\n\
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1369 \n\
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23344
diff changeset
1370 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
1371
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1372
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1373 static PyNumberMethods float_as_number = {
37304
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1374 float_add, /*nb_add*/
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1375 float_sub, /*nb_subtract*/
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1376 float_mul, /*nb_multiply*/
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1377 float_classic_div, /*nb_divide*/
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1378 float_rem, /*nb_remainder*/
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1379 float_divmod, /*nb_divmod*/
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1380 float_pow, /*nb_power*/
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1347
diff changeset
1381 (unaryfunc)float_neg, /*nb_negative*/
44432
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1382 (unaryfunc)float_float, /*nb_positive*/
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1347
diff changeset
1383 (unaryfunc)float_abs, /*nb_absolute*/
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1347
diff changeset
1384 (inquiry)float_nonzero, /*nb_nonzero*/
405
d3d328680328 Added NULL function pointers for shift and mask ops.
Guido van Rossum <guido@python.org>
parents: 391
diff changeset
1385 0, /*nb_invert*/
d3d328680328 Added NULL function pointers for shift and mask ops.
Guido van Rossum <guido@python.org>
parents: 391
diff changeset
1386 0, /*nb_lshift*/
d3d328680328 Added NULL function pointers for shift and mask ops.
Guido van Rossum <guido@python.org>
parents: 391
diff changeset
1387 0, /*nb_rshift*/
d3d328680328 Added NULL function pointers for shift and mask ops.
Guido van Rossum <guido@python.org>
parents: 391
diff changeset
1388 0, /*nb_and*/
d3d328680328 Added NULL function pointers for shift and mask ops.
Guido van Rossum <guido@python.org>
parents: 391
diff changeset
1389 0, /*nb_xor*/
d3d328680328 Added NULL function pointers for shift and mask ops.
Guido van Rossum <guido@python.org>
parents: 391
diff changeset
1390 0, /*nb_or*/
37304
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1391 float_coerce, /*nb_coerce*/
44432
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1392 float_trunc, /*nb_int*/
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1393 float_trunc, /*nb_long*/
37304
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1394 float_float, /*nb_float*/
19051
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1395 0, /* nb_oct */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1396 0, /* nb_hex */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1397 0, /* nb_inplace_add */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1398 0, /* nb_inplace_subtract */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1399 0, /* nb_inplace_multiply */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1400 0, /* nb_inplace_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1401 0, /* nb_inplace_remainder */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1402 0, /* nb_inplace_power */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1403 0, /* nb_inplace_lshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1404 0, /* nb_inplace_rshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1405 0, /* nb_inplace_and */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1406 0, /* nb_inplace_xor */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1407 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
1408 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
1409 float_div, /* nb_true_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1410 0, /* nb_inplace_floor_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory.
Guido van Rossum <guido@python.org>
parents: 18933
diff changeset
1411 0, /* nb_inplace_true_divide */
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1412 };
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1413
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1414 PyTypeObject PyFloat_Type = {
42333
6620a510e9a9 PEP 3123: Provide forward compatibility with Python 3.0, while keeping
Martin v. Löwis <martin@v.loewis.de>
parents: 41580
diff changeset
1415 PyVarObject_HEAD_INIT(&PyType_Type, 0)
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1416 "float",
5396
d1447950fa04 Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
1417 sizeof(PyFloatObject),
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1418 0,
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1419 (destructor)float_dealloc, /* tp_dealloc */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1420 (printfunc)float_print, /* tp_print */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1421 0, /* tp_getattr */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1422 0, /* tp_setattr */
32150
65f9ad9bc829 Remove float_compare as per
Michael W. Hudson <mwh@python.net>
parents: 31590
diff changeset
1423 0, /* tp_compare */
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1424 (reprfunc)float_repr, /* tp_repr */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1425 &float_as_number, /* tp_as_number */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1426 0, /* tp_as_sequence */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1427 0, /* tp_as_mapping */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1428 (hashfunc)float_hash, /* tp_hash */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1429 0, /* tp_call */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1430 (reprfunc)float_str, /* tp_str */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1431 PyObject_GenericGetAttr, /* tp_getattro */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1432 0, /* tp_setattro */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1433 0, /* tp_as_buffer */
19552
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1434 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
6c30d20d27f2 Make int, long and float subclassable.
Guido van Rossum <guido@python.org>
parents: 19457
diff changeset
1435 Py_TPFLAGS_BASETYPE, /* tp_flags */
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1436 float_doc, /* tp_doc */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1437 0, /* tp_traverse */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1438 0, /* tp_clear */
37304
79a0f080f898 Remove unnecessary casts in type object initializers.
Georg Brandl <georg@python.org>
parents: 36759
diff changeset
1439 float_richcompare, /* tp_richcompare */
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1440 0, /* tp_weaklistoffset */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1441 0, /* tp_iter */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1442 0, /* tp_iternext */
27521
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents: 27484
diff changeset
1443 float_methods, /* tp_methods */
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1444 0, /* tp_members */
44432
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just
Jeffrey Yasskin <jyasskin@gmail.com>
parents: 44350
diff changeset
1445 float_getset, /* tp_getset */
18933
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1446 0, /* tp_base */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1447 0, /* tp_dict */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1448 0, /* tp_descr_get */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1449 0, /* tp_descr_set */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1450 0, /* tp_dictoffset */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1451 0, /* tp_init */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1452 0, /* tp_alloc */
09df3254b49d Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents: 18838
diff changeset
1453 float_new, /* tp_new */
6
fc6fcd7df4f7 Initial revision
Guido van Rossum <guido@python.org>
parents:
diff changeset
1454 };
5936
80d24364b932 Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents: 5504
diff changeset
1455
80d24364b932 Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents: 5504
diff changeset
1456 void
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1457 _PyFloat_Init(void)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1458 {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1459 /* 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
1460 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
1461 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
1462 IEEE platform, the float packing/unpacking routines can
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1463 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
1464 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
1465 values, but what happens to infinities, NaNs and signed
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1466 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
1467 a NaN or an infinity will raise an exception.
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1468
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1469 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
1470 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
1471 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
1472 method. */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1473
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1474 #if SIZEOF_DOUBLE == 8
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 double x = 9006104071832581.0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1477 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
1478 detected_double_format = ieee_big_endian_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1479 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
1480 detected_double_format = ieee_little_endian_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1481 else
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1482 detected_double_format = unknown_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1483 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1484 #else
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1485 detected_double_format = unknown_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1486 #endif
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1487
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1488 #if SIZEOF_FLOAT == 4
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1489 {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1490 float y = 16711938.0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1491 if (memcmp(&y, "\x4b\x7f\x01\x02", 4) == 0)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1492 detected_float_format = ieee_big_endian_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1493 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
1494 detected_float_format = ieee_little_endian_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1495 else
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1496 detected_float_format = unknown_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1497 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1498 #else
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1499 detected_float_format = unknown_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1500 #endif
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 double_format = detected_double_format;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1503 float_format = detected_float_format;
44267
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
1504
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
1505 #ifdef Py_BROKEN_REPR
44262
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
1506 /* Initialize floating point repr */
24749a380409 Backport of r59456:59458 from py3k to trunk
Christian Heimes <christian@cheimes.de>
parents: 44085
diff changeset
1507 _PyFloat_DigitsInit();
44267
f909872917b9 The new float repr causes too much trouble and pain. I'm disabling the feature until we have sorted out the issues on all machines. 64bit machines seem to have issues and Guido has reported even worse.
Christian Heimes <christian@cheimes.de>
parents: 44262
diff changeset
1508 #endif
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1509 }
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 void
13454
fcc75a3748f5 ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents: 13447
diff changeset
1512 PyFloat_Fini(void)
5936
80d24364b932 Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents: 5504
diff changeset
1513 {
10391
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1514 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
1515 PyFloatBlock *list, *next;
32533
201986d6d9d6 Fix a couple of signed/unsigned comparison warnings
Neal Norwitz <nnorwitz@gmail.com>
parents: 32305
diff changeset
1516 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
1517 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
1518 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
1519
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error,
Guido van Rossum <guido@python.org>
parents: 10375
diff changeset
1520 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
1521 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
1522 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
1523 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
1524 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
1525 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
1526 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
1527 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
1528 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
1529 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
1530 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
1531 i++, p++) {
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
1532 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
1533 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
1534 }
10391
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1535 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
1536 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
1537 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
1538 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
1539 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
1540 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
1541 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
1542 if (!PyFloat_CheckExact(p) ||
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
1543 Py_REFCNT(p) == 0) {
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
1544 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
1545 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
1546 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
1547 }
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
1548 }
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
1549 }
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error,
Guido van Rossum <guido@python.org>
parents: 10375
diff changeset
1550 else {
12576
1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring.
Guido van Rossum <guido@python.org>
parents: 12248
diff changeset
1551 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
1552 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
1553 }
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error,
Guido van Rossum <guido@python.org>
parents: 10375
diff changeset
1554 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
1555 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
1556 }
10391
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1557 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
1558 return;
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1559 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
1560 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
1561 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
1562 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1563 else {
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1564 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
1565 ": %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
1566 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
1567 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
1568 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1569 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
1570 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
1571 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
1572 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
1573 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
1574 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
1575 if (PyFloat_CheckExact(p) &&
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
1576 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
1577 char buf[100];
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1578 PyFloat_AsString(buf, p);
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
1579 /* 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
1580 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
1581 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
1582 */
10391
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1583 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
1584 "# <float at %p, refcnt=%ld, val=%s>\n",
44350
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available.
Christian Heimes <christian@cheimes.de>
parents: 44344
diff changeset
1585 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
1586 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1587 }
7b810aa35b5c Vladimir has restructured his code somewhat so that the blocks are now
Guido van Rossum <guido@python.org>
parents: 10382
diff changeset
1588 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
1589 }
e2a08a81e56f OK, try again. Vladimir gave me a fix for the alignment bus error,
Guido van Rossum <guido@python.org>
parents: 10375
diff changeset
1590 }
5936
80d24364b932 Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents: 5504
diff changeset
1591 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1592
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1593 /*----------------------------------------------------------------------------
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1594 * _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
1595 *
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1596 * 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
1597 * 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
1598 */
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1599 int
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1600 _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
1601 {
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1602 if (float_format == unknown_format) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1603 unsigned char sign;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1604 int e;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1605 double f;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1606 unsigned int fbits;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1607 int incr = 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1608
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1609 if (le) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1610 p += 3;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1611 incr = -1;
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
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1614 if (x < 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1615 sign = 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1616 x = -x;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1617 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1618 else
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1619 sign = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1620
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1621 f = frexp(x, &e);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1622
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1623 /* 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
1624 if (0.5 <= f && f < 1.0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1625 f *= 2.0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1626 e--;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1627 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1628 else if (f == 0.0)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1629 e = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1630 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1631 PyErr_SetString(PyExc_SystemError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1632 "frexp() result out of range");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1633 return -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1634 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1635
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1636 if (e >= 128)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1637 goto Overflow;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1638 else if (e < -126) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1639 /* Gradual underflow */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1640 f = ldexp(f, 126 + e);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1641 e = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1642 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1643 else if (!(e == 0 && f == 0.0)) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1644 e += 127;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1645 f -= 1.0; /* Get rid of leading 1 */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1646 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1647
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1648 f *= 8388608.0; /* 2**23 */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1649 fbits = (unsigned int)(f + 0.5); /* Round */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1650 assert(fbits <= 8388608);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1651 if (fbits >> 23) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1652 /* 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
1653 fbits = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1654 ++e;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1655 if (e >= 255)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1656 goto Overflow;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1657 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1658
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1659 /* First byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1660 *p = (sign << 7) | (e >> 1);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1661 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1662
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1663 /* Second byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1664 *p = (char) (((e & 1) << 7) | (fbits >> 16));
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1665 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1666
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1667 /* Third byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1668 *p = (fbits >> 8) & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1669 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1670
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1671 /* Fourth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1672 *p = fbits & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1673
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1674 /* Done */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1675 return 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1676
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1677 Overflow:
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1678 PyErr_SetString(PyExc_OverflowError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1679 "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
1680 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
1681 }
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1682 else {
35178
cf7a849ce61f Apparently some compiler gives a warning on
Michael W. Hudson <mwh@python.net>
parents: 34972
diff changeset
1683 float y = (float)x;
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1684 const char *s = (char*)&y;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1685 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
1686
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1687 if ((float_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1688 || (float_format == ieee_big_endian_format && le)) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1689 p += 3;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1690 incr = -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1691 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1692
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1693 for (i = 0; i < 4; i++) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1694 *p = *s++;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1695 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1696 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1697 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
1698 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1699 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1700
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1701 int
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1702 _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
1703 {
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1704 if (double_format == unknown_format) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1705 unsigned char sign;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1706 int e;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1707 double f;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1708 unsigned int fhi, flo;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1709 int incr = 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1710
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1711 if (le) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1712 p += 7;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1713 incr = -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1714 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1715
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1716 if (x < 0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1717 sign = 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1718 x = -x;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1719 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1720 else
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1721 sign = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1722
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1723 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
1724
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1725 /* 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
1726 if (0.5 <= f && f < 1.0) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1727 f *= 2.0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1728 e--;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1729 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1730 else if (f == 0.0)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1731 e = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1732 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1733 PyErr_SetString(PyExc_SystemError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1734 "frexp() result out of range");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1735 return -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1736 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1737
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1738 if (e >= 1024)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1739 goto Overflow;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1740 else if (e < -1022) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1741 /* Gradual underflow */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1742 f = ldexp(f, 1022 + e);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1743 e = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1744 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1745 else if (!(e == 0 && f == 0.0)) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1746 e += 1023;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1747 f -= 1.0; /* Get rid of leading 1 */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1748 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1749
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1750 /* 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
1751 f *= 268435456.0; /* 2**28 */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1752 fhi = (unsigned int)f; /* Truncate */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1753 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
1754
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1755 f -= (double)fhi;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1756 f *= 16777216.0; /* 2**24 */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1757 flo = (unsigned int)(f + 0.5); /* Round */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1758 assert(flo <= 16777216);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1759 if (flo >> 24) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1760 /* 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
1761 flo = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1762 ++fhi;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1763 if (fhi >> 28) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1764 /* 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
1765 fhi = 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1766 ++e;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1767 if (e >= 2047)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1768 goto Overflow;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1769 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1770 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1771
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1772 /* First byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1773 *p = (sign << 7) | (e >> 4);
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1774 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1775
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1776 /* Second byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1777 *p = (unsigned char) (((e & 0xF) << 4) | (fhi >> 24));
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1778 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
1779
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1780 /* Third byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1781 *p = (fhi >> 16) & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1782 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1783
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1784 /* Fourth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1785 *p = (fhi >> 8) & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1786 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1787
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1788 /* Fifth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1789 *p = fhi & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1790 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1791
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1792 /* Sixth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1793 *p = (flo >> 16) & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1794 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1795
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1796 /* Seventh byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1797 *p = (flo >> 8) & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1798 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1799
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1800 /* Eighth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1801 *p = flo & 0xFF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1802 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1803
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1804 /* Done */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1805 return 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1806
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1807 Overflow:
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1808 PyErr_SetString(PyExc_OverflowError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1809 "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
1810 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
1811 }
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1812 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1813 const char *s = (char*)&x;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1814 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
1815
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1816 if ((double_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1817 || (double_format == ieee_big_endian_format && le)) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1818 p += 7;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1819 incr = -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1820 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1821
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1822 for (i = 0; i < 8; i++) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1823 *p = *s++;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1824 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1825 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1826 return 0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1827 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1828 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1829
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1830 double
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1831 _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
1832 {
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1833 if (float_format == unknown_format) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1834 unsigned char sign;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1835 int e;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1836 unsigned int f;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1837 double x;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1838 int incr = 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1839
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1840 if (le) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1841 p += 3;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1842 incr = -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1843 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1844
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1845 /* First byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1846 sign = (*p >> 7) & 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1847 e = (*p & 0x7F) << 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1848 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
1849
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1850 /* Second byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1851 e |= (*p >> 7) & 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1852 f = (*p & 0x7F) << 16;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1853 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
1854
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1855 if (e == 255) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1856 PyErr_SetString(
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1857 PyExc_ValueError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1858 "can't unpack IEEE 754 special value "
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1859 "on non-IEEE platform");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1860 return -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1861 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1862
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1863 /* Third byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1864 f |= *p << 8;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1865 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
1866
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1867 /* Fourth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1868 f |= *p;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1869
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1870 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
1871
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1872 /* XXX This sadly ignores Inf/NaN issues */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1873 if (e == 0)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1874 e = -126;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1875 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1876 x += 1.0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1877 e -= 127;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1878 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1879 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
1880
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1881 if (sign)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1882 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
1883
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1884 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
1885 }
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1886 else {
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1887 float x;
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1888
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1889 if ((float_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1890 || (float_format == ieee_big_endian_format && le)) {
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1891 char buf[4];
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1892 char *d = &buf[3];
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1893 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
1894
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1895 for (i = 0; i < 4; i++) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1896 *d-- = *p++;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1897 }
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1898 memcpy(&x, buf, 4);
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1899 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1900 else {
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1901 memcpy(&x, p, 4);
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1902 }
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1903
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1904 return x;
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1905 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1906 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1907
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1908 double
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1909 _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
1910 {
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1911 if (double_format == unknown_format) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1912 unsigned char sign;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1913 int e;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1914 unsigned int fhi, flo;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1915 double x;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1916 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
1917
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1918 if (le) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1919 p += 7;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1920 incr = -1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1921 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1922
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1923 /* First byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1924 sign = (*p >> 7) & 1;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1925 e = (*p & 0x7F) << 4;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1926
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1927 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
1928
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1929 /* Second byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1930 e |= (*p >> 4) & 0xF;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1931 fhi = (*p & 0xF) << 24;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1932 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
1933
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1934 if (e == 2047) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1935 PyErr_SetString(
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1936 PyExc_ValueError,
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1937 "can't unpack IEEE 754 special value "
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1938 "on non-IEEE platform");
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1939 return -1.0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1940 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1941
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1942 /* Third byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1943 fhi |= *p << 16;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1944 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
1945
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1946 /* Fourth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1947 fhi |= *p << 8;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1948 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1949
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1950 /* Fifth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1951 fhi |= *p;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1952 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
1953
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1954 /* Sixth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1955 flo = *p << 16;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1956 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1957
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1958 /* Seventh byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1959 flo |= *p << 8;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1960 p += incr;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1961
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1962 /* Eighth byte */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1963 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
1964
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1965 x = (double)fhi + (double)flo / 16777216.0; /* 2**24 */
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1966 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
1967
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1968 if (e == 0)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1969 e = -1022;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1970 else {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1971 x += 1.0;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1972 e -= 1023;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1973 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1974 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
1975
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1976 if (sign)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1977 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
1978
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1979 return x;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1980 }
28335
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
1981 else {
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1982 double x;
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1983
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1984 if ((double_format == ieee_little_endian_format && !le)
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1985 || (double_format == ieee_big_endian_format && le)) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1986 char buf[8];
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1987 char *d = &buf[7];
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1988 int i;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1989
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1990 for (i = 0; i < 8; i++) {
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1991 *d-- = *p++;
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1992 }
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1993 memcpy(&x, buf, 8);
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1994 }
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1995 else {
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1996 memcpy(&x, p, 8);
34972
1dd8a0d64432 This is my patch:
Michael W. Hudson <mwh@python.net>
parents: 34931
diff changeset
1997 }
35987
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1998
8eda1a58a490 Fix bug
Michael W. Hudson <mwh@python.net>
parents: 35178
diff changeset
1999 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
2000 }
70003b0cb837 New private API functions _PyFloat_{Pack,Unpack}(4,8}. This is a
Tim Peters <tim.peters@gmail.com>
parents: 27521
diff changeset
2001 }