Note that *lock* is a keyword only argument.
- Note that an array of :data:`ctypes.c_char` has *value* and *rawvalue*
+ Note that an array of :data:`ctypes.c_char` has *value* and *raw*
attributes which allow one to use it to store and retrieve strings.
:func:`Value` instead to make sure that access is automatically synchronized
using a lock.
- Note that an array of :data:`ctypes.c_char` has ``value`` and ``rawvalue``
+ Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw``
attributes which allow one to use it to store and retrieve strings -- see
documentation for :mod:`ctypes`.
q(uit)
Quit from the debugger. The program being executed is aborted.
-
-
-.. _debugger-hooks:
-
-How It Works
-============
-
-Some changes were made to the interpreter:
-
-* ``sys.settrace(func)`` sets the global trace function
-
-* there can also a local trace function (see later)
-
-Trace functions have three arguments: *frame*, *event*, and *arg*. *frame* is
-the current stack frame. *event* is a string: ``'call'``, ``'line'``,
-``'return'``, ``'exception'``, ``'c_call'``, ``'c_return'``, or
-``'c_exception'``. *arg* depends on the event type.
-
-The global trace function is invoked (with *event* set to ``'call'``) whenever a
-new local scope is entered; it should return a reference to the local trace
-function to be used that scope, or ``None`` if the scope shouldn't be traced.
-
-The local trace function should return a reference to itself (or to another
-function for further tracing in that scope), or ``None`` to turn off tracing in
-that scope.
-
-Instance methods are accepted (and very useful!) as trace functions.
-
-The events have the following meaning:
-
-``'call'``
- A function is called (or some other code block entered). The global trace
- function is called; *arg* is ``None``; the return value specifies the local
- trace function.
-
-``'line'``
- The interpreter is about to execute a new line of code (sometimes multiple line
- events on one line exist). The local trace function is called; *arg* is
- ``None``; the return value specifies the new local trace function.
-
-``'return'``
- A function (or other code block) is about to return. The local trace function
- is called; *arg* is the value that will be returned. The trace function's
- return value is ignored.
-
-``'exception'``
- An exception has occurred. The local trace function is called; *arg* is a
- triple ``(exception, value, traceback)``; the return value specifies the new
- local trace function.
-
-``'c_call'``
- A C function is about to be called. This may be an extension function or a
- builtin. *arg* is the C function object.
-
-``'c_return'``
- A C function has returned. *arg* is ``None``.
-
-``'c_exception'``
- A C function has thrown an exception. *arg* is ``None``.
-
-Note that as an exception is propagated down the chain of callers, an
-``'exception'`` event is generated at each level.
-
-For more information on code and frame objects, refer to :ref:`types`.
-
single: debugger
Set the system's trace function, which allows you to implement a Python
- source code debugger in Python. See section :ref:`debugger-hooks` in the
- chapter on the Python debugger. The function is thread-specific; for a
+ source code debugger in Python. The function is thread-specific; for a
debugger to support multiple threads, it must be registered using
:func:`settrace` for each thread being debugged.
+ Trace functions should have three arguments: *frame*, *event*, and
+ *arg*. *frame* is the current stack frame. *event* is a string: ``'call'``,
+ ``'line'``, ``'return'``, ``'exception'``, ``'c_call'``, ``'c_return'``, or
+ ``'c_exception'``. *arg* depends on the event type.
+
+ The trace function is invoked (with *event* set to ``'call'``) whenever a new
+ local scope is entered; it should return a reference to a local trace
+ function to be used that scope, or ``None`` if the scope shouldn't be traced.
+
+ The local trace function should return a reference to itself (or to another
+ function for further tracing in that scope), or ``None`` to turn off tracing
+ in that scope.
+
+ The events have the following meaning:
+
+ ``'call'``
+ A function is called (or some other code block entered). The
+ global trace function is called; *arg* is ``None``; the return value
+ specifies the local trace function.
+
+ ``'line'``
+ The interpreter is about to execute a new line of code (sometimes multiple
+ line events on one line exist). The local trace function is called; *arg*
+ is ``None``; the return value specifies the new local trace function.
+
+ ``'return'``
+ A function (or other code block) is about to return. The local trace
+ function is called; *arg* is the value that will be returned. The trace
+ function's return value is ignored.
+
+ ``'exception'``
+ An exception has occurred. The local trace function is called; *arg* is a
+ tuple ``(exception, value, traceback)``; the return value specifies the
+ new local trace function.
+
+ ``'c_call'``
+ A C function is about to be called. This may be an extension function or
+ a builtin. *arg* is the C function object.
+
+ ``'c_return'``
+ A C function has returned. *arg* is ``None``.
+
+ ``'c_exception'``
+ A C function has thrown an exception. *arg* is ``None``.
+
+ Note that as an exception is propagated down the chain of callers, an
+ ``'exception'`` event is generated at each level.
+
+ For more information on code and frame objects, refer to :ref:`types`.
+
.. note::
The :func:`settrace` function is intended only for implementing debuggers,
# Issue 4348. Make sure that operations that don't mutate the array
# copy the bytes.
b = bytearray(b'abc')
- #self.assertFalse(b is b.replace(b'abc', b'cde', 0))
+ self.assertFalse(b is b.replace(b'abc', b'cde', 0))
t = bytearray([i for i in range(256)])
x = bytearray(b'')
# When the system provides a version-1 UUID generator, use it (but don't
# use UuidCreate here because its UUIDs don't conform to RFC 4122).
- _buffer = ctypes.create_string_buffer(16)
if _uuid_generate_time and node is clock_seq is None:
+ _buffer = ctypes.create_string_buffer(16)
_uuid_generate_time(_buffer)
return UUID(bytes=bytes_(_buffer.raw))
"""Generate a random UUID."""
# When the system provides a version-4 UUID generator, use it.
- _buffer = ctypes.create_string_buffer(16)
if _uuid_generate_random:
+ _buffer = ctypes.create_string_buffer(16)
_uuid_generate_random(_buffer)
return UUID(bytes=bytes_(_buffer.raw))
Core and Builtins
-----------------
+- Issue #3996: On Windows, the PyOS_CheckStack function would cause the
+ interpreter to abort ("Fatal Python error: Could not reset the stack!")
+ instead of throwing a MemoryError.
+
+- Issue #4367: Python would segfault during compiling when the unicodedata
+ module couldn't be imported and \N escapes were present.
+
Library
-------
Library
-------
+- Issue #4363: The uuid.uuid1() and uuid.uuid4() functions now work even if
+ the ctypes module is not present.
+
- FileIO's mode attribute now always includes ``"b"``.
- Issue #3799: Fix dbm.dumb to accept strings as well as bytes for keys. String
# End Source File\r
# Begin Source File\r
\r
-SOURCE=..\..\Modules\yuvconvert.c\r
-# End Source File\r
-# Begin Source File\r
-\r
SOURCE=..\..\Modules\zipimport.c\r
# End Source File\r
# Begin Source File\r
<File
RelativePath="..\..\Modules\xxsubtype.c">
</File>
- <File
- RelativePath="..\..\Modules\yuvconvert.c">
- </File>
<File
RelativePath="..\..\Modules\zipimport.c">
</File>
RelativePath="..\..\Modules\xxsubtype.c"
>
</File>
- <File
- RelativePath="..\..\Modules\yuv.h"
- >
- </File>
- <File
- RelativePath="..\..\Modules\yuvconvert.c"
- >
- </File>
<File
RelativePath="..\..\Modules\zipimport.c"
>
$(PATHOBJ)\StropModule.obj \
$(PATHOBJ)\StructModule.obj \
$(PATHOBJ)\TimeModule.obj \
- $(PATHOBJ)\ThreadModule.obj \
- $(PATHOBJ)\YUVConvert.obj
+ $(PATHOBJ)\ThreadModule.obj
# Standalone Parser Generator Program (Shares Some of Python's Modules)
PGEN = \
$(PY_INCLUDE)\sliceobject.h $(PY_INCLUDE)\stringobject.h \
$(PY_INCLUDE)\sysmodule.h $(PY_INCLUDE)\traceback.h $(PY_INCLUDE)\tupleobject.h
-yuvconvert.obj: $(PY_MODULES)\yuv.h
-
zlibmodule.obj: $(PY_INCLUDE)\abstract.h $(PY_INCLUDE)\ceval.h $(PY_INCLUDE)\classobject.h \
$(PY_INCLUDE)\cobject.h $(PY_INCLUDE)\complexobject.h pyconfig.h \
$(PY_INCLUDE)\dictobject.h $(PY_INCLUDE)\fileobject.h $(PY_INCLUDE)\floatobject.h \
StropModule.obj \
StructModule.obj \
TimeModule.obj \
- ThreadModule.obj \
- YUVConvert.obj
+ ThreadModule.obj
# Omitted Modules (and Description/Reason):
#
pythonrun.h rangeobject.h sliceobject.h stringobject.h sysmodule.h \
traceback.h tupleobject.h
-yuvconvert.obj: yuv.h
-
zlibmodule.obj: abstract.h ceval.h classobject.h cobject.h complexobject.h \
pyconfig.h dictobject.h fileobject.h floatobject.h funcobject.h \
import.h intobject.h intrcheck.h listobject.h longobject.h \
RelativePath="..\Modules\xxsubtype.c"
>
</File>
- <File
- RelativePath="..\Modules\yuv.h"
- >
- </File>
- <File
- RelativePath="..\Modules\yuvconvert.c"
- >
- </File>
<File
RelativePath="..\Modules\zipimport.c"
>
EXCEPTION_EXECUTE_HANDLER :
EXCEPTION_CONTINUE_SEARCH) {
int errcode = _resetstkoflw();
- if (errcode)
+ if (errcode == 0)
{
Py_FatalError("Could not reset the stack!");
}
projects / python / commitdiff