Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

1 files changed, 248 insertions, 248 deletions

diff --git a/contrib/tools/cython/Cython/Includes/cpython/exc.pxd b/contrib/tools/cython/Cython/Includes/cpython/exc.pxd
index bc57c0e571..de0a086e11 100644
--- a/contrib/tools/cython/Cython/Includes/cpython/exc.pxd
+++ b/contrib/tools/cython/Cython/Includes/cpython/exc.pxd
@@ -1,158 +1,158 @@
 from .object cimport PyObject
-
-cdef extern from "Python.h":
-
-    #####################################################################
-    # 3. Exception Handling
-    #####################################################################
-
-    # The functions described in this chapter will let you handle and
-    # raise Python exceptions. It is important to understand some of
-    # the basics of Python exception handling. It works somewhat like
-    # the Unix errno variable: there is a global indicator (per
-    # thread) of the last error that occurred. Most functions don't
-    # clear this on success, but will set it to indicate the cause of
-    # the error on failure. Most functions also return an error
-    # indicator, usually NULL if they are supposed to return a
-    # pointer, or -1 if they return an integer (exception: the
-    # PyArg_*() functions return 1 for success and 0 for failure).
-
-    # When a function must fail because some function it called
-    # failed, it generally doesn't set the error indicator; the
-    # function it called already set it. It is responsible for either
-    # handling the error and clearing the exception or returning after
-    # cleaning up any resources it holds (such as object references or
-    # memory allocations); it should not continue normally if it is
-    # not prepared to handle the error. If returning due to an error,
-    # it is important to indicate to the caller that an error has been
-    # set. If the error is not handled or carefully propagated,
-    # additional calls into the Python/C API may not behave as
-    # intended and may fail in mysterious ways.
-
-    # The error indicator consists of three Python objects
-    # corresponding to the Python variables sys.exc_type,
-    # sys.exc_value and sys.exc_traceback. API functions exist to
-    # interact with the error indicator in various ways. There is a
-    # separate error indicator for each thread.
-
-    void PyErr_Print()
-    # Print a standard traceback to sys.stderr and clear the error
-    # indicator. Call this function only when the error indicator is
-    # set. (Otherwise it will cause a fatal error!)
-
-    PyObject* PyErr_Occurred()
-    # Return value: Borrowed reference.
-    # Test whether the error indicator is set. If set, return the
-    # exception type (the first argument to the last call to one of
-    # the PyErr_Set*() functions or to PyErr_Restore()). If not set,
-    # return NULL. You do not own a reference to the return value, so
-    # you do not need to Py_DECREF() it. Note: Do not compare the
-    # return value to a specific exception; use
-    # PyErr_ExceptionMatches() instead, shown below. (The comparison
-    # could easily fail since the exception may be an instance instead
+ 
+cdef extern from "Python.h": 
+ 
+    ##################################################################### 
+    # 3. Exception Handling 
+    ##################################################################### 
+ 
+    # The functions described in this chapter will let you handle and 
+    # raise Python exceptions. It is important to understand some of 
+    # the basics of Python exception handling. It works somewhat like 
+    # the Unix errno variable: there is a global indicator (per 
+    # thread) of the last error that occurred. Most functions don't 
+    # clear this on success, but will set it to indicate the cause of 
+    # the error on failure. Most functions also return an error 
+    # indicator, usually NULL if they are supposed to return a 
+    # pointer, or -1 if they return an integer (exception: the 
+    # PyArg_*() functions return 1 for success and 0 for failure). 
+ 
+    # When a function must fail because some function it called 
+    # failed, it generally doesn't set the error indicator; the 
+    # function it called already set it. It is responsible for either 
+    # handling the error and clearing the exception or returning after 
+    # cleaning up any resources it holds (such as object references or 
+    # memory allocations); it should not continue normally if it is 
+    # not prepared to handle the error. If returning due to an error, 
+    # it is important to indicate to the caller that an error has been 
+    # set. If the error is not handled or carefully propagated, 
+    # additional calls into the Python/C API may not behave as 
+    # intended and may fail in mysterious ways. 
+ 
+    # The error indicator consists of three Python objects 
+    # corresponding to the Python variables sys.exc_type, 
+    # sys.exc_value and sys.exc_traceback. API functions exist to 
+    # interact with the error indicator in various ways. There is a 
+    # separate error indicator for each thread. 
+ 
+    void PyErr_Print() 
+    # Print a standard traceback to sys.stderr and clear the error 
+    # indicator. Call this function only when the error indicator is 
+    # set. (Otherwise it will cause a fatal error!) 
+ 
+    PyObject* PyErr_Occurred() 
+    # Return value: Borrowed reference. 
+    # Test whether the error indicator is set. If set, return the 
+    # exception type (the first argument to the last call to one of 
+    # the PyErr_Set*() functions or to PyErr_Restore()). If not set, 
+    # return NULL. You do not own a reference to the return value, so 
+    # you do not need to Py_DECREF() it. Note: Do not compare the 
+    # return value to a specific exception; use 
+    # PyErr_ExceptionMatches() instead, shown below. (The comparison 
+    # could easily fail since the exception may be an instance instead 
     # of a class, in the case of a class exception, or it may be a
-    # subclass of the expected exception.)
-
-    bint PyErr_ExceptionMatches(object exc)
-    # Equivalent to "PyErr_GivenExceptionMatches(PyErr_Occurred(),
-    # exc)". This should only be called when an exception is actually
-    # set; a memory access violation will occur if no exception has
-    # been raised.
-
-    bint PyErr_GivenExceptionMatches(object given, object exc)
-    # Return true if the given exception matches the exception in
-    # exc. If exc is a class object, this also returns true when given
-    # is an instance of a subclass. If exc is a tuple, all exceptions
-    # in the tuple (and recursively in subtuples) are searched for a
-    # match. If given is NULL, a memory access violation will occur.
-
-    void PyErr_NormalizeException(PyObject** exc, PyObject** val, PyObject** tb)
-    # Under certain circumstances, the values returned by
-    # PyErr_Fetch() below can be ``unnormalized'', meaning that *exc
-    # is a class object but *val is not an instance of the same
-    # class. This function can be used to instantiate the class in
-    # that case. If the values are already normalized, nothing
-    # happens. The delayed normalization is implemented to improve
-    # performance.
-
-    void PyErr_Clear()
-    # Clear the error indicator. If the error indicator is not set, there is no effect.
-
-    void PyErr_Fetch(PyObject** ptype, PyObject** pvalue, PyObject** ptraceback)
-    # Retrieve the error indicator into three variables whose
-    # addresses are passed. If the error indicator is not set, set all
-    # three variables to NULL. If it is set, it will be cleared and
-    # you own a reference to each object retrieved. The value and
-    # traceback object may be NULL even when the type object is
-    # not. Note: This function is normally only used by code that
-    # needs to handle exceptions or by code that needs to save and
-    # restore the error indicator temporarily.
-
-    void PyErr_Restore(PyObject* type, PyObject* value, PyObject* traceback)
-    # Set the error indicator from the three objects. If the error
-    # indicator is already set, it is cleared first. If the objects
-    # are NULL, the error indicator is cleared. Do not pass a NULL
-    # type and non-NULL value or traceback. The exception type should
-    # be a class. Do not pass an invalid exception type or
-    # value. (Violating these rules will cause subtle problems later.)
-    # This call takes away a reference to each object: you must own a
-    # reference to each object before the call and after the call you
-    # no longer own these references. (If you don't understand this,
-    # don't use this function. I warned you.) Note: This function is
-    # normally only used by code that needs to save and restore the
-    # error indicator temporarily; use PyErr_Fetch() to save the
-    # current exception state.
-
-    void PyErr_SetString(object type, char *message)
-    # This is the most common way to set the error indicator. The
-    # first argument specifies the exception type; it is normally one
-    # of the standard exceptions, e.g. PyExc_RuntimeError. You need
-    # not increment its reference count. The second argument is an
-    # error message; it is converted to a string object.
-
-    void PyErr_SetObject(object type, object value)
-    # This function is similar to PyErr_SetString() but lets you
-    # specify an arbitrary Python object for the ``value'' of the
-    # exception.
-
-    PyObject* PyErr_Format(object exception, char *format, ...) except NULL
-    # Return value: Always NULL.
-    # This function sets the error indicator and returns
-    # NULL. exception should be a Python exception (class, not an
-    # instance). format should be a string, containing format codes,
-    # similar to printf(). The width.precision before a format code is
-    # parsed, but the width part is ignored.
-
-    void PyErr_SetNone(object type)
-    # This is a shorthand for "PyErr_SetObject(type, Py_None)".
-
-    int PyErr_BadArgument() except 0
-
-    # This is a shorthand for "PyErr_SetString(PyExc_TypeError,
-    # message)", where message indicates that a built-in operation was
-    # invoked with an illegal argument. It is mostly for internal use.
-
-    PyObject* PyErr_NoMemory() except NULL
-    # Return value: Always NULL.
-    # This is a shorthand for "PyErr_SetNone(PyExc_MemoryError)"; it
-    # returns NULL so an object allocation function can write "return
-    # PyErr_NoMemory();" when it runs out of memory.
-
-    PyObject* PyErr_SetFromErrno(object type) except NULL
-    # Return value: Always NULL.
-    # This is a convenience function to raise an exception when a C
-    # library function has returned an error and set the C variable
-    # errno. It constructs a tuple object whose first item is the
-    # integer errno value and whose second item is the corresponding
-    # error message (gotten from strerror()), and then calls
-    # "PyErr_SetObject(type, object)". On Unix, when the errno value
-    # is EINTR, indicating an interrupted system call, this calls
-    # PyErr_CheckSignals(), and if that set the error indicator,
-    # leaves it set to that. The function always returns NULL, so a
-    # wrapper function around a system call can write "return
-    # PyErr_SetFromErrno(type);" when the system call returns an
-    # error.
-
+    # subclass of the expected exception.) 
+ 
+    bint PyErr_ExceptionMatches(object exc) 
+    # Equivalent to "PyErr_GivenExceptionMatches(PyErr_Occurred(), 
+    # exc)". This should only be called when an exception is actually 
+    # set; a memory access violation will occur if no exception has 
+    # been raised. 
+ 
+    bint PyErr_GivenExceptionMatches(object given, object exc) 
+    # Return true if the given exception matches the exception in 
+    # exc. If exc is a class object, this also returns true when given 
+    # is an instance of a subclass. If exc is a tuple, all exceptions 
+    # in the tuple (and recursively in subtuples) are searched for a 
+    # match. If given is NULL, a memory access violation will occur. 
+ 
+    void PyErr_NormalizeException(PyObject** exc, PyObject** val, PyObject** tb) 
+    # Under certain circumstances, the values returned by 
+    # PyErr_Fetch() below can be ``unnormalized'', meaning that *exc 
+    # is a class object but *val is not an instance of the same 
+    # class. This function can be used to instantiate the class in 
+    # that case. If the values are already normalized, nothing 
+    # happens. The delayed normalization is implemented to improve 
+    # performance. 
+ 
+    void PyErr_Clear() 
+    # Clear the error indicator. If the error indicator is not set, there is no effect. 
+ 
+    void PyErr_Fetch(PyObject** ptype, PyObject** pvalue, PyObject** ptraceback) 
+    # Retrieve the error indicator into three variables whose 
+    # addresses are passed. If the error indicator is not set, set all 
+    # three variables to NULL. If it is set, it will be cleared and 
+    # you own a reference to each object retrieved. The value and 
+    # traceback object may be NULL even when the type object is 
+    # not. Note: This function is normally only used by code that 
+    # needs to handle exceptions or by code that needs to save and 
+    # restore the error indicator temporarily. 
+ 
+    void PyErr_Restore(PyObject* type, PyObject* value, PyObject* traceback) 
+    # Set the error indicator from the three objects. If the error 
+    # indicator is already set, it is cleared first. If the objects 
+    # are NULL, the error indicator is cleared. Do not pass a NULL 
+    # type and non-NULL value or traceback. The exception type should 
+    # be a class. Do not pass an invalid exception type or 
+    # value. (Violating these rules will cause subtle problems later.) 
+    # This call takes away a reference to each object: you must own a 
+    # reference to each object before the call and after the call you 
+    # no longer own these references. (If you don't understand this, 
+    # don't use this function. I warned you.) Note: This function is 
+    # normally only used by code that needs to save and restore the 
+    # error indicator temporarily; use PyErr_Fetch() to save the 
+    # current exception state. 
+ 
+    void PyErr_SetString(object type, char *message) 
+    # This is the most common way to set the error indicator. The 
+    # first argument specifies the exception type; it is normally one 
+    # of the standard exceptions, e.g. PyExc_RuntimeError. You need 
+    # not increment its reference count. The second argument is an 
+    # error message; it is converted to a string object. 
+ 
+    void PyErr_SetObject(object type, object value) 
+    # This function is similar to PyErr_SetString() but lets you 
+    # specify an arbitrary Python object for the ``value'' of the 
+    # exception. 
+ 
+    PyObject* PyErr_Format(object exception, char *format, ...) except NULL 
+    # Return value: Always NULL. 
+    # This function sets the error indicator and returns 
+    # NULL. exception should be a Python exception (class, not an 
+    # instance). format should be a string, containing format codes, 
+    # similar to printf(). The width.precision before a format code is 
+    # parsed, but the width part is ignored. 
+ 
+    void PyErr_SetNone(object type) 
+    # This is a shorthand for "PyErr_SetObject(type, Py_None)". 
+ 
+    int PyErr_BadArgument() except 0 
+ 
+    # This is a shorthand for "PyErr_SetString(PyExc_TypeError, 
+    # message)", where message indicates that a built-in operation was 
+    # invoked with an illegal argument. It is mostly for internal use. 
+ 
+    PyObject* PyErr_NoMemory() except NULL 
+    # Return value: Always NULL. 
+    # This is a shorthand for "PyErr_SetNone(PyExc_MemoryError)"; it 
+    # returns NULL so an object allocation function can write "return 
+    # PyErr_NoMemory();" when it runs out of memory. 
+ 
+    PyObject* PyErr_SetFromErrno(object type) except NULL 
+    # Return value: Always NULL. 
+    # This is a convenience function to raise an exception when a C 
+    # library function has returned an error and set the C variable 
+    # errno. It constructs a tuple object whose first item is the 
+    # integer errno value and whose second item is the corresponding 
+    # error message (gotten from strerror()), and then calls 
+    # "PyErr_SetObject(type, object)". On Unix, when the errno value 
+    # is EINTR, indicating an interrupted system call, this calls 
+    # PyErr_CheckSignals(), and if that set the error indicator, 
+    # leaves it set to that. The function always returns NULL, so a 
+    # wrapper function around a system call can write "return 
+    # PyErr_SetFromErrno(type);" when the system call returns an 
+    # error. 
+ 
     PyObject* PyErr_SetFromErrnoWithFilenameObject(object type, object filenameObject) except NULL
     # Similar to PyErr_SetFromErrno(), with the additional behavior
     # that if filenameObject is not NULL, it is passed to the
@@ -160,98 +160,98 @@ cdef extern from "Python.h":
     # In the case of OSError exception, this is used to define
     # the filename attribute of the exception instance.
 
-    PyObject* PyErr_SetFromErrnoWithFilename(object type, char *filename) except NULL
-    # Return value: Always NULL.  Similar to PyErr_SetFromErrno(),
-    # with the additional behavior that if filename is not NULL, it is
-    # passed to the constructor of type as a third parameter. In the
-    # case of exceptions such as IOError and OSError, this is used to
-    # define the filename attribute of the exception instance.
-
-    PyObject* PyErr_SetFromWindowsErr(int ierr) except NULL
-    # Return value: Always NULL.  This is a convenience function to
-    # raise WindowsError. If called with ierr of 0, the error code
-    # returned by a call to GetLastError() is used instead. It calls
-    # the Win32 function FormatMessage() to retrieve the Windows
-    # description of error code given by ierr or GetLastError(), then
-    # it constructs a tuple object whose first item is the ierr value
-    # and whose second item is the corresponding error message (gotten
-    # from FormatMessage()), and then calls
-    # "PyErr_SetObject(PyExc_WindowsError, object)". This function
-    # always returns NULL. Availability: Windows.
-
-    PyObject* PyErr_SetExcFromWindowsErr(object type, int ierr) except NULL
-    # Return value: Always NULL.  Similar to
-    # PyErr_SetFromWindowsErr(), with an additional parameter
-    # specifying the exception type to be raised. Availability:
-    # Windows. New in version 2.3.
-
-    PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, char *filename) except NULL
-    # Return value: Always NULL.  Similar to
-    # PyErr_SetFromWindowsErr(), with the additional behavior that if
-    # filename is not NULL, it is passed to the constructor of
-    # WindowsError as a third parameter. Availability: Windows.
-
-    PyObject* PyErr_SetExcFromWindowsErrWithFilename(object type, int ierr, char *filename) except NULL
-    # Return value: Always NULL.
-    # Similar to PyErr_SetFromWindowsErrWithFilename(), with an
-    # additional parameter specifying the exception type to be
-    # raised. Availability: Windows.
-
-    void PyErr_BadInternalCall()
-    # This is a shorthand for "PyErr_SetString(PyExc_TypeError,
-    # message)", where message indicates that an internal operation
-    # (e.g. a Python/C API function) was invoked with an illegal
-    # argument. It is mostly for internal use.
-
-    int PyErr_WarnEx(object category, char *message, int stacklevel) except -1
-    # Issue a warning message. The category argument is a warning
-    # category (see below) or NULL; the message argument is a message
-    # string. stacklevel is a positive number giving a number of stack
-    # frames; the warning will be issued from the currently executing
-    # line of code in that stack frame. A stacklevel of 1 is the
-    # function calling PyErr_WarnEx(), 2 is the function above that,
-    # and so forth.
-
-    int PyErr_WarnExplicit(object category, char *message, char *filename, int lineno, char *module, object registry) except -1
-    # Issue a warning message with explicit control over all warning
-    # attributes. This is a straightforward wrapper around the Python
-    # function warnings.warn_explicit(), see there for more
-    # information. The module and registry arguments may be set to
-    # NULL to get the default effect described there.
-
-    int PyErr_CheckSignals() except -1
-    # This function interacts with Python's signal handling. It checks
-    # whether a signal has been sent to the processes and if so,
-    # invokes the corresponding signal handler. If the signal module
-    # is supported, this can invoke a signal handler written in
-    # Python. In all cases, the default effect for SIGINT is to raise
-    # the KeyboardInterrupt exception. If an exception is raised the
-    # error indicator is set and the function returns 1; otherwise the
-    # function returns 0. The error indicator may or may not be
-    # cleared if it was previously set.
-
-    void PyErr_SetInterrupt() nogil
-    # This function simulates the effect of a SIGINT signal arriving
-    # -- the next time PyErr_CheckSignals() is called,
-    # KeyboardInterrupt will be raised. It may be called without
-    # holding the interpreter lock.
-
-    object PyErr_NewException(char *name, object base, object dict)
-    # Return value: New reference.
-    # This utility function creates and returns a new exception
-    # object. The name argument must be the name of the new exception,
-    # a C string of the form module.class. The base and dict arguments
-    # are normally NULL. This creates a class object derived from
-    # Exception (accessible in C as PyExc_Exception).
-
-    void PyErr_WriteUnraisable(object obj)
-    # This utility function prints a warning message to sys.stderr
-    # when an exception has been set but it is impossible for the
-    # interpreter to actually raise the exception. It is used, for
-    # example, when an exception occurs in an __del__() method.
-    #
-    # The function is called with a single argument obj that
-    # identifies the context in which the unraisable exception
-    # occurred. The repr of obj will be printed in the warning
-    # message.
-
+    PyObject* PyErr_SetFromErrnoWithFilename(object type, char *filename) except NULL 
+    # Return value: Always NULL.  Similar to PyErr_SetFromErrno(), 
+    # with the additional behavior that if filename is not NULL, it is 
+    # passed to the constructor of type as a third parameter. In the 
+    # case of exceptions such as IOError and OSError, this is used to 
+    # define the filename attribute of the exception instance. 
+ 
+    PyObject* PyErr_SetFromWindowsErr(int ierr) except NULL 
+    # Return value: Always NULL.  This is a convenience function to 
+    # raise WindowsError. If called with ierr of 0, the error code 
+    # returned by a call to GetLastError() is used instead. It calls 
+    # the Win32 function FormatMessage() to retrieve the Windows 
+    # description of error code given by ierr or GetLastError(), then 
+    # it constructs a tuple object whose first item is the ierr value 
+    # and whose second item is the corresponding error message (gotten 
+    # from FormatMessage()), and then calls 
+    # "PyErr_SetObject(PyExc_WindowsError, object)". This function 
+    # always returns NULL. Availability: Windows. 
+ 
+    PyObject* PyErr_SetExcFromWindowsErr(object type, int ierr) except NULL 
+    # Return value: Always NULL.  Similar to 
+    # PyErr_SetFromWindowsErr(), with an additional parameter 
+    # specifying the exception type to be raised. Availability: 
+    # Windows. New in version 2.3. 
+ 
+    PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, char *filename) except NULL 
+    # Return value: Always NULL.  Similar to 
+    # PyErr_SetFromWindowsErr(), with the additional behavior that if 
+    # filename is not NULL, it is passed to the constructor of 
+    # WindowsError as a third parameter. Availability: Windows. 
+ 
+    PyObject* PyErr_SetExcFromWindowsErrWithFilename(object type, int ierr, char *filename) except NULL 
+    # Return value: Always NULL. 
+    # Similar to PyErr_SetFromWindowsErrWithFilename(), with an 
+    # additional parameter specifying the exception type to be 
+    # raised. Availability: Windows. 
+ 
+    void PyErr_BadInternalCall() 
+    # This is a shorthand for "PyErr_SetString(PyExc_TypeError, 
+    # message)", where message indicates that an internal operation 
+    # (e.g. a Python/C API function) was invoked with an illegal 
+    # argument. It is mostly for internal use. 
+ 
+    int PyErr_WarnEx(object category, char *message, int stacklevel) except -1 
+    # Issue a warning message. The category argument is a warning 
+    # category (see below) or NULL; the message argument is a message 
+    # string. stacklevel is a positive number giving a number of stack 
+    # frames; the warning will be issued from the currently executing 
+    # line of code in that stack frame. A stacklevel of 1 is the 
+    # function calling PyErr_WarnEx(), 2 is the function above that, 
+    # and so forth. 
+ 
+    int PyErr_WarnExplicit(object category, char *message, char *filename, int lineno, char *module, object registry) except -1 
+    # Issue a warning message with explicit control over all warning 
+    # attributes. This is a straightforward wrapper around the Python 
+    # function warnings.warn_explicit(), see there for more 
+    # information. The module and registry arguments may be set to 
+    # NULL to get the default effect described there. 
+ 
+    int PyErr_CheckSignals() except -1 
+    # This function interacts with Python's signal handling. It checks 
+    # whether a signal has been sent to the processes and if so, 
+    # invokes the corresponding signal handler. If the signal module 
+    # is supported, this can invoke a signal handler written in 
+    # Python. In all cases, the default effect for SIGINT is to raise 
+    # the KeyboardInterrupt exception. If an exception is raised the 
+    # error indicator is set and the function returns 1; otherwise the 
+    # function returns 0. The error indicator may or may not be 
+    # cleared if it was previously set. 
+ 
+    void PyErr_SetInterrupt() nogil 
+    # This function simulates the effect of a SIGINT signal arriving 
+    # -- the next time PyErr_CheckSignals() is called, 
+    # KeyboardInterrupt will be raised. It may be called without 
+    # holding the interpreter lock. 
+ 
+    object PyErr_NewException(char *name, object base, object dict) 
+    # Return value: New reference. 
+    # This utility function creates and returns a new exception 
+    # object. The name argument must be the name of the new exception, 
+    # a C string of the form module.class. The base and dict arguments 
+    # are normally NULL. This creates a class object derived from 
+    # Exception (accessible in C as PyExc_Exception). 
+ 
+    void PyErr_WriteUnraisable(object obj) 
+    # This utility function prints a warning message to sys.stderr 
+    # when an exception has been set but it is impossible for the 
+    # interpreter to actually raise the exception. It is used, for 
+    # example, when an exception occurs in an __del__() method. 
+    # 
+    # The function is called with a single argument obj that 
+    # identifies the context in which the unraisable exception 
+    # occurred. The repr of obj will be printed in the warning 
+    # message. 
+