.. cfunction:: PyObject* PyMethod_GET_SELF(PyObject *meth)
Macro version of :cfunc:`PyMethod_Self` which avoids error checking.
+
+
+.. cfunction:: int PyMethod_ClearFreeList(void)
+
+ Clear the free list. Return the total number of freed items.
+
Return true if *p* is a :class:`set` object or an instance of a subtype.
- .. versionadded:: 2.6
-
.. cfunction:: int PyFrozenSet_Check(PyObject *p)
Return true if *p* is a :class:`frozenset` object or an instance of a
subtype.
- .. versionadded:: 2.6
-
.. cfunction:: int PyAnySet_Check(PyObject *p)
Return true if *p* is a :class:`set` object, a :class:`frozenset` object, or an
this function. If the object referenced by ``*p`` is replaced, the original
``*p`` is destroyed. On failure, returns ``-1`` and sets ``*p`` to *NULL*, and
raises :exc:`MemoryError` or :exc:`SystemError`.
+
+.. cfunction:: int PyMethod_ClearFreeList(void)
+
+ Clear the free list. Return the total number of freed items.
Clears the internal lookup cache. Return the current version tag.
- .. versionadded:: 2.6
-
.. cfunction:: int PyType_HasFeature(PyObject *o, int feature)
Return a pointer to the internal buffer of the object. *o* has to be a
:ctype:`PyUnicodeObject` (not checked).
+
+.. cfunction:: int PyUnicode_ClearFreeList(void)
+
+ Clear the free list. Return the total number of freed items.
+
Unicode provides many different character properties. The most often needed ones
are available through these macros which are mapped to C functions depending on
the Python configuration.
their methods and attributes.
.. versionchanged:: 2.6
-
ctypes data types that are not and do not contain pointers can
now be pickled.
'<.02>'
"""
- q = Decimal((0, (1,), -places)) # 2 places --> '0.01'
- sign, digits, exp = value.quantize(q).as_tuple()
- assert exp == -places
+ q = Decimal(10) ** -places # 2 places --> '0.01'
+ sign, digits, exp = value.quantize(q).as_tuple()
result = []
digits = map(str, digits)
build, next = result.append, digits.pop
if sign:
build(trailneg)
for i in range(places):
- if digits:
- build(next())
- else:
- build('0')
+ build(next() if digits else '0')
build(dp)
i = 0
while digits:
i = 0
build(sep)
build(curr)
- if sign:
- build(neg)
- else:
- build(pos)
- result.reverse()
- return ''.join(result)
+ build(neg if sign else pos)
+ return ''.join(reversed(result))
def pi():
"""Compute Pi to the current precision.
Q. It is cumbersome to type ``decimal.Decimal('1234.5')``. Is there a way to
minimize typing when using the interactive interpreter?
-\A. Some users abbreviate the constructor to just a single letter::
+A. Some users abbreviate the constructor to just a single letter::
>>> D = decimal.Decimal
>>> D('1.23') + D('3.45')
Q. Once I have valid two place inputs, how do I maintain that invariant
throughout an application?
-A. Some operations like addition and subtraction automatically preserve fixed
-point. Others, like multiplication and division, change the number of decimal
-places and need to be followed-up with a :meth:`quantize` step.
+A. Some operations like addition, subtraction, and multiplication by an integer
+will automatically preserve fixed point. Others operations, like division and
+non-integer multiplication, will change the number of decimal places and need to
+be followed-up with a :meth:`quantize` step::
+
+ >>> a = Decimal('102.72') # Initial fixed-point values
+ >>> b = Decimal('3.17')
+ >>> a + b # Addition preserves fixed-point
+ Decimal('105.89')
+ >>> a - b
+ Decimal('99.55')
+ >>> a * 42 # So does integer multiplication
+ Decimal('4314.24')
+ >>> (a * b).quantize(TWOPLACES) # Must quantize non-integer multiplication
+ Decimal('325.62')
+ >>> (b / a).quantize(TWOPLACES) # And quantize division
+ Decimal('0.03')
+
+In developing fixed-point applications, it is convenient to define functions
+to handle the :meth:`quantize` step::
+
+ >>> def mul(x, y, fp=TWOPLACES):
+ ... return (x * y).quantize(fp)
+ >>> def div(x, y, fp=TWOPLACES):
+ ... return (x / y).quantize(fp)
+
+ >>> mul(a, b) # Automatically preserve fixed-point
+ Decimal('325.62')
+ >>> div(b, a)
+ Decimal('0.03')
Q. There are many ways to express the same value. The numbers :const:`200`,
:const:`200.000`, :const:`2E2`, and :const:`.02E+4` all have the same value at
:const:`5.0E+3` as :const:`5000` keeps the value constant but cannot show the
original's two-place significance.
+If an application does not care about tracking significance, it is easy to
+remove the exponent and trailing zeroes, losing signficance, but keeping the
+value unchanged::
+
+ >>> def remove_exponent(d):
+ ... return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()
+
+ >>> remove_exponent(Decimal('5E+3'))
+ Decimal('5000')
+
Q. Is there a way to convert a regular float to a :class:`Decimal`?
A. Yes, all binary floating point numbers can be exactly expressed as a
int int
>>> var._asdict()
{'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
- >>> v2 = var._replace('name', 'amplitude')
+ >>> v2 = var._replace(name='amplitude')
>>> v2
variable(id=1, name='amplitude', type='int', size=4)
#define PyMethod_GET_SELF(meth) \
(((PyMethodObject *)meth) -> im_self)
+PyAPI_FUNC(int) PyMethod_ClearFreeList(void);
typedef struct {
PyObject_HEAD
PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int);
PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
+PyAPI_FUNC(int) PyFrame_ClearFreeList(void);
+
#ifdef __cplusplus
}
#endif
PyObject *m_module; /* The __module__ attribute, can be anything */
} PyCFunctionObject;
+PyAPI_FUNC(int) PyCFunction_ClearFreeList(void);
+
#ifdef __cplusplus
}
#endif
/* Macro, *only* to be used to fill in brand new tuples */
#define PyTuple_SET_ITEM(op, i, v) (((PyTupleObject *)(op))->ob_item[i] = v)
+PyAPI_FUNC(int) PyTuple_ClearFreeList(void);
+
#ifdef __cplusplus
}
#endif
# define _PyUnicode_AsDefaultEncodedString _PyUnicodeUCS2_AsDefaultEncodedString
# define _PyUnicode_Fini _PyUnicodeUCS2_Fini
# define _PyUnicode_Init _PyUnicodeUCS2_Init
+# define PyUnicode_ClearFreeList PyUnicodeUCS2_ClearFreelist
# define _PyUnicode_IsAlpha _PyUnicodeUCS2_IsAlpha
# define _PyUnicode_IsDecimalDigit _PyUnicodeUCS2_IsDecimalDigit
# define _PyUnicode_IsDigit _PyUnicodeUCS2_IsDigit
# define _PyUnicode_AsDefaultEncodedString _PyUnicodeUCS4_AsDefaultEncodedString
# define _PyUnicode_Fini _PyUnicodeUCS4_Fini
# define _PyUnicode_Init _PyUnicodeUCS4_Init
+# define PyUnicode_ClearFreeList PyUnicodeUCS2_ClearFreelist
# define _PyUnicode_IsAlpha _PyUnicodeUCS4_IsAlpha
# define _PyUnicode_IsDecimalDigit _PyUnicodeUCS4_IsDecimalDigit
# define _PyUnicode_IsDigit _PyUnicodeUCS4_IsDigit
extern "C" {
#endif
+PyAPI_FUNC(int) PyUnicode_ClearFreeList(void);
+
/* --- Unicode Type ------------------------------------------------------- */
typedef struct {
except os.error:
pid = None
if not pid: break
- self.active_children.remove(pid)
+ try:
+ self.active_children.remove(pid)
+ except ValueError as e:
+ raise ValueError('%s. x=%d and list=%r' % (e.message, pid,
+ self.active_children))
def handle_timeout(self):
"""Wait for zombies after self.timeout seconds of inactivity.
def upper(self): return self.__class__(self.data.upper())
def zfill(self, width): return self.__class__(self.data.zfill(width))
-collections.Sequence.register(UserString)
-
class MutableString(UserString, collections.MutableSequence):
"""mutable string objects
self.width = idleConf.GetOption('main','EditorWindow','width')
self.text = text = MultiCallCreator(Text)(
text_frame, name='text', padx=5, wrap='none',
- foreground=idleConf.GetHighlight(currentTheme,
- 'normal',fgBg='fg'),
- background=idleConf.GetHighlight(currentTheme,
- 'normal',fgBg='bg'),
- highlightcolor=idleConf.GetHighlight(currentTheme,
- 'hilite',fgBg='fg'),
- highlightbackground=idleConf.GetHighlight(currentTheme,
- 'hilite',fgBg='bg'),
- insertbackground=idleConf.GetHighlight(currentTheme,
- 'cursor',fgBg='fg'),
width=self.width,
height=idleConf.GetOption('main','EditorWindow','height') )
self.top.focused_widget = self.text
# Making the initial values larger slows things down more often.
self.num_context_lines = 50, 500, 5000000
self.per = per = self.Percolator(text)
- self.color = None
self.undo = undo = self.UndoDelegator()
per.insertfilter(undo)
text.undo_block_start = undo.undo_block_start
io.set_filename_change_hook(self.filename_change_hook)
self.good_load = False
self.set_indentation_params(False)
+ self.color = None # initialized below in self.ResetColorizer
if filename:
if os.path.exists(filename) and not os.path.isdir(filename):
if io.loadfile(filename):
per.insertfilter(color)
else:
io.set_filename(filename)
+ self.ResetColorizer()
self.saved_change_hook()
self.update_recent_files_list()
self.load_extensions()
self.flist.filename_changed_edit(self)
self.saved_change_hook()
self.top.update_windowlist_registry(self)
- if self.ispythonsource(self.io.filename):
- self.addcolorizer()
- else:
- self.rmcolorizer()
+ self.ResetColorizer()
- def addcolorizer(self):
+ def _addcolorizer(self):
if self.color:
return
- self.per.removefilter(self.undo)
- self.color = self.ColorDelegator()
- self.per.insertfilter(self.color)
- self.per.insertfilter(self.undo)
+ if self.ispythonsource(self.io.filename):
+ self.color = self.ColorDelegator()
+ # can add more colorizers here...
+ if self.color:
+ self.per.removefilter(self.undo)
+ self.per.insertfilter(self.color)
+ self.per.insertfilter(self.undo)
- def rmcolorizer(self):
+ def _rmcolorizer(self):
if not self.color:
return
self.color.removecolors()
- self.per.removefilter(self.undo)
self.per.removefilter(self.color)
self.color = None
- self.per.insertfilter(self.undo)
def ResetColorizer(self):
- "Update the colour theme if it is changed"
- # Called from configDialog.py
- if self.color:
- self.color = self.ColorDelegator()
- self.per.insertfilter(self.color)
+ "Update the colour theme"
+ # Called from self.filename_change_hook and from configDialog.py
+ self._rmcolorizer()
+ self._addcolorizer()
theme = idleConf.GetOption('main','Theme','name')
- self.text.config(idleConf.GetHighlight(theme, "normal"))
+ normal_colors = idleConf.GetHighlight(theme, 'normal')
+ cursor_color = idleConf.GetHighlight(theme, 'cursor', fgBg='fg')
+ select_colors = idleConf.GetHighlight(theme, 'hilite')
+ self.text.config(
+ foreground=normal_colors['foreground'],
+ background=normal_colors['background'],
+ insertbackground=cursor_color,
+ selectforeground=select_colors['foreground'],
+ selectbackground=select_colors['background'],
+ )
IDENTCHARS = string.ascii_letters + string.digits + "_"
*Release date: XX-XXX-200X* UNRELEASED, but merged into 3.0
+- Configured selection highlighting colors were ignored; updating highlighting
+ in the config dialog would cause non-Python files to be colored as if they
+ were Python source; improve use of ColorDelagator. Patch 1334. Tal Einat.
+
+- ScriptBinding event handlers weren't returning 'break'. Patch 2050, Tal Einat.
+
- There was an error on exit if no sys.exitfunc was defined. Issue 1647.
- Could not open files in .idlerc directory if latter was hidden on Windows.
def check_module_event(self, event):
filename = self.getfilename()
if not filename:
- return
+ return 'break'
if not self.checksyntax(filename):
- return
+ return 'break'
if not self.tabnanny(filename):
- return
+ return 'break'
def tabnanny(self, filename):
f = open(filename, 'r')
"""
filename = self.getfilename()
if not filename:
- return
+ return 'break'
code = self.checksyntax(filename)
if not code:
- return
+ return 'break'
if not self.tabnanny(filename):
- return
+ return 'break'
shell = self.shell
interp = shell.interp
if PyShell.use_subprocess:
# go to __stderr__. With subprocess, they go to the shell.
# Need to change streams in PyShell.ModifiedInterpreter.
interp.runcode(code)
+ return 'break'
def getfilename(self):
"""Get source filename. If not saved, offer to save (or create) file
def ActivateConfigChanges(self):
"Dynamically apply configuration changes"
winInstances = self.parent.instance_dict.keys()
- theme = idleConf.CurrentTheme()
- cursor_color = idleConf.GetHighlight(theme, 'cursor', fgBg='fg')
for instance in winInstances:
instance.ResetColorizer()
instance.ResetFont()
instance.set_notabs_indentwidth()
instance.ApplyKeybindings()
instance.reset_help_menu_entries()
- instance.text.configure(insertbackground=cursor_color)
def Cancel(self):
self.destroy()
from random import random
from math import atan2
+INF = float("inf")
+NAN = float("nan")
# These tests ensure that complex math does the right thing
class ComplexTest(unittest.TestCase):
self.assertEqual(-6j,complex(repr(-6j)))
self.assertEqual(6j,complex(repr(6j)))
+ self.assertEqual(repr(complex(1., INF)), "(1+inf*j)")
+ self.assertEqual(repr(complex(1., -INF)), "(1-inf*j)")
+ self.assertEqual(repr(complex(INF, 1)), "(inf+1j)")
+ self.assertEqual(repr(complex(-INF, INF)), "(-inf+inf*j)")
+ self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)")
+ self.assertEqual(repr(complex(1, NAN)), "(1+nan*j)")
+ self.assertEqual(repr(complex(NAN, NAN)), "(nan+nan*j)")
+
+ self.assertEqual(repr(complex(0, INF)), "inf*j")
+ self.assertEqual(repr(complex(0, -INF)), "-inf*j")
+ self.assertEqual(repr(complex(0, NAN)), "nan*j")
+
def test_neg(self):
self.assertEqual(-(1+6j), -1-6j)
a.foo = 42
self.assertEqual(a.__dict__, {"foo": 42})
+ def test_slots_descriptor(self):
+ # Issue2115: slot descriptors did not correctly check
+ # the type of the given object
+ import abc
+ class MyABC(metaclass=abc.ABCMeta):
+ __slots__ = "a"
+
+ class Unrelated(object):
+ pass
+ MyABC.register(Unrelated)
+
+ u = Unrelated()
+ self.assert_(isinstance(u, MyABC))
+
+ # This used to crash
+ self.assertRaises(TypeError, MyABC.a.__set__, u, 3)
+
def test_dynamics(self):
# Testing class attribute propagation...
class D(object):
gc.disable()
gc.set_threshold(*thresholds)
+ # The following two tests are fragile:
+ # They precisely count the number of allocations,
+ # which is highly implementation-dependent.
+ # For example:
+ # - disposed tuples are not freed, but reused
+ # - the call to assertEqual somehow avoids building its args tuple
def test_get_count(self):
+ # Avoid future allocation of method object
+ assertEqual = self.assertEqual
gc.collect()
- self.assertEqual(gc.get_count(), (0, 0, 0))
+ assertEqual(gc.get_count(), (0, 0, 0))
a = dict()
- self.assertEqual(gc.get_count(), (1, 0, 0))
+ # since gc.collect(), we created two objects:
+ # the dict, and the tuple returned by get_count()
+ assertEqual(gc.get_count(), (2, 0, 0))
def test_collect_generations(self):
+ # Avoid future allocation of method object
+ assertEqual = self.assertEqual
gc.collect()
a = dict()
gc.collect(0)
- self.assertEqual(gc.get_count(), (0, 1, 0))
+ assertEqual(gc.get_count(), (0, 1, 0))
gc.collect(1)
- self.assertEqual(gc.get_count(), (0, 0, 1))
+ assertEqual(gc.get_count(), (0, 0, 1))
gc.collect(2)
- self.assertEqual(gc.get_count(), (0, 0, 0))
+ assertEqual(gc.get_count(), (0, 0, 0))
def test_trashcan(self):
class Ouch:
return mmap.mmap.__new__(klass, -1, *args, **kwargs)
anon_mmap(PAGESIZE)
+ def test_prot_readonly(self):
+ mapsize = 10
+ open(TESTFN, "wb").write(b"a"*mapsize)
+ f = open(TESTFN, "rb")
+ m = mmap.mmap(f.fileno(), mapsize, prot=mmap.PROT_READ)
+ self.assertRaises(TypeError, m.write, "foo")
+
def test_main():
run_unittest(MmapTests)
Core and Builtins
-----------------
+<<<<<<< .working
+=======
+- Issue #2115: Important speedup in setting __slot__ attributes. Also
+ prevent a possible crash: an Abstract Base Class would try to access a slot
+ on a registered virtual subclass.
+
+- Fixed repr() and str() of complex numbers with infinity or nan as real or
+ imaginary part.
+
+- Clear all free list during a gc.collect() of the highest generation in order
+ to allow pymalloc to free more arenas. Python may give back memory to the
+ OS earlier.
+
+- Issue #2045: Fix an infinite recursion triggered when printing a subclass of
+ collections.defaultdict, if its default_factory is set to a bound method.
+
+- Fixed a minor memory leak in dictobject.c. The content of the free
+ list was not freed on interpreter shutdown.
+
+- Limit free list of method and builtin function objects to 256 entries
+ each.
+
+- Patch #1953: Added ``sys._compact_freelists()`` and the C API functions
+ ``PyInt_CompactFreeList`` and ``PyFloat_CompactFreeList``
+ to compact the internal free lists of pre-allocted ints and floats.
+
+- Bug #1983: Fixed return type of fork(), fork1() and forkpty() calls.
+ Python expected the return type int but the fork familie returns pi_t.
+
+- Issue #1678380: Fix a bug that identifies 0j and -0j when they appear
+ in the same code unit.
+
+>>>>>>> .merge-right.r60845
- Issue #2025 : Add tuple.count() and tuple.index() methods to comply with
the collections.Sequence API.
Extension Modules
-----------------
+<<<<<<< .working
- Issue #1762972: Readded the reload() function as imp.reload()
+=======
+- Bug #2111: mmap segfaults when trying to write a block opened with PROT_READ
+
+- #2063: correct order of utime and stime in os.times() result on Windows.
+>>>>>>> .merge-right.r60845
Library
echo "<li><a href=\"$2\">$1</a> <font size=\"-1\">($time seconds)</font></li>" >> $RESULT_FILE
}
+place_summary_first() {
+ testf=$1
+ sed -n '/^[0-9][0-9]* tests OK\./,$p' < $testf \
+ | egrep -v '\[[0-9]+ refs\]' > $testf.tmp
+ echo "" >> $testf.tmp
+ cat $testf >> $testf.tmp
+ mv $testf.tmp $testf
+}
+
+count_failures () {
+ testf=$1
+ n=`grep -ic " failed:" $testf`
+ if [ $n -eq 1 ] ; then
+ n=`grep " failed:" $testf | sed -e 's/ .*//'`
+ fi
+ echo $n
+}
+
mail_on_failure() {
if [ "$NUM_FAILURES" != "0" ]; then
dest=$FAILURE_MAILTO
F=make-test.out
start=`current_time`
$PYTHON $REGRTEST_ARGS $ALWAYS_SKIP >& build/$F
- NUM_FAILURES=`grep -ic " failed:" build/$F`
+ NUM_FAILURES=`count_failures build/$F`
+ place_summary_first build/$F
update_status "Testing basics ($NUM_FAILURES failures)" "$F" $start
mail_on_failure "basics" build/$F
F=make-test-opt.out
start=`current_time`
$PYTHON -O $REGRTEST_ARGS $ALWAYS_SKIP >& build/$F
- NUM_FAILURES=`grep -ic " failed:" build/$F`
+ NUM_FAILURES=`count_failures build/$F`
+ place_summary_first build/$F
update_status "Testing opt ($NUM_FAILURES failures)" "$F" $start
mail_on_failure "opt" build/$F
$PYTHON $REGRTEST_ARGS -R 4:3:$REFLOG -u network $LEAKY_SKIPS >& build/$F
LEAK_PAT="($LEAKY_TESTS|sum=0)"
NUM_FAILURES=`egrep -vc "$LEAK_PAT" $REFLOG`
+ place_summary_first build/$F
update_status "Testing refleaks ($NUM_FAILURES failures)" "$F" $start
mail_on_failure "refleak" $REFLOG "$LEAK_PAT"
## skip curses when running from cron since there's no terminal
## skip sound since it's not setup on the PSF box (/dev/dsp)
$PYTHON $REGRTEST_ARGS -uall -x test_curses test_linuxaudiodev test_ossaudiodev $_ALWAYS_SKIP >& build/$F
- NUM_FAILURES=`grep -ic " failed:" build/$F`
+ NUM_FAILURES=`count_failures build/$F`
+ place_summary_first build/$F
update_status "Testing all except curses and sound ($NUM_FAILURES failures)" "$F" $start
mail_on_failure "all" build/$F
fi
*/
#include "Python.h"
+#include "frameobject.h" /* for PyFrame_ClearFreeList */
/* Get an object's GC head */
#define AS_GC(o) ((PyGC_Head *)(o)-1)
}
}
+/* Clear all free lists
+ * All free lists are cleared during the collection of the highest generation.
+ * Allocated items in the free list may keep a pymalloc arena occupied.
+ * Clearing the free lists may give back memory to the OS earlier.
+ */
+static void
+clear_freelists(void)
+{
+ (void)PyMethod_ClearFreeList();
+ (void)PyFrame_ClearFreeList();
+ (void)PyCFunction_ClearFreeList();
+ (void)PyTuple_ClearFreeList();
+ (void)PyUnicode_ClearFreeList();
+}
+
/* This is the main function. Read this to understand how the
* collection process works. */
static Py_ssize_t
*/
(void)handle_finalizers(&finalizers, old);
+ /* Clear free list only during the collection of the higest
+ * generation */
+ if (generation == NUM_GENERATIONS-1) {
+ clear_freelists();
+ }
+
if (PyErr_Occurred()) {
if (gc_str == NULL)
gc_str = PyUnicode_FromString("garbage collection");
"mmap invalid access parameter.");
}
+ if (prot == PROT_READ) {
+ access = ACCESS_READ;
+ }
+
#ifdef HAVE_FSTAT
# ifdef __VMS
/* on OpenVMS we must ensure that all bytes are written to the file */
PyObject *
PyNumber_ToBase(PyObject *n, int base)
{
- PyObject *res;
+ PyObject *res = NULL;
PyObject *index = PyNumber_Index(n);
if (!index)
return NULL;
- assert(PyLong_Check(index));
- res = _PyLong_Format(index, base);
+ if (PyLong_Check(index))
+ res = _PyLong_Format(index, base);
+ else
+ /* It should not be possible to get here, as
+ PyNumber_Index already has a check for the same
+ condition */
+ PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not "
+ "int or long");
Py_DECREF(index);
return res;
}
int
PyObject_IsInstance(PyObject *inst, PyObject *cls)
{
+ static PyObject *name = NULL;
PyObject *t, *v, *tb;
PyObject *checker;
PyErr_Fetch(&t, &v, &tb);
- checker = PyObject_GetAttrString(cls, "__instancecheck__");
+
+ if (name == NULL) {
+ name = PyUnicode_InternFromString("__instancecheck__");
+ if (name == NULL)
+ return -1;
+ }
+ checker = PyObject_GetAttr(cls, name);
PyErr_Restore(t, v, tb);
if (checker != NULL) {
PyObject *res;
int
PyObject_IsSubclass(PyObject *derived, PyObject *cls)
{
+ static PyObject *name = NULL;
PyObject *t, *v, *tb;
PyObject *checker;
PyErr_Fetch(&t, &v, &tb);
- checker = PyObject_GetAttrString(cls, "__subclasscheck__");
+
+ if (name == NULL) {
+ name = PyUnicode_InternFromString("__subclasscheck__");
+ if (name == NULL)
+ return -1;
+ }
+ checker = PyObject_GetAttr(cls, name);
PyErr_Restore(t, v, tb);
if (checker != NULL) {
PyObject *res;
/* Clear out the free list */
-void
-PyMethod_Fini(void)
+int
+PyMethod_ClearFreeList(void)
{
+ int freelist_size = numfree;
+
while (free_list) {
PyMethodObject *im = free_list;
free_list = (PyMethodObject *)(im->im_self);
numfree--;
}
assert(numfree == 0);
+ return freelist_size;
+}
+
+void
+PyMethod_Fini(void)
+{
+ (void)PyMethod_ClearFreeList();
}
/* ------------------------------------------------------------------------
{
char format[32];
if (v->cval.real == 0.) {
- PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
- PyOS_ascii_formatd(buf, bufsz - 1, format, v->cval.imag);
- strncat(buf, "j", 1);
+ if (!Py_IS_FINITE(v->cval.imag)) {
+ if (Py_IS_NAN(v->cval.imag))
+ strncpy(buf, "nan*j", 6);
+ /* else if (copysign(1, v->cval.imag) == 1) */
+ else if (v->cval.imag > 0)
+ strncpy(buf, "inf*j", 6);
+ else
+ strncpy(buf, "-inf*j", 7);
+ }
+ else {
+ PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
+ PyOS_ascii_formatd(buf, bufsz - 1, format, v->cval.imag);
+ strncat(buf, "j", 1);
+ }
} else {
char re[64], im[64];
/* Format imaginary part with sign, real part without */
- PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
- PyOS_ascii_formatd(re, sizeof(re), format, v->cval.real);
- PyOS_snprintf(format, sizeof(format), "%%+.%ig", precision);
- PyOS_ascii_formatd(im, sizeof(im), format, v->cval.imag);
+ if (!Py_IS_FINITE(v->cval.real)) {
+ if (Py_IS_NAN(v->cval.real))
+ strncpy(re, "nan", 4);
+ /* else if (copysign(1, v->cval.real) == 1) */
+ else if (v->cval.real > 0)
+ strncpy(re, "inf", 4);
+ else
+ strncpy(re, "-inf", 5);
+ }
+ else {
+ PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
+ PyOS_ascii_formatd(re, sizeof(re), format, v->cval.real);
+ }
+ if (!Py_IS_FINITE(v->cval.imag)) {
+ if (Py_IS_NAN(v->cval.imag))
+ strncpy(im, "+nan*", 6);
+ /* else if (copysign(1, v->cval.imag) == 1) */
+ else if (v->cval.imag > 0)
+ strncpy(im, "+inf*", 6);
+ else
+ strncpy(im, "-inf*", 6);
+ }
+ else {
+ PyOS_snprintf(format, sizeof(format), "%%+.%ig", precision);
+ PyOS_ascii_formatd(im, sizeof(im), format, v->cval.imag);
+ }
PyOS_snprintf(buf, bufsz, "(%s%sj)", re, im);
}
}
int *pres)
{
assert(obj != NULL);
- if (!PyObject_IsInstance(obj, (PyObject *)(descr->d_type))) {
+ if (!PyObject_TypeCheck(obj, descr->d_type)) {
PyErr_Format(PyExc_TypeError,
"descriptor '%V' for '%.100s' objects "
"doesn't apply to '%.100s' object",
}
/* Clear out the free list */
-
-void
-PyFrame_Fini(void)
+int
+PyFrame_ClearFreeList(void)
{
+ int freelist_size = numfree;
+
while (free_list != NULL) {
PyFrameObject *f = free_list;
free_list = free_list->f_back;
--numfree;
}
assert(numfree == 0);
+ return freelist_size;
+}
+
+void
+PyFrame_Fini(void)
+{
+ (void)PyFrame_ClearFreeList();
Py_XDECREF(builtin_object);
builtin_object = NULL;
}
/* Clear out the free list */
-void
-PyCFunction_Fini(void)
+int
+PyCFunction_ClearFreeList(void)
{
+ int freelist_size = numfree;
+
while (free_list) {
PyCFunctionObject *v = free_list;
free_list = (PyCFunctionObject *)(v->m_self);
numfree--;
}
assert(numfree == 0);
+ return freelist_size;
+}
+
+void
+PyCFunction_Fini(void)
+{
+ (void)PyCFunction_ClearFreeList();
}
/* PyCFunction_New() is now just a macro that calls PyCFunction_NewEx(),
return 0;
}
-void
-PyTuple_Fini(void)
+int
+PyTuple_ClearFreeList(void)
{
+ int freelist_size = 0;
#if PyTuple_MAXSAVESIZE > 0
int i;
-
- Py_XDECREF(free_list[0]);
- free_list[0] = NULL;
-
for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
PyTupleObject *p, *q;
p = free_list[i];
+ freelist_size += numfree[i];
free_list[i] = NULL;
+ numfree[i] = 0;
while (p) {
q = p;
p = (PyTupleObject *)(p->ob_item[0]);
PyObject_GC_Del(q);
}
}
+#endif
+ return freelist_size;
+}
+
+void
+PyTuple_Fini(void)
+{
+#if PyTuple_MAXSAVESIZE > 0
+ /* empty tuples are used all over the place and applications may
+ * rely on the fact that an empty tuple is a singleton. */
+ Py_XDECREF(free_list[0]);
+ free_list[0] = NULL;
+
+ (void)PyTuple_ClearFreeList();
#endif
}
/* Finalize the Unicode implementation */
+int
+PyUnicode_ClearFreeList(void)
+{
+ int freelist_size = numfree;
+ PyUnicodeObject *u;
+
+ for (u = free_list; u != NULL;) {
+ PyUnicodeObject *v = u;
+ u = *(PyUnicodeObject **)u;
+ if (v->str)
+ PyMem_DEL(v->str);
+ Py_XDECREF(v->defenc);
+ PyObject_Del(v);
+ numfree--;
+ }
+ free_list = NULL;
+ assert(numfree == 0);
+ return freelist_size;
+}
+
void
_PyUnicode_Fini(void)
{
- PyUnicodeObject *u;
int i;
Py_XDECREF(unicode_empty);
unicode_latin1[i] = NULL;
}
}
-
- for (u = free_list; u != NULL;) {
- PyUnicodeObject *v = u;
- u = *(PyUnicodeObject **)u;
- if (v->str)
- PyMem_DEL(v->str);
- Py_XDECREF(v->defenc);
- PyObject_Del(v);
- }
- free_list = NULL;
- numfree = 0;
+ (void)PyUnicode_ClearFreeList();
}
void
projects / python / commitdiff