SOURCES =
DISTVERSION = $(shell $(PYTHON) tools/extensions/patchlevel.py)
-ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees -D latex_paper_size=$(PAPER) \
+ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees -D latex_elements.papersize=$(PAPER) \
$(SPHINXOPTS) . build/$(BUILDER) $(SOURCES)
.PHONY: help build html htmlhelp latex text changes linkcheck \
# for development releases: always build
autobuild-dev:
- make dist SPHINXOPTS='$(SPHINXOPTS) -A daily=1 -A versionswitcher=1'
+ make dist SPHINXOPTS='$(SPHINXOPTS) -A daily=1 -A switchers=1'
-make suspicious
# for quick rebuilds (HTML only)
autobuild-dev-html:
- make html SPHINXOPTS='$(SPHINXOPTS) -A daily=1 -A versionswitcher=1'
+ make html SPHINXOPTS='$(SPHINXOPTS) -A daily=1 -A switchers=1'
# for stable releases: only build if not in pre-release stage (alpha, beta)
# release candidate downloads are okay, since the stable tree can be in that stage
exception handling (for example, :c:func:`Py_DECREF` owned references and return
an error value).
- Warning categories must be subclasses of :c:data:`Warning`; the default warning
- category is :c:data:`RuntimeWarning`. The standard Python warning categories are
- available as global variables whose names are ``PyExc_`` followed by the Python
- exception name. These have the type :c:type:`PyObject\*`; they are all class
- objects. Their names are :c:data:`PyExc_Warning`, :c:data:`PyExc_UserWarning`,
- :c:data:`PyExc_UnicodeWarning`, :c:data:`PyExc_DeprecationWarning`,
- :c:data:`PyExc_SyntaxWarning`, :c:data:`PyExc_RuntimeWarning`, and
- :c:data:`PyExc_FutureWarning`. :c:data:`PyExc_Warning` is a subclass of
- :c:data:`PyExc_Exception`; the other warning categories are subclasses of
- :c:data:`PyExc_Warning`.
+ Warning categories must be subclasses of :c:data:`PyExc_Warning`;
+ :c:data:`PyExc_Warning` is a subclass of :c:data:`PyExc_Exception`;
+ the default warning category is :c:data:`PyExc_RuntimeWarning`. The standard
+ Python warning categories are available as global variables whose names are
+ enumerated at :ref:`standardwarningcategories`.
For information about warning control, see the documentation for the
:mod:`warnings` module and the :option:`-W` option in the command line
:c:type:`PyObject\*`; they are all class objects. For completeness, here are all
the variables:
-+-------------------------------------+----------------------------+----------+
-| C Name | Python Name | Notes |
-+=====================================+============================+==========+
-| :c:data:`PyExc_BaseException` | :exc:`BaseException` | (1), (4) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_Exception` | :exc:`Exception` | \(1) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_StandardError` | :exc:`StandardError` | \(1) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_ArithmeticError` | :exc:`ArithmeticError` | \(1) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_LookupError` | :exc:`LookupError` | \(1) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_AssertionError` | :exc:`AssertionError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_AttributeError` | :exc:`AttributeError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_EOFError` | :exc:`EOFError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_EnvironmentError` | :exc:`EnvironmentError` | \(1) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_FloatingPointError` | :exc:`FloatingPointError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_IOError` | :exc:`IOError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_ImportError` | :exc:`ImportError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_IndexError` | :exc:`IndexError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_KeyError` | :exc:`KeyError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_KeyboardInterrupt` | :exc:`KeyboardInterrupt` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_MemoryError` | :exc:`MemoryError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_NameError` | :exc:`NameError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_NotImplementedError` | :exc:`NotImplementedError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_OSError` | :exc:`OSError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_OverflowError` | :exc:`OverflowError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_ReferenceError` | :exc:`ReferenceError` | \(2) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_RuntimeError` | :exc:`RuntimeError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_SyntaxError` | :exc:`SyntaxError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_SystemError` | :exc:`SystemError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_SystemExit` | :exc:`SystemExit` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_TypeError` | :exc:`TypeError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_ValueError` | :exc:`ValueError` | |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_WindowsError` | :exc:`WindowsError` | \(3) |
-+-------------------------------------+----------------------------+----------+
-| :c:data:`PyExc_ZeroDivisionError` | :exc:`ZeroDivisionError` | |
-+-------------------------------------+----------------------------+----------+
-
.. index::
single: PyExc_BaseException
single: PyExc_Exception
single: PyExc_StandardError
single: PyExc_ArithmeticError
- single: PyExc_LookupError
single: PyExc_AssertionError
single: PyExc_AttributeError
- single: PyExc_EOFError
+ single: PyExc_BufferError
single: PyExc_EnvironmentError
+ single: PyExc_EOFError
single: PyExc_FloatingPointError
- single: PyExc_IOError
+ single: PyExc_GeneratorExit
single: PyExc_ImportError
+ single: PyExc_IndentationError
single: PyExc_IndexError
+ single: PyExc_IOError
single: PyExc_KeyError
single: PyExc_KeyboardInterrupt
+ single: PyExc_LookupError
single: PyExc_MemoryError
single: PyExc_NameError
single: PyExc_NotImplementedError
single: PyExc_OverflowError
single: PyExc_ReferenceError
single: PyExc_RuntimeError
+ single: PyExc_StopIteration
single: PyExc_SyntaxError
single: PyExc_SystemError
single: PyExc_SystemExit
+ single: PyExc_TabError
single: PyExc_TypeError
+ single: PyExc_UnboundLocalError
+ single: PyExc_UnicodeDecodeError
+ single: PyExc_UnicodeEncodeError
+ single: PyExc_UnicodeError
+ single: PyExc_UnicodeTranslateError
+ single: PyExc_VMSError
single: PyExc_ValueError
single: PyExc_WindowsError
single: PyExc_ZeroDivisionError
++-----------------------------------------+---------------------------------+----------+
+| C Name | Python Name | Notes |
++=========================================+=================================+==========+
+| :c:data:`PyExc_BaseException` | :exc:`BaseException` | (1), (4) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_Exception` | :exc:`Exception` | \(1) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_StandardError` | :exc:`StandardError` | \(1) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_ArithmeticError` | :exc:`ArithmeticError` | \(1) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_AssertionError` | :exc:`AssertionError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_AttributeError` | :exc:`AttributeError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_BufferError` | :exc:`BufferError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_EnvironmentError` | :exc:`EnvironmentError` | \(1) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_EOFError` | :exc:`EOFError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_FloatingPointError` | :exc:`FloatingPointError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_GeneratorExit` | :exc:`GeneratorExit` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_ImportError` | :exc:`ImportError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_IndentationError` | :exc:`IndentationError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_IndexError` | :exc:`IndexError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_IOError` | :exc:`IOError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_KeyError` | :exc:`KeyError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_KeyboardInterrupt` | :exc:`KeyboardInterrupt` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_LookupError` | :exc:`LookupError` | \(1) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_MemoryError` | :exc:`MemoryError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_NameError` | :exc:`NameError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_NotImplementedError` | :exc:`NotImplementedError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_OSError` | :exc:`OSError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_OverflowError` | :exc:`OverflowError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_ReferenceError` | :exc:`ReferenceError` | \(2) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_RuntimeError` | :exc:`RuntimeError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_StopIteration` | :exc:`StopIteration` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_SyntaxError` | :exc:`SyntaxError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_SystemError` | :exc:`SystemError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_SystemExit` | :exc:`SystemExit` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_TabError` | :exc:`TabError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_TypeError` | :exc:`TypeError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_UnboundLocalError` | :exc:`UnboundLocalError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_UnicodeDecodeError` | :exc:`UnicodeDecodeError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_UnicodeEncodeError` | :exc:`UnicodeEncodeError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_UnicodeError` | :exc:`UnicodeError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_UnicodeTranslateError` | :exc:`UnicodeTranslateError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_VMSError` | :exc:`VMSError` | \(5) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_ValueError` | :exc:`ValueError` | |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_WindowsError` | :exc:`WindowsError` | \(3) |
++-----------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_ZeroDivisionError` | :exc:`ZeroDivisionError` | |
++-----------------------------------------+---------------------------------+----------+
+
Notes:
(1)
(4)
.. versionadded:: 2.5
+(5)
+ Only defined on VMS; protect code that uses this by testing that the
+ preprocessor macro ``__VMS`` is defined.
+
+.. _standardwarningcategories:
+
+Standard Warning Categories
+===========================
+
+All standard Python warning categories are available as global variables whose
+names are ``PyExc_`` followed by the Python exception name. These have the type
+:c:type:`PyObject\*`; they are all class objects. For completeness, here are all
+the variables:
+
+.. index::
+ single: PyExc_Warning
+ single: PyExc_BytesWarning
+ single: PyExc_DeprecationWarning
+ single: PyExc_FutureWarning
+ single: PyExc_ImportWarning
+ single: PyExc_PendingDeprecationWarning
+ single: PyExc_RuntimeWarning
+ single: PyExc_SyntaxWarning
+ single: PyExc_UnicodeWarning
+ single: PyExc_UserWarning
+
++------------------------------------------+---------------------------------+----------+
+| C Name | Python Name | Notes |
++==========================================+=================================+==========+
+| :c:data:`PyExc_Warning` | :exc:`Warning` | \(1) |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_BytesWarning` | :exc:`BytesWarning` | |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_DeprecationWarning` | :exc:`DeprecationWarning` | |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_FutureWarning` | :exc:`FutureWarning` | |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_ImportWarning` | :exc:`ImportWarning` | |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_PendingDeprecationWarning`| :exc:`PendingDeprecationWarning`| |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_RuntimeWarning` | :exc:`RuntimeWarning` | |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_SyntaxWarning` | :exc:`SyntaxWarning` | |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_UnicodeWarning` | :exc:`UnicodeWarning` | |
++------------------------------------------+---------------------------------+----------+
+| :c:data:`PyExc_UserWarning` | :exc:`UserWarning` | |
++------------------------------------------+---------------------------------+----------+
+
+Notes:
+
+(1)
+ This is a base class for other standard warning categories.
String Exceptions
=================
.. versionchanged:: 2.6
All exceptions to be raised or caught must be derived from :exc:`BaseException`.
Trying to raise a string exception now raises :exc:`TypeError`.
-
:c:type:`int *` type for *start*, *stop*, *step*, and *slicelength*. This
might require changes in your code for properly supporting 64-bit
systems.
+
+
+Ellipsis Object
+---------------
+
+
+.. c:var:: PyObject *Py_Ellipsis
+
+ The Python ``Ellipsis`` object. This object has no methods. It needs to be
+ treated just like any other object with respect to reference counts. Like
+ :c:data:`Py_None` it is a singleton object.
+==================+=============+===============================+
| :attr:`name` | char \* | name of the member |
+------------------+-------------+-------------------------------+
- | :attr:`type` | int | the type of the member in the |
+ | :attr:`!type` | int | the type of the member in the |
| | | C struct |
+------------------+-------------+-------------------------------+
| :attr:`offset` | Py_ssize_t | the offset in bytes that the |
| | | docstring |
+------------------+-------------+-------------------------------+
- :attr:`type` can be one of many ``T_`` macros corresponding to various C
+ :attr:`!type` can be one of many ``T_`` macros corresponding to various C
types. When the member is accessed in Python, it will be converted to the
equivalent Python type.
Structure used to hold the function pointers which define an implementation of
the buffer protocol.
- The first slot is :attr:`bf_getreadbuffer`, of type :c:type:`getreadbufferproc`.
+ The first slot is :attr:`bf_getreadbuffer`, of type :c:type:`readbufferproc`.
If this slot is *NULL*, then the object does not support reading from the
internal data. This is non-sensical, so implementors should fill this in, but
callers should test that the slot contains a non-*NULL* value.
The next slot is :attr:`bf_getwritebuffer` having type
- :c:type:`getwritebufferproc`. This slot may be *NULL* if the object does not
+ :c:type:`writebufferproc`. This slot may be *NULL* if the object does not
allow writing into its returned buffers.
- The third slot is :attr:`bf_getsegcount`, with type :c:type:`getsegcountproc`.
+ The third slot is :attr:`bf_getsegcount`, with type :c:type:`segcountproc`.
This slot must not be *NULL* and is used to inform the caller how many segments
the object contains. Simple objects such as :c:type:`PyString_Type` and
:c:type:`PyBuffer_Type` objects contain a single segment.
.. index:: single: PyType_HasFeature()
- The last slot is :attr:`bf_getcharbuffer`, of type :c:type:`getcharbufferproc`.
+ The last slot is :attr:`bf_getcharbuffer`, of type :c:type:`charbufferproc`.
This slot will only be present if the :const:`Py_TPFLAGS_HAVE_GETCHARBUFFER`
flag is present in the :c:member:`~PyTypeObject.tp_flags` field of the object's
:c:type:`PyTypeObject`. Before using this slot, the caller should test whether it
# Options for LaTeX output
# ------------------------
+# Get LaTeX to handle Unicode correctly
+latex_elements = {'inputenc': r'\usepackage[utf8x]{inputenc}', 'utf8extra': ''}
+
+# Additional stuff for the LaTeX preamble.
+latex_elements['preamble'] = r'''
+\authoraddress{
+ \strong{Python Software Foundation}\\
+ Email: \email{docs@python.org}
+}
+\let\Verbatim=\OriginalVerbatim
+\let\endVerbatim=\endOriginalVerbatim
+'''
+
# The paper size ('letter' or 'a4').
-latex_paper_size = 'a4'
+latex_elements['papersize'] = 'a4'
# The font size ('10pt', '11pt' or '12pt').
-latex_font_size = '10pt'
+latex_elements['font_size'] = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, document class [howto/manual]).
for fn in os.listdir('howto')
if fn.endswith('.rst') and fn != 'index.rst')
-# Additional stuff for the LaTeX preamble.
-latex_preamble = r'''
-\authoraddress{
- \strong{Python Software Foundation}\\
- Email: \email{docs@python.org}
-}
-\let\Verbatim=\OriginalVerbatim
-\let\endVerbatim=\endOriginalVerbatim
-'''
-
# Documents to append as an appendix to all manuals.
latex_appendices = ['glossary', 'about', 'license', 'copyright']
-# Get LaTeX to handle Unicode correctly
-latex_elements = {'inputenc': r'\usepackage[utf8x]{inputenc}', 'utf8extra': ''}
-
-
# Options for Epub output
# -----------------------
epub_author = 'Python Documentation Authors'
epub_publisher = 'Python Software Foundation'
-
# Options for the coverage checker
# --------------------------------
Moving on, we come to the crunch --- the type object. ::
static PyTypeObject noddy_NoddyType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- "noddy.Noddy", /*tp_name*/
- sizeof(noddy_NoddyObject), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- 0, /*tp_dealloc*/
- 0, /*tp_print*/
- 0, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- 0, /*tp_hash */
- 0, /*tp_call*/
- 0, /*tp_str*/
- 0, /*tp_getattro*/
- 0, /*tp_setattro*/
- 0, /*tp_as_buffer*/
- Py_TPFLAGS_DEFAULT, /*tp_flags*/
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "noddy.Noddy", /* tp_name */
+ sizeof(noddy_NoddyObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
"Noddy objects", /* tp_doc */
};
This is so important that we're going to pick the top of it apart still
further::
- PyObject_HEAD_INIT(NULL)
+ PyVarObject_HEAD_INIT(NULL, 0)
This line is a bit of a wart; what we'd like to write is::
- PyObject_HEAD_INIT(&PyType_Type)
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
as the type of a type object is "type", but this isn't strictly conforming C and
some compilers complain. Fortunately, this member will be filled in for us by
:c:func:`PyType_Ready`. ::
- 0, /* ob_size */
-
-The :attr:`ob_size` field of the header is not used; its presence in the type
-structure is a historical artifact that is maintained for binary compatibility
-with extension modules compiled for older versions of Python. Always set this
-field to zero. ::
-
"noddy.Noddy", /* tp_name */
The name of our type. This will appear in the default textual representation of
>>> "" + noddy.new_noddy()
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
TypeError: cannot add type "noddy.Noddy" to string
Note that the name is a dotted name that includes both the module name and the
Skipping a number of type methods that we don't provide, we set the class flags
to :const:`Py_TPFLAGS_DEFAULT`. ::
- Py_TPFLAGS_DEFAULT, /*tp_flags*/
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
All types should include this constant in their flags. It enables all of the
members defined by the current version of Python.
Adding data and methods to the Basic example
--------------------------------------------
-Let's expend the basic example to add some data and methods. Let's also make
+Let's extend the basic example to add some data and methods. Let's also make
the type usable as a base class. We'll create a new module, :mod:`noddy2` that
adds these capabilities:
{
Py_XDECREF(self->first);
Py_XDECREF(self->last);
- self->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(self)->tp_free((PyObject*)self);
}
which is assigned to the :c:member:`~PyTypeObject.tp_dealloc` member::
The method is implemented as a C function that takes a :class:`Noddy` (or
:class:`Noddy` subclass) instance as the first argument. Methods always take an
instance as the first argument. Methods often take positional and keyword
-arguments as well, but in this cased we don't take any and don't need to accept
+arguments as well, but in this case we don't take any and don't need to accept
a positional argument tuple or keyword argument dictionary. This method is
equivalent to the Python method::
Finally, we add the :const:`Py_TPFLAGS_HAVE_GC` flag to the class flags::
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */
That's pretty much it. If we had written custom :c:member:`~PyTypeObject.tp_alloc` or
:c:member:`~PyTypeObject.tp_free` slots, we'd need to modify them for cyclic-garbage collection.
This function is called when the reference count of the instance of your type is
reduced to zero and the Python interpreter wants to reclaim it. If your type
-has memory to free or other clean-up to perform, put it here. The object itself
-needs to be freed here as well. Here is an example of this function::
+has memory to free or other clean-up to perform, you can put it here. The
+object itself needs to be freed here as well. Here is an example of this
+function::
static void
newdatatype_dealloc(newdatatypeobject * obj)
{
free(obj->obj_UnderlyingDatatypePtr);
- obj->ob_type->tp_free(obj);
+ Py_TYPE(obj)->tp_free(obj);
}
.. index::
Py_DECREF(self->my_callback);
}
- obj->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(obj)->tp_free((PyObject*)self);
}
The latest Python source distribution is always available from python.org, at
https://www.python.org/downloads/. The latest development sources can be obtained
-via anonymous Mercurial access at https://hg.python.org/cpython.
+at https://github.com/python/cpython/.
The source distribution is a gzipped tar file containing the complete C source,
Sphinx-formatted documentation, Python library modules, example programs, and
newsgroups and on the Python home page at https://www.python.org/; an RSS feed of
news is available.
-You can also access the development version of Python through Mercurial. See
-https://docs.python.org/devguide/faq.html for details.
+You can also access the development version of Python through Git. See
+`The Python Developer's Guide <https://docs.python.org/devguide/>`_ for details.
How do I submit bug reports and patches for Python?
powerful and mature cross-platform windowing system, are available from `the
PyFLTK project <http://pyfltk.sourceforge.net>`_.
-
-FOX
-----
-
-A wrapper for `the FOX toolkit <http://www.fox-toolkit.org/>`_ called `FXpy
-<http://fxpy.sourceforge.net/>`_ is available. FOX supports both Unix variants
-and Windows.
-
-
OpenGL
------
size" to 4, and select the "Insert spaces" radio button.
If you suspect mixed tabs and spaces are causing problems in leading whitespace,
-run Python with the :option:`-t` switch or run ``Tools/Scripts/tabnanny.py`` to
+run Python with the :option:`-t` switch or run the :mod:`tabnanny` module to
check a directory tree in batch mode.
Introducing Optional arguments
==============================
-So far we, have been playing with positional arguments. Let us
+So far we have been playing with positional arguments. Let us
have a look on how to add optional ones::
import argparse
class Cell(object):
. . .
- def getvalue(self, obj):
- "Recalculate cell before returning value"
+ def getvalue(self):
+ "Recalculate the cell before returning value"
self.recalc()
- return obj._value
+ return self._value
value = property(getvalue)
3
>>> it.next()
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
StopIteration
>>>
2
>>> gen.next()
Traceback (most recent call last):
- File "stdin", line 1, in ?
+ File "stdin", line 1, in <module>
File "stdin", line 2, in generate_ints
StopIteration
9
>>> print it.next()
Traceback (most recent call last):
- File "t.py", line 15, in ?
+ File "t.py", line 15, in <module>
print it.next()
StopIteration
-------------------------------
Although most logging messages are intended for reading by humans, and thus not
-readily machine-parseable, there might be cirumstances where you want to output
+readily machine-parseable, there might be circumstances where you want to output
messages in a structured format which *is* capable of being parsed by a program
(without needing complex regular expressions to parse the log message). This is
straightforward to achieve using the logging package. There are a number of
-------------------------
There might be situations when it is desirable to have logging messages rendered
-in an audible rather than a visible format. This is easy to do if you have text-
-to-speech (TTS) functionality available in your system, even if it doesn't have
+in an audible rather than a visible format. This is easy to do if you have
+text-to-speech (TTS) functionality available in your system, even if it doesn't have
a Python binding. Most TTS systems have a command line program you can run, and
this can be invoked from a handler using :mod:`subprocess`. It's assumed here
that TTS command line programs won't expect to interact with users or take a
please see :ref:`cporting-howto`.
If you would like to read one core Python developer's take on why Python 3
- came into existence, you can read Nick Coghlan's `Python 3 Q & A`_.
+ came into existence, you can read Nick Coghlan's `Python 3 Q & A`_ or
+ Brett Cannon's `Why Python 3 exists`_.
For help with porting, you can email the python-porting_ mailing list with
questions.
To make your project be single-source Python 2/3 compatible, the basic steps
are:
-#. Update your code to drop support for Python 2.5 or older (supporting only
- Python 2.7 is ideal)
+#. Only worry about supporting Python 2.7
#. Make sure you have good test coverage (coverage.py_ can help;
``pip install coverage``)
#. Learn the differences between Python 2 & 3
-#. Use Modernize_ or Futurize_ to update your code (``pip install modernize`` or
- ``pip install future``, respectively)
+#. Use Futurize_ (or Modernize_) to update your code (e.g. ``pip install future``)
#. Use Pylint_ to help make sure you don't regress on your Python 3 support
- (if only supporting Python 2.7/3.4 or newer; ``pip install pylint``)
+ (``pip install pylint``)
#. Use caniusepython3_ to find out which of your dependencies are blocking your
use of Python 3 (``pip install caniusepython3``)
#. Once your dependencies are no longer blocking you, use continuous integration
to make sure you stay compatible with Python 2 & 3 (tox_ can help test
against multiple versions of Python; ``pip install tox``)
-
-If you are dropping support for Python 2 entirely, then after you learn the
-differences between Python 2 & 3 you can run 2to3_ over your code and skip the
-rest of the steps outlined above.
+#. Consider using optional static type checking to make sure your type usage
+ works in both Python 2 & 3 (e.g. use mypy_ to check your typing under both
+ Python 2 & Python 3).
Details
**today**! Even if your dependencies are not supporting Python 3 yet that does
not mean you can't modernize your code **now** to support Python 3. Most changes
required to support Python 3 lead to cleaner code using newer practices even in
-Python 2.
+Python 2 code.
Another key point is that modernizing your Python 2 code to also support
Python 3 is largely automated for you. While you might have to make some API
your code to support Python 2 & 3 simultaneously.
-Drop support for Python 2.5 and older (at least)
-------------------------------------------------
+Drop support for Python 2.6 and older
+-------------------------------------
While you can make Python 2.5 work with Python 3, it is **much** easier if you
-only have to work with Python 2.6 or newer (and easier still if you only have
-to work with Python 2.7). If dropping Python 2.5 is not an option then the six_
-project can help you support Python 2.5 & 3 simultaneously
+only have to work with Python 2.7. If dropping Python 2.5 is not an
+option then the six_ project can help you support Python 2.5 & 3 simultaneously
(``pip install six``). Do realize, though, that nearly all the projects listed
in this HOWTO will not be available to you.
-If you are able to only support Python 2.6 or newer, then the required changes
+If you are able to skip Python 2.5 and older, then the required changes
to your code should continue to look and feel like idiomatic Python code. At
worst you will have to use a function instead of a method in some instances or
have to import a function instead of using a built-in one, but otherwise the
overall transformation should not feel foreign to you.
-But please aim for Python 2.7. Bugfixes for that version of Python will continue
-until 2020 while Python 2.6 is no longer supported. There are also some tools
-mentioned in this HOWTO which do not support Python 2.6 (e.g., Pylint_), and
-this will become more commonplace as time goes on.
+But you should aim for only supporting Python 2.7. Python 2.6 is no longer
+freely supported and thus is not receiving bugfixes. This means **you** will have
+to work around any issues you come across with Python 2.6. There are also some
+tools mentioned in this HOWTO which do not support Python 2.6 (e.g., Pylint_),
+and this will become more commonplace as time goes on. It will simply be easier
+for you if you only support the versions of Python that you have to support.
+
Make sure you specify the proper version support in your ``setup.py`` file
--------------------------------------------------------------------------
also specify each major/minor version of Python that you do support, e.g.
``Programming Language :: Python :: 2.7``.
+
Have good test coverage
-----------------------
thumb is that if you want to be confident enough in your test suite that any
failures that appear after having tools rewrite your code are actual bugs in the
tools and not in your code. If you want a number to aim for, try to get over 80%
-coverage (and don't feel bad if you can't easily get past 90%). If you
-don't already have a tool to measure test coverage then coverage.py_ is
-recommended.
+coverage (and don't feel bad if you find it hard to get better than 90%
+coverage). If you don't already have a tool to measure test coverage then
+coverage.py_ is recommended.
+
Learn the differences between Python 2 & 3
-------------------------------------------
Once you feel like you know what is different in Python 3 compared to Python 2,
it's time to update your code! You have a choice between two tools in porting
-your code automatically: Modernize_ and Futurize_. Which tool you choose will
+your code automatically: Futurize_ and Modernize_. Which tool you choose will
depend on how much like Python 3 you want your code to be. Futurize_ does its
best to make Python 3 idioms and practices exist in Python 2, e.g. backporting
the ``bytes`` type from Python 3 so that you have semantic parity between the
major versions of Python. Modernize_,
on the other hand, is more conservative and targets a Python 2/3 subset of
-Python, relying on six_ to help provide compatibility.
+Python, directly relying on six_ to help provide compatibility. As Python 3 is
+the future, it might be best to consider Futurize to begin adjusting to any new
+practices that Python 3 introduces which you are not accustomed to yet.
Regardless of which tool you choose, they will update your code to run under
Python 3 while staying compatible with the version of Python 2 you started with.
though, there are only a couple of things to watch out for which can be
considered large issues that may be hard to debug if not watched for.
+
Division
++++++++
division or continue using ``/`` and expect a float
The reason that ``/`` isn't simply translated to ``//`` automatically is that if
-an object defines its own ``__div__`` method but not ``__floordiv__`` then your
-code would begin to fail.
+an object defines a ``__truediv__`` method but not ``__floordiv__`` then your
+code would begin to fail (e.g. a user-defined class that uses ``/`` to
+signify some operation but not ``//`` for the same thing or at all).
+
Text versus binary data
+++++++++++++++++++++++
pronounced, Python 3 did what most languages created in the age of the internet
have done and made text and binary data distinct types that cannot blindly be
mixed together (Python predates widespread access to the internet). For any code
-that only deals with text or only binary data, this separation doesn't pose an
+that deals only with text or only binary data, this separation doesn't pose an
issue. But for code that has to deal with both, it does mean you might have to
now care about when you are using text compared to binary data, which is why
this cannot be entirely automated.
(it is **highly** recommended you don't design APIs that can take both due to
the difficulty of keeping the code working; as stated earlier it is difficult to
do well). In Python 2 this means making sure the APIs that take text can work
-with ``unicode`` in Python 2 and those that work with binary data work with the
-``bytes`` type from Python 3 and thus a subset of ``str`` in Python 2 (which the
-``bytes`` type in Python 2 is an alias for). Usually the biggest issue is
-realizing which methods exist for which types in Python 2 & 3 simultaneously
+with ``unicode`` and those that work with binary data work with the
+``bytes`` type from Python 3 (which is a subset of ``str`` in Python 2 and acts
+as an alias for ``bytes`` type in Python 2). Usually the biggest issue is
+realizing which methods exist on which types in Python 2 & 3 simultaneously
(for text that's ``unicode`` in Python 2 and ``str`` in Python 3, for binary
that's ``str``/``bytes`` in Python 2 and ``bytes`` in Python 3). The following
table lists the **unique** methods of each data type across Python 2 & 3
(e.g., the ``decode()`` method is usable on the equivalent binary data type in
-either Python 2 or 3, but it can't be used by the text data type consistently
-between Python 2 and 3 because ``str`` in Python 3 doesn't have the method).
+either Python 2 or 3, but it can't be used by the textual data type consistently
+between Python 2 and 3 because ``str`` in Python 3 doesn't have the method). Do
+note that as of Python 3.5 the ``__mod__`` method was added to the bytes type.
======================== =====================
**Text data** **Binary data**
------------------------ ---------------------
-__mod__ (``%`` operator)
------------------------- ---------------------
\ decode
------------------------ ---------------------
encode
having to keep track of what type of data you are working with.
The next issue is making sure you know whether the string literals in your code
-represent text or binary data. At minimum you should add a ``b`` prefix to any
-literal that presents binary data. For text you should either use the
-``from __future__ import unicode_literals`` statement or add a ``u`` prefix to
-the text literal.
+represent text or binary data. You should add a ``b`` prefix to any
+literal that presents binary data. For text you should add a ``u`` prefix to
+the text literal. (there is a :mod:`__future__` import to force all unspecified
+literals to be Unicode, but usage has shown it isn't as effective as adding a
+``b`` or ``u`` prefix to all literals explicitly)
As part of this dichotomy you also need to be careful about opening files.
Unless you have been working on Windows, there is a chance you have not always
binary reading). Under Python 3, binary files and text files are clearly
distinct and mutually incompatible; see the :mod:`io` module for details.
Therefore, you **must** make a decision of whether a file will be used for
-binary access (allowing binary data to be read and/or written) or text access
+binary access (allowing binary data to be read and/or written) or textual access
(allowing text data to be read and/or written). You should also use :func:`io.open`
for opening files instead of the built-in :func:`open` function as the :mod:`io`
module is consistent from Python 2 to 3 while the built-in :func:`open` function
-is not (in Python 3 it's actually :func:`io.open`).
+is not (in Python 3 it's actually :func:`io.open`). Do not bother with the
+outdated practice of using :func:`codecs.open` as that's only necessary for
+keeping compatibility with Python 2.5.
The constructors of both ``str`` and ``bytes`` have different semantics for the
same arguments between Python 2 & 3. Passing an integer to ``bytes`` in Python 2
#. Make sure that your code that works with text also works with ``unicode`` and
code for binary data works with ``bytes`` in Python 2 (see the table above
for what methods you cannot use for each type)
-#. Mark all binary literals with a ``b`` prefix, use a ``u`` prefix or
- :mod:`__future__` import statement for text literals
+#. Mark all binary literals with a ``b`` prefix, textual literals with a ``u``
+ prefix
#. Decode binary data to text as soon as possible, encode text as binary data as
late as possible
#. Open files using :func:`io.open` and make sure to specify the ``b`` mode when
appropriate
-#. Be careful when indexing binary data
+#. Be careful when indexing into binary data
+
+
+Use feature detection instead of version detection
+++++++++++++++++++++++++++++++++++++++++++++++++++
+
+Inevitably you will have code that has to choose what to do based on what
+version of Python is running. The best way to do this is with feature detection
+of whether the version of Python you're running under supports what you need.
+If for some reason that doesn't work then you should make the version check be
+against Python 2 and not Python 3. To help explain this, let's look at an
+example.
+
+Let's pretend that you need access to a feature of importlib_ that
+is available in Python's standard library since Python 3.3 and available for
+Python 2 through importlib2_ on PyPI. You might be tempted to write code to
+access e.g. the ``importlib.abc`` module by doing the following::
+
+ import sys
+
+ if sys.version_info[0] == 3:
+ from importlib import abc
+ else:
+ from importlib2 import abc
+
+The problem with this code is what happens when Python 4 comes out? It would
+be better to treat Python 2 as the exceptional case instead of Python 3 and
+assume that future Python versions will be more compatible with Python 3 than
+Python 2::
+
+ import sys
+
+ if sys.version_info[0] > 2:
+ from importlib import abc
+ else:
+ from importlib2 import abc
+
+The best solution, though, is to do no version detection at all and instead rely
+on feature detection. That avoids any potential issues of getting the version
+detection wrong and helps keep you future-compatible::
+
+ try:
+ from importlib import abc
+ except ImportError:
+ from importlib2 import abc
+
Prevent compatibility regressions
---------------------------------
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
- from __future__ import unicode_literals
You can also run Python 2 with the ``-3`` flag to be warned about various
compatibility issues your code triggers during execution. If you turn warnings
into errors with ``-Werror`` then you can make sure that you don't accidentally
miss a warning.
-
You can also use the Pylint_ project and its ``--py3k`` flag to lint your code
to receive warnings when your code begins to deviate from Python 3
compatibility. This also prevents you from having to run Modernize_ or Futurize_
project was created to help you determine which projects
-- directly or indirectly -- are blocking you from supporting Python 3. There
is both a command-line tool as well as a web interface at
-https://caniusepython3.com .
+https://caniusepython3.com.
The project also provides code which you can integrate into your test suite so
that you will have a failing test when you no longer have dependencies blocking
you from using Python 3. This allows you to avoid having to manually check your
dependencies and to be notified quickly when you can start running on Python 3.
+
Update your ``setup.py`` file to denote Python 3 compatibility
--------------------------------------------------------------
Once your code works under Python 3, you should update the classifiers in
your ``setup.py`` to contain ``Programming Language :: Python :: 3`` and to not
-specify sole Python 2 support. This will tell
-anyone using your code that you support Python 2 **and** 3. Ideally you will
-also want to add classifiers for each major/minor version of Python you now
-support.
+specify sole Python 2 support. This will tell anyone using your code that you
+support Python 2 **and** 3. Ideally you will also want to add classifiers for
+each major/minor version of Python you now support.
+
Use continuous integration to stay compatible
---------------------------------------------
Python 2 or 3 support.
You may also want to use the ``-bb`` flag with the Python 3 interpreter to
-trigger an exception when you are comparing bytes to strings. Usually it's
-simply ``False``, but if you made a mistake in your separation of text/binary
-data handling you may be accidentally comparing text and binary data. This flag
-will raise an exception when that occurs to help track down such cases.
+trigger an exception when you are comparing bytes to strings or bytes to an int
+(the latter is available starting in Python 3.5). By default type-differing
+comparisons simply return ``False``, but if you made a mistake in your
+separation of text/binary data handling or indexing on bytes you wouldn't easily
+find the mistake. This flag will raise an exception when these kinds of
+comparisons occur, making the mistake much easier to track down.
And that's mostly it! At this point your code base is compatible with both
Python 2 and 3 simultaneously. Your testing will also be set up so that you
you typically run your tests under while developing.
-Dropping Python 2 support completely
-====================================
-
-If you are able to fully drop support for Python 2, then the steps required
-to transition to Python 3 simplify greatly.
-
-#. Update your code to only support Python 2.7
-#. Make sure you have good test coverage (coverage.py_ can help)
-#. Learn the differences between Python 2 & 3
-#. Use 2to3_ to rewrite your code to run only under Python 3
+Consider using optional static type checking
+--------------------------------------------
-After this your code will be fully Python 3 compliant but in a way that is not
-supported by Python 2. You should also update the classifiers in your
-``setup.py`` to contain ``Programming Language :: Python :: 3 :: Only``.
+Another way to help port your code is to use a static type checker like
+mypy_ or pytype_ on your code. These tools can be used to analyze your code as
+if it's being run under Python 2, then you can run the tool a second time as if
+your code is running under Python 3. By running a static type checker twice like
+this you can discover if you're e.g. misusing binary data type in one version
+of Python compared to another. If you add optional type hints to your code you
+can also explicitly state whether your APIs use textual or binary data, helping
+to make sure everything functions as expected in both versions of Python.
.. _2to3: https://docs.python.org/3/library/2to3.html
.. _cheat sheet: http://python-future.org/compatible_idioms.html
.. _coverage.py: https://pypi.python.org/pypi/coverage
.. _Futurize: http://python-future.org/automatic_conversion.html
+.. _importlib: https://docs.python.org/3/library/importlib.html#module-importlib
+.. _importlib2: https://pypi.python.org/pypi/importlib2
.. _Modernize: https://python-modernize.readthedocs.org/en/latest/
+.. _mypy: http://mypy-lang.org/
.. _Porting to Python 3: http://python3porting.com/
.. _Pylint: https://pypi.python.org/pypi/pylint
+
.. _Python 3 Q & A: https://ncoghlan-devs-python-notes.readthedocs.org/en/latest/python3/questions_and_answers.html
+.. _pytype: https://github.com/google/pytype
.. _python-future: http://python-future.org/
.. _python-porting: https://mail.python.org/mailman/listinfo/python-porting
.. _six: https://pypi.python.org/pypi/six
.. _tox: https://pypi.python.org/pypi/tox
.. _trove classifier: https://pypi.python.org/pypi?%3Aaction=list_classifiers
+
.. _"What's New": https://docs.python.org/3/whatsnew/index.html
+
+.. _Why Python 3 exists: http://www.snarky.ca/why-python-3-exists
machines assigned values between 128 and 255 to accented characters. Different
machines had different codes, however, which led to problems exchanging files.
Eventually various commonly used sets of values for the 128--255 range emerged.
-Some were true standards, defined by the International Standards Organization,
-and some were **de facto** conventions that were invented by one company or
-another and managed to catch on.
+Some were true standards, defined by the International Organization for
+Standardization, and some were *de facto* conventions that were invented by one
+company or another and managed to catch on.
255 characters aren't very many. For example, you can't fit both the accented
characters used in Western Europe and the Cyrillic alphabet used for Russian
on. These are provided by objects called handlers and openers.
urllib2 supports fetching URLs for many "URL schemes" (identified by the string
-before the ":" in URL - for example "ftp" is the URL scheme of
-"ftp://python.org/") using their associated network protocols (e.g. FTP, HTTP).
+before the ``":"`` in URL - for example ``"ftp"`` is the URL scheme of
+``"ftp://python.org/"``) using their associated network protocols (e.g. FTP, HTTP).
This tutorial focuses on the most common case, HTTP.
For straightforward situations *urlopen* is very easy to use. But as soon as you
``top_level_url`` is in fact *either* a full URL (including the 'http:' scheme
component and the hostname and optionally the port number)
-e.g. "http://example.com/" *or* an "authority" (i.e. the hostname,
-optionally including the port number) e.g. "example.com" or "example.com:8080"
+e.g. ``"http://example.com/"`` *or* an "authority" (i.e. the hostname,
+optionally including the port number) e.g. ``"example.com"`` or ``"example.com:8080"``
(the latter example includes a port number). The authority, if present, must
-NOT contain the "userinfo" component - for example "joe:password@example.com" is
+NOT contain the "userinfo" component - for example ``"joe:password@example.com"`` is
not correct.
} noddy_NoddyObject;
static PyTypeObject noddy_NoddyType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- "noddy.Noddy", /*tp_name*/
- sizeof(noddy_NoddyObject), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- 0, /*tp_dealloc*/
- 0, /*tp_print*/
- 0, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- 0, /*tp_hash */
- 0, /*tp_call*/
- 0, /*tp_str*/
- 0, /*tp_getattro*/
- 0, /*tp_setattro*/
- 0, /*tp_as_buffer*/
- Py_TPFLAGS_DEFAULT, /*tp_flags*/
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "noddy.Noddy", /* tp_name */
+ sizeof(noddy_NoddyObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
"Noddy objects", /* tp_doc */
};
{
Py_XDECREF(self->first);
Py_XDECREF(self->last);
- self->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(self)->tp_free((PyObject*)self);
}
static PyObject *
self = (Noddy *)type->tp_alloc(type, 0);
if (self != NULL) {
self->first = PyString_FromString("");
- if (self->first == NULL)
- {
+ if (self->first == NULL) {
Py_DECREF(self);
return NULL;
- }
-
+ }
+
self->last = PyString_FromString("");
- if (self->last == NULL)
- {
+ if (self->last == NULL) {
Py_DECREF(self);
return NULL;
- }
+ }
self->number = 0;
}
static char *kwlist[] = {"first", "last", "number", NULL};
- if (! PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist,
- &first, &last,
+ if (! PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist,
+ &first, &last,
&self->number))
- return -1;
+ return -1;
if (first) {
tmp = self->first;
result = PyString_Format(format, args);
Py_DECREF(args);
-
+
return result;
}
};
static PyTypeObject NoddyType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- "noddy.Noddy", /*tp_name*/
- sizeof(Noddy), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- (destructor)Noddy_dealloc, /*tp_dealloc*/
- 0, /*tp_print*/
- 0, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- 0, /*tp_hash */
- 0, /*tp_call*/
- 0, /*tp_str*/
- 0, /*tp_getattro*/
- 0, /*tp_setattro*/
- 0, /*tp_as_buffer*/
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "noddy.Noddy", /* tp_name */
+ sizeof(Noddy), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)Noddy_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
"Noddy objects", /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
Noddy_methods, /* tp_methods */
Noddy_members, /* tp_members */
0, /* tp_getset */
#define PyMODINIT_FUNC void
#endif
PyMODINIT_FUNC
-initnoddy2(void)
+initnoddy2(void)
{
PyObject* m;
"Example module that creates an extension type.");
if (m == NULL)
- return;
+ return;
Py_INCREF(&NoddyType);
PyModule_AddObject(m, "Noddy", (PyObject *)&NoddyType);
{
Py_XDECREF(self->first);
Py_XDECREF(self->last);
- self->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(self)->tp_free((PyObject*)self);
}
static PyObject *
self = (Noddy *)type->tp_alloc(type, 0);
if (self != NULL) {
self->first = PyString_FromString("");
- if (self->first == NULL)
- {
+ if (self->first == NULL) {
Py_DECREF(self);
return NULL;
- }
-
+ }
+
self->last = PyString_FromString("");
- if (self->last == NULL)
- {
+ if (self->last == NULL) {
Py_DECREF(self);
return NULL;
- }
+ }
self->number = 0;
}
static char *kwlist[] = {"first", "last", "number", NULL};
- if (! PyArg_ParseTupleAndKeywords(args, kwds, "|SSi", kwlist,
- &first, &last,
+ if (! PyArg_ParseTupleAndKeywords(args, kwds, "|SSi", kwlist,
+ &first, &last,
&self->number))
- return -1;
+ return -1;
if (first) {
tmp = self->first;
static int
Noddy_setfirst(Noddy *self, PyObject *value, void *closure)
{
- if (value == NULL) {
- PyErr_SetString(PyExc_TypeError, "Cannot delete the first attribute");
- return -1;
- }
-
- if (! PyString_Check(value)) {
- PyErr_SetString(PyExc_TypeError,
- "The first attribute value must be a string");
- return -1;
- }
-
- Py_DECREF(self->first);
- Py_INCREF(value);
- self->first = value;
-
- return 0;
+ if (value == NULL) {
+ PyErr_SetString(PyExc_TypeError, "Cannot delete the first attribute");
+ return -1;
+ }
+
+ if (! PyString_Check(value)) {
+ PyErr_SetString(PyExc_TypeError,
+ "The first attribute value must be a string");
+ return -1;
+ }
+
+ Py_DECREF(self->first);
+ Py_INCREF(value);
+ self->first = value;
+
+ return 0;
}
static PyObject *
static int
Noddy_setlast(Noddy *self, PyObject *value, void *closure)
{
- if (value == NULL) {
- PyErr_SetString(PyExc_TypeError, "Cannot delete the last attribute");
- return -1;
- }
-
- if (! PyString_Check(value)) {
- PyErr_SetString(PyExc_TypeError,
- "The last attribute value must be a string");
- return -1;
- }
-
- Py_DECREF(self->last);
- Py_INCREF(value);
- self->last = value;
-
- return 0;
+ if (value == NULL) {
+ PyErr_SetString(PyExc_TypeError, "Cannot delete the last attribute");
+ return -1;
+ }
+
+ if (! PyString_Check(value)) {
+ PyErr_SetString(PyExc_TypeError,
+ "The last attribute value must be a string");
+ return -1;
+ }
+
+ Py_DECREF(self->last);
+ Py_INCREF(value);
+ self->last = value;
+
+ return 0;
}
static PyGetSetDef Noddy_getseters[] = {
- {"first",
+ {"first",
(getter)Noddy_getfirst, (setter)Noddy_setfirst,
"first name",
NULL},
- {"last",
+ {"last",
(getter)Noddy_getlast, (setter)Noddy_setlast,
"last name",
NULL},
result = PyString_Format(format, args);
Py_DECREF(args);
-
+
return result;
}
};
static PyTypeObject NoddyType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- "noddy.Noddy", /*tp_name*/
- sizeof(Noddy), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- (destructor)Noddy_dealloc, /*tp_dealloc*/
- 0, /*tp_print*/
- 0, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- 0, /*tp_hash */
- 0, /*tp_call*/
- 0, /*tp_str*/
- 0, /*tp_getattro*/
- 0, /*tp_setattro*/
- 0, /*tp_as_buffer*/
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "noddy.Noddy", /* tp_name */
+ sizeof(Noddy), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)Noddy_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
"Noddy objects", /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
Noddy_methods, /* tp_methods */
Noddy_members, /* tp_members */
Noddy_getseters, /* tp_getset */
#define PyMODINIT_FUNC void
#endif
PyMODINIT_FUNC
-initnoddy3(void)
+initnoddy3(void)
{
PyObject* m;
"Example module that creates an extension type.");
if (m == NULL)
- return;
+ return;
Py_INCREF(&NoddyType);
PyModule_AddObject(m, "Noddy", (PyObject *)&NoddyType);
return 0;
}
-static int
+static int
Noddy_clear(Noddy *self)
{
PyObject *tmp;
Noddy_dealloc(Noddy* self)
{
Noddy_clear(self);
- self->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(self)->tp_free((PyObject*)self);
}
static PyObject *
self = (Noddy *)type->tp_alloc(type, 0);
if (self != NULL) {
self->first = PyString_FromString("");
- if (self->first == NULL)
- {
+ if (self->first == NULL) {
Py_DECREF(self);
return NULL;
- }
-
+ }
+
self->last = PyString_FromString("");
- if (self->last == NULL)
- {
+ if (self->last == NULL) {
Py_DECREF(self);
return NULL;
- }
+ }
self->number = 0;
}
static char *kwlist[] = {"first", "last", "number", NULL};
- if (! PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist,
- &first, &last,
+ if (! PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist,
+ &first, &last,
&self->number))
- return -1;
+ return -1;
if (first) {
tmp = self->first;
result = PyString_Format(format, args);
Py_DECREF(args);
-
+
return result;
}
};
static PyTypeObject NoddyType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
- "noddy.Noddy", /*tp_name*/
- sizeof(Noddy), /*tp_basicsize*/
- 0, /*tp_itemsize*/
- (destructor)Noddy_dealloc, /*tp_dealloc*/
- 0, /*tp_print*/
- 0, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- 0, /*tp_hash */
- 0, /*tp_call*/
- 0, /*tp_str*/
- 0, /*tp_getattro*/
- 0, /*tp_setattro*/
- 0, /*tp_as_buffer*/
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "noddy.Noddy", /* tp_name */
+ sizeof(Noddy), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)Noddy_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE |
+ Py_TPFLAGS_HAVE_GC, /* tp_flags */
"Noddy objects", /* tp_doc */
(traverseproc)Noddy_traverse, /* tp_traverse */
(inquiry)Noddy_clear, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
Noddy_methods, /* tp_methods */
Noddy_members, /* tp_members */
0, /* tp_getset */
#define PyMODINIT_FUNC void
#endif
PyMODINIT_FUNC
-initnoddy4(void)
+initnoddy4(void)
{
PyObject* m;
"Example module that creates an extension type.");
if (m == NULL)
- return;
+ return;
Py_INCREF(&NoddyType);
PyModule_AddObject(m, "Noddy", (PyObject *)&NoddyType);
Extension("noddy2", ["noddy2.c"]),
Extension("noddy3", ["noddy3.c"]),
Extension("noddy4", ["noddy4.c"]),
+ Extension("shoddy", ["shoddy.c"]),
])
static PyTypeObject ShoddyType = {
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
+ PyVarObject_HEAD_INIT(NULL, 0)
"shoddy.Shoddy", /* tp_name */
sizeof(Shoddy), /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT |
- Py_TPFLAGS_BASETYPE, /* tp_flags */
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
0, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
per-user installation when installing packages with ``pip``.
+Pip not installed
+-----------------
+
+It is possible that ``pip`` does not get installed by default. One potential fix is::
+
+ python -m ensurepip --default-pip
+
+There are also additional resources for `installing pip.
+<https://packaging.python.org/tutorials/installing-packages/#install-pip-setuptools-and-wheel>`__
+
+
Installing binary extensions
----------------------------
because the :class:`memoryview` API is similar but not exactly the same as
that of :class:`buffer`.
-.. 2to3fixer:: callable
-
- Converts ``callable(x)`` to ``isinstance(x, collections.Callable)``, adding
- an import to :mod:`collections` if needed. Note ``callable(x)`` has returned
- in Python 3.2, so if you do not intend to support Python 3.1, you can disable
- this fixer.
-
.. 2to3fixer:: dict
Fixes dictionary iteration methods. :meth:`dict.iteritems` is converted to
-:mod:`_winreg` -- Windows registry access
-=========================================
+:mod:`_winreg` --- Windows registry access
+==========================================
.. module:: _winreg
:platform: Windows
* conflict_handler_ - The strategy for resolving conflicting optionals
(usually unnecessary)
- * add_help_ - Add a -h/--help option to the parser (default: ``True``)
+ * add_help_ - Add a ``-h/--help`` option to the parser (default: ``True``)
The following sections describe how each of these are used.
-h, --help show this help message and exit
--foo FOO foo help
$ cd ..
- $ python subdir\myprogram.py --help
+ $ python subdir/myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]
optional arguments:
.. function:: crc_hqx(data, crc)
- Compute the binhex4 crc value of *data*, starting with an initial *crc* and
- returning the result.
+ Compute a 16-bit CRC value of *data*, starting with an initial *crc* and
+ returning the result. This uses the CRC-CCITT polynomial
+ *x*:sup:`16` + *x*:sup:`12` + *x*:sup:`5` + 1, often represented as
+ 0x1021. This CRC is used in the binhex4 format.
.. function:: crc32(data[, crc])
adapted for Python 2.5 and an early `Bag recipe
<https://code.activestate.com/recipes/259174/>`_ for Python 2.4.
+ * `Bag class <https://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html>`_
in Smalltalk.
* Wikipedia entry for `Multisets <https://en.wikipedia.org/wiki/Multiset>`_.
.. versionchanged:: 2.7
Returns an :class:`OrderedDict` instead of a regular :class:`dict`.
-.. method:: somenamedtuple._replace(kwargs)
+.. method:: somenamedtuple._replace(**kwargs)
Return a new instance of the named tuple replacing specified fields with new
values::
.. seealso::
Module :mod:`shlex`
- Support for a creating Unix shell-like mini-languages which can be used
- as an alternate format for application configuration files.
+ Support for creating Unix shell-like mini-languages which can be used as
+ an alternate format for application configuration files.
Module :mod:`json`
The json module implements a subset of JavaScript syntax which can also
* Recursive objects (compound objects that, directly or indirectly, contain a
reference to themselves) may cause a recursive loop.
-* Because deep copy copies *everything* it may copy too much, e.g.,
- even administrative data structures that should be shared even between copies.
+* Because deep copy copies everything it may copy too much, such as data
+ which is intended to be shared between copies.
The :func:`deepcopy` function avoids these problems by:
<_FuncPtr object at 0x...>
>>> print windll.kernel32.MyOwnFunction # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
File "ctypes.py", line 239, in __getattr__
func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0] # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
File "ctypes.py", line 310, in __getitem__
func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>> windll.kernel32.GetModuleHandleA() # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>> windll.kernel32.GetModuleHandleA(0, 0) # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>
>>> cdll.kernel32.GetModuleHandleA(None) # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>
>>> windll.msvcrt.printf("spam") # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>
>>> windll.kernel32.GetModuleHandleA(32) # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
WindowsError: exception: access violation reading 0x00000020
>>>
19
>>> printf("%f bottles of beer\n", 42.5)
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ArgumentError: argument 2: exceptions.TypeError: Don't know how to convert parameter 2
>>>
>>> printf("%d %d %d", 1, 2, 3)
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ArgumentError: argument 2: exceptions.TypeError: wrong type
>>> printf("%s %d %f\n", "X", 2, 3)
X 2 3.000000
'def'
>>> strchr("abcdef", "def")
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ArgumentError: argument 2: exceptions.TypeError: one character string expected
>>> print strchr("abcdef", "x")
None
486539264
>>> GetModuleHandle("something silly") # doctest: +WINDOWS
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in ValidHandle
WindowsError: [Errno 126] The specified module could not be found.
>>>
0 5
>>> POINT(1, 2, 3)
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: too many initializers
>>>
<class 'ctypes.LP_c_long'>
>>> PI(42)
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
TypeError: expected c_long instead of int
>>> PI(c_int(42))
<ctypes.LP_c_long object at 0x...>
>>> bar.values = (c_byte * 4)()
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
TypeError: incompatible types, c_byte_Array_4 instance instead of LP_c_long instance
>>>
... ("next", POINTER(cell))]
...
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in cell
NameError: name 'cell' is not defined
>>>
A string representing the current version of the module. Also available as
:const:`__version__`.
-Several constants are available to specify character cell attributes:
+Some constants are available to specify character cell attributes.
+The exact constants available are system dependent.
+------------------+-------------------------------+
| Attribute | Meaning |
+==================+===============================+
-| ``A_ALTCHARSET`` | Alternate character set mode. |
+| ``A_ALTCHARSET`` | Alternate character set mode |
+------------------+-------------------------------+
-| ``A_BLINK`` | Blink mode. |
+| ``A_BLINK`` | Blink mode |
+------------------+-------------------------------+
-| ``A_BOLD`` | Bold mode. |
+| ``A_BOLD`` | Bold mode |
+------------------+-------------------------------+
-| ``A_DIM`` | Dim mode. |
+| ``A_DIM`` | Dim mode |
+------------------+-------------------------------+
-| ``A_NORMAL`` | Normal attribute. |
+| ``A_INVIS`` | Invisible or blank mode |
++------------------+-------------------------------+
+| ``A_NORMAL`` | Normal attribute |
++------------------+-------------------------------+
+| ``A_PROTECT`` | Protected mode |
+------------------+-------------------------------+
| ``A_REVERSE`` | Reverse background and |
-| | foreground colors. |
+| | foreground colors |
++------------------+-------------------------------+
+| ``A_STANDOUT`` | Standout mode |
++------------------+-------------------------------+
+| ``A_UNDERLINE`` | Underline mode |
++------------------+-------------------------------+
+| ``A_HORIZONTAL`` | Horizontal highlight |
++------------------+-------------------------------+
+| ``A_LEFT`` | Left highlight |
++------------------+-------------------------------+
+| ``A_LOW`` | Low highlight |
++------------------+-------------------------------+
+| ``A_RIGHT`` | Right highlight |
++------------------+-------------------------------+
+| ``A_TOP`` | Top highlight |
++------------------+-------------------------------+
+| ``A_VERTICAL`` | Vertical highlight |
++------------------+-------------------------------+
+| ``A_CHARTEXT`` | Bit-mask to extract a |
+| | character |
++------------------+-------------------------------+
+
+Several constants are available to extract corresponding attributes returned
+by some methods.
+
++------------------+-------------------------------+
+| Bit-mask | Meaning |
++==================+===============================+
+| ``A_ATTRIBUTES`` | Bit-mask to extract |
+| | attributes |
+------------------+-------------------------------+
-| ``A_STANDOUT`` | Standout mode. |
+| ``A_CHARTEXT`` | Bit-mask to extract a |
+| | character |
+------------------+-------------------------------+
-| ``A_UNDERLINE`` | Underline mode. |
+| ``A_COLOR`` | Bit-mask to extract |
+| | color-pair field information |
+------------------+-------------------------------+
Keys are referred to by integer constants with names starting with ``KEY_``.
+-------------------+--------------------------------------------+
| ``KEY_SEOL`` | Shifted Clear line |
+-------------------+--------------------------------------------+
-| ``KEY_SEXIT`` | Shifted Dxit |
+| ``KEY_SEXIT`` | Shifted Exit |
+-------------------+--------------------------------------------+
| ``KEY_SFIND`` | Shifted Find |
+-------------------+--------------------------------------------+
Example:
- >>> from datetime import time, tzinfo
+ >>> from datetime import time, tzinfo, timedelta
>>> class GMT1(tzinfo):
... def utcoffset(self, dt):
... return timedelta(hours=1)
>>> [1, 2, 3].remove(42)
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
That doctest succeeds if :exc:`ValueError` is raised, with the ``list.remove(x):
>>> raise ValueError('multi\n line\ndetail')
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: multi
line
detail
A number of option flags control various aspects of doctest's behavior.
Symbolic names for the flags are supplied as module constants, which can be
-or'ed together and passed to various functions. The names can also be used in
-:ref:`doctest directives <doctest-directives>`.
+:ref:`bitwise ORed <bitwise>` together and passed to various functions.
+The names can also be used in :ref:`doctest directives <doctest-directives>`.
The first group of options define test semantics, controlling aspects of how
doctest decides whether actual output matches an example's expected output:
>>> (1, 2)[3] = 'moo'
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
TypeError: object doesn't support item assignment
passes under Python 2.3 and later Python versions with the flag specified,
the option flags specified for the test case when the :class:`DocTestCase`
instance was constructed. If no reporting flags were specified (which is the
typical and expected case), :mod:`doctest`'s :mod:`unittest` reporting flags are
- or'ed into the option flags, and the option flags so augmented are passed to the
- :class:`DocTestRunner` instance created to run the doctest. If any reporting
- flags were specified when the :class:`DocTestCase` instance was constructed,
- :mod:`doctest`'s :mod:`unittest` reporting flags are ignored.
+ :ref:`bitwise ORed <bitwise>` into the option flags, and the option flags
+ so augmented are passed to the :class:`DocTestRunner` instance created to
+ run the doctest. If any reporting flags were specified when the
+ :class:`DocTestCase` instance was constructed, :mod:`doctest`'s
+ :mod:`unittest` reporting flags are ignored.
The value of the :mod:`unittest` reporting flags in effect before the function
was called is returned by the function.
Unless the ``_charset`` parameter is explicitly set to ``None``, the
MIMEText object created will have both a :mailheader:`Content-Type` header
- with a ``charset`` parameter, and a :mailheader:`Content-Transfer-Endcoding`
+ with a ``charset`` parameter, and a :mailheader:`Content-Transfer-Encoding`
header. This means that a subsequent ``set_payload`` call will not result
in an encoded payload, even if a charset is passed in the ``set_payload``
command. You can "reset" this behavior by deleting the
.. function:: fnmatch(filename, pattern)
Test whether the *filename* string matches the *pattern* string, returning
- :const:`True` or :const:`False`. If the operating system is case-insensitive,
- then both parameters will be normalized to all lower- or upper-case before
- the comparison is performed. :func:`fnmatchcase` can be used to perform a
+ :const:`True` or :const:`False`. Both parameters are case-normalized
+ using :func:`os.path.normcase`. :func:`fnmatchcase` can be used to perform a
case-sensitive comparison, regardless of whether that's standard for the
operating system.
.. function:: fnmatchcase(filename, pattern)
Test whether *filename* matches *pattern*, returning :const:`True` or
- :const:`False`; the comparison is case-sensitive.
+ :const:`False`; the comparison is case-sensitive and does not apply
+ :func:`os.path.normcase`.
.. function:: filter(names, pattern)
>>> import math
>>> math.exp(1000)
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
FloatingPointError: in math_1
the trailing CRLF stripped. The default *callback* prints the line to ``sys.stdout``.
-.. method:: FTP.set_pasv(boolean)
+.. method:: FTP.set_pasv(val)
- Enable "passive" mode if *boolean* is true, other disable passive mode. (In
+ Enable "passive" mode if *val* is true, otherwise disable passive mode. (In
Python 2.0 and before, passive mode was off by default; in Python 2.1 and later,
it is on by default.)
-.. method:: FTP.storbinary(command, file[, blocksize, callback, rest])
+.. method:: FTP.storbinary(command, fp[, blocksize, callback, rest])
Store a file in binary transfer mode. *command* should be an appropriate
- ``STOR`` command: ``"STOR filename"``. *file* is an open file object which is
+ ``STOR`` command: ``"STOR filename"``. *fp* is an open file object which is
read until EOF using its :meth:`read` method in blocks of size *blocksize* to
provide the data to be stored. The *blocksize* argument defaults to 8192.
*callback* is an optional single parameter callable that is called
.. versionchanged:: 2.7
*rest* parameter added.
-.. method:: FTP.storlines(command, file[, callback])
+.. method:: FTP.storlines(command, fp[, callback])
Store a file in ASCII transfer mode. *command* should be an appropriate
``STOR`` command (see :meth:`storbinary`). Lines are read until EOF from the
- open file object *file* using its :meth:`~file.readline` method to provide
+ open file object *fp* using its :meth:`~file.readline` method to provide
the data to be stored. *callback* is an optional single parameter callable
that is called on each line after it is sent.
:func:`basestring` :func:`execfile` :func:`issubclass` :func:`print` :func:`super`
:func:`bin` :func:`file` :func:`iter` :func:`property` :func:`tuple`
:func:`bool` :func:`filter` :func:`len` :func:`range` :func:`type`
-:func:`bytearray` :func:`float` :func:`list` :func:`raw_input` :func:`unichr`
+:func:`bytearray` :func:`float` |func-list|_ :func:`raw_input` :func:`unichr`
:func:`callable` :func:`format` :func:`locals` :func:`reduce` :func:`unicode`
:func:`chr` |func-frozenset|_ :func:`long` :func:`reload` :func:`vars`
:func:`classmethod` :func:`getattr` :func:`map` |func-repr|_ :func:`xrange`
.. |func-dict| replace:: ``dict()``
.. |func-frozenset| replace:: ``frozenset()``
+.. |func-list| replace:: ``list()``
.. |func-memoryview| replace:: ``memoryview()``
.. |func-repr| replace:: ``repr()``
.. |func-set| replace:: ``set()``
'0x1L'
If x is not a Python :class:`int` or :class:`long` object, it has to
- define an __index__() method that returns an integer.
+ define a __hex__() method that returns a string.
See also :func:`int` for converting a hexadecimal string to an
integer using a base of 16.
(such as a dictionary, set, or frozen set).
+.. _func-list:
.. class:: list([iterable])
+ :noindex:
Return a list whose items are the same and in the same order as *iterable*'s
items. *iterable* may be either a sequence, a container that supports
.. method:: HTTPConnection.set_tunnel(host,port=None, headers=None)
Set the host and the port for HTTP Connect Tunnelling. Normally used when
- it is required to do HTTPS Conection through a proxy server.
+ it is required to do HTTPS Connection through a proxy server.
The headers argument should be a mapping of extra HTTP headers to send
with the CONNECT request.
single: stack viewer
Debugger (toggle)
- When actived, code entered in the Shell or run from an Editor will run
+ When activated, code entered in the Shell or run from an Editor will run
under the debugger. In the Editor, breakpoints can be set with the context
menu. This feature is still incomplete and somewhat experimental.
* :kbd:`C-l` center window around the insertion point
- * :kbd:`C-b` go backwards one character without deleting (usually you can
+ * :kbd:`C-b` go backward one character without deleting (usually you can
also use the cursor key for this)
* :kbd:`C-f` go forward one character without deleting (usually you can
Python Shell window by one tab). After certain keywords (break, return etc.)
the next line is dedented. In leading indentation, :kbd:`Backspace` deletes up
to 4 spaces if they are there. :kbd:`Tab` inserts spaces (in the Python
-Shell window one tab), number depends on Indent width. Currently tabs
+Shell window one tab), number depends on Indent width. Currently, tabs
are restricted to four spaces due to Tcl/Tk limitations.
See also the indent/dedent region commands in the edit menu.
:kbd:`C-space` will open a completions window. In an empty
string, this will contain the files in the current directory. On a
blank line, it will contain the built-in and user-defined functions and
-classes in the current name spaces, plus any modules imported. If some
+classes in the current namespaces, plus any modules imported. If some
characters have been entered, the ACW will attempt to be more specific.
If a string of characters is typed, the ACW selection will jump to the
As much as possible, the result of executing Python code with IDLE is the
same as executing the same code in a console window. However, the different
-interface and operation occasionally affects visible results. For instance,
+interface and operation occasionally affect visible results. For instance,
``sys.modules`` starts with more entries.
IDLE also replaces ``sys.stdin``, ``sys.stdout``, and ``sys.stderr`` with
If the attempt to make the socket connection fails, Idle will notify you.
Such failures are sometimes transient, but if persistent, the problem
-may be either a firewall blocking the connecton or misconfiguration of
+may be either a firewall blocking the connection or misconfiguration of
a particular system. Until the problem is fixed, one can run Idle with
the -n command line switch.
The font preferences, highlighting, keys, and general preferences can be
changed via Configure IDLE on the Option menu. Keys can be user defined;
-IDLE ships with four built in key sets. In addition a user can create a
+IDLE ships with four built-in key sets. In addition, a user can create a
custom key set in the Configure IDLE dialog under the keys tab.
Extensions
^^^^^^^^^^
-IDLE contains an extension facility. Peferences for extensions can be
+IDLE contains an extension facility. Preferences for extensions can be
changed with Configure Extensions. See the beginning of config-extensions.def
in the idlelib directory for further information. The default extensions
are currently:
-:mod:`importlib` -- Convenience wrappers for :func:`__import__`
-===============================================================
+:mod:`importlib` --- Convenience wrappers for :func:`__import__`
+================================================================
.. module:: importlib
:synopsis: Convenience wrappers for __import__
... # Let the base class default method raise the TypeError
... return json.JSONEncoder.default(self, obj)
...
- >>> dumps(2 + 1j, cls=ComplexEncoder)
+ >>> json.dumps(2 + 1j, cls=ComplexEncoder)
'[2.0, 1.0]'
>>> ComplexEncoder().encode(2 + 1j)
'[2.0, 1.0]'
:param disable_existing_loggers: If specified as ``False``, loggers which
exist when this call is made are left
enabled. The default is ``True`` because this
- enables old behaviour in a backward-
- compatible way. This behaviour is to
+ enables old behaviour in a
+ backward-compatible way. This behaviour is to
disable any existing loggers unless they or
their ancestors are explicitly named in the
logging configuration.
loaded "on top" of the default database.
-.. attribute:: MimeTypes.suffix_map
+ .. attribute:: MimeTypes.suffix_map
- Dictionary mapping suffixes to suffixes. This is used to allow recognition of
- encoded files for which the encoding and the type are indicated by the same
- extension. For example, the :file:`.tgz` extension is mapped to :file:`.tar.gz`
- to allow the encoding and type to be recognized separately. This is initially a
- copy of the global :data:`suffix_map` defined in the module.
+ Dictionary mapping suffixes to suffixes. This is used to allow recognition of
+ encoded files for which the encoding and the type are indicated by the same
+ extension. For example, the :file:`.tgz` extension is mapped to :file:`.tar.gz`
+ to allow the encoding and type to be recognized separately. This is initially a
+ copy of the global :data:`suffix_map` defined in the module.
-.. attribute:: MimeTypes.encodings_map
+ .. attribute:: MimeTypes.encodings_map
- Dictionary mapping filename extensions to encoding types. This is initially a
- copy of the global :data:`encodings_map` defined in the module.
+ Dictionary mapping filename extensions to encoding types. This is initially a
+ copy of the global :data:`encodings_map` defined in the module.
-.. attribute:: MimeTypes.types_map
+ .. attribute:: MimeTypes.types_map
- Tuple containing two dictionaries, mapping filename extensions to MIME types:
- the first dictionary is for the non-standards types and the second one is for
- the standard types. They are initialized by :data:`common_types` and
- :data:`types_map`.
+ Tuple containing two dictionaries, mapping filename extensions to MIME types:
+ the first dictionary is for the non-standards types and the second one is for
+ the standard types. They are initialized by :data:`common_types` and
+ :data:`types_map`.
-.. attribute:: MimeTypes.types_map_inv
+ .. attribute:: MimeTypes.types_map_inv
- Tuple containing two dictionaries, mapping MIME types to a list of filename
- extensions: the first dictionary is for the non-standards types and the
- second one is for the standard types. They are initialized by
- :data:`common_types` and :data:`types_map`.
+ Tuple containing two dictionaries, mapping MIME types to a list of filename
+ extensions: the first dictionary is for the non-standards types and the
+ second one is for the standard types. They are initialized by
+ :data:`common_types` and :data:`types_map`.
-.. method:: MimeTypes.guess_extension(type, strict=True)
+ .. method:: MimeTypes.guess_extension(type, strict=True)
- Similar to the :func:`guess_extension` function, using the tables stored as part
- of the object.
+ Similar to the :func:`guess_extension` function, using the tables stored as part
+ of the object.
-.. method:: MimeTypes.guess_type(url, strict=True)
+ .. method:: MimeTypes.guess_type(url, strict=True)
- Similar to the :func:`guess_type` function, using the tables stored as part of
- the object.
+ Similar to the :func:`guess_type` function, using the tables stored as part of
+ the object.
-.. method:: MimeTypes.guess_all_extensions(type, strict=True)
+ .. method:: MimeTypes.guess_all_extensions(type, strict=True)
- Similar to the :func:`guess_all_extensions` function, using the tables stored
- as part of the object.
+ Similar to the :func:`guess_all_extensions` function, using the tables stored
+ as part of the object.
-.. method:: MimeTypes.read(filename, strict=True)
+ .. method:: MimeTypes.read(filename, strict=True)
- Load MIME information from a file named *filename*. This uses :meth:`readfp` to
- parse the file.
+ Load MIME information from a file named *filename*. This uses :meth:`readfp` to
+ parse the file.
- If *strict* is ``True``, information will be added to list of standard types,
- else to the list of non-standard types.
+ If *strict* is ``True``, information will be added to list of standard types,
+ else to the list of non-standard types.
-.. method:: MimeTypes.readfp(fp, strict=True)
+ .. method:: MimeTypes.readfp(fp, strict=True)
- Load MIME type information from an open file *fp*. The file must have the format of
- the standard :file:`mime.types` files.
+ Load MIME type information from an open file *fp*. The file must have the format of
+ the standard :file:`mime.types` files.
- If *strict* is ``True``, information will be added to the list of standard
- types, else to the list of non-standard types.
+ If *strict* is ``True``, information will be added to the list of standard
+ types, else to the list of non-standard types.
-.. method:: MimeTypes.read_windows_registry(strict=True)
+ .. method:: MimeTypes.read_windows_registry(strict=True)
- Load MIME type information from the Windows registry. Availability: Windows.
+ Load MIME type information from the Windows registry. Availability: Windows.
- If *strict* is ``True``, information will be added to the list of standard
- types, else to the list of non-standard types.
+ If *strict* is ``True``, information will be added to the list of standard
+ types, else to the list of non-standard types.
- .. versionadded:: 2.7
+ .. versionadded:: 2.7
-:mod:`msvcrt` -- Useful routines from the MS VC++ runtime
-=========================================================
+:mod:`msvcrt` --- Useful routines from the MS VC++ runtime
+==========================================================
.. module:: msvcrt
:platform: Windows
.. method:: recv()
Return an object sent from the other end of the connection using
- :meth:`send`. Blocks until there its something to receive. Raises
+ :meth:`send`. Blocks until there is something to receive. Raises
:exc:`EOFError` if there is nothing left to receive
and the other end was closed.
.. function:: setpgrp()
- Call the system call :c:func:`setpgrp` or :c:func:`setpgrp(0, 0)` depending on
+ Call the system call :c:func:`setpgrp` or ``setpgrp(0, 0)`` depending on
which version is implemented (if any). See the Unix manual for the semantics.
Availability: Unix.
>>> import mymodule
>>> mymodule.test()
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
File "./mymodule.py", line 4, in test
test2()
File "./mymodule.py", line 3, in test2
When a pickled class instance is unpickled, its :meth:`__init__` method is
normally *not* invoked. If it is desirable that the :meth:`__init__` method
be called on unpickling, an old-style class can define a method
- :meth:`__getinitargs__`, which should return a *tuple* containing the
+ :meth:`__getinitargs__`, which should return a *tuple* of positional
arguments to be passed to the class constructor (:meth:`__init__` for
- example). The :meth:`__getinitargs__` method is called at pickle time; the
- tuple it returns is incorporated in the pickle for the instance.
+ example). Keyword arguments are not supported. The :meth:`__getinitargs__`
+ method is called at pickle time; the tuple it returns is incorporated in the
+ pickle for the instance.
.. method:: object.__getnewargs__()
returned as strings.
Values that cannot be determined are returned as given by the parameter presets.
- If bits is given as ``''``, the :c:func:`sizeof(pointer)` (or
- :c:func:`sizeof(long)` on Python version < 1.5.2) is used as indicator for the
+ If bits is given as ``''``, the ``sizeof(pointer)`` (or
+ ``sizeof(long)`` on Python version < 1.5.2) is used as indicator for the
supported pointer size.
The function relies on the system's :file:`file` command to do the actual work.
.. rubric:: Footnotes
-.. [#] The encoding string included in XML output should conform to the
+.. [1] The encoding string included in XML output should conform to the
appropriate standards. For example, "UTF-8" is valid, but "UTF8" is
not. See https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl
and https://www.iana.org/assignments/character-sets/character-sets.xhtml.
Bookkeeping functions:
-.. function:: seed([x])
+.. function:: seed(a=None)
- Initialize the basic random number generator. Optional argument *x* can be any
- :term:`hashable` object. If *x* is omitted or ``None``, current system time is used;
- current system time is also used to initialize the generator when the module is
- first imported. If randomness sources are provided by the operating system,
- they are used instead of the system time (see the :func:`os.urandom` function
- for details on availability).
+ Initialize internal state of the random number generator.
- If a :term:`hashable` object is given, deterministic results are only assured
- when :envvar:`PYTHONHASHSEED` is disabled.
+ ``None`` or no argument seeds from current time or from an operating
+ system specific randomness source if available (see the :func:`os.urandom`
+ function for details on availability).
+
+ If *a* is not ``None`` or an :class:`int` or a :class:`long`, then
+ ``hash(a)`` is used instead. Note that the hash values for some types
+ are nondeterministic when :envvar:`PYTHONHASHSEED` is enabled.
.. versionchanged:: 2.4
formerly, operating system resources were not used.
shortcuts that don't require you to compile a regex object first, but miss some
fine-tuning parameters.
+.. seealso::
+
+ The third-party `regex <https://pypi.python.org/pypi/regex/>`_ module,
+ which has an API compatible with the standard library :mod:`re` module,
+ but offers additional functionality and a more thorough Unicode support.
+
.. _re-syntax:
IGNORECASE
Perform case-insensitive matching; expressions like ``[A-Z]`` will match
- lowercase letters, too. This is not affected by the current locale.
+ lowercase letters, too. This is not affected by the current locale. To
+ get this effect on non-ASCII Unicode characters such as ``ü`` and ``Ü``,
+ add the :const:`UNICODE` flag.
.. data:: L
.. data:: U
UNICODE
- Make ``\w``, ``\W``, ``\b``, ``\B``, ``\d``, ``\D``, ``\s`` and ``\S`` dependent
- on the Unicode character properties database.
+ Make the ``\w``, ``\W``, ``\b``, ``\B``, ``\d``, ``\D``, ``\s`` and ``\S``
+ sequences dependent on the Unicode character properties database. Also
+ enables non-ASCII matching for :const:`IGNORECASE`.
.. versionadded:: 2.0
Added the optional flags argument.
-.. function:: escape(string)
+.. function:: escape(pattern)
+
+ Escape all the characters in *pattern* except ASCII letters and numbers.
+ This is useful if you want to match an arbitrary literal string that may
+ have regular expression metacharacters in it. For example::
+
+ >>> print re.escape('python.exe')
+ python\.exe
+
+ >>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
+ >>> print '[%s]+' % re.escape(legal_chars)
+ [abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^\_\`\|\~\:]+
- Return *string* with all non-alphanumerics backslashed; this is useful if you
- want to match an arbitrary literal string that may have regular expression
- metacharacters in it.
+ >>> operators = ['+', '-', '*', '/', '**']
+ >>> print '|'.join(map(re.escape, sorted(operators, reverse=True)))
+ \/|\-|\+|\*\*|\*
.. function:: purge()
passing it to :meth:`convert_entityref`. If a translation is returned, it calls
the method :meth:`handle_data` with the translation; otherwise, it calls the
method ``unknown_entityref(ref)``. The default :attr:`entitydefs` defines
- translations for ``&``, ``&apos``, ``>``, ``<``, and ``"``.
+ translations for ``&``, ``'``, ``>``, ``<``, and ``"``.
.. versionchanged:: 2.5
Use :meth:`convert_entityref` instead of hard-coding the conversion.
*base_name* is the name of the file to create, including the path, minus
any format-specific extension. *format* is the archive format: one of
- "zip", "tar", "bztar" or "gztar".
+ "zip" (if the :mod:`zlib` module or external ``zip`` executable is
+ available), "tar", "gztar" (if the :mod:`zlib` module is available), or
+ "bztar" (if the :mod:`bz2` module is available).
*root_dir* is a directory that will be the root directory of the
archive; ie. we typically chdir into *root_dir* before creating the
By default :mod:`shutil` provides these formats:
- - *gztar*: gzip'ed tar-file
- - *bztar*: bzip2'ed tar-file
- - *tar*: uncompressed tar file
- - *zip*: ZIP file
+ - *zip*: ZIP file (if the :mod:`zlib` module or external ``zip``
+ executable is available).
+ - *tar*: uncompressed tar file.
+ - *gztar*: gzip'ed tar-file (if the :mod:`zlib` module is available).
+ - *bztar*: bzip2'ed tar-file (if the :mod:`bz2` module is available).
You can register new formats or provide your own archiver for any existing
formats, by using :func:`register_archive_format`.
written to the fd. This can be used by a library to wakeup a poll or select
call, allowing the signal to be fully processed.
- The old wakeup fd is returned. *fd* must be non-blocking. It is up to the
- library to remove any bytes before calling poll or select again.
+ The old wakeup fd is returned (or -1 if file descriptor wakeup was not
+ enabled). If *fd* is -1, file descriptor wakeup is disabled.
+ If not -1, *fd* must be non-blocking. It is up to the library to remove
+ any bytes from *fd* before calling poll or select again.
When threads are enabled, this function can only be called from the main thread;
attempting to call it from other threads will cause a :exc:`ValueError`
does not contain certificates from *capath* unless a certificate was
requested and loaded by a SSL connection.
+ .. note::
+ Certificates in a capath directory aren't loaded unless they have
+ been used at least once.
+
.. method:: SSLContext.set_default_verify_paths()
Load a set of default "certification authority" (CA) certificates from
This method will raise :exc:`NotImplementedError` if :data:`HAS_ALPN` is
False.
- OpenSSL 1.1.0+ will abort the handshake and raise :exc:`SSLError` when
- both sides support ALPN but cannot agree on a protocol.
+ OpenSSL 1.1.0 to 1.1.0e will abort the handshake and raise :exc:`SSLError`
+ when both sides support ALPN but cannot agree on a protocol. 1.1.0f+
+ behaves like 1.0.2, :meth:`SSLSocket.selected_alpn_protocol` returns None.
.. versionadded:: 2.7.10
>>> stats['hits'], stats['misses']
(0, 0)
-.. method:: SSLContext.get_ca_certs(binary_form=False)
-
- Returns a list of dicts with information of loaded CA certs. If the
- optional argument is true, returns a DER-encoded copy of the CA
- certificate.
-
- .. note::
- Certificates in a capath directory aren't loaded unless they have
- been used at least once.
-
.. attribute:: SSLContext.check_hostname
Wether to match the peer cert's hostname with :func:`match_hostname` in
(1)
This is a short-circuit operator, so it only evaluates the second
- argument if the first one is :const:`False`.
+ argument if the first one is false.
(2)
This is a short-circuit operator, so it only evaluates the second
- argument if the first one is :const:`True`.
+ argument if the first one is true.
(3)
``not`` has a lower priority than non-Boolean operators, so ``not a == b`` is
pair: bitwise; operations
pair: shifting; operations
pair: masking; operations
+ operator: |
operator: ^
operator: &
operator: <<
operator: >>
+ operator: ~
Bitwise operations only make sense for integers. Negative numbers are treated
as their 2's complement value (this assumes a sufficiently large number of bits
:ref:`faq-multidimensional-list`.
(3)
- If *i* or *j* is negative, the index is relative to the end of the string:
+ If *i* or *j* is negative, the index is relative to the end of sequence *s*:
``len(s) + i`` or ``len(s) + j`` is substituted. But note that ``-0`` is still
``0``.
The slice of *s* from *i* to *j* with step *k* is defined as the sequence of
items with index ``x = i + n*k`` such that ``0 <= n < (j-i)/k``. In other words,
the indices are ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` and so on, stopping when
- *j* is reached (but never including *j*). If *i* or *j* is greater than
- ``len(s)``, use ``len(s)``. If *i* or *j* are omitted or ``None``, they become
+ *j* is reached (but never including *j*). When *k* is positive,
+ *i* and *j* are reduced to ``len(s)`` if they are greater.
+ When *k* is negative, *i* and *j* are reduced to ``len(s) - 1`` if
+ they are greater. If *i* or *j* are omitted or ``None``, they become
"end" values (which end depends on the sign of *k*). Note, *k* cannot be zero.
If *k* is ``None``, it is treated like ``1``.
.. method:: str.join(iterable)
- Return a string which is the concatenation of the strings in the
- :term:`iterable` *iterable*. The separator between elements is the string
- providing this method.
+ Return a string which is the concatenation of the strings in *iterable*.
+ A :exc:`TypeError` will be raised if there are any non-string values in
+ *iterable*, including :class:`bytes` objects. The separator between
+ elements is the string providing this method.
.. method:: str.ljust(width[, fillchar])
(2)
The alternate form causes a leading ``'0x'`` or ``'0X'`` (depending on whether
- the ``'x'`` or ``'X'`` format was used) to be inserted between left-hand padding
- and the formatting of the number if the leading character of the result is not
- already a zero.
+ the ``'x'`` or ``'X'`` format was used) to be inserted before the first digit.
(3)
The alternate form causes the result to always contain a decimal point, even if
Note, the *elem* argument to the :meth:`__contains__`, :meth:`remove`, and
:meth:`discard` methods may be a set. To support searching for an equivalent
- frozenset, the *elem* set is temporarily mutated during the search and then
- restored. During the search, the *elem* set should not be read or mutated
- since it does not have a meaningful value.
+ frozenset, a temporary one is created from *elem*.
.. seealso::
.. method:: AU_read.getnchannels()
- Returns number of audio channels (1 for mone, 2 for stereo).
+ Returns number of audio channels (1 for mono, 2 for stereo).
.. method:: AU_read.getsampwidth()
.. exception:: NannyNag
- Raised by :func:`tokeneater` if detecting an ambiguous indent. Captured and
+ Raised by :func:`process_tokens` if detecting an ambiguous indent. Captured and
handled in :func:`check`.
-.. function:: tokeneater(type, token, start, end, line)
+.. function:: process_tokens(tokens)
- This function is used by :func:`check` as a callback parameter to the function
- :func:`tokenize.tokenize`.
+ This function is used by :func:`check` to process tokens generated by the
+ :mod:`tokenize` module.
.. XXX document errprint, format_witnesses, Whitespace, check_equal, indents,
reset_globals
The :mod:`test` package contains all regression tests for Python as well as the
-modules :mod:`test.test_support` and :mod:`test.regrtest`.
-:mod:`test.test_support` is used to enhance your tests while
+modules :mod:`test.support` and :mod:`test.regrtest`.
+:mod:`test.support` is used to enhance your tests while
:mod:`test.regrtest` drives the testing suite.
Each module in the :mod:`test` package whose name starts with ``test_`` is a
A basic boilerplate is often used::
import unittest
- from test import test_support
+ from test import support
class MyTestCase1(unittest.TestCase):
... more test classes ...
def test_main():
- test_support.run_unittest(MyTestCase1,
- MyTestCase2,
- ... list other tests ...
- )
+ support.run_unittest(MyTestCase1,
+ MyTestCase2,
+ ... list other tests ...
+ )
if __name__ == '__main__':
test_main()
:program:`rt.bat` from your :file:`PCBuild` directory will run all regression
tests.
+.. versionchanged:: 2.7.14
+ The :mod:`test` package can be run as a script: :program:`python -m test`.
+ This works the same as running the :mod:`test.regrtest` module.
-:mod:`test.test_support` --- Utility functions for tests
-========================================================
-.. module:: test.test_support
+:mod:`test.support` --- Utility functions for tests
+===================================================
+
+.. module:: test.support
:synopsis: Support for Python regression tests.
.. note::
The :mod:`test.test_support` module has been renamed to :mod:`test.support`
- in Python 3.x.
+ in Python 3.x and 2.7.14. The name ``test.test_support`` has been retained
+ as an alias in 2.7.
-The :mod:`test.test_support` module provides support for Python's regression
+The :mod:`test.support` module provides support for Python's regression
tests.
This module defines the following exceptions:
network connection) is not available. Raised by the :func:`requires`
function.
-The :mod:`test.test_support` module defines the following constants:
+The :mod:`test.support` module defines the following constants:
.. data:: verbose
Set to a name that is safe to use as the name of a temporary file. Any
temporary file that is created should be closed and unlinked (removed).
-The :mod:`test.test_support` module defines the following functions:
+The :mod:`test.support` module defines the following functions:
.. function:: forget(module_name)
following :func:`test_main` function::
def test_main():
- test_support.run_unittest(__name__)
+ support.run_unittest(__name__)
This will run all tests defined in the named module.
.. versionadded:: 2.7
-The :mod:`test.test_support` module defines the following classes:
+The :mod:`test.support` module defines the following classes:
.. class:: TransientResource(exc[, **kwargs])
.. function:: tzset()
- Resets the time conversion rules used by the library routines. The environment
- variable :envvar:`TZ` specifies how this is done.
+ Reset the time conversion rules used by the library routines. The environment
+ variable :envvar:`TZ` specifies how this is done. It will also set the variables
+ ``tzname`` (from the :envvar:`TZ` environment variable), ``timezone`` (non-DST
+ seconds West of UTC), ``altzone`` (DST seconds west of UTC) and ``daylight``
+ (to 0 if this timezone does not have any daylight saving time rules, or to
+ nonzero if there is a time, past, present or future when daylight saving time
+ applies).
.. versionadded:: 2.3
This function prints a stack trace from its invocation point. The optional
*f* argument can be used to specify an alternate stack frame to start. The
- optional limit* and *file* arguments have the same meaning as for
+ optional *limit* and *file* arguments have the same meaning as for
:func:`print_exception`.
| wikipedia | a pattern from the wikipedia | :func:`clone`, |
| | article on turtle graphics | :func:`undo` |
+----------------+------------------------------+-----------------------+
-| yingyang | another elementary example | :func:`circle` |
+| yinyang | another elementary example | :func:`circle` |
+----------------+------------------------------+-----------------------+
Have fun!
9
>>> unicodedata.decimal(u'a')
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: not a decimal
>>> unicodedata.category(u'A') # 'L'etter, 'u'ppercase
'Lu'
Test that the multiline string *first* is equal to the string *second*.
When not equal a diff of the two strings highlighting the differences
will be included in the error message. This method is used by default
- when comparing strings with :meth:`assertEqual`.
+ when comparing Unicode strings with :meth:`assertEqual`.
.. versionadded:: 2.7
.. class:: TestSuite(tests=())
- This class represents an aggregation of individual tests cases and test suites.
+ This class represents an aggregation of individual test cases and test suites.
The class presents the interface needed by the test runner to allow it to be run
as any other test case. Running a :class:`TestSuite` instance is the same as
iterating over the suite, running each test individually.
.. method:: loadTestsFromTestCase(testCaseClass)
- Return a suite of all tests cases contained in the :class:`TestCase`\ -derived
+ Return a suite of all test cases contained in the :class:`TestCase`\ -derived
:class:`testCaseClass`.
.. method:: loadTestsFromModule(module)
- Return a suite of all tests cases contained in the given module. This
+ Return a suite of all test cases contained in the given module. This
method searches *module* for classes derived from :class:`TestCase` and
creates an instance of the class for each test method defined for the
class.
.. method:: loadTestsFromName(name, module=None)
- Return a suite of all tests cases given a string specifier.
+ Return a suite of all test cases given a string specifier.
The specifier *name* is a "dotted name" that may resolve either to a
module, a test case class, a test method within a test case class, a
.. seealso::
- The `Requests package <http://requests.readthedocs.org/>`_
+ The `Requests package <http://docs.python-requests.org/>`_
is recommended for a higher-level HTTP client interface.
-.. warning:: When opening HTTPS URLs, it does not attempt to validate the
- server certificate. Use at your own risk!
+.. versionchanged:: 2.7.9
+
+ For HTTPS URIs, :mod:`urllib` performs all the neccessary certificate and hostname checks by default.
+
+.. warning::
+
+ For Python versions earlier than 2.7.9, urllib does not attempt to validate the server certificates of HTTPS URIs. Use at your own risk!
High-level interface
:envvar:`no_proxy` environment variable.
.. versionchanged:: 2.7.9
- The *context* parameter was added.
+ The *context* parameter was added. All the neccessary certificate and hostname checks are done by default.
.. deprecated:: 2.6
The :func:`urlopen` function has been removed in Python 3 in favor
If both lowercase and uppercase environment variables exist (and disagree),
lowercase is preferred.
- .. note::
+ .. note::
- If the environment variable ``REQUEST_METHOD`` is set, which usually
- indicates your script is running in a CGI environment, the environment
- variable ``HTTP_PROXY`` (uppercase ``_PROXY``) will be ignored. This is
- because that variable can be injected by a client using the "Proxy:"
- HTTP header. If you need to use an HTTP proxy in a CGI environment,
- either use ``ProxyHandler`` explicitly, or make sure the variable name
- is in lowercase (or at least the ``_proxy`` suffix).
+ If the environment variable ``REQUEST_METHOD`` is set, which usually
+ indicates your script is running in a CGI environment, the environment
+ variable ``HTTP_PROXY`` (uppercase ``_PROXY``) will be ignored. This is
+ because that variable can be injected by a client using the "Proxy:" HTTP
+ header. If you need to use an HTTP proxy in a CGI environment, either use
+ ``ProxyHandler`` explicitly, or make sure the variable name is in
+ lowercase (or at least the ``_proxy`` suffix).
.. note::
urllib also exposes certain utility functions like splittype, splithost and
:class:`URLopener` objects will raise an :exc:`IOError` exception if the server
returns an error code.
- .. method:: open(fullurl[, data])
+ .. method:: open(fullurl[, data])
- Open *fullurl* using the appropriate protocol. This method sets up cache and
- proxy information, then calls the appropriate open method with its input
- arguments. If the scheme is not recognized, :meth:`open_unknown` is called.
- The *data* argument has the same meaning as the *data* argument of
- :func:`urlopen`.
+ Open *fullurl* using the appropriate protocol. This method sets up cache and
+ proxy information, then calls the appropriate open method with its input
+ arguments. If the scheme is not recognized, :meth:`open_unknown` is called.
+ The *data* argument has the same meaning as the *data* argument of
+ :func:`urlopen`.
- .. method:: open_unknown(fullurl[, data])
+ .. method:: open_unknown(fullurl[, data])
- Overridable interface to open unknown URL types.
+ Overridable interface to open unknown URL types.
- .. method:: retrieve(url[, filename[, reporthook[, data]]])
+ .. method:: retrieve(url[, filename[, reporthook[, data]]])
- Retrieves the contents of *url* and places it in *filename*. The return value
- is a tuple consisting of a local filename and either a
- :class:`mimetools.Message` object containing the response headers (for remote
- URLs) or ``None`` (for local URLs). The caller must then open and read the
- contents of *filename*. If *filename* is not given and the URL refers to a
- local file, the input filename is returned. If the URL is non-local and
- *filename* is not given, the filename is the output of :func:`tempfile.mktemp`
- with a suffix that matches the suffix of the last path component of the input
- URL. If *reporthook* is given, it must be a function accepting three numeric
- parameters. It will be called after each chunk of data is read from the
- network. *reporthook* is ignored for local URLs.
+ Retrieves the contents of *url* and places it in *filename*. The return value
+ is a tuple consisting of a local filename and either a
+ :class:`mimetools.Message` object containing the response headers (for remote
+ URLs) or ``None`` (for local URLs). The caller must then open and read the
+ contents of *filename*. If *filename* is not given and the URL refers to a
+ local file, the input filename is returned. If the URL is non-local and
+ *filename* is not given, the filename is the output of :func:`tempfile.mktemp`
+ with a suffix that matches the suffix of the last path component of the input
+ URL. If *reporthook* is given, it must be a function accepting three numeric
+ parameters. It will be called after each chunk of data is read from the
+ network. *reporthook* is ignored for local URLs.
- If the *url* uses the :file:`http:` scheme identifier, the optional *data*
- argument may be given to specify a ``POST`` request (normally the request type
- is ``GET``). The *data* argument must in standard
- :mimetype:`application/x-www-form-urlencoded` format; see the :func:`urlencode`
- function below.
+ If the *url* uses the :file:`http:` scheme identifier, the optional *data*
+ argument may be given to specify a ``POST`` request (normally the request type
+ is ``GET``). The *data* argument must in standard
+ :mimetype:`application/x-www-form-urlencoded` format; see the :func:`urlencode`
+ function below.
- .. attribute:: version
+ .. attribute:: version
- Variable that specifies the user agent of the opener object. To get
- :mod:`urllib` to tell servers that it is a particular user agent, set this in a
- subclass as a class variable or in the constructor before calling the base
- constructor.
+ Variable that specifies the user agent of the opener object. To get
+ :mod:`urllib` to tell servers that it is a particular user agent, set this in a
+ subclass as a class variable or in the constructor before calling the base
+ constructor.
.. class:: FancyURLopener(...)
users for the required information on the controlling terminal. A subclass may
override this method to support more appropriate behavior if needed.
- The :class:`FancyURLopener` class offers one additional method that should be
- overloaded to provide the appropriate behavior:
+ The :class:`FancyURLopener` class offers one additional method that should be
+ overloaded to provide the appropriate behavior:
- .. method:: prompt_user_passwd(host, realm)
+ .. method:: prompt_user_passwd(host, realm)
- Return information needed to authenticate the user at the given host in the
- specified security realm. The return value should be a tuple, ``(user,
- password)``, which can be used for basic authentication.
+ Return information needed to authenticate the user at the given host in the
+ specified security realm. The return value should be a tuple, ``(user,
+ password)``, which can be used for basic authentication.
- The implementation prompts for this information on the terminal; an application
- should override this method to use an appropriate interaction model in the local
- environment.
+ The implementation prompts for this information on the terminal; an application
+ should override this method to use an appropriate interaction model in the local
+ environment.
.. exception:: ContentTooShortError(msg[, content])
.. attribute:: UUID.variant
The UUID variant, which determines the internal layout of the UUID. This will be
- one of the integer constants :const:`RESERVED_NCS`, :const:`RFC_4122`,
+ one of the constants :const:`RESERVED_NCS`, :const:`RFC_4122`,
:const:`RESERVED_MICROSOFT`, or :const:`RESERVED_FUTURE`.
magic" (as a side effect of garbage collection).
:class:`WeakValueDictionary` objects have the following additional methods.
-These method have the same issues as the :meth:`iterkeyrefs` and :meth:`keyrefs`
-methods of :class:`WeakKeyDictionary` objects.
+These methods have the same issues as the :meth:`iterkeyrefs` and
+:meth:`keyrefs` methods of :class:`WeakKeyDictionary` objects.
.. method:: WeakValueDictionary.itervaluerefs()
.. rubric:: Footnotes
-.. [#] The encoding string included in XML output should conform to the
+.. [1] The encoding string included in XML output should conform to the
appropriate standards. For example, "UTF-8" is valid, but "UTF8" is
not. See https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl
and https://www.iana.org/assignments/character-sets/character-sets.xhtml.
.. rubric:: Footnotes
-.. [#] The encoding string included in XML output should conform to the
+.. [1] The encoding string included in XML output should conform to the
appropriate standards. For example, "UTF-8" is valid, but "UTF8" is
not. See https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl
and https://www.iana.org/assignments/character-sets/character-sets.xhtml.
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python |release| alone or in any derivative
version, provided, however, that PSF's License Agreement and PSF's notice of
- copyright, i.e., "Copyright © 2001-2016 Python Software Foundation; All Rights
+ copyright, i.e., "Copyright © 2001-2017 Python Software Foundation; All Rights
Reserved" are retained in Python |release| alone or in any derivative version
prepared by Licensee.
\r
:build\r
if NOT "%PAPER%" == "" (\r
- set SPHINXOPTS=-D latex_paper_size=%PAPER% %SPHINXOPTS%\r
+ set SPHINXOPTS=-D latex_elements.papersize=%PAPER% %SPHINXOPTS%\r
)\r
cmd /C %SPHINXBUILD% %SPHINXOPTS% -b%1 -dbuild\doctrees . %BUILDDIR%\%*\r
\r
hashed collections including :class:`set`, :class:`frozenset`, and
:class:`dict`. :meth:`__hash__` should return an integer. The only required
property is that objects which compare equal have the same hash value; it is
- advised to somehow mix together (e.g. using exclusive or) the hash values for
- the components of the object that also play a part in comparison of objects.
+ advised to mix together the hash values of the components of the object that
+ also play a part in comparison of objects by packing them into a tuple and
+ hashing the tuple. Example::
+
+ def __hash__(self):
+ return hash((self.name, self.nick, self.color))
If a class does not define a :meth:`__cmp__` or :meth:`__eq__` method it
should not define a :meth:`__hash__` operation either; if it defines
:meth:`__nonzero__` method and whose :meth:`__len__` method returns zero is
considered to be false in a Boolean context.
+ .. impl-detail::
+
+ In CPython, the length is required to be at most :attr:`sys.maxsize`.
+ If the length is larger than :attr:`!sys.maxsize` some features (such as
+ :func:`len`) may raise :exc:`OverflowError`. To prevent raising
+ :exc:`!OverflowError` by truth value testing, an object must define a
+ :meth:`__nonzero__` method.
+
.. method:: object.__getitem__(self, key)
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2
.. _comparisons:
-.. _is:
-.. _is not:
-.. _in:
-.. _not in:
Comparisons
===========
preferred; where ``!=`` is mentioned below ``<>`` is also accepted. The ``<>``
spelling is considered obsolescent.
+Value comparisons
+-----------------
+
The operators ``<``, ``>``, ``==``, ``>=``, ``<=``, and ``!=`` compare the
-values of two objects. The objects need not have the same type. If both are
-numbers, they are converted to a common type. Otherwise, objects of different
-types *always* compare unequal, and are ordered consistently but arbitrarily.
-You can control comparison behavior of objects of non-built-in types by defining
-a ``__cmp__`` method or rich comparison methods like ``__gt__``, described in
-section :ref:`specialnames`.
+values of two objects. The objects do not need to have the same type.
+
+Chapter :ref:`objects` states that objects have a value (in addition to type
+and identity). The value of an object is a rather abstract notion in Python:
+For example, there is no canonical access method for an object's value. Also,
+there is no requirement that the value of an object should be constructed in a
+particular way, e.g. comprised of all its data attributes. Comparison operators
+implement a particular notion of what the value of an object is. One can think
+of them as defining the value of an object indirectly, by means of their
+comparison implementation.
+
+Types can customize their comparison behavior by implementing
+a :meth:`__cmp__` method or
+:dfn:`rich comparison methods` like :meth:`__lt__`, described in
+:ref:`customization`.
+
+The default behavior for equality comparison (``==`` and ``!=``) is based on
+the identity of the objects. Hence, equality comparison of instances with the
+same identity results in equality, and equality comparison of instances with
+different identities results in inequality. A motivation for this default
+behavior is the desire that all objects should be reflexive (i.e. ``x is y``
+implies ``x == y``).
+
+The default order comparison (``<``, ``>``, ``<=``, and ``>=``) gives a
+consistent but arbitrary order.
(This unusual definition of comparison was used to simplify the definition of
operations like sorting and the :keyword:`in` and :keyword:`not in` operators.
In the future, the comparison rules for objects of different types are likely to
change.)
-Comparison of objects of the same type depends on the type:
-
-* Numbers are compared arithmetically.
-
-* Strings are compared lexicographically using the numeric equivalents (the
- result of the built-in function :func:`ord`) of their characters. Unicode and
- 8-bit strings are fully interoperable in this behavior. [#]_
-
-* Tuples and lists are compared lexicographically using comparison of
- corresponding elements. This means that to compare equal, each element must
- compare equal and the two sequences must be of the same type and have the same
- length.
-
- If not equal, the sequences are ordered the same as their first differing
- elements. For example, ``cmp([1,2,x], [1,2,y])`` returns the same as
- ``cmp(x,y)``. If the corresponding element does not exist, the shorter sequence
- is ordered first (for example, ``[1,2] < [1,2,3]``).
-
-* Mappings (dictionaries) compare equal if and only if their sorted (key, value)
- lists compare equal. [#]_ Outcomes other than equality are resolved
+The behavior of the default equality comparison, that instances with different
+identities are always unequal, may be in contrast to what types will need that
+have a sensible definition of object value and value-based equality. Such
+types will need to customize their comparison behavior, and in fact, a number
+of built-in types have done that.
+
+The following list describes the comparison behavior of the most important
+built-in types.
+
+* Numbers of built-in numeric types (:ref:`typesnumeric`) and of the standard
+ library types :class:`fractions.Fraction` and :class:`decimal.Decimal` can be
+ compared within and across their types, with the restriction that complex
+ numbers do not support order comparison. Within the limits of the types
+ involved, they compare mathematically (algorithmically) correct without loss
+ of precision.
+
+* Strings (instances of :class:`str` or :class:`unicode`)
+ compare lexicographically using the numeric equivalents (the
+ result of the built-in function :func:`ord`) of their characters. [#]_
+ When comparing an 8-bit string and a Unicode string, the 8-bit string
+ is converted to Unicode. If the conversion fails, the strings
+ are considered unequal.
+
+* Instances of :class:`tuple` or :class:`list` can be compared only
+ within each of their types. Equality comparison across these types
+ results in unequality, and ordering comparison across these types
+ gives an arbitrary order.
+
+ These sequences compare lexicographically using comparison of corresponding
+ elements, whereby reflexivity of the elements is enforced.
+
+ In enforcing reflexivity of elements, the comparison of collections assumes
+ that for a collection element ``x``, ``x == x`` is always true. Based on
+ that assumption, element identity is compared first, and element comparison
+ is performed only for distinct elements. This approach yields the same
+ result as a strict element comparison would, if the compared elements are
+ reflexive. For non-reflexive elements, the result is different than for
+ strict element comparison.
+
+ Lexicographical comparison between built-in collections works as follows:
+
+ - For two collections to compare equal, they must be of the same type, have
+ the same length, and each pair of corresponding elements must compare
+ equal (for example, ``[1,2] == (1,2)`` is false because the type is not the
+ same).
+
+ - Collections are ordered the same as their
+ first unequal elements (for example, ``cmp([1,2,x], [1,2,y])`` returns the
+ same as ``cmp(x,y)``). If a corresponding element does not exist, the
+ shorter collection is ordered first (for example, ``[1,2] < [1,2,3]`` is
+ true).
+
+* Mappings (instances of :class:`dict`) compare equal if and only if they have
+ equal `(key, value)` pairs. Equality comparison of the keys and values
+ enforces reflexivity.
+
+ Outcomes other than equality are resolved
consistently, but are not otherwise defined. [#]_
* Most other objects of built-in types compare unequal unless they are the same
another one is made arbitrarily but consistently within one execution of a
program.
-.. _membership-test-details:
+User-defined classes that customize their comparison behavior should follow
+some consistency rules, if possible:
+
+* Equality comparison should be reflexive.
+ In other words, identical objects should compare equal:
+
+ ``x is y`` implies ``x == y``
+
+* Comparison should be symmetric.
+ In other words, the following expressions should have the same result:
+
+ ``x == y`` and ``y == x``
+
+ ``x != y`` and ``y != x``
+
+ ``x < y`` and ``y > x``
+
+ ``x <= y`` and ``y >= x``
+
+* Comparison should be transitive.
+ The following (non-exhaustive) examples illustrate that:
-The operators :keyword:`in` and :keyword:`not in` test for collection
-membership. ``x in s`` evaluates to true if *x* is a member of the collection
-*s*, and false otherwise. ``x not in s`` returns the negation of ``x in s``.
-The collection membership test has traditionally been bound to sequences; an
-object is a member of a collection if the collection is a sequence and contains
-an element equal to that object. However, it make sense for many other object
-types to support membership tests without being a sequence. In particular,
-dictionaries (for keys) and sets support membership testing.
+ ``x > y and y > z`` implies ``x > z``
-For the list and tuple types, ``x in y`` is true if and only if there exists an
-index *i* such that either ``x is y[i]`` or ``x == y[i]`` is true.
+ ``x < y and y <= z`` implies ``x < z``
-For the Unicode and string types, ``x in y`` is true if and only if *x* is a
-substring of *y*. An equivalent test is ``y.find(x) != -1``. Note, *x* and *y*
-need not be the same type; consequently, ``u'ab' in 'abc'`` will return
-``True``. Empty strings are always considered to be a substring of any other
-string, so ``"" in "abc"`` will return ``True``.
+* Inverse comparison should result in the boolean negation.
+ In other words, the following expressions should have the same result:
-.. versionchanged:: 2.3
- Previously, *x* was required to be a string of length ``1``.
+ ``x == y`` and ``not x != y``
+
+ ``x < y`` and ``not x >= y`` (for total ordering)
+
+ ``x > y`` and ``not x <= y`` (for total ordering)
+
+ The last two expressions apply to totally ordered collections (e.g. to
+ sequences, but not to sets or mappings). See also the
+ :func:`~functools.total_ordering` decorator.
+
+* The :func:`hash` result should be consistent with equality.
+ Objects that are equal should either have the same hash value,
+ or be marked as unhashable.
+
+Python does not enforce these consistency rules.
+
+
+.. _in:
+.. _not in:
+.. _membership-test-details:
+
+Membership test operations
+--------------------------
+
+The operators :keyword:`in` and :keyword:`not in` test for membership. ``x in
+s`` evaluates to ``True`` if *x* is a member of *s*, and ``False`` otherwise.
+``x not in s`` returns the negation of ``x in s``. All built-in sequences and
+set types support this as well as dictionary, for which :keyword:`in` tests
+whether the dictionary has a given key. For container types such as list, tuple,
+set, frozenset, dict, or collections.deque, the expression ``x in y`` is equivalent
+to ``any(x is e or x == e for e in y)``.
+
+For the string and bytes types, ``x in y`` is ``True`` if and only if *x* is a
+substring of *y*. An equivalent test is ``y.find(x) != -1``. Empty strings are
+always considered to be a substring of any other string, so ``"" in "abc"`` will
+return ``True``.
For user-defined classes which define the :meth:`__contains__` method, ``x in
-y`` is true if and only if ``y.__contains__(x)`` is true.
+y`` returns ``True`` if ``y.__contains__(x)`` returns a true value, and
+``False`` otherwise.
For user-defined classes which do not define :meth:`__contains__` but do define
-:meth:`__iter__`, ``x in y`` is true if some value ``z`` with ``x == z`` is
+:meth:`__iter__`, ``x in y`` is ``True`` if some value ``z`` with ``x == z`` is
produced while iterating over ``y``. If an exception is raised during the
iteration, it is as if :keyword:`in` raised that exception.
Lastly, the old-style iteration protocol is tried: if a class defines
-:meth:`__getitem__`, ``x in y`` is true if and only if there is a non-negative
+:meth:`__getitem__`, ``x in y`` is ``True`` if and only if there is a non-negative
integer index *i* such that ``x == y[i]``, and all lower integer indices do not
raise :exc:`IndexError` exception. (If any other exception is raised, it is as
if :keyword:`in` raised that exception).
operator: is not
pair: identity; test
+
+.. _is:
+.. _is not:
+
+Identity comparisons
+--------------------
+
The operators :keyword:`is` and :keyword:`is not` test for object identity: ``x
is y`` is true if and only if *x* and *y* are the same object. ``x is not y``
yields the inverse truth value. [#]_
cases, Python returns the latter result, in order to preserve that
``divmod(x,y)[0] * y + x % y`` be very close to ``x``.
-.. [#] While comparisons between unicode strings make sense at the byte
- level, they may be counter-intuitive to users. For example, the
- strings ``u"\u00C7"`` and ``u"\u0043\u0327"`` compare differently,
- even though they both represent the same unicode character (LATIN
- CAPITAL LETTER C WITH CEDILLA). To compare strings in a human
- recognizable way, compare using :func:`unicodedata.normalize`.
-
-.. [#] The implementation computes this efficiently, without constructing lists or
- sorting.
+.. [#] The Unicode standard distinguishes between :dfn:`code points`
+ (e.g. U+0041) and :dfn:`abstract characters` (e.g. "LATIN CAPITAL LETTER A").
+ While most abstract characters in Unicode are only represented using one
+ code point, there is a number of abstract characters that can in addition be
+ represented using a sequence of more than one code point. For example, the
+ abstract character "LATIN CAPITAL LETTER C WITH CEDILLA" can be represented
+ as a single :dfn:`precomposed character` at code position U+00C7, or as a
+ sequence of a :dfn:`base character` at code position U+0043 (LATIN CAPITAL
+ LETTER C), followed by a :dfn:`combining character` at code position U+0327
+ (COMBINING CEDILLA).
+
+ The comparison operators on unicode strings compare at the level of Unicode code
+ points. This may be counter-intuitive to humans. For example,
+ ``u"\u00C7" == u"\u0043\u0327"`` is ``False``, even though both strings
+ represent the same abstract character "LATIN CAPITAL LETTER C WITH CEDILLA".
+
+ To compare strings at the level of abstract characters (that is, in a way
+ intuitive to humans), use :func:`unicodedata.normalize`.
.. [#] Earlier versions of Python used lexicographic comparison of the sorted (key,
value) lists, but this was very expensive for the common case of comparing for
builtin: execfile
builtin: compile
-**Programmer's note:** the :keyword:`global` is a directive to the parser. It
+**Programmer's note:** :keyword:`global` is a directive to the parser. It
applies only to code parsed at the same time as the :keyword:`global` statement.
In particular, a :keyword:`global` statement contained in an :keyword:`exec`
statement does not affect the code block *containing* the :keyword:`exec`
"""
ISSUE_URI = 'https://bugs.python.org/issue%s'
-SOURCE_URI = 'https://hg.python.org/cpython/file/2.7/%s'
+SOURCE_URI = 'https://github.com/python/cpython/tree/2.7/%s'
from docutils import nodes, utils
+from docutils.parsers.rst import Directive
from sphinx.util.nodes import split_explicit_title
-from sphinx.util.compat import Directive
from sphinx.writers.html import HTMLTranslator
from sphinx.writers.latex import LaTeXTranslator
def issue_role(typ, rawtext, text, lineno, inliner, options={}, content=[]):
issue = utils.unescape(text)
- text = 'issue ' + issue
+ text = 'bpo-'+ issue
refnode = nodes.reference(text, text, refuri=ISSUE_URI % issue)
return [refnode], []
--- /dev/null
+(function() {
+ 'use strict';
+
+ // Parses versions in URL segments like:
+ // "3", "dev", "release/2.7" or "3.6rc2"
+ var version_regexs = [
+ '(?:\\d)',
+ '(?:\\d\\.\\d[\\w\\d\\.]*)',
+ '(?:dev)',
+ '(?:release/\\d.\\d[\\x\\d\\.]*)'];
+
+ var all_versions = {
+ '3.7': 'dev (3.7)',
+ '3.6': '3.6',
+ '3.5': '3.5',
+ '3.4': '3.4',
+ '3.3': '3.3',
+ '2.7': '2.7',
+ };
+
+ var all_languages = {
+ 'en': 'English',
+ 'fr': 'French',
+ 'ja': 'Japanese',
+ };
+
+ function build_version_select(current_version, current_release) {
+ var buf = ['<select>'];
+
+ $.each(all_versions, function(version, title) {
+ buf.push('<option value="' + version + '"');
+ if (version == current_version)
+ buf.push(' selected="selected">' + current_release + '</option>');
+ else
+ buf.push('>' + title + '</option>');
+ });
+
+ buf.push('</select>');
+ return buf.join('');
+ }
+
+ function build_language_select(current_language) {
+ var buf = ['<select>'];
+
+ $.each(all_languages, function(language, title) {
+ if (language == current_language)
+ buf.push('<option value="' + language + '" selected="selected">' +
+ all_languages[current_language] + '</option>');
+ else
+ buf.push('<option value="' + language + '">' + title + '</option>');
+ });
+ buf.push('</select>');
+ return buf.join('');
+ }
+
+ function navigate_to_first_existing(urls) {
+ // Navigate to the first existing URL in urls.
+ var url = urls.shift();
+ if (urls.length == 0) {
+ window.location.href = url;
+ return;
+ }
+ $.ajax({
+ url: url,
+ success: function() {
+ window.location.href = url;
+ },
+ error: function() {
+ navigate_to_first_existing(urls);
+ }
+ });
+ }
+
+ function on_version_switch() {
+ var selected_version = $(this).children('option:selected').attr('value') + '/';
+ var url = window.location.href;
+ var current_language = language_segment_from_url(url);
+ var current_version = version_segment_in_url(url);
+ var new_url = url.replace('.org/' + current_language + current_version,
+ '.org/' + current_language + selected_version);
+ if (new_url != url) {
+ navigate_to_first_existing([
+ new_url,
+ url.replace('.org/' + current_language + current_version,
+ '.org/' + selected_version),
+ 'https://docs.python.org/' + current_language + selected_version,
+ 'https://docs.python.org/' + selected_version,
+ 'https://docs.python.org/'
+ ]);
+ }
+ }
+
+ function on_language_switch() {
+ var selected_language = $(this).children('option:selected').attr('value') + '/';
+ var url = window.location.href;
+ var current_language = language_segment_from_url(url);
+ var current_version = version_segment_in_url(url);
+ if (selected_language == 'en/') // Special 'default' case for english.
+ selected_language = '';
+ var new_url = url.replace('.org/' + current_language + current_version,
+ '.org/' + selected_language + current_version);
+ if (new_url != url) {
+ navigate_to_first_existing([
+ new_url,
+ 'https://docs.python.org/'
+ ]);
+ }
+ }
+
+ // Returns the path segment of the language as a string, like 'fr/'
+ // or '' if not found.
+ function language_segment_from_url(url) {
+ var language_regexp = '\.org/([a-z]{2}(?:-[a-z]{2})?/)';
+ var match = url.match(language_regexp);
+ if (match !== null)
+ return match[1];
+ return '';
+ }
+
+ // Returns the path segment of the version as a string, like '3.6/'
+ // or '' if not found.
+ function version_segment_in_url(url) {
+ var language_segment = '(?:[a-z]{2}(?:-[a-z]{2})?/)';
+ var version_segment = '(?:(?:' + version_regexs.join('|') + ')/)';
+ var version_regexp = '\\.org/' + language_segment + '?(' + version_segment + ')';
+ var match = url.match(version_regexp);
+ if (match !== null)
+ return match[1];
+ return ''
+ }
+
+ $(document).ready(function() {
+ var release = DOCUMENTATION_OPTIONS.VERSION;
+ var language_segment = language_segment_from_url(window.location.href);
+ var current_language = language_segment.replace(/\/+$/g, '') || 'en';
+ var version = release.substr(0, 3);
+ var version_select = build_version_select(version, release);
+
+ $('.version_switcher_placeholder').html(version_select);
+ $('.version_switcher_placeholder select').bind('change', on_version_switch);
+
+ var language_select = build_language_select(current_language);
+
+ $('.language_switcher_placeholder').html(language_select);
+ $('.language_switcher_placeholder select').bind('change', on_language_switch);
+ });
+})();
+++ /dev/null
-(function() {
- 'use strict';
-
- var all_versions = {
- '3.7': 'dev (3.7)',
- '3.6': '3.6',
- '3.5': '3.5',
- '3.4': '3.4',
- '3.3': '3.3',
- '2.7': '2.7',
- };
-
- function build_select(current_version, current_release) {
- var buf = ['<select>'];
-
- $.each(all_versions, function(version, title) {
- buf.push('<option value="' + version + '"');
- if (version == current_version)
- buf.push(' selected="selected">' + current_release + '</option>');
- else
- buf.push('>' + title + '</option>');
- });
-
- buf.push('</select>');
- return buf.join('');
- }
-
- function patch_url(url, new_version) {
- var url_re = /\.org\/(\d|py3k|dev|((release\/)?\d\.\d[\w\d\.]*))\//,
- new_url = url.replace(url_re, '.org/' + new_version + '/');
-
- if (new_url == url && !new_url.match(url_re)) {
- // python 2 url without version?
- new_url = url.replace(/\.org\//, '.org/' + new_version + '/');
- }
- return new_url;
- }
-
- function on_switch() {
- var selected = $(this).children('option:selected').attr('value');
-
- var url = window.location.href,
- new_url = patch_url(url, selected);
-
- if (new_url != url) {
- // check beforehand if url exists, else redirect to version's start page
- $.ajax({
- url: new_url,
- success: function() {
- window.location.href = new_url;
- },
- error: function() {
- window.location.href = 'https://docs.python.org/' + selected;
- }
- });
- }
- }
-
- $(document).ready(function() {
- var release = DOCUMENTATION_OPTIONS.VERSION;
- var version = release.substr(0, 3);
- var select = build_select(version, release);
-
- $('.version_switcher_placeholder').html(select);
- $('.version_switcher_placeholder select').bind('change', on_switch);
- });
-})();
howto/pyporting,,::,Programming Language :: Python :: 3
howto/regex,,::,
howto/regex,,:foo,(?:foo)
-howto/urllib2,,:password,"for example ""joe:password@example.com"""
+howto/urllib2,,:password,"""joe:password@example.com"""
library/audioop,,:ipos,"# factor = audioop.findfactor(in_test[ipos*2:ipos*2+len(out_test)],"
library/bisect,,:hi,all(val >= x for val in a[i:hi])
library/bisect,,:hi,all(val > x for val in a[i:hi])
library/profile,,:lineno,filename:lineno(function)
library/pyexpat,,:elem1,<py:elem1 />
library/pyexpat,,:py,"xmlns:py = ""http://www.python.org/ns/"">"
+library/re,,`,!#$%&'*+-.^_`|~:
+library/re,,`,[abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^\_\`\|\~\:]+
library/smtplib,,:port,method must support that as well as a regular host:port
library/socket,,::,'5aef:2b::8'
library/sqlite3,,:memory,
reference/datamodel,,:max,
reference/expressions,,:index,x[index:index]
reference/expressions,,`,`expressions...`
-reference/expressions,,`,"""`"""
+reference/expressions,350,`,`
reference/grammar,,`,'`' testlist1 '`'
reference/lexical_analysis,,:fileencoding,# vim:fileencoding=<encoding-name>
reference/lexical_analysis,,`,", : . ` = ;"
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-pdf-letter.zip">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 8 MB){% endtrans %}
+ </a> {% trans %}(ca. 11 MB){% endtrans %}
</td>
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-pdf-letter.tar.bz2">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 8 MB){% endtrans %}
+ </a> {% trans %}(ca. 11 MB){% endtrans %}
</td>
</tr>
<tr><td>{% trans %}PDF (A4 paper size){% endtrans %}</td>
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-pdf-a4.zip">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 8 MB){% endtrans %}</td>
+ </a> {% trans %}(ca. 11 MB){% endtrans %}</td>
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-pdf-a4.tar.bz2">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 8 MB){% endtrans %}</td>
+ </a> {% trans %}(ca. 11 MB){% endtrans %}</td>
</tr>
<tr><td>{% trans %}HTML{% endtrans %}</td>
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-html.zip">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 6 MB){% endtrans %}
+ </a> {% trans %}(ca. 7.5 MB){% endtrans %}
</td>
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-html.tar.bz2">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 4 MB){% endtrans %}
+ </a> {% trans %}(ca. 5 MB){% endtrans %}
</td>
</tr>
<tr>
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-text.zip">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 2 MB){% endtrans %}
+ </a> {% trans %}(ca. 2.5 MB){% endtrans %}
</td>
<td>
<a href="{{ dlbase }}/python-{{ release }}-docs-text.tar.bz2">
{% trans %}Download{% endtrans %}
- </a> {% trans %}(ca. 1.5 MB){% endtrans %}
+ </a> {% trans %}(ca. 2 MB){% endtrans %}
</td>
</tr>
</table>
<p>{% trans %}These archives contain all the content in the
documentation.{% endtrans %}</p>
-<p>{% trans download_page="https://www.python.org/download/releases/{{ release[:5] }}/" %}HTML Help
-(<tt>.chm</tt>) files are made available in the "Windows" section
-on the <a href={{ download_page }}>Python download page</a>.{% endtrans %}</p>
+<p>{% trans download_page="https://www.python.org/downloads/release/python-" + release.replace('.', '') + "/" %}HTML Help
+(<tt>.chm</tt>) files are made available in the "Files" section
+on the <a href="{{ download_page }}">Python download page</a>.{% endtrans %}</p>
<h2>{% trans %}Unpacking{% endtrans %}</h2>
-{% extends "defindex.html" %}
-{% block tables %}
+{% extends "layout.html" %}
+{%- block htmltitle -%}
+<title>{{ shorttitle }}</title>
+{%- endblock -%}
+{% block body %}
+ <h1>{{ docstitle|e }}</h1>
+ <p>
+ {% trans %}Welcome! This is the documentation for Python {{ release }}.{% endtrans %}
+ </p>
<p><strong>{% trans %}Parts of the documentation:{% endtrans %}</strong></p>
<table class="contentstable" align="center"><tr>
<td width="50%">
<p><a href="{{ pathto('download') }}">{% trans %}Download these documents{% endtrans %}</a></p>
<h3>{% trans %}Docs for other versions{% endtrans %}</h3>
<ul>
- <li><a href="https://docs.python.org/3.4/">{% trans %}Python 3.4 (stable){% endtrans %}</a></li>
- <li><a href="https://docs.python.org/3.5/">{% trans %}Python 3.5 (in development){% endtrans %}</a></li>
+ <li><a href="https://docs.python.org/3.5/">{% trans %}Python 3.5 (stable){% endtrans %}</a></li>
+ <li><a href="https://docs.python.org/3.6/">{% trans %}Python 3.6 (stable){% endtrans %}</a></li>
+ <li><a href="https://docs.python.org/3.7/">{% trans %}Python 3.7 (in development){% endtrans %}</a></li>
<li><a href="https://www.python.org/doc/versions/">{% trans %}Old versions{% endtrans %}</a></li>
</ul>
style="vertical-align: middle; margin-top: -1px"/></li>
<li><a href="https://www.python.org/">Python</a>{{ reldelim1 }}</li>
<li>
- {%- if versionswitcher is defined %}
+ {%- if switchers is defined %}
+ <span class="language_switcher_placeholder">{{ language or 'en' }}</span>
<span class="version_switcher_placeholder">{{ release }}</span>
<a href="{{ pathto('index') }}">{% trans %}Documentation{% endtrans %}</a>{{ reldelim1 }}
{%- else %}
{% block relbar2 %} {% if builder != 'qthelp' %} {{ relbar() }} {% endif %} {% endblock %}
{% block extrahead %}
<link rel="shortcut icon" type="image/png" href="{{ pathto('_static/py.png', 1) }}" />
+ <link rel="canonical" href="https://docs.python.org/2/{{pagename}}.html" />
{% if not embedded %}<script type="text/javascript" src="{{ pathto('_static/copybutton.js', 1) }}"></script>{% endif %}
- {% if versionswitcher is defined and not embedded %}<script type="text/javascript" src="{{ pathto('_static/version_switch.js', 1) }}"></script>{% endif %}
+ {% if switchers is defined and not embedded %}<script type="text/javascript" src="{{ pathto('_static/switchers.js', 1) }}"></script>{% endif %}
{{ super() }}
{% if builder == 'qthelp' %}
<style type="text/css">
<h3>{{ _('This Page') }}</h3>
<ul class="this-page-menu">
<li><a href="{{ pathto('bugs') }}">{% trans %}Report a Bug{% endtrans %}</a></li>
- <li><a href="{{ pathto('_sources/' + sourcename, true)|e }}"
- rel="nofollow">{% trans %}Show Source{% endtrans %}</a></li>
+ <li><a href="https://github.com/python/cpython/blob/{{ version }}/Doc/{{ sourcename|replace('.rst.txt', '.rst') }}"
+ rel="nofollow">{% trans %}Show Source{% endtrans %}</a>
+ </li>
</ul>
{%- endif %}
{% endblock %}
'c'
>>> it.next()
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
it.next()
StopIteration
:keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` Clauses on Loops
=========================================================================================
-The :keyword:`break` statement, like in C, breaks out of the smallest enclosing
+The :keyword:`break` statement, like in C, breaks out of the innermost enclosing
:keyword:`for` or :keyword:`while` loop.
Loop statements may have an ``else`` clause; it is executed when the loop
...
>>> function(0, a=0)
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for keyword argument 'a'
When a final formal parameter of the form ``**name`` is present, it receives a
You might have noticed that methods like ``insert``, ``remove`` or ``sort`` that
only modify the list have no return value printed -- they return the default
-``None``. [1]_ This is a design principle for all mutable data structures in
+``None``. This is a design principle for all mutable data structures in
Python.
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
- File "<stdin>", line 1
+ File "<stdin>", line 1, in <module>
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> f.close()
>>> f.read()
Traceback (most recent call last):
- File "<stdin>", line 1, in ?
+ File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file
It is good practice to use the :keyword:`with` keyword when dealing with file
If you have an object ``x``, you can view its JSON string representation with a
simple line of code::
+ >>> import json
>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'
Source Code Encoding
--------------------
-It is possible to use encodings different than ASCII in Python source files. The
-best way to do it is to put one more special comment line right after the ``#!``
-line to define the source file encoding::
-
- # -*- coding: encoding -*-
+By default, Python source files are treated as encoded in UTF-8. In that
+encoding, characters of most languages in the world can be used simultaneously
+in string literals, identifiers and comments --- although the standard library
+only uses ASCII characters for identifiers, a convention that any portable code
+should follow. To display all these characters properly, your editor must
+recognize that the file is UTF-8, and it must use a font that supports all the
+characters in the file.
+To declare an encoding other than the default one, a special comment line
+should be added as the *first* line of the file. The syntax is as follows::
-With that declaration, all characters in the source file will be treated as
-having the encoding *encoding*, and it will be possible to directly write
-Unicode string literals in the selected encoding. The list of possible
-encodings can be found in the Python Library Reference, in the section on
-:mod:`codecs`.
+ # -*- coding: encoding -*-
-For example, to write Unicode literals including the Euro currency symbol, the
-ISO-8859-15 encoding can be used, with the Euro symbol having the ordinal value
-164. This script, when saved in the ISO-8859-15 encoding, will print the value
-8364 (the Unicode code point corresponding to the Euro symbol) and then exit::
+where *encoding* is one of the valid :mod:`codecs` supported by Python.
- # -*- coding: iso-8859-15 -*-
+For example, to declare that Windows-1252 encoding is to be used, the first
+line of your source code file should be::
- currency = u"€"
- print ord(currency)
+ # -*- coding: cp-1252 -*-
-If your editor supports saving files as ``UTF-8`` with a UTF-8 *byte order mark*
-(aka BOM), you can use that instead of an encoding declaration. IDLE supports
-this capability if ``Options/General/Default Source Encoding/UTF-8`` is set.
-Notice that this signature is not understood in older Python releases (2.2 and
-earlier), and also not understood by the operating system for script files with
-``#!`` lines (only used on Unix systems).
+One exception to the *first line* rule is when the source code starts with a
+:ref:`UNIX "shebang" line <tut-scripts>`. In this case, the encoding
+declaration should be added as the second line of the file. For example::
-By using UTF-8 (either through the signature or an encoding declaration),
-characters of most languages in the world can be used simultaneously in string
-literals and comments. Using non-ASCII characters in identifiers is not
-supported. To display all these characters properly, your editor must recognize
-that the file is UTF-8, and it must use a font that supports all the characters
-in the file.
+ #!/usr/bin/env python
+ # -*- coding: cp-1252 -*-
.. _tut-brieftourtwo:
-*********************************************
-Brief Tour of the Standard Library -- Part II
-*********************************************
+**********************************************
+Brief Tour of the Standard Library --- Part II
+**********************************************
This second tour covers more advanced modules that support professional
programming needs. These modules rarely occur in small scripts.
When invoking Python, you may specify any of these options::
- python [-BdEiOQsRStuUvVWxX3?] [-c command | -m module-name | script | - ] [args]
+ python [-bBdEiOQsRStuUvVWxX3?] [-c command | -m module-name | script | - ] [args]
The most common use case is, of course, a simple invocation of a script::
Miscellaneous options
~~~~~~~~~~~~~~~~~~~~~
+.. cmdoption:: -b
+
+ Issue a warning when comparing :class:`unicode` with :class:`bytearray`.
+ Issue an error when the option is given twice (:option:`!-bb`).
+
+ Note that, unlike the corresponding Python 3.x flag, this will **not** emit
+ warnings for comparisons between :class:`str` and :class:`unicode`.
+ Instead, the ``str`` instance will be implicitly decoded to ``unicode`` and
+ Unicode comparison used.
+
+ .. versionadded:: 2.6
+
+
.. cmdoption:: -B
If given, Python won't try to write ``.pyc`` or ``.pyo`` files on the
Warn about Python 3.x possible incompatibilities by emitting a
:exc:`DeprecationWarning` for features that are removed or significantly
- changed in Python 3.
+ changed in Python 3 and can't be detected using static code analysis.
.. versionadded:: 2.6
+ See :doc:`/howto/pyporting` for more details.
+
Options you shouldn't use
~~~~~~~~~~~~~~~~~~~~~~~~~
This part of the documentation is devoted to general information on the setup
-of the Python environment on different platform, the invocation of the
+of the Python environment on different platforms, the invocation of the
interpreter and things that make working with Python easier.
To use shell commands in your Python scripts, look at the :mod:`subprocess` module.
-Editors
-=======
+Editors and IDEs
+================
-Vim and Emacs are excellent editors which support Python very well. For more
-information on how to code in Python in these editors, look at:
+There are a number of IDEs that support Python programming language.
+Many editors and IDEs provide syntax highlighting, debugging tools, and PEP-8 checks.
-* http://www.vim.org/scripts/script.php?script_id=790
-* https://sourceforge.net/projects/python-mode
-
-Geany is an excellent IDE with support for a lot of languages. For more
-information, read: https://www.geany.org/
-
-Komodo edit is another extremely good IDE. It also has support for a lot of
-languages. For more information, read https://komodoide.com/.
+Please go to `Python Editors <https://wiki.python.org/moin/PythonEditors>`_ and
+`Integrated Development Environments <https://wiki.python.org/moin/IntegratedDevelopmentEnvironments>`_
+for a comprehensive list.
\ No newline at end of file
8-bit number used by ASCII, meaning that 65,536 distinct characters can be
supported.
-The final interface for Unicode support was arrived at through countless often-
-stormy discussions on the python-dev mailing list, and mostly implemented by
+The final interface for Unicode support was arrived at through countless
+often-stormy discussions on the python-dev mailing list, and mostly implemented by
Marc-André Lemburg, based on a Unicode string type implementation by Fredrik
Lundh. A detailed explanation of the interface was written up as :pep:`100`,
"Python Unicode Integration". This article will simply cover the most
registering new encodings that are then available throughout a Python program.
If an encoding isn't specified, the default encoding is usually 7-bit ASCII,
though it can be changed for your Python installation by calling the
-:func:`sys.setdefaultencoding(encoding)` function in a customised version of
+``sys.setdefaultencoding(encoding)`` function in a customised version of
:file:`site.py`.
Combining 8-bit and Unicode strings always coerces to Unicode, using the default
The :mod:`codecs` module contains functions to look up existing encodings and
register new ones. Unless you want to implement a new encoding, you'll most
-often use the :func:`codecs.lookup(encoding)` function, which returns a
+often use the ``codecs.lookup(encoding)`` function, which returns a
4-element tuple: ``(encode_func, decode_func, stream_reader, stream_writer)``.
* *encode_func* is a function that takes a Unicode string, and returns a 2-tuple
Changes to Built-in Functions
-----------------------------
-A new built-in, :func:`zip(seq1, seq2, ...)`, has been added. :func:`zip`
+A new built-in, ``zip(seq1, seq2, ...)``, has been added. :func:`zip`
returns a list of tuples where each tuple contains the i-th element from each of
the argument sequences. The difference between :func:`zip` and ``map(None,
seq1, seq2)`` is that :func:`map` pads the sequences with ``None`` if the
would be ``(2, 0, 1, 'beta', 1)``. *level* is a string such as ``"alpha"``,
``"beta"``, or ``"final"`` for a final release.
-Dictionaries have an odd new method, :meth:`setdefault(key, default)`, which
+Dictionaries have an odd new method, ``setdefault(key, default)``, which
behaves similarly to the existing :meth:`get` method. However, if the key is
missing, :meth:`setdefault` both returns the value of *default* as :meth:`get`
would do, and also inserts it into the dictionary as the value for *key*. Thus,
API for XML) provides an event-driven interface with some similarities to
:mod:`xmllib`, and the DOM (Document Object Model) provides a tree-based
interface, transforming an XML document into a tree of nodes that can be
-traversed and modified. Python 2.0 includes a SAX2 interface and a stripped-
-down DOM interface as part of the :mod:`xml` package. Here we will give a brief
+traversed and modified. Python 2.0 includes a SAX2 interface and a stripped-down
+DOM interface as part of the :mod:`xml` package. Here we will give a brief
overview of these new interfaces; consult the Python documentation or the source
code for complete details. The Python XML SIG is also working on improved
documentation.
is an implementation of the Secure Socket Layer, which encrypts the data being
sent over a socket. When compiling Python, you can edit :file:`Modules/Setup`
to include SSL support, which adds an additional function to the :mod:`socket`
-module: :func:`socket.ssl(socket, keyfile, certfile)`, which takes a socket
+module: ``socket.ssl(socket, keyfile, certfile)``, which takes a socket
object and returns an SSL socket. The :mod:`httplib` and :mod:`urllib` modules
were also changed to support ``https://`` URLs, though no one has implemented
FTP or SMTP over SSL.
PEP 207: Rich Comparisons
=========================
-In earlier versions, Python's support for implementing comparisons on user-
-defined classes and extension types was quite simple. Classes could implement a
+In earlier versions, Python's support for implementing comparisons on user-defined
+classes and extension types was quite simple. Classes could implement a
:meth:`__cmp__` method that was given two instances of a class, and could only
return 0 if they were equal or +1 or -1 if they weren't; the method couldn't
raise an exception or return anything other than a Boolean value. Users of
list, or any other Python object. Alternatively they can raise an exception if
the comparison is impossible, inconsistent, or otherwise meaningless.
-The built-in :func:`cmp(A,B)` function can use the rich comparison machinery,
+The built-in ``cmp(A,B)`` function can use the rich comparison machinery,
and now accepts an optional argument specifying which comparison operation to
use; this is given as one of the strings ``"<"``, ``"<="``, ``">"``, ``">="``,
``"=="``, or ``"!="``. If called without the optional third argument,
and another being circular references in data structures such as trees.
For example, consider a memoizing function that caches the results of another
-function :func:`f(x)` by storing the function's argument and its result in a
+function ``f(x)`` by storing the function's argument and its result in a
dictionary::
_cache = {}
distinguish the filenames ``FILE.PY`` and ``file.py``, even though they do store
the file's name in its original case (they're case-preserving, too).
-In Python 2.1, the :keyword:`import` statement will work to simulate case-
-sensitivity on case-insensitive platforms. Python will now search for the first
+In Python 2.1, the :keyword:`import` statement will work to simulate case-sensitivity
+on case-insensitive platforms. Python will now search for the first
case-sensitive match by default, raising an :exc:`ImportError` if no such file
-is found, so ``import file`` will not import a module named ``FILE.PY``. Case-
-insensitive matching can be requested by setting the :envvar:`PYTHONCASEOK`
+is found, so ``import file`` will not import a module named ``FILE.PY``.
+Case-insensitive matching can be requested by setting the :envvar:`PYTHONCASEOK`
environment variable before starting the Python interpreter.
.. ======================================================================
When using the Python interpreter interactively, the output of commands is
displayed using the built-in :func:`repr` function. In Python 2.1, the variable
:func:`sys.displayhook` can be set to a callable object which will be called
-instead of :func:`repr`. For example, you can set it to a special pretty-
-printing function::
+instead of :func:`repr`. For example, you can set it to a special
+pretty-printing function::
>>> # Create a recursive data structure
... L = [1,2,3]
use :mod:`ftplib` to retrieve files and then don't work from behind a firewall.
It's deemed unlikely that this will cause problems for anyone, because Netscape
defaults to passive mode and few people complain, but if passive mode is
- unsuitable for your application or network setup, call :meth:`set_pasv(0)` on
+ unsuitable for your application or network setup, call ``set_pasv(0)`` on
FTP objects to disable passive mode.
* Support for raw socket access has been added to the :mod:`socket` module,
for displaying timing profiles for Python programs, invoked when the module is
run as a script. Contributed by Eric S. Raymond.
-* A new implementation-dependent function, :func:`sys._getframe([depth])`, has
+* A new implementation-dependent function, ``sys._getframe([depth])``, has
been added to return a given frame object from the current call stack.
:func:`sys._getframe` returns the frame at the top of the call stack; if the
optional integer argument *depth* is supplied, the function returns the frame
* :attr:`__doc__` is the attribute's docstring.
-* :meth:`__get__(object)` is a method that retrieves the attribute value from
+* ``__get__(object)`` is a method that retrieves the attribute value from
*object*.
-* :meth:`__set__(object, value)` sets the attribute on *object* to *value*.
+* ``__set__(object, value)`` sets the attribute on *object* to *value*.
-* :meth:`__delete__(object, value)` deletes the *value* attribute of *object*.
+* ``__delete__(object, value)`` deletes the *value* attribute of *object*.
For example, when you write ``obj.x``, the steps that Python actually performs
are::
which is the behaviour we're after. This lookup rule is the same as the one
followed by Common Lisp. A new built-in function, :func:`super`, provides a way
to get at a class's superclasses without having to reimplement Python's
-algorithm. The most commonly used form will be :func:`super(class, obj)`, which
+algorithm. The most commonly used form will be ``super(class, obj)``, which
returns a bound superclass object (not the actual class object). This form
will be used in methods to call a method in the superclass; for example,
:class:`D`'s :meth:`save` method would look like this::
...
:func:`super` can also return unbound superclass objects when called as
-:func:`super(class)` or :func:`super(class1, class2)`, but this probably won't
+``super(class)`` or ``super(class1, class2)``, but this probably won't
often be useful.
``obj.parent`` into a method call such as ``obj.get_parent``. Python 2.2 adds
some new ways of controlling attribute access.
-First, :meth:`__getattr__(attr_name)` is still supported by new-style classes,
+First, ``__getattr__(attr_name)`` is still supported by new-style classes,
and nothing about it has changed. As before, it will be called when an attempt
is made to access ``obj.foo`` and no attribute named ``foo`` is found in the
instance's dictionary.
New-style classes also support a new method,
-:meth:`__getattribute__(attr_name)`. The difference between the two methods is
+``__getattribute__(attr_name)``. The difference between the two methods is
that :meth:`__getattribute__` is *always* called whenever any attribute is
accessed, while the old :meth:`__getattr__` is only called if ``foo`` isn't
found in the instance's dictionary.
In Python 2.2, iteration can be implemented separately, and :meth:`__getitem__`
methods can be limited to classes that really do support random access. The
-basic idea of iterators is simple. A new built-in function, :func:`iter(obj)`
-or ``iter(C, sentinel)``, is used to get an iterator. :func:`iter(obj)` returns
+basic idea of iterators is simple. A new built-in function, ``iter(obj)``
+or ``iter(C, sentinel)``, is used to get an iterator. ``iter(obj)`` returns
an iterator for the object *obj*, while ``iter(C, sentinel)`` returns an
iterator that will invoke the callable object *C* until it returns *sentinel* to
signal that the iterator is done.
Another change is simpler to explain. Since their introduction, Unicode strings
have supported an :meth:`encode` method to convert the string to a selected
-encoding such as UTF-8 or Latin-1. A symmetric :meth:`decode([*encoding*])`
+encoding such as UTF-8 or Latin-1. A symmetric ``decode([*encoding*])``
method has been added to 8-bit strings (though not to Unicode strings) in 2.2.
:meth:`decode` assumes that the string is in the specified encoding and decodes
it, returning whatever is returned by the codec.
* The new :mod:`hmac` module implements the HMAC algorithm described by
:rfc:`2104`. (Contributed by Gerhard Häring.)
-* Several functions that originally returned lengthy tuples now return pseudo-
- sequences that still behave like tuples but also have mnemonic attributes such
+* Several functions that originally returned lengthy tuples now return
+ pseudo-sequences that still behave like tuples but also have mnemonic attributes such
as memberst_mtime or :attr:`tm_year`. The enhanced functions include
:func:`stat`, :func:`fstat`, :func:`statvfs`, and :func:`fstatvfs` in the
:mod:`os` module, and :func:`localtime`, :func:`gmtime`, and :func:`strptime` in
The most significant change is the ability to build Python as a framework,
enabled by supplying the :option:`!--enable-framework` option to the configure
- script when compiling Python. According to Jack Jansen, "This installs a self-
- contained Python installation plus the OS X framework "glue" into
+ script when compiling Python. According to Jack Jansen, "This installs a
+ self-contained Python installation plus the OS X framework "glue" into
:file:`/Library/Frameworks/Python.framework` (or another location of choice).
For now there is little immediate added benefit to this (actually, there is the
disadvantage that you have to change your PATH to be able to find Python), but
to an MBCS encoded string, as used by the Microsoft file APIs. As MBCS is
explicitly used by the file APIs, Python's choice of ASCII as the default
encoding turns out to be an annoyance. On Unix, the locale's character set is
- used if :func:`locale.nl_langinfo(CODESET)` is available. (Windows support was
+ used if ``locale.nl_langinfo(CODESET)`` is available. (Windows support was
contributed by Mark Hammond with assistance from Marc-André Lemburg. Unix
support was added by Martin von Löwis.)
It's also possible to take the symmetric difference of two sets. This is the
set of all elements in the union that aren't in the intersection. Another way
of putting it is that the symmetric difference contains all elements that are in
-exactly one set. Again, there's an alternative notation (``^``), and an in-
-place version with the ungainly name :meth:`symmetric_difference_update`. ::
+exactly one set. Again, there's an alternative notation (``^``), and an
+in-place version with the ungainly name :meth:`symmetric_difference_update`. ::
>>> S1 = sets.Set([1,2,3,4])
>>> S2 = sets.Set([3,4,5,6])
PEP 273: Importing Modules from ZIP Archives
============================================
-The new :mod:`zipimport` module adds support for importing modules from a ZIP-
-format archive. You don't need to import the module explicitly; it will be
+The new :mod:`zipimport` module adds support for importing modules from a
+ZIP-format archive. You don't need to import the module explicitly; it will be
automatically imported if a ZIP archive's filename is added to ``sys.path``.
For example:
==================================
The three major operating systems used today are Microsoft Windows, Apple's
-Macintosh OS, and the various Unix derivatives. A minor irritation of cross-
-platform work is that these three platforms all use different characters to
+Macintosh OS, and the various Unix derivatives. A minor irritation of
+cross-platform work is that these three platforms all use different characters to
mark the ends of lines in text files. Unix uses the linefeed (ASCII character
10), MacOS uses the carriage return (ASCII character 13), and Windows uses a
two-character sequence of a carriage return plus a newline.
ZeroDivisionError: integer division or modulo by zero
Slightly more advanced programs will use a logger other than the root logger.
-The :func:`getLogger(name)` function is used to get a particular log, creating
-it if it doesn't exist yet. :func:`getLogger(None)` returns the root logger. ::
+The ``getLogger(name)`` function is used to get a particular log, creating
+it if it doesn't exist yet. ``getLogger(None)`` returns the root logger. ::
log = logging.getLogger('server')
...
objects to it. Additional built-in and frozen modules can be imported by an
object added to this list.
-Importer objects must have a single method, :meth:`find_module(fullname,
-path=None)`. *fullname* will be a module or package name, e.g. ``string`` or
+Importer objects must have a single method, ``find_module(fullname,
+path=None)``. *fullname* will be a module or package name, e.g. ``string`` or
``distutils.core``. :meth:`find_module` must return a loader object that has a
-single method, :meth:`load_module(fullname)`, that creates and returns the
+single method, ``load_module(fullname)``, that creates and returns the
corresponding module object.
Pseudo-code for Python's new import logic, therefore, looks something like this
[0, 2, 4]
To simplify implementing sequences that support extended slicing, slice objects
-now have a method :meth:`indices(length)` which, given the length of a sequence,
+now have a method ``indices(length)`` which, given the length of a sequence,
returns a ``(start, stop, step)`` tuple that can be passed directly to
:func:`range`. :meth:`indices` handles omitted and out-of-bounds indices in a
manner consistent with regular slices (and this innocuous phrase hides a welter
* Built-in types now support the extended slicing syntax, as described in
section :ref:`section-slices` of this document.
-* A new built-in function, :func:`sum(iterable, start=0)`, adds up the numeric
+* A new built-in function, ``sum(iterable, start=0)``, adds up the numeric
items in the iterable object and returns their sum. :func:`sum` only accepts
numbers, meaning that you can't use it to concatenate a bunch of strings.
(Contributed by Alex Martelli.)
its index, now takes optional *start* and *stop* arguments to limit the search
to only part of the list.
-* Dictionaries have a new method, :meth:`pop(key[, *default*])`, that returns
+* Dictionaries have a new method, ``pop(key[, *default*])``, that returns
the value corresponding to *key* and removes that key/value pair from the
dictionary. If the requested key isn't present in the dictionary, *default* is
returned if it's specified and :exc:`KeyError` raised if it isn't. ::
{}
>>>
- There's also a new class method, :meth:`dict.fromkeys(iterable, value)`, that
+ There's also a new class method, ``dict.fromkeys(iterable, value)``, that
creates a dictionary with keys taken from the supplied iterator *iterable* and
all values set to *value*, defaulting to ``None``.
100 bytecodes, speeding up single-threaded applications by reducing the
switching overhead. Some multithreaded applications may suffer slower response
time, but that's easily fixed by setting the limit back to a lower number using
- :func:`sys.setcheckinterval(N)`. The limit can be retrieved with the new
+ ``sys.setcheckinterval(N)``. The limit can be retrieved with the new
:func:`sys.getcheckinterval` function.
* One minor but far-reaching change is that the names of extension types defined
* Previously the :mod:`doctest` module would only search the docstrings of
public methods and functions for test cases, but it now also examines private
- ones as well. The :func:`DocTestSuite(` function creates a
+ ones as well. The :func:`DocTestSuite` function creates a
:class:`unittest.TestSuite` object from a set of :mod:`doctest` tests.
-* The new :func:`gc.get_referents(object)` function returns a list of all the
+* The new ``gc.get_referents(object)`` function returns a list of all the
objects referenced by *object*.
* The :mod:`getopt` module gained a new function, :func:`gnu_getopt`, that
documentation for details.
(Contributed by Raymond Hettinger.)
-* Two new functions in the :mod:`math` module, :func:`degrees(rads)` and
- :func:`radians(degs)`, convert between radians and degrees. Other functions in
+* Two new functions in the :mod:`math` module, ``degrees(rads)`` and
+ ``radians(degs)``, convert between radians and degrees. Other functions in
the :mod:`math` module such as :func:`math.sin` and :func:`math.cos` have always
required input values measured in radians. Also, an optional *base* argument
was added to :func:`math.log` to make it easier to compute logarithms for bases
and therefore faster performance. Setting the parser object's
:attr:`buffer_text` attribute to :const:`True` will enable buffering.
-* The :func:`sample(population, k)` function was added to the :mod:`random`
+* The ``sample(population, k)`` function was added to the :mod:`random`
module. *population* is a sequence or :class:`xrange` object containing the
elements of a population, and :func:`sample` chooses *k* elements from the
population without replacing chosen elements. *k* can be any value up to
encryption is not believed to be secure. If you need encryption, use one of the
several AES Python modules that are available separately.
-* The :mod:`shutil` module gained a :func:`move(src, dest)` function that
+* The :mod:`shutil` module gained a ``move(src, dest)`` function that
recursively moves a file or directory to a new location.
* Support for more advanced POSIX signal handling was added to the :mod:`signal`
platforms.
* The :mod:`socket` module now supports timeouts. You can call the
- :meth:`settimeout(t)` method on a socket object to set a timeout of *t* seconds.
+ ``settimeout(t)`` method on a socket object to set a timeout of *t* seconds.
Subsequent socket operations that take longer than *t* seconds to complete will
abort and raise a :exc:`socket.timeout` exception.
:program:`tar`\ -format archive files. (Contributed by Lars Gustäbel.)
* The new :mod:`textwrap` module contains functions for wrapping strings
- containing paragraphs of text. The :func:`wrap(text, width)` function takes a
+ containing paragraphs of text. The ``wrap(text, width)`` function takes a
string and returns a list containing the text split into lines of no more than
- the chosen width. The :func:`fill(text, width)` function returns a single
+ the chosen width. The ``fill(text, width)`` function returns a single
string, reformatted to fit into lines no longer than the chosen width. (As you
can guess, :func:`fill` is built on top of :func:`wrap`. For example::
short int`, ``I`` for :c:type:`unsigned int`, and ``K`` for :c:type:`unsigned
long long`.
-* A new function, :c:func:`PyObject_DelItemString(mapping, char \*key)` was added
+* A new function, ``PyObject_DelItemString(mapping, char *key)`` was added
as shorthand for ``PyObject_DelItem(mapping, PyString_New(key))``.
* File objects now manage their internal string buffer differently, increasing
Python 2.3 introduced the :mod:`sets` module. C implementations of set data
types have now been added to the Python core as two new built-in types,
-:func:`set(iterable)` and :func:`frozenset(iterable)`. They provide high speed
+``set(iterable)`` and ``frozenset(iterable)``. They provide high speed
operations for membership testing, for eliminating duplicates from sequences,
and for mathematical operations like unions, intersections, differences, and
symmetric differences. ::
PEP 322: Reverse Iteration
==========================
-A new built-in function, :func:`reversed(seq)`, takes a sequence and returns an
+A new built-in function, ``reversed(seq)``, takes a sequence and returns an
iterator that loops over the elements of the sequence in reverse order. ::
>>> for i in reversed(xrange(1,4)):
The standard library provides a number of ways to execute a subprocess, offering
different features and different levels of complexity.
-:func:`os.system(command)` is easy to use, but slow (it runs a shell process
+``os.system(command)`` is easy to use, but slow (it runs a shell process
which executes the command) and dangerous (you have to be careful about escaping
the shell's metacharacters). The :mod:`popen2` module offers classes that can
capture standard output and standard error from the subprocess, but the naming
Once you've created the :class:`Popen` instance, you can call its :meth:`wait`
method to pause until the subprocess has exited, :meth:`poll` to check if it's
-exited without pausing, or :meth:`communicate(data)` to send the string *data*
-to the subprocess's standard input. :meth:`communicate(data)` then reads any
+exited without pausing, or ``communicate(data)`` to send the string *data*
+to the subprocess's standard input. ``communicate(data)`` then reads any
data that the subprocess has sent to its standard output or standard error,
returning a tuple ``(stdout_data, stderr_data)``.
>>> 1.1
1.1000000000000001
-The inaccuracy isn't always visible when you print the number because the FP-to-
-decimal-string conversion is provided by the C library, and most C libraries try
+The inaccuracy isn't always visible when you print the number because the
+FP-to-decimal-string conversion is provided by the C library, and most C libraries try
to produce sensible output. Even if it's not displayed, however, the inaccuracy
is still there and subsequent operations can magnify the error.
...
decimal.InvalidOperation: x ** (non-integer)
-You can combine :class:`Decimal` instances with integers, but not with floating-
-point numbers::
+You can combine :class:`Decimal` instances with integers, but not with
+floating-point numbers::
>>> a + 4
Decimal("39.72")
Raymond Hettinger, Aahz, and Tim Peters.
http://www.lahey.com/float.htm
- The article uses Fortran code to illustrate many of the problems that floating-
- point inaccuracy can cause.
+ The article uses Fortran code to illustrate many of the problems that
+ floating-point inaccuracy can cause.
http://speleotrove.com/decimal/
A description of a decimal-based representation. This representation is being
to the ``'C'`` locale. Often this was because the code was using the C
library's :c:func:`atof` function.
-Not setting the numeric locale caused trouble for extensions that used third-
-party C libraries, however, because they wouldn't have the correct locale set.
+Not setting the numeric locale caused trouble for extensions that used third-party
+C libraries, however, because they wouldn't have the correct locale set.
The motivating example was GTK+, whose user interface widgets weren't displaying
numbers in the current locale.
The solution described in the PEP is to add three new functions to the Python
API that perform ASCII-only conversions, ignoring the locale setting:
-* :c:func:`PyOS_ascii_strtod(str, ptr)` and :c:func:`PyOS_ascii_atof(str, ptr)`
+* ``PyOS_ascii_strtod(str, ptr)`` and ``PyOS_ascii_atof(str, ptr)``
both convert a string to a C :c:type:`double`.
-* :c:func:`PyOS_ascii_formatd(buffer, buf_len, format, d)` converts a
+* ``PyOS_ascii_formatd(buffer, buf_len, format, d)`` converts a
:c:type:`double` to an ASCII string.
The code for these functions came from the GLib library
* Decorators for functions and methods were added (:pep:`318`).
* Built-in :func:`set` and :func:`frozenset` types were added (:pep:`218`).
- Other new built-ins include the :func:`reversed(seq)` function (:pep:`322`).
+ Other new built-ins include the ``reversed(seq)`` function (:pep:`322`).
* Generator expressions were added (:pep:`289`).
(All changes to :meth:`sort` contributed by Raymond Hettinger.)
-* There is a new built-in function :func:`sorted(iterable)` that works like the
+* There is a new built-in function ``sorted(iterable)`` that works like the
in-place :meth:`list.sort` method but can be used in expressions. The
differences are:
For example, you can now run the Python profiler with ``python -m profile``.
(Contributed by Nick Coghlan.)
-* The :func:`eval(expr, globals, locals)` and :func:`execfile(filename, globals,
- locals)` functions and the :keyword:`exec` statement now accept any mapping type
+* The ``eval(expr, globals, locals)`` and ``execfile(filename, globals,
+ locals)`` functions and the :keyword:`exec` statement now accept any mapping type
for the *locals* parameter. Previously this had to be a regular Python
dictionary. (Contributed by Raymond Hettinger.)
(Contributed by Raymond Hettinger.)
-* Encountering a failure while importing a module no longer leaves a partially-
- initialized module object in ``sys.modules``. The incomplete module object left
+* Encountering a failure while importing a module no longer leaves a partially-initialized
+ module object in ``sys.modules``. The incomplete module object left
behind would fool further imports of the same module into succeeding, leading to
confusing errors. (Fixed by Tim Peters.)
previous ones left off. (Implemented by Walter Dörwald.)
* There is a new :mod:`collections` module for various specialized collection
- datatypes. Currently it contains just one type, :class:`deque`, a double-
- ended queue that supports efficiently adding and removing elements from either
+ datatypes. Currently it contains just one type, :class:`deque`, a double-ended
+ queue that supports efficiently adding and removing elements from either
end::
>>> from collections import deque
Yves Dionne) and new :meth:`deleteacl` and :meth:`myrights` methods (contributed
by Arnaud Mazin).
-* The :mod:`itertools` module gained a :func:`groupby(iterable[, *func*])`
+* The :mod:`itertools` module gained a ``groupby(iterable[, *func*])``
function. *iterable* is something that can be iterated over to return a stream
of elements, and the optional *func* parameter is a function that takes an
element and returns a key value; if omitted, the key is simply the element
(Contributed by Hye-Shik Chang.)
-* :mod:`itertools` also gained a function named :func:`tee(iterator, N)` that
+* :mod:`itertools` also gained a function named ``tee(iterator, N)`` that
returns *N* independent iterators that replicate *iterator*. If *N* is omitted,
the default is 2. ::
level=0, # Log all messages
format='%(levelname):%(process):%(thread):%(message)')
- Other additions to the :mod:`logging` package include a :meth:`log(level, msg)`
+ Other additions to the :mod:`logging` package include a ``log(level, msg)``
convenience method, as well as a :class:`TimedRotatingFileHandler` class that
rotates its log files at a timed interval. The module already had
:class:`RotatingFileHandler`, which rotated logs once the file exceeded a
group or for a range of groups. (Contributed by Jürgen A. Erhard.)
* Two new functions were added to the :mod:`operator` module,
- :func:`attrgetter(attr)` and :func:`itemgetter(index)`. Both functions return
+ ``attrgetter(attr)`` and ``itemgetter(index)``. Both functions return
callables that take a single argument and return the corresponding attribute or
item; these callables make excellent data extractors when used with :func:`map`
or :func:`sorted`. For example::
replacement for :func:`rfc822.formatdate`. You may want to write new e-mail
processing code with this in mind. (Change implemented by Anthony Baxter.)
-* A new :func:`urandom(n)` function was added to the :mod:`os` module, returning
+* A new ``urandom(n)`` function was added to the :mod:`os` module, returning
a string containing *n* bytes of random data. This function provides access to
platform-specific sources of randomness such as :file:`/dev/urandom` on Linux or
the Windows CryptoAPI. (Contributed by Trevor Perrin.)
-* Another new function: :func:`os.path.lexists(path)` returns true if the file
+* Another new function: ``os.path.lexists(path)`` returns true if the file
specified by *path* exists, whether or not it's a symbolic link. This differs
- from the existing :func:`os.path.exists(path)` function, which returns false if
+ from the existing ``os.path.exists(path)`` function, which returns false if
*path* is a symlink that points to a destination that doesn't exist.
(Contributed by Beni Cherniavsky.)
* The :mod:`profile` module can now profile C extension functions. (Contributed
by Nick Bastin.)
-* The :mod:`random` module has a new method called :meth:`getrandbits(N)` that
+* The :mod:`random` module has a new method called ``getrandbits(N)`` that
returns a long integer *N* bits in length. The existing :meth:`randrange`
method now uses :meth:`getrandbits` where appropriate, making generation of
arbitrarily large random numbers more efficient. (Contributed by Raymond
this, but 2.4 will raise a :exc:`RuntimeError` exception.
* Two new functions were added to the :mod:`socket` module. :func:`socketpair`
- returns a pair of connected sockets and :func:`getservbyport(port)` looks up the
+ returns a pair of connected sockets and ``getservbyport(port)`` looks up the
service name for a given port number. (Contributed by Dave Cole and Barry
Warsaw.)
* Another new macro, :c:macro:`Py_CLEAR(obj)`, decreases the reference count of
*obj* and sets *obj* to the null pointer. (Contributed by Jim Fulton.)
-* A new function, :c:func:`PyTuple_Pack(N, obj1, obj2, ..., objN)`, constructs
+* A new function, ``PyTuple_Pack(N, obj1, obj2, ..., objN)``, constructs
tuples from a variable length argument list of Python objects. (Contributed by
Raymond Hettinger.)
-* A new function, :c:func:`PyDict_Contains(d, k)`, implements fast dictionary
+* A new function, ``PyDict_Contains(d, k)``, implements fast dictionary
lookups without masking exceptions raised during the look-up process.
(Contributed by Raymond Hettinger.)
intended as an aid to people developing the Python core. Providing
:option:`!--enable-profiling` to the :program:`configure` script will let you
profile the interpreter with :program:`gprof`, and providing the
- :option:`!--with-tsc` switch enables profiling using the Pentium's Time-Stamp-
- Counter register. Note that the :option:`!--with-tsc` switch is slightly
+ :option:`!--with-tsc` switch enables profiling using the Pentium's
+ Time-Stamp-Counter register. Note that the :option:`!--with-tsc` switch is slightly
misnamed, because the profiling feature also works on the PowerPC platform,
though that processor architecture doesn't call that register "the TSC
register". (Contributed by Jeremy Hylton.)
* The :mod:`tarfile` module now generates GNU-format tar files by default.
-* Encountering a failure while importing a module no longer leaves a partially-
- initialized module object in ``sys.modules``.
+* Encountering a failure while importing a module no longer leaves a
+ partially-initialized module object in ``sys.modules``.
* :const:`None` is now a constant; code that binds a new value to the name
``None`` is now a syntax error.
server_log = functools.partial(log, subsystem='server')
server_log('Unable to open socket')
-Here's another example, from a program that uses PyGTK. Here a context-
-sensitive pop-up menu is being constructed dynamically. The callback provided
+Here's another example, from a program that uses PyGTK. Here a context-sensitive
+pop-up menu is being constructed dynamically. The callback provided
for the menu option is a partially applied version of the :meth:`open_item`
method, where the first argument has been provided. ::
popup_menu.append( ("Open", open_func, 1) )
Another function in the :mod:`functools` module is the
-:func:`update_wrapper(wrapper, wrapped)` function that helps you write well-
-behaved decorators. :func:`update_wrapper` copies the name, module, and
+``update_wrapper(wrapper, wrapped)`` function that helps you write
+well-behaved decorators. :func:`update_wrapper` copies the name, module, and
docstring attribute to a wrapper function so that tracebacks inside the wrapped
function are easier to understand. For example, you might write::
added in a future version of Python.
In Python 2.5, you can switch :keyword:`import`'s behaviour to absolute imports
-using a ``from __future__ import absolute_import`` directive. This absolute-
-import behaviour will become the default in a future version (probably Python
+using a ``from __future__ import absolute_import`` directive. This absolute-import
+behaviour will become the default in a future version (probably Python
2.7). Once absolute imports are the default, ``import string`` will always
find the standard library's version. It's suggested that users should begin
using absolute imports as much as possible, so it's preferable to begin writing
``val = yield i`` but have to use parentheses when there's an operation, as in
``val = (yield i) + 12``.)
-Values are sent into a generator by calling its :meth:`send(value)` method. The
+Values are sent into a generator by calling its ``send(value)`` method. The
generator's code is then resumed and the :keyword:`yield` expression returns the
specified *value*. If the regular :meth:`next` method is called, the
:keyword:`yield` returns :const:`None`.
In addition to :meth:`send`, there are two other new methods on generators:
-* :meth:`throw(type, value=None, traceback=None)` is used to raise an exception
+* ``throw(type, value=None, traceback=None)`` is used to raise an exception
inside the generator; the exception is raised by the :keyword:`yield` expression
where the generator's execution is paused.
... more processing code ...
After this statement has executed, the file object in *f* will have been
-automatically closed, even if the :keyword:`for` loop raised an exception part-
-way through the block.
+automatically closed, even if the :keyword:`for` loop raised an exception
+part-way through the block.
.. note::
* The code in *BLOCK* is executed.
-* If *BLOCK* raises an exception, the :meth:`__exit__(type, value, traceback)`
+* If *BLOCK* raises an exception, the ``__exit__(type, value, traceback)``
is called with the exception details, the same values returned by
:func:`sys.exc_info`. The method's return value controls whether the exception
is re-raised: any false value re-raises the exception, and ``True`` will result
with db_transaction(db) as cursor:
...
-The :mod:`contextlib` module also has a :func:`nested(mgr1, mgr2, ...)` function
+The :mod:`contextlib` module also has a ``nested(mgr1, mgr2, ...)`` function
that combines a number of context managers so you don't need to write nested
':keyword:`with`' statements. In this example, the single ':keyword:`with`'
statement both starts a database transaction and acquires a thread lock::
with nested (db_transaction(db), lock) as (cursor, locked):
...
-Finally, the :func:`closing(object)` function returns *object* so that it can be
+Finally, the ``closing(object)`` function returns *object* so that it can be
bound to a variable, and calls ``object.close`` at the end of the block. ::
import urllib, sys
A corresponding :attr:`nb_index` slot was added to the C-level
:c:type:`PyNumberMethods` structure to let C extensions implement this protocol.
-:c:func:`PyNumber_Index(obj)` can be used in extension code to call the
+``PyNumber_Index(obj)`` can be used in extension code to call the
:meth:`__index__` function and retrieve its result.
* The :class:`dict` type has a new hook for letting subclasses provide a default
value when a key isn't contained in the dictionary. When a key isn't found, the
- dictionary's :meth:`__missing__(key)` method will be called. This hook is used
+ dictionary's ``__missing__(key)`` method will be called. This hook is used
to implement the new :class:`defaultdict` class in the :mod:`collections`
module. The following example defines a dictionary that returns zero for any
missing key::
print d[1], d[2] # Prints 1, 2
print d[3], d[4] # Prints 0, 0
-* Both 8-bit and Unicode strings have new :meth:`partition(sep)` and
- :meth:`rpartition(sep)` methods that simplify a common use case.
+* Both 8-bit and Unicode strings have new ``partition(sep)`` and
+ ``rpartition(sep)`` methods that simplify a common use case.
- The :meth:`find(S)` method is often used to get an index which is then used to
+ The ``find(S)`` method is often used to get an index which is then used to
slice the string and obtain the pieces that are before and after the separator.
- :meth:`partition(sep)` condenses this pattern into a single method call that
+ ``partition(sep)`` condenses this pattern into a single method call that
returns a 3-tuple containing the substring before the separator, the separator
itself, and the substring after the separator. If the separator isn't found,
the first element of the tuple is the entire string and the other two elements
- are empty. :meth:`rpartition(sep)` also returns a 3-tuple but starts searching
+ are empty. ``rpartition(sep)`` also returns a 3-tuple but starts searching
from the end of the string; the ``r`` stands for 'reverse'.
Some examples::
.. Patch 1313939, 1359618
-* The :func:`long(str, base)` function is now faster on long digit strings
+* The ``long(str, base)`` function is now faster on long digit strings
because fewer intermediate results are calculated. The peak is for strings of
around 800--1000 digits where the function is 6 times faster. (Contributed by
Alan McIntyre and committed at the NeedForSpeed sprint.)
(Contributed by Guido van Rossum.)
* The :class:`deque` double-ended queue type supplied by the :mod:`collections`
- module now has a :meth:`remove(value)` method that removes the first occurrence
+ module now has a ``remove(value)`` method that removes the first occurrence
of *value* in the queue, raising :exc:`ValueError` if the value isn't found.
(Contributed by Raymond Hettinger.)
* The :mod:`csv` module, which parses files in comma-separated value format,
received several enhancements and a number of bugfixes. You can now set the
maximum size in bytes of a field by calling the
- :meth:`csv.field_size_limit(new_limit)` function; omitting the *new_limit*
+ ``csv.field_size_limit(new_limit)`` function; omitting the *new_limit*
argument will return the currently-set limit. The :class:`reader` class now has
a :attr:`line_num` attribute that counts the number of physical lines read from
the source; records can span multiple physical lines, so :attr:`line_num` is not
(Contributed by Skip Montanaro and Andrew McNamara.)
* The :class:`~datetime.datetime` class in the :mod:`datetime` module now has a
- :meth:`strptime(string, format)` method for parsing date strings, contributed
+ ``strptime(string, format)`` method for parsing date strings, contributed
by Josh Spoerri. It uses the same format characters as :func:`time.strptime` and
:func:`time.strftime`::
* The :mod:`mailbox` module underwent a massive rewrite to add the capability to
modify mailboxes in addition to reading them. A new set of classes that include
:class:`mbox`, :class:`MH`, and :class:`Maildir` are used to read mailboxes, and
- have an :meth:`add(message)` method to add messages, :meth:`remove(key)` to
+ have an ``add(message)`` method to add messages, ``remove(key)`` to
remove messages, and :meth:`lock`/:meth:`unlock` to lock/unlock the mailbox.
The following example converts a maildir-format mailbox into an mbox-format
one::
:func:`wait4` return additional information. :func:`wait3` doesn't take a
process ID as input, so it waits for any child process to exit and returns a
3-tuple of *process-id*, *exit-status*, *resource-usage* as returned from the
- :func:`resource.getrusage` function. :func:`wait4(pid)` does take a process ID.
+ :func:`resource.getrusage` function. ``wait4(pid)`` does take a process ID.
(Contributed by Chad J. Schroeder.)
On FreeBSD, the :func:`os.stat` function now returns times with nanosecond
In Python code, netlink addresses are represented as a tuple of 2 integers,
``(pid, group_mask)``.
- Two new methods on socket objects, :meth:`recv_into(buffer)` and
- :meth:`recvfrom_into(buffer)`, store the received data in an object that
+ Two new methods on socket objects, ``recv_into(buffer)`` and
+ ``recvfrom_into(buffer)``, store the received data in an object that
supports the buffer protocol instead of returning the data as a string. This
means you can put the data directly into an array or a memory-mapped file.
year, number, name = s.unpack(data)
You can also pack and unpack data to and from buffer objects directly using the
- :meth:`pack_into(buffer, offset, v1, v2, ...)` and :meth:`unpack_from(buffer,
- offset)` methods. This lets you store data directly into an array or a memory-
- mapped file.
+ ``pack_into(buffer, offset, v1, v2, ...)`` and ``unpack_from(buffer,
+ offset)`` methods. This lets you store data directly into an array or a
+ memory-mapped file.
(:class:`Struct` objects were implemented by Bob Ippolito at the NeedForSpeed
sprint. Support for buffer objects was added by Martin Blais, also at the
.. patch 918101
* The :mod:`threading` module now lets you set the stack size used when new
- threads are created. The :func:`stack_size([*size*])` function returns the
+ threads are created. The ``stack_size([*size*])`` function returns the
currently configured stack size, and supplying the optional *size* parameter
sets a new value. Not all platforms support changing the stack size, but
Windows, POSIX threading, and OS/2 all do. (Contributed by Andrew MacIntyre.)
h = hashlib.new('md5') # Provide algorithm as a string
Once a hash object has been created, its methods are the same as before:
-:meth:`update(string)` hashes the specified string into the current digest
+``update(string)`` hashes the specified string into the current digest
state, :meth:`digest` and :meth:`hexdigest` return the digest value as a binary
string or a string of hex digits, and :meth:`copy` returns a new hashing object
with the same digest state.
* Two new macros can be used to indicate C functions that are local to the
current file so that a faster calling convention can be used.
- :c:func:`Py_LOCAL(type)` declares the function as returning a value of the
+ ``Py_LOCAL(type)`` declares the function as returning a value of the
specified *type* and uses a fast-calling qualifier.
- :c:func:`Py_LOCAL_INLINE(type)` does the same thing and also requests the
+ ``Py_LOCAL_INLINE(type)`` does the same thing and also requests the
function be inlined. If :c:func:`PY_LOCAL_AGGRESSIVE` is defined before
:file:`python.h` is included, a set of more aggressive optimizations are enabled
for the module; you should benchmark the results to find out if these
optimizations actually make the code faster. (Contributed by Fredrik Lundh at
the NeedForSpeed sprint.)
-* :c:func:`PyErr_NewException(name, base, dict)` can now accept a tuple of base
+* ``PyErr_NewException(name, base, dict)`` can now accept a tuple of base
classes as its *base* argument. (Contributed by Georg Brandl.)
* The :c:func:`PyErr_Warn` function for issuing warnings is now deprecated in
- favour of :c:func:`PyErr_WarnEx(category, message, stacklevel)` which lets you
+ favour of ``PyErr_WarnEx(category, message, stacklevel)`` which lets you
specify the number of stack frames separating this function and the caller. A
*stacklevel* of 1 is the function calling :c:func:`PyErr_WarnEx`, 2 is the
function above that, and so forth. (Added by Neal Norwitz.)
The author would like to thank the following people for offering suggestions,
corrections and assistance with various drafts of this article: Georg Brandl,
-Nick Coghlan, Phillip J. Eby, Lars Gustäbel, Raymond Hettinger, Ralf W. Grosse-
-Kunstleve, Kent Johnson, Iain Lowe, Martin von Löwis, Fredrik Lundh, Andrew
+Nick Coghlan, Phillip J. Eby, Lars Gustäbel, Raymond Hettinger, Ralf W.
+Grosse-Kunstleve, Kent Johnson, Iain Lowe, Martin von Löwis, Fredrik Lundh, Andrew
McNamara, Skip Montanaro, Gustavo Niemeyer, Paul Prescod, James Pryor, Mike
Rovner, Scott Weikart, Barry Warsaw, Thomas Wouters.
... more processing code ...
After this statement has executed, the file object in *f* will have been
-automatically closed, even if the :keyword:`for` loop raised an exception part-
-way through the block.
+automatically closed, even if the :keyword:`for` loop raised an exception
+part-way through the block.
.. note::
#endif /* !WITH_THREAD */
PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *);
#ifdef __cplusplus
PyAPI_FUNC(PyObject *) _PyDict_GetItemWithError(PyObject *mp, PyObject *key);
PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key);
+PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key,
+ int (*predicate)(PyObject *value));
+
PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
PyAPI_FUNC(int) PyDict_Next(
PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
/*--start constants--*/
#define PY_MAJOR_VERSION 2
#define PY_MINOR_VERSION 7
-#define PY_MICRO_VERSION 13
+#define PY_MICRO_VERSION 14
#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL
#define PY_RELEASE_SERIAL 0
/* Version as a string */
-#define PY_VERSION "2.7.13"
+#define PY_VERSION "2.7.14"
/*--end constants--*/
/* Subversion Revision number of this file (not of the repository). Empty
PyAPI_FUNC(const char *) Py_GetCopyright(void);
PyAPI_FUNC(const char *) Py_GetCompiler(void);
PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
-PyAPI_FUNC(const char *) _Py_svnversion(void);
PyAPI_FUNC(const char *) Py_SubversionRevision(void);
PyAPI_FUNC(const char *) Py_SubversionShortBranch(void);
-PyAPI_FUNC(const char *) _Py_hgidentifier(void);
-PyAPI_FUNC(const char *) _Py_hgversion(void);
+PyAPI_FUNC(const char *) _Py_gitidentifier(void);
+PyAPI_FUNC(const char *) _Py_gitversion(void);
/* Internal -- various one-time initializations */
PyAPI_FUNC(PyObject *) _PyBuiltin_Init(void);
Py_ssize_t *start, Py_ssize_t *stop,
Py_ssize_t *step, Py_ssize_t *slicelength);
+PyAPI_FUNC(int) _PySlice_Unpack(PyObject *slice,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
+PyAPI_FUNC(Py_ssize_t) _PySlice_AdjustIndices(Py_ssize_t length,
+ Py_ssize_t *start, Py_ssize_t *stop,
+ Py_ssize_t step);
+
#ifdef __cplusplus
}
#endif
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
-year, the PythonLabs team moved to Digital Creations (now Zope
-Corporation, see http://www.zope.com). In 2001, the Python Software
-Foundation (PSF, see http://www.python.org/psf/) was formed, a
-non-profit organization created specifically to own Python-related
-Intellectual Property. Zope Corporation is a sponsoring member of
-the PSF.
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation. In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
All Python releases are Open Source (see http://www.opensource.org for
the Open Source Definition). Historically, most, but not all, Python
distribute, and otherwise use Python alone or in any derivative version,
provided, however, that PSF's License Agreement and PSF's notice of copyright,
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
-2011, 2012, 2013, 2014, 2015, 2016 Python Software Foundation; All Rights
+2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights
Reserved" are retained in Python alone or in any derivative version prepared by
Licensee.
else:
# Cannot use name2codepoint directly, because HTMLParser supports apos,
# which is not part of HTML 4
- import htmlentitydefs
if HTMLParser.entitydefs is None:
- entitydefs = HTMLParser.entitydefs = {'apos':u"'"}
+ import htmlentitydefs
+ entitydefs = {'apos':u"'"}
for k, v in htmlentitydefs.name2codepoint.iteritems():
entitydefs[k] = unichr(v)
+ HTMLParser.entitydefs = entitydefs
try:
return self.entitydefs[s]
except KeyError:
# format directives (%m, etc.).
regex_chars = re_compile(r"([\\.^$*+?\(\){}\[\]|])")
format = regex_chars.sub(r"\\\1", format)
- whitespace_replacement = re_compile('\s+')
- format = whitespace_replacement.sub('\s+', format)
+ whitespace_replacement = re_compile(r'\s+')
+ format = whitespace_replacement.sub(r'\\s+', format)
while '%' in format:
directive_index = format.index('%')+1
processed_format = "%s%s%s" % (processed_format,
# _ssnd_chunk -- instantiation of a chunk class for the SSND chunk
# _framesize -- size of one frame in the file
+ _file = None # Set here since __del__ checks it
+
def initfp(self, file):
self._version = 0
self._decomp = None
self._decomp.SetParams(params)
def __init__(self, f):
- if type(f) == type(''):
+ if isinstance(f, basestring):
f = __builtin__.open(f, 'rb')
- # else, assume it is an open file object already
- self.initfp(f)
+ try:
+ self.initfp(f)
+ except:
+ f.close()
+ raise
+ else:
+ # assume it is an open file object already
+ self.initfp(f)
#
# User visible methods.
# _datalength -- the size of the audio samples written to the header
# _datawritten -- the size of the audio samples actually written
+ _file = None # Set here since __del__ checks it
+
def __init__(self, f):
- if type(f) == type(''):
+ if isinstance(f, basestring):
filename = f
f = __builtin__.open(f, 'wb')
else:
# no terminator, collect it all
self.collect_incoming_data (self.ac_in_buffer)
self.ac_in_buffer = ''
- elif isinstance(terminator, int) or isinstance(terminator, long):
+ elif isinstance(terminator, (int, long)):
# numeric terminator
n = terminator
if lb < n:
write = send
def close(self):
- os.close(self.fd)
+ if self.fd < 0:
+ return
+ fd = self.fd
+ self.fd = -1
+ os.close(fd)
def fileno(self):
return self.fd
self.assertEqual(vals, None, vals)
vals = secDB.pget('Unknown', txn=txn)
- self.assertTrue(vals[0] == 99 or vals[0] == '99', vals)
+ self.assertIn(vals[0], (99, '99'), vals)
vals[1].index('Unknown')
vals[1].index('Unnamed')
vals[1].index('unknown')
if type(self.keytype) == type(''):
self.assertTrue(int(rec[0])) # for primary db, key is a number
else:
- self.assertTrue(rec[0] and type(rec[0]) == type(0))
+ self.assertTrue(rec[0])
+ self.assertIs(type(rec[0]), int)
count = count + 1
if verbose:
print rec
# test cursor pget
vals = self.cur.pget('Unknown', flags=db.DB_LAST)
- self.assertTrue(vals[1] == 99 or vals[1] == '99', vals)
+ self.assertIn(vals[1], (99, '99'), vals)
self.assertEqual(vals[0], 'Unknown')
vals[2].index('Unknown')
vals[2].index('Unnamed')
d.put("abcde", "ABCDE");
num = d.truncate()
- self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
+ self.assertGreaterEqual(num, 1, "truncate returned <= 0 on non-empty database")
num = d.truncate()
self.assertEqual(num, 0,
"truncate on empty DB returned nonzero (%r)" % (num,))
if db.version() >= (4, 6):
def test08_exists(self) :
self.d.put("abcde", "ABCDE")
- self.assertTrue(self.d.exists("abcde") == True,
+ self.assertEqual(self.d.exists("abcde"), True,
"DB->exists() returns wrong value")
- self.assertTrue(self.d.exists("x") == False,
+ self.assertEqual(self.d.exists("x"), False,
"DB->exists() returns wrong value")
#----------------------------------------
if verbose:
print 'log file: ' + log
logs = self.env.log_archive(db.DB_ARCH_REMOVE)
- self.assertTrue(not logs)
+ self.assertFalse(logs)
self.txn = self.env.txn_begin()
self.d.put("abcde", "ABCDE", txn=txn)
txn.commit()
txn = self.env.txn_begin()
- self.assertTrue(self.d.exists("abcde", txn=txn) == True,
+ self.assertEqual(self.d.exists("abcde", txn=txn), True,
"DB->exists() returns wrong value")
- self.assertTrue(self.d.exists("x", txn=txn) == False,
+ self.assertEqual(self.d.exists("x", txn=txn), False,
"DB->exists() returns wrong value")
txn.abort()
d.put("abcde", "ABCDE");
txn = self.env.txn_begin()
num = d.truncate(txn)
- self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
+ self.assertGreaterEqual(num, 1, "truncate returned <= 0 on non-empty database")
num = d.truncate(txn)
self.assertEqual(num, 0,
"truncate on empty DB returned nonzero (%r)" % (num,))
a = "example of private object"
self.obj.set_private(a)
b = self.obj.get_private()
- self.assertTrue(a is b) # Object identity
+ self.assertIs(a, b) # Object identity
def test03_leak_assignment(self) :
a = "example of private object"
self.env.set_cache_max(0, size)
size2 = self.env.get_cache_max()
self.assertEqual(0, size2[0])
- self.assertTrue(size <= size2[1])
- self.assertTrue(2*size > size2[1])
+ self.assertLessEqual(size, size2[1])
+ self.assertGreater(2*size, size2[1])
if db.version() >= (4, 4) :
def test_mutex_stat(self) :
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
db.DB_INIT_LOCK)
stat = self.env.mutex_stat()
- self.assertTrue("mutex_inuse_max" in stat)
+ self.assertIn("mutex_inuse_max", stat)
def test_lg_filemode(self) :
for i in [0600, 0660, 0666] :
i = i*1024*1024
self.env.set_lg_regionmax(i)
j = self.env.get_lg_regionmax()
- self.assertTrue(i <= j)
- self.assertTrue(2*i > j)
+ self.assertLessEqual(i, j)
+ self.assertGreater(2*i, j)
def test_lk_detect(self) :
flags= [db.DB_LOCK_DEFAULT, db.DB_LOCK_EXPIRE, db.DB_LOCK_MAXLOCKS,
def test_lg_bsize(self) :
log_size = 70*1024
self.env.set_lg_bsize(log_size)
- self.assertTrue(self.env.get_lg_bsize() >= log_size)
- self.assertTrue(self.env.get_lg_bsize() < 4*log_size)
+ self.assertGreaterEqual(self.env.get_lg_bsize(), log_size)
+ self.assertLess(self.env.get_lg_bsize(), 4*log_size)
self.env.set_lg_bsize(4*log_size)
- self.assertTrue(self.env.get_lg_bsize() >= 4*log_size)
+ self.assertGreaterEqual(self.env.get_lg_bsize(), 4*log_size)
def test_setget_data_dirs(self) :
dirs = ("a", "b", "c", "d")
self.assertEqual(cachesize2[0], cachesize3[0])
self.assertEqual(cachesize2[2], cachesize3[2])
# In Berkeley DB 5.1, the cachesize can change when opening the Env
- self.assertTrue(cachesize2[1] <= cachesize3[1])
+ self.assertLessEqual(cachesize2[1], cachesize3[1])
def test_set_cachesize_dbenv_db(self) :
# You can not configure the cachesize using
msg = "This is a test..."
self.env.log_printf(msg)
logc = self.env.log_cursor()
- self.assertTrue(msg in (logc.last()[1]))
+ self.assertIn(msg, logc.last()[1])
if db.version() >= (4, 7) :
def test_log_config(self) :
txn.commit()
logc = self.env.log_cursor()
logc.last() # Skip the commit
- self.assertTrue(msg in (logc.prev()[1]))
+ self.assertIn(msg, logc.prev()[1])
msg = "This is another test..."
txn = self.env.txn_begin()
self.env.log_printf(msg, txn=txn)
txn.abort() # Do not store the new message
logc.last() # Skip the abort
- self.assertTrue(msg not in (logc.prev()[1]))
+ self.assertNotIn(msg, logc.prev()[1])
msg = "This is a third test..."
txn = self.env.txn_begin()
self.env.log_printf(msg, txn=txn)
txn.commit() # Do not store the new message
logc.last() # Skip the commit
- self.assertTrue(msg in (logc.prev()[1]))
+ self.assertIn(msg, logc.prev()[1])
class DBEnv_memp(DBEnv):
def test_memp_1_trickle(self) :
self.db.put("hi", "bye")
- self.assertTrue(self.env.memp_trickle(100) > 0)
+ self.assertGreater(self.env.memp_trickle(100), 0)
# Preserve the order, do "memp_trickle" test first
def test_memp_2_sync(self) :
self.db.put("hi", "bye")
self.env.memp_sync() # Full flush
# Nothing to do...
- self.assertTrue(self.env.memp_trickle(100) == 0)
+ self.assertEqual(self.env.memp_trickle(100), 0)
self.db.put("hi", "bye2")
self.env.memp_sync((1, 0)) # NOP, probably
# Something to do... or not
- self.assertTrue(self.env.memp_trickle(100) >= 0)
+ self.assertGreaterEqual(self.env.memp_trickle(100), 0)
self.db.put("hi", "bye3")
self.env.memp_sync((123, 99)) # Full flush
# Nothing to do...
- self.assertTrue(self.env.memp_trickle(100) == 0)
+ self.assertEqual(self.env.memp_trickle(100), 0)
def test_memp_stat_1(self) :
stats = self.env.memp_stat() # No param
- self.assertTrue(len(stats)==2)
- self.assertTrue("cache_miss" in stats[0])
+ self.assertEqual(len(stats), 2)
+ self.assertIn("cache_miss", stats[0])
stats = self.env.memp_stat(db.DB_STAT_CLEAR) # Positional param
- self.assertTrue("cache_miss" in stats[0])
+ self.assertIn("cache_miss", stats[0])
stats = self.env.memp_stat(flags=0) # Keyword param
- self.assertTrue("cache_miss" in stats[0])
+ self.assertIn("cache_miss", stats[0])
def test_memp_stat_2(self) :
stats=self.env.memp_stat()[1]
- self.assertTrue(len(stats))==1
- self.assertTrue("test" in stats)
- self.assertTrue("page_in" in stats["test"])
+ self.assertEqual(len(stats), 1)
+ self.assertIn("test", stats)
+ self.assertIn("page_in", stats["test"])
class DBEnv_logcursor(DBEnv):
def setUp(self):
DBEnv.tearDown(self)
def _check_return(self, value) :
- self.assertTrue(isinstance(value, tuple))
+ self.assertIsInstance(value, tuple)
self.assertEqual(len(value), 2)
- self.assertTrue(isinstance(value[0], tuple))
+ self.assertIsInstance(value[0], tuple)
self.assertEqual(len(value[0]), 2)
- self.assertTrue(isinstance(value[0][0], int))
- self.assertTrue(isinstance(value[0][1], int))
- self.assertTrue(isinstance(value[1], str))
+ self.assertIsInstance(value[0][0], int)
+ self.assertIsInstance(value[0][1], int)
+ self.assertIsInstance(value[1], str)
# Preserve test order
def test_1_first(self) :
logc = self.env.log_cursor()
v = logc.first()
self._check_return(v)
- self.assertTrue((1, 1) < v[0])
- self.assertTrue(len(v[1])>0)
+ self.assertLess((1, 1), v[0])
+ self.assertGreater(len(v[1]), 0)
def test_2_last(self) :
logc = self.env.log_cursor()
lsn_first = logc.first()[0]
v = logc.last()
self._check_return(v)
- self.assertTrue(lsn_first < v[0])
+ self.assertLess(lsn_first, v[0])
def test_3_next(self) :
logc = self.env.log_cursor()
lsn_first = logc.first()[0]
v = logc.next()
self._check_return(v)
- self.assertTrue(lsn_first < v[0])
- self.assertTrue(lsn_last > v[0])
+ self.assertLess(lsn_first, v[0])
+ self.assertGreater(lsn_last, v[0])
v2 = logc.next()
- self.assertTrue(v2[0] > v[0])
- self.assertTrue(lsn_last > v2[0])
+ self.assertGreater(v2[0], v[0])
+ self.assertGreater(lsn_last, v2[0])
v3 = logc.next()
- self.assertTrue(v3[0] > v2[0])
- self.assertTrue(lsn_last > v3[0])
+ self.assertGreater(v3[0], v2[0])
+ self.assertGreater(lsn_last, v3[0])
def test_4_prev(self) :
logc = self.env.log_cursor()
lsn_last = logc.last()[0]
v = logc.prev()
self._check_return(v)
- self.assertTrue(lsn_first < v[0])
- self.assertTrue(lsn_last > v[0])
+ self.assertLess(lsn_first, v[0])
+ self.assertGreater(lsn_last, v[0])
v2 = logc.prev()
- self.assertTrue(v2[0] < v[0])
- self.assertTrue(lsn_first < v2[0])
+ self.assertLess(v2[0], v[0])
+ self.assertLess(lsn_first, v2[0])
v3 = logc.prev()
- self.assertTrue(v3[0] < v2[0])
- self.assertTrue(lsn_first < v3[0])
+ self.assertLess(v3[0], v2[0])
+ self.assertLess(lsn_first, v3[0])
def test_5_current(self) :
logc = self.env.log_cursor()
self.assertEqual(value.L, [x] * 10)
else:
- self.assertTrue(0, 'Unknown key type, fix the test')
+ self.fail('Unknown key type, fix the test')
#----------------------------------------------------------------------
colval = pickle.loads(values[0][colname])
else :
colval = pickle.loads(bytes(values[0][colname], "iso8859-1"))
- self.assertTrue(colval > 3.141)
- self.assertTrue(colval < 3.142)
+ self.assertGreater(colval, 3.141)
+ self.assertLess(colval, 3.142)
def test02(self):
recovered_txns=self.dbenv.txn_recover()
self.assertEqual(self.num_txns,len(recovered_txns))
for gid,txn in recovered_txns :
- self.assertTrue(gid in txns)
+ self.assertIn(gid, txns)
del txn
del recovered_txns
# Be sure there are not pending transactions.
# Check also database size.
recovered_txns=self.dbenv.txn_recover()
- self.assertTrue(len(recovered_txns)==0)
+ self.assertEqual(len(recovered_txns), 0)
self.assertEqual(len(committed_txns),self.db.stat()["nkeys"])
class DBTxn_distributedSYNC(DBTxn_distributed):
TestCases for testing the locking sub-system.
"""
+import sys
import time
import unittest
if have_threads :
from threading import Thread
- import sys
if sys.version_info[0] < 3 :
from threading import currentThread
else :
end_time=time.time()
deadlock_detection.end=True
# Floating point rounding
- self.assertTrue((end_time-start_time) >= 0.0999)
+ if sys.platform == 'win32':
+ # bpo-30850: On Windows, tolerate 50 ms whereas 100 ms is expected.
+ # The lock sometimes times out after only 58 ms. Windows clocks
+ # have a bad resolution and bad accuracy.
+ min_dt = 0.050
+ else:
+ min_dt = 0.0999
+ self.assertGreaterEqual(end_time-start_time, min_dt)
self.env.lock_put(lock)
t.join()
self.env.lock_id_free(anID2)
if db.version() >= (4,6):
- self.assertTrue(deadlock_detection.count>0)
+ self.assertGreater(deadlock_detection.count, 0)
def theThread(self, lockType):
import sys
def test02_db_home(self):
env = db.DBEnv()
# check for crash fixed when db_home is used before open()
- self.assertTrue(env.db_home is None)
+ self.assertIsNone(env.db_home)
env.open(self.homeDir, db.DB_CREATE)
if sys.version_info[0] < 3 :
self.assertEqual(self.homeDir, env.db_home)
def assertIsInstance(self, obj, datatype, msg=None) :
return self.assertEqual(type(obj), datatype, msg=msg)
def assertGreaterEqual(self, a, b, msg=None) :
- return self.assertTrue(a>=b, msg=msg)
+ return self.assertGreaterEqual(a, b, msg=msg)
def setUp(self):
d = d.values()[0] # There is only one
self.assertEqual(d[0], "127.0.0.1")
self.assertEqual(d[1], client_port)
- self.assertTrue((d[2]==db.DB_REPMGR_CONNECTED) or \
- (d[2]==db.DB_REPMGR_DISCONNECTED))
+ self.assertIn(d[2], (db.DB_REPMGR_CONNECTED, db.DB_REPMGR_DISCONNECTED))
d = self.dbenvClient.repmgr_site_list()
self.assertEqual(len(d), 1)
d = d.values()[0] # There is only one
self.assertEqual(d[0], "127.0.0.1")
self.assertEqual(d[1], master_port)
- self.assertTrue((d[2]==db.DB_REPMGR_CONNECTED) or \
- (d[2]==db.DB_REPMGR_DISCONNECTED))
+ self.assertIn(d[2], (db.DB_REPMGR_CONNECTED, db.DB_REPMGR_DISCONNECTED))
if db.version() >= (4,6) :
d = self.dbenvMaster.repmgr_stat(flags=db.DB_STAT_CLEAR);
- self.assertTrue("msgs_queued" in d)
+ self.assertIn("msgs_queued", d)
self.dbMaster=db.DB(self.dbenvMaster)
txn=self.dbenvMaster.txn_begin()
if time.time()>=timeout and startup_timeout:
self.skipTest("replication test skipped due to random failure, "
"see issue 3892")
- self.assertTrue(time.time()<timeout)
+ self.assertLess(time.time(), timeout)
self.assertEqual("123", v)
txn=self.dbenvMaster.txn_begin()
txn.commit()
if v is None :
time.sleep(0.02)
- self.assertTrue(time.time()<timeout)
+ self.assertLess(time.time(), timeout)
self.assertEqual(None, v)
class DBBaseReplication(DBReplication) :
while (time.time()<timeout) and not (self.confirmed_master and
self.client_startupdone) :
time.sleep(0.02)
- self.assertTrue(time.time()<timeout)
+ self.assertLess(time.time(), timeout)
self.dbMaster=db.DB(self.dbenvMaster)
txn=self.dbenvMaster.txn_begin()
break
d = self.dbenvMaster.rep_stat(flags=db.DB_STAT_CLEAR);
- self.assertTrue("master_changes" in d)
+ self.assertIn("master_changes", d)
txn=self.dbenvMaster.txn_begin()
self.dbMaster.put("ABC", "123", txn=txn)
txn.commit()
if v is None :
time.sleep(0.02)
- self.assertTrue(time.time()<timeout)
+ self.assertLess(time.time(), timeout)
self.assertEqual("123", v)
txn=self.dbenvMaster.txn_begin()
txn.commit()
if v is None :
time.sleep(0.02)
- self.assertTrue(time.time()<timeout)
+ self.assertLess(time.time(), timeout)
self.assertEqual(None, v)
if db.version() >= (4,7) :
stat = self.seq.stat()
for param in ('nowait', 'min', 'max', 'value', 'current',
'flags', 'cache_size', 'last_value', 'wait'):
- self.assertTrue(param in stat, "parameter %s isn't in stat info" % param)
+ self.assertIn(param, stat, "parameter %s isn't in stat info" % param)
if db.version() >= (4,7) :
# This code checks a crash solved in Berkeley DB 4.7
readers_per_writer=self.readers//self.writers
self.assertEqual(self.records,self.writers*records_per_writer)
self.assertEqual(self.readers,self.writers*readers_per_writer)
- self.assertTrue((records_per_writer%readers_per_writer)==0)
+ self.assertEqual(records_per_writer%readers_per_writer, 0)
readers = []
for x in xrange(self.readers):
readers_per_writer=self.readers//self.writers
self.assertEqual(self.records,self.writers*records_per_writer)
self.assertEqual(self.readers,self.writers*readers_per_writer)
- self.assertTrue((records_per_writer%readers_per_writer)==0)
+ self.assertEqual(records_per_writer%readers_per_writer, 0)
readers = []
for x in xrange(self.readers):
readers_per_writer=self.readers//self.writers
self.assertEqual(self.records,self.writers*records_per_writer)
self.assertEqual(self.readers,self.writers*readers_per_writer)
- self.assertTrue((records_per_writer%readers_per_writer)==0)
+ self.assertEqual(records_per_writer%readers_per_writer, 0)
readers=[]
for x in xrange(self.readers):
def twobyte(val):
"""Convert an int argument into high and low bytes"""
- assert isinstance(val, int)
+ assert isinstance(val, (int, long))
return divmod(val, 256)
class LineAddrTable:
def debug_tree(tree):
l = []
for elt in tree:
- if isinstance(elt, int):
+ if isinstance(elt, (int, long)):
l.append(_names.get(elt, elt))
elif isinstance(elt, str):
l.append(elt)
continue
# mangled names
elif name.startswith('__') and not name.endswith('__'):
- names.append('_%s%s' % (c.__name__, name))
+ stripped = c.__name__.lstrip('_')
+ if stripped:
+ names.append('_%s%s' % (stripped, name))
+ else:
+ names.append(name)
else:
names.append(name)
"""
_func_flags_ = _FUNCFLAG_CDECL
_func_restype_ = c_int
+ # default values for repr
+ _name = '<uninitialized>'
+ _handle = 0
+ _FuncPtr = None
def __init__(self, name, mode=DEFAULT_MODE, handle=None,
use_errno=False,
import os
from ctypes.util import find_library
from ctypes.test import is_resource_enabled
+import test.test_support as support
libc_name = None
if os.name == "nt":
CDLL(os.path.basename(libc_name))
self.assertRaises(OSError, CDLL, self.unknowndll)
+ @support.requires_unicode
+ @unittest.skipUnless(libc_name is not None, 'could not find libc')
+ def test_load_unicode(self):
+ CDLL(unicode(libc_name))
+ self.assertRaises(OSError, CDLL, unicode(self.unknowndll))
+
@unittest.skipUnless(libc_name is not None, 'could not find libc')
@unittest.skipUnless(libc_name is not None and
os.path.basename(libc_name) == "libc.so.6",
def isalnum(c): return isalpha(c) or isdigit(c)
def isalpha(c): return isupper(c) or islower(c)
-def isascii(c): return _ctoi(c) <= 127 # ?
+def isascii(c): return 0 <= _ctoi(c) <= 127 # ?
def isblank(c): return _ctoi(c) in (9, 32)
-def iscntrl(c): return _ctoi(c) <= 31 or _ctoi(c) == 127
-def isdigit(c): return _ctoi(c) >= 48 and _ctoi(c) <= 57
-def isgraph(c): return _ctoi(c) >= 33 and _ctoi(c) <= 126
-def islower(c): return _ctoi(c) >= 97 and _ctoi(c) <= 122
-def isprint(c): return _ctoi(c) >= 32 and _ctoi(c) <= 126
+def iscntrl(c): return 0 <= _ctoi(c) <= 31 or _ctoi(c) == 127
+def isdigit(c): return 48 <= _ctoi(c) <= 57
+def isgraph(c): return 33 <= _ctoi(c) <= 126
+def islower(c): return 97 <= _ctoi(c) <= 122
+def isprint(c): return 32 <= _ctoi(c) <= 126
def ispunct(c): return isgraph(c) and not isalnum(c)
def isspace(c): return _ctoi(c) in (9, 10, 11, 12, 13, 32)
-def isupper(c): return _ctoi(c) >= 65 and _ctoi(c) <= 90
+def isupper(c): return 65 <= _ctoi(c) <= 90
def isxdigit(c): return isdigit(c) or \
- (_ctoi(c) >= 65 and _ctoi(c) <= 70) or (_ctoi(c) >= 97 and _ctoi(c) <= 102)
-def isctrl(c): return _ctoi(c) < 32
+ (65 <= _ctoi(c) <= 70) or (97 <= _ctoi(c) <= 102)
+def isctrl(c): return 0 <= _ctoi(c) < 32
def ismeta(c): return _ctoi(c) > 127
def ascii(c):
def __init__(self, win, insert_mode=False):
self.win = win
self.insert_mode = insert_mode
- (self.maxy, self.maxx) = win.getmaxyx()
- self.maxy = self.maxy - 1
- self.maxx = self.maxx - 1
+ self._update_max_yx()
self.stripspaces = 1
self.lastcmd = None
win.keypad(1)
+ def _update_max_yx(self):
+ maxy, maxx = self.win.getmaxyx()
+ self.maxy = maxy - 1
+ self.maxx = maxx - 1
+
def _end_of_line(self, y):
"""Go to the location of the first blank on the given line,
returning the index of the last non-blank character."""
+ self._update_max_yx()
last = self.maxx
while True:
if curses.ascii.ascii(self.win.inch(y, last)) != curses.ascii.SP:
return last
def _insert_printable_char(self, ch):
+ self._update_max_yx()
(y, x) = self.win.getyx()
- if y < self.maxy or x < self.maxx:
+ backyx = None
+ while y < self.maxy or x < self.maxx:
if self.insert_mode:
oldch = self.win.inch()
# The try-catch ignores the error we trigger from some curses
self.win.addch(ch)
except curses.error:
pass
- if self.insert_mode:
- (backy, backx) = self.win.getyx()
- if curses.ascii.isprint(oldch):
- self._insert_printable_char(oldch)
- self.win.move(backy, backx)
+ if not self.insert_mode or not curses.ascii.isprint(oldch):
+ break
+ ch = oldch
+ (y, x) = self.win.getyx()
+ # Remember where to put the cursor back since we are in insert_mode
+ if backyx is None:
+ backyx = y, x
+
+ if backyx is not None:
+ self.win.move(*backyx)
def do_command(self, ch):
"Process a single editing command."
+ self._update_max_yx()
(y, x) = self.win.getyx()
self.lastcmd = ch
if curses.ascii.isprint(ch):
def gather(self):
"Collect and return the contents of the window."
result = ""
+ self._update_max_yx()
for y in range(self.maxy+1):
self.win.move(y, 0)
stop = self._end_of_line(y)
@unittest.skipIf(find_executable('rpmbuild') is None,
'the rpmbuild command is not found')
def test_no_optimize_flag(self):
- # let's create a package that brakes bdist_rpm
+ # let's create a package that breaks bdist_rpm
tmp_dir = self.mkdtemp()
os.environ['HOME'] = tmp_dir # to confine dir '.rpmdb' creation
pkg_dir = os.path.join(tmp_dir, 'foo')
class BuildExtTestCase(support.TempdirManager,
support.LoggingSilencer,
+ support.EnvironGuard,
unittest.TestCase):
def setUp(self):
super(BuildExtTestCase, self).setUp()
class InstallTestCase(support.TempdirManager,
+ support.EnvironGuard,
support.LoggingSilencer,
unittest.TestCase):
from test.test_support import run_unittest
from distutils.errors import DistutilsByteCompileError
+from distutils.tests import support
from distutils.util import byte_compile, grok_environment_error
-class UtilTestCase(unittest.TestCase):
+class UtilTestCase(support.EnvironGuard, unittest.TestCase):
def test_dont_write_bytecode(self):
# makes sure byte_compile raise a DistutilsError
# Internal: send one line to the server, appending CRLF
def putline(self, line):
+ if '\r' in line or '\n' in line:
+ raise ValueError('an illegal newline character should not be contained')
line = line + CRLF
if self.debugging > 1: print '*put*', self.sanitize(line)
self.sock.sendall(line)
"""
self.voidcmd('TYPE I')
conn = self.transfercmd(cmd, rest)
- while 1:
- data = conn.recv(blocksize)
- if not data:
- break
- callback(data)
- conn.close()
+ try:
+ while 1:
+ data = conn.recv(blocksize)
+ if not data:
+ break
+ callback(data)
+ finally:
+ conn.close()
return self.voidresp()
def retrlines(self, cmd, callback = None):
if callback is None: callback = print_line
resp = self.sendcmd('TYPE A')
conn = self.transfercmd(cmd)
- fp = conn.makefile('rb')
- while 1:
- line = fp.readline(self.maxline + 1)
- if len(line) > self.maxline:
- raise Error("got more than %d bytes" % self.maxline)
- if self.debugging > 2: print '*retr*', repr(line)
- if not line:
- break
- if line[-2:] == CRLF:
- line = line[:-2]
- elif line[-1:] == '\n':
- line = line[:-1]
- callback(line)
- fp.close()
- conn.close()
+ fp = None
+ try:
+ fp = conn.makefile('rb')
+ while 1:
+ line = fp.readline(self.maxline + 1)
+ if len(line) > self.maxline:
+ raise Error("got more than %d bytes" % self.maxline)
+ if self.debugging > 2: print '*retr*', repr(line)
+ if not line:
+ break
+ if line[-2:] == CRLF:
+ line = line[:-2]
+ elif line[-1:] == '\n':
+ line = line[:-1]
+ callback(line)
+ finally:
+ if fp:
+ fp.close()
+ conn.close()
return self.voidresp()
def storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None):
"""
self.voidcmd('TYPE I')
conn = self.transfercmd(cmd, rest)
- while 1:
- buf = fp.read(blocksize)
- if not buf: break
- conn.sendall(buf)
- if callback: callback(buf)
- conn.close()
+ try:
+ while 1:
+ buf = fp.read(blocksize)
+ if not buf: break
+ conn.sendall(buf)
+ if callback: callback(buf)
+ finally:
+ conn.close()
return self.voidresp()
def storlines(self, cmd, fp, callback=None):
"""
self.voidcmd('TYPE A')
conn = self.transfercmd(cmd)
- while 1:
- buf = fp.readline(self.maxline + 1)
- if len(buf) > self.maxline:
- raise Error("got more than %d bytes" % self.maxline)
- if not buf: break
- if buf[-2:] != CRLF:
- if buf[-1] in CRLF: buf = buf[:-1]
- buf = buf + CRLF
- conn.sendall(buf)
- if callback: callback(buf)
- conn.close()
+ try:
+ while 1:
+ buf = fp.readline(self.maxline + 1)
+ if len(buf) > self.maxline:
+ raise Error("got more than %d bytes" % self.maxline)
+ if not buf: break
+ if buf[-2:] != CRLF:
+ if buf[-1] in CRLF: buf = buf[:-1]
+ buf = buf + CRLF
+ conn.sendall(buf)
+ if callback: callback(buf)
+ finally:
+ conn.close()
return self.voidresp()
def acct(self, password):
raise ValueError("read from closed file")
if size is None:
size = -1
- elif not isinstance(size, int):
+ elif not isinstance(size, (int, long)):
raise TypeError('must be int, not ' + type(size).__name__)
result = self._line_buffer
self._line_buffer = ''
raise ValueError("read from closed file")
if size is None:
size = -1
- elif not isinstance(size, int):
+ elif not isinstance(size, (int, long)):
raise TypeError('must be int, not ' + type(size).__name__)
line = self._line_buffer or self.shell.readline()
if size < 0:
</ul>
</div>
<div class="footer">
- © <a href="../copyright.html">Copyright</a> 1990-2016, Python Software Foundation.
+ © <a href="../copyright.html">Copyright</a> 1990-2017, Python Software Foundation.
<br />
The Python Software Foundation is a non-profit corporation.
<a href="https://www.python.org/psf/donations/">Please donate.</a>
try:
self.sock.shutdown(socket.SHUT_RDWR)
except socket.error as e:
- # The server might already have closed the connection
- if e.errno != errno.ENOTCONN:
+ # The server might already have closed the connection.
+ # On Windows, this may result in WSAEINVAL (error 10022):
+ # An invalid operation was attempted.
+ if e.errno not in (errno.ENOTCONN, 10022):
raise
finally:
self.sock.close()
be in the correct format.
"""
- if isinstance(date_time, (int, float)):
+ if isinstance(date_time, (int, long, float)):
tt = time.localtime(date_time)
elif isinstance(date_time, (tuple, time.struct_time)):
tt = date_time
if opname in ('UNPACK_TUPLE', 'UNPACK_SEQUENCE'):
remain.append(value)
count.append(value)
- elif opname == 'STORE_FAST':
- stack.append(names[value])
+ elif opname in ('STORE_FAST', 'STORE_DEREF'):
+ if opname == 'STORE_FAST':
+ stack.append(names[value])
+ else:
+ stack.append(co.co_cellvars[value])
# Special case for sublists of length 1: def foo((bar))
# doesn't generate the UNPACK_TUPLE bytecode, so if
>>> def encode_complex(obj):
... if isinstance(obj, complex):
... return [obj.real, obj.imag]
- ... raise TypeError(repr(o) + " is not JSON serializable")
+ ... raise TypeError(repr(obj) + " is not JSON serializable")
...
>>> json.dumps(2 + 1j, default=encode_complex)
'[2.0, 1.0]'
from json.tests import CTest
+class BadBool:
+ def __nonzero__(self):
+ 1/0
+
+
class TestSpeedups(CTest):
def test_scanstring(self):
self.assertEqual(self.json.decoder.scanstring.__module__, "_json")
def test_make_scanner(self):
self.assertRaises(AttributeError, self.json.scanner.c_make_scanner, 1)
+ def test_bad_bool_args(self):
+ def test(value):
+ self.json.decoder.JSONDecoder(strict=BadBool()).decode(value)
+ self.assertRaises(ZeroDivisionError, test, '""')
+ self.assertRaises(ZeroDivisionError, test, '{}')
+ self.assertRaises(ZeroDivisionError, test, u'""')
+ self.assertRaises(ZeroDivisionError, test, u'{}')
+
+
+class TestEncode(CTest):
def test_make_encoder(self):
self.assertRaises(TypeError, self.json.encoder.c_make_encoder,
None,
"\xCD\x7D\x3D\x4E\x12\x4C\xF9\x79\xD7\x52\xBA\x82\xF2\x27\x4A\x7D\xA0\xCA\x75",
None)
+
+ def test_bad_bool_args(self):
+ def test(name):
+ self.json.encoder.JSONEncoder(**{name: BadBool()}).encode({'a': 1})
+ self.assertRaises(ZeroDivisionError, test, 'skipkeys')
+ self.assertRaises(ZeroDivisionError, test, 'ensure_ascii')
+ self.assertRaises(ZeroDivisionError, test, 'check_circular')
+ self.assertRaises(ZeroDivisionError, test, 'allow_nan')
+ self.assertRaises(ZeroDivisionError, test, 'sort_keys')
+
+ def test_bad_encoding(self):
+ with self.assertRaises(UnicodeEncodeError):
+ self.json.encoder.JSONEncoder(encoding=u'\udcff').encode({'key': 123})
-# -*-mode: python; fill-column: 75; tab-width: 8; coding: iso-latin-1-unix -*-
-#
-# $Id$
-#
# Tix.py -- Tix widget wrappers.
#
# For Tix, see http://tix.sourceforge.net
self.tk.call('winfo', 'height', self._w))
def winfo_id(self):
"""Return identifier ID for this widget."""
- return self.tk.getint(
- self.tk.call('winfo', 'id', self._w))
+ return int(self.tk.call('winfo', 'id', self._w), 0)
def winfo_interps(self, displayof=0):
"""Return the name of all Tcl interpreters for this display."""
args = ('winfo', 'interps') + self._displayof(displayof)
return getint(
self.tk.call('winfo', 'ismapped', self._w))
def winfo_manager(self):
- """Return the window mananger name for this widget."""
+ """Return the window manager name for this widget."""
return self.tk.call('winfo', 'manager', self._w)
def winfo_name(self):
"""Return the name of this widget."""
elif isinstance(v, (tuple, list)):
nv = []
for item in v:
- if not isinstance(item, (basestring, int)):
+ if not isinstance(item, (basestring, int, long)):
break
- elif isinstance(item, int):
+ elif isinstance(item, (int, long)):
nv.append('%d' % item)
else:
# format it to proper Tcl code if it contains space
return self.tk.splitlist(self.tk.call('image', 'names'))
def image_types(self):
- """Return a list of all available image types (e.g. phote bitmap)."""
+ """Return a list of all available image types (e.g. photo bitmap)."""
return self.tk.splitlist(self.tk.call('image', 'types'))
"""Return item which is closest to pixel at X, Y.
If several match take the top-most.
All items closer than HALO are considered overlapping (all are
- closests). If START is specified the next below this tag is taken."""
+ closest). If START is specified the next below this tag is taken."""
return self.find('closest', x, y, halo, start)
def find_enclosed(self, x1, y1, x2, y2):
"""Return all items in rectangle defined
"""Print the contents of the canvas to a postscript
file. Valid options: colormap, colormode, file, fontmap,
height, pageanchor, pageheight, pagewidth, pagex, pagey,
- rotate, witdh, x, y."""
+ rotate, width, x, y."""
return self.tk.call((self._w, 'postscript') +
self._options(cnf, kw))
def tag_raise(self, *args):
return getint(
self.tk.call('image', 'height', self.name))
def type(self):
- """Return the type of the imgage, e.g. "photo" or "bitmap"."""
+ """Return the type of the image, e.g. "photo" or "bitmap"."""
return self.tk.call('image', 'type', self.name)
def width(self):
"""Return the width of the image."""
import unittest
import Tkinter as tkinter
import tkFont as font
-from test.test_support import requires, run_unittest
+from test.test_support import requires, run_unittest, gc_collect
from test_ttk.support import AbstractTkTest
requires('gui')
self.assertIsInstance(self.font.cget(key), sizetype)
self.assertIsInstance(self.font[key], sizetype)
+ def test_unicode_family(self):
+ family = u'MS \u30b4\u30b7\u30c3\u30af'
+ try:
+ f = font.Font(root=self.root, family=family, exists=True)
+ except tkinter.TclError:
+ f = font.Font(root=self.root, family=family, exists=False)
+ self.assertEqual(f.cget('family'), family)
+ del f
+ gc_collect()
+
def test_actual(self):
options = self.font.actual()
self.assertGreaterEqual(set(options),
widget = self.create()
self.assertEqual(widget['use'], '')
parent = self.create(container=True)
- wid = parent.winfo_id()
+ wid = hex(parent.winfo_id())
widget2 = self.create(use=wid)
- self.assertEqual(int(widget2['use']), wid)
+ self.assertEqual(widget2['use'], wid)
@add_standard_options(StandardOptionsTests)
def _set(self, kw):
options = []
for k, v in kw.items():
+ if not isinstance(v, basestring):
+ v = str(v)
options.append("-"+k)
- options.append(str(v))
+ options.append(v)
return tuple(options)
def _get(self, args):
pass
else:
del self._variable
- Frame.destroy(self)
+ Frame.destroy(self)
+ self.label = None
+ self.scale = None
def _adjust(self, *args):
def destroy(self):
"""Destroy this widget and its associated variable."""
- del self._variable
+ try:
+ del self._variable
+ except AttributeError:
+ pass
Menubutton.destroy(self)
return self[0]*other[0]+self[1]*other[1]
return Vec2D(self[0]*other, self[1]*other)
def __rmul__(self, other):
- if isinstance(other, int) or isinstance(other, float):
+ if isinstance(other, (int, long, float)):
return Vec2D(self[0]*other, self[1]*other)
def __sub__(self, other):
return Vec2D(self[0]-other[0], self[1]-other[1])
self._resizemode = p["resizemode"]
if "stretchfactor" in p:
sf = p["stretchfactor"]
- if isinstance(sf, (int, float)):
+ if isinstance(sf, (int, long, float)):
sf = (sf, sf)
self._stretchfactor = sf
if "outline" in p:
"""Base class for fixers (optional, but recommended)."""
# Python imports
-import logging
import itertools
# Local imports
The main refactoring tool should call this.
"""
self.filename = filename
- self.logger = logging.getLogger(filename)
def match(self, node):
"""Returns match for a given parse tree node.
else:
# A named token (NAME, NUMBER, STRING)
itoken = getattr(token, label, None)
- assert isinstance(itoken, int), label
+ assert isinstance(itoken, (int, long)), label
assert itoken in token.tok_name, label
if itoken in c.tokens:
return c.tokens[itoken]
pass
result = nl_langinfo(CODESET)
setlocale(LC_CTYPE, oldloc)
- return result
else:
- return nl_langinfo(CODESET)
+ result = nl_langinfo(CODESET)
+
+ if not result and sys.platform == 'darwin':
+ # nl_langinfo can return an empty string
+ # when the setting has an invalid value.
+ # Default to UTF-8 in that case because
+ # UTF-8 is the default charset on OSX and
+ # returning nothing will crash the
+ # interpreter.
+ result = 'UTF-8'
+ return result
### Database
logger.log(level, "We have a %s", "mysterious problem", exc_info=1)
"""
- if not isinstance(level, int):
+ if not isinstance(level, (int, long)):
if raiseExceptions:
raise TypeError("level must be an integer")
else:
self.unixsocket = 1
self._connect_unixsocket(address)
else:
- self.unixsocket = 0
+ self.unixsocket = False
if socktype is None:
socktype = socket.SOCK_DGRAM
- self.socket = socket.socket(socket.AF_INET, socktype)
- if socktype == socket.SOCK_STREAM:
- self.socket.connect(address)
+ host, port = address
+ ress = socket.getaddrinfo(host, port, 0, socktype)
+ if not ress:
+ raise socket.error("getaddrinfo returns an empty list")
+ for res in ress:
+ af, socktype, proto, _, sa = res
+ err = sock = None
+ try:
+ sock = socket.socket(af, socktype, proto)
+ if socktype == socket.SOCK_STREAM:
+ sock.connect(sa)
+ break
+ except socket.error as exc:
+ err = exc
+ if sock is not None:
+ sock.close()
+ if err is not None:
+ raise err
+ self.socket = sock
self.socktype = socktype
- self.formatter = None
def _connect_unixsocket(self, address):
use_socktype = self.socktype
priority = self.priority_names[priority]
return (facility << 3) | priority
- def close (self):
+ def close(self):
"""
Closes the socket.
"""
if _logger is not None:
d['log_level'] = _logger.getEffectiveLevel()
- if not WINEXE and not WINSERVICE:
+ if not WINEXE and not WINSERVICE and \
+ not d['sys_argv'][0].lower().endswith('pythonservice.exe'):
main_path = getattr(sys.modules['__main__'], '__file__', None)
if not main_path and sys.argv[0] not in ('', '-c'):
main_path = sys.argv[0]
def worker(inqueue, outqueue, initializer=None, initargs=(), maxtasks=None):
- assert maxtasks is None or (type(maxtasks) == int and maxtasks > 0)
+ assert maxtasks is None or (type(maxtasks) in (int, long) and maxtasks > 0)
put = outqueue.put
get = inqueue.get
if hasattr(inqueue, '_writer'):
debug("Possible encoding error while sending result: %s" % (
wrapped))
put((job, i, (False, wrapped)))
+
+ task = job = result = func = args = kwds = None
completed += 1
debug('worker exiting after %d tasks' % completed)
if set_length:
debug('doing set_length()')
set_length(i+1)
+ finally:
+ task = taskseq = job = None
else:
debug('task handler got sentinel')
-
try:
# tell result handler to finish when cache is empty
debug('task handler sending sentinel to result handler')
cache[job]._set(i, obj)
except KeyError:
pass
+ task = job = obj = None
while cache and thread._state != TERMINATE:
try:
cache[job]._set(i, obj)
except KeyError:
pass
+ task = job = obj = None
if hasattr(outqueue, '_reader'):
debug('ensuring that outqueue is not full')
else:
from .forking import Popen
self._popen = Popen(self)
+ # Avoid a refcycle if the target function holds an indirect
+ # reference to the process object (see bpo-30775)
+ del self._target, self._args, self._kwargs
_current_process._children.add(self)
def terminate(self):
if self is _current_process:
return True
assert self._parent_pid == os.getpid(), 'can only test a child process'
+
if self._popen is None:
return False
- self._popen.poll()
- return self._popen.returncode is None
+
+ returncode = self._popen.poll()
+ if returncode is None:
+ return True
+ else:
+ _current_process._children.discard(self)
+ return False
@property
def name(self):
else:
status = 'started'
- if type(status) is int:
+ if type(status) in (int, long):
if status == 0:
status = 'stopped'
else:
except SystemExit, e:
if not e.args:
exitcode = 1
- elif isinstance(e.args[0], int):
- exitcode = e.args[0]
+ elif isinstance(e.args[0], (int, long)):
+ exitcode = int(e.args[0])
else:
sys.stderr.write(str(e.args[0]) + '\n')
sys.stderr.flush()
try:
if block:
timeout = deadline - time.time()
- if timeout < 0 or not self._poll(timeout):
+ if not self._poll(timeout):
raise Empty
elif not self._poll():
raise Empty
else:
wacquire = None
- try:
- while 1:
+ while 1:
+ try:
nacquire()
try:
if not buffer:
wrelease()
except IndexError:
pass
- except Exception, e:
- # Since this runs in a daemon thread the resources it uses
- # may be become unusable while the process is cleaning up.
- # We ignore errors which happen after the process has
- # started to cleanup.
- try:
+ except Exception as e:
+ # Since this runs in a daemon thread the resources it uses
+ # may be become unusable while the process is cleaning up.
+ # We ignore errors which happen after the process has
+ # started to cleanup.
if is_exiting():
info('error in queue thread: %s', e)
+ return
else:
import traceback
traceback.print_exc()
- except Exception:
- pass
_sentinel = object()
Class which supports object finalization using weakrefs
'''
def __init__(self, obj, callback, args=(), kwargs=None, exitpriority=None):
- assert exitpriority is None or type(exitpriority) is int
+ assert exitpriority is None or type(exitpriority) in (int, long)
if obj is not None:
self._weakref = weakref.ref(obj, self)
else:
f = lambda p : p[0][0] is not None and p[0][0] >= minpriority
+ # Careful: _finalizer_registry may be mutated while this function
+ # is running (either by a GC run or by another thread).
+
items = [x for x in _finalizer_registry.items() if f(x)]
items.sort(reverse=True)
assert isinstance(name, str)
self.name = name
- assert isinstance(n, int) and (n >= 0 or
+ assert isinstance(n, (int, long)) and (n >= 0 or
n in (UP_TO_NEWLINE,
TAKEN_FROM_ARGUMENT1,
TAKEN_FROM_ARGUMENT4))
assert isinstance(x, StackObject)
self.stack_after = stack_after
- assert isinstance(proto, int) and 0 <= proto <= 2
+ assert isinstance(proto, (int, long)) and 0 <= proto <= 2
self.proto = proto
assert isinstance(doc, str)
# -*- coding: utf-8 -*-
-# Autogenerated by Sphinx on Sat Dec 3 12:36:20 2016
-topics = {'assert': u'\nThe "assert" statement\n**********************\n\nAssert statements are a convenient way to insert debugging assertions\ninto a program:\n\n assert_stmt ::= "assert" expression ["," expression]\n\nThe simple form, "assert expression", is equivalent to\n\n if __debug__:\n if not expression: raise AssertionError\n\nThe extended form, "assert expression1, expression2", is equivalent to\n\n if __debug__:\n if not expression1: raise AssertionError(expression2)\n\nThese equivalences assume that "__debug__" and "AssertionError" refer\nto the built-in variables with those names. In the current\nimplementation, the built-in variable "__debug__" is "True" under\nnormal circumstances, "False" when optimization is requested (command\nline option -O). The current code generator emits no code for an\nassert statement when optimization is requested at compile time. Note\nthat it is unnecessary to include the source code for the expression\nthat failed in the error message; it will be displayed as part of the\nstack trace.\n\nAssignments to "__debug__" are illegal. The value for the built-in\nvariable is determined when the interpreter starts.\n',
- 'assignment': u'\nAssignment statements\n*********************\n\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n\n assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)\n target_list ::= target ("," target)* [","]\n target ::= identifier\n | "(" target_list ")"\n | "[" [target_list] "]"\n | attributeref\n | subscription\n | slicing\n\n(See section Primaries for the syntax definitions for the last three\nsymbols.)\n\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\n\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable. The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section The standard type\nhierarchy).\n\nAssignment of an object to a target list is recursively defined as\nfollows.\n\n* If the target list is a single target: The object is assigned to\n that target.\n\n* If the target list is a comma-separated list of targets: The\n object must be an iterable with the same number of items as there\n are targets in the target list, and the items are assigned, from\n left to right, to the corresponding targets.\n\nAssignment of an object to a single target is recursively defined as\nfollows.\n\n* If the target is an identifier (name):\n\n * If the name does not occur in a "global" statement in the\n current code block: the name is bound to the object in the current\n local namespace.\n\n * Otherwise: the name is bound to the object in the current global\n namespace.\n\n The name is rebound if it was already bound. This may cause the\n reference count for the object previously bound to the name to reach\n zero, causing the object to be deallocated and its destructor (if it\n has one) to be called.\n\n* If the target is a target list enclosed in parentheses or in\n square brackets: The object must be an iterable with the same number\n of items as there are targets in the target list, and its items are\n assigned, from left to right, to the corresponding targets.\n\n* If the target is an attribute reference: The primary expression in\n the reference is evaluated. It should yield an object with\n assignable attributes; if this is not the case, "TypeError" is\n raised. That object is then asked to assign the assigned object to\n the given attribute; if it cannot perform the assignment, it raises\n an exception (usually but not necessarily "AttributeError").\n\n Note: If the object is a class instance and the attribute reference\n occurs on both sides of the assignment operator, the RHS expression,\n "a.x" can access either an instance attribute or (if no instance\n attribute exists) a class attribute. The LHS target "a.x" is always\n set as an instance attribute, creating it if necessary. Thus, the\n two occurrences of "a.x" do not necessarily refer to the same\n attribute: if the RHS expression refers to a class attribute, the\n LHS creates a new instance attribute as the target of the\n assignment:\n\n class Cls:\n x = 3 # class variable\n inst = Cls()\n inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3\n\n This description does not necessarily apply to descriptor\n attributes, such as properties created with "property()".\n\n* If the target is a subscription: The primary expression in the\n reference is evaluated. It should yield either a mutable sequence\n object (such as a list) or a mapping object (such as a dictionary).\n Next, the subscript expression is evaluated.\n\n If the primary is a mutable sequence object (such as a list), the\n subscript must yield a plain integer. If it is negative, the\n sequence\'s length is added to it. The resulting value must be a\n nonnegative integer less than the sequence\'s length, and the\n sequence is asked to assign the assigned object to its item with\n that index. If the index is out of range, "IndexError" is raised\n (assignment to a subscripted sequence cannot add new items to a\n list).\n\n If the primary is a mapping object (such as a dictionary), the\n subscript must have a type compatible with the mapping\'s key type,\n and the mapping is then asked to create a key/datum pair which maps\n the subscript to the assigned object. This can either replace an\n existing key/value pair with the same key value, or insert a new\n key/value pair (if no key with the same value existed).\n\n* If the target is a slicing: The primary expression in the\n reference is evaluated. It should yield a mutable sequence object\n (such as a list). The assigned object should be a sequence object\n of the same type. Next, the lower and upper bound expressions are\n evaluated, insofar they are present; defaults are zero and the\n sequence\'s length. The bounds should evaluate to (small) integers.\n If either bound is negative, the sequence\'s length is added to it.\n The resulting bounds are clipped to lie between zero and the\n sequence\'s length, inclusive. Finally, the sequence object is asked\n to replace the slice with the items of the assigned sequence. The\n length of the slice may be different from the length of the assigned\n sequence, thus changing the length of the target sequence, if the\n object allows it.\n\n**CPython implementation detail:** In the current implementation, the\nsyntax for targets is taken to be the same as for expressions, and\ninvalid syntax is rejected during the code generation phase, causing\nless detailed error messages.\n\nWARNING: Although the definition of assignment implies that overlaps\nbetween the left-hand side and the right-hand side are \'safe\' (for\nexample "a, b = b, a" swaps two variables), overlaps *within* the\ncollection of assigned-to variables are not safe! For instance, the\nfollowing program prints "[0, 2]":\n\n x = [0, 1]\n i = 0\n i, x[i] = 1, 2\n print x\n\n\nAugmented assignment statements\n===============================\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n augtarget ::= identifier | attributeref | subscription | slicing\n augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="\n | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section Primaries for the syntax definitions for the last three\nsymbols.)\n\nAn augmented assignment evaluates the target (which, unlike normal\nassignment statements, cannot be an unpacking) and the expression\nlist, performs the binary operation specific to the type of assignment\non the two operands, and assigns the result to the original target.\nThe target is only evaluated once.\n\nAn augmented assignment expression like "x += 1" can be rewritten as\n"x = x + 1" to achieve a similar, but not exactly equal effect. In the\naugmented version, "x" is only evaluated once. Also, when possible,\nthe actual operation is performed *in-place*, meaning that rather than\ncreating a new object and assigning that to the target, the old object\nis modified instead.\n\nWith the exception of assigning to tuples and multiple targets in a\nsingle statement, the assignment done by augmented assignment\nstatements is handled the same way as normal assignments. Similarly,\nwith the exception of the possible *in-place* behavior, the binary\noperation performed by augmented assignment is the same as the normal\nbinary operations.\n\nFor targets which are attribute references, the same caveat about\nclass and instance attributes applies as for regular assignments.\n',
- 'atom-identifiers': u'\nIdentifiers (Names)\n*******************\n\nAn identifier occurring as an atom is a name. See section Identifiers\nand keywords for lexical definition and section Naming and binding for\ndocumentation of naming and binding.\n\nWhen the name is bound to an object, evaluation of the atom yields\nthat object. When a name is not bound, an attempt to evaluate it\nraises a "NameError" exception.\n\n**Private name mangling:** When an identifier that textually occurs in\na class definition begins with two or more underscore characters and\ndoes not end in two or more underscores, it is considered a *private\nname* of that class. Private names are transformed to a longer form\nbefore code is generated for them. The transformation inserts the\nclass name, with leading underscores removed and a single underscore\ninserted, in front of the name. For example, the identifier "__spam"\noccurring in a class named "Ham" will be transformed to "_Ham__spam".\nThis transformation is independent of the syntactical context in which\nthe identifier is used. If the transformed name is extremely long\n(longer than 255 characters), implementation defined truncation may\nhappen. If the class name consists only of underscores, no\ntransformation is done.\n',
- 'atom-literals': u"\nLiterals\n********\n\nPython supports string literals and various numeric literals:\n\n literal ::= stringliteral | integer | longinteger\n | floatnumber | imagnumber\n\nEvaluation of a literal yields an object of the given type (string,\ninteger, long integer, floating point number, complex number) with the\ngiven value. The value may be approximated in the case of floating\npoint and imaginary (complex) literals. See section Literals for\ndetails.\n\nAll literals correspond to immutable data types, and hence the\nobject's identity is less important than its value. Multiple\nevaluations of literals with the same value (either the same\noccurrence in the program text or a different occurrence) may obtain\nthe same object or a different object with the same value.\n",
- 'attribute-access': u'\nCustomizing attribute access\n****************************\n\nThe following methods can be defined to customize the meaning of\nattribute access (use of, assignment to, or deletion of "x.name") for\nclass instances.\n\nobject.__getattr__(self, name)\n\n Called when an attribute lookup has not found the attribute in the\n usual places (i.e. it is not an instance attribute nor is it found\n in the class tree for "self"). "name" is the attribute name. This\n method should return the (computed) attribute value or raise an\n "AttributeError" exception.\n\n Note that if the attribute is found through the normal mechanism,\n "__getattr__()" is not called. (This is an intentional asymmetry\n between "__getattr__()" and "__setattr__()".) This is done both for\n efficiency reasons and because otherwise "__getattr__()" would have\n no way to access other attributes of the instance. Note that at\n least for instance variables, you can fake total control by not\n inserting any values in the instance attribute dictionary (but\n instead inserting them in another object). See the\n "__getattribute__()" method below for a way to actually get total\n control in new-style classes.\n\nobject.__setattr__(self, name, value)\n\n Called when an attribute assignment is attempted. This is called\n instead of the normal mechanism (i.e. store the value in the\n instance dictionary). *name* is the attribute name, *value* is the\n value to be assigned to it.\n\n If "__setattr__()" wants to assign to an instance attribute, it\n should not simply execute "self.name = value" --- this would cause\n a recursive call to itself. Instead, it should insert the value in\n the dictionary of instance attributes, e.g., "self.__dict__[name] =\n value". For new-style classes, rather than accessing the instance\n dictionary, it should call the base class method with the same\n name, for example, "object.__setattr__(self, name, value)".\n\nobject.__delattr__(self, name)\n\n Like "__setattr__()" but for attribute deletion instead of\n assignment. This should only be implemented if "del obj.name" is\n meaningful for the object.\n\n\nMore attribute access for new-style classes\n===========================================\n\nThe following methods only apply to new-style classes.\n\nobject.__getattribute__(self, name)\n\n Called unconditionally to implement attribute accesses for\n instances of the class. If the class also defines "__getattr__()",\n the latter will not be called unless "__getattribute__()" either\n calls it explicitly or raises an "AttributeError". This method\n should return the (computed) attribute value or raise an\n "AttributeError" exception. In order to avoid infinite recursion in\n this method, its implementation should always call the base class\n method with the same name to access any attributes it needs, for\n example, "object.__getattribute__(self, name)".\n\n Note: This method may still be bypassed when looking up special\n methods as the result of implicit invocation via language syntax\n or built-in functions. See Special method lookup for new-style\n classes.\n\n\nImplementing Descriptors\n========================\n\nThe following methods only apply when an instance of the class\ncontaining the method (a so-called *descriptor* class) appears in an\n*owner* class (the descriptor must be in either the owner\'s class\ndictionary or in the class dictionary for one of its parents). In the\nexamples below, "the attribute" refers to the attribute whose name is\nthe key of the property in the owner class\' "__dict__".\n\nobject.__get__(self, instance, owner)\n\n Called to get the attribute of the owner class (class attribute\n access) or of an instance of that class (instance attribute\n access). *owner* is always the owner class, while *instance* is the\n instance that the attribute was accessed through, or "None" when\n the attribute is accessed through the *owner*. This method should\n return the (computed) attribute value or raise an "AttributeError"\n exception.\n\nobject.__set__(self, instance, value)\n\n Called to set the attribute on an instance *instance* of the owner\n class to a new value, *value*.\n\nobject.__delete__(self, instance)\n\n Called to delete the attribute on an instance *instance* of the\n owner class.\n\n\nInvoking Descriptors\n====================\n\nIn general, a descriptor is an object attribute with "binding\nbehavior", one whose attribute access has been overridden by methods\nin the descriptor protocol: "__get__()", "__set__()", and\n"__delete__()". If any of those methods are defined for an object, it\nis said to be a descriptor.\n\nThe default behavior for attribute access is to get, set, or delete\nthe attribute from an object\'s dictionary. For instance, "a.x" has a\nlookup chain starting with "a.__dict__[\'x\']", then\n"type(a).__dict__[\'x\']", and continuing through the base classes of\n"type(a)" excluding metaclasses.\n\nHowever, if the looked-up value is an object defining one of the\ndescriptor methods, then Python may override the default behavior and\ninvoke the descriptor method instead. Where this occurs in the\nprecedence chain depends on which descriptor methods were defined and\nhow they were called. Note that descriptors are only invoked for new\nstyle objects or classes (ones that subclass "object()" or "type()").\n\nThe starting point for descriptor invocation is a binding, "a.x". How\nthe arguments are assembled depends on "a":\n\nDirect Call\n The simplest and least common call is when user code directly\n invokes a descriptor method: "x.__get__(a)".\n\nInstance Binding\n If binding to a new-style object instance, "a.x" is transformed\n into the call: "type(a).__dict__[\'x\'].__get__(a, type(a))".\n\nClass Binding\n If binding to a new-style class, "A.x" is transformed into the\n call: "A.__dict__[\'x\'].__get__(None, A)".\n\nSuper Binding\n If "a" is an instance of "super", then the binding "super(B,\n obj).m()" searches "obj.__class__.__mro__" for the base class "A"\n immediately preceding "B" and then invokes the descriptor with the\n call: "A.__dict__[\'m\'].__get__(obj, obj.__class__)".\n\nFor instance bindings, the precedence of descriptor invocation depends\non the which descriptor methods are defined. A descriptor can define\nany combination of "__get__()", "__set__()" and "__delete__()". If it\ndoes not define "__get__()", then accessing the attribute will return\nthe descriptor object itself unless there is a value in the object\'s\ninstance dictionary. If the descriptor defines "__set__()" and/or\n"__delete__()", it is a data descriptor; if it defines neither, it is\na non-data descriptor. Normally, data descriptors define both\n"__get__()" and "__set__()", while non-data descriptors have just the\n"__get__()" method. Data descriptors with "__set__()" and "__get__()"\ndefined always override a redefinition in an instance dictionary. In\ncontrast, non-data descriptors can be overridden by instances.\n\nPython methods (including "staticmethod()" and "classmethod()") are\nimplemented as non-data descriptors. Accordingly, instances can\nredefine and override methods. This allows individual instances to\nacquire behaviors that differ from other instances of the same class.\n\nThe "property()" function is implemented as a data descriptor.\nAccordingly, instances cannot override the behavior of a property.\n\n\n__slots__\n=========\n\nBy default, instances of both old and new-style classes have a\ndictionary for attribute storage. This wastes space for objects\nhaving very few instance variables. The space consumption can become\nacute when creating large numbers of instances.\n\nThe default can be overridden by defining *__slots__* in a new-style\nclass definition. The *__slots__* declaration takes a sequence of\ninstance variables and reserves just enough space in each instance to\nhold a value for each variable. Space is saved because *__dict__* is\nnot created for each instance.\n\n__slots__\n\n This class variable can be assigned a string, iterable, or sequence\n of strings with variable names used by instances. If defined in a\n new-style class, *__slots__* reserves space for the declared\n variables and prevents the automatic creation of *__dict__* and\n *__weakref__* for each instance.\n\n New in version 2.2.\n\nNotes on using *__slots__*\n\n* When inheriting from a class without *__slots__*, the *__dict__*\n attribute of that class will always be accessible, so a *__slots__*\n definition in the subclass is meaningless.\n\n* Without a *__dict__* variable, instances cannot be assigned new\n variables not listed in the *__slots__* definition. Attempts to\n assign to an unlisted variable name raises "AttributeError". If\n dynamic assignment of new variables is desired, then add\n "\'__dict__\'" to the sequence of strings in the *__slots__*\n declaration.\n\n Changed in version 2.3: Previously, adding "\'__dict__\'" to the\n *__slots__* declaration would not enable the assignment of new\n attributes not specifically listed in the sequence of instance\n variable names.\n\n* Without a *__weakref__* variable for each instance, classes\n defining *__slots__* do not support weak references to its\n instances. If weak reference support is needed, then add\n "\'__weakref__\'" to the sequence of strings in the *__slots__*\n declaration.\n\n Changed in version 2.3: Previously, adding "\'__weakref__\'" to the\n *__slots__* declaration would not enable support for weak\n references.\n\n* *__slots__* are implemented at the class level by creating\n descriptors (Implementing Descriptors) for each variable name. As a\n result, class attributes cannot be used to set default values for\n instance variables defined by *__slots__*; otherwise, the class\n attribute would overwrite the descriptor assignment.\n\n* The action of a *__slots__* declaration is limited to the class\n where it is defined. As a result, subclasses will have a *__dict__*\n unless they also define *__slots__* (which must only contain names\n of any *additional* slots).\n\n* If a class defines a slot also defined in a base class, the\n instance variable defined by the base class slot is inaccessible\n (except by retrieving its descriptor directly from the base class).\n This renders the meaning of the program undefined. In the future, a\n check may be added to prevent this.\n\n* Nonempty *__slots__* does not work for classes derived from\n "variable-length" built-in types such as "long", "str" and "tuple".\n\n* Any non-string iterable may be assigned to *__slots__*. Mappings\n may also be used; however, in the future, special meaning may be\n assigned to the values corresponding to each key.\n\n* *__class__* assignment works only if both classes have the same\n *__slots__*.\n\n Changed in version 2.6: Previously, *__class__* assignment raised an\n error if either new or old class had *__slots__*.\n',
- 'attribute-references': u'\nAttribute references\n********************\n\nAn attribute reference is a primary followed by a period and a name:\n\n attributeref ::= primary "." identifier\n\nThe primary must evaluate to an object of a type that supports\nattribute references, e.g., a module, list, or an instance. This\nobject is then asked to produce the attribute whose name is the\nidentifier. If this attribute is not available, the exception\n"AttributeError" is raised. Otherwise, the type and value of the\nobject produced is determined by the object. Multiple evaluations of\nthe same attribute reference may yield different objects.\n',
- 'augassign': u'\nAugmented assignment statements\n*******************************\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n augtarget ::= identifier | attributeref | subscription | slicing\n augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="\n | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section Primaries for the syntax definitions for the last three\nsymbols.)\n\nAn augmented assignment evaluates the target (which, unlike normal\nassignment statements, cannot be an unpacking) and the expression\nlist, performs the binary operation specific to the type of assignment\non the two operands, and assigns the result to the original target.\nThe target is only evaluated once.\n\nAn augmented assignment expression like "x += 1" can be rewritten as\n"x = x + 1" to achieve a similar, but not exactly equal effect. In the\naugmented version, "x" is only evaluated once. Also, when possible,\nthe actual operation is performed *in-place*, meaning that rather than\ncreating a new object and assigning that to the target, the old object\nis modified instead.\n\nWith the exception of assigning to tuples and multiple targets in a\nsingle statement, the assignment done by augmented assignment\nstatements is handled the same way as normal assignments. Similarly,\nwith the exception of the possible *in-place* behavior, the binary\noperation performed by augmented assignment is the same as the normal\nbinary operations.\n\nFor targets which are attribute references, the same caveat about\nclass and instance attributes applies as for regular assignments.\n',
- 'binary': u'\nBinary arithmetic operations\n****************************\n\nThe binary arithmetic operations have the conventional priority\nlevels. Note that some of these operations also apply to certain non-\nnumeric types. Apart from the power operator, there are only two\nlevels, one for multiplicative operators and one for additive\noperators:\n\n m_expr ::= u_expr | m_expr "*" u_expr | m_expr "//" u_expr | m_expr "/" u_expr\n | m_expr "%" u_expr\n a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr\n\nThe "*" (multiplication) operator yields the product of its arguments.\nThe arguments must either both be numbers, or one argument must be an\ninteger (plain or long) and the other must be a sequence. In the\nformer case, the numbers are converted to a common type and then\nmultiplied together. In the latter case, sequence repetition is\nperformed; a negative repetition factor yields an empty sequence.\n\nThe "/" (division) and "//" (floor division) operators yield the\nquotient of their arguments. The numeric arguments are first\nconverted to a common type. Plain or long integer division yields an\ninteger of the same type; the result is that of mathematical division\nwith the \'floor\' function applied to the result. Division by zero\nraises the "ZeroDivisionError" exception.\n\nThe "%" (modulo) operator yields the remainder from the division of\nthe first argument by the second. The numeric arguments are first\nconverted to a common type. A zero right argument raises the\n"ZeroDivisionError" exception. The arguments may be floating point\nnumbers, e.g., "3.14%0.7" equals "0.34" (since "3.14" equals "4*0.7 +\n0.34".) The modulo operator always yields a result with the same sign\nas its second operand (or zero); the absolute value of the result is\nstrictly smaller than the absolute value of the second operand [2].\n\nThe integer division and modulo operators are connected by the\nfollowing identity: "x == (x/y)*y + (x%y)". Integer division and\nmodulo are also connected with the built-in function "divmod()":\n"divmod(x, y) == (x/y, x%y)". These identities don\'t hold for\nfloating point numbers; there similar identities hold approximately\nwhere "x/y" is replaced by "floor(x/y)" or "floor(x/y) - 1" [3].\n\nIn addition to performing the modulo operation on numbers, the "%"\noperator is also overloaded by string and unicode objects to perform\nstring formatting (also known as interpolation). The syntax for string\nformatting is described in the Python Library Reference, section\nString Formatting Operations.\n\nDeprecated since version 2.3: The floor division operator, the modulo\noperator, and the "divmod()" function are no longer defined for\ncomplex numbers. Instead, convert to a floating point number using\nthe "abs()" function if appropriate.\n\nThe "+" (addition) operator yields the sum of its arguments. The\narguments must either both be numbers or both sequences of the same\ntype. In the former case, the numbers are converted to a common type\nand then added together. In the latter case, the sequences are\nconcatenated.\n\nThe "-" (subtraction) operator yields the difference of its arguments.\nThe numeric arguments are first converted to a common type.\n',
- 'bitwise': u'\nBinary bitwise operations\n*************************\n\nEach of the three bitwise operations has a different priority level:\n\n and_expr ::= shift_expr | and_expr "&" shift_expr\n xor_expr ::= and_expr | xor_expr "^" and_expr\n or_expr ::= xor_expr | or_expr "|" xor_expr\n\nThe "&" operator yields the bitwise AND of its arguments, which must\nbe plain or long integers. The arguments are converted to a common\ntype.\n\nThe "^" operator yields the bitwise XOR (exclusive OR) of its\narguments, which must be plain or long integers. The arguments are\nconverted to a common type.\n\nThe "|" operator yields the bitwise (inclusive) OR of its arguments,\nwhich must be plain or long integers. The arguments are converted to\na common type.\n',
- 'bltin-code-objects': u'\nCode Objects\n************\n\nCode objects are used by the implementation to represent "pseudo-\ncompiled" executable Python code such as a function body. They differ\nfrom function objects because they don\'t contain a reference to their\nglobal execution environment. Code objects are returned by the built-\nin "compile()" function and can be extracted from function objects\nthrough their "func_code" attribute. See also the "code" module.\n\nA code object can be executed or evaluated by passing it (instead of a\nsource string) to the "exec" statement or the built-in "eval()"\nfunction.\n\nSee The standard type hierarchy for more information.\n',
- 'bltin-ellipsis-object': u'\nThe Ellipsis Object\n*******************\n\nThis object is used by extended slice notation (see Slicings). It\nsupports no special operations. There is exactly one ellipsis object,\nnamed "Ellipsis" (a built-in name).\n\nIt is written as "Ellipsis". When in a subscript, it can also be\nwritten as "...", for example "seq[...]".\n',
- 'bltin-file-objects': u'\nFile Objects\n************\n\nFile objects are implemented using C\'s "stdio" package and can be\ncreated with the built-in "open()" function. File objects are also\nreturned by some other built-in functions and methods, such as\n"os.popen()" and "os.fdopen()" and the "makefile()" method of socket\nobjects. Temporary files can be created using the "tempfile" module,\nand high-level file operations such as copying, moving, and deleting\nfiles and directories can be achieved with the "shutil" module.\n\nWhen a file operation fails for an I/O-related reason, the exception\n"IOError" is raised. This includes situations where the operation is\nnot defined for some reason, like "seek()" on a tty device or writing\na file opened for reading.\n\nFiles have the following methods:\n\nfile.close()\n\n Close the file. A closed file cannot be read or written any more.\n Any operation which requires that the file be open will raise a\n "ValueError" after the file has been closed. Calling "close()"\n more than once is allowed.\n\n As of Python 2.5, you can avoid having to call this method\n explicitly if you use the "with" statement. For example, the\n following code will automatically close *f* when the "with" block\n is exited:\n\n from __future__ import with_statement # This isn\'t required in Python 2.6\n\n with open("hello.txt") as f:\n for line in f:\n print line,\n\n In older versions of Python, you would have needed to do this to\n get the same effect:\n\n f = open("hello.txt")\n try:\n for line in f:\n print line,\n finally:\n f.close()\n\n Note: Not all "file-like" types in Python support use as a\n context manager for the "with" statement. If your code is\n intended to work with any file-like object, you can use the\n function "contextlib.closing()" instead of using the object\n directly.\n\nfile.flush()\n\n Flush the internal buffer, like "stdio"\'s "fflush()". This may be\n a no-op on some file-like objects.\n\n Note: "flush()" does not necessarily write the file\'s data to\n disk. Use "flush()" followed by "os.fsync()" to ensure this\n behavior.\n\nfile.fileno()\n\n Return the integer "file descriptor" that is used by the underlying\n implementation to request I/O operations from the operating system.\n This can be useful for other, lower level interfaces that use file\n descriptors, such as the "fcntl" module or "os.read()" and friends.\n\n Note: File-like objects which do not have a real file descriptor\n should *not* provide this method!\n\nfile.isatty()\n\n Return "True" if the file is connected to a tty(-like) device, else\n "False".\n\n Note: If a file-like object is not associated with a real file,\n this method should *not* be implemented.\n\nfile.next()\n\n A file object is its own iterator, for example "iter(f)" returns\n *f* (unless *f* is closed). When a file is used as an iterator,\n typically in a "for" loop (for example, "for line in f: print\n line.strip()"), the "next()" method is called repeatedly. This\n method returns the next input line, or raises "StopIteration" when\n EOF is hit when the file is open for reading (behavior is undefined\n when the file is open for writing). In order to make a "for" loop\n the most efficient way of looping over the lines of a file (a very\n common operation), the "next()" method uses a hidden read-ahead\n buffer. As a consequence of using a read-ahead buffer, combining\n "next()" with other file methods (like "readline()") does not work\n right. However, using "seek()" to reposition the file to an\n absolute position will flush the read-ahead buffer.\n\n New in version 2.3.\n\nfile.read([size])\n\n Read at most *size* bytes from the file (less if the read hits EOF\n before obtaining *size* bytes). If the *size* argument is negative\n or omitted, read all data until EOF is reached. The bytes are\n returned as a string object. An empty string is returned when EOF\n is encountered immediately. (For certain files, like ttys, it\n makes sense to continue reading after an EOF is hit.) Note that\n this method may call the underlying C function "fread()" more than\n once in an effort to acquire as close to *size* bytes as possible.\n Also note that when in non-blocking mode, less data than was\n requested may be returned, even if no *size* parameter was given.\n\n Note: This function is simply a wrapper for the underlying\n "fread()" C function, and will behave the same in corner cases,\n such as whether the EOF value is cached.\n\nfile.readline([size])\n\n Read one entire line from the file. A trailing newline character\n is kept in the string (but may be absent when a file ends with an\n incomplete line). [6] If the *size* argument is present and non-\n negative, it is a maximum byte count (including the trailing\n newline) and an incomplete line may be returned. When *size* is not\n 0, an empty string is returned *only* when EOF is encountered\n immediately.\n\n Note: Unlike "stdio"\'s "fgets()", the returned string contains\n null characters ("\'\\0\'") if they occurred in the input.\n\nfile.readlines([sizehint])\n\n Read until EOF using "readline()" and return a list containing the\n lines thus read. If the optional *sizehint* argument is present,\n instead of reading up to EOF, whole lines totalling approximately\n *sizehint* bytes (possibly after rounding up to an internal buffer\n size) are read. Objects implementing a file-like interface may\n choose to ignore *sizehint* if it cannot be implemented, or cannot\n be implemented efficiently.\n\nfile.xreadlines()\n\n This method returns the same thing as "iter(f)".\n\n New in version 2.1.\n\n Deprecated since version 2.3: Use "for line in file" instead.\n\nfile.seek(offset[, whence])\n\n Set the file\'s current position, like "stdio"\'s "fseek()". The\n *whence* argument is optional and defaults to "os.SEEK_SET" or "0"\n (absolute file positioning); other values are "os.SEEK_CUR" or "1"\n (seek relative to the current position) and "os.SEEK_END" or "2"\n (seek relative to the file\'s end). There is no return value.\n\n For example, "f.seek(2, os.SEEK_CUR)" advances the position by two\n and "f.seek(-3, os.SEEK_END)" sets the position to the third to\n last.\n\n Note that if the file is opened for appending (mode "\'a\'" or\n "\'a+\'"), any "seek()" operations will be undone at the next write.\n If the file is only opened for writing in append mode (mode "\'a\'"),\n this method is essentially a no-op, but it remains useful for files\n opened in append mode with reading enabled (mode "\'a+\'"). If the\n file is opened in text mode (without "\'b\'"), only offsets returned\n by "tell()" are legal. Use of other offsets causes undefined\n behavior.\n\n Note that not all file objects are seekable.\n\n Changed in version 2.6: Passing float values as offset has been\n deprecated.\n\nfile.tell()\n\n Return the file\'s current position, like "stdio"\'s "ftell()".\n\n Note: On Windows, "tell()" can return illegal values (after an\n "fgets()") when reading files with Unix-style line-endings. Use\n binary mode ("\'rb\'") to circumvent this problem.\n\nfile.truncate([size])\n\n Truncate the file\'s size. If the optional *size* argument is\n present, the file is truncated to (at most) that size. The size\n defaults to the current position. The current file position is not\n changed. Note that if a specified size exceeds the file\'s current\n size, the result is platform-dependent: possibilities include that\n the file may remain unchanged, increase to the specified size as if\n zero-filled, or increase to the specified size with undefined new\n content. Availability: Windows, many Unix variants.\n\nfile.write(str)\n\n Write a string to the file. There is no return value. Due to\n buffering, the string may not actually show up in the file until\n the "flush()" or "close()" method is called.\n\nfile.writelines(sequence)\n\n Write a sequence of strings to the file. The sequence can be any\n iterable object producing strings, typically a list of strings.\n There is no return value. (The name is intended to match\n "readlines()"; "writelines()" does not add line separators.)\n\nFiles support the iterator protocol. Each iteration returns the same\nresult as "readline()", and iteration ends when the "readline()"\nmethod returns an empty string.\n\nFile objects also offer a number of other interesting attributes.\nThese are not required for file-like objects, but should be\nimplemented if they make sense for the particular object.\n\nfile.closed\n\n bool indicating the current state of the file object. This is a\n read-only attribute; the "close()" method changes the value. It may\n not be available on all file-like objects.\n\nfile.encoding\n\n The encoding that this file uses. When Unicode strings are written\n to a file, they will be converted to byte strings using this\n encoding. In addition, when the file is connected to a terminal,\n the attribute gives the encoding that the terminal is likely to use\n (that information might be incorrect if the user has misconfigured\n the terminal). The attribute is read-only and may not be present\n on all file-like objects. It may also be "None", in which case the\n file uses the system default encoding for converting Unicode\n strings.\n\n New in version 2.3.\n\nfile.errors\n\n The Unicode error handler used along with the encoding.\n\n New in version 2.6.\n\nfile.mode\n\n The I/O mode for the file. If the file was created using the\n "open()" built-in function, this will be the value of the *mode*\n parameter. This is a read-only attribute and may not be present on\n all file-like objects.\n\nfile.name\n\n If the file object was created using "open()", the name of the\n file. Otherwise, some string that indicates the source of the file\n object, of the form "<...>". This is a read-only attribute and may\n not be present on all file-like objects.\n\nfile.newlines\n\n If Python was built with *universal newlines* enabled (the default)\n this read-only attribute exists, and for files opened in universal\n newline read mode it keeps track of the types of newlines\n encountered while reading the file. The values it can take are\n "\'\\r\'", "\'\\n\'", "\'\\r\\n\'", "None" (unknown, no newlines read yet) or\n a tuple containing all the newline types seen, to indicate that\n multiple newline conventions were encountered. For files not opened\n in universal newlines read mode the value of this attribute will be\n "None".\n\nfile.softspace\n\n Boolean that indicates whether a space character needs to be\n printed before another value when using the "print" statement.\n Classes that are trying to simulate a file object should also have\n a writable "softspace" attribute, which should be initialized to\n zero. This will be automatic for most classes implemented in\n Python (care may be needed for objects that override attribute\n access); types implemented in C will have to provide a writable\n "softspace" attribute.\n\n Note: This attribute is not used to control the "print"\n statement, but to allow the implementation of "print" to keep\n track of its internal state.\n',
- 'bltin-null-object': u'\nThe Null Object\n***************\n\nThis object is returned by functions that don\'t explicitly return a\nvalue. It supports no special operations. There is exactly one null\nobject, named "None" (a built-in name).\n\nIt is written as "None".\n',
- 'bltin-type-objects': u'\nType Objects\n************\n\nType objects represent the various object types. An object\'s type is\naccessed by the built-in function "type()". There are no special\noperations on types. The standard module "types" defines names for\nall standard built-in types.\n\nTypes are written like this: "<type \'int\'>".\n',
- 'booleans': u'\nBoolean operations\n******************\n\n or_test ::= and_test | or_test "or" and_test\n and_test ::= not_test | and_test "and" not_test\n not_test ::= comparison | "not" not_test\n\nIn the context of Boolean operations, and also when expressions are\nused by control flow statements, the following values are interpreted\nas false: "False", "None", numeric zero of all types, and empty\nstrings and containers (including strings, tuples, lists,\ndictionaries, sets and frozensets). All other values are interpreted\nas true. (See the "__nonzero__()" special method for a way to change\nthis.)\n\nThe operator "not" yields "True" if its argument is false, "False"\notherwise.\n\nThe expression "x and y" first evaluates *x*; if *x* is false, its\nvalue is returned; otherwise, *y* is evaluated and the resulting value\nis returned.\n\nThe expression "x or y" first evaluates *x*; if *x* is true, its value\nis returned; otherwise, *y* is evaluated and the resulting value is\nreturned.\n\n(Note that neither "and" nor "or" restrict the value and type they\nreturn to "False" and "True", but rather return the last evaluated\nargument. This is sometimes useful, e.g., if "s" is a string that\nshould be replaced by a default value if it is empty, the expression\n"s or \'foo\'" yields the desired value. Because "not" has to invent a\nvalue anyway, it does not bother to return a value of the same type as\nits argument, so e.g., "not \'foo\'" yields "False", not "\'\'".)\n',
- 'break': u'\nThe "break" statement\n*********************\n\n break_stmt ::= "break"\n\n"break" may only occur syntactically nested in a "for" or "while"\nloop, but not nested in a function or class definition within that\nloop.\n\nIt terminates the nearest enclosing loop, skipping the optional "else"\nclause if the loop has one.\n\nIf a "for" loop is terminated by "break", the loop control target\nkeeps its current value.\n\nWhen "break" passes control out of a "try" statement with a "finally"\nclause, that "finally" clause is executed before really leaving the\nloop.\n',
- 'callable-types': u'\nEmulating callable objects\n**************************\n\nobject.__call__(self[, args...])\n\n Called when the instance is "called" as a function; if this method\n is defined, "x(arg1, arg2, ...)" is a shorthand for\n "x.__call__(arg1, arg2, ...)".\n',
- 'calls': u'\nCalls\n*****\n\nA call calls a callable object (e.g., a *function*) with a possibly\nempty series of *arguments*:\n\n call ::= primary "(" [argument_list [","]\n | expression genexpr_for] ")"\n argument_list ::= positional_arguments ["," keyword_arguments]\n ["," "*" expression] ["," keyword_arguments]\n ["," "**" expression]\n | keyword_arguments ["," "*" expression]\n ["," "**" expression]\n | "*" expression ["," keyword_arguments] ["," "**" expression]\n | "**" expression\n positional_arguments ::= expression ("," expression)*\n keyword_arguments ::= keyword_item ("," keyword_item)*\n keyword_item ::= identifier "=" expression\n\nA trailing comma may be present after the positional and keyword\narguments but does not affect the semantics.\n\nThe primary must evaluate to a callable object (user-defined\nfunctions, built-in functions, methods of built-in objects, class\nobjects, methods of class instances, and certain class instances\nthemselves are callable; extensions may define additional callable\nobject types). All argument expressions are evaluated before the call\nis attempted. Please refer to section Function definitions for the\nsyntax of formal *parameter* lists.\n\nIf keyword arguments are present, they are first converted to\npositional arguments, as follows. First, a list of unfilled slots is\ncreated for the formal parameters. If there are N positional\narguments, they are placed in the first N slots. Next, for each\nkeyword argument, the identifier is used to determine the\ncorresponding slot (if the identifier is the same as the first formal\nparameter name, the first slot is used, and so on). If the slot is\nalready filled, a "TypeError" exception is raised. Otherwise, the\nvalue of the argument is placed in the slot, filling it (even if the\nexpression is "None", it fills the slot). When all arguments have\nbeen processed, the slots that are still unfilled are filled with the\ncorresponding default value from the function definition. (Default\nvalues are calculated, once, when the function is defined; thus, a\nmutable object such as a list or dictionary used as default value will\nbe shared by all calls that don\'t specify an argument value for the\ncorresponding slot; this should usually be avoided.) If there are any\nunfilled slots for which no default value is specified, a "TypeError"\nexception is raised. Otherwise, the list of filled slots is used as\nthe argument list for the call.\n\n**CPython implementation detail:** An implementation may provide\nbuilt-in functions whose positional parameters do not have names, even\nif they are \'named\' for the purpose of documentation, and which\ntherefore cannot be supplied by keyword. In CPython, this is the case\nfor functions implemented in C that use "PyArg_ParseTuple()" to parse\ntheir arguments.\n\nIf there are more positional arguments than there are formal parameter\nslots, a "TypeError" exception is raised, unless a formal parameter\nusing the syntax "*identifier" is present; in this case, that formal\nparameter receives a tuple containing the excess positional arguments\n(or an empty tuple if there were no excess positional arguments).\n\nIf any keyword argument does not correspond to a formal parameter\nname, a "TypeError" exception is raised, unless a formal parameter\nusing the syntax "**identifier" is present; in this case, that formal\nparameter receives a dictionary containing the excess keyword\narguments (using the keywords as keys and the argument values as\ncorresponding values), or a (new) empty dictionary if there were no\nexcess keyword arguments.\n\nIf the syntax "*expression" appears in the function call, "expression"\nmust evaluate to an iterable. Elements from this iterable are treated\nas if they were additional positional arguments; if there are\npositional arguments *x1*, ..., *xN*, and "expression" evaluates to a\nsequence *y1*, ..., *yM*, this is equivalent to a call with M+N\npositional arguments *x1*, ..., *xN*, *y1*, ..., *yM*.\n\nA consequence of this is that although the "*expression" syntax may\nappear *after* some keyword arguments, it is processed *before* the\nkeyword arguments (and the "**expression" argument, if any -- see\nbelow). So:\n\n >>> def f(a, b):\n ... print a, b\n ...\n >>> f(b=1, *(2,))\n 2 1\n >>> f(a=1, *(2,))\n Traceback (most recent call last):\n File "<stdin>", line 1, in ?\n TypeError: f() got multiple values for keyword argument \'a\'\n >>> f(1, *(2,))\n 1 2\n\nIt is unusual for both keyword arguments and the "*expression" syntax\nto be used in the same call, so in practice this confusion does not\narise.\n\nIf the syntax "**expression" appears in the function call,\n"expression" must evaluate to a mapping, the contents of which are\ntreated as additional keyword arguments. In the case of a keyword\nappearing in both "expression" and as an explicit keyword argument, a\n"TypeError" exception is raised.\n\nFormal parameters using the syntax "*identifier" or "**identifier"\ncannot be used as positional argument slots or as keyword argument\nnames. Formal parameters using the syntax "(sublist)" cannot be used\nas keyword argument names; the outermost sublist corresponds to a\nsingle unnamed argument slot, and the argument value is assigned to\nthe sublist using the usual tuple assignment rules after all other\nparameter processing is done.\n\nA call always returns some value, possibly "None", unless it raises an\nexception. How this value is computed depends on the type of the\ncallable object.\n\nIf it is---\n\na user-defined function:\n The code block for the function is executed, passing it the\n argument list. The first thing the code block will do is bind the\n formal parameters to the arguments; this is described in section\n Function definitions. When the code block executes a "return"\n statement, this specifies the return value of the function call.\n\na built-in function or method:\n The result is up to the interpreter; see Built-in Functions for the\n descriptions of built-in functions and methods.\n\na class object:\n A new instance of that class is returned.\n\na class instance method:\n The corresponding user-defined function is called, with an argument\n list that is one longer than the argument list of the call: the\n instance becomes the first argument.\n\na class instance:\n The class must define a "__call__()" method; the effect is then the\n same as if that method was called.\n',
- 'class': u'\nClass definitions\n*****************\n\nA class definition defines a class object (see section The standard\ntype hierarchy):\n\n classdef ::= "class" classname [inheritance] ":" suite\n inheritance ::= "(" [expression_list] ")"\n classname ::= identifier\n\nA class definition is an executable statement. It first evaluates the\ninheritance list, if present. Each item in the inheritance list\nshould evaluate to a class object or class type which allows\nsubclassing. The class\'s suite is then executed in a new execution\nframe (see section Naming and binding), using a newly created local\nnamespace and the original global namespace. (Usually, the suite\ncontains only function definitions.) When the class\'s suite finishes\nexecution, its execution frame is discarded but its local namespace is\nsaved. [4] A class object is then created using the inheritance list\nfor the base classes and the saved local namespace for the attribute\ndictionary. The class name is bound to this class object in the\noriginal local namespace.\n\n**Programmer\'s note:** Variables defined in the class definition are\nclass variables; they are shared by all instances. To create instance\nvariables, they can be set in a method with "self.name = value". Both\nclass and instance variables are accessible through the notation\n""self.name"", and an instance variable hides a class variable with\nthe same name when accessed in this way. Class variables can be used\nas defaults for instance variables, but using mutable values there can\nlead to unexpected results. For *new-style class*es, descriptors can\nbe used to create instance variables with different implementation\ndetails.\n\nClass definitions, like function definitions, may be wrapped by one or\nmore *decorator* expressions. The evaluation rules for the decorator\nexpressions are the same as for functions. The result must be a class\nobject, which is then bound to the class name.\n\n-[ Footnotes ]-\n\n[1] The exception is propagated to the invocation stack unless\n there is a "finally" clause which happens to raise another\n exception. That new exception causes the old one to be lost.\n\n[2] Currently, control "flows off the end" except in the case of\n an exception or the execution of a "return", "continue", or\n "break" statement.\n\n[3] A string literal appearing as the first statement in the\n function body is transformed into the function\'s "__doc__"\n attribute and therefore the function\'s *docstring*.\n\n[4] A string literal appearing as the first statement in the class\n body is transformed into the namespace\'s "__doc__" item and\n therefore the class\'s *docstring*.\n',
- 'comparisons': u'\nComparisons\n***********\n\nUnlike C, all comparison operations in Python have the same priority,\nwhich is lower than that of any arithmetic, shifting or bitwise\noperation. Also unlike C, expressions like "a < b < c" have the\ninterpretation that is conventional in mathematics:\n\n comparison ::= or_expr ( comp_operator or_expr )*\n comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "<>" | "!="\n | "is" ["not"] | ["not"] "in"\n\nComparisons yield boolean values: "True" or "False".\n\nComparisons can be chained arbitrarily, e.g., "x < y <= z" is\nequivalent to "x < y and y <= z", except that "y" is evaluated only\nonce (but in both cases "z" is not evaluated at all when "x < y" is\nfound to be false).\n\nFormally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and *op1*,\n*op2*, ..., *opN* are comparison operators, then "a op1 b op2 c ... y\nopN z" is equivalent to "a op1 b and b op2 c and ... y opN z", except\nthat each expression is evaluated at most once.\n\nNote that "a op1 b op2 c" doesn\'t imply any kind of comparison between\n*a* and *c*, so that, e.g., "x < y > z" is perfectly legal (though\nperhaps not pretty).\n\nThe forms "<>" and "!=" are equivalent; for consistency with C, "!="\nis preferred; where "!=" is mentioned below "<>" is also accepted.\nThe "<>" spelling is considered obsolescent.\n\nThe operators "<", ">", "==", ">=", "<=", and "!=" compare the values\nof two objects. The objects need not have the same type. If both are\nnumbers, they are converted to a common type. Otherwise, objects of\ndifferent types *always* compare unequal, and are ordered consistently\nbut arbitrarily. You can control comparison behavior of objects of\nnon-built-in types by defining a "__cmp__" method or rich comparison\nmethods like "__gt__", described in section Special method names.\n\n(This unusual definition of comparison was used to simplify the\ndefinition of operations like sorting and the "in" and "not in"\noperators. In the future, the comparison rules for objects of\ndifferent types are likely to change.)\n\nComparison of objects of the same type depends on the type:\n\n* Numbers are compared arithmetically.\n\n* Strings are compared lexicographically using the numeric\n equivalents (the result of the built-in function "ord()") of their\n characters. Unicode and 8-bit strings are fully interoperable in\n this behavior. [4]\n\n* Tuples and lists are compared lexicographically using comparison\n of corresponding elements. This means that to compare equal, each\n element must compare equal and the two sequences must be of the same\n type and have the same length.\n\n If not equal, the sequences are ordered the same as their first\n differing elements. For example, "cmp([1,2,x], [1,2,y])" returns\n the same as "cmp(x,y)". If the corresponding element does not\n exist, the shorter sequence is ordered first (for example, "[1,2] <\n [1,2,3]").\n\n* Mappings (dictionaries) compare equal if and only if their sorted\n (key, value) lists compare equal. [5] Outcomes other than equality\n are resolved consistently, but are not otherwise defined. [6]\n\n* Most other objects of built-in types compare unequal unless they\n are the same object; the choice whether one object is considered\n smaller or larger than another one is made arbitrarily but\n consistently within one execution of a program.\n\nThe operators "in" and "not in" test for collection membership. "x in\ns" evaluates to true if *x* is a member of the collection *s*, and\nfalse otherwise. "x not in s" returns the negation of "x in s". The\ncollection membership test has traditionally been bound to sequences;\nan object is a member of a collection if the collection is a sequence\nand contains an element equal to that object. However, it make sense\nfor many other object types to support membership tests without being\na sequence. In particular, dictionaries (for keys) and sets support\nmembership testing.\n\nFor the list and tuple types, "x in y" is true if and only if there\nexists an index *i* such that either "x is y[i]" or "x == y[i]" is\ntrue.\n\nFor the Unicode and string types, "x in y" is true if and only if *x*\nis a substring of *y*. An equivalent test is "y.find(x) != -1".\nNote, *x* and *y* need not be the same type; consequently, "u\'ab\' in\n\'abc\'" will return "True". Empty strings are always considered to be a\nsubstring of any other string, so """ in "abc"" will return "True".\n\nChanged in version 2.3: Previously, *x* was required to be a string of\nlength "1".\n\nFor user-defined classes which define the "__contains__()" method, "x\nin y" is true if and only if "y.__contains__(x)" is true.\n\nFor user-defined classes which do not define "__contains__()" but do\ndefine "__iter__()", "x in y" is true if some value "z" with "x == z"\nis produced while iterating over "y". If an exception is raised\nduring the iteration, it is as if "in" raised that exception.\n\nLastly, the old-style iteration protocol is tried: if a class defines\n"__getitem__()", "x in y" is true if and only if there is a non-\nnegative integer index *i* such that "x == y[i]", and all lower\ninteger indices do not raise "IndexError" exception. (If any other\nexception is raised, it is as if "in" raised that exception).\n\nThe operator "not in" is defined to have the inverse true value of\n"in".\n\nThe operators "is" and "is not" test for object identity: "x is y" is\ntrue if and only if *x* and *y* are the same object. "x is not y"\nyields the inverse truth value. [7]\n',
- 'compound': u'\nCompound statements\n*******************\n\nCompound statements contain (groups of) other statements; they affect\nor control the execution of those other statements in some way. In\ngeneral, compound statements span multiple lines, although in simple\nincarnations a whole compound statement may be contained in one line.\n\nThe "if", "while" and "for" statements implement traditional control\nflow constructs. "try" specifies exception handlers and/or cleanup\ncode for a group of statements. Function and class definitions are\nalso syntactically compound statements.\n\nCompound statements consist of one or more \'clauses.\' A clause\nconsists of a header and a \'suite.\' The clause headers of a\nparticular compound statement are all at the same indentation level.\nEach clause header begins with a uniquely identifying keyword and ends\nwith a colon. A suite is a group of statements controlled by a\nclause. A suite can be one or more semicolon-separated simple\nstatements on the same line as the header, following the header\'s\ncolon, or it can be one or more indented statements on subsequent\nlines. Only the latter form of suite can contain nested compound\nstatements; the following is illegal, mostly because it wouldn\'t be\nclear to which "if" clause a following "else" clause would belong:\n\n if test1: if test2: print x\n\nAlso note that the semicolon binds tighter than the colon in this\ncontext, so that in the following example, either all or none of the\n"print" statements are executed:\n\n if x < y < z: print x; print y; print z\n\nSummarizing:\n\n compound_stmt ::= if_stmt\n | while_stmt\n | for_stmt\n | try_stmt\n | with_stmt\n | funcdef\n | classdef\n | decorated\n suite ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT\n statement ::= stmt_list NEWLINE | compound_stmt\n stmt_list ::= simple_stmt (";" simple_stmt)* [";"]\n\nNote that statements always end in a "NEWLINE" possibly followed by a\n"DEDENT". Also note that optional continuation clauses always begin\nwith a keyword that cannot start a statement, thus there are no\nambiguities (the \'dangling "else"\' problem is solved in Python by\nrequiring nested "if" statements to be indented).\n\nThe formatting of the grammar rules in the following sections places\neach clause on a separate line for clarity.\n\n\nThe "if" statement\n==================\n\nThe "if" statement is used for conditional execution:\n\n if_stmt ::= "if" expression ":" suite\n ( "elif" expression ":" suite )*\n ["else" ":" suite]\n\nIt selects exactly one of the suites by evaluating the expressions one\nby one until one is found to be true (see section Boolean operations\nfor the definition of true and false); then that suite is executed\n(and no other part of the "if" statement is executed or evaluated).\nIf all expressions are false, the suite of the "else" clause, if\npresent, is executed.\n\n\nThe "while" statement\n=====================\n\nThe "while" statement is used for repeated execution as long as an\nexpression is true:\n\n while_stmt ::= "while" expression ":" suite\n ["else" ":" suite]\n\nThis repeatedly tests the expression and, if it is true, executes the\nfirst suite; if the expression is false (which may be the first time\nit is tested) the suite of the "else" clause, if present, is executed\nand the loop terminates.\n\nA "break" statement executed in the first suite terminates the loop\nwithout executing the "else" clause\'s suite. A "continue" statement\nexecuted in the first suite skips the rest of the suite and goes back\nto testing the expression.\n\n\nThe "for" statement\n===================\n\nThe "for" statement is used to iterate over the elements of a sequence\n(such as a string, tuple or list) or other iterable object:\n\n for_stmt ::= "for" target_list "in" expression_list ":" suite\n ["else" ":" suite]\n\nThe expression list is evaluated once; it should yield an iterable\nobject. An iterator is created for the result of the\n"expression_list". The suite is then executed once for each item\nprovided by the iterator, in the order of ascending indices. Each\nitem in turn is assigned to the target list using the standard rules\nfor assignments, and then the suite is executed. When the items are\nexhausted (which is immediately when the sequence is empty), the suite\nin the "else" clause, if present, is executed, and the loop\nterminates.\n\nA "break" statement executed in the first suite terminates the loop\nwithout executing the "else" clause\'s suite. A "continue" statement\nexecuted in the first suite skips the rest of the suite and continues\nwith the next item, or with the "else" clause if there was no next\nitem.\n\nThe suite may assign to the variable(s) in the target list; this does\nnot affect the next item assigned to it.\n\nThe target list is not deleted when the loop is finished, but if the\nsequence is empty, it will not have been assigned to at all by the\nloop. Hint: the built-in function "range()" returns a sequence of\nintegers suitable to emulate the effect of Pascal\'s "for i := a to b\ndo"; e.g., "range(3)" returns the list "[0, 1, 2]".\n\nNote: There is a subtlety when the sequence is being modified by the\n loop (this can only occur for mutable sequences, i.e. lists). An\n internal counter is used to keep track of which item is used next,\n and this is incremented on each iteration. When this counter has\n reached the length of the sequence the loop terminates. This means\n that if the suite deletes the current (or a previous) item from the\n sequence, the next item will be skipped (since it gets the index of\n the current item which has already been treated). Likewise, if the\n suite inserts an item in the sequence before the current item, the\n current item will be treated again the next time through the loop.\n This can lead to nasty bugs that can be avoided by making a\n temporary copy using a slice of the whole sequence, e.g.,\n\n for x in a[:]:\n if x < 0: a.remove(x)\n\n\nThe "try" statement\n===================\n\nThe "try" statement specifies exception handlers and/or cleanup code\nfor a group of statements:\n\n try_stmt ::= try1_stmt | try2_stmt\n try1_stmt ::= "try" ":" suite\n ("except" [expression [("as" | ",") identifier]] ":" suite)+\n ["else" ":" suite]\n ["finally" ":" suite]\n try2_stmt ::= "try" ":" suite\n "finally" ":" suite\n\nChanged in version 2.5: In previous versions of Python,\n"try"..."except"..."finally" did not work. "try"..."except" had to be\nnested in "try"..."finally".\n\nThe "except" clause(s) specify one or more exception handlers. When no\nexception occurs in the "try" clause, no exception handler is\nexecuted. When an exception occurs in the "try" suite, a search for an\nexception handler is started. This search inspects the except clauses\nin turn until one is found that matches the exception. An expression-\nless except clause, if present, must be last; it matches any\nexception. For an except clause with an expression, that expression\nis evaluated, and the clause matches the exception if the resulting\nobject is "compatible" with the exception. An object is compatible\nwith an exception if it is the class or a base class of the exception\nobject, or a tuple containing an item compatible with the exception.\n\nIf no except clause matches the exception, the search for an exception\nhandler continues in the surrounding code and on the invocation stack.\n[1]\n\nIf the evaluation of an expression in the header of an except clause\nraises an exception, the original search for a handler is canceled and\na search starts for the new exception in the surrounding code and on\nthe call stack (it is treated as if the entire "try" statement raised\nthe exception).\n\nWhen a matching except clause is found, the exception is assigned to\nthe target specified in that except clause, if present, and the except\nclause\'s suite is executed. All except clauses must have an\nexecutable block. When the end of this block is reached, execution\ncontinues normally after the entire try statement. (This means that\nif two nested handlers exist for the same exception, and the exception\noccurs in the try clause of the inner handler, the outer handler will\nnot handle the exception.)\n\nBefore an except clause\'s suite is executed, details about the\nexception are assigned to three variables in the "sys" module:\n"sys.exc_type" receives the object identifying the exception;\n"sys.exc_value" receives the exception\'s parameter;\n"sys.exc_traceback" receives a traceback object (see section The\nstandard type hierarchy) identifying the point in the program where\nthe exception occurred. These details are also available through the\n"sys.exc_info()" function, which returns a tuple "(exc_type,\nexc_value, exc_traceback)". Use of the corresponding variables is\ndeprecated in favor of this function, since their use is unsafe in a\nthreaded program. As of Python 1.5, the variables are restored to\ntheir previous values (before the call) when returning from a function\nthat handled an exception.\n\nThe optional "else" clause is executed if and when control flows off\nthe end of the "try" clause. [2] Exceptions in the "else" clause are\nnot handled by the preceding "except" clauses.\n\nIf "finally" is present, it specifies a \'cleanup\' handler. The "try"\nclause is executed, including any "except" and "else" clauses. If an\nexception occurs in any of the clauses and is not handled, the\nexception is temporarily saved. The "finally" clause is executed. If\nthere is a saved exception, it is re-raised at the end of the\n"finally" clause. If the "finally" clause raises another exception or\nexecutes a "return" or "break" statement, the saved exception is\ndiscarded:\n\n >>> def f():\n ... try:\n ... 1/0\n ... finally:\n ... return 42\n ...\n >>> f()\n 42\n\nThe exception information is not available to the program during\nexecution of the "finally" clause.\n\nWhen a "return", "break" or "continue" statement is executed in the\n"try" suite of a "try"..."finally" statement, the "finally" clause is\nalso executed \'on the way out.\' A "continue" statement is illegal in\nthe "finally" clause. (The reason is a problem with the current\nimplementation --- this restriction may be lifted in the future).\n\nThe return value of a function is determined by the last "return"\nstatement executed. Since the "finally" clause always executes, a\n"return" statement executed in the "finally" clause will always be the\nlast one executed:\n\n >>> def foo():\n ... try:\n ... return \'try\'\n ... finally:\n ... return \'finally\'\n ...\n >>> foo()\n \'finally\'\n\nAdditional information on exceptions can be found in section\nExceptions, and information on using the "raise" statement to generate\nexceptions may be found in section The raise statement.\n\n\nThe "with" statement\n====================\n\nNew in version 2.5.\n\nThe "with" statement is used to wrap the execution of a block with\nmethods defined by a context manager (see section With Statement\nContext Managers). This allows common "try"..."except"..."finally"\nusage patterns to be encapsulated for convenient reuse.\n\n with_stmt ::= "with" with_item ("," with_item)* ":" suite\n with_item ::= expression ["as" target]\n\nThe execution of the "with" statement with one "item" proceeds as\nfollows:\n\n1. The context expression (the expression given in the "with_item")\n is evaluated to obtain a context manager.\n\n2. The context manager\'s "__exit__()" is loaded for later use.\n\n3. The context manager\'s "__enter__()" method is invoked.\n\n4. If a target was included in the "with" statement, the return\n value from "__enter__()" is assigned to it.\n\n Note: The "with" statement guarantees that if the "__enter__()"\n method returns without an error, then "__exit__()" will always be\n called. Thus, if an error occurs during the assignment to the\n target list, it will be treated the same as an error occurring\n within the suite would be. See step 6 below.\n\n5. The suite is executed.\n\n6. The context manager\'s "__exit__()" method is invoked. If an\n exception caused the suite to be exited, its type, value, and\n traceback are passed as arguments to "__exit__()". Otherwise, three\n "None" arguments are supplied.\n\n If the suite was exited due to an exception, and the return value\n from the "__exit__()" method was false, the exception is reraised.\n If the return value was true, the exception is suppressed, and\n execution continues with the statement following the "with"\n statement.\n\n If the suite was exited for any reason other than an exception, the\n return value from "__exit__()" is ignored, and execution proceeds\n at the normal location for the kind of exit that was taken.\n\nWith more than one item, the context managers are processed as if\nmultiple "with" statements were nested:\n\n with A() as a, B() as b:\n suite\n\nis equivalent to\n\n with A() as a:\n with B() as b:\n suite\n\nNote: In Python 2.5, the "with" statement is only allowed when the\n "with_statement" feature has been enabled. It is always enabled in\n Python 2.6.\n\nChanged in version 2.7: Support for multiple context expressions.\n\nSee also:\n\n **PEP 343** - The "with" statement\n The specification, background, and examples for the Python "with"\n statement.\n\n\nFunction definitions\n====================\n\nA function definition defines a user-defined function object (see\nsection The standard type hierarchy):\n\n decorated ::= decorators (classdef | funcdef)\n decorators ::= decorator+\n decorator ::= "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE\n funcdef ::= "def" funcname "(" [parameter_list] ")" ":" suite\n dotted_name ::= identifier ("." identifier)*\n parameter_list ::= (defparameter ",")*\n ( "*" identifier ["," "**" identifier]\n | "**" identifier\n | defparameter [","] )\n defparameter ::= parameter ["=" expression]\n sublist ::= parameter ("," parameter)* [","]\n parameter ::= identifier | "(" sublist ")"\n funcname ::= identifier\n\nA function definition is an executable statement. Its execution binds\nthe function name in the current local namespace to a function object\n(a wrapper around the executable code for the function). This\nfunction object contains a reference to the current global namespace\nas the global namespace to be used when the function is called.\n\nThe function definition does not execute the function body; this gets\nexecuted only when the function is called. [3]\n\nA function definition may be wrapped by one or more *decorator*\nexpressions. Decorator expressions are evaluated when the function is\ndefined, in the scope that contains the function definition. The\nresult must be a callable, which is invoked with the function object\nas the only argument. The returned value is bound to the function name\ninstead of the function object. Multiple decorators are applied in\nnested fashion. For example, the following code:\n\n @f1(arg)\n @f2\n def func(): pass\n\nis equivalent to:\n\n def func(): pass\n func = f1(arg)(f2(func))\n\nWhen one or more top-level *parameters* have the form *parameter* "="\n*expression*, the function is said to have "default parameter values."\nFor a parameter with a default value, the corresponding *argument* may\nbe omitted from a call, in which case the parameter\'s default value is\nsubstituted. If a parameter has a default value, all following\nparameters must also have a default value --- this is a syntactic\nrestriction that is not expressed by the grammar.\n\n**Default parameter values are evaluated when the function definition\nis executed.** This means that the expression is evaluated once, when\nthe function is defined, and that the same "pre-computed" value is\nused for each call. This is especially important to understand when a\ndefault parameter is a mutable object, such as a list or a dictionary:\nif the function modifies the object (e.g. by appending an item to a\nlist), the default value is in effect modified. This is generally not\nwhat was intended. A way around this is to use "None" as the\ndefault, and explicitly test for it in the body of the function, e.g.:\n\n def whats_on_the_telly(penguin=None):\n if penguin is None:\n penguin = []\n penguin.append("property of the zoo")\n return penguin\n\nFunction call semantics are described in more detail in section Calls.\nA function call always assigns values to all parameters mentioned in\nthe parameter list, either from position arguments, from keyword\narguments, or from default values. If the form ""*identifier"" is\npresent, it is initialized to a tuple receiving any excess positional\nparameters, defaulting to the empty tuple. If the form\n""**identifier"" is present, it is initialized to a new dictionary\nreceiving any excess keyword arguments, defaulting to a new empty\ndictionary.\n\nIt is also possible to create anonymous functions (functions not bound\nto a name), for immediate use in expressions. This uses lambda\nexpressions, described in section Lambdas. Note that the lambda\nexpression is merely a shorthand for a simplified function definition;\na function defined in a ""def"" statement can be passed around or\nassigned to another name just like a function defined by a lambda\nexpression. The ""def"" form is actually more powerful since it\nallows the execution of multiple statements.\n\n**Programmer\'s note:** Functions are first-class objects. A ""def""\nform executed inside a function definition defines a local function\nthat can be returned or passed around. Free variables used in the\nnested function can access the local variables of the function\ncontaining the def. See section Naming and binding for details.\n\n\nClass definitions\n=================\n\nA class definition defines a class object (see section The standard\ntype hierarchy):\n\n classdef ::= "class" classname [inheritance] ":" suite\n inheritance ::= "(" [expression_list] ")"\n classname ::= identifier\n\nA class definition is an executable statement. It first evaluates the\ninheritance list, if present. Each item in the inheritance list\nshould evaluate to a class object or class type which allows\nsubclassing. The class\'s suite is then executed in a new execution\nframe (see section Naming and binding), using a newly created local\nnamespace and the original global namespace. (Usually, the suite\ncontains only function definitions.) When the class\'s suite finishes\nexecution, its execution frame is discarded but its local namespace is\nsaved. [4] A class object is then created using the inheritance list\nfor the base classes and the saved local namespace for the attribute\ndictionary. The class name is bound to this class object in the\noriginal local namespace.\n\n**Programmer\'s note:** Variables defined in the class definition are\nclass variables; they are shared by all instances. To create instance\nvariables, they can be set in a method with "self.name = value". Both\nclass and instance variables are accessible through the notation\n""self.name"", and an instance variable hides a class variable with\nthe same name when accessed in this way. Class variables can be used\nas defaults for instance variables, but using mutable values there can\nlead to unexpected results. For *new-style class*es, descriptors can\nbe used to create instance variables with different implementation\ndetails.\n\nClass definitions, like function definitions, may be wrapped by one or\nmore *decorator* expressions. The evaluation rules for the decorator\nexpressions are the same as for functions. The result must be a class\nobject, which is then bound to the class name.\n\n-[ Footnotes ]-\n\n[1] The exception is propagated to the invocation stack unless\n there is a "finally" clause which happens to raise another\n exception. That new exception causes the old one to be lost.\n\n[2] Currently, control "flows off the end" except in the case of\n an exception or the execution of a "return", "continue", or\n "break" statement.\n\n[3] A string literal appearing as the first statement in the\n function body is transformed into the function\'s "__doc__"\n attribute and therefore the function\'s *docstring*.\n\n[4] A string literal appearing as the first statement in the class\n body is transformed into the namespace\'s "__doc__" item and\n therefore the class\'s *docstring*.\n',
- 'context-managers': u'\nWith Statement Context Managers\n*******************************\n\nNew in version 2.5.\n\nA *context manager* is an object that defines the runtime context to\nbe established when executing a "with" statement. The context manager\nhandles the entry into, and the exit from, the desired runtime context\nfor the execution of the block of code. Context managers are normally\ninvoked using the "with" statement (described in section The with\nstatement), but can also be used by directly invoking their methods.\n\nTypical uses of context managers include saving and restoring various\nkinds of global state, locking and unlocking resources, closing opened\nfiles, etc.\n\nFor more information on context managers, see Context Manager Types.\n\nobject.__enter__(self)\n\n Enter the runtime context related to this object. The "with"\n statement will bind this method\'s return value to the target(s)\n specified in the "as" clause of the statement, if any.\n\nobject.__exit__(self, exc_type, exc_value, traceback)\n\n Exit the runtime context related to this object. The parameters\n describe the exception that caused the context to be exited. If the\n context was exited without an exception, all three arguments will\n be "None".\n\n If an exception is supplied, and the method wishes to suppress the\n exception (i.e., prevent it from being propagated), it should\n return a true value. Otherwise, the exception will be processed\n normally upon exit from this method.\n\n Note that "__exit__()" methods should not reraise the passed-in\n exception; this is the caller\'s responsibility.\n\nSee also:\n\n **PEP 343** - The "with" statement\n The specification, background, and examples for the Python "with"\n statement.\n',
- 'continue': u'\nThe "continue" statement\n************************\n\n continue_stmt ::= "continue"\n\n"continue" may only occur syntactically nested in a "for" or "while"\nloop, but not nested in a function or class definition or "finally"\nclause within that loop. It continues with the next cycle of the\nnearest enclosing loop.\n\nWhen "continue" passes control out of a "try" statement with a\n"finally" clause, that "finally" clause is executed before really\nstarting the next loop cycle.\n',
- 'conversions': u'\nArithmetic conversions\n**********************\n\nWhen a description of an arithmetic operator below uses the phrase\n"the numeric arguments are converted to a common type," the arguments\nare coerced using the coercion rules listed at Coercion rules. If\nboth arguments are standard numeric types, the following coercions are\napplied:\n\n* If either argument is a complex number, the other is converted to\n complex;\n\n* otherwise, if either argument is a floating point number, the\n other is converted to floating point;\n\n* otherwise, if either argument is a long integer, the other is\n converted to long integer;\n\n* otherwise, both must be plain integers and no conversion is\n necessary.\n\nSome additional rules apply for certain operators (e.g., a string left\nargument to the \'%\' operator). Extensions can define their own\ncoercions.\n',
- 'customization': u'\nBasic customization\n*******************\n\nobject.__new__(cls[, ...])\n\n Called to create a new instance of class *cls*. "__new__()" is a\n static method (special-cased so you need not declare it as such)\n that takes the class of which an instance was requested as its\n first argument. The remaining arguments are those passed to the\n object constructor expression (the call to the class). The return\n value of "__new__()" should be the new object instance (usually an\n instance of *cls*).\n\n Typical implementations create a new instance of the class by\n invoking the superclass\'s "__new__()" method using\n "super(currentclass, cls).__new__(cls[, ...])" with appropriate\n arguments and then modifying the newly-created instance as\n necessary before returning it.\n\n If "__new__()" returns an instance of *cls*, then the new\n instance\'s "__init__()" method will be invoked like\n "__init__(self[, ...])", where *self* is the new instance and the\n remaining arguments are the same as were passed to "__new__()".\n\n If "__new__()" does not return an instance of *cls*, then the new\n instance\'s "__init__()" method will not be invoked.\n\n "__new__()" is intended mainly to allow subclasses of immutable\n types (like int, str, or tuple) to customize instance creation. It\n is also commonly overridden in custom metaclasses in order to\n customize class creation.\n\nobject.__init__(self[, ...])\n\n Called after the instance has been created (by "__new__()"), but\n before it is returned to the caller. The arguments are those\n passed to the class constructor expression. If a base class has an\n "__init__()" method, the derived class\'s "__init__()" method, if\n any, must explicitly call it to ensure proper initialization of the\n base class part of the instance; for example:\n "BaseClass.__init__(self, [args...])".\n\n Because "__new__()" and "__init__()" work together in constructing\n objects ("__new__()" to create it, and "__init__()" to customise\n it), no non-"None" value may be returned by "__init__()"; doing so\n will cause a "TypeError" to be raised at runtime.\n\nobject.__del__(self)\n\n Called when the instance is about to be destroyed. This is also\n called a destructor. If a base class has a "__del__()" method, the\n derived class\'s "__del__()" method, if any, must explicitly call it\n to ensure proper deletion of the base class part of the instance.\n Note that it is possible (though not recommended!) for the\n "__del__()" method to postpone destruction of the instance by\n creating a new reference to it. It may then be called at a later\n time when this new reference is deleted. It is not guaranteed that\n "__del__()" methods are called for objects that still exist when\n the interpreter exits.\n\n Note: "del x" doesn\'t directly call "x.__del__()" --- the former\n decrements the reference count for "x" by one, and the latter is\n only called when "x"\'s reference count reaches zero. Some common\n situations that may prevent the reference count of an object from\n going to zero include: circular references between objects (e.g.,\n a doubly-linked list or a tree data structure with parent and\n child pointers); a reference to the object on the stack frame of\n a function that caught an exception (the traceback stored in\n "sys.exc_traceback" keeps the stack frame alive); or a reference\n to the object on the stack frame that raised an unhandled\n exception in interactive mode (the traceback stored in\n "sys.last_traceback" keeps the stack frame alive). The first\n situation can only be remedied by explicitly breaking the cycles;\n the latter two situations can be resolved by storing "None" in\n "sys.exc_traceback" or "sys.last_traceback". Circular references\n which are garbage are detected when the option cycle detector is\n enabled (it\'s on by default), but can only be cleaned up if there\n are no Python-level "__del__()" methods involved. Refer to the\n documentation for the "gc" module for more information about how\n "__del__()" methods are handled by the cycle detector,\n particularly the description of the "garbage" value.\n\n Warning: Due to the precarious circumstances under which\n "__del__()" methods are invoked, exceptions that occur during\n their execution are ignored, and a warning is printed to\n "sys.stderr" instead. Also, when "__del__()" is invoked in\n response to a module being deleted (e.g., when execution of the\n program is done), other globals referenced by the "__del__()"\n method may already have been deleted or in the process of being\n torn down (e.g. the import machinery shutting down). For this\n reason, "__del__()" methods should do the absolute minimum needed\n to maintain external invariants. Starting with version 1.5,\n Python guarantees that globals whose name begins with a single\n underscore are deleted from their module before other globals are\n deleted; if no other references to such globals exist, this may\n help in assuring that imported modules are still available at the\n time when the "__del__()" method is called.\n\n See also the "-R" command-line option.\n\nobject.__repr__(self)\n\n Called by the "repr()" built-in function and by string conversions\n (reverse quotes) to compute the "official" string representation of\n an object. If at all possible, this should look like a valid\n Python expression that could be used to recreate an object with the\n same value (given an appropriate environment). If this is not\n possible, a string of the form "<...some useful description...>"\n should be returned. The return value must be a string object. If a\n class defines "__repr__()" but not "__str__()", then "__repr__()"\n is also used when an "informal" string representation of instances\n of that class is required.\n\n This is typically used for debugging, so it is important that the\n representation is information-rich and unambiguous.\n\nobject.__str__(self)\n\n Called by the "str()" built-in function and by the "print"\n statement to compute the "informal" string representation of an\n object. This differs from "__repr__()" in that it does not have to\n be a valid Python expression: a more convenient or concise\n representation may be used instead. The return value must be a\n string object.\n\nobject.__lt__(self, other)\nobject.__le__(self, other)\nobject.__eq__(self, other)\nobject.__ne__(self, other)\nobject.__gt__(self, other)\nobject.__ge__(self, other)\n\n New in version 2.1.\n\n These are the so-called "rich comparison" methods, and are called\n for comparison operators in preference to "__cmp__()" below. The\n correspondence between operator symbols and method names is as\n follows: "x<y" calls "x.__lt__(y)", "x<=y" calls "x.__le__(y)",\n "x==y" calls "x.__eq__(y)", "x!=y" and "x<>y" call "x.__ne__(y)",\n "x>y" calls "x.__gt__(y)", and "x>=y" calls "x.__ge__(y)".\n\n A rich comparison method may return the singleton "NotImplemented"\n if it does not implement the operation for a given pair of\n arguments. By convention, "False" and "True" are returned for a\n successful comparison. However, these methods can return any value,\n so if the comparison operator is used in a Boolean context (e.g.,\n in the condition of an "if" statement), Python will call "bool()"\n on the value to determine if the result is true or false.\n\n There are no implied relationships among the comparison operators.\n The truth of "x==y" does not imply that "x!=y" is false.\n Accordingly, when defining "__eq__()", one should also define\n "__ne__()" so that the operators will behave as expected. See the\n paragraph on "__hash__()" for some important notes on creating\n *hashable* objects which support custom comparison operations and\n are usable as dictionary keys.\n\n There are no swapped-argument versions of these methods (to be used\n when the left argument does not support the operation but the right\n argument does); rather, "__lt__()" and "__gt__()" are each other\'s\n reflection, "__le__()" and "__ge__()" are each other\'s reflection,\n and "__eq__()" and "__ne__()" are their own reflection.\n\n Arguments to rich comparison methods are never coerced.\n\n To automatically generate ordering operations from a single root\n operation, see "functools.total_ordering()".\n\nobject.__cmp__(self, other)\n\n Called by comparison operations if rich comparison (see above) is\n not defined. Should return a negative integer if "self < other",\n zero if "self == other", a positive integer if "self > other". If\n no "__cmp__()", "__eq__()" or "__ne__()" operation is defined,\n class instances are compared by object identity ("address"). See\n also the description of "__hash__()" for some important notes on\n creating *hashable* objects which support custom comparison\n operations and are usable as dictionary keys. (Note: the\n restriction that exceptions are not propagated by "__cmp__()" has\n been removed since Python 1.5.)\n\nobject.__rcmp__(self, other)\n\n Changed in version 2.1: No longer supported.\n\nobject.__hash__(self)\n\n Called by built-in function "hash()" and for operations on members\n of hashed collections including "set", "frozenset", and "dict".\n "__hash__()" should return an integer. The only required property\n is that objects which compare equal have the same hash value; it is\n advised to somehow mix together (e.g. using exclusive or) the hash\n values for the components of the object that also play a part in\n comparison of objects.\n\n If a class does not define a "__cmp__()" or "__eq__()" method it\n should not define a "__hash__()" operation either; if it defines\n "__cmp__()" or "__eq__()" but not "__hash__()", its instances will\n not be usable in hashed collections. If a class defines mutable\n objects and implements a "__cmp__()" or "__eq__()" method, it\n should not implement "__hash__()", since hashable collection\n implementations require that an object\'s hash value is immutable\n (if the object\'s hash value changes, it will be in the wrong hash\n bucket).\n\n User-defined classes have "__cmp__()" and "__hash__()" methods by\n default; with them, all objects compare unequal (except with\n themselves) and "x.__hash__()" returns a result derived from\n "id(x)".\n\n Classes which inherit a "__hash__()" method from a parent class but\n change the meaning of "__cmp__()" or "__eq__()" such that the hash\n value returned is no longer appropriate (e.g. by switching to a\n value-based concept of equality instead of the default identity\n based equality) can explicitly flag themselves as being unhashable\n by setting "__hash__ = None" in the class definition. Doing so\n means that not only will instances of the class raise an\n appropriate "TypeError" when a program attempts to retrieve their\n hash value, but they will also be correctly identified as\n unhashable when checking "isinstance(obj, collections.Hashable)"\n (unlike classes which define their own "__hash__()" to explicitly\n raise "TypeError").\n\n Changed in version 2.5: "__hash__()" may now also return a long\n integer object; the 32-bit integer is then derived from the hash of\n that object.\n\n Changed in version 2.6: "__hash__" may now be set to "None" to\n explicitly flag instances of a class as unhashable.\n\nobject.__nonzero__(self)\n\n Called to implement truth value testing and the built-in operation\n "bool()"; should return "False" or "True", or their integer\n equivalents "0" or "1". When this method is not defined,\n "__len__()" is called, if it is defined, and the object is\n considered true if its result is nonzero. If a class defines\n neither "__len__()" nor "__nonzero__()", all its instances are\n considered true.\n\nobject.__unicode__(self)\n\n Called to implement "unicode()" built-in; should return a Unicode\n object. When this method is not defined, string conversion is\n attempted, and the result of string conversion is converted to\n Unicode using the system default encoding.\n',
- 'debugger': u'\n"pdb" --- The Python Debugger\n*****************************\n\n**Source code:** Lib/pdb.py\n\n======================================================================\n\nThe module "pdb" defines an interactive source code debugger for\nPython programs. It supports setting (conditional) breakpoints and\nsingle stepping at the source line level, inspection of stack frames,\nsource code listing, and evaluation of arbitrary Python code in the\ncontext of any stack frame. It also supports post-mortem debugging\nand can be called under program control.\n\nThe debugger is extensible --- it is actually defined as the class\n"Pdb". This is currently undocumented but easily understood by reading\nthe source. The extension interface uses the modules "bdb" and "cmd".\n\nThe debugger\'s prompt is "(Pdb)". Typical usage to run a program under\ncontrol of the debugger is:\n\n >>> import pdb\n >>> import mymodule\n >>> pdb.run(\'mymodule.test()\')\n > <string>(0)?()\n (Pdb) continue\n > <string>(1)?()\n (Pdb) continue\n NameError: \'spam\'\n > <string>(1)?()\n (Pdb)\n\n"pdb.py" can also be invoked as a script to debug other scripts. For\nexample:\n\n python -m pdb myscript.py\n\nWhen invoked as a script, pdb will automatically enter post-mortem\ndebugging if the program being debugged exits abnormally. After post-\nmortem debugging (or after normal exit of the program), pdb will\nrestart the program. Automatic restarting preserves pdb\'s state (such\nas breakpoints) and in most cases is more useful than quitting the\ndebugger upon program\'s exit.\n\nNew in version 2.4: Restarting post-mortem behavior added.\n\nThe typical usage to break into the debugger from a running program is\nto insert\n\n import pdb; pdb.set_trace()\n\nat the location you want to break into the debugger. You can then\nstep through the code following this statement, and continue running\nwithout the debugger using the "c" command.\n\nThe typical usage to inspect a crashed program is:\n\n >>> import pdb\n >>> import mymodule\n >>> mymodule.test()\n Traceback (most recent call last):\n File "<stdin>", line 1, in ?\n File "./mymodule.py", line 4, in test\n test2()\n File "./mymodule.py", line 3, in test2\n print spam\n NameError: spam\n >>> pdb.pm()\n > ./mymodule.py(3)test2()\n -> print spam\n (Pdb)\n\nThe module defines the following functions; each enters the debugger\nin a slightly different way:\n\npdb.run(statement[, globals[, locals]])\n\n Execute the *statement* (given as a string) under debugger control.\n The debugger prompt appears before any code is executed; you can\n set breakpoints and type "continue", or you can step through the\n statement using "step" or "next" (all these commands are explained\n below). The optional *globals* and *locals* arguments specify the\n environment in which the code is executed; by default the\n dictionary of the module "__main__" is used. (See the explanation\n of the "exec" statement or the "eval()" built-in function.)\n\npdb.runeval(expression[, globals[, locals]])\n\n Evaluate the *expression* (given as a string) under debugger\n control. When "runeval()" returns, it returns the value of the\n expression. Otherwise this function is similar to "run()".\n\npdb.runcall(function[, argument, ...])\n\n Call the *function* (a function or method object, not a string)\n with the given arguments. When "runcall()" returns, it returns\n whatever the function call returned. The debugger prompt appears\n as soon as the function is entered.\n\npdb.set_trace()\n\n Enter the debugger at the calling stack frame. This is useful to\n hard-code a breakpoint at a given point in a program, even if the\n code is not otherwise being debugged (e.g. when an assertion\n fails).\n\npdb.post_mortem([traceback])\n\n Enter post-mortem debugging of the given *traceback* object. If no\n *traceback* is given, it uses the one of the exception that is\n currently being handled (an exception must be being handled if the\n default is to be used).\n\npdb.pm()\n\n Enter post-mortem debugging of the traceback found in\n "sys.last_traceback".\n\nThe "run*" functions and "set_trace()" are aliases for instantiating\nthe "Pdb" class and calling the method of the same name. If you want\nto access further features, you have to do this yourself:\n\nclass pdb.Pdb(completekey=\'tab\', stdin=None, stdout=None, skip=None)\n\n "Pdb" is the debugger class.\n\n The *completekey*, *stdin* and *stdout* arguments are passed to the\n underlying "cmd.Cmd" class; see the description there.\n\n The *skip* argument, if given, must be an iterable of glob-style\n module name patterns. The debugger will not step into frames that\n originate in a module that matches one of these patterns. [1]\n\n Example call to enable tracing with *skip*:\n\n import pdb; pdb.Pdb(skip=[\'django.*\']).set_trace()\n\n New in version 2.7: The *skip* argument.\n\n run(statement[, globals[, locals]])\n runeval(expression[, globals[, locals]])\n runcall(function[, argument, ...])\n set_trace()\n\n See the documentation for the functions explained above.\n',
- 'del': u'\nThe "del" statement\n*******************\n\n del_stmt ::= "del" target_list\n\nDeletion is recursively defined very similar to the way assignment is\ndefined. Rather than spelling it out in full details, here are some\nhints.\n\nDeletion of a target list recursively deletes each target, from left\nto right.\n\nDeletion of a name removes the binding of that name from the local or\nglobal namespace, depending on whether the name occurs in a "global"\nstatement in the same code block. If the name is unbound, a\n"NameError" exception will be raised.\n\nIt is illegal to delete a name from the local namespace if it occurs\nas a free variable in a nested block.\n\nDeletion of attribute references, subscriptions and slicings is passed\nto the primary object involved; deletion of a slicing is in general\nequivalent to assignment of an empty slice of the right type (but even\nthis is determined by the sliced object).\n',
- 'dict': u'\nDictionary displays\n*******************\n\nA dictionary display is a possibly empty series of key/datum pairs\nenclosed in curly braces:\n\n dict_display ::= "{" [key_datum_list | dict_comprehension] "}"\n key_datum_list ::= key_datum ("," key_datum)* [","]\n key_datum ::= expression ":" expression\n dict_comprehension ::= expression ":" expression comp_for\n\nA dictionary display yields a new dictionary object.\n\nIf a comma-separated sequence of key/datum pairs is given, they are\nevaluated from left to right to define the entries of the dictionary:\neach key object is used as a key into the dictionary to store the\ncorresponding datum. This means that you can specify the same key\nmultiple times in the key/datum list, and the final dictionary\'s value\nfor that key will be the last one given.\n\nA dict comprehension, in contrast to list and set comprehensions,\nneeds two expressions separated with a colon followed by the usual\n"for" and "if" clauses. When the comprehension is run, the resulting\nkey and value elements are inserted in the new dictionary in the order\nthey are produced.\n\nRestrictions on the types of the key values are listed earlier in\nsection The standard type hierarchy. (To summarize, the key type\nshould be *hashable*, which excludes all mutable objects.) Clashes\nbetween duplicate keys are not detected; the last datum (textually\nrightmost in the display) stored for a given key value prevails.\n',
- 'dynamic-features': u'\nInteraction with dynamic features\n*********************************\n\nThere are several cases where Python statements are illegal when used\nin conjunction with nested scopes that contain free variables.\n\nIf a variable is referenced in an enclosing scope, it is illegal to\ndelete the name. An error will be reported at compile time.\n\nIf the wild card form of import --- "import *" --- is used in a\nfunction and the function contains or is a nested block with free\nvariables, the compiler will raise a "SyntaxError".\n\nIf "exec" is used in a function and the function contains or is a\nnested block with free variables, the compiler will raise a\n"SyntaxError" unless the exec explicitly specifies the local namespace\nfor the "exec". (In other words, "exec obj" would be illegal, but\n"exec obj in ns" would be legal.)\n\nThe "eval()", "execfile()", and "input()" functions and the "exec"\nstatement do not have access to the full environment for resolving\nnames. Names may be resolved in the local and global namespaces of\nthe caller. Free variables are not resolved in the nearest enclosing\nnamespace, but in the global namespace. [1] The "exec" statement and\nthe "eval()" and "execfile()" functions have optional arguments to\noverride the global and local namespace. If only one namespace is\nspecified, it is used for both.\n',
- 'else': u'\nThe "if" statement\n******************\n\nThe "if" statement is used for conditional execution:\n\n if_stmt ::= "if" expression ":" suite\n ( "elif" expression ":" suite )*\n ["else" ":" suite]\n\nIt selects exactly one of the suites by evaluating the expressions one\nby one until one is found to be true (see section Boolean operations\nfor the definition of true and false); then that suite is executed\n(and no other part of the "if" statement is executed or evaluated).\nIf all expressions are false, the suite of the "else" clause, if\npresent, is executed.\n',
- 'exceptions': u'\nExceptions\n**********\n\nExceptions are a means of breaking out of the normal flow of control\nof a code block in order to handle errors or other exceptional\nconditions. An exception is *raised* at the point where the error is\ndetected; it may be *handled* by the surrounding code block or by any\ncode block that directly or indirectly invoked the code block where\nthe error occurred.\n\nThe Python interpreter raises an exception when it detects a run-time\nerror (such as division by zero). A Python program can also\nexplicitly raise an exception with the "raise" statement. Exception\nhandlers are specified with the "try" ... "except" statement. The\n"finally" clause of such a statement can be used to specify cleanup\ncode which does not handle the exception, but is executed whether an\nexception occurred or not in the preceding code.\n\nPython uses the "termination" model of error handling: an exception\nhandler can find out what happened and continue execution at an outer\nlevel, but it cannot repair the cause of the error and retry the\nfailing operation (except by re-entering the offending piece of code\nfrom the top).\n\nWhen an exception is not handled at all, the interpreter terminates\nexecution of the program, or returns to its interactive main loop. In\neither case, it prints a stack backtrace, except when the exception is\n"SystemExit".\n\nExceptions are identified by class instances. The "except" clause is\nselected depending on the class of the instance: it must reference the\nclass of the instance or a base class thereof. The instance can be\nreceived by the handler and can carry additional information about the\nexceptional condition.\n\nExceptions can also be identified by strings, in which case the\n"except" clause is selected by object identity. An arbitrary value\ncan be raised along with the identifying string which can be passed to\nthe handler.\n\nNote: Messages to exceptions are not part of the Python API. Their\n contents may change from one version of Python to the next without\n warning and should not be relied on by code which will run under\n multiple versions of the interpreter.\n\nSee also the description of the "try" statement in section The try\nstatement and "raise" statement in section The raise statement.\n\n-[ Footnotes ]-\n\n[1] This limitation occurs because the code that is executed by\n these operations is not available at the time the module is\n compiled.\n',
- 'exec': u'\nThe "exec" statement\n********************\n\n exec_stmt ::= "exec" or_expr ["in" expression ["," expression]]\n\nThis statement supports dynamic execution of Python code. The first\nexpression should evaluate to either a Unicode string, a *Latin-1*\nencoded string, an open file object, a code object, or a tuple. If it\nis a string, the string is parsed as a suite of Python statements\nwhich is then executed (unless a syntax error occurs). [1] If it is an\nopen file, the file is parsed until EOF and executed. If it is a code\nobject, it is simply executed. For the interpretation of a tuple, see\nbelow. In all cases, the code that\'s executed is expected to be valid\nas file input (see section File input). Be aware that the "return"\nand "yield" statements may not be used outside of function definitions\neven within the context of code passed to the "exec" statement.\n\nIn all cases, if the optional parts are omitted, the code is executed\nin the current scope. If only the first expression after "in" is\nspecified, it should be a dictionary, which will be used for both the\nglobal and the local variables. If two expressions are given, they\nare used for the global and local variables, respectively. If\nprovided, *locals* can be any mapping object. Remember that at module\nlevel, globals and locals are the same dictionary. If two separate\nobjects are given as *globals* and *locals*, the code will be executed\nas if it were embedded in a class definition.\n\nThe first expression may also be a tuple of length 2 or 3. In this\ncase, the optional parts must be omitted. The form "exec(expr,\nglobals)" is equivalent to "exec expr in globals", while the form\n"exec(expr, globals, locals)" is equivalent to "exec expr in globals,\nlocals". The tuple form of "exec" provides compatibility with Python\n3, where "exec" is a function rather than a statement.\n\nChanged in version 2.4: Formerly, *locals* was required to be a\ndictionary.\n\nAs a side effect, an implementation may insert additional keys into\nthe dictionaries given besides those corresponding to variable names\nset by the executed code. For example, the current implementation may\nadd a reference to the dictionary of the built-in module "__builtin__"\nunder the key "__builtins__" (!).\n\n**Programmer\'s hints:** dynamic evaluation of expressions is supported\nby the built-in function "eval()". The built-in functions "globals()"\nand "locals()" return the current global and local dictionary,\nrespectively, which may be useful to pass around for use by "exec".\n\n-[ Footnotes ]-\n\n[1] Note that the parser only accepts the Unix-style end of line\n convention. If you are reading the code from a file, make sure to\n use *universal newlines* mode to convert Windows or Mac-style\n newlines.\n',
- 'execmodel': u'\nExecution model\n***************\n\n\nNaming and binding\n==================\n\n*Names* refer to objects. Names are introduced by name binding\noperations. Each occurrence of a name in the program text refers to\nthe *binding* of that name established in the innermost function block\ncontaining the use.\n\nA *block* is a piece of Python program text that is executed as a\nunit. The following are blocks: a module, a function body, and a class\ndefinition. Each command typed interactively is a block. A script\nfile (a file given as standard input to the interpreter or specified\non the interpreter command line the first argument) is a code block.\nA script command (a command specified on the interpreter command line\nwith the \'**-c**\' option) is a code block. The file read by the\nbuilt-in function "execfile()" is a code block. The string argument\npassed to the built-in function "eval()" and to the "exec" statement\nis a code block. The expression read and evaluated by the built-in\nfunction "input()" is a code block.\n\nA code block is executed in an *execution frame*. A frame contains\nsome administrative information (used for debugging) and determines\nwhere and how execution continues after the code block\'s execution has\ncompleted.\n\nA *scope* defines the visibility of a name within a block. If a local\nvariable is defined in a block, its scope includes that block. If the\ndefinition occurs in a function block, the scope extends to any blocks\ncontained within the defining one, unless a contained block introduces\na different binding for the name. The scope of names defined in a\nclass block is limited to the class block; it does not extend to the\ncode blocks of methods -- this includes generator expressions since\nthey are implemented using a function scope. This means that the\nfollowing will fail:\n\n class A:\n a = 42\n b = list(a + i for i in range(10))\n\nWhen a name is used in a code block, it is resolved using the nearest\nenclosing scope. The set of all such scopes visible to a code block\nis called the block\'s *environment*.\n\nIf a name is bound in a block, it is a local variable of that block.\nIf a name is bound at the module level, it is a global variable. (The\nvariables of the module code block are local and global.) If a\nvariable is used in a code block but not defined there, it is a *free\nvariable*.\n\nWhen a name is not found at all, a "NameError" exception is raised.\nIf the name refers to a local variable that has not been bound, a\n"UnboundLocalError" exception is raised. "UnboundLocalError" is a\nsubclass of "NameError".\n\nThe following constructs bind names: formal parameters to functions,\n"import" statements, class and function definitions (these bind the\nclass or function name in the defining block), and targets that are\nidentifiers if occurring in an assignment, "for" loop header, in the\nsecond position of an "except" clause header or after "as" in a "with"\nstatement. The "import" statement of the form "from ... import *"\nbinds all names defined in the imported module, except those beginning\nwith an underscore. This form may only be used at the module level.\n\nA target occurring in a "del" statement is also considered bound for\nthis purpose (though the actual semantics are to unbind the name). It\nis illegal to unbind a name that is referenced by an enclosing scope;\nthe compiler will report a "SyntaxError".\n\nEach assignment or import statement occurs within a block defined by a\nclass or function definition or at the module level (the top-level\ncode block).\n\nIf a name binding operation occurs anywhere within a code block, all\nuses of the name within the block are treated as references to the\ncurrent block. This can lead to errors when a name is used within a\nblock before it is bound. This rule is subtle. Python lacks\ndeclarations and allows name binding operations to occur anywhere\nwithin a code block. The local variables of a code block can be\ndetermined by scanning the entire text of the block for name binding\noperations.\n\nIf the global statement occurs within a block, all uses of the name\nspecified in the statement refer to the binding of that name in the\ntop-level namespace. Names are resolved in the top-level namespace by\nsearching the global namespace, i.e. the namespace of the module\ncontaining the code block, and the builtins namespace, the namespace\nof the module "__builtin__". The global namespace is searched first.\nIf the name is not found there, the builtins namespace is searched.\nThe global statement must precede all uses of the name.\n\nThe builtins namespace associated with the execution of a code block\nis actually found by looking up the name "__builtins__" in its global\nnamespace; this should be a dictionary or a module (in the latter case\nthe module\'s dictionary is used). By default, when in the "__main__"\nmodule, "__builtins__" is the built-in module "__builtin__" (note: no\n\'s\'); when in any other module, "__builtins__" is an alias for the\ndictionary of the "__builtin__" module itself. "__builtins__" can be\nset to a user-created dictionary to create a weak form of restricted\nexecution.\n\n**CPython implementation detail:** Users should not touch\n"__builtins__"; it is strictly an implementation detail. Users\nwanting to override values in the builtins namespace should "import"\nthe "__builtin__" (no \'s\') module and modify its attributes\nappropriately.\n\nThe namespace for a module is automatically created the first time a\nmodule is imported. The main module for a script is always called\n"__main__".\n\nThe "global" statement has the same scope as a name binding operation\nin the same block. If the nearest enclosing scope for a free variable\ncontains a global statement, the free variable is treated as a global.\n\nA class definition is an executable statement that may use and define\nnames. These references follow the normal rules for name resolution.\nThe namespace of the class definition becomes the attribute dictionary\nof the class. Names defined at the class scope are not visible in\nmethods.\n\n\nInteraction with dynamic features\n---------------------------------\n\nThere are several cases where Python statements are illegal when used\nin conjunction with nested scopes that contain free variables.\n\nIf a variable is referenced in an enclosing scope, it is illegal to\ndelete the name. An error will be reported at compile time.\n\nIf the wild card form of import --- "import *" --- is used in a\nfunction and the function contains or is a nested block with free\nvariables, the compiler will raise a "SyntaxError".\n\nIf "exec" is used in a function and the function contains or is a\nnested block with free variables, the compiler will raise a\n"SyntaxError" unless the exec explicitly specifies the local namespace\nfor the "exec". (In other words, "exec obj" would be illegal, but\n"exec obj in ns" would be legal.)\n\nThe "eval()", "execfile()", and "input()" functions and the "exec"\nstatement do not have access to the full environment for resolving\nnames. Names may be resolved in the local and global namespaces of\nthe caller. Free variables are not resolved in the nearest enclosing\nnamespace, but in the global namespace. [1] The "exec" statement and\nthe "eval()" and "execfile()" functions have optional arguments to\noverride the global and local namespace. If only one namespace is\nspecified, it is used for both.\n\n\nExceptions\n==========\n\nExceptions are a means of breaking out of the normal flow of control\nof a code block in order to handle errors or other exceptional\nconditions. An exception is *raised* at the point where the error is\ndetected; it may be *handled* by the surrounding code block or by any\ncode block that directly or indirectly invoked the code block where\nthe error occurred.\n\nThe Python interpreter raises an exception when it detects a run-time\nerror (such as division by zero). A Python program can also\nexplicitly raise an exception with the "raise" statement. Exception\nhandlers are specified with the "try" ... "except" statement. The\n"finally" clause of such a statement can be used to specify cleanup\ncode which does not handle the exception, but is executed whether an\nexception occurred or not in the preceding code.\n\nPython uses the "termination" model of error handling: an exception\nhandler can find out what happened and continue execution at an outer\nlevel, but it cannot repair the cause of the error and retry the\nfailing operation (except by re-entering the offending piece of code\nfrom the top).\n\nWhen an exception is not handled at all, the interpreter terminates\nexecution of the program, or returns to its interactive main loop. In\neither case, it prints a stack backtrace, except when the exception is\n"SystemExit".\n\nExceptions are identified by class instances. The "except" clause is\nselected depending on the class of the instance: it must reference the\nclass of the instance or a base class thereof. The instance can be\nreceived by the handler and can carry additional information about the\nexceptional condition.\n\nExceptions can also be identified by strings, in which case the\n"except" clause is selected by object identity. An arbitrary value\ncan be raised along with the identifying string which can be passed to\nthe handler.\n\nNote: Messages to exceptions are not part of the Python API. Their\n contents may change from one version of Python to the next without\n warning and should not be relied on by code which will run under\n multiple versions of the interpreter.\n\nSee also the description of the "try" statement in section The try\nstatement and "raise" statement in section The raise statement.\n\n-[ Footnotes ]-\n\n[1] This limitation occurs because the code that is executed by\n these operations is not available at the time the module is\n compiled.\n',
- 'exprlists': u'\nExpression lists\n****************\n\n expression_list ::= expression ( "," expression )* [","]\n\nAn expression list containing at least one comma yields a tuple. The\nlength of the tuple is the number of expressions in the list. The\nexpressions are evaluated from left to right.\n\nThe trailing comma is required only to create a single tuple (a.k.a. a\n*singleton*); it is optional in all other cases. A single expression\nwithout a trailing comma doesn\'t create a tuple, but rather yields the\nvalue of that expression. (To create an empty tuple, use an empty pair\nof parentheses: "()".)\n',
- 'floating': u'\nFloating point literals\n***********************\n\nFloating point literals are described by the following lexical\ndefinitions:\n\n floatnumber ::= pointfloat | exponentfloat\n pointfloat ::= [intpart] fraction | intpart "."\n exponentfloat ::= (intpart | pointfloat) exponent\n intpart ::= digit+\n fraction ::= "." digit+\n exponent ::= ("e" | "E") ["+" | "-"] digit+\n\nNote that the integer and exponent parts of floating point numbers can\nlook like octal integers, but are interpreted using radix 10. For\nexample, "077e010" is legal, and denotes the same number as "77e10".\nThe allowed range of floating point literals is implementation-\ndependent. Some examples of floating point literals:\n\n 3.14 10. .001 1e100 3.14e-10 0e0\n\nNote that numeric literals do not include a sign; a phrase like "-1"\nis actually an expression composed of the unary operator "-" and the\nliteral "1".\n',
- 'for': u'\nThe "for" statement\n*******************\n\nThe "for" statement is used to iterate over the elements of a sequence\n(such as a string, tuple or list) or other iterable object:\n\n for_stmt ::= "for" target_list "in" expression_list ":" suite\n ["else" ":" suite]\n\nThe expression list is evaluated once; it should yield an iterable\nobject. An iterator is created for the result of the\n"expression_list". The suite is then executed once for each item\nprovided by the iterator, in the order of ascending indices. Each\nitem in turn is assigned to the target list using the standard rules\nfor assignments, and then the suite is executed. When the items are\nexhausted (which is immediately when the sequence is empty), the suite\nin the "else" clause, if present, is executed, and the loop\nterminates.\n\nA "break" statement executed in the first suite terminates the loop\nwithout executing the "else" clause\'s suite. A "continue" statement\nexecuted in the first suite skips the rest of the suite and continues\nwith the next item, or with the "else" clause if there was no next\nitem.\n\nThe suite may assign to the variable(s) in the target list; this does\nnot affect the next item assigned to it.\n\nThe target list is not deleted when the loop is finished, but if the\nsequence is empty, it will not have been assigned to at all by the\nloop. Hint: the built-in function "range()" returns a sequence of\nintegers suitable to emulate the effect of Pascal\'s "for i := a to b\ndo"; e.g., "range(3)" returns the list "[0, 1, 2]".\n\nNote: There is a subtlety when the sequence is being modified by the\n loop (this can only occur for mutable sequences, i.e. lists). An\n internal counter is used to keep track of which item is used next,\n and this is incremented on each iteration. When this counter has\n reached the length of the sequence the loop terminates. This means\n that if the suite deletes the current (or a previous) item from the\n sequence, the next item will be skipped (since it gets the index of\n the current item which has already been treated). Likewise, if the\n suite inserts an item in the sequence before the current item, the\n current item will be treated again the next time through the loop.\n This can lead to nasty bugs that can be avoided by making a\n temporary copy using a slice of the whole sequence, e.g.,\n\n for x in a[:]:\n if x < 0: a.remove(x)\n',
- 'formatstrings': u'\nFormat String Syntax\n********************\n\nThe "str.format()" method and the "Formatter" class share the same\nsyntax for format strings (although in the case of "Formatter",\nsubclasses can define their own format string syntax).\n\nFormat strings contain "replacement fields" surrounded by curly braces\n"{}". Anything that is not contained in braces is considered literal\ntext, which is copied unchanged to the output. If you need to include\na brace character in the literal text, it can be escaped by doubling:\n"{{" and "}}".\n\nThe grammar for a replacement field is as follows:\n\n replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"\n field_name ::= arg_name ("." attribute_name | "[" element_index "]")*\n arg_name ::= [identifier | integer]\n attribute_name ::= identifier\n element_index ::= integer | index_string\n index_string ::= <any source character except "]"> +\n conversion ::= "r" | "s"\n format_spec ::= <described in the next section>\n\nIn less formal terms, the replacement field can start with a\n*field_name* that specifies the object whose value is to be formatted\nand inserted into the output instead of the replacement field. The\n*field_name* is optionally followed by a *conversion* field, which is\npreceded by an exclamation point "\'!\'", and a *format_spec*, which is\npreceded by a colon "\':\'". These specify a non-default format for the\nreplacement value.\n\nSee also the Format Specification Mini-Language section.\n\nThe *field_name* itself begins with an *arg_name* that is either a\nnumber or a keyword. If it\'s a number, it refers to a positional\nargument, and if it\'s a keyword, it refers to a named keyword\nargument. If the numerical arg_names in a format string are 0, 1, 2,\n... in sequence, they can all be omitted (not just some) and the\nnumbers 0, 1, 2, ... will be automatically inserted in that order.\nBecause *arg_name* is not quote-delimited, it is not possible to\nspecify arbitrary dictionary keys (e.g., the strings "\'10\'" or\n"\':-]\'") within a format string. The *arg_name* can be followed by any\nnumber of index or attribute expressions. An expression of the form\n"\'.name\'" selects the named attribute using "getattr()", while an\nexpression of the form "\'[index]\'" does an index lookup using\n"__getitem__()".\n\nChanged in version 2.7: The positional argument specifiers can be\nomitted, so "\'{} {}\'" is equivalent to "\'{0} {1}\'".\n\nSome simple format string examples:\n\n "First, thou shalt count to {0}" # References first positional argument\n "Bring me a {}" # Implicitly references the first positional argument\n "From {} to {}" # Same as "From {0} to {1}"\n "My quest is {name}" # References keyword argument \'name\'\n "Weight in tons {0.weight}" # \'weight\' attribute of first positional arg\n "Units destroyed: {players[0]}" # First element of keyword argument \'players\'.\n\nThe *conversion* field causes a type coercion before formatting.\nNormally, the job of formatting a value is done by the "__format__()"\nmethod of the value itself. However, in some cases it is desirable to\nforce a type to be formatted as a string, overriding its own\ndefinition of formatting. By converting the value to a string before\ncalling "__format__()", the normal formatting logic is bypassed.\n\nTwo conversion flags are currently supported: "\'!s\'" which calls\n"str()" on the value, and "\'!r\'" which calls "repr()".\n\nSome examples:\n\n "Harold\'s a clever {0!s}" # Calls str() on the argument first\n "Bring out the holy {name!r}" # Calls repr() on the argument first\n\nThe *format_spec* field contains a specification of how the value\nshould be presented, including such details as field width, alignment,\npadding, decimal precision and so on. Each value type can define its\nown "formatting mini-language" or interpretation of the *format_spec*.\n\nMost built-in types support a common formatting mini-language, which\nis described in the next section.\n\nA *format_spec* field can also include nested replacement fields\nwithin it. These nested replacement fields may contain a field name,\nconversion flag and format specification, but deeper nesting is not\nallowed. The replacement fields within the format_spec are\nsubstituted before the *format_spec* string is interpreted. This\nallows the formatting of a value to be dynamically specified.\n\nSee the Format examples section for some examples.\n\n\nFormat Specification Mini-Language\n==================================\n\n"Format specifications" are used within replacement fields contained\nwithin a format string to define how individual values are presented\n(see Format String Syntax). They can also be passed directly to the\nbuilt-in "format()" function. Each formattable type may define how\nthe format specification is to be interpreted.\n\nMost built-in types implement the following options for format\nspecifications, although some of the formatting options are only\nsupported by the numeric types.\n\nA general convention is that an empty format string ("""") produces\nthe same result as if you had called "str()" on the value. A non-empty\nformat string typically modifies the result.\n\nThe general form of a *standard format specifier* is:\n\n format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]\n fill ::= <any character>\n align ::= "<" | ">" | "=" | "^"\n sign ::= "+" | "-" | " "\n width ::= integer\n precision ::= integer\n type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"\n\nIf a valid *align* value is specified, it can be preceded by a *fill*\ncharacter that can be any character and defaults to a space if\nomitted. It is not possible to use a literal curly brace (""{"" or\n""}"") as the *fill* character when using the "str.format()" method.\nHowever, it is possible to insert a curly brace with a nested\nreplacement field. This limitation doesn\'t affect the "format()"\nfunction.\n\nThe meaning of the various alignment options is as follows:\n\n +-----------+------------------------------------------------------------+\n | Option | Meaning |\n +===========+============================================================+\n | "\'<\'" | Forces the field to be left-aligned within the available |\n | | space (this is the default for most objects). |\n +-----------+------------------------------------------------------------+\n | "\'>\'" | Forces the field to be right-aligned within the available |\n | | space (this is the default for numbers). |\n +-----------+------------------------------------------------------------+\n | "\'=\'" | Forces the padding to be placed after the sign (if any) |\n | | but before the digits. This is used for printing fields |\n | | in the form \'+000000120\'. This alignment option is only |\n | | valid for numeric types. It becomes the default when \'0\' |\n | | immediately precedes the field width. |\n +-----------+------------------------------------------------------------+\n | "\'^\'" | Forces the field to be centered within the available |\n | | space. |\n +-----------+------------------------------------------------------------+\n\nNote that unless a minimum field width is defined, the field width\nwill always be the same size as the data to fill it, so that the\nalignment option has no meaning in this case.\n\nThe *sign* option is only valid for number types, and can be one of\nthe following:\n\n +-----------+------------------------------------------------------------+\n | Option | Meaning |\n +===========+============================================================+\n | "\'+\'" | indicates that a sign should be used for both positive as |\n | | well as negative numbers. |\n +-----------+------------------------------------------------------------+\n | "\'-\'" | indicates that a sign should be used only for negative |\n | | numbers (this is the default behavior). |\n +-----------+------------------------------------------------------------+\n | space | indicates that a leading space should be used on positive |\n | | numbers, and a minus sign on negative numbers. |\n +-----------+------------------------------------------------------------+\n\nThe "\'#\'" option is only valid for integers, and only for binary,\noctal, or hexadecimal output. If present, it specifies that the\noutput will be prefixed by "\'0b\'", "\'0o\'", or "\'0x\'", respectively.\n\nThe "\',\'" option signals the use of a comma for a thousands separator.\nFor a locale aware separator, use the "\'n\'" integer presentation type\ninstead.\n\nChanged in version 2.7: Added the "\',\'" option (see also **PEP 378**).\n\n*width* is a decimal integer defining the minimum field width. If not\nspecified, then the field width will be determined by the content.\n\nWhen no explicit alignment is given, preceding the *width* field by a\nzero ("\'0\'") character enables sign-aware zero-padding for numeric\ntypes. This is equivalent to a *fill* character of "\'0\'" with an\n*alignment* type of "\'=\'".\n\nThe *precision* is a decimal number indicating how many digits should\nbe displayed after the decimal point for a floating point value\nformatted with "\'f\'" and "\'F\'", or before and after the decimal point\nfor a floating point value formatted with "\'g\'" or "\'G\'". For non-\nnumber types the field indicates the maximum field size - in other\nwords, how many characters will be used from the field content. The\n*precision* is not allowed for integer values.\n\nFinally, the *type* determines how the data should be presented.\n\nThe available string presentation types are:\n\n +-----------+------------------------------------------------------------+\n | Type | Meaning |\n +===========+============================================================+\n | "\'s\'" | String format. This is the default type for strings and |\n | | may be omitted. |\n +-----------+------------------------------------------------------------+\n | None | The same as "\'s\'". |\n +-----------+------------------------------------------------------------+\n\nThe available integer presentation types are:\n\n +-----------+------------------------------------------------------------+\n | Type | Meaning |\n +===========+============================================================+\n | "\'b\'" | Binary format. Outputs the number in base 2. |\n +-----------+------------------------------------------------------------+\n | "\'c\'" | Character. Converts the integer to the corresponding |\n | | unicode character before printing. |\n +-----------+------------------------------------------------------------+\n | "\'d\'" | Decimal Integer. Outputs the number in base 10. |\n +-----------+------------------------------------------------------------+\n | "\'o\'" | Octal format. Outputs the number in base 8. |\n +-----------+------------------------------------------------------------+\n | "\'x\'" | Hex format. Outputs the number in base 16, using lower- |\n | | case letters for the digits above 9. |\n +-----------+------------------------------------------------------------+\n | "\'X\'" | Hex format. Outputs the number in base 16, using upper- |\n | | case letters for the digits above 9. |\n +-----------+------------------------------------------------------------+\n | "\'n\'" | Number. This is the same as "\'d\'", except that it uses the |\n | | current locale setting to insert the appropriate number |\n | | separator characters. |\n +-----------+------------------------------------------------------------+\n | None | The same as "\'d\'". |\n +-----------+------------------------------------------------------------+\n\nIn addition to the above presentation types, integers can be formatted\nwith the floating point presentation types listed below (except "\'n\'"\nand "None"). When doing so, "float()" is used to convert the integer\nto a floating point number before formatting.\n\nThe available presentation types for floating point and decimal values\nare:\n\n +-----------+------------------------------------------------------------+\n | Type | Meaning |\n +===========+============================================================+\n | "\'e\'" | Exponent notation. Prints the number in scientific |\n | | notation using the letter \'e\' to indicate the exponent. |\n | | The default precision is "6". |\n +-----------+------------------------------------------------------------+\n | "\'E\'" | Exponent notation. Same as "\'e\'" except it uses an upper |\n | | case \'E\' as the separator character. |\n +-----------+------------------------------------------------------------+\n | "\'f\'" | Fixed point. Displays the number as a fixed-point number. |\n | | The default precision is "6". |\n +-----------+------------------------------------------------------------+\n | "\'F\'" | Fixed point. Same as "\'f\'". |\n +-----------+------------------------------------------------------------+\n | "\'g\'" | General format. For a given precision "p >= 1", this |\n | | rounds the number to "p" significant digits and then |\n | | formats the result in either fixed-point format or in |\n | | scientific notation, depending on its magnitude. The |\n | | precise rules are as follows: suppose that the result |\n | | formatted with presentation type "\'e\'" and precision "p-1" |\n | | would have exponent "exp". Then if "-4 <= exp < p", the |\n | | number is formatted with presentation type "\'f\'" and |\n | | precision "p-1-exp". Otherwise, the number is formatted |\n | | with presentation type "\'e\'" and precision "p-1". In both |\n | | cases insignificant trailing zeros are removed from the |\n | | significand, and the decimal point is also removed if |\n | | there are no remaining digits following it. Positive and |\n | | negative infinity, positive and negative zero, and nans, |\n | | are formatted as "inf", "-inf", "0", "-0" and "nan" |\n | | respectively, regardless of the precision. A precision of |\n | | "0" is treated as equivalent to a precision of "1". The |\n | | default precision is "6". |\n +-----------+------------------------------------------------------------+\n | "\'G\'" | General format. Same as "\'g\'" except switches to "\'E\'" if |\n | | the number gets too large. The representations of infinity |\n | | and NaN are uppercased, too. |\n +-----------+------------------------------------------------------------+\n | "\'n\'" | Number. This is the same as "\'g\'", except that it uses the |\n | | current locale setting to insert the appropriate number |\n | | separator characters. |\n +-----------+------------------------------------------------------------+\n | "\'%\'" | Percentage. Multiplies the number by 100 and displays in |\n | | fixed ("\'f\'") format, followed by a percent sign. |\n +-----------+------------------------------------------------------------+\n | None | The same as "\'g\'". |\n +-----------+------------------------------------------------------------+\n\n\nFormat examples\n===============\n\nThis section contains examples of the "str.format()" syntax and\ncomparison with the old "%"-formatting.\n\nIn most of the cases the syntax is similar to the old "%"-formatting,\nwith the addition of the "{}" and with ":" used instead of "%". For\nexample, "\'%03.2f\'" can be translated to "\'{:03.2f}\'".\n\nThe new format syntax also supports new and different options, shown\nin the follow examples.\n\nAccessing arguments by position:\n\n >>> \'{0}, {1}, {2}\'.format(\'a\', \'b\', \'c\')\n \'a, b, c\'\n >>> \'{}, {}, {}\'.format(\'a\', \'b\', \'c\') # 2.7+ only\n \'a, b, c\'\n >>> \'{2}, {1}, {0}\'.format(\'a\', \'b\', \'c\')\n \'c, b, a\'\n >>> \'{2}, {1}, {0}\'.format(*\'abc\') # unpacking argument sequence\n \'c, b, a\'\n >>> \'{0}{1}{0}\'.format(\'abra\', \'cad\') # arguments\' indices can be repeated\n \'abracadabra\'\n\nAccessing arguments by name:\n\n >>> \'Coordinates: {latitude}, {longitude}\'.format(latitude=\'37.24N\', longitude=\'-115.81W\')\n \'Coordinates: 37.24N, -115.81W\'\n >>> coord = {\'latitude\': \'37.24N\', \'longitude\': \'-115.81W\'}\n >>> \'Coordinates: {latitude}, {longitude}\'.format(**coord)\n \'Coordinates: 37.24N, -115.81W\'\n\nAccessing arguments\' attributes:\n\n >>> c = 3-5j\n >>> (\'The complex number {0} is formed from the real part {0.real} \'\n ... \'and the imaginary part {0.imag}.\').format(c)\n \'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.\'\n >>> class Point(object):\n ... def __init__(self, x, y):\n ... self.x, self.y = x, y\n ... def __str__(self):\n ... return \'Point({self.x}, {self.y})\'.format(self=self)\n ...\n >>> str(Point(4, 2))\n \'Point(4, 2)\'\n\nAccessing arguments\' items:\n\n >>> coord = (3, 5)\n >>> \'X: {0[0]}; Y: {0[1]}\'.format(coord)\n \'X: 3; Y: 5\'\n\nReplacing "%s" and "%r":\n\n >>> "repr() shows quotes: {!r}; str() doesn\'t: {!s}".format(\'test1\', \'test2\')\n "repr() shows quotes: \'test1\'; str() doesn\'t: test2"\n\nAligning the text and specifying a width:\n\n >>> \'{:<30}\'.format(\'left aligned\')\n \'left aligned \'\n >>> \'{:>30}\'.format(\'right aligned\')\n \' right aligned\'\n >>> \'{:^30}\'.format(\'centered\')\n \' centered \'\n >>> \'{:*^30}\'.format(\'centered\') # use \'*\' as a fill char\n \'***********centered***********\'\n\nReplacing "%+f", "%-f", and "% f" and specifying a sign:\n\n >>> \'{:+f}; {:+f}\'.format(3.14, -3.14) # show it always\n \'+3.140000; -3.140000\'\n >>> \'{: f}; {: f}\'.format(3.14, -3.14) # show a space for positive numbers\n \' 3.140000; -3.140000\'\n >>> \'{:-f}; {:-f}\'.format(3.14, -3.14) # show only the minus -- same as \'{:f}; {:f}\'\n \'3.140000; -3.140000\'\n\nReplacing "%x" and "%o" and converting the value to different bases:\n\n >>> # format also supports binary numbers\n >>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)\n \'int: 42; hex: 2a; oct: 52; bin: 101010\'\n >>> # with 0x, 0o, or 0b as prefix:\n >>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)\n \'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010\'\n\nUsing the comma as a thousands separator:\n\n >>> \'{:,}\'.format(1234567890)\n \'1,234,567,890\'\n\nExpressing a percentage:\n\n >>> points = 19.5\n >>> total = 22\n >>> \'Correct answers: {:.2%}\'.format(points/total)\n \'Correct answers: 88.64%\'\n\nUsing type-specific formatting:\n\n >>> import datetime\n >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)\n >>> \'{:%Y-%m-%d %H:%M:%S}\'.format(d)\n \'2010-07-04 12:15:58\'\n\nNesting arguments and more complex examples:\n\n >>> for align, text in zip(\'<^>\', [\'left\', \'center\', \'right\']):\n ... \'{0:{fill}{align}16}\'.format(text, fill=align, align=align)\n ...\n \'left<<<<<<<<<<<<\'\n \'^^^^^center^^^^^\'\n \'>>>>>>>>>>>right\'\n >>>\n >>> octets = [192, 168, 0, 1]\n >>> \'{:02X}{:02X}{:02X}{:02X}\'.format(*octets)\n \'C0A80001\'\n >>> int(_, 16)\n 3232235521\n >>>\n >>> width = 5\n >>> for num in range(5,12):\n ... for base in \'dXob\':\n ... print \'{0:{width}{base}}\'.format(num, base=base, width=width),\n ... print\n ...\n 5 5 5 101\n 6 6 6 110\n 7 7 7 111\n 8 8 10 1000\n 9 9 11 1001\n 10 A 12 1010\n 11 B 13 1011\n',
- 'function': u'\nFunction definitions\n********************\n\nA function definition defines a user-defined function object (see\nsection The standard type hierarchy):\n\n decorated ::= decorators (classdef | funcdef)\n decorators ::= decorator+\n decorator ::= "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE\n funcdef ::= "def" funcname "(" [parameter_list] ")" ":" suite\n dotted_name ::= identifier ("." identifier)*\n parameter_list ::= (defparameter ",")*\n ( "*" identifier ["," "**" identifier]\n | "**" identifier\n | defparameter [","] )\n defparameter ::= parameter ["=" expression]\n sublist ::= parameter ("," parameter)* [","]\n parameter ::= identifier | "(" sublist ")"\n funcname ::= identifier\n\nA function definition is an executable statement. Its execution binds\nthe function name in the current local namespace to a function object\n(a wrapper around the executable code for the function). This\nfunction object contains a reference to the current global namespace\nas the global namespace to be used when the function is called.\n\nThe function definition does not execute the function body; this gets\nexecuted only when the function is called. [3]\n\nA function definition may be wrapped by one or more *decorator*\nexpressions. Decorator expressions are evaluated when the function is\ndefined, in the scope that contains the function definition. The\nresult must be a callable, which is invoked with the function object\nas the only argument. The returned value is bound to the function name\ninstead of the function object. Multiple decorators are applied in\nnested fashion. For example, the following code:\n\n @f1(arg)\n @f2\n def func(): pass\n\nis equivalent to:\n\n def func(): pass\n func = f1(arg)(f2(func))\n\nWhen one or more top-level *parameters* have the form *parameter* "="\n*expression*, the function is said to have "default parameter values."\nFor a parameter with a default value, the corresponding *argument* may\nbe omitted from a call, in which case the parameter\'s default value is\nsubstituted. If a parameter has a default value, all following\nparameters must also have a default value --- this is a syntactic\nrestriction that is not expressed by the grammar.\n\n**Default parameter values are evaluated when the function definition\nis executed.** This means that the expression is evaluated once, when\nthe function is defined, and that the same "pre-computed" value is\nused for each call. This is especially important to understand when a\ndefault parameter is a mutable object, such as a list or a dictionary:\nif the function modifies the object (e.g. by appending an item to a\nlist), the default value is in effect modified. This is generally not\nwhat was intended. A way around this is to use "None" as the\ndefault, and explicitly test for it in the body of the function, e.g.:\n\n def whats_on_the_telly(penguin=None):\n if penguin is None:\n penguin = []\n penguin.append("property of the zoo")\n return penguin\n\nFunction call semantics are described in more detail in section Calls.\nA function call always assigns values to all parameters mentioned in\nthe parameter list, either from position arguments, from keyword\narguments, or from default values. If the form ""*identifier"" is\npresent, it is initialized to a tuple receiving any excess positional\nparameters, defaulting to the empty tuple. If the form\n""**identifier"" is present, it is initialized to a new dictionary\nreceiving any excess keyword arguments, defaulting to a new empty\ndictionary.\n\nIt is also possible to create anonymous functions (functions not bound\nto a name), for immediate use in expressions. This uses lambda\nexpressions, described in section Lambdas. Note that the lambda\nexpression is merely a shorthand for a simplified function definition;\na function defined in a ""def"" statement can be passed around or\nassigned to another name just like a function defined by a lambda\nexpression. The ""def"" form is actually more powerful since it\nallows the execution of multiple statements.\n\n**Programmer\'s note:** Functions are first-class objects. A ""def""\nform executed inside a function definition defines a local function\nthat can be returned or passed around. Free variables used in the\nnested function can access the local variables of the function\ncontaining the def. See section Naming and binding for details.\n',
- 'global': u'\nThe "global" statement\n**********************\n\n global_stmt ::= "global" identifier ("," identifier)*\n\nThe "global" statement is a declaration which holds for the entire\ncurrent code block. It means that the listed identifiers are to be\ninterpreted as globals. It would be impossible to assign to a global\nvariable without "global", although free variables may refer to\nglobals without being declared global.\n\nNames listed in a "global" statement must not be used in the same code\nblock textually preceding that "global" statement.\n\nNames listed in a "global" statement must not be defined as formal\nparameters or in a "for" loop control target, "class" definition,\nfunction definition, or "import" statement.\n\n**CPython implementation detail:** The current implementation does not\nenforce the latter two restrictions, but programs should not abuse\nthis freedom, as future implementations may enforce them or silently\nchange the meaning of the program.\n\n**Programmer\'s note:** the "global" is a directive to the parser. It\napplies only to code parsed at the same time as the "global"\nstatement. In particular, a "global" statement contained in an "exec"\nstatement does not affect the code block *containing* the "exec"\nstatement, and code contained in an "exec" statement is unaffected by\n"global" statements in the code containing the "exec" statement. The\nsame applies to the "eval()", "execfile()" and "compile()" functions.\n',
- 'id-classes': u'\nReserved classes of identifiers\n*******************************\n\nCertain classes of identifiers (besides keywords) have special\nmeanings. These classes are identified by the patterns of leading and\ntrailing underscore characters:\n\n"_*"\n Not imported by "from module import *". The special identifier "_"\n is used in the interactive interpreter to store the result of the\n last evaluation; it is stored in the "__builtin__" module. When\n not in interactive mode, "_" has no special meaning and is not\n defined. See section The import statement.\n\n Note: The name "_" is often used in conjunction with\n internationalization; refer to the documentation for the\n "gettext" module for more information on this convention.\n\n"__*__"\n System-defined names. These names are defined by the interpreter\n and its implementation (including the standard library). Current\n system names are discussed in the Special method names section and\n elsewhere. More will likely be defined in future versions of\n Python. *Any* use of "__*__" names, in any context, that does not\n follow explicitly documented use, is subject to breakage without\n warning.\n\n"__*"\n Class-private names. Names in this category, when used within the\n context of a class definition, are re-written to use a mangled form\n to help avoid name clashes between "private" attributes of base and\n derived classes. See section Identifiers (Names).\n',
- 'identifiers': u'\nIdentifiers and keywords\n************************\n\nIdentifiers (also referred to as *names*) are described by the\nfollowing lexical definitions:\n\n identifier ::= (letter|"_") (letter | digit | "_")*\n letter ::= lowercase | uppercase\n lowercase ::= "a"..."z"\n uppercase ::= "A"..."Z"\n digit ::= "0"..."9"\n\nIdentifiers are unlimited in length. Case is significant.\n\n\nKeywords\n========\n\nThe following identifiers are used as reserved words, or *keywords* of\nthe language, and cannot be used as ordinary identifiers. They must\nbe spelled exactly as written here:\n\n and del from not while\n as elif global or with\n assert else if pass yield\n break except import print\n class exec in raise\n continue finally is return\n def for lambda try\n\nChanged in version 2.4: "None" became a constant and is now recognized\nby the compiler as a name for the built-in object "None". Although it\nis not a keyword, you cannot assign a different object to it.\n\nChanged in version 2.5: Using "as" and "with" as identifiers triggers\na warning. To use them as keywords, enable the "with_statement"\nfuture feature .\n\nChanged in version 2.6: "as" and "with" are full keywords.\n\n\nReserved classes of identifiers\n===============================\n\nCertain classes of identifiers (besides keywords) have special\nmeanings. These classes are identified by the patterns of leading and\ntrailing underscore characters:\n\n"_*"\n Not imported by "from module import *". The special identifier "_"\n is used in the interactive interpreter to store the result of the\n last evaluation; it is stored in the "__builtin__" module. When\n not in interactive mode, "_" has no special meaning and is not\n defined. See section The import statement.\n\n Note: The name "_" is often used in conjunction with\n internationalization; refer to the documentation for the\n "gettext" module for more information on this convention.\n\n"__*__"\n System-defined names. These names are defined by the interpreter\n and its implementation (including the standard library). Current\n system names are discussed in the Special method names section and\n elsewhere. More will likely be defined in future versions of\n Python. *Any* use of "__*__" names, in any context, that does not\n follow explicitly documented use, is subject to breakage without\n warning.\n\n"__*"\n Class-private names. Names in this category, when used within the\n context of a class definition, are re-written to use a mangled form\n to help avoid name clashes between "private" attributes of base and\n derived classes. See section Identifiers (Names).\n',
- 'if': u'\nThe "if" statement\n******************\n\nThe "if" statement is used for conditional execution:\n\n if_stmt ::= "if" expression ":" suite\n ( "elif" expression ":" suite )*\n ["else" ":" suite]\n\nIt selects exactly one of the suites by evaluating the expressions one\nby one until one is found to be true (see section Boolean operations\nfor the definition of true and false); then that suite is executed\n(and no other part of the "if" statement is executed or evaluated).\nIf all expressions are false, the suite of the "else" clause, if\npresent, is executed.\n',
- 'imaginary': u'\nImaginary literals\n******************\n\nImaginary literals are described by the following lexical definitions:\n\n imagnumber ::= (floatnumber | intpart) ("j" | "J")\n\nAn imaginary literal yields a complex number with a real part of 0.0.\nComplex numbers are represented as a pair of floating point numbers\nand have the same restrictions on their range. To create a complex\nnumber with a nonzero real part, add a floating point number to it,\ne.g., "(3+4j)". Some examples of imaginary literals:\n\n 3.14j 10.j 10j .001j 1e100j 3.14e-10j\n',
- 'import': u'\nThe "import" statement\n**********************\n\n import_stmt ::= "import" module ["as" name] ( "," module ["as" name] )*\n | "from" relative_module "import" identifier ["as" name]\n ( "," identifier ["as" name] )*\n | "from" relative_module "import" "(" identifier ["as" name]\n ( "," identifier ["as" name] )* [","] ")"\n | "from" module "import" "*"\n module ::= (identifier ".")* identifier\n relative_module ::= "."* module | "."+\n name ::= identifier\n\nImport statements are executed in two steps: (1) find a module, and\ninitialize it if necessary; (2) define a name or names in the local\nnamespace (of the scope where the "import" statement occurs). The\nstatement comes in two forms differing on whether it uses the "from"\nkeyword. The first form (without "from") repeats these steps for each\nidentifier in the list. The form with "from" performs step (1) once,\nand then performs step (2) repeatedly.\n\nTo understand how step (1) occurs, one must first understand how\nPython handles hierarchical naming of modules. To help organize\nmodules and provide a hierarchy in naming, Python has a concept of\npackages. A package can contain other packages and modules while\nmodules cannot contain other modules or packages. From a file system\nperspective, packages are directories and modules are files.\n\nOnce the name of the module is known (unless otherwise specified, the\nterm "module" will refer to both packages and modules), searching for\nthe module or package can begin. The first place checked is\n"sys.modules", the cache of all modules that have been imported\npreviously. If the module is found there then it is used in step (2)\nof import.\n\nIf the module is not found in the cache, then "sys.meta_path" is\nsearched (the specification for "sys.meta_path" can be found in **PEP\n302**). The object is a list of *finder* objects which are queried in\norder as to whether they know how to load the module by calling their\n"find_module()" method with the name of the module. If the module\nhappens to be contained within a package (as denoted by the existence\nof a dot in the name), then a second argument to "find_module()" is\ngiven as the value of the "__path__" attribute from the parent package\n(everything up to the last dot in the name of the module being\nimported). If a finder can find the module it returns a *loader*\n(discussed later) or returns "None".\n\nIf none of the finders on "sys.meta_path" are able to find the module\nthen some implicitly defined finders are queried. Implementations of\nPython vary in what implicit meta path finders are defined. The one\nthey all do define, though, is one that handles "sys.path_hooks",\n"sys.path_importer_cache", and "sys.path".\n\nThe implicit finder searches for the requested module in the "paths"\nspecified in one of two places ("paths" do not have to be file system\npaths). If the module being imported is supposed to be contained\nwithin a package then the second argument passed to "find_module()",\n"__path__" on the parent package, is used as the source of paths. If\nthe module is not contained in a package then "sys.path" is used as\nthe source of paths.\n\nOnce the source of paths is chosen it is iterated over to find a\nfinder that can handle that path. The dict at\n"sys.path_importer_cache" caches finders for paths and is checked for\na finder. If the path does not have a finder cached then\n"sys.path_hooks" is searched by calling each object in the list with a\nsingle argument of the path, returning a finder or raises\n"ImportError". If a finder is returned then it is cached in\n"sys.path_importer_cache" and then used for that path entry. If no\nfinder can be found but the path exists then a value of "None" is\nstored in "sys.path_importer_cache" to signify that an implicit, file-\nbased finder that handles modules stored as individual files should be\nused for that path. If the path does not exist then a finder which\nalways returns "None" is placed in the cache for the path.\n\nIf no finder can find the module then "ImportError" is raised.\nOtherwise some finder returned a loader whose "load_module()" method\nis called with the name of the module to load (see **PEP 302** for the\noriginal definition of loaders). A loader has several responsibilities\nto perform on a module it loads. First, if the module already exists\nin "sys.modules" (a possibility if the loader is called outside of the\nimport machinery) then it is to use that module for initialization and\nnot a new module. But if the module does not exist in "sys.modules"\nthen it is to be added to that dict before initialization begins. If\nan error occurs during loading of the module and it was added to\n"sys.modules" it is to be removed from the dict. If an error occurs\nbut the module was already in "sys.modules" it is left in the dict.\n\nThe loader must set several attributes on the module. "__name__" is to\nbe set to the name of the module. "__file__" is to be the "path" to\nthe file unless the module is built-in (and thus listed in\n"sys.builtin_module_names") in which case the attribute is not set. If\nwhat is being imported is a package then "__path__" is to be set to a\nlist of paths to be searched when looking for modules and packages\ncontained within the package being imported. "__package__" is optional\nbut should be set to the name of package that contains the module or\npackage (the empty string is used for module not contained in a\npackage). "__loader__" is also optional but should be set to the\nloader object that is loading the module.\n\nIf an error occurs during loading then the loader raises "ImportError"\nif some other exception is not already being propagated. Otherwise the\nloader returns the module that was loaded and initialized.\n\nWhen step (1) finishes without raising an exception, step (2) can\nbegin.\n\nThe first form of "import" statement binds the module name in the\nlocal namespace to the module object, and then goes on to import the\nnext identifier, if any. If the module name is followed by "as", the\nname following "as" is used as the local name for the module.\n\nThe "from" form does not bind the module name: it goes through the\nlist of identifiers, looks each one of them up in the module found in\nstep (1), and binds the name in the local namespace to the object thus\nfound. As with the first form of "import", an alternate local name\ncan be supplied by specifying ""as" localname". If a name is not\nfound, "ImportError" is raised. If the list of identifiers is\nreplaced by a star ("\'*\'"), all public names defined in the module are\nbound in the local namespace of the "import" statement..\n\nThe *public names* defined by a module are determined by checking the\nmodule\'s namespace for a variable named "__all__"; if defined, it must\nbe a sequence of strings which are names defined or imported by that\nmodule. The names given in "__all__" are all considered public and\nare required to exist. If "__all__" is not defined, the set of public\nnames includes all names found in the module\'s namespace which do not\nbegin with an underscore character ("\'_\'"). "__all__" should contain\nthe entire public API. It is intended to avoid accidentally exporting\nitems that are not part of the API (such as library modules which were\nimported and used within the module).\n\nThe "from" form with "*" may only occur in a module scope. If the\nwild card form of import --- "import *" --- is used in a function and\nthe function contains or is a nested block with free variables, the\ncompiler will raise a "SyntaxError".\n\nWhen specifying what module to import you do not have to specify the\nabsolute name of the module. When a module or package is contained\nwithin another package it is possible to make a relative import within\nthe same top package without having to mention the package name. By\nusing leading dots in the specified module or package after "from" you\ncan specify how high to traverse up the current package hierarchy\nwithout specifying exact names. One leading dot means the current\npackage where the module making the import exists. Two dots means up\none package level. Three dots is up two levels, etc. So if you execute\n"from . import mod" from a module in the "pkg" package then you will\nend up importing "pkg.mod". If you execute "from ..subpkg2 import mod"\nfrom within "pkg.subpkg1" you will import "pkg.subpkg2.mod". The\nspecification for relative imports is contained within **PEP 328**.\n\n"importlib.import_module()" is provided to support applications that\ndetermine which modules need to be loaded dynamically.\n\n\nFuture statements\n=================\n\nA *future statement* is a directive to the compiler that a particular\nmodule should be compiled using syntax or semantics that will be\navailable in a specified future release of Python. The future\nstatement is intended to ease migration to future versions of Python\nthat introduce incompatible changes to the language. It allows use of\nthe new features on a per-module basis before the release in which the\nfeature becomes standard.\n\n future_statement ::= "from" "__future__" "import" feature ["as" name]\n ("," feature ["as" name])*\n | "from" "__future__" "import" "(" feature ["as" name]\n ("," feature ["as" name])* [","] ")"\n feature ::= identifier\n name ::= identifier\n\nA future statement must appear near the top of the module. The only\nlines that can appear before a future statement are:\n\n* the module docstring (if any),\n\n* comments,\n\n* blank lines, and\n\n* other future statements.\n\nThe features recognized by Python 2.6 are "unicode_literals",\n"print_function", "absolute_import", "division", "generators",\n"nested_scopes" and "with_statement". "generators", "with_statement",\n"nested_scopes" are redundant in Python version 2.6 and above because\nthey are always enabled.\n\nA future statement is recognized and treated specially at compile\ntime: Changes to the semantics of core constructs are often\nimplemented by generating different code. It may even be the case\nthat a new feature introduces new incompatible syntax (such as a new\nreserved word), in which case the compiler may need to parse the\nmodule differently. Such decisions cannot be pushed off until\nruntime.\n\nFor any given release, the compiler knows which feature names have\nbeen defined, and raises a compile-time error if a future statement\ncontains a feature not known to it.\n\nThe direct runtime semantics are the same as for any import statement:\nthere is a standard module "__future__", described later, and it will\nbe imported in the usual way at the time the future statement is\nexecuted.\n\nThe interesting runtime semantics depend on the specific feature\nenabled by the future statement.\n\nNote that there is nothing special about the statement:\n\n import __future__ [as name]\n\nThat is not a future statement; it\'s an ordinary import statement with\nno special semantics or syntax restrictions.\n\nCode compiled by an "exec" statement or calls to the built-in\nfunctions "compile()" and "execfile()" that occur in a module "M"\ncontaining a future statement will, by default, use the new syntax or\nsemantics associated with the future statement. This can, starting\nwith Python 2.2 be controlled by optional arguments to "compile()" ---\nsee the documentation of that function for details.\n\nA future statement typed at an interactive interpreter prompt will\ntake effect for the rest of the interpreter session. If an\ninterpreter is started with the "-i" option, is passed a script name\nto execute, and the script includes a future statement, it will be in\neffect in the interactive session started after the script is\nexecuted.\n\nSee also:\n\n **PEP 236** - Back to the __future__\n The original proposal for the __future__ mechanism.\n',
- 'in': u'\nComparisons\n***********\n\nUnlike C, all comparison operations in Python have the same priority,\nwhich is lower than that of any arithmetic, shifting or bitwise\noperation. Also unlike C, expressions like "a < b < c" have the\ninterpretation that is conventional in mathematics:\n\n comparison ::= or_expr ( comp_operator or_expr )*\n comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "<>" | "!="\n | "is" ["not"] | ["not"] "in"\n\nComparisons yield boolean values: "True" or "False".\n\nComparisons can be chained arbitrarily, e.g., "x < y <= z" is\nequivalent to "x < y and y <= z", except that "y" is evaluated only\nonce (but in both cases "z" is not evaluated at all when "x < y" is\nfound to be false).\n\nFormally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and *op1*,\n*op2*, ..., *opN* are comparison operators, then "a op1 b op2 c ... y\nopN z" is equivalent to "a op1 b and b op2 c and ... y opN z", except\nthat each expression is evaluated at most once.\n\nNote that "a op1 b op2 c" doesn\'t imply any kind of comparison between\n*a* and *c*, so that, e.g., "x < y > z" is perfectly legal (though\nperhaps not pretty).\n\nThe forms "<>" and "!=" are equivalent; for consistency with C, "!="\nis preferred; where "!=" is mentioned below "<>" is also accepted.\nThe "<>" spelling is considered obsolescent.\n\nThe operators "<", ">", "==", ">=", "<=", and "!=" compare the values\nof two objects. The objects need not have the same type. If both are\nnumbers, they are converted to a common type. Otherwise, objects of\ndifferent types *always* compare unequal, and are ordered consistently\nbut arbitrarily. You can control comparison behavior of objects of\nnon-built-in types by defining a "__cmp__" method or rich comparison\nmethods like "__gt__", described in section Special method names.\n\n(This unusual definition of comparison was used to simplify the\ndefinition of operations like sorting and the "in" and "not in"\noperators. In the future, the comparison rules for objects of\ndifferent types are likely to change.)\n\nComparison of objects of the same type depends on the type:\n\n* Numbers are compared arithmetically.\n\n* Strings are compared lexicographically using the numeric\n equivalents (the result of the built-in function "ord()") of their\n characters. Unicode and 8-bit strings are fully interoperable in\n this behavior. [4]\n\n* Tuples and lists are compared lexicographically using comparison\n of corresponding elements. This means that to compare equal, each\n element must compare equal and the two sequences must be of the same\n type and have the same length.\n\n If not equal, the sequences are ordered the same as their first\n differing elements. For example, "cmp([1,2,x], [1,2,y])" returns\n the same as "cmp(x,y)". If the corresponding element does not\n exist, the shorter sequence is ordered first (for example, "[1,2] <\n [1,2,3]").\n\n* Mappings (dictionaries) compare equal if and only if their sorted\n (key, value) lists compare equal. [5] Outcomes other than equality\n are resolved consistently, but are not otherwise defined. [6]\n\n* Most other objects of built-in types compare unequal unless they\n are the same object; the choice whether one object is considered\n smaller or larger than another one is made arbitrarily but\n consistently within one execution of a program.\n\nThe operators "in" and "not in" test for collection membership. "x in\ns" evaluates to true if *x* is a member of the collection *s*, and\nfalse otherwise. "x not in s" returns the negation of "x in s". The\ncollection membership test has traditionally been bound to sequences;\nan object is a member of a collection if the collection is a sequence\nand contains an element equal to that object. However, it make sense\nfor many other object types to support membership tests without being\na sequence. In particular, dictionaries (for keys) and sets support\nmembership testing.\n\nFor the list and tuple types, "x in y" is true if and only if there\nexists an index *i* such that either "x is y[i]" or "x == y[i]" is\ntrue.\n\nFor the Unicode and string types, "x in y" is true if and only if *x*\nis a substring of *y*. An equivalent test is "y.find(x) != -1".\nNote, *x* and *y* need not be the same type; consequently, "u\'ab\' in\n\'abc\'" will return "True". Empty strings are always considered to be a\nsubstring of any other string, so """ in "abc"" will return "True".\n\nChanged in version 2.3: Previously, *x* was required to be a string of\nlength "1".\n\nFor user-defined classes which define the "__contains__()" method, "x\nin y" is true if and only if "y.__contains__(x)" is true.\n\nFor user-defined classes which do not define "__contains__()" but do\ndefine "__iter__()", "x in y" is true if some value "z" with "x == z"\nis produced while iterating over "y". If an exception is raised\nduring the iteration, it is as if "in" raised that exception.\n\nLastly, the old-style iteration protocol is tried: if a class defines\n"__getitem__()", "x in y" is true if and only if there is a non-\nnegative integer index *i* such that "x == y[i]", and all lower\ninteger indices do not raise "IndexError" exception. (If any other\nexception is raised, it is as if "in" raised that exception).\n\nThe operator "not in" is defined to have the inverse true value of\n"in".\n\nThe operators "is" and "is not" test for object identity: "x is y" is\ntrue if and only if *x* and *y* are the same object. "x is not y"\nyields the inverse truth value. [7]\n',
- 'integers': u'\nInteger and long integer literals\n*********************************\n\nInteger and long integer literals are described by the following\nlexical definitions:\n\n longinteger ::= integer ("l" | "L")\n integer ::= decimalinteger | octinteger | hexinteger | bininteger\n decimalinteger ::= nonzerodigit digit* | "0"\n octinteger ::= "0" ("o" | "O") octdigit+ | "0" octdigit+\n hexinteger ::= "0" ("x" | "X") hexdigit+\n bininteger ::= "0" ("b" | "B") bindigit+\n nonzerodigit ::= "1"..."9"\n octdigit ::= "0"..."7"\n bindigit ::= "0" | "1"\n hexdigit ::= digit | "a"..."f" | "A"..."F"\n\nAlthough both lower case "\'l\'" and upper case "\'L\'" are allowed as\nsuffix for long integers, it is strongly recommended to always use\n"\'L\'", since the letter "\'l\'" looks too much like the digit "\'1\'".\n\nPlain integer literals that are above the largest representable plain\ninteger (e.g., 2147483647 when using 32-bit arithmetic) are accepted\nas if they were long integers instead. [1] There is no limit for long\ninteger literals apart from what can be stored in available memory.\n\nSome examples of plain integer literals (first row) and long integer\nliterals (second and third rows):\n\n 7 2147483647 0177\n 3L 79228162514264337593543950336L 0377L 0x100000000L\n 79228162514264337593543950336 0xdeadbeef\n',
- 'lambda': u'\nLambdas\n*******\n\n lambda_expr ::= "lambda" [parameter_list]: expression\n old_lambda_expr ::= "lambda" [parameter_list]: old_expression\n\nLambda expressions (sometimes called lambda forms) have the same\nsyntactic position as expressions. They are a shorthand to create\nanonymous functions; the expression "lambda arguments: expression"\nyields a function object. The unnamed object behaves like a function\nobject defined with\n\n def name(arguments):\n return expression\n\nSee section Function definitions for the syntax of parameter lists.\nNote that functions created with lambda expressions cannot contain\nstatements.\n',
- 'lists': u'\nList displays\n*************\n\nA list display is a possibly empty series of expressions enclosed in\nsquare brackets:\n\n list_display ::= "[" [expression_list | list_comprehension] "]"\n list_comprehension ::= expression list_for\n list_for ::= "for" target_list "in" old_expression_list [list_iter]\n old_expression_list ::= old_expression [("," old_expression)+ [","]]\n old_expression ::= or_test | old_lambda_expr\n list_iter ::= list_for | list_if\n list_if ::= "if" old_expression [list_iter]\n\nA list display yields a new list object. Its contents are specified\nby providing either a list of expressions or a list comprehension.\nWhen a comma-separated list of expressions is supplied, its elements\nare evaluated from left to right and placed into the list object in\nthat order. When a list comprehension is supplied, it consists of a\nsingle expression followed by at least one "for" clause and zero or\nmore "for" or "if" clauses. In this case, the elements of the new\nlist are those that would be produced by considering each of the "for"\nor "if" clauses a block, nesting from left to right, and evaluating\nthe expression to produce a list element each time the innermost block\nis reached [1].\n',
- 'naming': u'\nNaming and binding\n******************\n\n*Names* refer to objects. Names are introduced by name binding\noperations. Each occurrence of a name in the program text refers to\nthe *binding* of that name established in the innermost function block\ncontaining the use.\n\nA *block* is a piece of Python program text that is executed as a\nunit. The following are blocks: a module, a function body, and a class\ndefinition. Each command typed interactively is a block. A script\nfile (a file given as standard input to the interpreter or specified\non the interpreter command line the first argument) is a code block.\nA script command (a command specified on the interpreter command line\nwith the \'**-c**\' option) is a code block. The file read by the\nbuilt-in function "execfile()" is a code block. The string argument\npassed to the built-in function "eval()" and to the "exec" statement\nis a code block. The expression read and evaluated by the built-in\nfunction "input()" is a code block.\n\nA code block is executed in an *execution frame*. A frame contains\nsome administrative information (used for debugging) and determines\nwhere and how execution continues after the code block\'s execution has\ncompleted.\n\nA *scope* defines the visibility of a name within a block. If a local\nvariable is defined in a block, its scope includes that block. If the\ndefinition occurs in a function block, the scope extends to any blocks\ncontained within the defining one, unless a contained block introduces\na different binding for the name. The scope of names defined in a\nclass block is limited to the class block; it does not extend to the\ncode blocks of methods -- this includes generator expressions since\nthey are implemented using a function scope. This means that the\nfollowing will fail:\n\n class A:\n a = 42\n b = list(a + i for i in range(10))\n\nWhen a name is used in a code block, it is resolved using the nearest\nenclosing scope. The set of all such scopes visible to a code block\nis called the block\'s *environment*.\n\nIf a name is bound in a block, it is a local variable of that block.\nIf a name is bound at the module level, it is a global variable. (The\nvariables of the module code block are local and global.) If a\nvariable is used in a code block but not defined there, it is a *free\nvariable*.\n\nWhen a name is not found at all, a "NameError" exception is raised.\nIf the name refers to a local variable that has not been bound, a\n"UnboundLocalError" exception is raised. "UnboundLocalError" is a\nsubclass of "NameError".\n\nThe following constructs bind names: formal parameters to functions,\n"import" statements, class and function definitions (these bind the\nclass or function name in the defining block), and targets that are\nidentifiers if occurring in an assignment, "for" loop header, in the\nsecond position of an "except" clause header or after "as" in a "with"\nstatement. The "import" statement of the form "from ... import *"\nbinds all names defined in the imported module, except those beginning\nwith an underscore. This form may only be used at the module level.\n\nA target occurring in a "del" statement is also considered bound for\nthis purpose (though the actual semantics are to unbind the name). It\nis illegal to unbind a name that is referenced by an enclosing scope;\nthe compiler will report a "SyntaxError".\n\nEach assignment or import statement occurs within a block defined by a\nclass or function definition or at the module level (the top-level\ncode block).\n\nIf a name binding operation occurs anywhere within a code block, all\nuses of the name within the block are treated as references to the\ncurrent block. This can lead to errors when a name is used within a\nblock before it is bound. This rule is subtle. Python lacks\ndeclarations and allows name binding operations to occur anywhere\nwithin a code block. The local variables of a code block can be\ndetermined by scanning the entire text of the block for name binding\noperations.\n\nIf the global statement occurs within a block, all uses of the name\nspecified in the statement refer to the binding of that name in the\ntop-level namespace. Names are resolved in the top-level namespace by\nsearching the global namespace, i.e. the namespace of the module\ncontaining the code block, and the builtins namespace, the namespace\nof the module "__builtin__". The global namespace is searched first.\nIf the name is not found there, the builtins namespace is searched.\nThe global statement must precede all uses of the name.\n\nThe builtins namespace associated with the execution of a code block\nis actually found by looking up the name "__builtins__" in its global\nnamespace; this should be a dictionary or a module (in the latter case\nthe module\'s dictionary is used). By default, when in the "__main__"\nmodule, "__builtins__" is the built-in module "__builtin__" (note: no\n\'s\'); when in any other module, "__builtins__" is an alias for the\ndictionary of the "__builtin__" module itself. "__builtins__" can be\nset to a user-created dictionary to create a weak form of restricted\nexecution.\n\n**CPython implementation detail:** Users should not touch\n"__builtins__"; it is strictly an implementation detail. Users\nwanting to override values in the builtins namespace should "import"\nthe "__builtin__" (no \'s\') module and modify its attributes\nappropriately.\n\nThe namespace for a module is automatically created the first time a\nmodule is imported. The main module for a script is always called\n"__main__".\n\nThe "global" statement has the same scope as a name binding operation\nin the same block. If the nearest enclosing scope for a free variable\ncontains a global statement, the free variable is treated as a global.\n\nA class definition is an executable statement that may use and define\nnames. These references follow the normal rules for name resolution.\nThe namespace of the class definition becomes the attribute dictionary\nof the class. Names defined at the class scope are not visible in\nmethods.\n\n\nInteraction with dynamic features\n=================================\n\nThere are several cases where Python statements are illegal when used\nin conjunction with nested scopes that contain free variables.\n\nIf a variable is referenced in an enclosing scope, it is illegal to\ndelete the name. An error will be reported at compile time.\n\nIf the wild card form of import --- "import *" --- is used in a\nfunction and the function contains or is a nested block with free\nvariables, the compiler will raise a "SyntaxError".\n\nIf "exec" is used in a function and the function contains or is a\nnested block with free variables, the compiler will raise a\n"SyntaxError" unless the exec explicitly specifies the local namespace\nfor the "exec". (In other words, "exec obj" would be illegal, but\n"exec obj in ns" would be legal.)\n\nThe "eval()", "execfile()", and "input()" functions and the "exec"\nstatement do not have access to the full environment for resolving\nnames. Names may be resolved in the local and global namespaces of\nthe caller. Free variables are not resolved in the nearest enclosing\nnamespace, but in the global namespace. [1] The "exec" statement and\nthe "eval()" and "execfile()" functions have optional arguments to\noverride the global and local namespace. If only one namespace is\nspecified, it is used for both.\n',
- 'numbers': u'\nNumeric literals\n****************\n\nThere are four types of numeric literals: plain integers, long\nintegers, floating point numbers, and imaginary numbers. There are no\ncomplex literals (complex numbers can be formed by adding a real\nnumber and an imaginary number).\n\nNote that numeric literals do not include a sign; a phrase like "-1"\nis actually an expression composed of the unary operator \'"-"\' and the\nliteral "1".\n',
- 'numeric-types': u'\nEmulating numeric types\n***********************\n\nThe following methods can be defined to emulate numeric objects.\nMethods corresponding to operations that are not supported by the\nparticular kind of number implemented (e.g., bitwise operations for\nnon-integral numbers) should be left undefined.\n\nobject.__add__(self, other)\nobject.__sub__(self, other)\nobject.__mul__(self, other)\nobject.__floordiv__(self, other)\nobject.__mod__(self, other)\nobject.__divmod__(self, other)\nobject.__pow__(self, other[, modulo])\nobject.__lshift__(self, other)\nobject.__rshift__(self, other)\nobject.__and__(self, other)\nobject.__xor__(self, other)\nobject.__or__(self, other)\n\n These methods are called to implement the binary arithmetic\n operations ("+", "-", "*", "//", "%", "divmod()", "pow()", "**",\n "<<", ">>", "&", "^", "|"). For instance, to evaluate the\n expression "x + y", where *x* is an instance of a class that has an\n "__add__()" method, "x.__add__(y)" is called. The "__divmod__()"\n method should be the equivalent to using "__floordiv__()" and\n "__mod__()"; it should not be related to "__truediv__()" (described\n below). Note that "__pow__()" should be defined to accept an\n optional third argument if the ternary version of the built-in\n "pow()" function is to be supported.\n\n If one of those methods does not support the operation with the\n supplied arguments, it should return "NotImplemented".\n\nobject.__div__(self, other)\nobject.__truediv__(self, other)\n\n The division operator ("/") is implemented by these methods. The\n "__truediv__()" method is used when "__future__.division" is in\n effect, otherwise "__div__()" is used. If only one of these two\n methods is defined, the object will not support division in the\n alternate context; "TypeError" will be raised instead.\n\nobject.__radd__(self, other)\nobject.__rsub__(self, other)\nobject.__rmul__(self, other)\nobject.__rdiv__(self, other)\nobject.__rtruediv__(self, other)\nobject.__rfloordiv__(self, other)\nobject.__rmod__(self, other)\nobject.__rdivmod__(self, other)\nobject.__rpow__(self, other)\nobject.__rlshift__(self, other)\nobject.__rrshift__(self, other)\nobject.__rand__(self, other)\nobject.__rxor__(self, other)\nobject.__ror__(self, other)\n\n These methods are called to implement the binary arithmetic\n operations ("+", "-", "*", "/", "%", "divmod()", "pow()", "**",\n "<<", ">>", "&", "^", "|") with reflected (swapped) operands.\n These functions are only called if the left operand does not\n support the corresponding operation and the operands are of\n different types. [2] For instance, to evaluate the expression "x -\n y", where *y* is an instance of a class that has an "__rsub__()"\n method, "y.__rsub__(x)" is called if "x.__sub__(y)" returns\n *NotImplemented*.\n\n Note that ternary "pow()" will not try calling "__rpow__()" (the\n coercion rules would become too complicated).\n\n Note: If the right operand\'s type is a subclass of the left\n operand\'s type and that subclass provides the reflected method\n for the operation, this method will be called before the left\n operand\'s non-reflected method. This behavior allows subclasses\n to override their ancestors\' operations.\n\nobject.__iadd__(self, other)\nobject.__isub__(self, other)\nobject.__imul__(self, other)\nobject.__idiv__(self, other)\nobject.__itruediv__(self, other)\nobject.__ifloordiv__(self, other)\nobject.__imod__(self, other)\nobject.__ipow__(self, other[, modulo])\nobject.__ilshift__(self, other)\nobject.__irshift__(self, other)\nobject.__iand__(self, other)\nobject.__ixor__(self, other)\nobject.__ior__(self, other)\n\n These methods are called to implement the augmented arithmetic\n assignments ("+=", "-=", "*=", "/=", "//=", "%=", "**=", "<<=",\n ">>=", "&=", "^=", "|="). These methods should attempt to do the\n operation in-place (modifying *self*) and return the result (which\n could be, but does not have to be, *self*). If a specific method\n is not defined, the augmented assignment falls back to the normal\n methods. For instance, to execute the statement "x += y", where\n *x* is an instance of a class that has an "__iadd__()" method,\n "x.__iadd__(y)" is called. If *x* is an instance of a class that\n does not define a "__iadd__()" method, "x.__add__(y)" and\n "y.__radd__(x)" are considered, as with the evaluation of "x + y".\n\nobject.__neg__(self)\nobject.__pos__(self)\nobject.__abs__(self)\nobject.__invert__(self)\n\n Called to implement the unary arithmetic operations ("-", "+",\n "abs()" and "~").\n\nobject.__complex__(self)\nobject.__int__(self)\nobject.__long__(self)\nobject.__float__(self)\n\n Called to implement the built-in functions "complex()", "int()",\n "long()", and "float()". Should return a value of the appropriate\n type.\n\nobject.__oct__(self)\nobject.__hex__(self)\n\n Called to implement the built-in functions "oct()" and "hex()".\n Should return a string value.\n\nobject.__index__(self)\n\n Called to implement "operator.index()". Also called whenever\n Python needs an integer object (such as in slicing). Must return\n an integer (int or long).\n\n New in version 2.5.\n\nobject.__coerce__(self, other)\n\n Called to implement "mixed-mode" numeric arithmetic. Should either\n return a 2-tuple containing *self* and *other* converted to a\n common numeric type, or "None" if conversion is impossible. When\n the common type would be the type of "other", it is sufficient to\n return "None", since the interpreter will also ask the other object\n to attempt a coercion (but sometimes, if the implementation of the\n other type cannot be changed, it is useful to do the conversion to\n the other type here). A return value of "NotImplemented" is\n equivalent to returning "None".\n',
- 'objects': u'\nObjects, values and types\n*************************\n\n*Objects* are Python\'s abstraction for data. All data in a Python\nprogram is represented by objects or by relations between objects. (In\na sense, and in conformance to Von Neumann\'s model of a "stored\nprogram computer," code is also represented by objects.)\n\nEvery object has an identity, a type and a value. An object\'s\n*identity* never changes once it has been created; you may think of it\nas the object\'s address in memory. The \'"is"\' operator compares the\nidentity of two objects; the "id()" function returns an integer\nrepresenting its identity (currently implemented as its address). An\nobject\'s *type* is also unchangeable. [1] An object\'s type determines\nthe operations that the object supports (e.g., "does it have a\nlength?") and also defines the possible values for objects of that\ntype. The "type()" function returns an object\'s type (which is an\nobject itself). The *value* of some objects can change. Objects\nwhose value can change are said to be *mutable*; objects whose value\nis unchangeable once they are created are called *immutable*. (The\nvalue of an immutable container object that contains a reference to a\nmutable object can change when the latter\'s value is changed; however\nthe container is still considered immutable, because the collection of\nobjects it contains cannot be changed. So, immutability is not\nstrictly the same as having an unchangeable value, it is more subtle.)\nAn object\'s mutability is determined by its type; for instance,\nnumbers, strings and tuples are immutable, while dictionaries and\nlists are mutable.\n\nObjects are never explicitly destroyed; however, when they become\nunreachable they may be garbage-collected. An implementation is\nallowed to postpone garbage collection or omit it altogether --- it is\na matter of implementation quality how garbage collection is\nimplemented, as long as no objects are collected that are still\nreachable.\n\n**CPython implementation detail:** CPython currently uses a reference-\ncounting scheme with (optional) delayed detection of cyclically linked\ngarbage, which collects most objects as soon as they become\nunreachable, but is not guaranteed to collect garbage containing\ncircular references. See the documentation of the "gc" module for\ninformation on controlling the collection of cyclic garbage. Other\nimplementations act differently and CPython may change. Do not depend\non immediate finalization of objects when they become unreachable (ex:\nalways close files).\n\nNote that the use of the implementation\'s tracing or debugging\nfacilities may keep objects alive that would normally be collectable.\nAlso note that catching an exception with a \'"try"..."except"\'\nstatement may keep objects alive.\n\nSome objects contain references to "external" resources such as open\nfiles or windows. It is understood that these resources are freed\nwhen the object is garbage-collected, but since garbage collection is\nnot guaranteed to happen, such objects also provide an explicit way to\nrelease the external resource, usually a "close()" method. Programs\nare strongly recommended to explicitly close such objects. The\n\'"try"..."finally"\' statement provides a convenient way to do this.\n\nSome objects contain references to other objects; these are called\n*containers*. Examples of containers are tuples, lists and\ndictionaries. The references are part of a container\'s value. In\nmost cases, when we talk about the value of a container, we imply the\nvalues, not the identities of the contained objects; however, when we\ntalk about the mutability of a container, only the identities of the\nimmediately contained objects are implied. So, if an immutable\ncontainer (like a tuple) contains a reference to a mutable object, its\nvalue changes if that mutable object is changed.\n\nTypes affect almost all aspects of object behavior. Even the\nimportance of object identity is affected in some sense: for immutable\ntypes, operations that compute new values may actually return a\nreference to any existing object with the same type and value, while\nfor mutable objects this is not allowed. E.g., after "a = 1; b = 1",\n"a" and "b" may or may not refer to the same object with the value\none, depending on the implementation, but after "c = []; d = []", "c"\nand "d" are guaranteed to refer to two different, unique, newly\ncreated empty lists. (Note that "c = d = []" assigns the same object\nto both "c" and "d".)\n',
- 'operator-summary': u'\nOperator precedence\n*******************\n\nThe following table summarizes the operator precedences in Python,\nfrom lowest precedence (least binding) to highest precedence (most\nbinding). Operators in the same box have the same precedence. Unless\nthe syntax is explicitly given, operators are binary. Operators in\nthe same box group left to right (except for comparisons, including\ntests, which all have the same precedence and chain from left to right\n--- see section Comparisons --- and exponentiation, which groups from\nright to left).\n\n+-------------------------------------------------+---------------------------------------+\n| Operator | Description |\n+=================================================+=======================================+\n| "lambda" | Lambda expression |\n+-------------------------------------------------+---------------------------------------+\n| "if" -- "else" | Conditional expression |\n+-------------------------------------------------+---------------------------------------+\n| "or" | Boolean OR |\n+-------------------------------------------------+---------------------------------------+\n| "and" | Boolean AND |\n+-------------------------------------------------+---------------------------------------+\n| "not" "x" | Boolean NOT |\n+-------------------------------------------------+---------------------------------------+\n| "in", "not in", "is", "is not", "<", "<=", ">", | Comparisons, including membership |\n| ">=", "<>", "!=", "==" | tests and identity tests |\n+-------------------------------------------------+---------------------------------------+\n| "|" | Bitwise OR |\n+-------------------------------------------------+---------------------------------------+\n| "^" | Bitwise XOR |\n+-------------------------------------------------+---------------------------------------+\n| "&" | Bitwise AND |\n+-------------------------------------------------+---------------------------------------+\n| "<<", ">>" | Shifts |\n+-------------------------------------------------+---------------------------------------+\n| "+", "-" | Addition and subtraction |\n+-------------------------------------------------+---------------------------------------+\n| "*", "/", "//", "%" | Multiplication, division, remainder |\n| | [8] |\n+-------------------------------------------------+---------------------------------------+\n| "+x", "-x", "~x" | Positive, negative, bitwise NOT |\n+-------------------------------------------------+---------------------------------------+\n| "**" | Exponentiation [9] |\n+-------------------------------------------------+---------------------------------------+\n| "x[index]", "x[index:index]", | Subscription, slicing, call, |\n| "x(arguments...)", "x.attribute" | attribute reference |\n+-------------------------------------------------+---------------------------------------+\n| "(expressions...)", "[expressions...]", "{key: | Binding or tuple display, list |\n| value...}", "`expressions...`" | display, dictionary display, string |\n| | conversion |\n+-------------------------------------------------+---------------------------------------+\n\n-[ Footnotes ]-\n\n[1] In Python 2.3 and later releases, a list comprehension "leaks"\n the control variables of each "for" it contains into the\n containing scope. However, this behavior is deprecated, and\n relying on it will not work in Python 3.\n\n[2] While "abs(x%y) < abs(y)" is true mathematically, for floats\n it may not be true numerically due to roundoff. For example, and\n assuming a platform on which a Python float is an IEEE 754 double-\n precision number, in order that "-1e-100 % 1e100" have the same\n sign as "1e100", the computed result is "-1e-100 + 1e100", which\n is numerically exactly equal to "1e100". The function\n "math.fmod()" returns a result whose sign matches the sign of the\n first argument instead, and so returns "-1e-100" in this case.\n Which approach is more appropriate depends on the application.\n\n[3] If x is very close to an exact integer multiple of y, it\'s\n possible for "floor(x/y)" to be one larger than "(x-x%y)/y" due to\n rounding. In such cases, Python returns the latter result, in\n order to preserve that "divmod(x,y)[0] * y + x % y" be very close\n to "x".\n\n[4] While comparisons between unicode strings make sense at the\n byte level, they may be counter-intuitive to users. For example,\n the strings "u"\\u00C7"" and "u"\\u0043\\u0327"" compare differently,\n even though they both represent the same unicode character (LATIN\n CAPITAL LETTER C WITH CEDILLA). To compare strings in a human\n recognizable way, compare using "unicodedata.normalize()".\n\n[5] The implementation computes this efficiently, without\n constructing lists or sorting.\n\n[6] Earlier versions of Python used lexicographic comparison of\n the sorted (key, value) lists, but this was very expensive for the\n common case of comparing for equality. An even earlier version of\n Python compared dictionaries by identity only, but this caused\n surprises because people expected to be able to test a dictionary\n for emptiness by comparing it to "{}".\n\n[7] Due to automatic garbage-collection, free lists, and the\n dynamic nature of descriptors, you may notice seemingly unusual\n behaviour in certain uses of the "is" operator, like those\n involving comparisons between instance methods, or constants.\n Check their documentation for more info.\n\n[8] The "%" operator is also used for string formatting; the same\n precedence applies.\n\n[9] The power operator "**" binds less tightly than an arithmetic\n or bitwise unary operator on its right, that is, "2**-1" is "0.5".\n',
- 'pass': u'\nThe "pass" statement\n********************\n\n pass_stmt ::= "pass"\n\n"pass" is a null operation --- when it is executed, nothing happens.\nIt is useful as a placeholder when a statement is required\nsyntactically, but no code needs to be executed, for example:\n\n def f(arg): pass # a function that does nothing (yet)\n\n class C: pass # a class with no methods (yet)\n',
- 'power': u'\nThe power operator\n******************\n\nThe power operator binds more tightly than unary operators on its\nleft; it binds less tightly than unary operators on its right. The\nsyntax is:\n\n power ::= primary ["**" u_expr]\n\nThus, in an unparenthesized sequence of power and unary operators, the\noperators are evaluated from right to left (this does not constrain\nthe evaluation order for the operands): "-1**2" results in "-1".\n\nThe power operator has the same semantics as the built-in "pow()"\nfunction, when called with two arguments: it yields its left argument\nraised to the power of its right argument. The numeric arguments are\nfirst converted to a common type. The result type is that of the\narguments after coercion.\n\nWith mixed operand types, the coercion rules for binary arithmetic\noperators apply. For int and long int operands, the result has the\nsame type as the operands (after coercion) unless the second argument\nis negative; in that case, all arguments are converted to float and a\nfloat result is delivered. For example, "10**2" returns "100", but\n"10**-2" returns "0.01". (This last feature was added in Python 2.2.\nIn Python 2.1 and before, if both arguments were of integer types and\nthe second argument was negative, an exception was raised).\n\nRaising "0.0" to a negative power results in a "ZeroDivisionError".\nRaising a negative number to a fractional power results in a\n"ValueError".\n',
- 'print': u'\nThe "print" statement\n*********************\n\n print_stmt ::= "print" ([expression ("," expression)* [","]]\n | ">>" expression [("," expression)+ [","]])\n\n"print" evaluates each expression in turn and writes the resulting\nobject to standard output (see below). If an object is not a string,\nit is first converted to a string using the rules for string\nconversions. The (resulting or original) string is then written. A\nspace is written before each object is (converted and) written, unless\nthe output system believes it is positioned at the beginning of a\nline. This is the case (1) when no characters have yet been written\nto standard output, (2) when the last character written to standard\noutput is a whitespace character except "\' \'", or (3) when the last\nwrite operation on standard output was not a "print" statement. (In\nsome cases it may be functional to write an empty string to standard\noutput for this reason.)\n\nNote: Objects which act like file objects but which are not the\n built-in file objects often do not properly emulate this aspect of\n the file object\'s behavior, so it is best not to rely on this.\n\nA "\'\\n\'" character is written at the end, unless the "print" statement\nends with a comma. This is the only action if the statement contains\njust the keyword "print".\n\nStandard output is defined as the file object named "stdout" in the\nbuilt-in module "sys". If no such object exists, or if it does not\nhave a "write()" method, a "RuntimeError" exception is raised.\n\n"print" also has an extended form, defined by the second portion of\nthe syntax described above. This form is sometimes referred to as\n""print" chevron." In this form, the first expression after the ">>"\nmust evaluate to a "file-like" object, specifically an object that has\na "write()" method as described above. With this extended form, the\nsubsequent expressions are printed to this file object. If the first\nexpression evaluates to "None", then "sys.stdout" is used as the file\nfor output.\n',
- 'raise': u'\nThe "raise" statement\n*********************\n\n raise_stmt ::= "raise" [expression ["," expression ["," expression]]]\n\nIf no expressions are present, "raise" re-raises the last exception\nthat was active in the current scope. If no exception is active in\nthe current scope, a "TypeError" exception is raised indicating that\nthis is an error (if running under IDLE, a "Queue.Empty" exception is\nraised instead).\n\nOtherwise, "raise" evaluates the expressions to get three objects,\nusing "None" as the value of omitted expressions. The first two\nobjects are used to determine the *type* and *value* of the exception.\n\nIf the first object is an instance, the type of the exception is the\nclass of the instance, the instance itself is the value, and the\nsecond object must be "None".\n\nIf the first object is a class, it becomes the type of the exception.\nThe second object is used to determine the exception value: If it is\nan instance of the class, the instance becomes the exception value. If\nthe second object is a tuple, it is used as the argument list for the\nclass constructor; if it is "None", an empty argument list is used,\nand any other object is treated as a single argument to the\nconstructor. The instance so created by calling the constructor is\nused as the exception value.\n\nIf a third object is present and not "None", it must be a traceback\nobject (see section The standard type hierarchy), and it is\nsubstituted instead of the current location as the place where the\nexception occurred. If the third object is present and not a\ntraceback object or "None", a "TypeError" exception is raised. The\nthree-expression form of "raise" is useful to re-raise an exception\ntransparently in an except clause, but "raise" with no expressions\nshould be preferred if the exception to be re-raised was the most\nrecently active exception in the current scope.\n\nAdditional information on exceptions can be found in section\nExceptions, and information about handling exceptions is in section\nThe try statement.\n',
- 'return': u'\nThe "return" statement\n**********************\n\n return_stmt ::= "return" [expression_list]\n\n"return" may only occur syntactically nested in a function definition,\nnot within a nested class definition.\n\nIf an expression list is present, it is evaluated, else "None" is\nsubstituted.\n\n"return" leaves the current function call with the expression list (or\n"None") as return value.\n\nWhen "return" passes control out of a "try" statement with a "finally"\nclause, that "finally" clause is executed before really leaving the\nfunction.\n\nIn a generator function, the "return" statement is not allowed to\ninclude an "expression_list". In that context, a bare "return"\nindicates that the generator is done and will cause "StopIteration" to\nbe raised.\n',
- 'sequence-types': u'\nEmulating container types\n*************************\n\nThe following methods can be defined to implement container objects.\nContainers usually are sequences (such as lists or tuples) or mappings\n(like dictionaries), but can represent other containers as well. The\nfirst set of methods is used either to emulate a sequence or to\nemulate a mapping; the difference is that for a sequence, the\nallowable keys should be the integers *k* for which "0 <= k < N" where\n*N* is the length of the sequence, or slice objects, which define a\nrange of items. (For backwards compatibility, the method\n"__getslice__()" (see below) can also be defined to handle simple, but\nnot extended slices.) It is also recommended that mappings provide the\nmethods "keys()", "values()", "items()", "has_key()", "get()",\n"clear()", "setdefault()", "iterkeys()", "itervalues()",\n"iteritems()", "pop()", "popitem()", "copy()", and "update()" behaving\nsimilar to those for Python\'s standard dictionary objects. The\n"UserDict" module provides a "DictMixin" class to help create those\nmethods from a base set of "__getitem__()", "__setitem__()",\n"__delitem__()", and "keys()". Mutable sequences should provide\nmethods "append()", "count()", "index()", "extend()", "insert()",\n"pop()", "remove()", "reverse()" and "sort()", like Python standard\nlist objects. Finally, sequence types should implement addition\n(meaning concatenation) and multiplication (meaning repetition) by\ndefining the methods "__add__()", "__radd__()", "__iadd__()",\n"__mul__()", "__rmul__()" and "__imul__()" described below; they\nshould not define "__coerce__()" or other numerical operators. It is\nrecommended that both mappings and sequences implement the\n"__contains__()" method to allow efficient use of the "in" operator;\nfor mappings, "in" should be equivalent of "has_key()"; for sequences,\nit should search through the values. It is further recommended that\nboth mappings and sequences implement the "__iter__()" method to allow\nefficient iteration through the container; for mappings, "__iter__()"\nshould be the same as "iterkeys()"; for sequences, it should iterate\nthrough the values.\n\nobject.__len__(self)\n\n Called to implement the built-in function "len()". Should return\n the length of the object, an integer ">=" 0. Also, an object that\n doesn\'t define a "__nonzero__()" method and whose "__len__()"\n method returns zero is considered to be false in a Boolean context.\n\nobject.__getitem__(self, key)\n\n Called to implement evaluation of "self[key]". For sequence types,\n the accepted keys should be integers and slice objects. Note that\n the special interpretation of negative indexes (if the class wishes\n to emulate a sequence type) is up to the "__getitem__()" method. If\n *key* is of an inappropriate type, "TypeError" may be raised; if of\n a value outside the set of indexes for the sequence (after any\n special interpretation of negative values), "IndexError" should be\n raised. For mapping types, if *key* is missing (not in the\n container), "KeyError" should be raised.\n\n Note: "for" loops expect that an "IndexError" will be raised for\n illegal indexes to allow proper detection of the end of the\n sequence.\n\nobject.__missing__(self, key)\n\n Called by "dict"."__getitem__()" to implement "self[key]" for dict\n subclasses when key is not in the dictionary.\n\nobject.__setitem__(self, key, value)\n\n Called to implement assignment to "self[key]". Same note as for\n "__getitem__()". This should only be implemented for mappings if\n the objects support changes to the values for keys, or if new keys\n can be added, or for sequences if elements can be replaced. The\n same exceptions should be raised for improper *key* values as for\n the "__getitem__()" method.\n\nobject.__delitem__(self, key)\n\n Called to implement deletion of "self[key]". Same note as for\n "__getitem__()". This should only be implemented for mappings if\n the objects support removal of keys, or for sequences if elements\n can be removed from the sequence. The same exceptions should be\n raised for improper *key* values as for the "__getitem__()" method.\n\nobject.__iter__(self)\n\n This method is called when an iterator is required for a container.\n This method should return a new iterator object that can iterate\n over all the objects in the container. For mappings, it should\n iterate over the keys of the container, and should also be made\n available as the method "iterkeys()".\n\n Iterator objects also need to implement this method; they are\n required to return themselves. For more information on iterator\n objects, see Iterator Types.\n\nobject.__reversed__(self)\n\n Called (if present) by the "reversed()" built-in to implement\n reverse iteration. It should return a new iterator object that\n iterates over all the objects in the container in reverse order.\n\n If the "__reversed__()" method is not provided, the "reversed()"\n built-in will fall back to using the sequence protocol ("__len__()"\n and "__getitem__()"). Objects that support the sequence protocol\n should only provide "__reversed__()" if they can provide an\n implementation that is more efficient than the one provided by\n "reversed()".\n\n New in version 2.6.\n\nThe membership test operators ("in" and "not in") are normally\nimplemented as an iteration through a sequence. However, container\nobjects can supply the following special method with a more efficient\nimplementation, which also does not require the object be a sequence.\n\nobject.__contains__(self, item)\n\n Called to implement membership test operators. Should return true\n if *item* is in *self*, false otherwise. For mapping objects, this\n should consider the keys of the mapping rather than the values or\n the key-item pairs.\n\n For objects that don\'t define "__contains__()", the membership test\n first tries iteration via "__iter__()", then the old sequence\n iteration protocol via "__getitem__()", see this section in the\n language reference.\n',
- 'shifting': u'\nShifting operations\n*******************\n\nThe shifting operations have lower priority than the arithmetic\noperations:\n\n shift_expr ::= a_expr | shift_expr ( "<<" | ">>" ) a_expr\n\nThese operators accept plain or long integers as arguments. The\narguments are converted to a common type. They shift the first\nargument to the left or right by the number of bits given by the\nsecond argument.\n\nA right shift by *n* bits is defined as division by "pow(2, n)". A\nleft shift by *n* bits is defined as multiplication with "pow(2, n)".\nNegative shift counts raise a "ValueError" exception.\n\nNote: In the current implementation, the right-hand operand is\n required to be at most "sys.maxsize". If the right-hand operand is\n larger than "sys.maxsize" an "OverflowError" exception is raised.\n',
- 'slicings': u'\nSlicings\n********\n\nA slicing selects a range of items in a sequence object (e.g., a\nstring, tuple or list). Slicings may be used as expressions or as\ntargets in assignment or "del" statements. The syntax for a slicing:\n\n slicing ::= simple_slicing | extended_slicing\n simple_slicing ::= primary "[" short_slice "]"\n extended_slicing ::= primary "[" slice_list "]"\n slice_list ::= slice_item ("," slice_item)* [","]\n slice_item ::= expression | proper_slice | ellipsis\n proper_slice ::= short_slice | long_slice\n short_slice ::= [lower_bound] ":" [upper_bound]\n long_slice ::= short_slice ":" [stride]\n lower_bound ::= expression\n upper_bound ::= expression\n stride ::= expression\n ellipsis ::= "..."\n\nThere is ambiguity in the formal syntax here: anything that looks like\nan expression list also looks like a slice list, so any subscription\ncan be interpreted as a slicing. Rather than further complicating the\nsyntax, this is disambiguated by defining that in this case the\ninterpretation as a subscription takes priority over the\ninterpretation as a slicing (this is the case if the slice list\ncontains no proper slice nor ellipses). Similarly, when the slice\nlist has exactly one short slice and no trailing comma, the\ninterpretation as a simple slicing takes priority over that as an\nextended slicing.\n\nThe semantics for a simple slicing are as follows. The primary must\nevaluate to a sequence object. The lower and upper bound expressions,\nif present, must evaluate to plain integers; defaults are zero and the\n"sys.maxint", respectively. If either bound is negative, the\nsequence\'s length is added to it. The slicing now selects all items\nwith index *k* such that "i <= k < j" where *i* and *j* are the\nspecified lower and upper bounds. This may be an empty sequence. It\nis not an error if *i* or *j* lie outside the range of valid indexes\n(such items don\'t exist so they aren\'t selected).\n\nThe semantics for an extended slicing are as follows. The primary\nmust evaluate to a mapping object, and it is indexed with a key that\nis constructed from the slice list, as follows. If the slice list\ncontains at least one comma, the key is a tuple containing the\nconversion of the slice items; otherwise, the conversion of the lone\nslice item is the key. The conversion of a slice item that is an\nexpression is that expression. The conversion of an ellipsis slice\nitem is the built-in "Ellipsis" object. The conversion of a proper\nslice is a slice object (see section The standard type hierarchy)\nwhose "start", "stop" and "step" attributes are the values of the\nexpressions given as lower bound, upper bound and stride,\nrespectively, substituting "None" for missing expressions.\n',
- 'specialattrs': u'\nSpecial Attributes\n******************\n\nThe implementation adds a few special read-only attributes to several\nobject types, where they are relevant. Some of these are not reported\nby the "dir()" built-in function.\n\nobject.__dict__\n\n A dictionary or other mapping object used to store an object\'s\n (writable) attributes.\n\nobject.__methods__\n\n Deprecated since version 2.2: Use the built-in function "dir()" to\n get a list of an object\'s attributes. This attribute is no longer\n available.\n\nobject.__members__\n\n Deprecated since version 2.2: Use the built-in function "dir()" to\n get a list of an object\'s attributes. This attribute is no longer\n available.\n\ninstance.__class__\n\n The class to which a class instance belongs.\n\nclass.__bases__\n\n The tuple of base classes of a class object.\n\ndefinition.__name__\n\n The name of the class, type, function, method, descriptor, or\n generator instance.\n\nThe following attributes are only supported by *new-style class*es.\n\nclass.__mro__\n\n This attribute is a tuple of classes that are considered when\n looking for base classes during method resolution.\n\nclass.mro()\n\n This method can be overridden by a metaclass to customize the\n method resolution order for its instances. It is called at class\n instantiation, and its result is stored in "__mro__".\n\nclass.__subclasses__()\n\n Each new-style class keeps a list of weak references to its\n immediate subclasses. This method returns a list of all those\n references still alive. Example:\n\n >>> int.__subclasses__()\n [<type \'bool\'>]\n\n-[ Footnotes ]-\n\n[1] Additional information on these special methods may be found\n in the Python Reference Manual (Basic customization).\n\n[2] As a consequence, the list "[1, 2]" is considered equal to\n "[1.0, 2.0]", and similarly for tuples.\n\n[3] They must have since the parser can\'t tell the type of the\n operands.\n\n[4] Cased characters are those with general category property\n being one of "Lu" (Letter, uppercase), "Ll" (Letter, lowercase),\n or "Lt" (Letter, titlecase).\n\n[5] To format only a tuple you should therefore provide a\n singleton tuple whose only element is the tuple to be formatted.\n\n[6] The advantage of leaving the newline on is that returning an\n empty string is then an unambiguous EOF indication. It is also\n possible (in cases where it might matter, for example, if you want\n to make an exact copy of a file while scanning its lines) to tell\n whether the last line of a file ended in a newline or not (yes\n this happens!).\n',
- 'specialnames': u'\nSpecial method names\n********************\n\nA class can implement certain operations that are invoked by special\nsyntax (such as arithmetic operations or subscripting and slicing) by\ndefining methods with special names. This is Python\'s approach to\n*operator overloading*, allowing classes to define their own behavior\nwith respect to language operators. For instance, if a class defines\na method named "__getitem__()", and "x" is an instance of this class,\nthen "x[i]" is roughly equivalent to "x.__getitem__(i)" for old-style\nclasses and "type(x).__getitem__(x, i)" for new-style classes. Except\nwhere mentioned, attempts to execute an operation raise an exception\nwhen no appropriate method is defined (typically "AttributeError" or\n"TypeError").\n\nWhen implementing a class that emulates any built-in type, it is\nimportant that the emulation only be implemented to the degree that it\nmakes sense for the object being modelled. For example, some\nsequences may work well with retrieval of individual elements, but\nextracting a slice may not make sense. (One example of this is the\n"NodeList" interface in the W3C\'s Document Object Model.)\n\n\nBasic customization\n===================\n\nobject.__new__(cls[, ...])\n\n Called to create a new instance of class *cls*. "__new__()" is a\n static method (special-cased so you need not declare it as such)\n that takes the class of which an instance was requested as its\n first argument. The remaining arguments are those passed to the\n object constructor expression (the call to the class). The return\n value of "__new__()" should be the new object instance (usually an\n instance of *cls*).\n\n Typical implementations create a new instance of the class by\n invoking the superclass\'s "__new__()" method using\n "super(currentclass, cls).__new__(cls[, ...])" with appropriate\n arguments and then modifying the newly-created instance as\n necessary before returning it.\n\n If "__new__()" returns an instance of *cls*, then the new\n instance\'s "__init__()" method will be invoked like\n "__init__(self[, ...])", where *self* is the new instance and the\n remaining arguments are the same as were passed to "__new__()".\n\n If "__new__()" does not return an instance of *cls*, then the new\n instance\'s "__init__()" method will not be invoked.\n\n "__new__()" is intended mainly to allow subclasses of immutable\n types (like int, str, or tuple) to customize instance creation. It\n is also commonly overridden in custom metaclasses in order to\n customize class creation.\n\nobject.__init__(self[, ...])\n\n Called after the instance has been created (by "__new__()"), but\n before it is returned to the caller. The arguments are those\n passed to the class constructor expression. If a base class has an\n "__init__()" method, the derived class\'s "__init__()" method, if\n any, must explicitly call it to ensure proper initialization of the\n base class part of the instance; for example:\n "BaseClass.__init__(self, [args...])".\n\n Because "__new__()" and "__init__()" work together in constructing\n objects ("__new__()" to create it, and "__init__()" to customise\n it), no non-"None" value may be returned by "__init__()"; doing so\n will cause a "TypeError" to be raised at runtime.\n\nobject.__del__(self)\n\n Called when the instance is about to be destroyed. This is also\n called a destructor. If a base class has a "__del__()" method, the\n derived class\'s "__del__()" method, if any, must explicitly call it\n to ensure proper deletion of the base class part of the instance.\n Note that it is possible (though not recommended!) for the\n "__del__()" method to postpone destruction of the instance by\n creating a new reference to it. It may then be called at a later\n time when this new reference is deleted. It is not guaranteed that\n "__del__()" methods are called for objects that still exist when\n the interpreter exits.\n\n Note: "del x" doesn\'t directly call "x.__del__()" --- the former\n decrements the reference count for "x" by one, and the latter is\n only called when "x"\'s reference count reaches zero. Some common\n situations that may prevent the reference count of an object from\n going to zero include: circular references between objects (e.g.,\n a doubly-linked list or a tree data structure with parent and\n child pointers); a reference to the object on the stack frame of\n a function that caught an exception (the traceback stored in\n "sys.exc_traceback" keeps the stack frame alive); or a reference\n to the object on the stack frame that raised an unhandled\n exception in interactive mode (the traceback stored in\n "sys.last_traceback" keeps the stack frame alive). The first\n situation can only be remedied by explicitly breaking the cycles;\n the latter two situations can be resolved by storing "None" in\n "sys.exc_traceback" or "sys.last_traceback". Circular references\n which are garbage are detected when the option cycle detector is\n enabled (it\'s on by default), but can only be cleaned up if there\n are no Python-level "__del__()" methods involved. Refer to the\n documentation for the "gc" module for more information about how\n "__del__()" methods are handled by the cycle detector,\n particularly the description of the "garbage" value.\n\n Warning: Due to the precarious circumstances under which\n "__del__()" methods are invoked, exceptions that occur during\n their execution are ignored, and a warning is printed to\n "sys.stderr" instead. Also, when "__del__()" is invoked in\n response to a module being deleted (e.g., when execution of the\n program is done), other globals referenced by the "__del__()"\n method may already have been deleted or in the process of being\n torn down (e.g. the import machinery shutting down). For this\n reason, "__del__()" methods should do the absolute minimum needed\n to maintain external invariants. Starting with version 1.5,\n Python guarantees that globals whose name begins with a single\n underscore are deleted from their module before other globals are\n deleted; if no other references to such globals exist, this may\n help in assuring that imported modules are still available at the\n time when the "__del__()" method is called.\n\n See also the "-R" command-line option.\n\nobject.__repr__(self)\n\n Called by the "repr()" built-in function and by string conversions\n (reverse quotes) to compute the "official" string representation of\n an object. If at all possible, this should look like a valid\n Python expression that could be used to recreate an object with the\n same value (given an appropriate environment). If this is not\n possible, a string of the form "<...some useful description...>"\n should be returned. The return value must be a string object. If a\n class defines "__repr__()" but not "__str__()", then "__repr__()"\n is also used when an "informal" string representation of instances\n of that class is required.\n\n This is typically used for debugging, so it is important that the\n representation is information-rich and unambiguous.\n\nobject.__str__(self)\n\n Called by the "str()" built-in function and by the "print"\n statement to compute the "informal" string representation of an\n object. This differs from "__repr__()" in that it does not have to\n be a valid Python expression: a more convenient or concise\n representation may be used instead. The return value must be a\n string object.\n\nobject.__lt__(self, other)\nobject.__le__(self, other)\nobject.__eq__(self, other)\nobject.__ne__(self, other)\nobject.__gt__(self, other)\nobject.__ge__(self, other)\n\n New in version 2.1.\n\n These are the so-called "rich comparison" methods, and are called\n for comparison operators in preference to "__cmp__()" below. The\n correspondence between operator symbols and method names is as\n follows: "x<y" calls "x.__lt__(y)", "x<=y" calls "x.__le__(y)",\n "x==y" calls "x.__eq__(y)", "x!=y" and "x<>y" call "x.__ne__(y)",\n "x>y" calls "x.__gt__(y)", and "x>=y" calls "x.__ge__(y)".\n\n A rich comparison method may return the singleton "NotImplemented"\n if it does not implement the operation for a given pair of\n arguments. By convention, "False" and "True" are returned for a\n successful comparison. However, these methods can return any value,\n so if the comparison operator is used in a Boolean context (e.g.,\n in the condition of an "if" statement), Python will call "bool()"\n on the value to determine if the result is true or false.\n\n There are no implied relationships among the comparison operators.\n The truth of "x==y" does not imply that "x!=y" is false.\n Accordingly, when defining "__eq__()", one should also define\n "__ne__()" so that the operators will behave as expected. See the\n paragraph on "__hash__()" for some important notes on creating\n *hashable* objects which support custom comparison operations and\n are usable as dictionary keys.\n\n There are no swapped-argument versions of these methods (to be used\n when the left argument does not support the operation but the right\n argument does); rather, "__lt__()" and "__gt__()" are each other\'s\n reflection, "__le__()" and "__ge__()" are each other\'s reflection,\n and "__eq__()" and "__ne__()" are their own reflection.\n\n Arguments to rich comparison methods are never coerced.\n\n To automatically generate ordering operations from a single root\n operation, see "functools.total_ordering()".\n\nobject.__cmp__(self, other)\n\n Called by comparison operations if rich comparison (see above) is\n not defined. Should return a negative integer if "self < other",\n zero if "self == other", a positive integer if "self > other". If\n no "__cmp__()", "__eq__()" or "__ne__()" operation is defined,\n class instances are compared by object identity ("address"). See\n also the description of "__hash__()" for some important notes on\n creating *hashable* objects which support custom comparison\n operations and are usable as dictionary keys. (Note: the\n restriction that exceptions are not propagated by "__cmp__()" has\n been removed since Python 1.5.)\n\nobject.__rcmp__(self, other)\n\n Changed in version 2.1: No longer supported.\n\nobject.__hash__(self)\n\n Called by built-in function "hash()" and for operations on members\n of hashed collections including "set", "frozenset", and "dict".\n "__hash__()" should return an integer. The only required property\n is that objects which compare equal have the same hash value; it is\n advised to somehow mix together (e.g. using exclusive or) the hash\n values for the components of the object that also play a part in\n comparison of objects.\n\n If a class does not define a "__cmp__()" or "__eq__()" method it\n should not define a "__hash__()" operation either; if it defines\n "__cmp__()" or "__eq__()" but not "__hash__()", its instances will\n not be usable in hashed collections. If a class defines mutable\n objects and implements a "__cmp__()" or "__eq__()" method, it\n should not implement "__hash__()", since hashable collection\n implementations require that an object\'s hash value is immutable\n (if the object\'s hash value changes, it will be in the wrong hash\n bucket).\n\n User-defined classes have "__cmp__()" and "__hash__()" methods by\n default; with them, all objects compare unequal (except with\n themselves) and "x.__hash__()" returns a result derived from\n "id(x)".\n\n Classes which inherit a "__hash__()" method from a parent class but\n change the meaning of "__cmp__()" or "__eq__()" such that the hash\n value returned is no longer appropriate (e.g. by switching to a\n value-based concept of equality instead of the default identity\n based equality) can explicitly flag themselves as being unhashable\n by setting "__hash__ = None" in the class definition. Doing so\n means that not only will instances of the class raise an\n appropriate "TypeError" when a program attempts to retrieve their\n hash value, but they will also be correctly identified as\n unhashable when checking "isinstance(obj, collections.Hashable)"\n (unlike classes which define their own "__hash__()" to explicitly\n raise "TypeError").\n\n Changed in version 2.5: "__hash__()" may now also return a long\n integer object; the 32-bit integer is then derived from the hash of\n that object.\n\n Changed in version 2.6: "__hash__" may now be set to "None" to\n explicitly flag instances of a class as unhashable.\n\nobject.__nonzero__(self)\n\n Called to implement truth value testing and the built-in operation\n "bool()"; should return "False" or "True", or their integer\n equivalents "0" or "1". When this method is not defined,\n "__len__()" is called, if it is defined, and the object is\n considered true if its result is nonzero. If a class defines\n neither "__len__()" nor "__nonzero__()", all its instances are\n considered true.\n\nobject.__unicode__(self)\n\n Called to implement "unicode()" built-in; should return a Unicode\n object. When this method is not defined, string conversion is\n attempted, and the result of string conversion is converted to\n Unicode using the system default encoding.\n\n\nCustomizing attribute access\n============================\n\nThe following methods can be defined to customize the meaning of\nattribute access (use of, assignment to, or deletion of "x.name") for\nclass instances.\n\nobject.__getattr__(self, name)\n\n Called when an attribute lookup has not found the attribute in the\n usual places (i.e. it is not an instance attribute nor is it found\n in the class tree for "self"). "name" is the attribute name. This\n method should return the (computed) attribute value or raise an\n "AttributeError" exception.\n\n Note that if the attribute is found through the normal mechanism,\n "__getattr__()" is not called. (This is an intentional asymmetry\n between "__getattr__()" and "__setattr__()".) This is done both for\n efficiency reasons and because otherwise "__getattr__()" would have\n no way to access other attributes of the instance. Note that at\n least for instance variables, you can fake total control by not\n inserting any values in the instance attribute dictionary (but\n instead inserting them in another object). See the\n "__getattribute__()" method below for a way to actually get total\n control in new-style classes.\n\nobject.__setattr__(self, name, value)\n\n Called when an attribute assignment is attempted. This is called\n instead of the normal mechanism (i.e. store the value in the\n instance dictionary). *name* is the attribute name, *value* is the\n value to be assigned to it.\n\n If "__setattr__()" wants to assign to an instance attribute, it\n should not simply execute "self.name = value" --- this would cause\n a recursive call to itself. Instead, it should insert the value in\n the dictionary of instance attributes, e.g., "self.__dict__[name] =\n value". For new-style classes, rather than accessing the instance\n dictionary, it should call the base class method with the same\n name, for example, "object.__setattr__(self, name, value)".\n\nobject.__delattr__(self, name)\n\n Like "__setattr__()" but for attribute deletion instead of\n assignment. This should only be implemented if "del obj.name" is\n meaningful for the object.\n\n\nMore attribute access for new-style classes\n-------------------------------------------\n\nThe following methods only apply to new-style classes.\n\nobject.__getattribute__(self, name)\n\n Called unconditionally to implement attribute accesses for\n instances of the class. If the class also defines "__getattr__()",\n the latter will not be called unless "__getattribute__()" either\n calls it explicitly or raises an "AttributeError". This method\n should return the (computed) attribute value or raise an\n "AttributeError" exception. In order to avoid infinite recursion in\n this method, its implementation should always call the base class\n method with the same name to access any attributes it needs, for\n example, "object.__getattribute__(self, name)".\n\n Note: This method may still be bypassed when looking up special\n methods as the result of implicit invocation via language syntax\n or built-in functions. See Special method lookup for new-style\n classes.\n\n\nImplementing Descriptors\n------------------------\n\nThe following methods only apply when an instance of the class\ncontaining the method (a so-called *descriptor* class) appears in an\n*owner* class (the descriptor must be in either the owner\'s class\ndictionary or in the class dictionary for one of its parents). In the\nexamples below, "the attribute" refers to the attribute whose name is\nthe key of the property in the owner class\' "__dict__".\n\nobject.__get__(self, instance, owner)\n\n Called to get the attribute of the owner class (class attribute\n access) or of an instance of that class (instance attribute\n access). *owner* is always the owner class, while *instance* is the\n instance that the attribute was accessed through, or "None" when\n the attribute is accessed through the *owner*. This method should\n return the (computed) attribute value or raise an "AttributeError"\n exception.\n\nobject.__set__(self, instance, value)\n\n Called to set the attribute on an instance *instance* of the owner\n class to a new value, *value*.\n\nobject.__delete__(self, instance)\n\n Called to delete the attribute on an instance *instance* of the\n owner class.\n\n\nInvoking Descriptors\n--------------------\n\nIn general, a descriptor is an object attribute with "binding\nbehavior", one whose attribute access has been overridden by methods\nin the descriptor protocol: "__get__()", "__set__()", and\n"__delete__()". If any of those methods are defined for an object, it\nis said to be a descriptor.\n\nThe default behavior for attribute access is to get, set, or delete\nthe attribute from an object\'s dictionary. For instance, "a.x" has a\nlookup chain starting with "a.__dict__[\'x\']", then\n"type(a).__dict__[\'x\']", and continuing through the base classes of\n"type(a)" excluding metaclasses.\n\nHowever, if the looked-up value is an object defining one of the\ndescriptor methods, then Python may override the default behavior and\ninvoke the descriptor method instead. Where this occurs in the\nprecedence chain depends on which descriptor methods were defined and\nhow they were called. Note that descriptors are only invoked for new\nstyle objects or classes (ones that subclass "object()" or "type()").\n\nThe starting point for descriptor invocation is a binding, "a.x". How\nthe arguments are assembled depends on "a":\n\nDirect Call\n The simplest and least common call is when user code directly\n invokes a descriptor method: "x.__get__(a)".\n\nInstance Binding\n If binding to a new-style object instance, "a.x" is transformed\n into the call: "type(a).__dict__[\'x\'].__get__(a, type(a))".\n\nClass Binding\n If binding to a new-style class, "A.x" is transformed into the\n call: "A.__dict__[\'x\'].__get__(None, A)".\n\nSuper Binding\n If "a" is an instance of "super", then the binding "super(B,\n obj).m()" searches "obj.__class__.__mro__" for the base class "A"\n immediately preceding "B" and then invokes the descriptor with the\n call: "A.__dict__[\'m\'].__get__(obj, obj.__class__)".\n\nFor instance bindings, the precedence of descriptor invocation depends\non the which descriptor methods are defined. A descriptor can define\nany combination of "__get__()", "__set__()" and "__delete__()". If it\ndoes not define "__get__()", then accessing the attribute will return\nthe descriptor object itself unless there is a value in the object\'s\ninstance dictionary. If the descriptor defines "__set__()" and/or\n"__delete__()", it is a data descriptor; if it defines neither, it is\na non-data descriptor. Normally, data descriptors define both\n"__get__()" and "__set__()", while non-data descriptors have just the\n"__get__()" method. Data descriptors with "__set__()" and "__get__()"\ndefined always override a redefinition in an instance dictionary. In\ncontrast, non-data descriptors can be overridden by instances.\n\nPython methods (including "staticmethod()" and "classmethod()") are\nimplemented as non-data descriptors. Accordingly, instances can\nredefine and override methods. This allows individual instances to\nacquire behaviors that differ from other instances of the same class.\n\nThe "property()" function is implemented as a data descriptor.\nAccordingly, instances cannot override the behavior of a property.\n\n\n__slots__\n---------\n\nBy default, instances of both old and new-style classes have a\ndictionary for attribute storage. This wastes space for objects\nhaving very few instance variables. The space consumption can become\nacute when creating large numbers of instances.\n\nThe default can be overridden by defining *__slots__* in a new-style\nclass definition. The *__slots__* declaration takes a sequence of\ninstance variables and reserves just enough space in each instance to\nhold a value for each variable. Space is saved because *__dict__* is\nnot created for each instance.\n\n__slots__\n\n This class variable can be assigned a string, iterable, or sequence\n of strings with variable names used by instances. If defined in a\n new-style class, *__slots__* reserves space for the declared\n variables and prevents the automatic creation of *__dict__* and\n *__weakref__* for each instance.\n\n New in version 2.2.\n\nNotes on using *__slots__*\n\n* When inheriting from a class without *__slots__*, the *__dict__*\n attribute of that class will always be accessible, so a *__slots__*\n definition in the subclass is meaningless.\n\n* Without a *__dict__* variable, instances cannot be assigned new\n variables not listed in the *__slots__* definition. Attempts to\n assign to an unlisted variable name raises "AttributeError". If\n dynamic assignment of new variables is desired, then add\n "\'__dict__\'" to the sequence of strings in the *__slots__*\n declaration.\n\n Changed in version 2.3: Previously, adding "\'__dict__\'" to the\n *__slots__* declaration would not enable the assignment of new\n attributes not specifically listed in the sequence of instance\n variable names.\n\n* Without a *__weakref__* variable for each instance, classes\n defining *__slots__* do not support weak references to its\n instances. If weak reference support is needed, then add\n "\'__weakref__\'" to the sequence of strings in the *__slots__*\n declaration.\n\n Changed in version 2.3: Previously, adding "\'__weakref__\'" to the\n *__slots__* declaration would not enable support for weak\n references.\n\n* *__slots__* are implemented at the class level by creating\n descriptors (Implementing Descriptors) for each variable name. As a\n result, class attributes cannot be used to set default values for\n instance variables defined by *__slots__*; otherwise, the class\n attribute would overwrite the descriptor assignment.\n\n* The action of a *__slots__* declaration is limited to the class\n where it is defined. As a result, subclasses will have a *__dict__*\n unless they also define *__slots__* (which must only contain names\n of any *additional* slots).\n\n* If a class defines a slot also defined in a base class, the\n instance variable defined by the base class slot is inaccessible\n (except by retrieving its descriptor directly from the base class).\n This renders the meaning of the program undefined. In the future, a\n check may be added to prevent this.\n\n* Nonempty *__slots__* does not work for classes derived from\n "variable-length" built-in types such as "long", "str" and "tuple".\n\n* Any non-string iterable may be assigned to *__slots__*. Mappings\n may also be used; however, in the future, special meaning may be\n assigned to the values corresponding to each key.\n\n* *__class__* assignment works only if both classes have the same\n *__slots__*.\n\n Changed in version 2.6: Previously, *__class__* assignment raised an\n error if either new or old class had *__slots__*.\n\n\nCustomizing class creation\n==========================\n\nBy default, new-style classes are constructed using "type()". A class\ndefinition is read into a separate namespace and the value of class\nname is bound to the result of "type(name, bases, dict)".\n\nWhen the class definition is read, if *__metaclass__* is defined then\nthe callable assigned to it will be called instead of "type()". This\nallows classes or functions to be written which monitor or alter the\nclass creation process:\n\n* Modifying the class dictionary prior to the class being created.\n\n* Returning an instance of another class -- essentially performing\n the role of a factory function.\n\nThese steps will have to be performed in the metaclass\'s "__new__()"\nmethod -- "type.__new__()" can then be called from this method to\ncreate a class with different properties. This example adds a new\nelement to the class dictionary before creating the class:\n\n class metacls(type):\n def __new__(mcs, name, bases, dict):\n dict[\'foo\'] = \'metacls was here\'\n return type.__new__(mcs, name, bases, dict)\n\nYou can of course also override other class methods (or add new\nmethods); for example defining a custom "__call__()" method in the\nmetaclass allows custom behavior when the class is called, e.g. not\nalways creating a new instance.\n\n__metaclass__\n\n This variable can be any callable accepting arguments for "name",\n "bases", and "dict". Upon class creation, the callable is used\n instead of the built-in "type()".\n\n New in version 2.2.\n\nThe appropriate metaclass is determined by the following precedence\nrules:\n\n* If "dict[\'__metaclass__\']" exists, it is used.\n\n* Otherwise, if there is at least one base class, its metaclass is\n used (this looks for a *__class__* attribute first and if not found,\n uses its type).\n\n* Otherwise, if a global variable named __metaclass__ exists, it is\n used.\n\n* Otherwise, the old-style, classic metaclass (types.ClassType) is\n used.\n\nThe potential uses for metaclasses are boundless. Some ideas that have\nbeen explored including logging, interface checking, automatic\ndelegation, automatic property creation, proxies, frameworks, and\nautomatic resource locking/synchronization.\n\n\nCustomizing instance and subclass checks\n========================================\n\nNew in version 2.6.\n\nThe following methods are used to override the default behavior of the\n"isinstance()" and "issubclass()" built-in functions.\n\nIn particular, the metaclass "abc.ABCMeta" implements these methods in\norder to allow the addition of Abstract Base Classes (ABCs) as\n"virtual base classes" to any class or type (including built-in\ntypes), including other ABCs.\n\nclass.__instancecheck__(self, instance)\n\n Return true if *instance* should be considered a (direct or\n indirect) instance of *class*. If defined, called to implement\n "isinstance(instance, class)".\n\nclass.__subclasscheck__(self, subclass)\n\n Return true if *subclass* should be considered a (direct or\n indirect) subclass of *class*. If defined, called to implement\n "issubclass(subclass, class)".\n\nNote that these methods are looked up on the type (metaclass) of a\nclass. They cannot be defined as class methods in the actual class.\nThis is consistent with the lookup of special methods that are called\non instances, only in this case the instance is itself a class.\n\nSee also:\n\n **PEP 3119** - Introducing Abstract Base Classes\n Includes the specification for customizing "isinstance()" and\n "issubclass()" behavior through "__instancecheck__()" and\n "__subclasscheck__()", with motivation for this functionality in\n the context of adding Abstract Base Classes (see the "abc"\n module) to the language.\n\n\nEmulating callable objects\n==========================\n\nobject.__call__(self[, args...])\n\n Called when the instance is "called" as a function; if this method\n is defined, "x(arg1, arg2, ...)" is a shorthand for\n "x.__call__(arg1, arg2, ...)".\n\n\nEmulating container types\n=========================\n\nThe following methods can be defined to implement container objects.\nContainers usually are sequences (such as lists or tuples) or mappings\n(like dictionaries), but can represent other containers as well. The\nfirst set of methods is used either to emulate a sequence or to\nemulate a mapping; the difference is that for a sequence, the\nallowable keys should be the integers *k* for which "0 <= k < N" where\n*N* is the length of the sequence, or slice objects, which define a\nrange of items. (For backwards compatibility, the method\n"__getslice__()" (see below) can also be defined to handle simple, but\nnot extended slices.) It is also recommended that mappings provide the\nmethods "keys()", "values()", "items()", "has_key()", "get()",\n"clear()", "setdefault()", "iterkeys()", "itervalues()",\n"iteritems()", "pop()", "popitem()", "copy()", and "update()" behaving\nsimilar to those for Python\'s standard dictionary objects. The\n"UserDict" module provides a "DictMixin" class to help create those\nmethods from a base set of "__getitem__()", "__setitem__()",\n"__delitem__()", and "keys()". Mutable sequences should provide\nmethods "append()", "count()", "index()", "extend()", "insert()",\n"pop()", "remove()", "reverse()" and "sort()", like Python standard\nlist objects. Finally, sequence types should implement addition\n(meaning concatenation) and multiplication (meaning repetition) by\ndefining the methods "__add__()", "__radd__()", "__iadd__()",\n"__mul__()", "__rmul__()" and "__imul__()" described below; they\nshould not define "__coerce__()" or other numerical operators. It is\nrecommended that both mappings and sequences implement the\n"__contains__()" method to allow efficient use of the "in" operator;\nfor mappings, "in" should be equivalent of "has_key()"; for sequences,\nit should search through the values. It is further recommended that\nboth mappings and sequences implement the "__iter__()" method to allow\nefficient iteration through the container; for mappings, "__iter__()"\nshould be the same as "iterkeys()"; for sequences, it should iterate\nthrough the values.\n\nobject.__len__(self)\n\n Called to implement the built-in function "len()". Should return\n the length of the object, an integer ">=" 0. Also, an object that\n doesn\'t define a "__nonzero__()" method and whose "__len__()"\n method returns zero is considered to be false in a Boolean context.\n\nobject.__getitem__(self, key)\n\n Called to implement evaluation of "self[key]". For sequence types,\n the accepted keys should be integers and slice objects. Note that\n the special interpretation of negative indexes (if the class wishes\n to emulate a sequence type) is up to the "__getitem__()" method. If\n *key* is of an inappropriate type, "TypeError" may be raised; if of\n a value outside the set of indexes for the sequence (after any\n special interpretation of negative values), "IndexError" should be\n raised. For mapping types, if *key* is missing (not in the\n container), "KeyError" should be raised.\n\n Note: "for" loops expect that an "IndexError" will be raised for\n illegal indexes to allow proper detection of the end of the\n sequence.\n\nobject.__missing__(self, key)\n\n Called by "dict"."__getitem__()" to implement "self[key]" for dict\n subclasses when key is not in the dictionary.\n\nobject.__setitem__(self, key, value)\n\n Called to implement assignment to "self[key]". Same note as for\n "__getitem__()". This should only be implemented for mappings if\n the objects support changes to the values for keys, or if new keys\n can be added, or for sequences if elements can be replaced. The\n same exceptions should be raised for improper *key* values as for\n the "__getitem__()" method.\n\nobject.__delitem__(self, key)\n\n Called to implement deletion of "self[key]". Same note as for\n "__getitem__()". This should only be implemented for mappings if\n the objects support removal of keys, or for sequences if elements\n can be removed from the sequence. The same exceptions should be\n raised for improper *key* values as for the "__getitem__()" method.\n\nobject.__iter__(self)\n\n This method is called when an iterator is required for a container.\n This method should return a new iterator object that can iterate\n over all the objects in the container. For mappings, it should\n iterate over the keys of the container, and should also be made\n available as the method "iterkeys()".\n\n Iterator objects also need to implement this method; they are\n required to return themselves. For more information on iterator\n objects, see Iterator Types.\n\nobject.__reversed__(self)\n\n Called (if present) by the "reversed()" built-in to implement\n reverse iteration. It should return a new iterator object that\n iterates over all the objects in the container in reverse order.\n\n If the "__reversed__()" method is not provided, the "reversed()"\n built-in will fall back to using the sequence protocol ("__len__()"\n and "__getitem__()"). Objects that support the sequence protocol\n should only provide "__reversed__()" if they can provide an\n implementation that is more efficient than the one provided by\n "reversed()".\n\n New in version 2.6.\n\nThe membership test operators ("in" and "not in") are normally\nimplemented as an iteration through a sequence. However, container\nobjects can supply the following special method with a more efficient\nimplementation, which also does not require the object be a sequence.\n\nobject.__contains__(self, item)\n\n Called to implement membership test operators. Should return true\n if *item* is in *self*, false otherwise. For mapping objects, this\n should consider the keys of the mapping rather than the values or\n the key-item pairs.\n\n For objects that don\'t define "__contains__()", the membership test\n first tries iteration via "__iter__()", then the old sequence\n iteration protocol via "__getitem__()", see this section in the\n language reference.\n\n\nAdditional methods for emulation of sequence types\n==================================================\n\nThe following optional methods can be defined to further emulate\nsequence objects. Immutable sequences methods should at most only\ndefine "__getslice__()"; mutable sequences might define all three\nmethods.\n\nobject.__getslice__(self, i, j)\n\n Deprecated since version 2.0: Support slice objects as parameters\n to the "__getitem__()" method. (However, built-in types in CPython\n currently still implement "__getslice__()". Therefore, you have to\n override it in derived classes when implementing slicing.)\n\n Called to implement evaluation of "self[i:j]". The returned object\n should be of the same type as *self*. Note that missing *i* or *j*\n in the slice expression are replaced by zero or "sys.maxsize",\n respectively. If negative indexes are used in the slice, the\n length of the sequence is added to that index. If the instance does\n not implement the "__len__()" method, an "AttributeError" is\n raised. No guarantee is made that indexes adjusted this way are not\n still negative. Indexes which are greater than the length of the\n sequence are not modified. If no "__getslice__()" is found, a slice\n object is created instead, and passed to "__getitem__()" instead.\n\nobject.__setslice__(self, i, j, sequence)\n\n Called to implement assignment to "self[i:j]". Same notes for *i*\n and *j* as for "__getslice__()".\n\n This method is deprecated. If no "__setslice__()" is found, or for\n extended slicing of the form "self[i:j:k]", a slice object is\n created, and passed to "__setitem__()", instead of "__setslice__()"\n being called.\n\nobject.__delslice__(self, i, j)\n\n Called to implement deletion of "self[i:j]". Same notes for *i* and\n *j* as for "__getslice__()". This method is deprecated. If no\n "__delslice__()" is found, or for extended slicing of the form\n "self[i:j:k]", a slice object is created, and passed to\n "__delitem__()", instead of "__delslice__()" being called.\n\nNotice that these methods are only invoked when a single slice with a\nsingle colon is used, and the slice method is available. For slice\noperations involving extended slice notation, or in absence of the\nslice methods, "__getitem__()", "__setitem__()" or "__delitem__()" is\ncalled with a slice object as argument.\n\nThe following example demonstrate how to make your program or module\ncompatible with earlier versions of Python (assuming that methods\n"__getitem__()", "__setitem__()" and "__delitem__()" support slice\nobjects as arguments):\n\n class MyClass:\n ...\n def __getitem__(self, index):\n ...\n def __setitem__(self, index, value):\n ...\n def __delitem__(self, index):\n ...\n\n if sys.version_info < (2, 0):\n # They won\'t be defined if version is at least 2.0 final\n\n def __getslice__(self, i, j):\n return self[max(0, i):max(0, j):]\n def __setslice__(self, i, j, seq):\n self[max(0, i):max(0, j):] = seq\n def __delslice__(self, i, j):\n del self[max(0, i):max(0, j):]\n ...\n\nNote the calls to "max()"; these are necessary because of the handling\nof negative indices before the "__*slice__()" methods are called.\nWhen negative indexes are used, the "__*item__()" methods receive them\nas provided, but the "__*slice__()" methods get a "cooked" form of the\nindex values. For each negative index value, the length of the\nsequence is added to the index before calling the method (which may\nstill result in a negative index); this is the customary handling of\nnegative indexes by the built-in sequence types, and the "__*item__()"\nmethods are expected to do this as well. However, since they should\nalready be doing that, negative indexes cannot be passed in; they must\nbe constrained to the bounds of the sequence before being passed to\nthe "__*item__()" methods. Calling "max(0, i)" conveniently returns\nthe proper value.\n\n\nEmulating numeric types\n=======================\n\nThe following methods can be defined to emulate numeric objects.\nMethods corresponding to operations that are not supported by the\nparticular kind of number implemented (e.g., bitwise operations for\nnon-integral numbers) should be left undefined.\n\nobject.__add__(self, other)\nobject.__sub__(self, other)\nobject.__mul__(self, other)\nobject.__floordiv__(self, other)\nobject.__mod__(self, other)\nobject.__divmod__(self, other)\nobject.__pow__(self, other[, modulo])\nobject.__lshift__(self, other)\nobject.__rshift__(self, other)\nobject.__and__(self, other)\nobject.__xor__(self, other)\nobject.__or__(self, other)\n\n These methods are called to implement the binary arithmetic\n operations ("+", "-", "*", "//", "%", "divmod()", "pow()", "**",\n "<<", ">>", "&", "^", "|"). For instance, to evaluate the\n expression "x + y", where *x* is an instance of a class that has an\n "__add__()" method, "x.__add__(y)" is called. The "__divmod__()"\n method should be the equivalent to using "__floordiv__()" and\n "__mod__()"; it should not be related to "__truediv__()" (described\n below). Note that "__pow__()" should be defined to accept an\n optional third argument if the ternary version of the built-in\n "pow()" function is to be supported.\n\n If one of those methods does not support the operation with the\n supplied arguments, it should return "NotImplemented".\n\nobject.__div__(self, other)\nobject.__truediv__(self, other)\n\n The division operator ("/") is implemented by these methods. The\n "__truediv__()" method is used when "__future__.division" is in\n effect, otherwise "__div__()" is used. If only one of these two\n methods is defined, the object will not support division in the\n alternate context; "TypeError" will be raised instead.\n\nobject.__radd__(self, other)\nobject.__rsub__(self, other)\nobject.__rmul__(self, other)\nobject.__rdiv__(self, other)\nobject.__rtruediv__(self, other)\nobject.__rfloordiv__(self, other)\nobject.__rmod__(self, other)\nobject.__rdivmod__(self, other)\nobject.__rpow__(self, other)\nobject.__rlshift__(self, other)\nobject.__rrshift__(self, other)\nobject.__rand__(self, other)\nobject.__rxor__(self, other)\nobject.__ror__(self, other)\n\n These methods are called to implement the binary arithmetic\n operations ("+", "-", "*", "/", "%", "divmod()", "pow()", "**",\n "<<", ">>", "&", "^", "|") with reflected (swapped) operands.\n These functions are only called if the left operand does not\n support the corresponding operation and the operands are of\n different types. [2] For instance, to evaluate the expression "x -\n y", where *y* is an instance of a class that has an "__rsub__()"\n method, "y.__rsub__(x)" is called if "x.__sub__(y)" returns\n *NotImplemented*.\n\n Note that ternary "pow()" will not try calling "__rpow__()" (the\n coercion rules would become too complicated).\n\n Note: If the right operand\'s type is a subclass of the left\n operand\'s type and that subclass provides the reflected method\n for the operation, this method will be called before the left\n operand\'s non-reflected method. This behavior allows subclasses\n to override their ancestors\' operations.\n\nobject.__iadd__(self, other)\nobject.__isub__(self, other)\nobject.__imul__(self, other)\nobject.__idiv__(self, other)\nobject.__itruediv__(self, other)\nobject.__ifloordiv__(self, other)\nobject.__imod__(self, other)\nobject.__ipow__(self, other[, modulo])\nobject.__ilshift__(self, other)\nobject.__irshift__(self, other)\nobject.__iand__(self, other)\nobject.__ixor__(self, other)\nobject.__ior__(self, other)\n\n These methods are called to implement the augmented arithmetic\n assignments ("+=", "-=", "*=", "/=", "//=", "%=", "**=", "<<=",\n ">>=", "&=", "^=", "|="). These methods should attempt to do the\n operation in-place (modifying *self*) and return the result (which\n could be, but does not have to be, *self*). If a specific method\n is not defined, the augmented assignment falls back to the normal\n methods. For instance, to execute the statement "x += y", where\n *x* is an instance of a class that has an "__iadd__()" method,\n "x.__iadd__(y)" is called. If *x* is an instance of a class that\n does not define a "__iadd__()" method, "x.__add__(y)" and\n "y.__radd__(x)" are considered, as with the evaluation of "x + y".\n\nobject.__neg__(self)\nobject.__pos__(self)\nobject.__abs__(self)\nobject.__invert__(self)\n\n Called to implement the unary arithmetic operations ("-", "+",\n "abs()" and "~").\n\nobject.__complex__(self)\nobject.__int__(self)\nobject.__long__(self)\nobject.__float__(self)\n\n Called to implement the built-in functions "complex()", "int()",\n "long()", and "float()". Should return a value of the appropriate\n type.\n\nobject.__oct__(self)\nobject.__hex__(self)\n\n Called to implement the built-in functions "oct()" and "hex()".\n Should return a string value.\n\nobject.__index__(self)\n\n Called to implement "operator.index()". Also called whenever\n Python needs an integer object (such as in slicing). Must return\n an integer (int or long).\n\n New in version 2.5.\n\nobject.__coerce__(self, other)\n\n Called to implement "mixed-mode" numeric arithmetic. Should either\n return a 2-tuple containing *self* and *other* converted to a\n common numeric type, or "None" if conversion is impossible. When\n the common type would be the type of "other", it is sufficient to\n return "None", since the interpreter will also ask the other object\n to attempt a coercion (but sometimes, if the implementation of the\n other type cannot be changed, it is useful to do the conversion to\n the other type here). A return value of "NotImplemented" is\n equivalent to returning "None".\n\n\nCoercion rules\n==============\n\nThis section used to document the rules for coercion. As the language\nhas evolved, the coercion rules have become hard to document\nprecisely; documenting what one version of one particular\nimplementation does is undesirable. Instead, here are some informal\nguidelines regarding coercion. In Python 3, coercion will not be\nsupported.\n\n* If the left operand of a % operator is a string or Unicode object,\n no coercion takes place and the string formatting operation is\n invoked instead.\n\n* It is no longer recommended to define a coercion operation. Mixed-\n mode operations on types that don\'t define coercion pass the\n original arguments to the operation.\n\n* New-style classes (those derived from "object") never invoke the\n "__coerce__()" method in response to a binary operator; the only\n time "__coerce__()" is invoked is when the built-in function\n "coerce()" is called.\n\n* For most intents and purposes, an operator that returns\n "NotImplemented" is treated the same as one that is not implemented\n at all.\n\n* Below, "__op__()" and "__rop__()" are used to signify the generic\n method names corresponding to an operator; "__iop__()" is used for\n the corresponding in-place operator. For example, for the operator\n \'"+"\', "__add__()" and "__radd__()" are used for the left and right\n variant of the binary operator, and "__iadd__()" for the in-place\n variant.\n\n* For objects *x* and *y*, first "x.__op__(y)" is tried. If this is\n not implemented or returns "NotImplemented", "y.__rop__(x)" is\n tried. If this is also not implemented or returns "NotImplemented",\n a "TypeError" exception is raised. But see the following exception:\n\n* Exception to the previous item: if the left operand is an instance\n of a built-in type or a new-style class, and the right operand is an\n instance of a proper subclass of that type or class and overrides\n the base\'s "__rop__()" method, the right operand\'s "__rop__()"\n method is tried *before* the left operand\'s "__op__()" method.\n\n This is done so that a subclass can completely override binary\n operators. Otherwise, the left operand\'s "__op__()" method would\n always accept the right operand: when an instance of a given class\n is expected, an instance of a subclass of that class is always\n acceptable.\n\n* When either operand type defines a coercion, this coercion is\n called before that type\'s "__op__()" or "__rop__()" method is\n called, but no sooner. If the coercion returns an object of a\n different type for the operand whose coercion is invoked, part of\n the process is redone using the new object.\n\n* When an in-place operator (like \'"+="\') is used, if the left\n operand implements "__iop__()", it is invoked without any coercion.\n When the operation falls back to "__op__()" and/or "__rop__()", the\n normal coercion rules apply.\n\n* In "x + y", if *x* is a sequence that implements sequence\n concatenation, sequence concatenation is invoked.\n\n* In "x * y", if one operand is a sequence that implements sequence\n repetition, and the other is an integer ("int" or "long"), sequence\n repetition is invoked.\n\n* Rich comparisons (implemented by methods "__eq__()" and so on)\n never use coercion. Three-way comparison (implemented by\n "__cmp__()") does use coercion under the same conditions as other\n binary operations use it.\n\n* In the current implementation, the built-in numeric types "int",\n "long", "float", and "complex" do not use coercion. All these types\n implement a "__coerce__()" method, for use by the built-in\n "coerce()" function.\n\n Changed in version 2.7: The complex type no longer makes implicit\n calls to the "__coerce__()" method for mixed-type binary arithmetic\n operations.\n\n\nWith Statement Context Managers\n===============================\n\nNew in version 2.5.\n\nA *context manager* is an object that defines the runtime context to\nbe established when executing a "with" statement. The context manager\nhandles the entry into, and the exit from, the desired runtime context\nfor the execution of the block of code. Context managers are normally\ninvoked using the "with" statement (described in section The with\nstatement), but can also be used by directly invoking their methods.\n\nTypical uses of context managers include saving and restoring various\nkinds of global state, locking and unlocking resources, closing opened\nfiles, etc.\n\nFor more information on context managers, see Context Manager Types.\n\nobject.__enter__(self)\n\n Enter the runtime context related to this object. The "with"\n statement will bind this method\'s return value to the target(s)\n specified in the "as" clause of the statement, if any.\n\nobject.__exit__(self, exc_type, exc_value, traceback)\n\n Exit the runtime context related to this object. The parameters\n describe the exception that caused the context to be exited. If the\n context was exited without an exception, all three arguments will\n be "None".\n\n If an exception is supplied, and the method wishes to suppress the\n exception (i.e., prevent it from being propagated), it should\n return a true value. Otherwise, the exception will be processed\n normally upon exit from this method.\n\n Note that "__exit__()" methods should not reraise the passed-in\n exception; this is the caller\'s responsibility.\n\nSee also:\n\n **PEP 343** - The "with" statement\n The specification, background, and examples for the Python "with"\n statement.\n\n\nSpecial method lookup for old-style classes\n===========================================\n\nFor old-style classes, special methods are always looked up in exactly\nthe same way as any other method or attribute. This is the case\nregardless of whether the method is being looked up explicitly as in\n"x.__getitem__(i)" or implicitly as in "x[i]".\n\nThis behaviour means that special methods may exhibit different\nbehaviour for different instances of a single old-style class if the\nappropriate special attributes are set differently:\n\n >>> class C:\n ... pass\n ...\n >>> c1 = C()\n >>> c2 = C()\n >>> c1.__len__ = lambda: 5\n >>> c2.__len__ = lambda: 9\n >>> len(c1)\n 5\n >>> len(c2)\n 9\n\n\nSpecial method lookup for new-style classes\n===========================================\n\nFor new-style classes, implicit invocations of special methods are\nonly guaranteed to work correctly if defined on an object\'s type, not\nin the object\'s instance dictionary. That behaviour is the reason why\nthe following code raises an exception (unlike the equivalent example\nwith old-style classes):\n\n >>> class C(object):\n ... pass\n ...\n >>> c = C()\n >>> c.__len__ = lambda: 5\n >>> len(c)\n Traceback (most recent call last):\n File "<stdin>", line 1, in <module>\n TypeError: object of type \'C\' has no len()\n\nThe rationale behind this behaviour lies with a number of special\nmethods such as "__hash__()" and "__repr__()" that are implemented by\nall objects, including type objects. If the implicit lookup of these\nmethods used the conventional lookup process, they would fail when\ninvoked on the type object itself:\n\n >>> 1 .__hash__() == hash(1)\n True\n >>> int.__hash__() == hash(int)\n Traceback (most recent call last):\n File "<stdin>", line 1, in <module>\n TypeError: descriptor \'__hash__\' of \'int\' object needs an argument\n\nIncorrectly attempting to invoke an unbound method of a class in this\nway is sometimes referred to as \'metaclass confusion\', and is avoided\nby bypassing the instance when looking up special methods:\n\n >>> type(1).__hash__(1) == hash(1)\n True\n >>> type(int).__hash__(int) == hash(int)\n True\n\nIn addition to bypassing any instance attributes in the interest of\ncorrectness, implicit special method lookup generally also bypasses\nthe "__getattribute__()" method even of the object\'s metaclass:\n\n >>> class Meta(type):\n ... def __getattribute__(*args):\n ... print "Metaclass getattribute invoked"\n ... return type.__getattribute__(*args)\n ...\n >>> class C(object):\n ... __metaclass__ = Meta\n ... def __len__(self):\n ... return 10\n ... def __getattribute__(*args):\n ... print "Class getattribute invoked"\n ... return object.__getattribute__(*args)\n ...\n >>> c = C()\n >>> c.__len__() # Explicit lookup via instance\n Class getattribute invoked\n 10\n >>> type(c).__len__(c) # Explicit lookup via type\n Metaclass getattribute invoked\n 10\n >>> len(c) # Implicit lookup\n 10\n\nBypassing the "__getattribute__()" machinery in this fashion provides\nsignificant scope for speed optimisations within the interpreter, at\nthe cost of some flexibility in the handling of special methods (the\nspecial method *must* be set on the class object itself in order to be\nconsistently invoked by the interpreter).\n\n-[ Footnotes ]-\n\n[1] It *is* possible in some cases to change an object\'s type,\n under certain controlled conditions. It generally isn\'t a good\n idea though, since it can lead to some very strange behaviour if\n it is handled incorrectly.\n\n[2] For operands of the same type, it is assumed that if the non-\n reflected method (such as "__add__()") fails the operation is not\n supported, which is why the reflected method is not called.\n',
- 'string-methods': u'\nString Methods\n**************\n\nBelow are listed the string methods which both 8-bit strings and\nUnicode objects support. Some of them are also available on\n"bytearray" objects.\n\nIn addition, Python\'s strings support the sequence type methods\ndescribed in the Sequence Types --- str, unicode, list, tuple,\nbytearray, buffer, xrange section. To output formatted strings use\ntemplate strings or the "%" operator described in the String\nFormatting Operations section. Also, see the "re" module for string\nfunctions based on regular expressions.\n\nstr.capitalize()\n\n Return a copy of the string with its first character capitalized\n and the rest lowercased.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.center(width[, fillchar])\n\n Return centered in a string of length *width*. Padding is done\n using the specified *fillchar* (default is a space).\n\n Changed in version 2.4: Support for the *fillchar* argument.\n\nstr.count(sub[, start[, end]])\n\n Return the number of non-overlapping occurrences of substring *sub*\n in the range [*start*, *end*]. Optional arguments *start* and\n *end* are interpreted as in slice notation.\n\nstr.decode([encoding[, errors]])\n\n Decodes the string using the codec registered for *encoding*.\n *encoding* defaults to the default string encoding. *errors* may\n be given to set a different error handling scheme. The default is\n "\'strict\'", meaning that encoding errors raise "UnicodeError".\n Other possible values are "\'ignore\'", "\'replace\'" and any other\n name registered via "codecs.register_error()", see section Codec\n Base Classes.\n\n New in version 2.2.\n\n Changed in version 2.3: Support for other error handling schemes\n added.\n\n Changed in version 2.7: Support for keyword arguments added.\n\nstr.encode([encoding[, errors]])\n\n Return an encoded version of the string. Default encoding is the\n current default string encoding. *errors* may be given to set a\n different error handling scheme. The default for *errors* is\n "\'strict\'", meaning that encoding errors raise a "UnicodeError".\n Other possible values are "\'ignore\'", "\'replace\'",\n "\'xmlcharrefreplace\'", "\'backslashreplace\'" and any other name\n registered via "codecs.register_error()", see section Codec Base\n Classes. For a list of possible encodings, see section Standard\n Encodings.\n\n New in version 2.0.\n\n Changed in version 2.3: Support for "\'xmlcharrefreplace\'" and\n "\'backslashreplace\'" and other error handling schemes added.\n\n Changed in version 2.7: Support for keyword arguments added.\n\nstr.endswith(suffix[, start[, end]])\n\n Return "True" if the string ends with the specified *suffix*,\n otherwise return "False". *suffix* can also be a tuple of suffixes\n to look for. With optional *start*, test beginning at that\n position. With optional *end*, stop comparing at that position.\n\n Changed in version 2.5: Accept tuples as *suffix*.\n\nstr.expandtabs([tabsize])\n\n Return a copy of the string where all tab characters are replaced\n by one or more spaces, depending on the current column and the\n given tab size. Tab positions occur every *tabsize* characters\n (default is 8, giving tab positions at columns 0, 8, 16 and so on).\n To expand the string, the current column is set to zero and the\n string is examined character by character. If the character is a\n tab ("\\t"), one or more space characters are inserted in the result\n until the current column is equal to the next tab position. (The\n tab character itself is not copied.) If the character is a newline\n ("\\n") or return ("\\r"), it is copied and the current column is\n reset to zero. Any other character is copied unchanged and the\n current column is incremented by one regardless of how the\n character is represented when printed.\n\n >>> \'01\\t012\\t0123\\t01234\'.expandtabs()\n \'01 012 0123 01234\'\n >>> \'01\\t012\\t0123\\t01234\'.expandtabs(4)\n \'01 012 0123 01234\'\n\nstr.find(sub[, start[, end]])\n\n Return the lowest index in the string where substring *sub* is\n found within the slice "s[start:end]". Optional arguments *start*\n and *end* are interpreted as in slice notation. Return "-1" if\n *sub* is not found.\n\n Note: The "find()" method should be used only if you need to know\n the position of *sub*. To check if *sub* is a substring or not,\n use the "in" operator:\n\n >>> \'Py\' in \'Python\'\n True\n\nstr.format(*args, **kwargs)\n\n Perform a string formatting operation. The string on which this\n method is called can contain literal text or replacement fields\n delimited by braces "{}". Each replacement field contains either\n the numeric index of a positional argument, or the name of a\n keyword argument. Returns a copy of the string where each\n replacement field is replaced with the string value of the\n corresponding argument.\n\n >>> "The sum of 1 + 2 is {0}".format(1+2)\n \'The sum of 1 + 2 is 3\'\n\n See Format String Syntax for a description of the various\n formatting options that can be specified in format strings.\n\n This method of string formatting is the new standard in Python 3,\n and should be preferred to the "%" formatting described in String\n Formatting Operations in new code.\n\n New in version 2.6.\n\nstr.index(sub[, start[, end]])\n\n Like "find()", but raise "ValueError" when the substring is not\n found.\n\nstr.isalnum()\n\n Return true if all characters in the string are alphanumeric and\n there is at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isalpha()\n\n Return true if all characters in the string are alphabetic and\n there is at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isdigit()\n\n Return true if all characters in the string are digits and there is\n at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.islower()\n\n Return true if all cased characters [4] in the string are lowercase\n and there is at least one cased character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isspace()\n\n Return true if there are only whitespace characters in the string\n and there is at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.istitle()\n\n Return true if the string is a titlecased string and there is at\n least one character, for example uppercase characters may only\n follow uncased characters and lowercase characters only cased ones.\n Return false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isupper()\n\n Return true if all cased characters [4] in the string are uppercase\n and there is at least one cased character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.join(iterable)\n\n Return a string which is the concatenation of the strings in the\n *iterable* *iterable*. The separator between elements is the\n string providing this method.\n\nstr.ljust(width[, fillchar])\n\n Return the string left justified in a string of length *width*.\n Padding is done using the specified *fillchar* (default is a\n space). The original string is returned if *width* is less than or\n equal to "len(s)".\n\n Changed in version 2.4: Support for the *fillchar* argument.\n\nstr.lower()\n\n Return a copy of the string with all the cased characters [4]\n converted to lowercase.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.lstrip([chars])\n\n Return a copy of the string with leading characters removed. The\n *chars* argument is a string specifying the set of characters to be\n removed. If omitted or "None", the *chars* argument defaults to\n removing whitespace. The *chars* argument is not a prefix; rather,\n all combinations of its values are stripped:\n\n >>> \' spacious \'.lstrip()\n \'spacious \'\n >>> \'www.example.com\'.lstrip(\'cmowz.\')\n \'example.com\'\n\n Changed in version 2.2.2: Support for the *chars* argument.\n\nstr.partition(sep)\n\n Split the string at the first occurrence of *sep*, and return a\n 3-tuple containing the part before the separator, the separator\n itself, and the part after the separator. If the separator is not\n found, return a 3-tuple containing the string itself, followed by\n two empty strings.\n\n New in version 2.5.\n\nstr.replace(old, new[, count])\n\n Return a copy of the string with all occurrences of substring *old*\n replaced by *new*. If the optional argument *count* is given, only\n the first *count* occurrences are replaced.\n\nstr.rfind(sub[, start[, end]])\n\n Return the highest index in the string where substring *sub* is\n found, such that *sub* is contained within "s[start:end]".\n Optional arguments *start* and *end* are interpreted as in slice\n notation. Return "-1" on failure.\n\nstr.rindex(sub[, start[, end]])\n\n Like "rfind()" but raises "ValueError" when the substring *sub* is\n not found.\n\nstr.rjust(width[, fillchar])\n\n Return the string right justified in a string of length *width*.\n Padding is done using the specified *fillchar* (default is a\n space). The original string is returned if *width* is less than or\n equal to "len(s)".\n\n Changed in version 2.4: Support for the *fillchar* argument.\n\nstr.rpartition(sep)\n\n Split the string at the last occurrence of *sep*, and return a\n 3-tuple containing the part before the separator, the separator\n itself, and the part after the separator. If the separator is not\n found, return a 3-tuple containing two empty strings, followed by\n the string itself.\n\n New in version 2.5.\n\nstr.rsplit([sep[, maxsplit]])\n\n Return a list of the words in the string, using *sep* as the\n delimiter string. If *maxsplit* is given, at most *maxsplit* splits\n are done, the *rightmost* ones. If *sep* is not specified or\n "None", any whitespace string is a separator. Except for splitting\n from the right, "rsplit()" behaves like "split()" which is\n described in detail below.\n\n New in version 2.4.\n\nstr.rstrip([chars])\n\n Return a copy of the string with trailing characters removed. The\n *chars* argument is a string specifying the set of characters to be\n removed. If omitted or "None", the *chars* argument defaults to\n removing whitespace. The *chars* argument is not a suffix; rather,\n all combinations of its values are stripped:\n\n >>> \' spacious \'.rstrip()\n \' spacious\'\n >>> \'mississippi\'.rstrip(\'ipz\')\n \'mississ\'\n\n Changed in version 2.2.2: Support for the *chars* argument.\n\nstr.split([sep[, maxsplit]])\n\n Return a list of the words in the string, using *sep* as the\n delimiter string. If *maxsplit* is given, at most *maxsplit*\n splits are done (thus, the list will have at most "maxsplit+1"\n elements). If *maxsplit* is not specified or "-1", then there is\n no limit on the number of splits (all possible splits are made).\n\n If *sep* is given, consecutive delimiters are not grouped together\n and are deemed to delimit empty strings (for example,\n "\'1,,2\'.split(\',\')" returns "[\'1\', \'\', \'2\']"). The *sep* argument\n may consist of multiple characters (for example,\n "\'1<>2<>3\'.split(\'<>\')" returns "[\'1\', \'2\', \'3\']"). Splitting an\n empty string with a specified separator returns "[\'\']".\n\n If *sep* is not specified or is "None", a different splitting\n algorithm is applied: runs of consecutive whitespace are regarded\n as a single separator, and the result will contain no empty strings\n at the start or end if the string has leading or trailing\n whitespace. Consequently, splitting an empty string or a string\n consisting of just whitespace with a "None" separator returns "[]".\n\n For example, "\' 1 2 3 \'.split()" returns "[\'1\', \'2\', \'3\']", and\n "\' 1 2 3 \'.split(None, 1)" returns "[\'1\', \'2 3 \']".\n\nstr.splitlines([keepends])\n\n Return a list of the lines in the string, breaking at line\n boundaries. This method uses the *universal newlines* approach to\n splitting lines. Line breaks are not included in the resulting list\n unless *keepends* is given and true.\n\n Python recognizes ""\\r"", ""\\n"", and ""\\r\\n"" as line boundaries\n for 8-bit strings.\n\n For example:\n\n >>> \'ab c\\n\\nde fg\\rkl\\r\\n\'.splitlines()\n [\'ab c\', \'\', \'de fg\', \'kl\']\n >>> \'ab c\\n\\nde fg\\rkl\\r\\n\'.splitlines(True)\n [\'ab c\\n\', \'\\n\', \'de fg\\r\', \'kl\\r\\n\']\n\n Unlike "split()" when a delimiter string *sep* is given, this\n method returns an empty list for the empty string, and a terminal\n line break does not result in an extra line:\n\n >>> "".splitlines()\n []\n >>> "One line\\n".splitlines()\n [\'One line\']\n\n For comparison, "split(\'\\n\')" gives:\n\n >>> \'\'.split(\'\\n\')\n [\'\']\n >>> \'Two lines\\n\'.split(\'\\n\')\n [\'Two lines\', \'\']\n\nunicode.splitlines([keepends])\n\n Return a list of the lines in the string, like "str.splitlines()".\n However, the Unicode method splits on the following line\n boundaries, which are a superset of the *universal newlines*\n recognized for 8-bit strings.\n\n +-------------------------+-------------------------------+\n | Representation | Description |\n +=========================+===============================+\n | "\\n" | Line Feed |\n +-------------------------+-------------------------------+\n | "\\r" | Carriage Return |\n +-------------------------+-------------------------------+\n | "\\r\\n" | Carriage Return + Line Feed |\n +-------------------------+-------------------------------+\n | "\\v" or "\\x0b" | Line Tabulation |\n +-------------------------+-------------------------------+\n | "\\f" or "\\x0c" | Form Feed |\n +-------------------------+-------------------------------+\n | "\\x1c" | File Separator |\n +-------------------------+-------------------------------+\n | "\\x1d" | Group Separator |\n +-------------------------+-------------------------------+\n | "\\x1e" | Record Separator |\n +-------------------------+-------------------------------+\n | "\\x85" | Next Line (C1 Control Code) |\n +-------------------------+-------------------------------+\n | "\\u2028" | Line Separator |\n +-------------------------+-------------------------------+\n | "\\u2029" | Paragraph Separator |\n +-------------------------+-------------------------------+\n\n Changed in version 2.7: "\\v" and "\\f" added to list of line\n boundaries.\n\nstr.startswith(prefix[, start[, end]])\n\n Return "True" if string starts with the *prefix*, otherwise return\n "False". *prefix* can also be a tuple of prefixes to look for.\n With optional *start*, test string beginning at that position.\n With optional *end*, stop comparing string at that position.\n\n Changed in version 2.5: Accept tuples as *prefix*.\n\nstr.strip([chars])\n\n Return a copy of the string with the leading and trailing\n characters removed. The *chars* argument is a string specifying the\n set of characters to be removed. If omitted or "None", the *chars*\n argument defaults to removing whitespace. The *chars* argument is\n not a prefix or suffix; rather, all combinations of its values are\n stripped:\n\n >>> \' spacious \'.strip()\n \'spacious\'\n >>> \'www.example.com\'.strip(\'cmowz.\')\n \'example\'\n\n Changed in version 2.2.2: Support for the *chars* argument.\n\nstr.swapcase()\n\n Return a copy of the string with uppercase characters converted to\n lowercase and vice versa.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.title()\n\n Return a titlecased version of the string where words start with an\n uppercase character and the remaining characters are lowercase.\n\n The algorithm uses a simple language-independent definition of a\n word as groups of consecutive letters. The definition works in\n many contexts but it means that apostrophes in contractions and\n possessives form word boundaries, which may not be the desired\n result:\n\n >>> "they\'re bill\'s friends from the UK".title()\n "They\'Re Bill\'S Friends From The Uk"\n\n A workaround for apostrophes can be constructed using regular\n expressions:\n\n >>> import re\n >>> def titlecase(s):\n ... return re.sub(r"[A-Za-z]+(\'[A-Za-z]+)?",\n ... lambda mo: mo.group(0)[0].upper() +\n ... mo.group(0)[1:].lower(),\n ... s)\n ...\n >>> titlecase("they\'re bill\'s friends.")\n "They\'re Bill\'s Friends."\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.translate(table[, deletechars])\n\n Return a copy of the string where all characters occurring in the\n optional argument *deletechars* are removed, and the remaining\n characters have been mapped through the given translation table,\n which must be a string of length 256.\n\n You can use the "maketrans()" helper function in the "string"\n module to create a translation table. For string objects, set the\n *table* argument to "None" for translations that only delete\n characters:\n\n >>> \'read this short text\'.translate(None, \'aeiou\')\n \'rd ths shrt txt\'\n\n New in version 2.6: Support for a "None" *table* argument.\n\n For Unicode objects, the "translate()" method does not accept the\n optional *deletechars* argument. Instead, it returns a copy of the\n *s* where all characters have been mapped through the given\n translation table which must be a mapping of Unicode ordinals to\n Unicode ordinals, Unicode strings or "None". Unmapped characters\n are left untouched. Characters mapped to "None" are deleted. Note,\n a more flexible approach is to create a custom character mapping\n codec using the "codecs" module (see "encodings.cp1251" for an\n example).\n\nstr.upper()\n\n Return a copy of the string with all the cased characters [4]\n converted to uppercase. Note that "str.upper().isupper()" might be\n "False" if "s" contains uncased characters or if the Unicode\n category of the resulting character(s) is not "Lu" (Letter,\n uppercase), but e.g. "Lt" (Letter, titlecase).\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.zfill(width)\n\n Return the numeric string left filled with zeros in a string of\n length *width*. A sign prefix is handled correctly. The original\n string is returned if *width* is less than or equal to "len(s)".\n\n New in version 2.2.2.\n\nThe following methods are present only on unicode objects:\n\nunicode.isnumeric()\n\n Return "True" if there are only numeric characters in S, "False"\n otherwise. Numeric characters include digit characters, and all\n characters that have the Unicode numeric value property, e.g.\n U+2155, VULGAR FRACTION ONE FIFTH.\n\nunicode.isdecimal()\n\n Return "True" if there are only decimal characters in S, "False"\n otherwise. Decimal characters include digit characters, and all\n characters that can be used to form decimal-radix numbers, e.g.\n U+0660, ARABIC-INDIC DIGIT ZERO.\n',
- 'strings': u'\nString literals\n***************\n\nString literals are described by the following lexical definitions:\n\n stringliteral ::= [stringprefix](shortstring | longstring)\n stringprefix ::= "r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" | "uR"\n | "b" | "B" | "br" | "Br" | "bR" | "BR"\n shortstring ::= "\'" shortstringitem* "\'" | \'"\' shortstringitem* \'"\'\n longstring ::= "\'\'\'" longstringitem* "\'\'\'"\n | \'"""\' longstringitem* \'"""\'\n shortstringitem ::= shortstringchar | escapeseq\n longstringitem ::= longstringchar | escapeseq\n shortstringchar ::= <any source character except "\\" or newline or the quote>\n longstringchar ::= <any source character except "\\">\n escapeseq ::= "\\" <any ASCII character>\n\nOne syntactic restriction not indicated by these productions is that\nwhitespace is not allowed between the "stringprefix" and the rest of\nthe string literal. The source character set is defined by the\nencoding declaration; it is ASCII if no encoding declaration is given\nin the source file; see section Encoding declarations.\n\nIn plain English: String literals can be enclosed in matching single\nquotes ("\'") or double quotes ("""). They can also be enclosed in\nmatching groups of three single or double quotes (these are generally\nreferred to as *triple-quoted strings*). The backslash ("\\")\ncharacter is used to escape characters that otherwise have a special\nmeaning, such as newline, backslash itself, or the quote character.\nString literals may optionally be prefixed with a letter "\'r\'" or\n"\'R\'"; such strings are called *raw strings* and use different rules\nfor interpreting backslash escape sequences. A prefix of "\'u\'" or\n"\'U\'" makes the string a Unicode string. Unicode strings use the\nUnicode character set as defined by the Unicode Consortium and ISO\n10646. Some additional escape sequences, described below, are\navailable in Unicode strings. A prefix of "\'b\'" or "\'B\'" is ignored in\nPython 2; it indicates that the literal should become a bytes literal\nin Python 3 (e.g. when code is automatically converted with 2to3). A\n"\'u\'" or "\'b\'" prefix may be followed by an "\'r\'" prefix.\n\nIn triple-quoted strings, unescaped newlines and quotes are allowed\n(and are retained), except that three unescaped quotes in a row\nterminate the string. (A "quote" is the character used to open the\nstring, i.e. either "\'" or """.)\n\nUnless an "\'r\'" or "\'R\'" prefix is present, escape sequences in\nstrings are interpreted according to rules similar to those used by\nStandard C. The recognized escape sequences are:\n\n+-------------------+-----------------------------------+---------+\n| Escape Sequence | Meaning | Notes |\n+===================+===================================+=========+\n| "\\newline" | Ignored | |\n+-------------------+-----------------------------------+---------+\n| "\\\\" | Backslash ("\\") | |\n+-------------------+-----------------------------------+---------+\n| "\\\'" | Single quote ("\'") | |\n+-------------------+-----------------------------------+---------+\n| "\\"" | Double quote (""") | |\n+-------------------+-----------------------------------+---------+\n| "\\a" | ASCII Bell (BEL) | |\n+-------------------+-----------------------------------+---------+\n| "\\b" | ASCII Backspace (BS) | |\n+-------------------+-----------------------------------+---------+\n| "\\f" | ASCII Formfeed (FF) | |\n+-------------------+-----------------------------------+---------+\n| "\\n" | ASCII Linefeed (LF) | |\n+-------------------+-----------------------------------+---------+\n| "\\N{name}" | Character named *name* in the | |\n| | Unicode database (Unicode only) | |\n+-------------------+-----------------------------------+---------+\n| "\\r" | ASCII Carriage Return (CR) | |\n+-------------------+-----------------------------------+---------+\n| "\\t" | ASCII Horizontal Tab (TAB) | |\n+-------------------+-----------------------------------+---------+\n| "\\uxxxx" | Character with 16-bit hex value | (1) |\n| | *xxxx* (Unicode only) | |\n+-------------------+-----------------------------------+---------+\n| "\\Uxxxxxxxx" | Character with 32-bit hex value | (2) |\n| | *xxxxxxxx* (Unicode only) | |\n+-------------------+-----------------------------------+---------+\n| "\\v" | ASCII Vertical Tab (VT) | |\n+-------------------+-----------------------------------+---------+\n| "\\ooo" | Character with octal value *ooo* | (3,5) |\n+-------------------+-----------------------------------+---------+\n| "\\xhh" | Character with hex value *hh* | (4,5) |\n+-------------------+-----------------------------------+---------+\n\nNotes:\n\n1. Individual code units which form parts of a surrogate pair can\n be encoded using this escape sequence.\n\n2. Any Unicode character can be encoded this way, but characters\n outside the Basic Multilingual Plane (BMP) will be encoded using a\n surrogate pair if Python is compiled to use 16-bit code units (the\n default).\n\n3. As in Standard C, up to three octal digits are accepted.\n\n4. Unlike in Standard C, exactly two hex digits are required.\n\n5. In a string literal, hexadecimal and octal escapes denote the\n byte with the given value; it is not necessary that the byte\n encodes a character in the source character set. In a Unicode\n literal, these escapes denote a Unicode character with the given\n value.\n\nUnlike Standard C, all unrecognized escape sequences are left in the\nstring unchanged, i.e., *the backslash is left in the string*. (This\nbehavior is useful when debugging: if an escape sequence is mistyped,\nthe resulting output is more easily recognized as broken.) It is also\nimportant to note that the escape sequences marked as "(Unicode only)"\nin the table above fall into the category of unrecognized escapes for\nnon-Unicode string literals.\n\nWhen an "\'r\'" or "\'R\'" prefix is present, a character following a\nbackslash is included in the string without change, and *all\nbackslashes are left in the string*. For example, the string literal\n"r"\\n"" consists of two characters: a backslash and a lowercase "\'n\'".\nString quotes can be escaped with a backslash, but the backslash\nremains in the string; for example, "r"\\""" is a valid string literal\nconsisting of two characters: a backslash and a double quote; "r"\\""\nis not a valid string literal (even a raw string cannot end in an odd\nnumber of backslashes). Specifically, *a raw string cannot end in a\nsingle backslash* (since the backslash would escape the following\nquote character). Note also that a single backslash followed by a\nnewline is interpreted as those two characters as part of the string,\n*not* as a line continuation.\n\nWhen an "\'r\'" or "\'R\'" prefix is used in conjunction with a "\'u\'" or\n"\'U\'" prefix, then the "\\uXXXX" and "\\UXXXXXXXX" escape sequences are\nprocessed while *all other backslashes are left in the string*. For\nexample, the string literal "ur"\\u0062\\n"" consists of three Unicode\ncharacters: \'LATIN SMALL LETTER B\', \'REVERSE SOLIDUS\', and \'LATIN\nSMALL LETTER N\'. Backslashes can be escaped with a preceding\nbackslash; however, both remain in the string. As a result, "\\uXXXX"\nescape sequences are only recognized when there are an odd number of\nbackslashes.\n',
- 'subscriptions': u'\nSubscriptions\n*************\n\nA subscription selects an item of a sequence (string, tuple or list)\nor mapping (dictionary) object:\n\n subscription ::= primary "[" expression_list "]"\n\nThe primary must evaluate to an object of a sequence or mapping type.\n\nIf the primary is a mapping, the expression list must evaluate to an\nobject whose value is one of the keys of the mapping, and the\nsubscription selects the value in the mapping that corresponds to that\nkey. (The expression list is a tuple except if it has exactly one\nitem.)\n\nIf the primary is a sequence, the expression (list) must evaluate to a\nplain integer. If this value is negative, the length of the sequence\nis added to it (so that, e.g., "x[-1]" selects the last item of "x".)\nThe resulting value must be a nonnegative integer less than the number\nof items in the sequence, and the subscription selects the item whose\nindex is that value (counting from zero).\n\nA string\'s items are characters. A character is not a separate data\ntype but a string of exactly one character.\n',
- 'truth': u'\nTruth Value Testing\n*******************\n\nAny object can be tested for truth value, for use in an "if" or\n"while" condition or as operand of the Boolean operations below. The\nfollowing values are considered false:\n\n* "None"\n\n* "False"\n\n* zero of any numeric type, for example, "0", "0L", "0.0", "0j".\n\n* any empty sequence, for example, "\'\'", "()", "[]".\n\n* any empty mapping, for example, "{}".\n\n* instances of user-defined classes, if the class defines a\n "__nonzero__()" or "__len__()" method, when that method returns the\n integer zero or "bool" value "False". [1]\n\nAll other values are considered true --- so objects of many types are\nalways true.\n\nOperations and built-in functions that have a Boolean result always\nreturn "0" or "False" for false and "1" or "True" for true, unless\notherwise stated. (Important exception: the Boolean operations "or"\nand "and" always return one of their operands.)\n',
- 'try': u'\nThe "try" statement\n*******************\n\nThe "try" statement specifies exception handlers and/or cleanup code\nfor a group of statements:\n\n try_stmt ::= try1_stmt | try2_stmt\n try1_stmt ::= "try" ":" suite\n ("except" [expression [("as" | ",") identifier]] ":" suite)+\n ["else" ":" suite]\n ["finally" ":" suite]\n try2_stmt ::= "try" ":" suite\n "finally" ":" suite\n\nChanged in version 2.5: In previous versions of Python,\n"try"..."except"..."finally" did not work. "try"..."except" had to be\nnested in "try"..."finally".\n\nThe "except" clause(s) specify one or more exception handlers. When no\nexception occurs in the "try" clause, no exception handler is\nexecuted. When an exception occurs in the "try" suite, a search for an\nexception handler is started. This search inspects the except clauses\nin turn until one is found that matches the exception. An expression-\nless except clause, if present, must be last; it matches any\nexception. For an except clause with an expression, that expression\nis evaluated, and the clause matches the exception if the resulting\nobject is "compatible" with the exception. An object is compatible\nwith an exception if it is the class or a base class of the exception\nobject, or a tuple containing an item compatible with the exception.\n\nIf no except clause matches the exception, the search for an exception\nhandler continues in the surrounding code and on the invocation stack.\n[1]\n\nIf the evaluation of an expression in the header of an except clause\nraises an exception, the original search for a handler is canceled and\na search starts for the new exception in the surrounding code and on\nthe call stack (it is treated as if the entire "try" statement raised\nthe exception).\n\nWhen a matching except clause is found, the exception is assigned to\nthe target specified in that except clause, if present, and the except\nclause\'s suite is executed. All except clauses must have an\nexecutable block. When the end of this block is reached, execution\ncontinues normally after the entire try statement. (This means that\nif two nested handlers exist for the same exception, and the exception\noccurs in the try clause of the inner handler, the outer handler will\nnot handle the exception.)\n\nBefore an except clause\'s suite is executed, details about the\nexception are assigned to three variables in the "sys" module:\n"sys.exc_type" receives the object identifying the exception;\n"sys.exc_value" receives the exception\'s parameter;\n"sys.exc_traceback" receives a traceback object (see section The\nstandard type hierarchy) identifying the point in the program where\nthe exception occurred. These details are also available through the\n"sys.exc_info()" function, which returns a tuple "(exc_type,\nexc_value, exc_traceback)". Use of the corresponding variables is\ndeprecated in favor of this function, since their use is unsafe in a\nthreaded program. As of Python 1.5, the variables are restored to\ntheir previous values (before the call) when returning from a function\nthat handled an exception.\n\nThe optional "else" clause is executed if and when control flows off\nthe end of the "try" clause. [2] Exceptions in the "else" clause are\nnot handled by the preceding "except" clauses.\n\nIf "finally" is present, it specifies a \'cleanup\' handler. The "try"\nclause is executed, including any "except" and "else" clauses. If an\nexception occurs in any of the clauses and is not handled, the\nexception is temporarily saved. The "finally" clause is executed. If\nthere is a saved exception, it is re-raised at the end of the\n"finally" clause. If the "finally" clause raises another exception or\nexecutes a "return" or "break" statement, the saved exception is\ndiscarded:\n\n >>> def f():\n ... try:\n ... 1/0\n ... finally:\n ... return 42\n ...\n >>> f()\n 42\n\nThe exception information is not available to the program during\nexecution of the "finally" clause.\n\nWhen a "return", "break" or "continue" statement is executed in the\n"try" suite of a "try"..."finally" statement, the "finally" clause is\nalso executed \'on the way out.\' A "continue" statement is illegal in\nthe "finally" clause. (The reason is a problem with the current\nimplementation --- this restriction may be lifted in the future).\n\nThe return value of a function is determined by the last "return"\nstatement executed. Since the "finally" clause always executes, a\n"return" statement executed in the "finally" clause will always be the\nlast one executed:\n\n >>> def foo():\n ... try:\n ... return \'try\'\n ... finally:\n ... return \'finally\'\n ...\n >>> foo()\n \'finally\'\n\nAdditional information on exceptions can be found in section\nExceptions, and information on using the "raise" statement to generate\nexceptions may be found in section The raise statement.\n',
- 'types': u'\nThe standard type hierarchy\n***************************\n\nBelow is a list of the types that are built into Python. Extension\nmodules (written in C, Java, or other languages, depending on the\nimplementation) can define additional types. Future versions of\nPython may add types to the type hierarchy (e.g., rational numbers,\nefficiently stored arrays of integers, etc.).\n\nSome of the type descriptions below contain a paragraph listing\n\'special attributes.\' These are attributes that provide access to the\nimplementation and are not intended for general use. Their definition\nmay change in the future.\n\nNone\n This type has a single value. There is a single object with this\n value. This object is accessed through the built-in name "None". It\n is used to signify the absence of a value in many situations, e.g.,\n it is returned from functions that don\'t explicitly return\n anything. Its truth value is false.\n\nNotImplemented\n This type has a single value. There is a single object with this\n value. This object is accessed through the built-in name\n "NotImplemented". Numeric methods and rich comparison methods may\n return this value if they do not implement the operation for the\n operands provided. (The interpreter will then try the reflected\n operation, or some other fallback, depending on the operator.) Its\n truth value is true.\n\nEllipsis\n This type has a single value. There is a single object with this\n value. This object is accessed through the built-in name\n "Ellipsis". It is used to indicate the presence of the "..." syntax\n in a slice. Its truth value is true.\n\n"numbers.Number"\n These are created by numeric literals and returned as results by\n arithmetic operators and arithmetic built-in functions. Numeric\n objects are immutable; once created their value never changes.\n Python numbers are of course strongly related to mathematical\n numbers, but subject to the limitations of numerical representation\n in computers.\n\n Python distinguishes between integers, floating point numbers, and\n complex numbers:\n\n "numbers.Integral"\n These represent elements from the mathematical set of integers\n (positive and negative).\n\n There are three types of integers:\n\n Plain integers\n These represent numbers in the range -2147483648 through\n 2147483647. (The range may be larger on machines with a\n larger natural word size, but not smaller.) When the result\n of an operation would fall outside this range, the result is\n normally returned as a long integer (in some cases, the\n exception "OverflowError" is raised instead). For the\n purpose of shift and mask operations, integers are assumed to\n have a binary, 2\'s complement notation using 32 or more bits,\n and hiding no bits from the user (i.e., all 4294967296\n different bit patterns correspond to different values).\n\n Long integers\n These represent numbers in an unlimited range, subject to\n available (virtual) memory only. For the purpose of shift\n and mask operations, a binary representation is assumed, and\n negative numbers are represented in a variant of 2\'s\n complement which gives the illusion of an infinite string of\n sign bits extending to the left.\n\n Booleans\n These represent the truth values False and True. The two\n objects representing the values "False" and "True" are the\n only Boolean objects. The Boolean type is a subtype of plain\n integers, and Boolean values behave like the values 0 and 1,\n respectively, in almost all contexts, the exception being\n that when converted to a string, the strings ""False"" or\n ""True"" are returned, respectively.\n\n The rules for integer representation are intended to give the\n most meaningful interpretation of shift and mask operations\n involving negative integers and the least surprises when\n switching between the plain and long integer domains. Any\n operation, if it yields a result in the plain integer domain,\n will yield the same result in the long integer domain or when\n using mixed operands. The switch between domains is transparent\n to the programmer.\n\n "numbers.Real" ("float")\n These represent machine-level double precision floating point\n numbers. You are at the mercy of the underlying machine\n architecture (and C or Java implementation) for the accepted\n range and handling of overflow. Python does not support single-\n precision floating point numbers; the savings in processor and\n memory usage that are usually the reason for using these are\n dwarfed by the overhead of using objects in Python, so there is\n no reason to complicate the language with two kinds of floating\n point numbers.\n\n "numbers.Complex"\n These represent complex numbers as a pair of machine-level\n double precision floating point numbers. The same caveats apply\n as for floating point numbers. The real and imaginary parts of a\n complex number "z" can be retrieved through the read-only\n attributes "z.real" and "z.imag".\n\nSequences\n These represent finite ordered sets indexed by non-negative\n numbers. The built-in function "len()" returns the number of items\n of a sequence. When the length of a sequence is *n*, the index set\n contains the numbers 0, 1, ..., *n*-1. Item *i* of sequence *a* is\n selected by "a[i]".\n\n Sequences also support slicing: "a[i:j]" selects all items with\n index *k* such that *i* "<=" *k* "<" *j*. When used as an\n expression, a slice is a sequence of the same type. This implies\n that the index set is renumbered so that it starts at 0.\n\n Some sequences also support "extended slicing" with a third "step"\n parameter: "a[i:j:k]" selects all items of *a* with index *x* where\n "x = i + n*k", *n* ">=" "0" and *i* "<=" *x* "<" *j*.\n\n Sequences are distinguished according to their mutability:\n\n Immutable sequences\n An object of an immutable sequence type cannot change once it is\n created. (If the object contains references to other objects,\n these other objects may be mutable and may be changed; however,\n the collection of objects directly referenced by an immutable\n object cannot change.)\n\n The following types are immutable sequences:\n\n Strings\n The items of a string are characters. There is no separate\n character type; a character is represented by a string of one\n item. Characters represent (at least) 8-bit bytes. The\n built-in functions "chr()" and "ord()" convert between\n characters and nonnegative integers representing the byte\n values. Bytes with the values 0--127 usually represent the\n corresponding ASCII values, but the interpretation of values\n is up to the program. The string data type is also used to\n represent arrays of bytes, e.g., to hold data read from a\n file.\n\n (On systems whose native character set is not ASCII, strings\n may use EBCDIC in their internal representation, provided the\n functions "chr()" and "ord()" implement a mapping between\n ASCII and EBCDIC, and string comparison preserves the ASCII\n order. Or perhaps someone can propose a better rule?)\n\n Unicode\n The items of a Unicode object are Unicode code units. A\n Unicode code unit is represented by a Unicode object of one\n item and can hold either a 16-bit or 32-bit value\n representing a Unicode ordinal (the maximum value for the\n ordinal is given in "sys.maxunicode", and depends on how\n Python is configured at compile time). Surrogate pairs may\n be present in the Unicode object, and will be reported as two\n separate items. The built-in functions "unichr()" and\n "ord()" convert between code units and nonnegative integers\n representing the Unicode ordinals as defined in the Unicode\n Standard 3.0. Conversion from and to other encodings are\n possible through the Unicode method "encode()" and the built-\n in function "unicode()".\n\n Tuples\n The items of a tuple are arbitrary Python objects. Tuples of\n two or more items are formed by comma-separated lists of\n expressions. A tuple of one item (a \'singleton\') can be\n formed by affixing a comma to an expression (an expression by\n itself does not create a tuple, since parentheses must be\n usable for grouping of expressions). An empty tuple can be\n formed by an empty pair of parentheses.\n\n Mutable sequences\n Mutable sequences can be changed after they are created. The\n subscription and slicing notations can be used as the target of\n assignment and "del" (delete) statements.\n\n There are currently two intrinsic mutable sequence types:\n\n Lists\n The items of a list are arbitrary Python objects. Lists are\n formed by placing a comma-separated list of expressions in\n square brackets. (Note that there are no special cases needed\n to form lists of length 0 or 1.)\n\n Byte Arrays\n A bytearray object is a mutable array. They are created by\n the built-in "bytearray()" constructor. Aside from being\n mutable (and hence unhashable), byte arrays otherwise provide\n the same interface and functionality as immutable bytes\n objects.\n\n The extension module "array" provides an additional example of a\n mutable sequence type.\n\nSet types\n These represent unordered, finite sets of unique, immutable\n objects. As such, they cannot be indexed by any subscript. However,\n they can be iterated over, and the built-in function "len()"\n returns the number of items in a set. Common uses for sets are fast\n membership testing, removing duplicates from a sequence, and\n computing mathematical operations such as intersection, union,\n difference, and symmetric difference.\n\n For set elements, the same immutability rules apply as for\n dictionary keys. Note that numeric types obey the normal rules for\n numeric comparison: if two numbers compare equal (e.g., "1" and\n "1.0"), only one of them can be contained in a set.\n\n There are currently two intrinsic set types:\n\n Sets\n These represent a mutable set. They are created by the built-in\n "set()" constructor and can be modified afterwards by several\n methods, such as "add()".\n\n Frozen sets\n These represent an immutable set. They are created by the\n built-in "frozenset()" constructor. As a frozenset is immutable\n and *hashable*, it can be used again as an element of another\n set, or as a dictionary key.\n\nMappings\n These represent finite sets of objects indexed by arbitrary index\n sets. The subscript notation "a[k]" selects the item indexed by "k"\n from the mapping "a"; this can be used in expressions and as the\n target of assignments or "del" statements. The built-in function\n "len()" returns the number of items in a mapping.\n\n There is currently a single intrinsic mapping type:\n\n Dictionaries\n These represent finite sets of objects indexed by nearly\n arbitrary values. The only types of values not acceptable as\n keys are values containing lists or dictionaries or other\n mutable types that are compared by value rather than by object\n identity, the reason being that the efficient implementation of\n dictionaries requires a key\'s hash value to remain constant.\n Numeric types used for keys obey the normal rules for numeric\n comparison: if two numbers compare equal (e.g., "1" and "1.0")\n then they can be used interchangeably to index the same\n dictionary entry.\n\n Dictionaries are mutable; they can be created by the "{...}"\n notation (see section Dictionary displays).\n\n The extension modules "dbm", "gdbm", and "bsddb" provide\n additional examples of mapping types.\n\nCallable types\n These are the types to which the function call operation (see\n section Calls) can be applied:\n\n User-defined functions\n A user-defined function object is created by a function\n definition (see section Function definitions). It should be\n called with an argument list containing the same number of items\n as the function\'s formal parameter list.\n\n Special attributes:\n\n +-------------------------+---------------------------------+-------------+\n | Attribute | Meaning | |\n +=========================+=================================+=============+\n | "__doc__" "func_doc" | The function\'s documentation | Writable |\n | | string, or "None" if | |\n | | unavailable. | |\n +-------------------------+---------------------------------+-------------+\n | "__name__" "func_name" | The function\'s name | Writable |\n +-------------------------+---------------------------------+-------------+\n | "__module__" | The name of the module the | Writable |\n | | function was defined in, or | |\n | | "None" if unavailable. | |\n +-------------------------+---------------------------------+-------------+\n | "__defaults__" | A tuple containing default | Writable |\n | "func_defaults" | argument values for those | |\n | | arguments that have defaults, | |\n | | or "None" if no arguments have | |\n | | a default value. | |\n +-------------------------+---------------------------------+-------------+\n | "__code__" "func_code" | The code object representing | Writable |\n | | the compiled function body. | |\n +-------------------------+---------------------------------+-------------+\n | "__globals__" | A reference to the dictionary | Read-only |\n | "func_globals" | that holds the function\'s | |\n | | global variables --- the global | |\n | | namespace of the module in | |\n | | which the function was defined. | |\n +-------------------------+---------------------------------+-------------+\n | "__dict__" "func_dict" | The namespace supporting | Writable |\n | | arbitrary function attributes. | |\n +-------------------------+---------------------------------+-------------+\n | "__closure__" | "None" or a tuple of cells that | Read-only |\n | "func_closure" | contain bindings for the | |\n | | function\'s free variables. | |\n +-------------------------+---------------------------------+-------------+\n\n Most of the attributes labelled "Writable" check the type of the\n assigned value.\n\n Changed in version 2.4: "func_name" is now writable.\n\n Changed in version 2.6: The double-underscore attributes\n "__closure__", "__code__", "__defaults__", and "__globals__"\n were introduced as aliases for the corresponding "func_*"\n attributes for forwards compatibility with Python 3.\n\n Function objects also support getting and setting arbitrary\n attributes, which can be used, for example, to attach metadata\n to functions. Regular attribute dot-notation is used to get and\n set such attributes. *Note that the current implementation only\n supports function attributes on user-defined functions. Function\n attributes on built-in functions may be supported in the\n future.*\n\n Additional information about a function\'s definition can be\n retrieved from its code object; see the description of internal\n types below.\n\n User-defined methods\n A user-defined method object combines a class, a class instance\n (or "None") and any callable object (normally a user-defined\n function).\n\n Special read-only attributes: "im_self" is the class instance\n object, "im_func" is the function object; "im_class" is the\n class of "im_self" for bound methods or the class that asked for\n the method for unbound methods; "__doc__" is the method\'s\n documentation (same as "im_func.__doc__"); "__name__" is the\n method name (same as "im_func.__name__"); "__module__" is the\n name of the module the method was defined in, or "None" if\n unavailable.\n\n Changed in version 2.2: "im_self" used to refer to the class\n that defined the method.\n\n Changed in version 2.6: For Python 3 forward-compatibility,\n "im_func" is also available as "__func__", and "im_self" as\n "__self__".\n\n Methods also support accessing (but not setting) the arbitrary\n function attributes on the underlying function object.\n\n User-defined method objects may be created when getting an\n attribute of a class (perhaps via an instance of that class), if\n that attribute is a user-defined function object, an unbound\n user-defined method object, or a class method object. When the\n attribute is a user-defined method object, a new method object\n is only created if the class from which it is being retrieved is\n the same as, or a derived class of, the class stored in the\n original method object; otherwise, the original method object is\n used as it is.\n\n When a user-defined method object is created by retrieving a\n user-defined function object from a class, its "im_self"\n attribute is "None" and the method object is said to be unbound.\n When one is created by retrieving a user-defined function object\n from a class via one of its instances, its "im_self" attribute\n is the instance, and the method object is said to be bound. In\n either case, the new method\'s "im_class" attribute is the class\n from which the retrieval takes place, and its "im_func"\n attribute is the original function object.\n\n When a user-defined method object is created by retrieving\n another method object from a class or instance, the behaviour is\n the same as for a function object, except that the "im_func"\n attribute of the new instance is not the original method object\n but its "im_func" attribute.\n\n When a user-defined method object is created by retrieving a\n class method object from a class or instance, its "im_self"\n attribute is the class itself, and its "im_func" attribute is\n the function object underlying the class method.\n\n When an unbound user-defined method object is called, the\n underlying function ("im_func") is called, with the restriction\n that the first argument must be an instance of the proper class\n ("im_class") or of a derived class thereof.\n\n When a bound user-defined method object is called, the\n underlying function ("im_func") is called, inserting the class\n instance ("im_self") in front of the argument list. For\n instance, when "C" is a class which contains a definition for a\n function "f()", and "x" is an instance of "C", calling "x.f(1)"\n is equivalent to calling "C.f(x, 1)".\n\n When a user-defined method object is derived from a class method\n object, the "class instance" stored in "im_self" will actually\n be the class itself, so that calling either "x.f(1)" or "C.f(1)"\n is equivalent to calling "f(C,1)" where "f" is the underlying\n function.\n\n Note that the transformation from function object to (unbound or\n bound) method object happens each time the attribute is\n retrieved from the class or instance. In some cases, a fruitful\n optimization is to assign the attribute to a local variable and\n call that local variable. Also notice that this transformation\n only happens for user-defined functions; other callable objects\n (and all non-callable objects) are retrieved without\n transformation. It is also important to note that user-defined\n functions which are attributes of a class instance are not\n converted to bound methods; this *only* happens when the\n function is an attribute of the class.\n\n Generator functions\n A function or method which uses the "yield" statement (see\n section The yield statement) is called a *generator function*.\n Such a function, when called, always returns an iterator object\n which can be used to execute the body of the function: calling\n the iterator\'s "next()" method will cause the function to\n execute until it provides a value using the "yield" statement.\n When the function executes a "return" statement or falls off the\n end, a "StopIteration" exception is raised and the iterator will\n have reached the end of the set of values to be returned.\n\n Built-in functions\n A built-in function object is a wrapper around a C function.\n Examples of built-in functions are "len()" and "math.sin()"\n ("math" is a standard built-in module). The number and type of\n the arguments are determined by the C function. Special read-\n only attributes: "__doc__" is the function\'s documentation\n string, or "None" if unavailable; "__name__" is the function\'s\n name; "__self__" is set to "None" (but see the next item);\n "__module__" is the name of the module the function was defined\n in or "None" if unavailable.\n\n Built-in methods\n This is really a different disguise of a built-in function, this\n time containing an object passed to the C function as an\n implicit extra argument. An example of a built-in method is\n "alist.append()", assuming *alist* is a list object. In this\n case, the special read-only attribute "__self__" is set to the\n object denoted by *alist*.\n\n Class Types\n Class types, or "new-style classes," are callable. These\n objects normally act as factories for new instances of\n themselves, but variations are possible for class types that\n override "__new__()". The arguments of the call are passed to\n "__new__()" and, in the typical case, to "__init__()" to\n initialize the new instance.\n\n Classic Classes\n Class objects are described below. When a class object is\n called, a new class instance (also described below) is created\n and returned. This implies a call to the class\'s "__init__()"\n method if it has one. Any arguments are passed on to the\n "__init__()" method. If there is no "__init__()" method, the\n class must be called without arguments.\n\n Class instances\n Class instances are described below. Class instances are\n callable only when the class has a "__call__()" method;\n "x(arguments)" is a shorthand for "x.__call__(arguments)".\n\nModules\n Modules are imported by the "import" statement (see section The\n import statement). A module object has a namespace implemented by a\n dictionary object (this is the dictionary referenced by the\n func_globals attribute of functions defined in the module).\n Attribute references are translated to lookups in this dictionary,\n e.g., "m.x" is equivalent to "m.__dict__["x"]". A module object\n does not contain the code object used to initialize the module\n (since it isn\'t needed once the initialization is done).\n\n Attribute assignment updates the module\'s namespace dictionary,\n e.g., "m.x = 1" is equivalent to "m.__dict__["x"] = 1".\n\n Special read-only attribute: "__dict__" is the module\'s namespace\n as a dictionary object.\n\n **CPython implementation detail:** Because of the way CPython\n clears module dictionaries, the module dictionary will be cleared\n when the module falls out of scope even if the dictionary still has\n live references. To avoid this, copy the dictionary or keep the\n module around while using its dictionary directly.\n\n Predefined (writable) attributes: "__name__" is the module\'s name;\n "__doc__" is the module\'s documentation string, or "None" if\n unavailable; "__file__" is the pathname of the file from which the\n module was loaded, if it was loaded from a file. The "__file__"\n attribute is not present for C modules that are statically linked\n into the interpreter; for extension modules loaded dynamically from\n a shared library, it is the pathname of the shared library file.\n\nClasses\n Both class types (new-style classes) and class objects (old-\n style/classic classes) are typically created by class definitions\n (see section Class definitions). A class has a namespace\n implemented by a dictionary object. Class attribute references are\n translated to lookups in this dictionary, e.g., "C.x" is translated\n to "C.__dict__["x"]" (although for new-style classes in particular\n there are a number of hooks which allow for other means of locating\n attributes). When the attribute name is not found there, the\n attribute search continues in the base classes. For old-style\n classes, the search is depth-first, left-to-right in the order of\n occurrence in the base class list. New-style classes use the more\n complex C3 method resolution order which behaves correctly even in\n the presence of \'diamond\' inheritance structures where there are\n multiple inheritance paths leading back to a common ancestor.\n Additional details on the C3 MRO used by new-style classes can be\n found in the documentation accompanying the 2.3 release at\n https://www.python.org/download/releases/2.3/mro/.\n\n When a class attribute reference (for class "C", say) would yield a\n user-defined function object or an unbound user-defined method\n object whose associated class is either "C" or one of its base\n classes, it is transformed into an unbound user-defined method\n object whose "im_class" attribute is "C". When it would yield a\n class method object, it is transformed into a bound user-defined\n method object whose "im_self" attribute is "C". When it would\n yield a static method object, it is transformed into the object\n wrapped by the static method object. See section Implementing\n Descriptors for another way in which attributes retrieved from a\n class may differ from those actually contained in its "__dict__"\n (note that only new-style classes support descriptors).\n\n Class attribute assignments update the class\'s dictionary, never\n the dictionary of a base class.\n\n A class object can be called (see above) to yield a class instance\n (see below).\n\n Special attributes: "__name__" is the class name; "__module__" is\n the module name in which the class was defined; "__dict__" is the\n dictionary containing the class\'s namespace; "__bases__" is a tuple\n (possibly empty or a singleton) containing the base classes, in the\n order of their occurrence in the base class list; "__doc__" is the\n class\'s documentation string, or "None" if undefined.\n\nClass instances\n A class instance is created by calling a class object (see above).\n A class instance has a namespace implemented as a dictionary which\n is the first place in which attribute references are searched.\n When an attribute is not found there, and the instance\'s class has\n an attribute by that name, the search continues with the class\n attributes. If a class attribute is found that is a user-defined\n function object or an unbound user-defined method object whose\n associated class is the class (call it "C") of the instance for\n which the attribute reference was initiated or one of its bases, it\n is transformed into a bound user-defined method object whose\n "im_class" attribute is "C" and whose "im_self" attribute is the\n instance. Static method and class method objects are also\n transformed, as if they had been retrieved from class "C"; see\n above under "Classes". See section Implementing Descriptors for\n another way in which attributes of a class retrieved via its\n instances may differ from the objects actually stored in the\n class\'s "__dict__". If no class attribute is found, and the\n object\'s class has a "__getattr__()" method, that is called to\n satisfy the lookup.\n\n Attribute assignments and deletions update the instance\'s\n dictionary, never a class\'s dictionary. If the class has a\n "__setattr__()" or "__delattr__()" method, this is called instead\n of updating the instance dictionary directly.\n\n Class instances can pretend to be numbers, sequences, or mappings\n if they have methods with certain special names. See section\n Special method names.\n\n Special attributes: "__dict__" is the attribute dictionary;\n "__class__" is the instance\'s class.\n\nFiles\n A file object represents an open file. File objects are created by\n the "open()" built-in function, and also by "os.popen()",\n "os.fdopen()", and the "makefile()" method of socket objects (and\n perhaps by other functions or methods provided by extension\n modules). The objects "sys.stdin", "sys.stdout" and "sys.stderr"\n are initialized to file objects corresponding to the interpreter\'s\n standard input, output and error streams. See File Objects for\n complete documentation of file objects.\n\nInternal types\n A few types used internally by the interpreter are exposed to the\n user. Their definitions may change with future versions of the\n interpreter, but they are mentioned here for completeness.\n\n Code objects\n Code objects represent *byte-compiled* executable Python code,\n or *bytecode*. The difference between a code object and a\n function object is that the function object contains an explicit\n reference to the function\'s globals (the module in which it was\n defined), while a code object contains no context; also the\n default argument values are stored in the function object, not\n in the code object (because they represent values calculated at\n run-time). Unlike function objects, code objects are immutable\n and contain no references (directly or indirectly) to mutable\n objects.\n\n Special read-only attributes: "co_name" gives the function name;\n "co_argcount" is the number of positional arguments (including\n arguments with default values); "co_nlocals" is the number of\n local variables used by the function (including arguments);\n "co_varnames" is a tuple containing the names of the local\n variables (starting with the argument names); "co_cellvars" is a\n tuple containing the names of local variables that are\n referenced by nested functions; "co_freevars" is a tuple\n containing the names of free variables; "co_code" is a string\n representing the sequence of bytecode instructions; "co_consts"\n is a tuple containing the literals used by the bytecode;\n "co_names" is a tuple containing the names used by the bytecode;\n "co_filename" is the filename from which the code was compiled;\n "co_firstlineno" is the first line number of the function;\n "co_lnotab" is a string encoding the mapping from bytecode\n offsets to line numbers (for details see the source code of the\n interpreter); "co_stacksize" is the required stack size\n (including local variables); "co_flags" is an integer encoding a\n number of flags for the interpreter.\n\n The following flag bits are defined for "co_flags": bit "0x04"\n is set if the function uses the "*arguments" syntax to accept an\n arbitrary number of positional arguments; bit "0x08" is set if\n the function uses the "**keywords" syntax to accept arbitrary\n keyword arguments; bit "0x20" is set if the function is a\n generator.\n\n Future feature declarations ("from __future__ import division")\n also use bits in "co_flags" to indicate whether a code object\n was compiled with a particular feature enabled: bit "0x2000" is\n set if the function was compiled with future division enabled;\n bits "0x10" and "0x1000" were used in earlier versions of\n Python.\n\n Other bits in "co_flags" are reserved for internal use.\n\n If a code object represents a function, the first item in\n "co_consts" is the documentation string of the function, or\n "None" if undefined.\n\n Frame objects\n Frame objects represent execution frames. They may occur in\n traceback objects (see below).\n\n Special read-only attributes: "f_back" is to the previous stack\n frame (towards the caller), or "None" if this is the bottom\n stack frame; "f_code" is the code object being executed in this\n frame; "f_locals" is the dictionary used to look up local\n variables; "f_globals" is used for global variables;\n "f_builtins" is used for built-in (intrinsic) names;\n "f_restricted" is a flag indicating whether the function is\n executing in restricted execution mode; "f_lasti" gives the\n precise instruction (this is an index into the bytecode string\n of the code object).\n\n Special writable attributes: "f_trace", if not "None", is a\n function called at the start of each source code line (this is\n used by the debugger); "f_exc_type", "f_exc_value",\n "f_exc_traceback" represent the last exception raised in the\n parent frame provided another exception was ever raised in the\n current frame (in all other cases they are "None"); "f_lineno"\n is the current line number of the frame --- writing to this from\n within a trace function jumps to the given line (only for the\n bottom-most frame). A debugger can implement a Jump command\n (aka Set Next Statement) by writing to f_lineno.\n\n Traceback objects\n Traceback objects represent a stack trace of an exception. A\n traceback object is created when an exception occurs. When the\n search for an exception handler unwinds the execution stack, at\n each unwound level a traceback object is inserted in front of\n the current traceback. When an exception handler is entered,\n the stack trace is made available to the program. (See section\n The try statement.) It is accessible as "sys.exc_traceback", and\n also as the third item of the tuple returned by\n "sys.exc_info()". The latter is the preferred interface, since\n it works correctly when the program is using multiple threads.\n When the program contains no suitable handler, the stack trace\n is written (nicely formatted) to the standard error stream; if\n the interpreter is interactive, it is also made available to the\n user as "sys.last_traceback".\n\n Special read-only attributes: "tb_next" is the next level in the\n stack trace (towards the frame where the exception occurred), or\n "None" if there is no next level; "tb_frame" points to the\n execution frame of the current level; "tb_lineno" gives the line\n number where the exception occurred; "tb_lasti" indicates the\n precise instruction. The line number and last instruction in\n the traceback may differ from the line number of its frame\n object if the exception occurred in a "try" statement with no\n matching except clause or with a finally clause.\n\n Slice objects\n Slice objects are used to represent slices when *extended slice\n syntax* is used. This is a slice using two colons, or multiple\n slices or ellipses separated by commas, e.g., "a[i:j:step]",\n "a[i:j, k:l]", or "a[..., i:j]". They are also created by the\n built-in "slice()" function.\n\n Special read-only attributes: "start" is the lower bound; "stop"\n is the upper bound; "step" is the step value; each is "None" if\n omitted. These attributes can have any type.\n\n Slice objects support one method:\n\n slice.indices(self, length)\n\n This method takes a single integer argument *length* and\n computes information about the extended slice that the slice\n object would describe if applied to a sequence of *length*\n items. It returns a tuple of three integers; respectively\n these are the *start* and *stop* indices and the *step* or\n stride length of the slice. Missing or out-of-bounds indices\n are handled in a manner consistent with regular slices.\n\n New in version 2.3.\n\n Static method objects\n Static method objects provide a way of defeating the\n transformation of function objects to method objects described\n above. A static method object is a wrapper around any other\n object, usually a user-defined method object. When a static\n method object is retrieved from a class or a class instance, the\n object actually returned is the wrapped object, which is not\n subject to any further transformation. Static method objects are\n not themselves callable, although the objects they wrap usually\n are. Static method objects are created by the built-in\n "staticmethod()" constructor.\n\n Class method objects\n A class method object, like a static method object, is a wrapper\n around another object that alters the way in which that object\n is retrieved from classes and class instances. The behaviour of\n class method objects upon such retrieval is described above,\n under "User-defined methods". Class method objects are created\n by the built-in "classmethod()" constructor.\n',
- 'typesfunctions': u'\nFunctions\n*********\n\nFunction objects are created by function definitions. The only\noperation on a function object is to call it: "func(argument-list)".\n\nThere are really two flavors of function objects: built-in functions\nand user-defined functions. Both support the same operation (to call\nthe function), but the implementation is different, hence the\ndifferent object types.\n\nSee Function definitions for more information.\n',
- 'typesmapping': u'\nMapping Types --- "dict"\n************************\n\nA *mapping* object maps *hashable* values to arbitrary objects.\nMappings are mutable objects. There is currently only one standard\nmapping type, the *dictionary*. (For other containers see the built\nin "list", "set", and "tuple" classes, and the "collections" module.)\n\nA dictionary\'s keys are *almost* arbitrary values. Values that are\nnot *hashable*, that is, values containing lists, dictionaries or\nother mutable types (that are compared by value rather than by object\nidentity) may not be used as keys. Numeric types used for keys obey\nthe normal rules for numeric comparison: if two numbers compare equal\n(such as "1" and "1.0") then they can be used interchangeably to index\nthe same dictionary entry. (Note however, that since computers store\nfloating-point numbers as approximations it is usually unwise to use\nthem as dictionary keys.)\n\nDictionaries can be created by placing a comma-separated list of "key:\nvalue" pairs within braces, for example: "{\'jack\': 4098, \'sjoerd\':\n4127}" or "{4098: \'jack\', 4127: \'sjoerd\'}", or by the "dict"\nconstructor.\n\nclass dict(**kwarg)\nclass dict(mapping, **kwarg)\nclass dict(iterable, **kwarg)\n\n Return a new dictionary initialized from an optional positional\n argument and a possibly empty set of keyword arguments.\n\n If no positional argument is given, an empty dictionary is created.\n If a positional argument is given and it is a mapping object, a\n dictionary is created with the same key-value pairs as the mapping\n object. Otherwise, the positional argument must be an *iterable*\n object. Each item in the iterable must itself be an iterable with\n exactly two objects. The first object of each item becomes a key\n in the new dictionary, and the second object the corresponding\n value. If a key occurs more than once, the last value for that key\n becomes the corresponding value in the new dictionary.\n\n If keyword arguments are given, the keyword arguments and their\n values are added to the dictionary created from the positional\n argument. If a key being added is already present, the value from\n the keyword argument replaces the value from the positional\n argument.\n\n To illustrate, the following examples all return a dictionary equal\n to "{"one": 1, "two": 2, "three": 3}":\n\n >>> a = dict(one=1, two=2, three=3)\n >>> b = {\'one\': 1, \'two\': 2, \'three\': 3}\n >>> c = dict(zip([\'one\', \'two\', \'three\'], [1, 2, 3]))\n >>> d = dict([(\'two\', 2), (\'one\', 1), (\'three\', 3)])\n >>> e = dict({\'three\': 3, \'one\': 1, \'two\': 2})\n >>> a == b == c == d == e\n True\n\n Providing keyword arguments as in the first example only works for\n keys that are valid Python identifiers. Otherwise, any valid keys\n can be used.\n\n New in version 2.2.\n\n Changed in version 2.3: Support for building a dictionary from\n keyword arguments added.\n\n These are the operations that dictionaries support (and therefore,\n custom mapping types should support too):\n\n len(d)\n\n Return the number of items in the dictionary *d*.\n\n d[key]\n\n Return the item of *d* with key *key*. Raises a "KeyError" if\n *key* is not in the map.\n\n If a subclass of dict defines a method "__missing__()" and *key*\n is not present, the "d[key]" operation calls that method with\n the key *key* as argument. The "d[key]" operation then returns\n or raises whatever is returned or raised by the\n "__missing__(key)" call. No other operations or methods invoke\n "__missing__()". If "__missing__()" is not defined, "KeyError"\n is raised. "__missing__()" must be a method; it cannot be an\n instance variable:\n\n >>> class Counter(dict):\n ... def __missing__(self, key):\n ... return 0\n >>> c = Counter()\n >>> c[\'red\']\n 0\n >>> c[\'red\'] += 1\n >>> c[\'red\']\n 1\n\n The example above shows part of the implementation of\n "collections.Counter". A different "__missing__" method is used\n by "collections.defaultdict".\n\n New in version 2.5: Recognition of __missing__ methods of dict\n subclasses.\n\n d[key] = value\n\n Set "d[key]" to *value*.\n\n del d[key]\n\n Remove "d[key]" from *d*. Raises a "KeyError" if *key* is not\n in the map.\n\n key in d\n\n Return "True" if *d* has a key *key*, else "False".\n\n New in version 2.2.\n\n key not in d\n\n Equivalent to "not key in d".\n\n New in version 2.2.\n\n iter(d)\n\n Return an iterator over the keys of the dictionary. This is a\n shortcut for "iterkeys()".\n\n clear()\n\n Remove all items from the dictionary.\n\n copy()\n\n Return a shallow copy of the dictionary.\n\n fromkeys(seq[, value])\n\n Create a new dictionary with keys from *seq* and values set to\n *value*.\n\n "fromkeys()" is a class method that returns a new dictionary.\n *value* defaults to "None".\n\n New in version 2.3.\n\n get(key[, default])\n\n Return the value for *key* if *key* is in the dictionary, else\n *default*. If *default* is not given, it defaults to "None", so\n that this method never raises a "KeyError".\n\n has_key(key)\n\n Test for the presence of *key* in the dictionary. "has_key()"\n is deprecated in favor of "key in d".\n\n items()\n\n Return a copy of the dictionary\'s list of "(key, value)" pairs.\n\n **CPython implementation detail:** Keys and values are listed in\n an arbitrary order which is non-random, varies across Python\n implementations, and depends on the dictionary\'s history of\n insertions and deletions.\n\n If "items()", "keys()", "values()", "iteritems()", "iterkeys()",\n and "itervalues()" are called with no intervening modifications\n to the dictionary, the lists will directly correspond. This\n allows the creation of "(value, key)" pairs using "zip()":\n "pairs = zip(d.values(), d.keys())". The same relationship\n holds for the "iterkeys()" and "itervalues()" methods: "pairs =\n zip(d.itervalues(), d.iterkeys())" provides the same value for\n "pairs". Another way to create the same list is "pairs = [(v, k)\n for (k, v) in d.iteritems()]".\n\n iteritems()\n\n Return an iterator over the dictionary\'s "(key, value)" pairs.\n See the note for "dict.items()".\n\n Using "iteritems()" while adding or deleting entries in the\n dictionary may raise a "RuntimeError" or fail to iterate over\n all entries.\n\n New in version 2.2.\n\n iterkeys()\n\n Return an iterator over the dictionary\'s keys. See the note for\n "dict.items()".\n\n Using "iterkeys()" while adding or deleting entries in the\n dictionary may raise a "RuntimeError" or fail to iterate over\n all entries.\n\n New in version 2.2.\n\n itervalues()\n\n Return an iterator over the dictionary\'s values. See the note\n for "dict.items()".\n\n Using "itervalues()" while adding or deleting entries in the\n dictionary may raise a "RuntimeError" or fail to iterate over\n all entries.\n\n New in version 2.2.\n\n keys()\n\n Return a copy of the dictionary\'s list of keys. See the note\n for "dict.items()".\n\n pop(key[, default])\n\n If *key* is in the dictionary, remove it and return its value,\n else return *default*. If *default* is not given and *key* is\n not in the dictionary, a "KeyError" is raised.\n\n New in version 2.3.\n\n popitem()\n\n Remove and return an arbitrary "(key, value)" pair from the\n dictionary.\n\n "popitem()" is useful to destructively iterate over a\n dictionary, as often used in set algorithms. If the dictionary\n is empty, calling "popitem()" raises a "KeyError".\n\n setdefault(key[, default])\n\n If *key* is in the dictionary, return its value. If not, insert\n *key* with a value of *default* and return *default*. *default*\n defaults to "None".\n\n update([other])\n\n Update the dictionary with the key/value pairs from *other*,\n overwriting existing keys. Return "None".\n\n "update()" accepts either another dictionary object or an\n iterable of key/value pairs (as tuples or other iterables of\n length two). If keyword arguments are specified, the dictionary\n is then updated with those key/value pairs: "d.update(red=1,\n blue=2)".\n\n Changed in version 2.4: Allowed the argument to be an iterable\n of key/value pairs and allowed keyword arguments.\n\n values()\n\n Return a copy of the dictionary\'s list of values. See the note\n for "dict.items()".\n\n viewitems()\n\n Return a new view of the dictionary\'s items ("(key, value)"\n pairs). See below for documentation of view objects.\n\n New in version 2.7.\n\n viewkeys()\n\n Return a new view of the dictionary\'s keys. See below for\n documentation of view objects.\n\n New in version 2.7.\n\n viewvalues()\n\n Return a new view of the dictionary\'s values. See below for\n documentation of view objects.\n\n New in version 2.7.\n\n Dictionaries compare equal if and only if they have the same "(key,\n value)" pairs.\n\n\nDictionary view objects\n=======================\n\nThe objects returned by "dict.viewkeys()", "dict.viewvalues()" and\n"dict.viewitems()" are *view objects*. They provide a dynamic view on\nthe dictionary\'s entries, which means that when the dictionary\nchanges, the view reflects these changes.\n\nDictionary views can be iterated over to yield their respective data,\nand support membership tests:\n\nlen(dictview)\n\n Return the number of entries in the dictionary.\n\niter(dictview)\n\n Return an iterator over the keys, values or items (represented as\n tuples of "(key, value)") in the dictionary.\n\n Keys and values are iterated over in an arbitrary order which is\n non-random, varies across Python implementations, and depends on\n the dictionary\'s history of insertions and deletions. If keys,\n values and items views are iterated over with no intervening\n modifications to the dictionary, the order of items will directly\n correspond. This allows the creation of "(value, key)" pairs using\n "zip()": "pairs = zip(d.values(), d.keys())". Another way to\n create the same list is "pairs = [(v, k) for (k, v) in d.items()]".\n\n Iterating views while adding or deleting entries in the dictionary\n may raise a "RuntimeError" or fail to iterate over all entries.\n\nx in dictview\n\n Return "True" if *x* is in the underlying dictionary\'s keys, values\n or items (in the latter case, *x* should be a "(key, value)"\n tuple).\n\nKeys views are set-like since their entries are unique and hashable.\nIf all values are hashable, so that (key, value) pairs are unique and\nhashable, then the items view is also set-like. (Values views are not\ntreated as set-like since the entries are generally not unique.) Then\nthese set operations are available ("other" refers either to another\nview or a set):\n\ndictview & other\n\n Return the intersection of the dictview and the other object as a\n new set.\n\ndictview | other\n\n Return the union of the dictview and the other object as a new set.\n\ndictview - other\n\n Return the difference between the dictview and the other object\n (all elements in *dictview* that aren\'t in *other*) as a new set.\n\ndictview ^ other\n\n Return the symmetric difference (all elements either in *dictview*\n or *other*, but not in both) of the dictview and the other object\n as a new set.\n\nAn example of dictionary view usage:\n\n >>> dishes = {\'eggs\': 2, \'sausage\': 1, \'bacon\': 1, \'spam\': 500}\n >>> keys = dishes.viewkeys()\n >>> values = dishes.viewvalues()\n\n >>> # iteration\n >>> n = 0\n >>> for val in values:\n ... n += val\n >>> print(n)\n 504\n\n >>> # keys and values are iterated over in the same order\n >>> list(keys)\n [\'eggs\', \'bacon\', \'sausage\', \'spam\']\n >>> list(values)\n [2, 1, 1, 500]\n\n >>> # view objects are dynamic and reflect dict changes\n >>> del dishes[\'eggs\']\n >>> del dishes[\'sausage\']\n >>> list(keys)\n [\'spam\', \'bacon\']\n\n >>> # set operations\n >>> keys & {\'eggs\', \'bacon\', \'salad\'}\n {\'bacon\'}\n',
- 'typesmethods': u'\nMethods\n*******\n\nMethods are functions that are called using the attribute notation.\nThere are two flavors: built-in methods (such as "append()" on lists)\nand class instance methods. Built-in methods are described with the\ntypes that support them.\n\nThe implementation adds two special read-only attributes to class\ninstance methods: "m.im_self" is the object on which the method\noperates, and "m.im_func" is the function implementing the method.\nCalling "m(arg-1, arg-2, ..., arg-n)" is completely equivalent to\ncalling "m.im_func(m.im_self, arg-1, arg-2, ..., arg-n)".\n\nClass instance methods are either *bound* or *unbound*, referring to\nwhether the method was accessed through an instance or a class,\nrespectively. When a method is unbound, its "im_self" attribute will\nbe "None" and if called, an explicit "self" object must be passed as\nthe first argument. In this case, "self" must be an instance of the\nunbound method\'s class (or a subclass of that class), otherwise a\n"TypeError" is raised.\n\nLike function objects, methods objects support getting arbitrary\nattributes. However, since method attributes are actually stored on\nthe underlying function object ("meth.im_func"), setting method\nattributes on either bound or unbound methods is disallowed.\nAttempting to set an attribute on a method results in an\n"AttributeError" being raised. In order to set a method attribute,\nyou need to explicitly set it on the underlying function object:\n\n >>> class C:\n ... def method(self):\n ... pass\n ...\n >>> c = C()\n >>> c.method.whoami = \'my name is method\' # can\'t set on the method\n Traceback (most recent call last):\n File "<stdin>", line 1, in <module>\n AttributeError: \'instancemethod\' object has no attribute \'whoami\'\n >>> c.method.im_func.whoami = \'my name is method\'\n >>> c.method.whoami\n \'my name is method\'\n\nSee The standard type hierarchy for more information.\n',
- 'typesmodules': u'\nModules\n*******\n\nThe only special operation on a module is attribute access: "m.name",\nwhere *m* is a module and *name* accesses a name defined in *m*\'s\nsymbol table. Module attributes can be assigned to. (Note that the\n"import" statement is not, strictly speaking, an operation on a module\nobject; "import foo" does not require a module object named *foo* to\nexist, rather it requires an (external) *definition* for a module\nnamed *foo* somewhere.)\n\nA special attribute of every module is "__dict__". This is the\ndictionary containing the module\'s symbol table. Modifying this\ndictionary will actually change the module\'s symbol table, but direct\nassignment to the "__dict__" attribute is not possible (you can write\n"m.__dict__[\'a\'] = 1", which defines "m.a" to be "1", but you can\'t\nwrite "m.__dict__ = {}"). Modifying "__dict__" directly is not\nrecommended.\n\nModules built into the interpreter are written like this: "<module\n\'sys\' (built-in)>". If loaded from a file, they are written as\n"<module \'os\' from \'/usr/local/lib/pythonX.Y/os.pyc\'>".\n',
- 'typesseq': u'\nSequence Types --- "str", "unicode", "list", "tuple", "bytearray", "buffer", "xrange"\n*************************************************************************************\n\nThere are seven sequence types: strings, Unicode strings, lists,\ntuples, bytearrays, buffers, and xrange objects.\n\nFor other containers see the built in "dict" and "set" classes, and\nthe "collections" module.\n\nString literals are written in single or double quotes: "\'xyzzy\'",\n""frobozz"". See String literals for more about string literals.\nUnicode strings are much like strings, but are specified in the syntax\nusing a preceding "\'u\'" character: "u\'abc\'", "u"def"". In addition to\nthe functionality described here, there are also string-specific\nmethods described in the String Methods section. Lists are constructed\nwith square brackets, separating items with commas: "[a, b, c]".\nTuples are constructed by the comma operator (not within square\nbrackets), with or without enclosing parentheses, but an empty tuple\nmust have the enclosing parentheses, such as "a, b, c" or "()". A\nsingle item tuple must have a trailing comma, such as "(d,)".\n\nBytearray objects are created with the built-in function\n"bytearray()".\n\nBuffer objects are not directly supported by Python syntax, but can be\ncreated by calling the built-in function "buffer()". They don\'t\nsupport concatenation or repetition.\n\nObjects of type xrange are similar to buffers in that there is no\nspecific syntax to create them, but they are created using the\n"xrange()" function. They don\'t support slicing, concatenation or\nrepetition, and using "in", "not in", "min()" or "max()" on them is\ninefficient.\n\nMost sequence types support the following operations. The "in" and\n"not in" operations have the same priorities as the comparison\noperations. The "+" and "*" operations have the same priority as the\ncorresponding numeric operations. [3] Additional methods are provided\nfor Mutable Sequence Types.\n\nThis table lists the sequence operations sorted in ascending priority.\nIn the table, *s* and *t* are sequences of the same type; *n*, *i* and\n*j* are integers:\n\n+--------------------+----------------------------------+------------+\n| Operation | Result | Notes |\n+====================+==================================+============+\n| "x in s" | "True" if an item of *s* is | (1) |\n| | equal to *x*, else "False" | |\n+--------------------+----------------------------------+------------+\n| "x not in s" | "False" if an item of *s* is | (1) |\n| | equal to *x*, else "True" | |\n+--------------------+----------------------------------+------------+\n| "s + t" | the concatenation of *s* and *t* | (6) |\n+--------------------+----------------------------------+------------+\n| "s * n, n * s" | equivalent to adding *s* to | (2) |\n| | itself *n* times | |\n+--------------------+----------------------------------+------------+\n| "s[i]" | *i*th item of *s*, origin 0 | (3) |\n+--------------------+----------------------------------+------------+\n| "s[i:j]" | slice of *s* from *i* to *j* | (3)(4) |\n+--------------------+----------------------------------+------------+\n| "s[i:j:k]" | slice of *s* from *i* to *j* | (3)(5) |\n| | with step *k* | |\n+--------------------+----------------------------------+------------+\n| "len(s)" | length of *s* | |\n+--------------------+----------------------------------+------------+\n| "min(s)" | smallest item of *s* | |\n+--------------------+----------------------------------+------------+\n| "max(s)" | largest item of *s* | |\n+--------------------+----------------------------------+------------+\n| "s.index(x)" | index of the first occurrence of | |\n| | *x* in *s* | |\n+--------------------+----------------------------------+------------+\n| "s.count(x)" | total number of occurrences of | |\n| | *x* in *s* | |\n+--------------------+----------------------------------+------------+\n\nSequence types also support comparisons. In particular, tuples and\nlists are compared lexicographically by comparing corresponding\nelements. This means that to compare equal, every element must compare\nequal and the two sequences must be of the same type and have the same\nlength. (For full details see Comparisons in the language reference.)\n\nNotes:\n\n1. When *s* is a string or Unicode string object the "in" and "not\n in" operations act like a substring test. In Python versions\n before 2.3, *x* had to be a string of length 1. In Python 2.3 and\n beyond, *x* may be a string of any length.\n\n2. Values of *n* less than "0" are treated as "0" (which yields an\n empty sequence of the same type as *s*). Note that items in the\n sequence *s* are not copied; they are referenced multiple times.\n This often haunts new Python programmers; consider:\n\n >>> lists = [[]] * 3\n >>> lists\n [[], [], []]\n >>> lists[0].append(3)\n >>> lists\n [[3], [3], [3]]\n\n What has happened is that "[[]]" is a one-element list containing\n an empty list, so all three elements of "[[]] * 3" are references\n to this single empty list. Modifying any of the elements of\n "lists" modifies this single list. You can create a list of\n different lists this way:\n\n >>> lists = [[] for i in range(3)]\n >>> lists[0].append(3)\n >>> lists[1].append(5)\n >>> lists[2].append(7)\n >>> lists\n [[3], [5], [7]]\n\n Further explanation is available in the FAQ entry How do I create a\n multidimensional list?.\n\n3. If *i* or *j* is negative, the index is relative to the end of\n the string: "len(s) + i" or "len(s) + j" is substituted. But note\n that "-0" is still "0".\n\n4. The slice of *s* from *i* to *j* is defined as the sequence of\n items with index *k* such that "i <= k < j". If *i* or *j* is\n greater than "len(s)", use "len(s)". If *i* is omitted or "None",\n use "0". If *j* is omitted or "None", use "len(s)". If *i* is\n greater than or equal to *j*, the slice is empty.\n\n5. The slice of *s* from *i* to *j* with step *k* is defined as the\n sequence of items with index "x = i + n*k" such that "0 <= n <\n (j-i)/k". In other words, the indices are "i", "i+k", "i+2*k",\n "i+3*k" and so on, stopping when *j* is reached (but never\n including *j*). If *i* or *j* is greater than "len(s)", use\n "len(s)". If *i* or *j* are omitted or "None", they become "end"\n values (which end depends on the sign of *k*). Note, *k* cannot be\n zero. If *k* is "None", it is treated like "1".\n\n6. **CPython implementation detail:** If *s* and *t* are both\n strings, some Python implementations such as CPython can usually\n perform an in-place optimization for assignments of the form "s = s\n + t" or "s += t". When applicable, this optimization makes\n quadratic run-time much less likely. This optimization is both\n version and implementation dependent. For performance sensitive\n code, it is preferable to use the "str.join()" method which assures\n consistent linear concatenation performance across versions and\n implementations.\n\n Changed in version 2.4: Formerly, string concatenation never\n occurred in-place.\n\n\nString Methods\n==============\n\nBelow are listed the string methods which both 8-bit strings and\nUnicode objects support. Some of them are also available on\n"bytearray" objects.\n\nIn addition, Python\'s strings support the sequence type methods\ndescribed in the Sequence Types --- str, unicode, list, tuple,\nbytearray, buffer, xrange section. To output formatted strings use\ntemplate strings or the "%" operator described in the String\nFormatting Operations section. Also, see the "re" module for string\nfunctions based on regular expressions.\n\nstr.capitalize()\n\n Return a copy of the string with its first character capitalized\n and the rest lowercased.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.center(width[, fillchar])\n\n Return centered in a string of length *width*. Padding is done\n using the specified *fillchar* (default is a space).\n\n Changed in version 2.4: Support for the *fillchar* argument.\n\nstr.count(sub[, start[, end]])\n\n Return the number of non-overlapping occurrences of substring *sub*\n in the range [*start*, *end*]. Optional arguments *start* and\n *end* are interpreted as in slice notation.\n\nstr.decode([encoding[, errors]])\n\n Decodes the string using the codec registered for *encoding*.\n *encoding* defaults to the default string encoding. *errors* may\n be given to set a different error handling scheme. The default is\n "\'strict\'", meaning that encoding errors raise "UnicodeError".\n Other possible values are "\'ignore\'", "\'replace\'" and any other\n name registered via "codecs.register_error()", see section Codec\n Base Classes.\n\n New in version 2.2.\n\n Changed in version 2.3: Support for other error handling schemes\n added.\n\n Changed in version 2.7: Support for keyword arguments added.\n\nstr.encode([encoding[, errors]])\n\n Return an encoded version of the string. Default encoding is the\n current default string encoding. *errors* may be given to set a\n different error handling scheme. The default for *errors* is\n "\'strict\'", meaning that encoding errors raise a "UnicodeError".\n Other possible values are "\'ignore\'", "\'replace\'",\n "\'xmlcharrefreplace\'", "\'backslashreplace\'" and any other name\n registered via "codecs.register_error()", see section Codec Base\n Classes. For a list of possible encodings, see section Standard\n Encodings.\n\n New in version 2.0.\n\n Changed in version 2.3: Support for "\'xmlcharrefreplace\'" and\n "\'backslashreplace\'" and other error handling schemes added.\n\n Changed in version 2.7: Support for keyword arguments added.\n\nstr.endswith(suffix[, start[, end]])\n\n Return "True" if the string ends with the specified *suffix*,\n otherwise return "False". *suffix* can also be a tuple of suffixes\n to look for. With optional *start*, test beginning at that\n position. With optional *end*, stop comparing at that position.\n\n Changed in version 2.5: Accept tuples as *suffix*.\n\nstr.expandtabs([tabsize])\n\n Return a copy of the string where all tab characters are replaced\n by one or more spaces, depending on the current column and the\n given tab size. Tab positions occur every *tabsize* characters\n (default is 8, giving tab positions at columns 0, 8, 16 and so on).\n To expand the string, the current column is set to zero and the\n string is examined character by character. If the character is a\n tab ("\\t"), one or more space characters are inserted in the result\n until the current column is equal to the next tab position. (The\n tab character itself is not copied.) If the character is a newline\n ("\\n") or return ("\\r"), it is copied and the current column is\n reset to zero. Any other character is copied unchanged and the\n current column is incremented by one regardless of how the\n character is represented when printed.\n\n >>> \'01\\t012\\t0123\\t01234\'.expandtabs()\n \'01 012 0123 01234\'\n >>> \'01\\t012\\t0123\\t01234\'.expandtabs(4)\n \'01 012 0123 01234\'\n\nstr.find(sub[, start[, end]])\n\n Return the lowest index in the string where substring *sub* is\n found within the slice "s[start:end]". Optional arguments *start*\n and *end* are interpreted as in slice notation. Return "-1" if\n *sub* is not found.\n\n Note: The "find()" method should be used only if you need to know\n the position of *sub*. To check if *sub* is a substring or not,\n use the "in" operator:\n\n >>> \'Py\' in \'Python\'\n True\n\nstr.format(*args, **kwargs)\n\n Perform a string formatting operation. The string on which this\n method is called can contain literal text or replacement fields\n delimited by braces "{}". Each replacement field contains either\n the numeric index of a positional argument, or the name of a\n keyword argument. Returns a copy of the string where each\n replacement field is replaced with the string value of the\n corresponding argument.\n\n >>> "The sum of 1 + 2 is {0}".format(1+2)\n \'The sum of 1 + 2 is 3\'\n\n See Format String Syntax for a description of the various\n formatting options that can be specified in format strings.\n\n This method of string formatting is the new standard in Python 3,\n and should be preferred to the "%" formatting described in String\n Formatting Operations in new code.\n\n New in version 2.6.\n\nstr.index(sub[, start[, end]])\n\n Like "find()", but raise "ValueError" when the substring is not\n found.\n\nstr.isalnum()\n\n Return true if all characters in the string are alphanumeric and\n there is at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isalpha()\n\n Return true if all characters in the string are alphabetic and\n there is at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isdigit()\n\n Return true if all characters in the string are digits and there is\n at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.islower()\n\n Return true if all cased characters [4] in the string are lowercase\n and there is at least one cased character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isspace()\n\n Return true if there are only whitespace characters in the string\n and there is at least one character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.istitle()\n\n Return true if the string is a titlecased string and there is at\n least one character, for example uppercase characters may only\n follow uncased characters and lowercase characters only cased ones.\n Return false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.isupper()\n\n Return true if all cased characters [4] in the string are uppercase\n and there is at least one cased character, false otherwise.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.join(iterable)\n\n Return a string which is the concatenation of the strings in the\n *iterable* *iterable*. The separator between elements is the\n string providing this method.\n\nstr.ljust(width[, fillchar])\n\n Return the string left justified in a string of length *width*.\n Padding is done using the specified *fillchar* (default is a\n space). The original string is returned if *width* is less than or\n equal to "len(s)".\n\n Changed in version 2.4: Support for the *fillchar* argument.\n\nstr.lower()\n\n Return a copy of the string with all the cased characters [4]\n converted to lowercase.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.lstrip([chars])\n\n Return a copy of the string with leading characters removed. The\n *chars* argument is a string specifying the set of characters to be\n removed. If omitted or "None", the *chars* argument defaults to\n removing whitespace. The *chars* argument is not a prefix; rather,\n all combinations of its values are stripped:\n\n >>> \' spacious \'.lstrip()\n \'spacious \'\n >>> \'www.example.com\'.lstrip(\'cmowz.\')\n \'example.com\'\n\n Changed in version 2.2.2: Support for the *chars* argument.\n\nstr.partition(sep)\n\n Split the string at the first occurrence of *sep*, and return a\n 3-tuple containing the part before the separator, the separator\n itself, and the part after the separator. If the separator is not\n found, return a 3-tuple containing the string itself, followed by\n two empty strings.\n\n New in version 2.5.\n\nstr.replace(old, new[, count])\n\n Return a copy of the string with all occurrences of substring *old*\n replaced by *new*. If the optional argument *count* is given, only\n the first *count* occurrences are replaced.\n\nstr.rfind(sub[, start[, end]])\n\n Return the highest index in the string where substring *sub* is\n found, such that *sub* is contained within "s[start:end]".\n Optional arguments *start* and *end* are interpreted as in slice\n notation. Return "-1" on failure.\n\nstr.rindex(sub[, start[, end]])\n\n Like "rfind()" but raises "ValueError" when the substring *sub* is\n not found.\n\nstr.rjust(width[, fillchar])\n\n Return the string right justified in a string of length *width*.\n Padding is done using the specified *fillchar* (default is a\n space). The original string is returned if *width* is less than or\n equal to "len(s)".\n\n Changed in version 2.4: Support for the *fillchar* argument.\n\nstr.rpartition(sep)\n\n Split the string at the last occurrence of *sep*, and return a\n 3-tuple containing the part before the separator, the separator\n itself, and the part after the separator. If the separator is not\n found, return a 3-tuple containing two empty strings, followed by\n the string itself.\n\n New in version 2.5.\n\nstr.rsplit([sep[, maxsplit]])\n\n Return a list of the words in the string, using *sep* as the\n delimiter string. If *maxsplit* is given, at most *maxsplit* splits\n are done, the *rightmost* ones. If *sep* is not specified or\n "None", any whitespace string is a separator. Except for splitting\n from the right, "rsplit()" behaves like "split()" which is\n described in detail below.\n\n New in version 2.4.\n\nstr.rstrip([chars])\n\n Return a copy of the string with trailing characters removed. The\n *chars* argument is a string specifying the set of characters to be\n removed. If omitted or "None", the *chars* argument defaults to\n removing whitespace. The *chars* argument is not a suffix; rather,\n all combinations of its values are stripped:\n\n >>> \' spacious \'.rstrip()\n \' spacious\'\n >>> \'mississippi\'.rstrip(\'ipz\')\n \'mississ\'\n\n Changed in version 2.2.2: Support for the *chars* argument.\n\nstr.split([sep[, maxsplit]])\n\n Return a list of the words in the string, using *sep* as the\n delimiter string. If *maxsplit* is given, at most *maxsplit*\n splits are done (thus, the list will have at most "maxsplit+1"\n elements). If *maxsplit* is not specified or "-1", then there is\n no limit on the number of splits (all possible splits are made).\n\n If *sep* is given, consecutive delimiters are not grouped together\n and are deemed to delimit empty strings (for example,\n "\'1,,2\'.split(\',\')" returns "[\'1\', \'\', \'2\']"). The *sep* argument\n may consist of multiple characters (for example,\n "\'1<>2<>3\'.split(\'<>\')" returns "[\'1\', \'2\', \'3\']"). Splitting an\n empty string with a specified separator returns "[\'\']".\n\n If *sep* is not specified or is "None", a different splitting\n algorithm is applied: runs of consecutive whitespace are regarded\n as a single separator, and the result will contain no empty strings\n at the start or end if the string has leading or trailing\n whitespace. Consequently, splitting an empty string or a string\n consisting of just whitespace with a "None" separator returns "[]".\n\n For example, "\' 1 2 3 \'.split()" returns "[\'1\', \'2\', \'3\']", and\n "\' 1 2 3 \'.split(None, 1)" returns "[\'1\', \'2 3 \']".\n\nstr.splitlines([keepends])\n\n Return a list of the lines in the string, breaking at line\n boundaries. This method uses the *universal newlines* approach to\n splitting lines. Line breaks are not included in the resulting list\n unless *keepends* is given and true.\n\n Python recognizes ""\\r"", ""\\n"", and ""\\r\\n"" as line boundaries\n for 8-bit strings.\n\n For example:\n\n >>> \'ab c\\n\\nde fg\\rkl\\r\\n\'.splitlines()\n [\'ab c\', \'\', \'de fg\', \'kl\']\n >>> \'ab c\\n\\nde fg\\rkl\\r\\n\'.splitlines(True)\n [\'ab c\\n\', \'\\n\', \'de fg\\r\', \'kl\\r\\n\']\n\n Unlike "split()" when a delimiter string *sep* is given, this\n method returns an empty list for the empty string, and a terminal\n line break does not result in an extra line:\n\n >>> "".splitlines()\n []\n >>> "One line\\n".splitlines()\n [\'One line\']\n\n For comparison, "split(\'\\n\')" gives:\n\n >>> \'\'.split(\'\\n\')\n [\'\']\n >>> \'Two lines\\n\'.split(\'\\n\')\n [\'Two lines\', \'\']\n\nunicode.splitlines([keepends])\n\n Return a list of the lines in the string, like "str.splitlines()".\n However, the Unicode method splits on the following line\n boundaries, which are a superset of the *universal newlines*\n recognized for 8-bit strings.\n\n +-------------------------+-------------------------------+\n | Representation | Description |\n +=========================+===============================+\n | "\\n" | Line Feed |\n +-------------------------+-------------------------------+\n | "\\r" | Carriage Return |\n +-------------------------+-------------------------------+\n | "\\r\\n" | Carriage Return + Line Feed |\n +-------------------------+-------------------------------+\n | "\\v" or "\\x0b" | Line Tabulation |\n +-------------------------+-------------------------------+\n | "\\f" or "\\x0c" | Form Feed |\n +-------------------------+-------------------------------+\n | "\\x1c" | File Separator |\n +-------------------------+-------------------------------+\n | "\\x1d" | Group Separator |\n +-------------------------+-------------------------------+\n | "\\x1e" | Record Separator |\n +-------------------------+-------------------------------+\n | "\\x85" | Next Line (C1 Control Code) |\n +-------------------------+-------------------------------+\n | "\\u2028" | Line Separator |\n +-------------------------+-------------------------------+\n | "\\u2029" | Paragraph Separator |\n +-------------------------+-------------------------------+\n\n Changed in version 2.7: "\\v" and "\\f" added to list of line\n boundaries.\n\nstr.startswith(prefix[, start[, end]])\n\n Return "True" if string starts with the *prefix*, otherwise return\n "False". *prefix* can also be a tuple of prefixes to look for.\n With optional *start*, test string beginning at that position.\n With optional *end*, stop comparing string at that position.\n\n Changed in version 2.5: Accept tuples as *prefix*.\n\nstr.strip([chars])\n\n Return a copy of the string with the leading and trailing\n characters removed. The *chars* argument is a string specifying the\n set of characters to be removed. If omitted or "None", the *chars*\n argument defaults to removing whitespace. The *chars* argument is\n not a prefix or suffix; rather, all combinations of its values are\n stripped:\n\n >>> \' spacious \'.strip()\n \'spacious\'\n >>> \'www.example.com\'.strip(\'cmowz.\')\n \'example\'\n\n Changed in version 2.2.2: Support for the *chars* argument.\n\nstr.swapcase()\n\n Return a copy of the string with uppercase characters converted to\n lowercase and vice versa.\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.title()\n\n Return a titlecased version of the string where words start with an\n uppercase character and the remaining characters are lowercase.\n\n The algorithm uses a simple language-independent definition of a\n word as groups of consecutive letters. The definition works in\n many contexts but it means that apostrophes in contractions and\n possessives form word boundaries, which may not be the desired\n result:\n\n >>> "they\'re bill\'s friends from the UK".title()\n "They\'Re Bill\'S Friends From The Uk"\n\n A workaround for apostrophes can be constructed using regular\n expressions:\n\n >>> import re\n >>> def titlecase(s):\n ... return re.sub(r"[A-Za-z]+(\'[A-Za-z]+)?",\n ... lambda mo: mo.group(0)[0].upper() +\n ... mo.group(0)[1:].lower(),\n ... s)\n ...\n >>> titlecase("they\'re bill\'s friends.")\n "They\'re Bill\'s Friends."\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.translate(table[, deletechars])\n\n Return a copy of the string where all characters occurring in the\n optional argument *deletechars* are removed, and the remaining\n characters have been mapped through the given translation table,\n which must be a string of length 256.\n\n You can use the "maketrans()" helper function in the "string"\n module to create a translation table. For string objects, set the\n *table* argument to "None" for translations that only delete\n characters:\n\n >>> \'read this short text\'.translate(None, \'aeiou\')\n \'rd ths shrt txt\'\n\n New in version 2.6: Support for a "None" *table* argument.\n\n For Unicode objects, the "translate()" method does not accept the\n optional *deletechars* argument. Instead, it returns a copy of the\n *s* where all characters have been mapped through the given\n translation table which must be a mapping of Unicode ordinals to\n Unicode ordinals, Unicode strings or "None". Unmapped characters\n are left untouched. Characters mapped to "None" are deleted. Note,\n a more flexible approach is to create a custom character mapping\n codec using the "codecs" module (see "encodings.cp1251" for an\n example).\n\nstr.upper()\n\n Return a copy of the string with all the cased characters [4]\n converted to uppercase. Note that "str.upper().isupper()" might be\n "False" if "s" contains uncased characters or if the Unicode\n category of the resulting character(s) is not "Lu" (Letter,\n uppercase), but e.g. "Lt" (Letter, titlecase).\n\n For 8-bit strings, this method is locale-dependent.\n\nstr.zfill(width)\n\n Return the numeric string left filled with zeros in a string of\n length *width*. A sign prefix is handled correctly. The original\n string is returned if *width* is less than or equal to "len(s)".\n\n New in version 2.2.2.\n\nThe following methods are present only on unicode objects:\n\nunicode.isnumeric()\n\n Return "True" if there are only numeric characters in S, "False"\n otherwise. Numeric characters include digit characters, and all\n characters that have the Unicode numeric value property, e.g.\n U+2155, VULGAR FRACTION ONE FIFTH.\n\nunicode.isdecimal()\n\n Return "True" if there are only decimal characters in S, "False"\n otherwise. Decimal characters include digit characters, and all\n characters that can be used to form decimal-radix numbers, e.g.\n U+0660, ARABIC-INDIC DIGIT ZERO.\n\n\nString Formatting Operations\n============================\n\nString and Unicode objects have one unique built-in operation: the "%"\noperator (modulo). This is also known as the string *formatting* or\n*interpolation* operator. Given "format % values" (where *format* is\na string or Unicode object), "%" conversion specifications in *format*\nare replaced with zero or more elements of *values*. The effect is\nsimilar to the using "sprintf()" in the C language. If *format* is a\nUnicode object, or if any of the objects being converted using the\n"%s" conversion are Unicode objects, the result will also be a Unicode\nobject.\n\nIf *format* requires a single argument, *values* may be a single non-\ntuple object. [5] Otherwise, *values* must be a tuple with exactly\nthe number of items specified by the format string, or a single\nmapping object (for example, a dictionary).\n\nA conversion specifier contains two or more characters and has the\nfollowing components, which must occur in this order:\n\n1. The "\'%\'" character, which marks the start of the specifier.\n\n2. Mapping key (optional), consisting of a parenthesised sequence\n of characters (for example, "(somename)").\n\n3. Conversion flags (optional), which affect the result of some\n conversion types.\n\n4. Minimum field width (optional). If specified as an "\'*\'"\n (asterisk), the actual width is read from the next element of the\n tuple in *values*, and the object to convert comes after the\n minimum field width and optional precision.\n\n5. Precision (optional), given as a "\'.\'" (dot) followed by the\n precision. If specified as "\'*\'" (an asterisk), the actual width\n is read from the next element of the tuple in *values*, and the\n value to convert comes after the precision.\n\n6. Length modifier (optional).\n\n7. Conversion type.\n\nWhen the right argument is a dictionary (or other mapping type), then\nthe formats in the string *must* include a parenthesised mapping key\ninto that dictionary inserted immediately after the "\'%\'" character.\nThe mapping key selects the value to be formatted from the mapping.\nFor example:\n\n>>> print \'%(language)s has %(number)03d quote types.\' % \\\n... {"language": "Python", "number": 2}\nPython has 002 quote types.\n\nIn this case no "*" specifiers may occur in a format (since they\nrequire a sequential parameter list).\n\nThe conversion flag characters are:\n\n+-----------+-----------------------------------------------------------------------+\n| Flag | Meaning |\n+===========+=======================================================================+\n| "\'#\'" | The value conversion will use the "alternate form" (where defined |\n| | below). |\n+-----------+-----------------------------------------------------------------------+\n| "\'0\'" | The conversion will be zero padded for numeric values. |\n+-----------+-----------------------------------------------------------------------+\n| "\'-\'" | The converted value is left adjusted (overrides the "\'0\'" conversion |\n| | if both are given). |\n+-----------+-----------------------------------------------------------------------+\n| "\' \'" | (a space) A blank should be left before a positive number (or empty |\n| | string) produced by a signed conversion. |\n+-----------+-----------------------------------------------------------------------+\n| "\'+\'" | A sign character ("\'+\'" or "\'-\'") will precede the conversion |\n| | (overrides a "space" flag). |\n+-----------+-----------------------------------------------------------------------+\n\nA length modifier ("h", "l", or "L") may be present, but is ignored as\nit is not necessary for Python -- so e.g. "%ld" is identical to "%d".\n\nThe conversion types are:\n\n+--------------+-------------------------------------------------------+---------+\n| Conversion | Meaning | Notes |\n+==============+=======================================================+=========+\n| "\'d\'" | Signed integer decimal. | |\n+--------------+-------------------------------------------------------+---------+\n| "\'i\'" | Signed integer decimal. | |\n+--------------+-------------------------------------------------------+---------+\n| "\'o\'" | Signed octal value. | (1) |\n+--------------+-------------------------------------------------------+---------+\n| "\'u\'" | Obsolete type -- it is identical to "\'d\'". | (7) |\n+--------------+-------------------------------------------------------+---------+\n| "\'x\'" | Signed hexadecimal (lowercase). | (2) |\n+--------------+-------------------------------------------------------+---------+\n| "\'X\'" | Signed hexadecimal (uppercase). | (2) |\n+--------------+-------------------------------------------------------+---------+\n| "\'e\'" | Floating point exponential format (lowercase). | (3) |\n+--------------+-------------------------------------------------------+---------+\n| "\'E\'" | Floating point exponential format (uppercase). | (3) |\n+--------------+-------------------------------------------------------+---------+\n| "\'f\'" | Floating point decimal format. | (3) |\n+--------------+-------------------------------------------------------+---------+\n| "\'F\'" | Floating point decimal format. | (3) |\n+--------------+-------------------------------------------------------+---------+\n| "\'g\'" | Floating point format. Uses lowercase exponential | (4) |\n| | format if exponent is less than -4 or not less than | |\n| | precision, decimal format otherwise. | |\n+--------------+-------------------------------------------------------+---------+\n| "\'G\'" | Floating point format. Uses uppercase exponential | (4) |\n| | format if exponent is less than -4 or not less than | |\n| | precision, decimal format otherwise. | |\n+--------------+-------------------------------------------------------+---------+\n| "\'c\'" | Single character (accepts integer or single character | |\n| | string). | |\n+--------------+-------------------------------------------------------+---------+\n| "\'r\'" | String (converts any Python object using repr()). | (5) |\n+--------------+-------------------------------------------------------+---------+\n| "\'s\'" | String (converts any Python object using "str()"). | (6) |\n+--------------+-------------------------------------------------------+---------+\n| "\'%\'" | No argument is converted, results in a "\'%\'" | |\n| | character in the result. | |\n+--------------+-------------------------------------------------------+---------+\n\nNotes:\n\n1. The alternate form causes a leading zero ("\'0\'") to be inserted\n between left-hand padding and the formatting of the number if the\n leading character of the result is not already a zero.\n\n2. The alternate form causes a leading "\'0x\'" or "\'0X\'" (depending\n on whether the "\'x\'" or "\'X\'" format was used) to be inserted\n between left-hand padding and the formatting of the number if the\n leading character of the result is not already a zero.\n\n3. The alternate form causes the result to always contain a decimal\n point, even if no digits follow it.\n\n The precision determines the number of digits after the decimal\n point and defaults to 6.\n\n4. The alternate form causes the result to always contain a decimal\n point, and trailing zeroes are not removed as they would otherwise\n be.\n\n The precision determines the number of significant digits before\n and after the decimal point and defaults to 6.\n\n5. The "%r" conversion was added in Python 2.0.\n\n The precision determines the maximal number of characters used.\n\n6. If the object or format provided is a "unicode" string, the\n resulting string will also be "unicode".\n\n The precision determines the maximal number of characters used.\n\n7. See **PEP 237**.\n\nSince Python strings have an explicit length, "%s" conversions do not\nassume that "\'\\0\'" is the end of the string.\n\nChanged in version 2.7: "%f" conversions for numbers whose absolute\nvalue is over 1e50 are no longer replaced by "%g" conversions.\n\nAdditional string operations are defined in standard modules "string"\nand "re".\n\n\nXRange Type\n===========\n\nThe "xrange" type is an immutable sequence which is commonly used for\nlooping. The advantage of the "xrange" type is that an "xrange"\nobject will always take the same amount of memory, no matter the size\nof the range it represents. There are no consistent performance\nadvantages.\n\nXRange objects have very little behavior: they only support indexing,\niteration, and the "len()" function.\n\n\nMutable Sequence Types\n======================\n\nList and "bytearray" objects support additional operations that allow\nin-place modification of the object. Other mutable sequence types\n(when added to the language) should also support these operations.\nStrings and tuples are immutable sequence types: such objects cannot\nbe modified once created. The following operations are defined on\nmutable sequence types (where *x* is an arbitrary object):\n\n+--------------------------------+----------------------------------+-----------------------+\n| Operation | Result | Notes |\n+================================+==================================+=======================+\n| "s[i] = x" | item *i* of *s* is replaced by | |\n| | *x* | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s[i:j] = t" | slice of *s* from *i* to *j* is | |\n| | replaced by the contents of the | |\n| | iterable *t* | |\n+--------------------------------+----------------------------------+-----------------------+\n| "del s[i:j]" | same as "s[i:j] = []" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s[i:j:k] = t" | the elements of "s[i:j:k]" are | (1) |\n| | replaced by those of *t* | |\n+--------------------------------+----------------------------------+-----------------------+\n| "del s[i:j:k]" | removes the elements of | |\n| | "s[i:j:k]" from the list | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.append(x)" | same as "s[len(s):len(s)] = [x]" | (2) |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.extend(t)" or "s += t" | for the most part the same as | (3) |\n| | "s[len(s):len(s)] = t" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s *= n" | updates *s* with its contents | (11) |\n| | repeated *n* times | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.count(x)" | return number of *i*\'s for which | |\n| | "s[i] == x" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.index(x[, i[, j]])" | return smallest *k* such that | (4) |\n| | "s[k] == x" and "i <= k < j" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.insert(i, x)" | same as "s[i:i] = [x]" | (5) |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.pop([i])" | same as "x = s[i]; del s[i]; | (6) |\n| | return x" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.remove(x)" | same as "del s[s.index(x)]" | (4) |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.reverse()" | reverses the items of *s* in | (7) |\n| | place | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.sort([cmp[, key[, | sort the items of *s* in place | (7)(8)(9)(10) |\n| reverse]]])" | | |\n+--------------------------------+----------------------------------+-----------------------+\n\nNotes:\n\n1. *t* must have the same length as the slice it is replacing.\n\n2. The C implementation of Python has historically accepted\n multiple parameters and implicitly joined them into a tuple; this\n no longer works in Python 2.0. Use of this misfeature has been\n deprecated since Python 1.4.\n\n3. *t* can be any iterable object.\n\n4. Raises "ValueError" when *x* is not found in *s*. When a\n negative index is passed as the second or third parameter to the\n "index()" method, the list length is added, as for slice indices.\n If it is still negative, it is truncated to zero, as for slice\n indices.\n\n Changed in version 2.3: Previously, "index()" didn\'t have arguments\n for specifying start and stop positions.\n\n5. When a negative index is passed as the first parameter to the\n "insert()" method, the list length is added, as for slice indices.\n If it is still negative, it is truncated to zero, as for slice\n indices.\n\n Changed in version 2.3: Previously, all negative indices were\n truncated to zero.\n\n6. The "pop()" method\'s optional argument *i* defaults to "-1", so\n that by default the last item is removed and returned.\n\n7. The "sort()" and "reverse()" methods modify the list in place\n for economy of space when sorting or reversing a large list. To\n remind you that they operate by side effect, they don\'t return the\n sorted or reversed list.\n\n8. The "sort()" method takes optional arguments for controlling the\n comparisons.\n\n *cmp* specifies a custom comparison function of two arguments (list\n items) which should return a negative, zero or positive number\n depending on whether the first argument is considered smaller than,\n equal to, or larger than the second argument: "cmp=lambda x,y:\n cmp(x.lower(), y.lower())". The default value is "None".\n\n *key* specifies a function of one argument that is used to extract\n a comparison key from each list element: "key=str.lower". The\n default value is "None".\n\n *reverse* is a boolean value. If set to "True", then the list\n elements are sorted as if each comparison were reversed.\n\n In general, the *key* and *reverse* conversion processes are much\n faster than specifying an equivalent *cmp* function. This is\n because *cmp* is called multiple times for each list element while\n *key* and *reverse* touch each element only once. Use\n "functools.cmp_to_key()" to convert an old-style *cmp* function to\n a *key* function.\n\n Changed in version 2.3: Support for "None" as an equivalent to\n omitting *cmp* was added.\n\n Changed in version 2.4: Support for *key* and *reverse* was added.\n\n9. Starting with Python 2.3, the "sort()" method is guaranteed to\n be stable. A sort is stable if it guarantees not to change the\n relative order of elements that compare equal --- this is helpful\n for sorting in multiple passes (for example, sort by department,\n then by salary grade).\n\n10. **CPython implementation detail:** While a list is being\n sorted, the effect of attempting to mutate, or even inspect, the\n list is undefined. The C implementation of Python 2.3 and newer\n makes the list appear empty for the duration, and raises\n "ValueError" if it can detect that the list has been mutated\n during a sort.\n\n11. The value *n* is an integer, or an object implementing\n "__index__()". Zero and negative values of *n* clear the\n sequence. Items in the sequence are not copied; they are\n referenced multiple times, as explained for "s * n" under Sequence\n Types --- str, unicode, list, tuple, bytearray, buffer, xrange.\n',
- 'typesseq-mutable': u'\nMutable Sequence Types\n**********************\n\nList and "bytearray" objects support additional operations that allow\nin-place modification of the object. Other mutable sequence types\n(when added to the language) should also support these operations.\nStrings and tuples are immutable sequence types: such objects cannot\nbe modified once created. The following operations are defined on\nmutable sequence types (where *x* is an arbitrary object):\n\n+--------------------------------+----------------------------------+-----------------------+\n| Operation | Result | Notes |\n+================================+==================================+=======================+\n| "s[i] = x" | item *i* of *s* is replaced by | |\n| | *x* | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s[i:j] = t" | slice of *s* from *i* to *j* is | |\n| | replaced by the contents of the | |\n| | iterable *t* | |\n+--------------------------------+----------------------------------+-----------------------+\n| "del s[i:j]" | same as "s[i:j] = []" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s[i:j:k] = t" | the elements of "s[i:j:k]" are | (1) |\n| | replaced by those of *t* | |\n+--------------------------------+----------------------------------+-----------------------+\n| "del s[i:j:k]" | removes the elements of | |\n| | "s[i:j:k]" from the list | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.append(x)" | same as "s[len(s):len(s)] = [x]" | (2) |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.extend(t)" or "s += t" | for the most part the same as | (3) |\n| | "s[len(s):len(s)] = t" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s *= n" | updates *s* with its contents | (11) |\n| | repeated *n* times | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.count(x)" | return number of *i*\'s for which | |\n| | "s[i] == x" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.index(x[, i[, j]])" | return smallest *k* such that | (4) |\n| | "s[k] == x" and "i <= k < j" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.insert(i, x)" | same as "s[i:i] = [x]" | (5) |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.pop([i])" | same as "x = s[i]; del s[i]; | (6) |\n| | return x" | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.remove(x)" | same as "del s[s.index(x)]" | (4) |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.reverse()" | reverses the items of *s* in | (7) |\n| | place | |\n+--------------------------------+----------------------------------+-----------------------+\n| "s.sort([cmp[, key[, | sort the items of *s* in place | (7)(8)(9)(10) |\n| reverse]]])" | | |\n+--------------------------------+----------------------------------+-----------------------+\n\nNotes:\n\n1. *t* must have the same length as the slice it is replacing.\n\n2. The C implementation of Python has historically accepted\n multiple parameters and implicitly joined them into a tuple; this\n no longer works in Python 2.0. Use of this misfeature has been\n deprecated since Python 1.4.\n\n3. *t* can be any iterable object.\n\n4. Raises "ValueError" when *x* is not found in *s*. When a\n negative index is passed as the second or third parameter to the\n "index()" method, the list length is added, as for slice indices.\n If it is still negative, it is truncated to zero, as for slice\n indices.\n\n Changed in version 2.3: Previously, "index()" didn\'t have arguments\n for specifying start and stop positions.\n\n5. When a negative index is passed as the first parameter to the\n "insert()" method, the list length is added, as for slice indices.\n If it is still negative, it is truncated to zero, as for slice\n indices.\n\n Changed in version 2.3: Previously, all negative indices were\n truncated to zero.\n\n6. The "pop()" method\'s optional argument *i* defaults to "-1", so\n that by default the last item is removed and returned.\n\n7. The "sort()" and "reverse()" methods modify the list in place\n for economy of space when sorting or reversing a large list. To\n remind you that they operate by side effect, they don\'t return the\n sorted or reversed list.\n\n8. The "sort()" method takes optional arguments for controlling the\n comparisons.\n\n *cmp* specifies a custom comparison function of two arguments (list\n items) which should return a negative, zero or positive number\n depending on whether the first argument is considered smaller than,\n equal to, or larger than the second argument: "cmp=lambda x,y:\n cmp(x.lower(), y.lower())". The default value is "None".\n\n *key* specifies a function of one argument that is used to extract\n a comparison key from each list element: "key=str.lower". The\n default value is "None".\n\n *reverse* is a boolean value. If set to "True", then the list\n elements are sorted as if each comparison were reversed.\n\n In general, the *key* and *reverse* conversion processes are much\n faster than specifying an equivalent *cmp* function. This is\n because *cmp* is called multiple times for each list element while\n *key* and *reverse* touch each element only once. Use\n "functools.cmp_to_key()" to convert an old-style *cmp* function to\n a *key* function.\n\n Changed in version 2.3: Support for "None" as an equivalent to\n omitting *cmp* was added.\n\n Changed in version 2.4: Support for *key* and *reverse* was added.\n\n9. Starting with Python 2.3, the "sort()" method is guaranteed to\n be stable. A sort is stable if it guarantees not to change the\n relative order of elements that compare equal --- this is helpful\n for sorting in multiple passes (for example, sort by department,\n then by salary grade).\n\n10. **CPython implementation detail:** While a list is being\n sorted, the effect of attempting to mutate, or even inspect, the\n list is undefined. The C implementation of Python 2.3 and newer\n makes the list appear empty for the duration, and raises\n "ValueError" if it can detect that the list has been mutated\n during a sort.\n\n11. The value *n* is an integer, or an object implementing\n "__index__()". Zero and negative values of *n* clear the\n sequence. Items in the sequence are not copied; they are\n referenced multiple times, as explained for "s * n" under Sequence\n Types --- str, unicode, list, tuple, bytearray, buffer, xrange.\n',
- 'unary': u'\nUnary arithmetic and bitwise operations\n***************************************\n\nAll unary arithmetic and bitwise operations have the same priority:\n\n u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr\n\nThe unary "-" (minus) operator yields the negation of its numeric\nargument.\n\nThe unary "+" (plus) operator yields its numeric argument unchanged.\n\nThe unary "~" (invert) operator yields the bitwise inversion of its\nplain or long integer argument. The bitwise inversion of "x" is\ndefined as "-(x+1)". It only applies to integral numbers.\n\nIn all three cases, if the argument does not have the proper type, a\n"TypeError" exception is raised.\n',
- 'while': u'\nThe "while" statement\n*********************\n\nThe "while" statement is used for repeated execution as long as an\nexpression is true:\n\n while_stmt ::= "while" expression ":" suite\n ["else" ":" suite]\n\nThis repeatedly tests the expression and, if it is true, executes the\nfirst suite; if the expression is false (which may be the first time\nit is tested) the suite of the "else" clause, if present, is executed\nand the loop terminates.\n\nA "break" statement executed in the first suite terminates the loop\nwithout executing the "else" clause\'s suite. A "continue" statement\nexecuted in the first suite skips the rest of the suite and goes back\nto testing the expression.\n',
- 'with': u'\nThe "with" statement\n********************\n\nNew in version 2.5.\n\nThe "with" statement is used to wrap the execution of a block with\nmethods defined by a context manager (see section With Statement\nContext Managers). This allows common "try"..."except"..."finally"\nusage patterns to be encapsulated for convenient reuse.\n\n with_stmt ::= "with" with_item ("," with_item)* ":" suite\n with_item ::= expression ["as" target]\n\nThe execution of the "with" statement with one "item" proceeds as\nfollows:\n\n1. The context expression (the expression given in the "with_item")\n is evaluated to obtain a context manager.\n\n2. The context manager\'s "__exit__()" is loaded for later use.\n\n3. The context manager\'s "__enter__()" method is invoked.\n\n4. If a target was included in the "with" statement, the return\n value from "__enter__()" is assigned to it.\n\n Note: The "with" statement guarantees that if the "__enter__()"\n method returns without an error, then "__exit__()" will always be\n called. Thus, if an error occurs during the assignment to the\n target list, it will be treated the same as an error occurring\n within the suite would be. See step 6 below.\n\n5. The suite is executed.\n\n6. The context manager\'s "__exit__()" method is invoked. If an\n exception caused the suite to be exited, its type, value, and\n traceback are passed as arguments to "__exit__()". Otherwise, three\n "None" arguments are supplied.\n\n If the suite was exited due to an exception, and the return value\n from the "__exit__()" method was false, the exception is reraised.\n If the return value was true, the exception is suppressed, and\n execution continues with the statement following the "with"\n statement.\n\n If the suite was exited for any reason other than an exception, the\n return value from "__exit__()" is ignored, and execution proceeds\n at the normal location for the kind of exit that was taken.\n\nWith more than one item, the context managers are processed as if\nmultiple "with" statements were nested:\n\n with A() as a, B() as b:\n suite\n\nis equivalent to\n\n with A() as a:\n with B() as b:\n suite\n\nNote: In Python 2.5, the "with" statement is only allowed when the\n "with_statement" feature has been enabled. It is always enabled in\n Python 2.6.\n\nChanged in version 2.7: Support for multiple context expressions.\n\nSee also:\n\n **PEP 343** - The "with" statement\n The specification, background, and examples for the Python "with"\n statement.\n',
- 'yield': u'\nThe "yield" statement\n*********************\n\n yield_stmt ::= yield_expression\n\nThe "yield" statement is only used when defining a generator function,\nand is only used in the body of the generator function. Using a\n"yield" statement in a function definition is sufficient to cause that\ndefinition to create a generator function instead of a normal\nfunction.\n\nWhen a generator function is called, it returns an iterator known as a\ngenerator iterator, or more commonly, a generator. The body of the\ngenerator function is executed by calling the generator\'s "next()"\nmethod repeatedly until it raises an exception.\n\nWhen a "yield" statement is executed, the state of the generator is\nfrozen and the value of "expression_list" is returned to "next()"\'s\ncaller. By "frozen" we mean that all local state is retained,\nincluding the current bindings of local variables, the instruction\npointer, and the internal evaluation stack: enough information is\nsaved so that the next time "next()" is invoked, the function can\nproceed exactly as if the "yield" statement were just another external\ncall.\n\nAs of Python version 2.5, the "yield" statement is now allowed in the\n"try" clause of a "try" ... "finally" construct. If the generator is\nnot resumed before it is finalized (by reaching a zero reference count\nor by being garbage collected), the generator-iterator\'s "close()"\nmethod will be called, allowing any pending "finally" clauses to\nexecute.\n\nFor full details of "yield" semantics, refer to the Yield expressions\nsection.\n\nNote: In Python 2.2, the "yield" statement was only allowed when the\n "generators" feature has been enabled. This "__future__" import\n statement was used to enable the feature:\n\n from __future__ import generators\n\nSee also:\n\n **PEP 255** - Simple Generators\n The proposal for adding generators and the "yield" statement to\n Python.\n\n **PEP 342** - Coroutines via Enhanced Generators\n The proposal that, among other generator enhancements, proposed\n allowing "yield" to appear inside a "try" ... "finally" block.\n'}
+# Autogenerated by Sphinx on Sat Aug 26 11:16:28 2017
+topics = {'assert': '\n'
+ 'The "assert" statement\n'
+ '**********************\n'
+ '\n'
+ 'Assert statements are a convenient way to insert debugging '
+ 'assertions\n'
+ 'into a program:\n'
+ '\n'
+ ' assert_stmt ::= "assert" expression ["," expression]\n'
+ '\n'
+ 'The simple form, "assert expression", is equivalent to\n'
+ '\n'
+ ' if __debug__:\n'
+ ' if not expression: raise AssertionError\n'
+ '\n'
+ 'The extended form, "assert expression1, expression2", is '
+ 'equivalent to\n'
+ '\n'
+ ' if __debug__:\n'
+ ' if not expression1: raise AssertionError(expression2)\n'
+ '\n'
+ 'These equivalences assume that "__debug__" and "AssertionError" '
+ 'refer\n'
+ 'to the built-in variables with those names. In the current\n'
+ 'implementation, the built-in variable "__debug__" is "True" under\n'
+ 'normal circumstances, "False" when optimization is requested '
+ '(command\n'
+ 'line option -O). The current code generator emits no code for an\n'
+ 'assert statement when optimization is requested at compile time. '
+ 'Note\n'
+ 'that it is unnecessary to include the source code for the '
+ 'expression\n'
+ 'that failed in the error message; it will be displayed as part of '
+ 'the\n'
+ 'stack trace.\n'
+ '\n'
+ 'Assignments to "__debug__" are illegal. The value for the '
+ 'built-in\n'
+ 'variable is determined when the interpreter starts.\n',
+ 'assignment': '\n'
+ 'Assignment statements\n'
+ '*********************\n'
+ '\n'
+ 'Assignment statements are used to (re)bind names to values and '
+ 'to\n'
+ 'modify attributes or items of mutable objects:\n'
+ '\n'
+ ' assignment_stmt ::= (target_list "=")+ (expression_list | '
+ 'yield_expression)\n'
+ ' target_list ::= target ("," target)* [","]\n'
+ ' target ::= identifier\n'
+ ' | "(" target_list ")"\n'
+ ' | "[" [target_list] "]"\n'
+ ' | attributeref\n'
+ ' | subscription\n'
+ ' | slicing\n'
+ '\n'
+ '(See section Primaries for the syntax definitions for the last '
+ 'three\n'
+ 'symbols.)\n'
+ '\n'
+ 'An assignment statement evaluates the expression list '
+ '(remember that\n'
+ 'this can be a single expression or a comma-separated list, the '
+ 'latter\n'
+ 'yielding a tuple) and assigns the single resulting object to '
+ 'each of\n'
+ 'the target lists, from left to right.\n'
+ '\n'
+ 'Assignment is defined recursively depending on the form of the '
+ 'target\n'
+ '(list). When a target is part of a mutable object (an '
+ 'attribute\n'
+ 'reference, subscription or slicing), the mutable object must\n'
+ 'ultimately perform the assignment and decide about its '
+ 'validity, and\n'
+ 'may raise an exception if the assignment is unacceptable. The '
+ 'rules\n'
+ 'observed by various types and the exceptions raised are given '
+ 'with the\n'
+ 'definition of the object types (see section The standard type\n'
+ 'hierarchy).\n'
+ '\n'
+ 'Assignment of an object to a target list is recursively '
+ 'defined as\n'
+ 'follows.\n'
+ '\n'
+ '* If the target list is a single target: The object is '
+ 'assigned to\n'
+ ' that target.\n'
+ '\n'
+ '* If the target list is a comma-separated list of targets: '
+ 'The\n'
+ ' object must be an iterable with the same number of items as '
+ 'there\n'
+ ' are targets in the target list, and the items are assigned, '
+ 'from\n'
+ ' left to right, to the corresponding targets.\n'
+ '\n'
+ 'Assignment of an object to a single target is recursively '
+ 'defined as\n'
+ 'follows.\n'
+ '\n'
+ '* If the target is an identifier (name):\n'
+ '\n'
+ ' * If the name does not occur in a "global" statement in the\n'
+ ' current code block: the name is bound to the object in the '
+ 'current\n'
+ ' local namespace.\n'
+ '\n'
+ ' * Otherwise: the name is bound to the object in the current '
+ 'global\n'
+ ' namespace.\n'
+ '\n'
+ ' The name is rebound if it was already bound. This may cause '
+ 'the\n'
+ ' reference count for the object previously bound to the name '
+ 'to reach\n'
+ ' zero, causing the object to be deallocated and its '
+ 'destructor (if it\n'
+ ' has one) to be called.\n'
+ '\n'
+ '* If the target is a target list enclosed in parentheses or '
+ 'in\n'
+ ' square brackets: The object must be an iterable with the '
+ 'same number\n'
+ ' of items as there are targets in the target list, and its '
+ 'items are\n'
+ ' assigned, from left to right, to the corresponding targets.\n'
+ '\n'
+ '* If the target is an attribute reference: The primary '
+ 'expression in\n'
+ ' the reference is evaluated. It should yield an object with\n'
+ ' assignable attributes; if this is not the case, "TypeError" '
+ 'is\n'
+ ' raised. That object is then asked to assign the assigned '
+ 'object to\n'
+ ' the given attribute; if it cannot perform the assignment, it '
+ 'raises\n'
+ ' an exception (usually but not necessarily '
+ '"AttributeError").\n'
+ '\n'
+ ' Note: If the object is a class instance and the attribute '
+ 'reference\n'
+ ' occurs on both sides of the assignment operator, the RHS '
+ 'expression,\n'
+ ' "a.x" can access either an instance attribute or (if no '
+ 'instance\n'
+ ' attribute exists) a class attribute. The LHS target "a.x" '
+ 'is always\n'
+ ' set as an instance attribute, creating it if necessary. '
+ 'Thus, the\n'
+ ' two occurrences of "a.x" do not necessarily refer to the '
+ 'same\n'
+ ' attribute: if the RHS expression refers to a class '
+ 'attribute, the\n'
+ ' LHS creates a new instance attribute as the target of the\n'
+ ' assignment:\n'
+ '\n'
+ ' class Cls:\n'
+ ' x = 3 # class variable\n'
+ ' inst = Cls()\n'
+ ' inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x '
+ 'as 3\n'
+ '\n'
+ ' This description does not necessarily apply to descriptor\n'
+ ' attributes, such as properties created with "property()".\n'
+ '\n'
+ '* If the target is a subscription: The primary expression in '
+ 'the\n'
+ ' reference is evaluated. It should yield either a mutable '
+ 'sequence\n'
+ ' object (such as a list) or a mapping object (such as a '
+ 'dictionary).\n'
+ ' Next, the subscript expression is evaluated.\n'
+ '\n'
+ ' If the primary is a mutable sequence object (such as a '
+ 'list), the\n'
+ ' subscript must yield a plain integer. If it is negative, '
+ 'the\n'
+ " sequence's length is added to it. The resulting value must "
+ 'be a\n'
+ " nonnegative integer less than the sequence's length, and "
+ 'the\n'
+ ' sequence is asked to assign the assigned object to its item '
+ 'with\n'
+ ' that index. If the index is out of range, "IndexError" is '
+ 'raised\n'
+ ' (assignment to a subscripted sequence cannot add new items '
+ 'to a\n'
+ ' list).\n'
+ '\n'
+ ' If the primary is a mapping object (such as a dictionary), '
+ 'the\n'
+ " subscript must have a type compatible with the mapping's key "
+ 'type,\n'
+ ' and the mapping is then asked to create a key/datum pair '
+ 'which maps\n'
+ ' the subscript to the assigned object. This can either '
+ 'replace an\n'
+ ' existing key/value pair with the same key value, or insert a '
+ 'new\n'
+ ' key/value pair (if no key with the same value existed).\n'
+ '\n'
+ '* If the target is a slicing: The primary expression in the\n'
+ ' reference is evaluated. It should yield a mutable sequence '
+ 'object\n'
+ ' (such as a list). The assigned object should be a sequence '
+ 'object\n'
+ ' of the same type. Next, the lower and upper bound '
+ 'expressions are\n'
+ ' evaluated, insofar they are present; defaults are zero and '
+ 'the\n'
+ " sequence's length. The bounds should evaluate to (small) "
+ 'integers.\n'
+ " If either bound is negative, the sequence's length is added "
+ 'to it.\n'
+ ' The resulting bounds are clipped to lie between zero and '
+ 'the\n'
+ " sequence's length, inclusive. Finally, the sequence object "
+ 'is asked\n'
+ ' to replace the slice with the items of the assigned '
+ 'sequence. The\n'
+ ' length of the slice may be different from the length of the '
+ 'assigned\n'
+ ' sequence, thus changing the length of the target sequence, '
+ 'if the\n'
+ ' object allows it.\n'
+ '\n'
+ '**CPython implementation detail:** In the current '
+ 'implementation, the\n'
+ 'syntax for targets is taken to be the same as for expressions, '
+ 'and\n'
+ 'invalid syntax is rejected during the code generation phase, '
+ 'causing\n'
+ 'less detailed error messages.\n'
+ '\n'
+ 'WARNING: Although the definition of assignment implies that '
+ 'overlaps\n'
+ "between the left-hand side and the right-hand side are 'safe' "
+ '(for\n'
+ 'example "a, b = b, a" swaps two variables), overlaps *within* '
+ 'the\n'
+ 'collection of assigned-to variables are not safe! For '
+ 'instance, the\n'
+ 'following program prints "[0, 2]":\n'
+ '\n'
+ ' x = [0, 1]\n'
+ ' i = 0\n'
+ ' i, x[i] = 1, 2\n'
+ ' print x\n'
+ '\n'
+ '\n'
+ 'Augmented assignment statements\n'
+ '===============================\n'
+ '\n'
+ 'Augmented assignment is the combination, in a single '
+ 'statement, of a\n'
+ 'binary operation and an assignment statement:\n'
+ '\n'
+ ' augmented_assignment_stmt ::= augtarget augop '
+ '(expression_list | yield_expression)\n'
+ ' augtarget ::= identifier | attributeref | '
+ 'subscription | slicing\n'
+ ' augop ::= "+=" | "-=" | "*=" | "/=" | '
+ '"//=" | "%=" | "**="\n'
+ ' | ">>=" | "<<=" | "&=" | "^=" | "|="\n'
+ '\n'
+ '(See section Primaries for the syntax definitions for the last '
+ 'three\n'
+ 'symbols.)\n'
+ '\n'
+ 'An augmented assignment evaluates the target (which, unlike '
+ 'normal\n'
+ 'assignment statements, cannot be an unpacking) and the '
+ 'expression\n'
+ 'list, performs the binary operation specific to the type of '
+ 'assignment\n'
+ 'on the two operands, and assigns the result to the original '
+ 'target.\n'
+ 'The target is only evaluated once.\n'
+ '\n'
+ 'An augmented assignment expression like "x += 1" can be '
+ 'rewritten as\n'
+ '"x = x + 1" to achieve a similar, but not exactly equal '
+ 'effect. In the\n'
+ 'augmented version, "x" is only evaluated once. Also, when '
+ 'possible,\n'
+ 'the actual operation is performed *in-place*, meaning that '
+ 'rather than\n'
+ 'creating a new object and assigning that to the target, the '
+ 'old object\n'
+ 'is modified instead.\n'
+ '\n'
+ 'With the exception of assigning to tuples and multiple targets '
+ 'in a\n'
+ 'single statement, the assignment done by augmented assignment\n'
+ 'statements is handled the same way as normal assignments. '
+ 'Similarly,\n'
+ 'with the exception of the possible *in-place* behavior, the '
+ 'binary\n'
+ 'operation performed by augmented assignment is the same as the '
+ 'normal\n'
+ 'binary operations.\n'
+ '\n'
+ 'For targets which are attribute references, the same caveat '
+ 'about\n'
+ 'class and instance attributes applies as for regular '
+ 'assignments.\n',
+ 'atom-identifiers': '\n'
+ 'Identifiers (Names)\n'
+ '*******************\n'
+ '\n'
+ 'An identifier occurring as an atom is a name. See '
+ 'section Identifiers\n'
+ 'and keywords for lexical definition and section Naming '
+ 'and binding for\n'
+ 'documentation of naming and binding.\n'
+ '\n'
+ 'When the name is bound to an object, evaluation of the '
+ 'atom yields\n'
+ 'that object. When a name is not bound, an attempt to '
+ 'evaluate it\n'
+ 'raises a "NameError" exception.\n'
+ '\n'
+ '**Private name mangling:** When an identifier that '
+ 'textually occurs in\n'
+ 'a class definition begins with two or more underscore '
+ 'characters and\n'
+ 'does not end in two or more underscores, it is '
+ 'considered a *private\n'
+ 'name* of that class. Private names are transformed to a '
+ 'longer form\n'
+ 'before code is generated for them. The transformation '
+ 'inserts the\n'
+ 'class name, with leading underscores removed and a '
+ 'single underscore\n'
+ 'inserted, in front of the name. For example, the '
+ 'identifier "__spam"\n'
+ 'occurring in a class named "Ham" will be transformed to '
+ '"_Ham__spam".\n'
+ 'This transformation is independent of the syntactical '
+ 'context in which\n'
+ 'the identifier is used. If the transformed name is '
+ 'extremely long\n'
+ '(longer than 255 characters), implementation defined '
+ 'truncation may\n'
+ 'happen. If the class name consists only of underscores, '
+ 'no\n'
+ 'transformation is done.\n',
+ 'atom-literals': '\n'
+ 'Literals\n'
+ '********\n'
+ '\n'
+ 'Python supports string literals and various numeric '
+ 'literals:\n'
+ '\n'
+ ' literal ::= stringliteral | integer | longinteger\n'
+ ' | floatnumber | imagnumber\n'
+ '\n'
+ 'Evaluation of a literal yields an object of the given type '
+ '(string,\n'
+ 'integer, long integer, floating point number, complex '
+ 'number) with the\n'
+ 'given value. The value may be approximated in the case of '
+ 'floating\n'
+ 'point and imaginary (complex) literals. See section '
+ 'Literals for\n'
+ 'details.\n'
+ '\n'
+ 'All literals correspond to immutable data types, and hence '
+ 'the\n'
+ "object's identity is less important than its value. "
+ 'Multiple\n'
+ 'evaluations of literals with the same value (either the '
+ 'same\n'
+ 'occurrence in the program text or a different occurrence) '
+ 'may obtain\n'
+ 'the same object or a different object with the same '
+ 'value.\n',
+ 'attribute-access': '\n'
+ 'Customizing attribute access\n'
+ '****************************\n'
+ '\n'
+ 'The following methods can be defined to customize the '
+ 'meaning of\n'
+ 'attribute access (use of, assignment to, or deletion of '
+ '"x.name") for\n'
+ 'class instances.\n'
+ '\n'
+ 'object.__getattr__(self, name)\n'
+ '\n'
+ ' Called when an attribute lookup has not found the '
+ 'attribute in the\n'
+ ' usual places (i.e. it is not an instance attribute '
+ 'nor is it found\n'
+ ' in the class tree for "self"). "name" is the '
+ 'attribute name. This\n'
+ ' method should return the (computed) attribute value '
+ 'or raise an\n'
+ ' "AttributeError" exception.\n'
+ '\n'
+ ' Note that if the attribute is found through the '
+ 'normal mechanism,\n'
+ ' "__getattr__()" is not called. (This is an '
+ 'intentional asymmetry\n'
+ ' between "__getattr__()" and "__setattr__()".) This is '
+ 'done both for\n'
+ ' efficiency reasons and because otherwise '
+ '"__getattr__()" would have\n'
+ ' no way to access other attributes of the instance. '
+ 'Note that at\n'
+ ' least for instance variables, you can fake total '
+ 'control by not\n'
+ ' inserting any values in the instance attribute '
+ 'dictionary (but\n'
+ ' instead inserting them in another object). See the\n'
+ ' "__getattribute__()" method below for a way to '
+ 'actually get total\n'
+ ' control in new-style classes.\n'
+ '\n'
+ 'object.__setattr__(self, name, value)\n'
+ '\n'
+ ' Called when an attribute assignment is attempted. '
+ 'This is called\n'
+ ' instead of the normal mechanism (i.e. store the value '
+ 'in the\n'
+ ' instance dictionary). *name* is the attribute name, '
+ '*value* is the\n'
+ ' value to be assigned to it.\n'
+ '\n'
+ ' If "__setattr__()" wants to assign to an instance '
+ 'attribute, it\n'
+ ' should not simply execute "self.name = value" --- '
+ 'this would cause\n'
+ ' a recursive call to itself. Instead, it should '
+ 'insert the value in\n'
+ ' the dictionary of instance attributes, e.g., '
+ '"self.__dict__[name] =\n'
+ ' value". For new-style classes, rather than accessing '
+ 'the instance\n'
+ ' dictionary, it should call the base class method with '
+ 'the same\n'
+ ' name, for example, "object.__setattr__(self, name, '
+ 'value)".\n'
+ '\n'
+ 'object.__delattr__(self, name)\n'
+ '\n'
+ ' Like "__setattr__()" but for attribute deletion '
+ 'instead of\n'
+ ' assignment. This should only be implemented if "del '
+ 'obj.name" is\n'
+ ' meaningful for the object.\n'
+ '\n'
+ '\n'
+ 'More attribute access for new-style classes\n'
+ '===========================================\n'
+ '\n'
+ 'The following methods only apply to new-style classes.\n'
+ '\n'
+ 'object.__getattribute__(self, name)\n'
+ '\n'
+ ' Called unconditionally to implement attribute '
+ 'accesses for\n'
+ ' instances of the class. If the class also defines '
+ '"__getattr__()",\n'
+ ' the latter will not be called unless '
+ '"__getattribute__()" either\n'
+ ' calls it explicitly or raises an "AttributeError". '
+ 'This method\n'
+ ' should return the (computed) attribute value or raise '
+ 'an\n'
+ ' "AttributeError" exception. In order to avoid '
+ 'infinite recursion in\n'
+ ' this method, its implementation should always call '
+ 'the base class\n'
+ ' method with the same name to access any attributes it '
+ 'needs, for\n'
+ ' example, "object.__getattribute__(self, name)".\n'
+ '\n'
+ ' Note: This method may still be bypassed when looking '
+ 'up special\n'
+ ' methods as the result of implicit invocation via '
+ 'language syntax\n'
+ ' or built-in functions. See Special method lookup '
+ 'for new-style\n'
+ ' classes.\n'
+ '\n'
+ '\n'
+ 'Implementing Descriptors\n'
+ '========================\n'
+ '\n'
+ 'The following methods only apply when an instance of the '
+ 'class\n'
+ 'containing the method (a so-called *descriptor* class) '
+ 'appears in an\n'
+ '*owner* class (the descriptor must be in either the '
+ "owner's class\n"
+ 'dictionary or in the class dictionary for one of its '
+ 'parents). In the\n'
+ 'examples below, "the attribute" refers to the attribute '
+ 'whose name is\n'
+ "the key of the property in the owner class' "
+ '"__dict__".\n'
+ '\n'
+ 'object.__get__(self, instance, owner)\n'
+ '\n'
+ ' Called to get the attribute of the owner class (class '
+ 'attribute\n'
+ ' access) or of an instance of that class (instance '
+ 'attribute\n'
+ ' access). *owner* is always the owner class, while '
+ '*instance* is the\n'
+ ' instance that the attribute was accessed through, or '
+ '"None" when\n'
+ ' the attribute is accessed through the *owner*. This '
+ 'method should\n'
+ ' return the (computed) attribute value or raise an '
+ '"AttributeError"\n'
+ ' exception.\n'
+ '\n'
+ 'object.__set__(self, instance, value)\n'
+ '\n'
+ ' Called to set the attribute on an instance *instance* '
+ 'of the owner\n'
+ ' class to a new value, *value*.\n'
+ '\n'
+ 'object.__delete__(self, instance)\n'
+ '\n'
+ ' Called to delete the attribute on an instance '
+ '*instance* of the\n'
+ ' owner class.\n'
+ '\n'
+ '\n'
+ 'Invoking Descriptors\n'
+ '====================\n'
+ '\n'
+ 'In general, a descriptor is an object attribute with '
+ '"binding\n'
+ 'behavior", one whose attribute access has been '
+ 'overridden by methods\n'
+ 'in the descriptor protocol: "__get__()", "__set__()", '
+ 'and\n'
+ '"__delete__()". If any of those methods are defined for '
+ 'an object, it\n'
+ 'is said to be a descriptor.\n'
+ '\n'
+ 'The default behavior for attribute access is to get, '
+ 'set, or delete\n'
+ "the attribute from an object's dictionary. For instance, "
+ '"a.x" has a\n'
+ 'lookup chain starting with "a.__dict__[\'x\']", then\n'
+ '"type(a).__dict__[\'x\']", and continuing through the '
+ 'base classes of\n'
+ '"type(a)" excluding metaclasses.\n'
+ '\n'
+ 'However, if the looked-up value is an object defining '
+ 'one of the\n'
+ 'descriptor methods, then Python may override the default '
+ 'behavior and\n'
+ 'invoke the descriptor method instead. Where this occurs '
+ 'in the\n'
+ 'precedence chain depends on which descriptor methods '
+ 'were defined and\n'
+ 'how they were called. Note that descriptors are only '
+ 'invoked for new\n'
+ 'style objects or classes (ones that subclass "object()" '
+ 'or "type()").\n'
+ '\n'
+ 'The starting point for descriptor invocation is a '
+ 'binding, "a.x". How\n'
+ 'the arguments are assembled depends on "a":\n'
+ '\n'
+ 'Direct Call\n'
+ ' The simplest and least common call is when user code '
+ 'directly\n'
+ ' invokes a descriptor method: "x.__get__(a)".\n'
+ '\n'
+ 'Instance Binding\n'
+ ' If binding to a new-style object instance, "a.x" is '
+ 'transformed\n'
+ ' into the call: "type(a).__dict__[\'x\'].__get__(a, '
+ 'type(a))".\n'
+ '\n'
+ 'Class Binding\n'
+ ' If binding to a new-style class, "A.x" is transformed '
+ 'into the\n'
+ ' call: "A.__dict__[\'x\'].__get__(None, A)".\n'
+ '\n'
+ 'Super Binding\n'
+ ' If "a" is an instance of "super", then the binding '
+ '"super(B,\n'
+ ' obj).m()" searches "obj.__class__.__mro__" for the '
+ 'base class "A"\n'
+ ' immediately preceding "B" and then invokes the '
+ 'descriptor with the\n'
+ ' call: "A.__dict__[\'m\'].__get__(obj, '
+ 'obj.__class__)".\n'
+ '\n'
+ 'For instance bindings, the precedence of descriptor '
+ 'invocation depends\n'
+ 'on the which descriptor methods are defined. A '
+ 'descriptor can define\n'
+ 'any combination of "__get__()", "__set__()" and '
+ '"__delete__()". If it\n'
+ 'does not define "__get__()", then accessing the '
+ 'attribute will return\n'
+ 'the descriptor object itself unless there is a value in '
+ "the object's\n"
+ 'instance dictionary. If the descriptor defines '
+ '"__set__()" and/or\n'
+ '"__delete__()", it is a data descriptor; if it defines '
+ 'neither, it is\n'
+ 'a non-data descriptor. Normally, data descriptors '
+ 'define both\n'
+ '"__get__()" and "__set__()", while non-data descriptors '
+ 'have just the\n'
+ '"__get__()" method. Data descriptors with "__set__()" '
+ 'and "__get__()"\n'
+ 'defined always override a redefinition in an instance '
+ 'dictionary. In\n'
+ 'contrast, non-data descriptors can be overridden by '
+ 'instances.\n'
+ '\n'
+ 'Python methods (including "staticmethod()" and '
+ '"classmethod()") are\n'
+ 'implemented as non-data descriptors. Accordingly, '
+ 'instances can\n'
+ 'redefine and override methods. This allows individual '
+ 'instances to\n'
+ 'acquire behaviors that differ from other instances of '
+ 'the same class.\n'
+ '\n'
+ 'The "property()" function is implemented as a data '
+ 'descriptor.\n'
+ 'Accordingly, instances cannot override the behavior of a '
+ 'property.\n'
+ '\n'
+ '\n'
+ '__slots__\n'
+ '=========\n'
+ '\n'
+ 'By default, instances of both old and new-style classes '
+ 'have a\n'
+ 'dictionary for attribute storage. This wastes space for '
+ 'objects\n'
+ 'having very few instance variables. The space '
+ 'consumption can become\n'
+ 'acute when creating large numbers of instances.\n'
+ '\n'
+ 'The default can be overridden by defining *__slots__* in '
+ 'a new-style\n'
+ 'class definition. The *__slots__* declaration takes a '
+ 'sequence of\n'
+ 'instance variables and reserves just enough space in '
+ 'each instance to\n'
+ 'hold a value for each variable. Space is saved because '
+ '*__dict__* is\n'
+ 'not created for each instance.\n'
+ '\n'
+ '__slots__\n'
+ '\n'
+ ' This class variable can be assigned a string, '
+ 'iterable, or sequence\n'
+ ' of strings with variable names used by instances. If '
+ 'defined in a\n'
+ ' new-style class, *__slots__* reserves space for the '
+ 'declared\n'
+ ' variables and prevents the automatic creation of '
+ '*__dict__* and\n'
+ ' *__weakref__* for each instance.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ 'Notes on using *__slots__*\n'
+ '\n'
+ '* When inheriting from a class without *__slots__*, the '
+ '*__dict__*\n'
+ ' attribute of that class will always be accessible, so '
+ 'a *__slots__*\n'
+ ' definition in the subclass is meaningless.\n'
+ '\n'
+ '* Without a *__dict__* variable, instances cannot be '
+ 'assigned new\n'
+ ' variables not listed in the *__slots__* definition. '
+ 'Attempts to\n'
+ ' assign to an unlisted variable name raises '
+ '"AttributeError". If\n'
+ ' dynamic assignment of new variables is desired, then '
+ 'add\n'
+ ' "\'__dict__\'" to the sequence of strings in the '
+ '*__slots__*\n'
+ ' declaration.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, adding '
+ '"\'__dict__\'" to the\n'
+ ' *__slots__* declaration would not enable the '
+ 'assignment of new\n'
+ ' attributes not specifically listed in the sequence of '
+ 'instance\n'
+ ' variable names.\n'
+ '\n'
+ '* Without a *__weakref__* variable for each instance, '
+ 'classes\n'
+ ' defining *__slots__* do not support weak references to '
+ 'its\n'
+ ' instances. If weak reference support is needed, then '
+ 'add\n'
+ ' "\'__weakref__\'" to the sequence of strings in the '
+ '*__slots__*\n'
+ ' declaration.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, adding '
+ '"\'__weakref__\'" to the\n'
+ ' *__slots__* declaration would not enable support for '
+ 'weak\n'
+ ' references.\n'
+ '\n'
+ '* *__slots__* are implemented at the class level by '
+ 'creating\n'
+ ' descriptors (Implementing Descriptors) for each '
+ 'variable name. As a\n'
+ ' result, class attributes cannot be used to set default '
+ 'values for\n'
+ ' instance variables defined by *__slots__*; otherwise, '
+ 'the class\n'
+ ' attribute would overwrite the descriptor assignment.\n'
+ '\n'
+ '* The action of a *__slots__* declaration is limited to '
+ 'the class\n'
+ ' where it is defined. As a result, subclasses will '
+ 'have a *__dict__*\n'
+ ' unless they also define *__slots__* (which must only '
+ 'contain names\n'
+ ' of any *additional* slots).\n'
+ '\n'
+ '* If a class defines a slot also defined in a base '
+ 'class, the\n'
+ ' instance variable defined by the base class slot is '
+ 'inaccessible\n'
+ ' (except by retrieving its descriptor directly from the '
+ 'base class).\n'
+ ' This renders the meaning of the program undefined. In '
+ 'the future, a\n'
+ ' check may be added to prevent this.\n'
+ '\n'
+ '* Nonempty *__slots__* does not work for classes derived '
+ 'from\n'
+ ' "variable-length" built-in types such as "long", "str" '
+ 'and "tuple".\n'
+ '\n'
+ '* Any non-string iterable may be assigned to '
+ '*__slots__*. Mappings\n'
+ ' may also be used; however, in the future, special '
+ 'meaning may be\n'
+ ' assigned to the values corresponding to each key.\n'
+ '\n'
+ '* *__class__* assignment works only if both classes have '
+ 'the same\n'
+ ' *__slots__*.\n'
+ '\n'
+ ' Changed in version 2.6: Previously, *__class__* '
+ 'assignment raised an\n'
+ ' error if either new or old class had *__slots__*.\n',
+ 'attribute-references': '\n'
+ 'Attribute references\n'
+ '********************\n'
+ '\n'
+ 'An attribute reference is a primary followed by a '
+ 'period and a name:\n'
+ '\n'
+ ' attributeref ::= primary "." identifier\n'
+ '\n'
+ 'The primary must evaluate to an object of a type '
+ 'that supports\n'
+ 'attribute references, e.g., a module, list, or an '
+ 'instance. This\n'
+ 'object is then asked to produce the attribute whose '
+ 'name is the\n'
+ 'identifier. If this attribute is not available, the '
+ 'exception\n'
+ '"AttributeError" is raised. Otherwise, the type and '
+ 'value of the\n'
+ 'object produced is determined by the object. '
+ 'Multiple evaluations of\n'
+ 'the same attribute reference may yield different '
+ 'objects.\n',
+ 'augassign': '\n'
+ 'Augmented assignment statements\n'
+ '*******************************\n'
+ '\n'
+ 'Augmented assignment is the combination, in a single statement, '
+ 'of a\n'
+ 'binary operation and an assignment statement:\n'
+ '\n'
+ ' augmented_assignment_stmt ::= augtarget augop '
+ '(expression_list | yield_expression)\n'
+ ' augtarget ::= identifier | attributeref | '
+ 'subscription | slicing\n'
+ ' augop ::= "+=" | "-=" | "*=" | "/=" | '
+ '"//=" | "%=" | "**="\n'
+ ' | ">>=" | "<<=" | "&=" | "^=" | "|="\n'
+ '\n'
+ '(See section Primaries for the syntax definitions for the last '
+ 'three\n'
+ 'symbols.)\n'
+ '\n'
+ 'An augmented assignment evaluates the target (which, unlike '
+ 'normal\n'
+ 'assignment statements, cannot be an unpacking) and the '
+ 'expression\n'
+ 'list, performs the binary operation specific to the type of '
+ 'assignment\n'
+ 'on the two operands, and assigns the result to the original '
+ 'target.\n'
+ 'The target is only evaluated once.\n'
+ '\n'
+ 'An augmented assignment expression like "x += 1" can be '
+ 'rewritten as\n'
+ '"x = x + 1" to achieve a similar, but not exactly equal effect. '
+ 'In the\n'
+ 'augmented version, "x" is only evaluated once. Also, when '
+ 'possible,\n'
+ 'the actual operation is performed *in-place*, meaning that '
+ 'rather than\n'
+ 'creating a new object and assigning that to the target, the old '
+ 'object\n'
+ 'is modified instead.\n'
+ '\n'
+ 'With the exception of assigning to tuples and multiple targets '
+ 'in a\n'
+ 'single statement, the assignment done by augmented assignment\n'
+ 'statements is handled the same way as normal assignments. '
+ 'Similarly,\n'
+ 'with the exception of the possible *in-place* behavior, the '
+ 'binary\n'
+ 'operation performed by augmented assignment is the same as the '
+ 'normal\n'
+ 'binary operations.\n'
+ '\n'
+ 'For targets which are attribute references, the same caveat '
+ 'about\n'
+ 'class and instance attributes applies as for regular '
+ 'assignments.\n',
+ 'binary': '\n'
+ 'Binary arithmetic operations\n'
+ '****************************\n'
+ '\n'
+ 'The binary arithmetic operations have the conventional priority\n'
+ 'levels. Note that some of these operations also apply to certain '
+ 'non-\n'
+ 'numeric types. Apart from the power operator, there are only two\n'
+ 'levels, one for multiplicative operators and one for additive\n'
+ 'operators:\n'
+ '\n'
+ ' m_expr ::= u_expr | m_expr "*" u_expr | m_expr "//" u_expr | '
+ 'm_expr "/" u_expr\n'
+ ' | m_expr "%" u_expr\n'
+ ' a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr\n'
+ '\n'
+ 'The "*" (multiplication) operator yields the product of its '
+ 'arguments.\n'
+ 'The arguments must either both be numbers, or one argument must be '
+ 'an\n'
+ 'integer (plain or long) and the other must be a sequence. In the\n'
+ 'former case, the numbers are converted to a common type and then\n'
+ 'multiplied together. In the latter case, sequence repetition is\n'
+ 'performed; a negative repetition factor yields an empty sequence.\n'
+ '\n'
+ 'The "/" (division) and "//" (floor division) operators yield the\n'
+ 'quotient of their arguments. The numeric arguments are first\n'
+ 'converted to a common type. Plain or long integer division yields '
+ 'an\n'
+ 'integer of the same type; the result is that of mathematical '
+ 'division\n'
+ "with the 'floor' function applied to the result. Division by zero\n"
+ 'raises the "ZeroDivisionError" exception.\n'
+ '\n'
+ 'The "%" (modulo) operator yields the remainder from the division '
+ 'of\n'
+ 'the first argument by the second. The numeric arguments are '
+ 'first\n'
+ 'converted to a common type. A zero right argument raises the\n'
+ '"ZeroDivisionError" exception. The arguments may be floating '
+ 'point\n'
+ 'numbers, e.g., "3.14%0.7" equals "0.34" (since "3.14" equals '
+ '"4*0.7 +\n'
+ '0.34".) The modulo operator always yields a result with the same '
+ 'sign\n'
+ 'as its second operand (or zero); the absolute value of the result '
+ 'is\n'
+ 'strictly smaller than the absolute value of the second operand '
+ '[2].\n'
+ '\n'
+ 'The integer division and modulo operators are connected by the\n'
+ 'following identity: "x == (x/y)*y + (x%y)". Integer division and\n'
+ 'modulo are also connected with the built-in function "divmod()":\n'
+ '"divmod(x, y) == (x/y, x%y)". These identities don\'t hold for\n'
+ 'floating point numbers; there similar identities hold '
+ 'approximately\n'
+ 'where "x/y" is replaced by "floor(x/y)" or "floor(x/y) - 1" [3].\n'
+ '\n'
+ 'In addition to performing the modulo operation on numbers, the '
+ '"%"\n'
+ 'operator is also overloaded by string and unicode objects to '
+ 'perform\n'
+ 'string formatting (also known as interpolation). The syntax for '
+ 'string\n'
+ 'formatting is described in the Python Library Reference, section\n'
+ 'String Formatting Operations.\n'
+ '\n'
+ 'Deprecated since version 2.3: The floor division operator, the '
+ 'modulo\n'
+ 'operator, and the "divmod()" function are no longer defined for\n'
+ 'complex numbers. Instead, convert to a floating point number '
+ 'using\n'
+ 'the "abs()" function if appropriate.\n'
+ '\n'
+ 'The "+" (addition) operator yields the sum of its arguments. The\n'
+ 'arguments must either both be numbers or both sequences of the '
+ 'same\n'
+ 'type. In the former case, the numbers are converted to a common '
+ 'type\n'
+ 'and then added together. In the latter case, the sequences are\n'
+ 'concatenated.\n'
+ '\n'
+ 'The "-" (subtraction) operator yields the difference of its '
+ 'arguments.\n'
+ 'The numeric arguments are first converted to a common type.\n',
+ 'bitwise': '\n'
+ 'Binary bitwise operations\n'
+ '*************************\n'
+ '\n'
+ 'Each of the three bitwise operations has a different priority '
+ 'level:\n'
+ '\n'
+ ' and_expr ::= shift_expr | and_expr "&" shift_expr\n'
+ ' xor_expr ::= and_expr | xor_expr "^" and_expr\n'
+ ' or_expr ::= xor_expr | or_expr "|" xor_expr\n'
+ '\n'
+ 'The "&" operator yields the bitwise AND of its arguments, which '
+ 'must\n'
+ 'be plain or long integers. The arguments are converted to a '
+ 'common\n'
+ 'type.\n'
+ '\n'
+ 'The "^" operator yields the bitwise XOR (exclusive OR) of its\n'
+ 'arguments, which must be plain or long integers. The arguments '
+ 'are\n'
+ 'converted to a common type.\n'
+ '\n'
+ 'The "|" operator yields the bitwise (inclusive) OR of its '
+ 'arguments,\n'
+ 'which must be plain or long integers. The arguments are '
+ 'converted to\n'
+ 'a common type.\n',
+ 'bltin-code-objects': '\n'
+ 'Code Objects\n'
+ '************\n'
+ '\n'
+ 'Code objects are used by the implementation to '
+ 'represent "pseudo-\n'
+ 'compiled" executable Python code such as a function '
+ 'body. They differ\n'
+ "from function objects because they don't contain a "
+ 'reference to their\n'
+ 'global execution environment. Code objects are '
+ 'returned by the built-\n'
+ 'in "compile()" function and can be extracted from '
+ 'function objects\n'
+ 'through their "func_code" attribute. See also the '
+ '"code" module.\n'
+ '\n'
+ 'A code object can be executed or evaluated by passing '
+ 'it (instead of a\n'
+ 'source string) to the "exec" statement or the built-in '
+ '"eval()"\n'
+ 'function.\n'
+ '\n'
+ 'See The standard type hierarchy for more '
+ 'information.\n',
+ 'bltin-ellipsis-object': '\n'
+ 'The Ellipsis Object\n'
+ '*******************\n'
+ '\n'
+ 'This object is used by extended slice notation (see '
+ 'Slicings). It\n'
+ 'supports no special operations. There is exactly '
+ 'one ellipsis object,\n'
+ 'named "Ellipsis" (a built-in name).\n'
+ '\n'
+ 'It is written as "Ellipsis". When in a subscript, '
+ 'it can also be\n'
+ 'written as "...", for example "seq[...]".\n',
+ 'bltin-file-objects': '\n'
+ 'File Objects\n'
+ '************\n'
+ '\n'
+ 'File objects are implemented using C\'s "stdio" '
+ 'package and can be\n'
+ 'created with the built-in "open()" function. File '
+ 'objects are also\n'
+ 'returned by some other built-in functions and methods, '
+ 'such as\n'
+ '"os.popen()" and "os.fdopen()" and the "makefile()" '
+ 'method of socket\n'
+ 'objects. Temporary files can be created using the '
+ '"tempfile" module,\n'
+ 'and high-level file operations such as copying, '
+ 'moving, and deleting\n'
+ 'files and directories can be achieved with the '
+ '"shutil" module.\n'
+ '\n'
+ 'When a file operation fails for an I/O-related reason, '
+ 'the exception\n'
+ '"IOError" is raised. This includes situations where '
+ 'the operation is\n'
+ 'not defined for some reason, like "seek()" on a tty '
+ 'device or writing\n'
+ 'a file opened for reading.\n'
+ '\n'
+ 'Files have the following methods:\n'
+ '\n'
+ 'file.close()\n'
+ '\n'
+ ' Close the file. A closed file cannot be read or '
+ 'written any more.\n'
+ ' Any operation which requires that the file be open '
+ 'will raise a\n'
+ ' "ValueError" after the file has been closed. '
+ 'Calling "close()"\n'
+ ' more than once is allowed.\n'
+ '\n'
+ ' As of Python 2.5, you can avoid having to call this '
+ 'method\n'
+ ' explicitly if you use the "with" statement. For '
+ 'example, the\n'
+ ' following code will automatically close *f* when '
+ 'the "with" block\n'
+ ' is exited:\n'
+ '\n'
+ ' from __future__ import with_statement # This '
+ "isn't required in Python 2.6\n"
+ '\n'
+ ' with open("hello.txt") as f:\n'
+ ' for line in f:\n'
+ ' print line,\n'
+ '\n'
+ ' In older versions of Python, you would have needed '
+ 'to do this to\n'
+ ' get the same effect:\n'
+ '\n'
+ ' f = open("hello.txt")\n'
+ ' try:\n'
+ ' for line in f:\n'
+ ' print line,\n'
+ ' finally:\n'
+ ' f.close()\n'
+ '\n'
+ ' Note: Not all "file-like" types in Python support '
+ 'use as a\n'
+ ' context manager for the "with" statement. If '
+ 'your code is\n'
+ ' intended to work with any file-like object, you '
+ 'can use the\n'
+ ' function "contextlib.closing()" instead of using '
+ 'the object\n'
+ ' directly.\n'
+ '\n'
+ 'file.flush()\n'
+ '\n'
+ ' Flush the internal buffer, like "stdio"\'s '
+ '"fflush()". This may be\n'
+ ' a no-op on some file-like objects.\n'
+ '\n'
+ ' Note: "flush()" does not necessarily write the '
+ "file's data to\n"
+ ' disk. Use "flush()" followed by "os.fsync()" to '
+ 'ensure this\n'
+ ' behavior.\n'
+ '\n'
+ 'file.fileno()\n'
+ '\n'
+ ' Return the integer "file descriptor" that is used '
+ 'by the underlying\n'
+ ' implementation to request I/O operations from the '
+ 'operating system.\n'
+ ' This can be useful for other, lower level '
+ 'interfaces that use file\n'
+ ' descriptors, such as the "fcntl" module or '
+ '"os.read()" and friends.\n'
+ '\n'
+ ' Note: File-like objects which do not have a real '
+ 'file descriptor\n'
+ ' should *not* provide this method!\n'
+ '\n'
+ 'file.isatty()\n'
+ '\n'
+ ' Return "True" if the file is connected to a '
+ 'tty(-like) device, else\n'
+ ' "False".\n'
+ '\n'
+ ' Note: If a file-like object is not associated with '
+ 'a real file,\n'
+ ' this method should *not* be implemented.\n'
+ '\n'
+ 'file.next()\n'
+ '\n'
+ ' A file object is its own iterator, for example '
+ '"iter(f)" returns\n'
+ ' *f* (unless *f* is closed). When a file is used as '
+ 'an iterator,\n'
+ ' typically in a "for" loop (for example, "for line '
+ 'in f: print\n'
+ ' line.strip()"), the "next()" method is called '
+ 'repeatedly. This\n'
+ ' method returns the next input line, or raises '
+ '"StopIteration" when\n'
+ ' EOF is hit when the file is open for reading '
+ '(behavior is undefined\n'
+ ' when the file is open for writing). In order to '
+ 'make a "for" loop\n'
+ ' the most efficient way of looping over the lines of '
+ 'a file (a very\n'
+ ' common operation), the "next()" method uses a '
+ 'hidden read-ahead\n'
+ ' buffer. As a consequence of using a read-ahead '
+ 'buffer, combining\n'
+ ' "next()" with other file methods (like '
+ '"readline()") does not work\n'
+ ' right. However, using "seek()" to reposition the '
+ 'file to an\n'
+ ' absolute position will flush the read-ahead '
+ 'buffer.\n'
+ '\n'
+ ' New in version 2.3.\n'
+ '\n'
+ 'file.read([size])\n'
+ '\n'
+ ' Read at most *size* bytes from the file (less if '
+ 'the read hits EOF\n'
+ ' before obtaining *size* bytes). If the *size* '
+ 'argument is negative\n'
+ ' or omitted, read all data until EOF is reached. '
+ 'The bytes are\n'
+ ' returned as a string object. An empty string is '
+ 'returned when EOF\n'
+ ' is encountered immediately. (For certain files, '
+ 'like ttys, it\n'
+ ' makes sense to continue reading after an EOF is '
+ 'hit.) Note that\n'
+ ' this method may call the underlying C function '
+ '"fread()" more than\n'
+ ' once in an effort to acquire as close to *size* '
+ 'bytes as possible.\n'
+ ' Also note that when in non-blocking mode, less data '
+ 'than was\n'
+ ' requested may be returned, even if no *size* '
+ 'parameter was given.\n'
+ '\n'
+ ' Note: This function is simply a wrapper for the '
+ 'underlying\n'
+ ' "fread()" C function, and will behave the same in '
+ 'corner cases,\n'
+ ' such as whether the EOF value is cached.\n'
+ '\n'
+ 'file.readline([size])\n'
+ '\n'
+ ' Read one entire line from the file. A trailing '
+ 'newline character\n'
+ ' is kept in the string (but may be absent when a '
+ 'file ends with an\n'
+ ' incomplete line). [6] If the *size* argument is '
+ 'present and non-\n'
+ ' negative, it is a maximum byte count (including the '
+ 'trailing\n'
+ ' newline) and an incomplete line may be returned. '
+ 'When *size* is not\n'
+ ' 0, an empty string is returned *only* when EOF is '
+ 'encountered\n'
+ ' immediately.\n'
+ '\n'
+ ' Note: Unlike "stdio"\'s "fgets()", the returned '
+ 'string contains\n'
+ ' null characters ("\'\\0\'") if they occurred in '
+ 'the input.\n'
+ '\n'
+ 'file.readlines([sizehint])\n'
+ '\n'
+ ' Read until EOF using "readline()" and return a list '
+ 'containing the\n'
+ ' lines thus read. If the optional *sizehint* '
+ 'argument is present,\n'
+ ' instead of reading up to EOF, whole lines totalling '
+ 'approximately\n'
+ ' *sizehint* bytes (possibly after rounding up to an '
+ 'internal buffer\n'
+ ' size) are read. Objects implementing a file-like '
+ 'interface may\n'
+ ' choose to ignore *sizehint* if it cannot be '
+ 'implemented, or cannot\n'
+ ' be implemented efficiently.\n'
+ '\n'
+ 'file.xreadlines()\n'
+ '\n'
+ ' This method returns the same thing as "iter(f)".\n'
+ '\n'
+ ' New in version 2.1.\n'
+ '\n'
+ ' Deprecated since version 2.3: Use "for line in '
+ 'file" instead.\n'
+ '\n'
+ 'file.seek(offset[, whence])\n'
+ '\n'
+ ' Set the file\'s current position, like "stdio"\'s '
+ '"fseek()". The\n'
+ ' *whence* argument is optional and defaults to '
+ '"os.SEEK_SET" or "0"\n'
+ ' (absolute file positioning); other values are '
+ '"os.SEEK_CUR" or "1"\n'
+ ' (seek relative to the current position) and '
+ '"os.SEEK_END" or "2"\n'
+ " (seek relative to the file's end). There is no "
+ 'return value.\n'
+ '\n'
+ ' For example, "f.seek(2, os.SEEK_CUR)" advances the '
+ 'position by two\n'
+ ' and "f.seek(-3, os.SEEK_END)" sets the position to '
+ 'the third to\n'
+ ' last.\n'
+ '\n'
+ ' Note that if the file is opened for appending (mode '
+ '"\'a\'" or\n'
+ ' "\'a+\'"), any "seek()" operations will be undone '
+ 'at the next write.\n'
+ ' If the file is only opened for writing in append '
+ 'mode (mode "\'a\'"),\n'
+ ' this method is essentially a no-op, but it remains '
+ 'useful for files\n'
+ ' opened in append mode with reading enabled (mode '
+ '"\'a+\'"). If the\n'
+ ' file is opened in text mode (without "\'b\'"), only '
+ 'offsets returned\n'
+ ' by "tell()" are legal. Use of other offsets causes '
+ 'undefined\n'
+ ' behavior.\n'
+ '\n'
+ ' Note that not all file objects are seekable.\n'
+ '\n'
+ ' Changed in version 2.6: Passing float values as '
+ 'offset has been\n'
+ ' deprecated.\n'
+ '\n'
+ 'file.tell()\n'
+ '\n'
+ " Return the file's current position, like "
+ '"stdio"\'s "ftell()".\n'
+ '\n'
+ ' Note: On Windows, "tell()" can return illegal '
+ 'values (after an\n'
+ ' "fgets()") when reading files with Unix-style '
+ 'line-endings. Use\n'
+ ' binary mode ("\'rb\'") to circumvent this '
+ 'problem.\n'
+ '\n'
+ 'file.truncate([size])\n'
+ '\n'
+ " Truncate the file's size. If the optional *size* "
+ 'argument is\n'
+ ' present, the file is truncated to (at most) that '
+ 'size. The size\n'
+ ' defaults to the current position. The current file '
+ 'position is not\n'
+ ' changed. Note that if a specified size exceeds the '
+ "file's current\n"
+ ' size, the result is platform-dependent: '
+ 'possibilities include that\n'
+ ' the file may remain unchanged, increase to the '
+ 'specified size as if\n'
+ ' zero-filled, or increase to the specified size with '
+ 'undefined new\n'
+ ' content. Availability: Windows, many Unix '
+ 'variants.\n'
+ '\n'
+ 'file.write(str)\n'
+ '\n'
+ ' Write a string to the file. There is no return '
+ 'value. Due to\n'
+ ' buffering, the string may not actually show up in '
+ 'the file until\n'
+ ' the "flush()" or "close()" method is called.\n'
+ '\n'
+ 'file.writelines(sequence)\n'
+ '\n'
+ ' Write a sequence of strings to the file. The '
+ 'sequence can be any\n'
+ ' iterable object producing strings, typically a list '
+ 'of strings.\n'
+ ' There is no return value. (The name is intended to '
+ 'match\n'
+ ' "readlines()"; "writelines()" does not add line '
+ 'separators.)\n'
+ '\n'
+ 'Files support the iterator protocol. Each iteration '
+ 'returns the same\n'
+ 'result as "readline()", and iteration ends when the '
+ '"readline()"\n'
+ 'method returns an empty string.\n'
+ '\n'
+ 'File objects also offer a number of other interesting '
+ 'attributes.\n'
+ 'These are not required for file-like objects, but '
+ 'should be\n'
+ 'implemented if they make sense for the particular '
+ 'object.\n'
+ '\n'
+ 'file.closed\n'
+ '\n'
+ ' bool indicating the current state of the file '
+ 'object. This is a\n'
+ ' read-only attribute; the "close()" method changes '
+ 'the value. It may\n'
+ ' not be available on all file-like objects.\n'
+ '\n'
+ 'file.encoding\n'
+ '\n'
+ ' The encoding that this file uses. When Unicode '
+ 'strings are written\n'
+ ' to a file, they will be converted to byte strings '
+ 'using this\n'
+ ' encoding. In addition, when the file is connected '
+ 'to a terminal,\n'
+ ' the attribute gives the encoding that the terminal '
+ 'is likely to use\n'
+ ' (that information might be incorrect if the user '
+ 'has misconfigured\n'
+ ' the terminal). The attribute is read-only and may '
+ 'not be present\n'
+ ' on all file-like objects. It may also be "None", in '
+ 'which case the\n'
+ ' file uses the system default encoding for '
+ 'converting Unicode\n'
+ ' strings.\n'
+ '\n'
+ ' New in version 2.3.\n'
+ '\n'
+ 'file.errors\n'
+ '\n'
+ ' The Unicode error handler used along with the '
+ 'encoding.\n'
+ '\n'
+ ' New in version 2.6.\n'
+ '\n'
+ 'file.mode\n'
+ '\n'
+ ' The I/O mode for the file. If the file was created '
+ 'using the\n'
+ ' "open()" built-in function, this will be the value '
+ 'of the *mode*\n'
+ ' parameter. This is a read-only attribute and may '
+ 'not be present on\n'
+ ' all file-like objects.\n'
+ '\n'
+ 'file.name\n'
+ '\n'
+ ' If the file object was created using "open()", the '
+ 'name of the\n'
+ ' file. Otherwise, some string that indicates the '
+ 'source of the file\n'
+ ' object, of the form "<...>". This is a read-only '
+ 'attribute and may\n'
+ ' not be present on all file-like objects.\n'
+ '\n'
+ 'file.newlines\n'
+ '\n'
+ ' If Python was built with *universal newlines* '
+ 'enabled (the default)\n'
+ ' this read-only attribute exists, and for files '
+ 'opened in universal\n'
+ ' newline read mode it keeps track of the types of '
+ 'newlines\n'
+ ' encountered while reading the file. The values it '
+ 'can take are\n'
+ ' "\'\\r\'", "\'\\n\'", "\'\\r\\n\'", "None" '
+ '(unknown, no newlines read yet) or\n'
+ ' a tuple containing all the newline types seen, to '
+ 'indicate that\n'
+ ' multiple newline conventions were encountered. For '
+ 'files not opened\n'
+ ' in universal newlines read mode the value of this '
+ 'attribute will be\n'
+ ' "None".\n'
+ '\n'
+ 'file.softspace\n'
+ '\n'
+ ' Boolean that indicates whether a space character '
+ 'needs to be\n'
+ ' printed before another value when using the "print" '
+ 'statement.\n'
+ ' Classes that are trying to simulate a file object '
+ 'should also have\n'
+ ' a writable "softspace" attribute, which should be '
+ 'initialized to\n'
+ ' zero. This will be automatic for most classes '
+ 'implemented in\n'
+ ' Python (care may be needed for objects that '
+ 'override attribute\n'
+ ' access); types implemented in C will have to '
+ 'provide a writable\n'
+ ' "softspace" attribute.\n'
+ '\n'
+ ' Note: This attribute is not used to control the '
+ '"print"\n'
+ ' statement, but to allow the implementation of '
+ '"print" to keep\n'
+ ' track of its internal state.\n',
+ 'bltin-null-object': '\n'
+ 'The Null Object\n'
+ '***************\n'
+ '\n'
+ "This object is returned by functions that don't "
+ 'explicitly return a\n'
+ 'value. It supports no special operations. There is '
+ 'exactly one null\n'
+ 'object, named "None" (a built-in name).\n'
+ '\n'
+ 'It is written as "None".\n',
+ 'bltin-type-objects': '\n'
+ 'Type Objects\n'
+ '************\n'
+ '\n'
+ 'Type objects represent the various object types. An '
+ "object's type is\n"
+ 'accessed by the built-in function "type()". There are '
+ 'no special\n'
+ 'operations on types. The standard module "types" '
+ 'defines names for\n'
+ 'all standard built-in types.\n'
+ '\n'
+ 'Types are written like this: "<type \'int\'>".\n',
+ 'booleans': '\n'
+ 'Boolean operations\n'
+ '******************\n'
+ '\n'
+ ' or_test ::= and_test | or_test "or" and_test\n'
+ ' and_test ::= not_test | and_test "and" not_test\n'
+ ' not_test ::= comparison | "not" not_test\n'
+ '\n'
+ 'In the context of Boolean operations, and also when expressions '
+ 'are\n'
+ 'used by control flow statements, the following values are '
+ 'interpreted\n'
+ 'as false: "False", "None", numeric zero of all types, and empty\n'
+ 'strings and containers (including strings, tuples, lists,\n'
+ 'dictionaries, sets and frozensets). All other values are '
+ 'interpreted\n'
+ 'as true. (See the "__nonzero__()" special method for a way to '
+ 'change\n'
+ 'this.)\n'
+ '\n'
+ 'The operator "not" yields "True" if its argument is false, '
+ '"False"\n'
+ 'otherwise.\n'
+ '\n'
+ 'The expression "x and y" first evaluates *x*; if *x* is false, '
+ 'its\n'
+ 'value is returned; otherwise, *y* is evaluated and the resulting '
+ 'value\n'
+ 'is returned.\n'
+ '\n'
+ 'The expression "x or y" first evaluates *x*; if *x* is true, its '
+ 'value\n'
+ 'is returned; otherwise, *y* is evaluated and the resulting value '
+ 'is\n'
+ 'returned.\n'
+ '\n'
+ '(Note that neither "and" nor "or" restrict the value and type '
+ 'they\n'
+ 'return to "False" and "True", but rather return the last '
+ 'evaluated\n'
+ 'argument. This is sometimes useful, e.g., if "s" is a string '
+ 'that\n'
+ 'should be replaced by a default value if it is empty, the '
+ 'expression\n'
+ '"s or \'foo\'" yields the desired value. Because "not" has to '
+ 'invent a\n'
+ 'value anyway, it does not bother to return a value of the same '
+ 'type as\n'
+ 'its argument, so e.g., "not \'foo\'" yields "False", not '
+ '"\'\'".)\n',
+ 'break': '\n'
+ 'The "break" statement\n'
+ '*********************\n'
+ '\n'
+ ' break_stmt ::= "break"\n'
+ '\n'
+ '"break" may only occur syntactically nested in a "for" or "while"\n'
+ 'loop, but not nested in a function or class definition within that\n'
+ 'loop.\n'
+ '\n'
+ 'It terminates the nearest enclosing loop, skipping the optional '
+ '"else"\n'
+ 'clause if the loop has one.\n'
+ '\n'
+ 'If a "for" loop is terminated by "break", the loop control target\n'
+ 'keeps its current value.\n'
+ '\n'
+ 'When "break" passes control out of a "try" statement with a '
+ '"finally"\n'
+ 'clause, that "finally" clause is executed before really leaving '
+ 'the\n'
+ 'loop.\n',
+ 'callable-types': '\n'
+ 'Emulating callable objects\n'
+ '**************************\n'
+ '\n'
+ 'object.__call__(self[, args...])\n'
+ '\n'
+ ' Called when the instance is "called" as a function; if '
+ 'this method\n'
+ ' is defined, "x(arg1, arg2, ...)" is a shorthand for\n'
+ ' "x.__call__(arg1, arg2, ...)".\n',
+ 'calls': '\n'
+ 'Calls\n'
+ '*****\n'
+ '\n'
+ 'A call calls a callable object (e.g., a *function*) with a '
+ 'possibly\n'
+ 'empty series of *arguments*:\n'
+ '\n'
+ ' call ::= primary "(" [argument_list [","]\n'
+ ' | expression genexpr_for] ")"\n'
+ ' argument_list ::= positional_arguments ["," '
+ 'keyword_arguments]\n'
+ ' ["," "*" expression] ["," '
+ 'keyword_arguments]\n'
+ ' ["," "**" expression]\n'
+ ' | keyword_arguments ["," "*" expression]\n'
+ ' ["," "**" expression]\n'
+ ' | "*" expression ["," keyword_arguments] ["," '
+ '"**" expression]\n'
+ ' | "**" expression\n'
+ ' positional_arguments ::= expression ("," expression)*\n'
+ ' keyword_arguments ::= keyword_item ("," keyword_item)*\n'
+ ' keyword_item ::= identifier "=" expression\n'
+ '\n'
+ 'A trailing comma may be present after the positional and keyword\n'
+ 'arguments but does not affect the semantics.\n'
+ '\n'
+ 'The primary must evaluate to a callable object (user-defined\n'
+ 'functions, built-in functions, methods of built-in objects, class\n'
+ 'objects, methods of class instances, and certain class instances\n'
+ 'themselves are callable; extensions may define additional callable\n'
+ 'object types). All argument expressions are evaluated before the '
+ 'call\n'
+ 'is attempted. Please refer to section Function definitions for '
+ 'the\n'
+ 'syntax of formal *parameter* lists.\n'
+ '\n'
+ 'If keyword arguments are present, they are first converted to\n'
+ 'positional arguments, as follows. First, a list of unfilled slots '
+ 'is\n'
+ 'created for the formal parameters. If there are N positional\n'
+ 'arguments, they are placed in the first N slots. Next, for each\n'
+ 'keyword argument, the identifier is used to determine the\n'
+ 'corresponding slot (if the identifier is the same as the first '
+ 'formal\n'
+ 'parameter name, the first slot is used, and so on). If the slot '
+ 'is\n'
+ 'already filled, a "TypeError" exception is raised. Otherwise, the\n'
+ 'value of the argument is placed in the slot, filling it (even if '
+ 'the\n'
+ 'expression is "None", it fills the slot). When all arguments have\n'
+ 'been processed, the slots that are still unfilled are filled with '
+ 'the\n'
+ 'corresponding default value from the function definition. '
+ '(Default\n'
+ 'values are calculated, once, when the function is defined; thus, a\n'
+ 'mutable object such as a list or dictionary used as default value '
+ 'will\n'
+ "be shared by all calls that don't specify an argument value for "
+ 'the\n'
+ 'corresponding slot; this should usually be avoided.) If there are '
+ 'any\n'
+ 'unfilled slots for which no default value is specified, a '
+ '"TypeError"\n'
+ 'exception is raised. Otherwise, the list of filled slots is used '
+ 'as\n'
+ 'the argument list for the call.\n'
+ '\n'
+ '**CPython implementation detail:** An implementation may provide\n'
+ 'built-in functions whose positional parameters do not have names, '
+ 'even\n'
+ "if they are 'named' for the purpose of documentation, and which\n"
+ 'therefore cannot be supplied by keyword. In CPython, this is the '
+ 'case\n'
+ 'for functions implemented in C that use "PyArg_ParseTuple()" to '
+ 'parse\n'
+ 'their arguments.\n'
+ '\n'
+ 'If there are more positional arguments than there are formal '
+ 'parameter\n'
+ 'slots, a "TypeError" exception is raised, unless a formal '
+ 'parameter\n'
+ 'using the syntax "*identifier" is present; in this case, that '
+ 'formal\n'
+ 'parameter receives a tuple containing the excess positional '
+ 'arguments\n'
+ '(or an empty tuple if there were no excess positional arguments).\n'
+ '\n'
+ 'If any keyword argument does not correspond to a formal parameter\n'
+ 'name, a "TypeError" exception is raised, unless a formal parameter\n'
+ 'using the syntax "**identifier" is present; in this case, that '
+ 'formal\n'
+ 'parameter receives a dictionary containing the excess keyword\n'
+ 'arguments (using the keywords as keys and the argument values as\n'
+ 'corresponding values), or a (new) empty dictionary if there were '
+ 'no\n'
+ 'excess keyword arguments.\n'
+ '\n'
+ 'If the syntax "*expression" appears in the function call, '
+ '"expression"\n'
+ 'must evaluate to an iterable. Elements from this iterable are '
+ 'treated\n'
+ 'as if they were additional positional arguments; if there are\n'
+ 'positional arguments *x1*, ..., *xN*, and "expression" evaluates to '
+ 'a\n'
+ 'sequence *y1*, ..., *yM*, this is equivalent to a call with M+N\n'
+ 'positional arguments *x1*, ..., *xN*, *y1*, ..., *yM*.\n'
+ '\n'
+ 'A consequence of this is that although the "*expression" syntax '
+ 'may\n'
+ 'appear *after* some keyword arguments, it is processed *before* '
+ 'the\n'
+ 'keyword arguments (and the "**expression" argument, if any -- see\n'
+ 'below). So:\n'
+ '\n'
+ ' >>> def f(a, b):\n'
+ ' ... print a, b\n'
+ ' ...\n'
+ ' >>> f(b=1, *(2,))\n'
+ ' 2 1\n'
+ ' >>> f(a=1, *(2,))\n'
+ ' Traceback (most recent call last):\n'
+ ' File "<stdin>", line 1, in <module>\n'
+ " TypeError: f() got multiple values for keyword argument 'a'\n"
+ ' >>> f(1, *(2,))\n'
+ ' 1 2\n'
+ '\n'
+ 'It is unusual for both keyword arguments and the "*expression" '
+ 'syntax\n'
+ 'to be used in the same call, so in practice this confusion does '
+ 'not\n'
+ 'arise.\n'
+ '\n'
+ 'If the syntax "**expression" appears in the function call,\n'
+ '"expression" must evaluate to a mapping, the contents of which are\n'
+ 'treated as additional keyword arguments. In the case of a keyword\n'
+ 'appearing in both "expression" and as an explicit keyword argument, '
+ 'a\n'
+ '"TypeError" exception is raised.\n'
+ '\n'
+ 'Formal parameters using the syntax "*identifier" or "**identifier"\n'
+ 'cannot be used as positional argument slots or as keyword argument\n'
+ 'names. Formal parameters using the syntax "(sublist)" cannot be '
+ 'used\n'
+ 'as keyword argument names; the outermost sublist corresponds to a\n'
+ 'single unnamed argument slot, and the argument value is assigned '
+ 'to\n'
+ 'the sublist using the usual tuple assignment rules after all other\n'
+ 'parameter processing is done.\n'
+ '\n'
+ 'A call always returns some value, possibly "None", unless it raises '
+ 'an\n'
+ 'exception. How this value is computed depends on the type of the\n'
+ 'callable object.\n'
+ '\n'
+ 'If it is---\n'
+ '\n'
+ 'a user-defined function:\n'
+ ' The code block for the function is executed, passing it the\n'
+ ' argument list. The first thing the code block will do is bind '
+ 'the\n'
+ ' formal parameters to the arguments; this is described in '
+ 'section\n'
+ ' Function definitions. When the code block executes a "return"\n'
+ ' statement, this specifies the return value of the function '
+ 'call.\n'
+ '\n'
+ 'a built-in function or method:\n'
+ ' The result is up to the interpreter; see Built-in Functions for '
+ 'the\n'
+ ' descriptions of built-in functions and methods.\n'
+ '\n'
+ 'a class object:\n'
+ ' A new instance of that class is returned.\n'
+ '\n'
+ 'a class instance method:\n'
+ ' The corresponding user-defined function is called, with an '
+ 'argument\n'
+ ' list that is one longer than the argument list of the call: the\n'
+ ' instance becomes the first argument.\n'
+ '\n'
+ 'a class instance:\n'
+ ' The class must define a "__call__()" method; the effect is then '
+ 'the\n'
+ ' same as if that method was called.\n',
+ 'class': '\n'
+ 'Class definitions\n'
+ '*****************\n'
+ '\n'
+ 'A class definition defines a class object (see section The '
+ 'standard\n'
+ 'type hierarchy):\n'
+ '\n'
+ ' classdef ::= "class" classname [inheritance] ":" suite\n'
+ ' inheritance ::= "(" [expression_list] ")"\n'
+ ' classname ::= identifier\n'
+ '\n'
+ 'A class definition is an executable statement. It first evaluates '
+ 'the\n'
+ 'inheritance list, if present. Each item in the inheritance list\n'
+ 'should evaluate to a class object or class type which allows\n'
+ "subclassing. The class's suite is then executed in a new "
+ 'execution\n'
+ 'frame (see section Naming and binding), using a newly created '
+ 'local\n'
+ 'namespace and the original global namespace. (Usually, the suite\n'
+ "contains only function definitions.) When the class's suite "
+ 'finishes\n'
+ 'execution, its execution frame is discarded but its local namespace '
+ 'is\n'
+ 'saved. [4] A class object is then created using the inheritance '
+ 'list\n'
+ 'for the base classes and the saved local namespace for the '
+ 'attribute\n'
+ 'dictionary. The class name is bound to this class object in the\n'
+ 'original local namespace.\n'
+ '\n'
+ "**Programmer's note:** Variables defined in the class definition "
+ 'are\n'
+ 'class variables; they are shared by all instances. To create '
+ 'instance\n'
+ 'variables, they can be set in a method with "self.name = value". '
+ 'Both\n'
+ 'class and instance variables are accessible through the notation\n'
+ '""self.name"", and an instance variable hides a class variable '
+ 'with\n'
+ 'the same name when accessed in this way. Class variables can be '
+ 'used\n'
+ 'as defaults for instance variables, but using mutable values there '
+ 'can\n'
+ 'lead to unexpected results. For *new-style class*es, descriptors '
+ 'can\n'
+ 'be used to create instance variables with different implementation\n'
+ 'details.\n'
+ '\n'
+ 'Class definitions, like function definitions, may be wrapped by one '
+ 'or\n'
+ 'more *decorator* expressions. The evaluation rules for the '
+ 'decorator\n'
+ 'expressions are the same as for functions. The result must be a '
+ 'class\n'
+ 'object, which is then bound to the class name.\n'
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ '[1] The exception is propagated to the invocation stack unless\n'
+ ' there is a "finally" clause which happens to raise another\n'
+ ' exception. That new exception causes the old one to be lost.\n'
+ '\n'
+ '[2] Currently, control "flows off the end" except in the case of\n'
+ ' an exception or the execution of a "return", "continue", or\n'
+ ' "break" statement.\n'
+ '\n'
+ '[3] A string literal appearing as the first statement in the\n'
+ ' function body is transformed into the function\'s "__doc__"\n'
+ " attribute and therefore the function's *docstring*.\n"
+ '\n'
+ '[4] A string literal appearing as the first statement in the class\n'
+ ' body is transformed into the namespace\'s "__doc__" item and\n'
+ " therefore the class's *docstring*.\n",
+ 'comparisons': '\n'
+ 'Comparisons\n'
+ '***********\n'
+ '\n'
+ 'Unlike C, all comparison operations in Python have the same '
+ 'priority,\n'
+ 'which is lower than that of any arithmetic, shifting or '
+ 'bitwise\n'
+ 'operation. Also unlike C, expressions like "a < b < c" have '
+ 'the\n'
+ 'interpretation that is conventional in mathematics:\n'
+ '\n'
+ ' comparison ::= or_expr ( comp_operator or_expr )*\n'
+ ' comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "<>" | '
+ '"!="\n'
+ ' | "is" ["not"] | ["not"] "in"\n'
+ '\n'
+ 'Comparisons yield boolean values: "True" or "False".\n'
+ '\n'
+ 'Comparisons can be chained arbitrarily, e.g., "x < y <= z" '
+ 'is\n'
+ 'equivalent to "x < y and y <= z", except that "y" is '
+ 'evaluated only\n'
+ 'once (but in both cases "z" is not evaluated at all when "x < '
+ 'y" is\n'
+ 'found to be false).\n'
+ '\n'
+ 'Formally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and '
+ '*op1*,\n'
+ '*op2*, ..., *opN* are comparison operators, then "a op1 b op2 '
+ 'c ... y\n'
+ 'opN z" is equivalent to "a op1 b and b op2 c and ... y opN '
+ 'z", except\n'
+ 'that each expression is evaluated at most once.\n'
+ '\n'
+ 'Note that "a op1 b op2 c" doesn\'t imply any kind of '
+ 'comparison between\n'
+ '*a* and *c*, so that, e.g., "x < y > z" is perfectly legal '
+ '(though\n'
+ 'perhaps not pretty).\n'
+ '\n'
+ 'The forms "<>" and "!=" are equivalent; for consistency with '
+ 'C, "!="\n'
+ 'is preferred; where "!=" is mentioned below "<>" is also '
+ 'accepted.\n'
+ 'The "<>" spelling is considered obsolescent.\n'
+ '\n'
+ '\n'
+ 'Value comparisons\n'
+ '=================\n'
+ '\n'
+ 'The operators "<", ">", "==", ">=", "<=", and "!=" compare '
+ 'the values\n'
+ 'of two objects. The objects do not need to have the same '
+ 'type.\n'
+ '\n'
+ 'Chapter Objects, values and types states that objects have a '
+ 'value (in\n'
+ 'addition to type and identity). The value of an object is a '
+ 'rather\n'
+ 'abstract notion in Python: For example, there is no canonical '
+ 'access\n'
+ "method for an object's value. Also, there is no requirement "
+ 'that the\n'
+ 'value of an object should be constructed in a particular way, '
+ 'e.g.\n'
+ 'comprised of all its data attributes. Comparison operators '
+ 'implement a\n'
+ 'particular notion of what the value of an object is. One can '
+ 'think of\n'
+ 'them as defining the value of an object indirectly, by means '
+ 'of their\n'
+ 'comparison implementation.\n'
+ '\n'
+ 'Types can customize their comparison behavior by implementing '
+ 'a\n'
+ '"__cmp__()" method or *rich comparison methods* like '
+ '"__lt__()",\n'
+ 'described in Basic customization.\n'
+ '\n'
+ 'The default behavior for equality comparison ("==" and "!=") '
+ 'is based\n'
+ 'on the identity of the objects. Hence, equality comparison '
+ 'of\n'
+ 'instances with the same identity results in equality, and '
+ 'equality\n'
+ 'comparison of instances with different identities results in\n'
+ 'inequality. A motivation for this default behavior is the '
+ 'desire that\n'
+ 'all objects should be reflexive (i.e. "x is y" implies "x == '
+ 'y").\n'
+ '\n'
+ 'The default order comparison ("<", ">", "<=", and ">=") gives '
+ 'a\n'
+ 'consistent but arbitrary order.\n'
+ '\n'
+ '(This unusual definition of comparison was used to simplify '
+ 'the\n'
+ 'definition of operations like sorting and the "in" and "not '
+ 'in"\n'
+ 'operators. In the future, the comparison rules for objects '
+ 'of\n'
+ 'different types are likely to change.)\n'
+ '\n'
+ 'The behavior of the default equality comparison, that '
+ 'instances with\n'
+ 'different identities are always unequal, may be in contrast '
+ 'to what\n'
+ 'types will need that have a sensible definition of object '
+ 'value and\n'
+ 'value-based equality. Such types will need to customize '
+ 'their\n'
+ 'comparison behavior, and in fact, a number of built-in types '
+ 'have done\n'
+ 'that.\n'
+ '\n'
+ 'The following list describes the comparison behavior of the '
+ 'most\n'
+ 'important built-in types.\n'
+ '\n'
+ '* Numbers of built-in numeric types (Numeric Types --- int, '
+ 'float,\n'
+ ' long, complex) and of the standard library types\n'
+ ' "fractions.Fraction" and "decimal.Decimal" can be compared '
+ 'within\n'
+ ' and across their types, with the restriction that complex '
+ 'numbers do\n'
+ ' not support order comparison. Within the limits of the '
+ 'types\n'
+ ' involved, they compare mathematically (algorithmically) '
+ 'correct\n'
+ ' without loss of precision.\n'
+ '\n'
+ '* Strings (instances of "str" or "unicode") compare\n'
+ ' lexicographically using the numeric equivalents (the result '
+ 'of the\n'
+ ' built-in function "ord()") of their characters. [4] When '
+ 'comparing\n'
+ ' an 8-bit string and a Unicode string, the 8-bit string is '
+ 'converted\n'
+ ' to Unicode. If the conversion fails, the strings are '
+ 'considered\n'
+ ' unequal.\n'
+ '\n'
+ '* Instances of "tuple" or "list" can be compared only within '
+ 'each of\n'
+ ' their types. Equality comparison across these types '
+ 'results in\n'
+ ' unequality, and ordering comparison across these types '
+ 'gives an\n'
+ ' arbitrary order.\n'
+ '\n'
+ ' These sequences compare lexicographically using comparison '
+ 'of\n'
+ ' corresponding elements, whereby reflexivity of the elements '
+ 'is\n'
+ ' enforced.\n'
+ '\n'
+ ' In enforcing reflexivity of elements, the comparison of '
+ 'collections\n'
+ ' assumes that for a collection element "x", "x == x" is '
+ 'always true.\n'
+ ' Based on that assumption, element identity is compared '
+ 'first, and\n'
+ ' element comparison is performed only for distinct '
+ 'elements. This\n'
+ ' approach yields the same result as a strict element '
+ 'comparison\n'
+ ' would, if the compared elements are reflexive. For '
+ 'non-reflexive\n'
+ ' elements, the result is different than for strict element\n'
+ ' comparison.\n'
+ '\n'
+ ' Lexicographical comparison between built-in collections '
+ 'works as\n'
+ ' follows:\n'
+ '\n'
+ ' * For two collections to compare equal, they must be of the '
+ 'same\n'
+ ' type, have the same length, and each pair of '
+ 'corresponding\n'
+ ' elements must compare equal (for example, "[1,2] == '
+ '(1,2)" is\n'
+ ' false because the type is not the same).\n'
+ '\n'
+ ' * Collections are ordered the same as their first unequal '
+ 'elements\n'
+ ' (for example, "cmp([1,2,x], [1,2,y])" returns the same '
+ 'as\n'
+ ' "cmp(x,y)"). If a corresponding element does not exist, '
+ 'the\n'
+ ' shorter collection is ordered first (for example, "[1,2] '
+ '<\n'
+ ' [1,2,3]" is true).\n'
+ '\n'
+ '* Mappings (instances of "dict") compare equal if and only if '
+ 'they\n'
+ ' have equal *(key, value)* pairs. Equality comparison of the '
+ 'keys and\n'
+ ' values enforces reflexivity.\n'
+ '\n'
+ ' Outcomes other than equality are resolved consistently, but '
+ 'are not\n'
+ ' otherwise defined. [5]\n'
+ '\n'
+ '* Most other objects of built-in types compare unequal unless '
+ 'they\n'
+ ' are the same object; the choice whether one object is '
+ 'considered\n'
+ ' smaller or larger than another one is made arbitrarily but\n'
+ ' consistently within one execution of a program.\n'
+ '\n'
+ 'User-defined classes that customize their comparison behavior '
+ 'should\n'
+ 'follow some consistency rules, if possible:\n'
+ '\n'
+ '* Equality comparison should be reflexive. In other words, '
+ 'identical\n'
+ ' objects should compare equal:\n'
+ '\n'
+ ' "x is y" implies "x == y"\n'
+ '\n'
+ '* Comparison should be symmetric. In other words, the '
+ 'following\n'
+ ' expressions should have the same result:\n'
+ '\n'
+ ' "x == y" and "y == x"\n'
+ '\n'
+ ' "x != y" and "y != x"\n'
+ '\n'
+ ' "x < y" and "y > x"\n'
+ '\n'
+ ' "x <= y" and "y >= x"\n'
+ '\n'
+ '* Comparison should be transitive. The following '
+ '(non-exhaustive)\n'
+ ' examples illustrate that:\n'
+ '\n'
+ ' "x > y and y > z" implies "x > z"\n'
+ '\n'
+ ' "x < y and y <= z" implies "x < z"\n'
+ '\n'
+ '* Inverse comparison should result in the boolean negation. '
+ 'In other\n'
+ ' words, the following expressions should have the same '
+ 'result:\n'
+ '\n'
+ ' "x == y" and "not x != y"\n'
+ '\n'
+ ' "x < y" and "not x >= y" (for total ordering)\n'
+ '\n'
+ ' "x > y" and "not x <= y" (for total ordering)\n'
+ '\n'
+ ' The last two expressions apply to totally ordered '
+ 'collections (e.g.\n'
+ ' to sequences, but not to sets or mappings). See also the\n'
+ ' "total_ordering()" decorator.\n'
+ '\n'
+ '* The "hash()" result should be consistent with equality. '
+ 'Objects\n'
+ ' that are equal should either have the same hash value, or '
+ 'be marked\n'
+ ' as unhashable.\n'
+ '\n'
+ 'Python does not enforce these consistency rules.\n'
+ '\n'
+ '\n'
+ 'Membership test operations\n'
+ '==========================\n'
+ '\n'
+ 'The operators "in" and "not in" test for membership. "x in '
+ 's"\n'
+ 'evaluates to "True" if *x* is a member of *s*, and "False" '
+ 'otherwise.\n'
+ '"x not in s" returns the negation of "x in s". All built-in '
+ 'sequences\n'
+ 'and set types support this as well as dictionary, for which '
+ '"in" tests\n'
+ 'whether the dictionary has a given key. For container types '
+ 'such as\n'
+ 'list, tuple, set, frozenset, dict, or collections.deque, the\n'
+ 'expression "x in y" is equivalent to "any(x is e or x == e '
+ 'for e in\n'
+ 'y)".\n'
+ '\n'
+ 'For the string and bytes types, "x in y" is "True" if and '
+ 'only if *x*\n'
+ 'is a substring of *y*. An equivalent test is "y.find(x) != '
+ '-1".\n'
+ 'Empty strings are always considered to be a substring of any '
+ 'other\n'
+ 'string, so """ in "abc"" will return "True".\n'
+ '\n'
+ 'For user-defined classes which define the "__contains__()" '
+ 'method, "x\n'
+ 'in y" returns "True" if "y.__contains__(x)" returns a true '
+ 'value, and\n'
+ '"False" otherwise.\n'
+ '\n'
+ 'For user-defined classes which do not define "__contains__()" '
+ 'but do\n'
+ 'define "__iter__()", "x in y" is "True" if some value "z" '
+ 'with "x ==\n'
+ 'z" is produced while iterating over "y". If an exception is '
+ 'raised\n'
+ 'during the iteration, it is as if "in" raised that '
+ 'exception.\n'
+ '\n'
+ 'Lastly, the old-style iteration protocol is tried: if a class '
+ 'defines\n'
+ '"__getitem__()", "x in y" is "True" if and only if there is a '
+ 'non-\n'
+ 'negative integer index *i* such that "x == y[i]", and all '
+ 'lower\n'
+ 'integer indices do not raise "IndexError" exception. (If any '
+ 'other\n'
+ 'exception is raised, it is as if "in" raised that '
+ 'exception).\n'
+ '\n'
+ 'The operator "not in" is defined to have the inverse true '
+ 'value of\n'
+ '"in".\n'
+ '\n'
+ '\n'
+ 'Identity comparisons\n'
+ '====================\n'
+ '\n'
+ 'The operators "is" and "is not" test for object identity: "x '
+ 'is y" is\n'
+ 'true if and only if *x* and *y* are the same object. "x is '
+ 'not y"\n'
+ 'yields the inverse truth value. [6]\n',
+ 'compound': '\n'
+ 'Compound statements\n'
+ '*******************\n'
+ '\n'
+ 'Compound statements contain (groups of) other statements; they '
+ 'affect\n'
+ 'or control the execution of those other statements in some way. '
+ 'In\n'
+ 'general, compound statements span multiple lines, although in '
+ 'simple\n'
+ 'incarnations a whole compound statement may be contained in one '
+ 'line.\n'
+ '\n'
+ 'The "if", "while" and "for" statements implement traditional '
+ 'control\n'
+ 'flow constructs. "try" specifies exception handlers and/or '
+ 'cleanup\n'
+ 'code for a group of statements. Function and class definitions '
+ 'are\n'
+ 'also syntactically compound statements.\n'
+ '\n'
+ "Compound statements consist of one or more 'clauses.' A clause\n"
+ "consists of a header and a 'suite.' The clause headers of a\n"
+ 'particular compound statement are all at the same indentation '
+ 'level.\n'
+ 'Each clause header begins with a uniquely identifying keyword '
+ 'and ends\n'
+ 'with a colon. A suite is a group of statements controlled by a\n'
+ 'clause. A suite can be one or more semicolon-separated simple\n'
+ 'statements on the same line as the header, following the '
+ "header's\n"
+ 'colon, or it can be one or more indented statements on '
+ 'subsequent\n'
+ 'lines. Only the latter form of suite can contain nested '
+ 'compound\n'
+ "statements; the following is illegal, mostly because it wouldn't "
+ 'be\n'
+ 'clear to which "if" clause a following "else" clause would '
+ 'belong:\n'
+ '\n'
+ ' if test1: if test2: print x\n'
+ '\n'
+ 'Also note that the semicolon binds tighter than the colon in '
+ 'this\n'
+ 'context, so that in the following example, either all or none of '
+ 'the\n'
+ '"print" statements are executed:\n'
+ '\n'
+ ' if x < y < z: print x; print y; print z\n'
+ '\n'
+ 'Summarizing:\n'
+ '\n'
+ ' compound_stmt ::= if_stmt\n'
+ ' | while_stmt\n'
+ ' | for_stmt\n'
+ ' | try_stmt\n'
+ ' | with_stmt\n'
+ ' | funcdef\n'
+ ' | classdef\n'
+ ' | decorated\n'
+ ' suite ::= stmt_list NEWLINE | NEWLINE INDENT '
+ 'statement+ DEDENT\n'
+ ' statement ::= stmt_list NEWLINE | compound_stmt\n'
+ ' stmt_list ::= simple_stmt (";" simple_stmt)* [";"]\n'
+ '\n'
+ 'Note that statements always end in a "NEWLINE" possibly followed '
+ 'by a\n'
+ '"DEDENT". Also note that optional continuation clauses always '
+ 'begin\n'
+ 'with a keyword that cannot start a statement, thus there are no\n'
+ 'ambiguities (the \'dangling "else"\' problem is solved in Python '
+ 'by\n'
+ 'requiring nested "if" statements to be indented).\n'
+ '\n'
+ 'The formatting of the grammar rules in the following sections '
+ 'places\n'
+ 'each clause on a separate line for clarity.\n'
+ '\n'
+ '\n'
+ 'The "if" statement\n'
+ '==================\n'
+ '\n'
+ 'The "if" statement is used for conditional execution:\n'
+ '\n'
+ ' if_stmt ::= "if" expression ":" suite\n'
+ ' ( "elif" expression ":" suite )*\n'
+ ' ["else" ":" suite]\n'
+ '\n'
+ 'It selects exactly one of the suites by evaluating the '
+ 'expressions one\n'
+ 'by one until one is found to be true (see section Boolean '
+ 'operations\n'
+ 'for the definition of true and false); then that suite is '
+ 'executed\n'
+ '(and no other part of the "if" statement is executed or '
+ 'evaluated).\n'
+ 'If all expressions are false, the suite of the "else" clause, '
+ 'if\n'
+ 'present, is executed.\n'
+ '\n'
+ '\n'
+ 'The "while" statement\n'
+ '=====================\n'
+ '\n'
+ 'The "while" statement is used for repeated execution as long as '
+ 'an\n'
+ 'expression is true:\n'
+ '\n'
+ ' while_stmt ::= "while" expression ":" suite\n'
+ ' ["else" ":" suite]\n'
+ '\n'
+ 'This repeatedly tests the expression and, if it is true, '
+ 'executes the\n'
+ 'first suite; if the expression is false (which may be the first '
+ 'time\n'
+ 'it is tested) the suite of the "else" clause, if present, is '
+ 'executed\n'
+ 'and the loop terminates.\n'
+ '\n'
+ 'A "break" statement executed in the first suite terminates the '
+ 'loop\n'
+ 'without executing the "else" clause\'s suite. A "continue" '
+ 'statement\n'
+ 'executed in the first suite skips the rest of the suite and goes '
+ 'back\n'
+ 'to testing the expression.\n'
+ '\n'
+ '\n'
+ 'The "for" statement\n'
+ '===================\n'
+ '\n'
+ 'The "for" statement is used to iterate over the elements of a '
+ 'sequence\n'
+ '(such as a string, tuple or list) or other iterable object:\n'
+ '\n'
+ ' for_stmt ::= "for" target_list "in" expression_list ":" '
+ 'suite\n'
+ ' ["else" ":" suite]\n'
+ '\n'
+ 'The expression list is evaluated once; it should yield an '
+ 'iterable\n'
+ 'object. An iterator is created for the result of the\n'
+ '"expression_list". The suite is then executed once for each '
+ 'item\n'
+ 'provided by the iterator, in the order of ascending indices. '
+ 'Each\n'
+ 'item in turn is assigned to the target list using the standard '
+ 'rules\n'
+ 'for assignments, and then the suite is executed. When the items '
+ 'are\n'
+ 'exhausted (which is immediately when the sequence is empty), the '
+ 'suite\n'
+ 'in the "else" clause, if present, is executed, and the loop\n'
+ 'terminates.\n'
+ '\n'
+ 'A "break" statement executed in the first suite terminates the '
+ 'loop\n'
+ 'without executing the "else" clause\'s suite. A "continue" '
+ 'statement\n'
+ 'executed in the first suite skips the rest of the suite and '
+ 'continues\n'
+ 'with the next item, or with the "else" clause if there was no '
+ 'next\n'
+ 'item.\n'
+ '\n'
+ 'The suite may assign to the variable(s) in the target list; this '
+ 'does\n'
+ 'not affect the next item assigned to it.\n'
+ '\n'
+ 'The target list is not deleted when the loop is finished, but if '
+ 'the\n'
+ 'sequence is empty, it will not have been assigned to at all by '
+ 'the\n'
+ 'loop. Hint: the built-in function "range()" returns a sequence '
+ 'of\n'
+ 'integers suitable to emulate the effect of Pascal\'s "for i := a '
+ 'to b\n'
+ 'do"; e.g., "range(3)" returns the list "[0, 1, 2]".\n'
+ '\n'
+ 'Note: There is a subtlety when the sequence is being modified by '
+ 'the\n'
+ ' loop (this can only occur for mutable sequences, i.e. lists). '
+ 'An\n'
+ ' internal counter is used to keep track of which item is used '
+ 'next,\n'
+ ' and this is incremented on each iteration. When this counter '
+ 'has\n'
+ ' reached the length of the sequence the loop terminates. This '
+ 'means\n'
+ ' that if the suite deletes the current (or a previous) item '
+ 'from the\n'
+ ' sequence, the next item will be skipped (since it gets the '
+ 'index of\n'
+ ' the current item which has already been treated). Likewise, '
+ 'if the\n'
+ ' suite inserts an item in the sequence before the current item, '
+ 'the\n'
+ ' current item will be treated again the next time through the '
+ 'loop.\n'
+ ' This can lead to nasty bugs that can be avoided by making a\n'
+ ' temporary copy using a slice of the whole sequence, e.g.,\n'
+ '\n'
+ ' for x in a[:]:\n'
+ ' if x < 0: a.remove(x)\n'
+ '\n'
+ '\n'
+ 'The "try" statement\n'
+ '===================\n'
+ '\n'
+ 'The "try" statement specifies exception handlers and/or cleanup '
+ 'code\n'
+ 'for a group of statements:\n'
+ '\n'
+ ' try_stmt ::= try1_stmt | try2_stmt\n'
+ ' try1_stmt ::= "try" ":" suite\n'
+ ' ("except" [expression [("as" | ",") '
+ 'identifier]] ":" suite)+\n'
+ ' ["else" ":" suite]\n'
+ ' ["finally" ":" suite]\n'
+ ' try2_stmt ::= "try" ":" suite\n'
+ ' "finally" ":" suite\n'
+ '\n'
+ 'Changed in version 2.5: In previous versions of Python,\n'
+ '"try"..."except"..."finally" did not work. "try"..."except" had '
+ 'to be\n'
+ 'nested in "try"..."finally".\n'
+ '\n'
+ 'The "except" clause(s) specify one or more exception handlers. '
+ 'When no\n'
+ 'exception occurs in the "try" clause, no exception handler is\n'
+ 'executed. When an exception occurs in the "try" suite, a search '
+ 'for an\n'
+ 'exception handler is started. This search inspects the except '
+ 'clauses\n'
+ 'in turn until one is found that matches the exception. An '
+ 'expression-\n'
+ 'less except clause, if present, must be last; it matches any\n'
+ 'exception. For an except clause with an expression, that '
+ 'expression\n'
+ 'is evaluated, and the clause matches the exception if the '
+ 'resulting\n'
+ 'object is "compatible" with the exception. An object is '
+ 'compatible\n'
+ 'with an exception if it is the class or a base class of the '
+ 'exception\n'
+ 'object, or a tuple containing an item compatible with the '
+ 'exception.\n'
+ '\n'
+ 'If no except clause matches the exception, the search for an '
+ 'exception\n'
+ 'handler continues in the surrounding code and on the invocation '
+ 'stack.\n'
+ '[1]\n'
+ '\n'
+ 'If the evaluation of an expression in the header of an except '
+ 'clause\n'
+ 'raises an exception, the original search for a handler is '
+ 'canceled and\n'
+ 'a search starts for the new exception in the surrounding code '
+ 'and on\n'
+ 'the call stack (it is treated as if the entire "try" statement '
+ 'raised\n'
+ 'the exception).\n'
+ '\n'
+ 'When a matching except clause is found, the exception is '
+ 'assigned to\n'
+ 'the target specified in that except clause, if present, and the '
+ 'except\n'
+ "clause's suite is executed. All except clauses must have an\n"
+ 'executable block. When the end of this block is reached, '
+ 'execution\n'
+ 'continues normally after the entire try statement. (This means '
+ 'that\n'
+ 'if two nested handlers exist for the same exception, and the '
+ 'exception\n'
+ 'occurs in the try clause of the inner handler, the outer handler '
+ 'will\n'
+ 'not handle the exception.)\n'
+ '\n'
+ "Before an except clause's suite is executed, details about the\n"
+ 'exception are assigned to three variables in the "sys" module:\n'
+ '"sys.exc_type" receives the object identifying the exception;\n'
+ '"sys.exc_value" receives the exception\'s parameter;\n'
+ '"sys.exc_traceback" receives a traceback object (see section '
+ 'The\n'
+ 'standard type hierarchy) identifying the point in the program '
+ 'where\n'
+ 'the exception occurred. These details are also available through '
+ 'the\n'
+ '"sys.exc_info()" function, which returns a tuple "(exc_type,\n'
+ 'exc_value, exc_traceback)". Use of the corresponding variables '
+ 'is\n'
+ 'deprecated in favor of this function, since their use is unsafe '
+ 'in a\n'
+ 'threaded program. As of Python 1.5, the variables are restored '
+ 'to\n'
+ 'their previous values (before the call) when returning from a '
+ 'function\n'
+ 'that handled an exception.\n'
+ '\n'
+ 'The optional "else" clause is executed if and when control flows '
+ 'off\n'
+ 'the end of the "try" clause. [2] Exceptions in the "else" clause '
+ 'are\n'
+ 'not handled by the preceding "except" clauses.\n'
+ '\n'
+ 'If "finally" is present, it specifies a \'cleanup\' handler. '
+ 'The "try"\n'
+ 'clause is executed, including any "except" and "else" clauses. '
+ 'If an\n'
+ 'exception occurs in any of the clauses and is not handled, the\n'
+ 'exception is temporarily saved. The "finally" clause is '
+ 'executed. If\n'
+ 'there is a saved exception, it is re-raised at the end of the\n'
+ '"finally" clause. If the "finally" clause raises another '
+ 'exception or\n'
+ 'executes a "return" or "break" statement, the saved exception '
+ 'is\n'
+ 'discarded:\n'
+ '\n'
+ ' >>> def f():\n'
+ ' ... try:\n'
+ ' ... 1/0\n'
+ ' ... finally:\n'
+ ' ... return 42\n'
+ ' ...\n'
+ ' >>> f()\n'
+ ' 42\n'
+ '\n'
+ 'The exception information is not available to the program '
+ 'during\n'
+ 'execution of the "finally" clause.\n'
+ '\n'
+ 'When a "return", "break" or "continue" statement is executed in '
+ 'the\n'
+ '"try" suite of a "try"..."finally" statement, the "finally" '
+ 'clause is\n'
+ 'also executed \'on the way out.\' A "continue" statement is '
+ 'illegal in\n'
+ 'the "finally" clause. (The reason is a problem with the current\n'
+ 'implementation --- this restriction may be lifted in the '
+ 'future).\n'
+ '\n'
+ 'The return value of a function is determined by the last '
+ '"return"\n'
+ 'statement executed. Since the "finally" clause always executes, '
+ 'a\n'
+ '"return" statement executed in the "finally" clause will always '
+ 'be the\n'
+ 'last one executed:\n'
+ '\n'
+ ' >>> def foo():\n'
+ ' ... try:\n'
+ " ... return 'try'\n"
+ ' ... finally:\n'
+ " ... return 'finally'\n"
+ ' ...\n'
+ ' >>> foo()\n'
+ " 'finally'\n"
+ '\n'
+ 'Additional information on exceptions can be found in section\n'
+ 'Exceptions, and information on using the "raise" statement to '
+ 'generate\n'
+ 'exceptions may be found in section The raise statement.\n'
+ '\n'
+ '\n'
+ 'The "with" statement\n'
+ '====================\n'
+ '\n'
+ 'New in version 2.5.\n'
+ '\n'
+ 'The "with" statement is used to wrap the execution of a block '
+ 'with\n'
+ 'methods defined by a context manager (see section With '
+ 'Statement\n'
+ 'Context Managers). This allows common '
+ '"try"..."except"..."finally"\n'
+ 'usage patterns to be encapsulated for convenient reuse.\n'
+ '\n'
+ ' with_stmt ::= "with" with_item ("," with_item)* ":" suite\n'
+ ' with_item ::= expression ["as" target]\n'
+ '\n'
+ 'The execution of the "with" statement with one "item" proceeds '
+ 'as\n'
+ 'follows:\n'
+ '\n'
+ '1. The context expression (the expression given in the '
+ '"with_item")\n'
+ ' is evaluated to obtain a context manager.\n'
+ '\n'
+ '2. The context manager\'s "__exit__()" is loaded for later use.\n'
+ '\n'
+ '3. The context manager\'s "__enter__()" method is invoked.\n'
+ '\n'
+ '4. If a target was included in the "with" statement, the return\n'
+ ' value from "__enter__()" is assigned to it.\n'
+ '\n'
+ ' Note: The "with" statement guarantees that if the '
+ '"__enter__()"\n'
+ ' method returns without an error, then "__exit__()" will '
+ 'always be\n'
+ ' called. Thus, if an error occurs during the assignment to '
+ 'the\n'
+ ' target list, it will be treated the same as an error '
+ 'occurring\n'
+ ' within the suite would be. See step 6 below.\n'
+ '\n'
+ '5. The suite is executed.\n'
+ '\n'
+ '6. The context manager\'s "__exit__()" method is invoked. If an\n'
+ ' exception caused the suite to be exited, its type, value, '
+ 'and\n'
+ ' traceback are passed as arguments to "__exit__()". Otherwise, '
+ 'three\n'
+ ' "None" arguments are supplied.\n'
+ '\n'
+ ' If the suite was exited due to an exception, and the return '
+ 'value\n'
+ ' from the "__exit__()" method was false, the exception is '
+ 'reraised.\n'
+ ' If the return value was true, the exception is suppressed, '
+ 'and\n'
+ ' execution continues with the statement following the "with"\n'
+ ' statement.\n'
+ '\n'
+ ' If the suite was exited for any reason other than an '
+ 'exception, the\n'
+ ' return value from "__exit__()" is ignored, and execution '
+ 'proceeds\n'
+ ' at the normal location for the kind of exit that was taken.\n'
+ '\n'
+ 'With more than one item, the context managers are processed as '
+ 'if\n'
+ 'multiple "with" statements were nested:\n'
+ '\n'
+ ' with A() as a, B() as b:\n'
+ ' suite\n'
+ '\n'
+ 'is equivalent to\n'
+ '\n'
+ ' with A() as a:\n'
+ ' with B() as b:\n'
+ ' suite\n'
+ '\n'
+ 'Note: In Python 2.5, the "with" statement is only allowed when '
+ 'the\n'
+ ' "with_statement" feature has been enabled. It is always '
+ 'enabled in\n'
+ ' Python 2.6.\n'
+ '\n'
+ 'Changed in version 2.7: Support for multiple context '
+ 'expressions.\n'
+ '\n'
+ 'See also:\n'
+ '\n'
+ ' **PEP 343** - The "with" statement\n'
+ ' The specification, background, and examples for the Python '
+ '"with"\n'
+ ' statement.\n'
+ '\n'
+ '\n'
+ 'Function definitions\n'
+ '====================\n'
+ '\n'
+ 'A function definition defines a user-defined function object '
+ '(see\n'
+ 'section The standard type hierarchy):\n'
+ '\n'
+ ' decorated ::= decorators (classdef | funcdef)\n'
+ ' decorators ::= decorator+\n'
+ ' decorator ::= "@" dotted_name ["(" [argument_list [","]] '
+ '")"] NEWLINE\n'
+ ' funcdef ::= "def" funcname "(" [parameter_list] ")" '
+ '":" suite\n'
+ ' dotted_name ::= identifier ("." identifier)*\n'
+ ' parameter_list ::= (defparameter ",")*\n'
+ ' ( "*" identifier ["," "**" identifier]\n'
+ ' | "**" identifier\n'
+ ' | defparameter [","] )\n'
+ ' defparameter ::= parameter ["=" expression]\n'
+ ' sublist ::= parameter ("," parameter)* [","]\n'
+ ' parameter ::= identifier | "(" sublist ")"\n'
+ ' funcname ::= identifier\n'
+ '\n'
+ 'A function definition is an executable statement. Its execution '
+ 'binds\n'
+ 'the function name in the current local namespace to a function '
+ 'object\n'
+ '(a wrapper around the executable code for the function). This\n'
+ 'function object contains a reference to the current global '
+ 'namespace\n'
+ 'as the global namespace to be used when the function is called.\n'
+ '\n'
+ 'The function definition does not execute the function body; this '
+ 'gets\n'
+ 'executed only when the function is called. [3]\n'
+ '\n'
+ 'A function definition may be wrapped by one or more *decorator*\n'
+ 'expressions. Decorator expressions are evaluated when the '
+ 'function is\n'
+ 'defined, in the scope that contains the function definition. '
+ 'The\n'
+ 'result must be a callable, which is invoked with the function '
+ 'object\n'
+ 'as the only argument. The returned value is bound to the '
+ 'function name\n'
+ 'instead of the function object. Multiple decorators are applied '
+ 'in\n'
+ 'nested fashion. For example, the following code:\n'
+ '\n'
+ ' @f1(arg)\n'
+ ' @f2\n'
+ ' def func(): pass\n'
+ '\n'
+ 'is equivalent to:\n'
+ '\n'
+ ' def func(): pass\n'
+ ' func = f1(arg)(f2(func))\n'
+ '\n'
+ 'When one or more top-level *parameters* have the form '
+ '*parameter* "="\n'
+ '*expression*, the function is said to have "default parameter '
+ 'values."\n'
+ 'For a parameter with a default value, the corresponding '
+ '*argument* may\n'
+ "be omitted from a call, in which case the parameter's default "
+ 'value is\n'
+ 'substituted. If a parameter has a default value, all following\n'
+ 'parameters must also have a default value --- this is a '
+ 'syntactic\n'
+ 'restriction that is not expressed by the grammar.\n'
+ '\n'
+ '**Default parameter values are evaluated when the function '
+ 'definition\n'
+ 'is executed.** This means that the expression is evaluated '
+ 'once, when\n'
+ 'the function is defined, and that the same "pre-computed" value '
+ 'is\n'
+ 'used for each call. This is especially important to understand '
+ 'when a\n'
+ 'default parameter is a mutable object, such as a list or a '
+ 'dictionary:\n'
+ 'if the function modifies the object (e.g. by appending an item '
+ 'to a\n'
+ 'list), the default value is in effect modified. This is '
+ 'generally not\n'
+ 'what was intended. A way around this is to use "None" as the\n'
+ 'default, and explicitly test for it in the body of the function, '
+ 'e.g.:\n'
+ '\n'
+ ' def whats_on_the_telly(penguin=None):\n'
+ ' if penguin is None:\n'
+ ' penguin = []\n'
+ ' penguin.append("property of the zoo")\n'
+ ' return penguin\n'
+ '\n'
+ 'Function call semantics are described in more detail in section '
+ 'Calls.\n'
+ 'A function call always assigns values to all parameters '
+ 'mentioned in\n'
+ 'the parameter list, either from position arguments, from '
+ 'keyword\n'
+ 'arguments, or from default values. If the form ""*identifier"" '
+ 'is\n'
+ 'present, it is initialized to a tuple receiving any excess '
+ 'positional\n'
+ 'parameters, defaulting to the empty tuple. If the form\n'
+ '""**identifier"" is present, it is initialized to a new '
+ 'dictionary\n'
+ 'receiving any excess keyword arguments, defaulting to a new '
+ 'empty\n'
+ 'dictionary.\n'
+ '\n'
+ 'It is also possible to create anonymous functions (functions not '
+ 'bound\n'
+ 'to a name), for immediate use in expressions. This uses lambda\n'
+ 'expressions, described in section Lambdas. Note that the '
+ 'lambda\n'
+ 'expression is merely a shorthand for a simplified function '
+ 'definition;\n'
+ 'a function defined in a ""def"" statement can be passed around '
+ 'or\n'
+ 'assigned to another name just like a function defined by a '
+ 'lambda\n'
+ 'expression. The ""def"" form is actually more powerful since '
+ 'it\n'
+ 'allows the execution of multiple statements.\n'
+ '\n'
+ "**Programmer's note:** Functions are first-class objects. A "
+ '""def""\n'
+ 'form executed inside a function definition defines a local '
+ 'function\n'
+ 'that can be returned or passed around. Free variables used in '
+ 'the\n'
+ 'nested function can access the local variables of the function\n'
+ 'containing the def. See section Naming and binding for '
+ 'details.\n'
+ '\n'
+ '\n'
+ 'Class definitions\n'
+ '=================\n'
+ '\n'
+ 'A class definition defines a class object (see section The '
+ 'standard\n'
+ 'type hierarchy):\n'
+ '\n'
+ ' classdef ::= "class" classname [inheritance] ":" suite\n'
+ ' inheritance ::= "(" [expression_list] ")"\n'
+ ' classname ::= identifier\n'
+ '\n'
+ 'A class definition is an executable statement. It first '
+ 'evaluates the\n'
+ 'inheritance list, if present. Each item in the inheritance '
+ 'list\n'
+ 'should evaluate to a class object or class type which allows\n'
+ "subclassing. The class's suite is then executed in a new "
+ 'execution\n'
+ 'frame (see section Naming and binding), using a newly created '
+ 'local\n'
+ 'namespace and the original global namespace. (Usually, the '
+ 'suite\n'
+ "contains only function definitions.) When the class's suite "
+ 'finishes\n'
+ 'execution, its execution frame is discarded but its local '
+ 'namespace is\n'
+ 'saved. [4] A class object is then created using the inheritance '
+ 'list\n'
+ 'for the base classes and the saved local namespace for the '
+ 'attribute\n'
+ 'dictionary. The class name is bound to this class object in '
+ 'the\n'
+ 'original local namespace.\n'
+ '\n'
+ "**Programmer's note:** Variables defined in the class definition "
+ 'are\n'
+ 'class variables; they are shared by all instances. To create '
+ 'instance\n'
+ 'variables, they can be set in a method with "self.name = '
+ 'value". Both\n'
+ 'class and instance variables are accessible through the '
+ 'notation\n'
+ '""self.name"", and an instance variable hides a class variable '
+ 'with\n'
+ 'the same name when accessed in this way. Class variables can be '
+ 'used\n'
+ 'as defaults for instance variables, but using mutable values '
+ 'there can\n'
+ 'lead to unexpected results. For *new-style class*es, '
+ 'descriptors can\n'
+ 'be used to create instance variables with different '
+ 'implementation\n'
+ 'details.\n'
+ '\n'
+ 'Class definitions, like function definitions, may be wrapped by '
+ 'one or\n'
+ 'more *decorator* expressions. The evaluation rules for the '
+ 'decorator\n'
+ 'expressions are the same as for functions. The result must be a '
+ 'class\n'
+ 'object, which is then bound to the class name.\n'
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ '[1] The exception is propagated to the invocation stack unless\n'
+ ' there is a "finally" clause which happens to raise another\n'
+ ' exception. That new exception causes the old one to be '
+ 'lost.\n'
+ '\n'
+ '[2] Currently, control "flows off the end" except in the case '
+ 'of\n'
+ ' an exception or the execution of a "return", "continue", or\n'
+ ' "break" statement.\n'
+ '\n'
+ '[3] A string literal appearing as the first statement in the\n'
+ ' function body is transformed into the function\'s "__doc__"\n'
+ " attribute and therefore the function's *docstring*.\n"
+ '\n'
+ '[4] A string literal appearing as the first statement in the '
+ 'class\n'
+ ' body is transformed into the namespace\'s "__doc__" item '
+ 'and\n'
+ " therefore the class's *docstring*.\n",
+ 'context-managers': '\n'
+ 'With Statement Context Managers\n'
+ '*******************************\n'
+ '\n'
+ 'New in version 2.5.\n'
+ '\n'
+ 'A *context manager* is an object that defines the '
+ 'runtime context to\n'
+ 'be established when executing a "with" statement. The '
+ 'context manager\n'
+ 'handles the entry into, and the exit from, the desired '
+ 'runtime context\n'
+ 'for the execution of the block of code. Context '
+ 'managers are normally\n'
+ 'invoked using the "with" statement (described in section '
+ 'The with\n'
+ 'statement), but can also be used by directly invoking '
+ 'their methods.\n'
+ '\n'
+ 'Typical uses of context managers include saving and '
+ 'restoring various\n'
+ 'kinds of global state, locking and unlocking resources, '
+ 'closing opened\n'
+ 'files, etc.\n'
+ '\n'
+ 'For more information on context managers, see Context '
+ 'Manager Types.\n'
+ '\n'
+ 'object.__enter__(self)\n'
+ '\n'
+ ' Enter the runtime context related to this object. The '
+ '"with"\n'
+ " statement will bind this method's return value to the "
+ 'target(s)\n'
+ ' specified in the "as" clause of the statement, if '
+ 'any.\n'
+ '\n'
+ 'object.__exit__(self, exc_type, exc_value, traceback)\n'
+ '\n'
+ ' Exit the runtime context related to this object. The '
+ 'parameters\n'
+ ' describe the exception that caused the context to be '
+ 'exited. If the\n'
+ ' context was exited without an exception, all three '
+ 'arguments will\n'
+ ' be "None".\n'
+ '\n'
+ ' If an exception is supplied, and the method wishes to '
+ 'suppress the\n'
+ ' exception (i.e., prevent it from being propagated), '
+ 'it should\n'
+ ' return a true value. Otherwise, the exception will be '
+ 'processed\n'
+ ' normally upon exit from this method.\n'
+ '\n'
+ ' Note that "__exit__()" methods should not reraise the '
+ 'passed-in\n'
+ " exception; this is the caller's responsibility.\n"
+ '\n'
+ 'See also:\n'
+ '\n'
+ ' **PEP 343** - The "with" statement\n'
+ ' The specification, background, and examples for the '
+ 'Python "with"\n'
+ ' statement.\n',
+ 'continue': '\n'
+ 'The "continue" statement\n'
+ '************************\n'
+ '\n'
+ ' continue_stmt ::= "continue"\n'
+ '\n'
+ '"continue" may only occur syntactically nested in a "for" or '
+ '"while"\n'
+ 'loop, but not nested in a function or class definition or '
+ '"finally"\n'
+ 'clause within that loop. It continues with the next cycle of '
+ 'the\n'
+ 'nearest enclosing loop.\n'
+ '\n'
+ 'When "continue" passes control out of a "try" statement with a\n'
+ '"finally" clause, that "finally" clause is executed before '
+ 'really\n'
+ 'starting the next loop cycle.\n',
+ 'conversions': '\n'
+ 'Arithmetic conversions\n'
+ '**********************\n'
+ '\n'
+ 'When a description of an arithmetic operator below uses the '
+ 'phrase\n'
+ '"the numeric arguments are converted to a common type," the '
+ 'arguments\n'
+ 'are coerced using the coercion rules listed at Coercion '
+ 'rules. If\n'
+ 'both arguments are standard numeric types, the following '
+ 'coercions are\n'
+ 'applied:\n'
+ '\n'
+ '* If either argument is a complex number, the other is '
+ 'converted to\n'
+ ' complex;\n'
+ '\n'
+ '* otherwise, if either argument is a floating point number, '
+ 'the\n'
+ ' other is converted to floating point;\n'
+ '\n'
+ '* otherwise, if either argument is a long integer, the other '
+ 'is\n'
+ ' converted to long integer;\n'
+ '\n'
+ '* otherwise, both must be plain integers and no conversion '
+ 'is\n'
+ ' necessary.\n'
+ '\n'
+ 'Some additional rules apply for certain operators (e.g., a '
+ 'string left\n'
+ "argument to the '%' operator). Extensions can define their "
+ 'own\n'
+ 'coercions.\n',
+ 'customization': '\n'
+ 'Basic customization\n'
+ '*******************\n'
+ '\n'
+ 'object.__new__(cls[, ...])\n'
+ '\n'
+ ' Called to create a new instance of class *cls*. '
+ '"__new__()" is a\n'
+ ' static method (special-cased so you need not declare it '
+ 'as such)\n'
+ ' that takes the class of which an instance was requested '
+ 'as its\n'
+ ' first argument. The remaining arguments are those '
+ 'passed to the\n'
+ ' object constructor expression (the call to the class). '
+ 'The return\n'
+ ' value of "__new__()" should be the new object instance '
+ '(usually an\n'
+ ' instance of *cls*).\n'
+ '\n'
+ ' Typical implementations create a new instance of the '
+ 'class by\n'
+ ' invoking the superclass\'s "__new__()" method using\n'
+ ' "super(currentclass, cls).__new__(cls[, ...])" with '
+ 'appropriate\n'
+ ' arguments and then modifying the newly-created instance '
+ 'as\n'
+ ' necessary before returning it.\n'
+ '\n'
+ ' If "__new__()" returns an instance of *cls*, then the '
+ 'new\n'
+ ' instance\'s "__init__()" method will be invoked like\n'
+ ' "__init__(self[, ...])", where *self* is the new '
+ 'instance and the\n'
+ ' remaining arguments are the same as were passed to '
+ '"__new__()".\n'
+ '\n'
+ ' If "__new__()" does not return an instance of *cls*, '
+ 'then the new\n'
+ ' instance\'s "__init__()" method will not be invoked.\n'
+ '\n'
+ ' "__new__()" is intended mainly to allow subclasses of '
+ 'immutable\n'
+ ' types (like int, str, or tuple) to customize instance '
+ 'creation. It\n'
+ ' is also commonly overridden in custom metaclasses in '
+ 'order to\n'
+ ' customize class creation.\n'
+ '\n'
+ 'object.__init__(self[, ...])\n'
+ '\n'
+ ' Called after the instance has been created (by '
+ '"__new__()"), but\n'
+ ' before it is returned to the caller. The arguments are '
+ 'those\n'
+ ' passed to the class constructor expression. If a base '
+ 'class has an\n'
+ ' "__init__()" method, the derived class\'s "__init__()" '
+ 'method, if\n'
+ ' any, must explicitly call it to ensure proper '
+ 'initialization of the\n'
+ ' base class part of the instance; for example:\n'
+ ' "BaseClass.__init__(self, [args...])".\n'
+ '\n'
+ ' Because "__new__()" and "__init__()" work together in '
+ 'constructing\n'
+ ' objects ("__new__()" to create it, and "__init__()" to '
+ 'customise\n'
+ ' it), no non-"None" value may be returned by '
+ '"__init__()"; doing so\n'
+ ' will cause a "TypeError" to be raised at runtime.\n'
+ '\n'
+ 'object.__del__(self)\n'
+ '\n'
+ ' Called when the instance is about to be destroyed. This '
+ 'is also\n'
+ ' called a destructor. If a base class has a "__del__()" '
+ 'method, the\n'
+ ' derived class\'s "__del__()" method, if any, must '
+ 'explicitly call it\n'
+ ' to ensure proper deletion of the base class part of the '
+ 'instance.\n'
+ ' Note that it is possible (though not recommended!) for '
+ 'the\n'
+ ' "__del__()" method to postpone destruction of the '
+ 'instance by\n'
+ ' creating a new reference to it. It may then be called '
+ 'at a later\n'
+ ' time when this new reference is deleted. It is not '
+ 'guaranteed that\n'
+ ' "__del__()" methods are called for objects that still '
+ 'exist when\n'
+ ' the interpreter exits.\n'
+ '\n'
+ ' Note: "del x" doesn\'t directly call "x.__del__()" --- '
+ 'the former\n'
+ ' decrements the reference count for "x" by one, and the '
+ 'latter is\n'
+ ' only called when "x"\'s reference count reaches zero. '
+ 'Some common\n'
+ ' situations that may prevent the reference count of an '
+ 'object from\n'
+ ' going to zero include: circular references between '
+ 'objects (e.g.,\n'
+ ' a doubly-linked list or a tree data structure with '
+ 'parent and\n'
+ ' child pointers); a reference to the object on the '
+ 'stack frame of\n'
+ ' a function that caught an exception (the traceback '
+ 'stored in\n'
+ ' "sys.exc_traceback" keeps the stack frame alive); or a '
+ 'reference\n'
+ ' to the object on the stack frame that raised an '
+ 'unhandled\n'
+ ' exception in interactive mode (the traceback stored '
+ 'in\n'
+ ' "sys.last_traceback" keeps the stack frame alive). '
+ 'The first\n'
+ ' situation can only be remedied by explicitly breaking '
+ 'the cycles;\n'
+ ' the latter two situations can be resolved by storing '
+ '"None" in\n'
+ ' "sys.exc_traceback" or "sys.last_traceback". Circular '
+ 'references\n'
+ ' which are garbage are detected when the option cycle '
+ 'detector is\n'
+ " enabled (it's on by default), but can only be cleaned "
+ 'up if there\n'
+ ' are no Python-level "__del__()" methods involved. '
+ 'Refer to the\n'
+ ' documentation for the "gc" module for more information '
+ 'about how\n'
+ ' "__del__()" methods are handled by the cycle '
+ 'detector,\n'
+ ' particularly the description of the "garbage" value.\n'
+ '\n'
+ ' Warning: Due to the precarious circumstances under '
+ 'which\n'
+ ' "__del__()" methods are invoked, exceptions that occur '
+ 'during\n'
+ ' their execution are ignored, and a warning is printed '
+ 'to\n'
+ ' "sys.stderr" instead. Also, when "__del__()" is '
+ 'invoked in\n'
+ ' response to a module being deleted (e.g., when '
+ 'execution of the\n'
+ ' program is done), other globals referenced by the '
+ '"__del__()"\n'
+ ' method may already have been deleted or in the process '
+ 'of being\n'
+ ' torn down (e.g. the import machinery shutting down). '
+ 'For this\n'
+ ' reason, "__del__()" methods should do the absolute '
+ 'minimum needed\n'
+ ' to maintain external invariants. Starting with '
+ 'version 1.5,\n'
+ ' Python guarantees that globals whose name begins with '
+ 'a single\n'
+ ' underscore are deleted from their module before other '
+ 'globals are\n'
+ ' deleted; if no other references to such globals exist, '
+ 'this may\n'
+ ' help in assuring that imported modules are still '
+ 'available at the\n'
+ ' time when the "__del__()" method is called.\n'
+ '\n'
+ ' See also the "-R" command-line option.\n'
+ '\n'
+ 'object.__repr__(self)\n'
+ '\n'
+ ' Called by the "repr()" built-in function and by string '
+ 'conversions\n'
+ ' (reverse quotes) to compute the "official" string '
+ 'representation of\n'
+ ' an object. If at all possible, this should look like a '
+ 'valid\n'
+ ' Python expression that could be used to recreate an '
+ 'object with the\n'
+ ' same value (given an appropriate environment). If this '
+ 'is not\n'
+ ' possible, a string of the form "<...some useful '
+ 'description...>"\n'
+ ' should be returned. The return value must be a string '
+ 'object. If a\n'
+ ' class defines "__repr__()" but not "__str__()", then '
+ '"__repr__()"\n'
+ ' is also used when an "informal" string representation of '
+ 'instances\n'
+ ' of that class is required.\n'
+ '\n'
+ ' This is typically used for debugging, so it is important '
+ 'that the\n'
+ ' representation is information-rich and unambiguous.\n'
+ '\n'
+ 'object.__str__(self)\n'
+ '\n'
+ ' Called by the "str()" built-in function and by the '
+ '"print"\n'
+ ' statement to compute the "informal" string '
+ 'representation of an\n'
+ ' object. This differs from "__repr__()" in that it does '
+ 'not have to\n'
+ ' be a valid Python expression: a more convenient or '
+ 'concise\n'
+ ' representation may be used instead. The return value '
+ 'must be a\n'
+ ' string object.\n'
+ '\n'
+ 'object.__lt__(self, other)\n'
+ 'object.__le__(self, other)\n'
+ 'object.__eq__(self, other)\n'
+ 'object.__ne__(self, other)\n'
+ 'object.__gt__(self, other)\n'
+ 'object.__ge__(self, other)\n'
+ '\n'
+ ' New in version 2.1.\n'
+ '\n'
+ ' These are the so-called "rich comparison" methods, and '
+ 'are called\n'
+ ' for comparison operators in preference to "__cmp__()" '
+ 'below. The\n'
+ ' correspondence between operator symbols and method names '
+ 'is as\n'
+ ' follows: "x<y" calls "x.__lt__(y)", "x<=y" calls '
+ '"x.__le__(y)",\n'
+ ' "x==y" calls "x.__eq__(y)", "x!=y" and "x<>y" call '
+ '"x.__ne__(y)",\n'
+ ' "x>y" calls "x.__gt__(y)", and "x>=y" calls '
+ '"x.__ge__(y)".\n'
+ '\n'
+ ' A rich comparison method may return the singleton '
+ '"NotImplemented"\n'
+ ' if it does not implement the operation for a given pair '
+ 'of\n'
+ ' arguments. By convention, "False" and "True" are '
+ 'returned for a\n'
+ ' successful comparison. However, these methods can return '
+ 'any value,\n'
+ ' so if the comparison operator is used in a Boolean '
+ 'context (e.g.,\n'
+ ' in the condition of an "if" statement), Python will call '
+ '"bool()"\n'
+ ' on the value to determine if the result is true or '
+ 'false.\n'
+ '\n'
+ ' There are no implied relationships among the comparison '
+ 'operators.\n'
+ ' The truth of "x==y" does not imply that "x!=y" is '
+ 'false.\n'
+ ' Accordingly, when defining "__eq__()", one should also '
+ 'define\n'
+ ' "__ne__()" so that the operators will behave as '
+ 'expected. See the\n'
+ ' paragraph on "__hash__()" for some important notes on '
+ 'creating\n'
+ ' *hashable* objects which support custom comparison '
+ 'operations and\n'
+ ' are usable as dictionary keys.\n'
+ '\n'
+ ' There are no swapped-argument versions of these methods '
+ '(to be used\n'
+ ' when the left argument does not support the operation '
+ 'but the right\n'
+ ' argument does); rather, "__lt__()" and "__gt__()" are '
+ "each other's\n"
+ ' reflection, "__le__()" and "__ge__()" are each other\'s '
+ 'reflection,\n'
+ ' and "__eq__()" and "__ne__()" are their own reflection.\n'
+ '\n'
+ ' Arguments to rich comparison methods are never coerced.\n'
+ '\n'
+ ' To automatically generate ordering operations from a '
+ 'single root\n'
+ ' operation, see "functools.total_ordering()".\n'
+ '\n'
+ 'object.__cmp__(self, other)\n'
+ '\n'
+ ' Called by comparison operations if rich comparison (see '
+ 'above) is\n'
+ ' not defined. Should return a negative integer if "self '
+ '< other",\n'
+ ' zero if "self == other", a positive integer if "self > '
+ 'other". If\n'
+ ' no "__cmp__()", "__eq__()" or "__ne__()" operation is '
+ 'defined,\n'
+ ' class instances are compared by object identity '
+ '("address"). See\n'
+ ' also the description of "__hash__()" for some important '
+ 'notes on\n'
+ ' creating *hashable* objects which support custom '
+ 'comparison\n'
+ ' operations and are usable as dictionary keys. (Note: '
+ 'the\n'
+ ' restriction that exceptions are not propagated by '
+ '"__cmp__()" has\n'
+ ' been removed since Python 1.5.)\n'
+ '\n'
+ 'object.__rcmp__(self, other)\n'
+ '\n'
+ ' Changed in version 2.1: No longer supported.\n'
+ '\n'
+ 'object.__hash__(self)\n'
+ '\n'
+ ' Called by built-in function "hash()" and for operations '
+ 'on members\n'
+ ' of hashed collections including "set", "frozenset", and '
+ '"dict".\n'
+ ' "__hash__()" should return an integer. The only '
+ 'required property\n'
+ ' is that objects which compare equal have the same hash '
+ 'value; it is\n'
+ ' advised to mix together the hash values of the '
+ 'components of the\n'
+ ' object that also play a part in comparison of objects by '
+ 'packing\n'
+ ' them into a tuple and hashing the tuple. Example:\n'
+ '\n'
+ ' def __hash__(self):\n'
+ ' return hash((self.name, self.nick, self.color))\n'
+ '\n'
+ ' If a class does not define a "__cmp__()" or "__eq__()" '
+ 'method it\n'
+ ' should not define a "__hash__()" operation either; if it '
+ 'defines\n'
+ ' "__cmp__()" or "__eq__()" but not "__hash__()", its '
+ 'instances will\n'
+ ' not be usable in hashed collections. If a class defines '
+ 'mutable\n'
+ ' objects and implements a "__cmp__()" or "__eq__()" '
+ 'method, it\n'
+ ' should not implement "__hash__()", since hashable '
+ 'collection\n'
+ " implementations require that an object's hash value is "
+ 'immutable\n'
+ " (if the object's hash value changes, it will be in the "
+ 'wrong hash\n'
+ ' bucket).\n'
+ '\n'
+ ' User-defined classes have "__cmp__()" and "__hash__()" '
+ 'methods by\n'
+ ' default; with them, all objects compare unequal (except '
+ 'with\n'
+ ' themselves) and "x.__hash__()" returns a result derived '
+ 'from\n'
+ ' "id(x)".\n'
+ '\n'
+ ' Classes which inherit a "__hash__()" method from a '
+ 'parent class but\n'
+ ' change the meaning of "__cmp__()" or "__eq__()" such '
+ 'that the hash\n'
+ ' value returned is no longer appropriate (e.g. by '
+ 'switching to a\n'
+ ' value-based concept of equality instead of the default '
+ 'identity\n'
+ ' based equality) can explicitly flag themselves as being '
+ 'unhashable\n'
+ ' by setting "__hash__ = None" in the class definition. '
+ 'Doing so\n'
+ ' means that not only will instances of the class raise '
+ 'an\n'
+ ' appropriate "TypeError" when a program attempts to '
+ 'retrieve their\n'
+ ' hash value, but they will also be correctly identified '
+ 'as\n'
+ ' unhashable when checking "isinstance(obj, '
+ 'collections.Hashable)"\n'
+ ' (unlike classes which define their own "__hash__()" to '
+ 'explicitly\n'
+ ' raise "TypeError").\n'
+ '\n'
+ ' Changed in version 2.5: "__hash__()" may now also return '
+ 'a long\n'
+ ' integer object; the 32-bit integer is then derived from '
+ 'the hash of\n'
+ ' that object.\n'
+ '\n'
+ ' Changed in version 2.6: "__hash__" may now be set to '
+ '"None" to\n'
+ ' explicitly flag instances of a class as unhashable.\n'
+ '\n'
+ 'object.__nonzero__(self)\n'
+ '\n'
+ ' Called to implement truth value testing and the built-in '
+ 'operation\n'
+ ' "bool()"; should return "False" or "True", or their '
+ 'integer\n'
+ ' equivalents "0" or "1". When this method is not '
+ 'defined,\n'
+ ' "__len__()" is called, if it is defined, and the object '
+ 'is\n'
+ ' considered true if its result is nonzero. If a class '
+ 'defines\n'
+ ' neither "__len__()" nor "__nonzero__()", all its '
+ 'instances are\n'
+ ' considered true.\n'
+ '\n'
+ 'object.__unicode__(self)\n'
+ '\n'
+ ' Called to implement "unicode()" built-in; should return '
+ 'a Unicode\n'
+ ' object. When this method is not defined, string '
+ 'conversion is\n'
+ ' attempted, and the result of string conversion is '
+ 'converted to\n'
+ ' Unicode using the system default encoding.\n',
+ 'debugger': '\n'
+ '"pdb" --- The Python Debugger\n'
+ '*****************************\n'
+ '\n'
+ '**Source code:** Lib/pdb.py\n'
+ '\n'
+ '======================================================================\n'
+ '\n'
+ 'The module "pdb" defines an interactive source code debugger '
+ 'for\n'
+ 'Python programs. It supports setting (conditional) breakpoints '
+ 'and\n'
+ 'single stepping at the source line level, inspection of stack '
+ 'frames,\n'
+ 'source code listing, and evaluation of arbitrary Python code in '
+ 'the\n'
+ 'context of any stack frame. It also supports post-mortem '
+ 'debugging\n'
+ 'and can be called under program control.\n'
+ '\n'
+ 'The debugger is extensible --- it is actually defined as the '
+ 'class\n'
+ '"Pdb". This is currently undocumented but easily understood by '
+ 'reading\n'
+ 'the source. The extension interface uses the modules "bdb" and '
+ '"cmd".\n'
+ '\n'
+ 'The debugger\'s prompt is "(Pdb)". Typical usage to run a '
+ 'program under\n'
+ 'control of the debugger is:\n'
+ '\n'
+ ' >>> import pdb\n'
+ ' >>> import mymodule\n'
+ " >>> pdb.run('mymodule.test()')\n"
+ ' > <string>(0)?()\n'
+ ' (Pdb) continue\n'
+ ' > <string>(1)?()\n'
+ ' (Pdb) continue\n'
+ " NameError: 'spam'\n"
+ ' > <string>(1)?()\n'
+ ' (Pdb)\n'
+ '\n'
+ '"pdb.py" can also be invoked as a script to debug other '
+ 'scripts. For\n'
+ 'example:\n'
+ '\n'
+ ' python -m pdb myscript.py\n'
+ '\n'
+ 'When invoked as a script, pdb will automatically enter '
+ 'post-mortem\n'
+ 'debugging if the program being debugged exits abnormally. After '
+ 'post-\n'
+ 'mortem debugging (or after normal exit of the program), pdb '
+ 'will\n'
+ "restart the program. Automatic restarting preserves pdb's state "
+ '(such\n'
+ 'as breakpoints) and in most cases is more useful than quitting '
+ 'the\n'
+ "debugger upon program's exit.\n"
+ '\n'
+ 'New in version 2.4: Restarting post-mortem behavior added.\n'
+ '\n'
+ 'The typical usage to break into the debugger from a running '
+ 'program is\n'
+ 'to insert\n'
+ '\n'
+ ' import pdb; pdb.set_trace()\n'
+ '\n'
+ 'at the location you want to break into the debugger. You can '
+ 'then\n'
+ 'step through the code following this statement, and continue '
+ 'running\n'
+ 'without the debugger using the "c" command.\n'
+ '\n'
+ 'The typical usage to inspect a crashed program is:\n'
+ '\n'
+ ' >>> import pdb\n'
+ ' >>> import mymodule\n'
+ ' >>> mymodule.test()\n'
+ ' Traceback (most recent call last):\n'
+ ' File "<stdin>", line 1, in <module>\n'
+ ' File "./mymodule.py", line 4, in test\n'
+ ' test2()\n'
+ ' File "./mymodule.py", line 3, in test2\n'
+ ' print spam\n'
+ ' NameError: spam\n'
+ ' >>> pdb.pm()\n'
+ ' > ./mymodule.py(3)test2()\n'
+ ' -> print spam\n'
+ ' (Pdb)\n'
+ '\n'
+ 'The module defines the following functions; each enters the '
+ 'debugger\n'
+ 'in a slightly different way:\n'
+ '\n'
+ 'pdb.run(statement[, globals[, locals]])\n'
+ '\n'
+ ' Execute the *statement* (given as a string) under debugger '
+ 'control.\n'
+ ' The debugger prompt appears before any code is executed; you '
+ 'can\n'
+ ' set breakpoints and type "continue", or you can step through '
+ 'the\n'
+ ' statement using "step" or "next" (all these commands are '
+ 'explained\n'
+ ' below). The optional *globals* and *locals* arguments '
+ 'specify the\n'
+ ' environment in which the code is executed; by default the\n'
+ ' dictionary of the module "__main__" is used. (See the '
+ 'explanation\n'
+ ' of the "exec" statement or the "eval()" built-in function.)\n'
+ '\n'
+ 'pdb.runeval(expression[, globals[, locals]])\n'
+ '\n'
+ ' Evaluate the *expression* (given as a string) under debugger\n'
+ ' control. When "runeval()" returns, it returns the value of '
+ 'the\n'
+ ' expression. Otherwise this function is similar to "run()".\n'
+ '\n'
+ 'pdb.runcall(function[, argument, ...])\n'
+ '\n'
+ ' Call the *function* (a function or method object, not a '
+ 'string)\n'
+ ' with the given arguments. When "runcall()" returns, it '
+ 'returns\n'
+ ' whatever the function call returned. The debugger prompt '
+ 'appears\n'
+ ' as soon as the function is entered.\n'
+ '\n'
+ 'pdb.set_trace()\n'
+ '\n'
+ ' Enter the debugger at the calling stack frame. This is '
+ 'useful to\n'
+ ' hard-code a breakpoint at a given point in a program, even if '
+ 'the\n'
+ ' code is not otherwise being debugged (e.g. when an assertion\n'
+ ' fails).\n'
+ '\n'
+ 'pdb.post_mortem([traceback])\n'
+ '\n'
+ ' Enter post-mortem debugging of the given *traceback* object. '
+ 'If no\n'
+ ' *traceback* is given, it uses the one of the exception that '
+ 'is\n'
+ ' currently being handled (an exception must be being handled '
+ 'if the\n'
+ ' default is to be used).\n'
+ '\n'
+ 'pdb.pm()\n'
+ '\n'
+ ' Enter post-mortem debugging of the traceback found in\n'
+ ' "sys.last_traceback".\n'
+ '\n'
+ 'The "run*" functions and "set_trace()" are aliases for '
+ 'instantiating\n'
+ 'the "Pdb" class and calling the method of the same name. If you '
+ 'want\n'
+ 'to access further features, you have to do this yourself:\n'
+ '\n'
+ "class pdb.Pdb(completekey='tab', stdin=None, stdout=None, "
+ 'skip=None)\n'
+ '\n'
+ ' "Pdb" is the debugger class.\n'
+ '\n'
+ ' The *completekey*, *stdin* and *stdout* arguments are passed '
+ 'to the\n'
+ ' underlying "cmd.Cmd" class; see the description there.\n'
+ '\n'
+ ' The *skip* argument, if given, must be an iterable of '
+ 'glob-style\n'
+ ' module name patterns. The debugger will not step into frames '
+ 'that\n'
+ ' originate in a module that matches one of these patterns. '
+ '[1]\n'
+ '\n'
+ ' Example call to enable tracing with *skip*:\n'
+ '\n'
+ " import pdb; pdb.Pdb(skip=['django.*']).set_trace()\n"
+ '\n'
+ ' New in version 2.7: The *skip* argument.\n'
+ '\n'
+ ' run(statement[, globals[, locals]])\n'
+ ' runeval(expression[, globals[, locals]])\n'
+ ' runcall(function[, argument, ...])\n'
+ ' set_trace()\n'
+ '\n'
+ ' See the documentation for the functions explained above.\n',
+ 'del': '\n'
+ 'The "del" statement\n'
+ '*******************\n'
+ '\n'
+ ' del_stmt ::= "del" target_list\n'
+ '\n'
+ 'Deletion is recursively defined very similar to the way assignment '
+ 'is\n'
+ 'defined. Rather than spelling it out in full details, here are some\n'
+ 'hints.\n'
+ '\n'
+ 'Deletion of a target list recursively deletes each target, from left\n'
+ 'to right.\n'
+ '\n'
+ 'Deletion of a name removes the binding of that name from the local '
+ 'or\n'
+ 'global namespace, depending on whether the name occurs in a "global"\n'
+ 'statement in the same code block. If the name is unbound, a\n'
+ '"NameError" exception will be raised.\n'
+ '\n'
+ 'It is illegal to delete a name from the local namespace if it occurs\n'
+ 'as a free variable in a nested block.\n'
+ '\n'
+ 'Deletion of attribute references, subscriptions and slicings is '
+ 'passed\n'
+ 'to the primary object involved; deletion of a slicing is in general\n'
+ 'equivalent to assignment of an empty slice of the right type (but '
+ 'even\n'
+ 'this is determined by the sliced object).\n',
+ 'dict': '\n'
+ 'Dictionary displays\n'
+ '*******************\n'
+ '\n'
+ 'A dictionary display is a possibly empty series of key/datum pairs\n'
+ 'enclosed in curly braces:\n'
+ '\n'
+ ' dict_display ::= "{" [key_datum_list | dict_comprehension] '
+ '"}"\n'
+ ' key_datum_list ::= key_datum ("," key_datum)* [","]\n'
+ ' key_datum ::= expression ":" expression\n'
+ ' dict_comprehension ::= expression ":" expression comp_for\n'
+ '\n'
+ 'A dictionary display yields a new dictionary object.\n'
+ '\n'
+ 'If a comma-separated sequence of key/datum pairs is given, they are\n'
+ 'evaluated from left to right to define the entries of the '
+ 'dictionary:\n'
+ 'each key object is used as a key into the dictionary to store the\n'
+ 'corresponding datum. This means that you can specify the same key\n'
+ "multiple times in the key/datum list, and the final dictionary's "
+ 'value\n'
+ 'for that key will be the last one given.\n'
+ '\n'
+ 'A dict comprehension, in contrast to list and set comprehensions,\n'
+ 'needs two expressions separated with a colon followed by the usual\n'
+ '"for" and "if" clauses. When the comprehension is run, the '
+ 'resulting\n'
+ 'key and value elements are inserted in the new dictionary in the '
+ 'order\n'
+ 'they are produced.\n'
+ '\n'
+ 'Restrictions on the types of the key values are listed earlier in\n'
+ 'section The standard type hierarchy. (To summarize, the key type\n'
+ 'should be *hashable*, which excludes all mutable objects.) Clashes\n'
+ 'between duplicate keys are not detected; the last datum (textually\n'
+ 'rightmost in the display) stored for a given key value prevails.\n',
+ 'dynamic-features': '\n'
+ 'Interaction with dynamic features\n'
+ '*********************************\n'
+ '\n'
+ 'There are several cases where Python statements are '
+ 'illegal when used\n'
+ 'in conjunction with nested scopes that contain free '
+ 'variables.\n'
+ '\n'
+ 'If a variable is referenced in an enclosing scope, it is '
+ 'illegal to\n'
+ 'delete the name. An error will be reported at compile '
+ 'time.\n'
+ '\n'
+ 'If the wild card form of import --- "import *" --- is '
+ 'used in a\n'
+ 'function and the function contains or is a nested block '
+ 'with free\n'
+ 'variables, the compiler will raise a "SyntaxError".\n'
+ '\n'
+ 'If "exec" is used in a function and the function '
+ 'contains or is a\n'
+ 'nested block with free variables, the compiler will '
+ 'raise a\n'
+ '"SyntaxError" unless the exec explicitly specifies the '
+ 'local namespace\n'
+ 'for the "exec". (In other words, "exec obj" would be '
+ 'illegal, but\n'
+ '"exec obj in ns" would be legal.)\n'
+ '\n'
+ 'The "eval()", "execfile()", and "input()" functions and '
+ 'the "exec"\n'
+ 'statement do not have access to the full environment for '
+ 'resolving\n'
+ 'names. Names may be resolved in the local and global '
+ 'namespaces of\n'
+ 'the caller. Free variables are not resolved in the '
+ 'nearest enclosing\n'
+ 'namespace, but in the global namespace. [1] The "exec" '
+ 'statement and\n'
+ 'the "eval()" and "execfile()" functions have optional '
+ 'arguments to\n'
+ 'override the global and local namespace. If only one '
+ 'namespace is\n'
+ 'specified, it is used for both.\n',
+ 'else': '\n'
+ 'The "if" statement\n'
+ '******************\n'
+ '\n'
+ 'The "if" statement is used for conditional execution:\n'
+ '\n'
+ ' if_stmt ::= "if" expression ":" suite\n'
+ ' ( "elif" expression ":" suite )*\n'
+ ' ["else" ":" suite]\n'
+ '\n'
+ 'It selects exactly one of the suites by evaluating the expressions '
+ 'one\n'
+ 'by one until one is found to be true (see section Boolean '
+ 'operations\n'
+ 'for the definition of true and false); then that suite is executed\n'
+ '(and no other part of the "if" statement is executed or evaluated).\n'
+ 'If all expressions are false, the suite of the "else" clause, if\n'
+ 'present, is executed.\n',
+ 'exceptions': '\n'
+ 'Exceptions\n'
+ '**********\n'
+ '\n'
+ 'Exceptions are a means of breaking out of the normal flow of '
+ 'control\n'
+ 'of a code block in order to handle errors or other '
+ 'exceptional\n'
+ 'conditions. An exception is *raised* at the point where the '
+ 'error is\n'
+ 'detected; it may be *handled* by the surrounding code block or '
+ 'by any\n'
+ 'code block that directly or indirectly invoked the code block '
+ 'where\n'
+ 'the error occurred.\n'
+ '\n'
+ 'The Python interpreter raises an exception when it detects a '
+ 'run-time\n'
+ 'error (such as division by zero). A Python program can also\n'
+ 'explicitly raise an exception with the "raise" statement. '
+ 'Exception\n'
+ 'handlers are specified with the "try" ... "except" statement. '
+ 'The\n'
+ '"finally" clause of such a statement can be used to specify '
+ 'cleanup\n'
+ 'code which does not handle the exception, but is executed '
+ 'whether an\n'
+ 'exception occurred or not in the preceding code.\n'
+ '\n'
+ 'Python uses the "termination" model of error handling: an '
+ 'exception\n'
+ 'handler can find out what happened and continue execution at '
+ 'an outer\n'
+ 'level, but it cannot repair the cause of the error and retry '
+ 'the\n'
+ 'failing operation (except by re-entering the offending piece '
+ 'of code\n'
+ 'from the top).\n'
+ '\n'
+ 'When an exception is not handled at all, the interpreter '
+ 'terminates\n'
+ 'execution of the program, or returns to its interactive main '
+ 'loop. In\n'
+ 'either case, it prints a stack backtrace, except when the '
+ 'exception is\n'
+ '"SystemExit".\n'
+ '\n'
+ 'Exceptions are identified by class instances. The "except" '
+ 'clause is\n'
+ 'selected depending on the class of the instance: it must '
+ 'reference the\n'
+ 'class of the instance or a base class thereof. The instance '
+ 'can be\n'
+ 'received by the handler and can carry additional information '
+ 'about the\n'
+ 'exceptional condition.\n'
+ '\n'
+ 'Exceptions can also be identified by strings, in which case '
+ 'the\n'
+ '"except" clause is selected by object identity. An arbitrary '
+ 'value\n'
+ 'can be raised along with the identifying string which can be '
+ 'passed to\n'
+ 'the handler.\n'
+ '\n'
+ 'Note: Messages to exceptions are not part of the Python API. '
+ 'Their\n'
+ ' contents may change from one version of Python to the next '
+ 'without\n'
+ ' warning and should not be relied on by code which will run '
+ 'under\n'
+ ' multiple versions of the interpreter.\n'
+ '\n'
+ 'See also the description of the "try" statement in section The '
+ 'try\n'
+ 'statement and "raise" statement in section The raise '
+ 'statement.\n'
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ '[1] This limitation occurs because the code that is executed '
+ 'by\n'
+ ' these operations is not available at the time the module '
+ 'is\n'
+ ' compiled.\n',
+ 'exec': '\n'
+ 'The "exec" statement\n'
+ '********************\n'
+ '\n'
+ ' exec_stmt ::= "exec" or_expr ["in" expression ["," expression]]\n'
+ '\n'
+ 'This statement supports dynamic execution of Python code. The '
+ 'first\n'
+ 'expression should evaluate to either a Unicode string, a *Latin-1*\n'
+ 'encoded string, an open file object, a code object, or a tuple. If '
+ 'it\n'
+ 'is a string, the string is parsed as a suite of Python statements\n'
+ 'which is then executed (unless a syntax error occurs). [1] If it is '
+ 'an\n'
+ 'open file, the file is parsed until EOF and executed. If it is a '
+ 'code\n'
+ 'object, it is simply executed. For the interpretation of a tuple, '
+ 'see\n'
+ "below. In all cases, the code that's executed is expected to be "
+ 'valid\n'
+ 'as file input (see section File input). Be aware that the "return"\n'
+ 'and "yield" statements may not be used outside of function '
+ 'definitions\n'
+ 'even within the context of code passed to the "exec" statement.\n'
+ '\n'
+ 'In all cases, if the optional parts are omitted, the code is '
+ 'executed\n'
+ 'in the current scope. If only the first expression after "in" is\n'
+ 'specified, it should be a dictionary, which will be used for both '
+ 'the\n'
+ 'global and the local variables. If two expressions are given, they\n'
+ 'are used for the global and local variables, respectively. If\n'
+ 'provided, *locals* can be any mapping object. Remember that at '
+ 'module\n'
+ 'level, globals and locals are the same dictionary. If two separate\n'
+ 'objects are given as *globals* and *locals*, the code will be '
+ 'executed\n'
+ 'as if it were embedded in a class definition.\n'
+ '\n'
+ 'The first expression may also be a tuple of length 2 or 3. In this\n'
+ 'case, the optional parts must be omitted. The form "exec(expr,\n'
+ 'globals)" is equivalent to "exec expr in globals", while the form\n'
+ '"exec(expr, globals, locals)" is equivalent to "exec expr in '
+ 'globals,\n'
+ 'locals". The tuple form of "exec" provides compatibility with '
+ 'Python\n'
+ '3, where "exec" is a function rather than a statement.\n'
+ '\n'
+ 'Changed in version 2.4: Formerly, *locals* was required to be a\n'
+ 'dictionary.\n'
+ '\n'
+ 'As a side effect, an implementation may insert additional keys into\n'
+ 'the dictionaries given besides those corresponding to variable '
+ 'names\n'
+ 'set by the executed code. For example, the current implementation '
+ 'may\n'
+ 'add a reference to the dictionary of the built-in module '
+ '"__builtin__"\n'
+ 'under the key "__builtins__" (!).\n'
+ '\n'
+ "**Programmer's hints:** dynamic evaluation of expressions is "
+ 'supported\n'
+ 'by the built-in function "eval()". The built-in functions '
+ '"globals()"\n'
+ 'and "locals()" return the current global and local dictionary,\n'
+ 'respectively, which may be useful to pass around for use by "exec".\n'
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ '[1] Note that the parser only accepts the Unix-style end of line\n'
+ ' convention. If you are reading the code from a file, make sure '
+ 'to\n'
+ ' use *universal newlines* mode to convert Windows or Mac-style\n'
+ ' newlines.\n',
+ 'execmodel': '\n'
+ 'Execution model\n'
+ '***************\n'
+ '\n'
+ '\n'
+ 'Naming and binding\n'
+ '==================\n'
+ '\n'
+ '*Names* refer to objects. Names are introduced by name '
+ 'binding\n'
+ 'operations. Each occurrence of a name in the program text '
+ 'refers to\n'
+ 'the *binding* of that name established in the innermost '
+ 'function block\n'
+ 'containing the use.\n'
+ '\n'
+ 'A *block* is a piece of Python program text that is executed as '
+ 'a\n'
+ 'unit. The following are blocks: a module, a function body, and '
+ 'a class\n'
+ 'definition. Each command typed interactively is a block. A '
+ 'script\n'
+ 'file (a file given as standard input to the interpreter or '
+ 'specified\n'
+ 'on the interpreter command line the first argument) is a code '
+ 'block.\n'
+ 'A script command (a command specified on the interpreter '
+ 'command line\n'
+ "with the '**-c**' option) is a code block. The file read by "
+ 'the\n'
+ 'built-in function "execfile()" is a code block. The string '
+ 'argument\n'
+ 'passed to the built-in function "eval()" and to the "exec" '
+ 'statement\n'
+ 'is a code block. The expression read and evaluated by the '
+ 'built-in\n'
+ 'function "input()" is a code block.\n'
+ '\n'
+ 'A code block is executed in an *execution frame*. A frame '
+ 'contains\n'
+ 'some administrative information (used for debugging) and '
+ 'determines\n'
+ "where and how execution continues after the code block's "
+ 'execution has\n'
+ 'completed.\n'
+ '\n'
+ 'A *scope* defines the visibility of a name within a block. If '
+ 'a local\n'
+ 'variable is defined in a block, its scope includes that block. '
+ 'If the\n'
+ 'definition occurs in a function block, the scope extends to any '
+ 'blocks\n'
+ 'contained within the defining one, unless a contained block '
+ 'introduces\n'
+ 'a different binding for the name. The scope of names defined '
+ 'in a\n'
+ 'class block is limited to the class block; it does not extend '
+ 'to the\n'
+ 'code blocks of methods -- this includes generator expressions '
+ 'since\n'
+ 'they are implemented using a function scope. This means that '
+ 'the\n'
+ 'following will fail:\n'
+ '\n'
+ ' class A:\n'
+ ' a = 42\n'
+ ' b = list(a + i for i in range(10))\n'
+ '\n'
+ 'When a name is used in a code block, it is resolved using the '
+ 'nearest\n'
+ 'enclosing scope. The set of all such scopes visible to a code '
+ 'block\n'
+ "is called the block's *environment*.\n"
+ '\n'
+ 'If a name is bound in a block, it is a local variable of that '
+ 'block.\n'
+ 'If a name is bound at the module level, it is a global '
+ 'variable. (The\n'
+ 'variables of the module code block are local and global.) If '
+ 'a\n'
+ 'variable is used in a code block but not defined there, it is a '
+ '*free\n'
+ 'variable*.\n'
+ '\n'
+ 'When a name is not found at all, a "NameError" exception is '
+ 'raised.\n'
+ 'If the name refers to a local variable that has not been bound, '
+ 'a\n'
+ '"UnboundLocalError" exception is raised. "UnboundLocalError" '
+ 'is a\n'
+ 'subclass of "NameError".\n'
+ '\n'
+ 'The following constructs bind names: formal parameters to '
+ 'functions,\n'
+ '"import" statements, class and function definitions (these bind '
+ 'the\n'
+ 'class or function name in the defining block), and targets that '
+ 'are\n'
+ 'identifiers if occurring in an assignment, "for" loop header, '
+ 'in the\n'
+ 'second position of an "except" clause header or after "as" in a '
+ '"with"\n'
+ 'statement. The "import" statement of the form "from ... import '
+ '*"\n'
+ 'binds all names defined in the imported module, except those '
+ 'beginning\n'
+ 'with an underscore. This form may only be used at the module '
+ 'level.\n'
+ '\n'
+ 'A target occurring in a "del" statement is also considered '
+ 'bound for\n'
+ 'this purpose (though the actual semantics are to unbind the '
+ 'name). It\n'
+ 'is illegal to unbind a name that is referenced by an enclosing '
+ 'scope;\n'
+ 'the compiler will report a "SyntaxError".\n'
+ '\n'
+ 'Each assignment or import statement occurs within a block '
+ 'defined by a\n'
+ 'class or function definition or at the module level (the '
+ 'top-level\n'
+ 'code block).\n'
+ '\n'
+ 'If a name binding operation occurs anywhere within a code '
+ 'block, all\n'
+ 'uses of the name within the block are treated as references to '
+ 'the\n'
+ 'current block. This can lead to errors when a name is used '
+ 'within a\n'
+ 'block before it is bound. This rule is subtle. Python lacks\n'
+ 'declarations and allows name binding operations to occur '
+ 'anywhere\n'
+ 'within a code block. The local variables of a code block can '
+ 'be\n'
+ 'determined by scanning the entire text of the block for name '
+ 'binding\n'
+ 'operations.\n'
+ '\n'
+ 'If the global statement occurs within a block, all uses of the '
+ 'name\n'
+ 'specified in the statement refer to the binding of that name in '
+ 'the\n'
+ 'top-level namespace. Names are resolved in the top-level '
+ 'namespace by\n'
+ 'searching the global namespace, i.e. the namespace of the '
+ 'module\n'
+ 'containing the code block, and the builtins namespace, the '
+ 'namespace\n'
+ 'of the module "__builtin__". The global namespace is searched '
+ 'first.\n'
+ 'If the name is not found there, the builtins namespace is '
+ 'searched.\n'
+ 'The global statement must precede all uses of the name.\n'
+ '\n'
+ 'The builtins namespace associated with the execution of a code '
+ 'block\n'
+ 'is actually found by looking up the name "__builtins__" in its '
+ 'global\n'
+ 'namespace; this should be a dictionary or a module (in the '
+ 'latter case\n'
+ "the module's dictionary is used). By default, when in the "
+ '"__main__"\n'
+ 'module, "__builtins__" is the built-in module "__builtin__" '
+ '(note: no\n'
+ '\'s\'); when in any other module, "__builtins__" is an alias '
+ 'for the\n'
+ 'dictionary of the "__builtin__" module itself. "__builtins__" '
+ 'can be\n'
+ 'set to a user-created dictionary to create a weak form of '
+ 'restricted\n'
+ 'execution.\n'
+ '\n'
+ '**CPython implementation detail:** Users should not touch\n'
+ '"__builtins__"; it is strictly an implementation detail. '
+ 'Users\n'
+ 'wanting to override values in the builtins namespace should '
+ '"import"\n'
+ 'the "__builtin__" (no \'s\') module and modify its attributes\n'
+ 'appropriately.\n'
+ '\n'
+ 'The namespace for a module is automatically created the first '
+ 'time a\n'
+ 'module is imported. The main module for a script is always '
+ 'called\n'
+ '"__main__".\n'
+ '\n'
+ 'The "global" statement has the same scope as a name binding '
+ 'operation\n'
+ 'in the same block. If the nearest enclosing scope for a free '
+ 'variable\n'
+ 'contains a global statement, the free variable is treated as a '
+ 'global.\n'
+ '\n'
+ 'A class definition is an executable statement that may use and '
+ 'define\n'
+ 'names. These references follow the normal rules for name '
+ 'resolution.\n'
+ 'The namespace of the class definition becomes the attribute '
+ 'dictionary\n'
+ 'of the class. Names defined at the class scope are not visible '
+ 'in\n'
+ 'methods.\n'
+ '\n'
+ '\n'
+ 'Interaction with dynamic features\n'
+ '---------------------------------\n'
+ '\n'
+ 'There are several cases where Python statements are illegal '
+ 'when used\n'
+ 'in conjunction with nested scopes that contain free variables.\n'
+ '\n'
+ 'If a variable is referenced in an enclosing scope, it is '
+ 'illegal to\n'
+ 'delete the name. An error will be reported at compile time.\n'
+ '\n'
+ 'If the wild card form of import --- "import *" --- is used in '
+ 'a\n'
+ 'function and the function contains or is a nested block with '
+ 'free\n'
+ 'variables, the compiler will raise a "SyntaxError".\n'
+ '\n'
+ 'If "exec" is used in a function and the function contains or is '
+ 'a\n'
+ 'nested block with free variables, the compiler will raise a\n'
+ '"SyntaxError" unless the exec explicitly specifies the local '
+ 'namespace\n'
+ 'for the "exec". (In other words, "exec obj" would be illegal, '
+ 'but\n'
+ '"exec obj in ns" would be legal.)\n'
+ '\n'
+ 'The "eval()", "execfile()", and "input()" functions and the '
+ '"exec"\n'
+ 'statement do not have access to the full environment for '
+ 'resolving\n'
+ 'names. Names may be resolved in the local and global '
+ 'namespaces of\n'
+ 'the caller. Free variables are not resolved in the nearest '
+ 'enclosing\n'
+ 'namespace, but in the global namespace. [1] The "exec" '
+ 'statement and\n'
+ 'the "eval()" and "execfile()" functions have optional arguments '
+ 'to\n'
+ 'override the global and local namespace. If only one namespace '
+ 'is\n'
+ 'specified, it is used for both.\n'
+ '\n'
+ '\n'
+ 'Exceptions\n'
+ '==========\n'
+ '\n'
+ 'Exceptions are a means of breaking out of the normal flow of '
+ 'control\n'
+ 'of a code block in order to handle errors or other exceptional\n'
+ 'conditions. An exception is *raised* at the point where the '
+ 'error is\n'
+ 'detected; it may be *handled* by the surrounding code block or '
+ 'by any\n'
+ 'code block that directly or indirectly invoked the code block '
+ 'where\n'
+ 'the error occurred.\n'
+ '\n'
+ 'The Python interpreter raises an exception when it detects a '
+ 'run-time\n'
+ 'error (such as division by zero). A Python program can also\n'
+ 'explicitly raise an exception with the "raise" statement. '
+ 'Exception\n'
+ 'handlers are specified with the "try" ... "except" statement. '
+ 'The\n'
+ '"finally" clause of such a statement can be used to specify '
+ 'cleanup\n'
+ 'code which does not handle the exception, but is executed '
+ 'whether an\n'
+ 'exception occurred or not in the preceding code.\n'
+ '\n'
+ 'Python uses the "termination" model of error handling: an '
+ 'exception\n'
+ 'handler can find out what happened and continue execution at an '
+ 'outer\n'
+ 'level, but it cannot repair the cause of the error and retry '
+ 'the\n'
+ 'failing operation (except by re-entering the offending piece of '
+ 'code\n'
+ 'from the top).\n'
+ '\n'
+ 'When an exception is not handled at all, the interpreter '
+ 'terminates\n'
+ 'execution of the program, or returns to its interactive main '
+ 'loop. In\n'
+ 'either case, it prints a stack backtrace, except when the '
+ 'exception is\n'
+ '"SystemExit".\n'
+ '\n'
+ 'Exceptions are identified by class instances. The "except" '
+ 'clause is\n'
+ 'selected depending on the class of the instance: it must '
+ 'reference the\n'
+ 'class of the instance or a base class thereof. The instance '
+ 'can be\n'
+ 'received by the handler and can carry additional information '
+ 'about the\n'
+ 'exceptional condition.\n'
+ '\n'
+ 'Exceptions can also be identified by strings, in which case '
+ 'the\n'
+ '"except" clause is selected by object identity. An arbitrary '
+ 'value\n'
+ 'can be raised along with the identifying string which can be '
+ 'passed to\n'
+ 'the handler.\n'
+ '\n'
+ 'Note: Messages to exceptions are not part of the Python API. '
+ 'Their\n'
+ ' contents may change from one version of Python to the next '
+ 'without\n'
+ ' warning and should not be relied on by code which will run '
+ 'under\n'
+ ' multiple versions of the interpreter.\n'
+ '\n'
+ 'See also the description of the "try" statement in section The '
+ 'try\n'
+ 'statement and "raise" statement in section The raise '
+ 'statement.\n'
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ '[1] This limitation occurs because the code that is executed '
+ 'by\n'
+ ' these operations is not available at the time the module '
+ 'is\n'
+ ' compiled.\n',
+ 'exprlists': '\n'
+ 'Expression lists\n'
+ '****************\n'
+ '\n'
+ ' expression_list ::= expression ( "," expression )* [","]\n'
+ '\n'
+ 'An expression list containing at least one comma yields a '
+ 'tuple. The\n'
+ 'length of the tuple is the number of expressions in the list. '
+ 'The\n'
+ 'expressions are evaluated from left to right.\n'
+ '\n'
+ 'The trailing comma is required only to create a single tuple '
+ '(a.k.a. a\n'
+ '*singleton*); it is optional in all other cases. A single '
+ 'expression\n'
+ "without a trailing comma doesn't create a tuple, but rather "
+ 'yields the\n'
+ 'value of that expression. (To create an empty tuple, use an '
+ 'empty pair\n'
+ 'of parentheses: "()".)\n',
+ 'floating': '\n'
+ 'Floating point literals\n'
+ '***********************\n'
+ '\n'
+ 'Floating point literals are described by the following lexical\n'
+ 'definitions:\n'
+ '\n'
+ ' floatnumber ::= pointfloat | exponentfloat\n'
+ ' pointfloat ::= [intpart] fraction | intpart "."\n'
+ ' exponentfloat ::= (intpart | pointfloat) exponent\n'
+ ' intpart ::= digit+\n'
+ ' fraction ::= "." digit+\n'
+ ' exponent ::= ("e" | "E") ["+" | "-"] digit+\n'
+ '\n'
+ 'Note that the integer and exponent parts of floating point '
+ 'numbers can\n'
+ 'look like octal integers, but are interpreted using radix 10. '
+ 'For\n'
+ 'example, "077e010" is legal, and denotes the same number as '
+ '"77e10".\n'
+ 'The allowed range of floating point literals is implementation-\n'
+ 'dependent. Some examples of floating point literals:\n'
+ '\n'
+ ' 3.14 10. .001 1e100 3.14e-10 0e0\n'
+ '\n'
+ 'Note that numeric literals do not include a sign; a phrase like '
+ '"-1"\n'
+ 'is actually an expression composed of the unary operator "-" and '
+ 'the\n'
+ 'literal "1".\n',
+ 'for': '\n'
+ 'The "for" statement\n'
+ '*******************\n'
+ '\n'
+ 'The "for" statement is used to iterate over the elements of a '
+ 'sequence\n'
+ '(such as a string, tuple or list) or other iterable object:\n'
+ '\n'
+ ' for_stmt ::= "for" target_list "in" expression_list ":" suite\n'
+ ' ["else" ":" suite]\n'
+ '\n'
+ 'The expression list is evaluated once; it should yield an iterable\n'
+ 'object. An iterator is created for the result of the\n'
+ '"expression_list". The suite is then executed once for each item\n'
+ 'provided by the iterator, in the order of ascending indices. Each\n'
+ 'item in turn is assigned to the target list using the standard rules\n'
+ 'for assignments, and then the suite is executed. When the items are\n'
+ 'exhausted (which is immediately when the sequence is empty), the '
+ 'suite\n'
+ 'in the "else" clause, if present, is executed, and the loop\n'
+ 'terminates.\n'
+ '\n'
+ 'A "break" statement executed in the first suite terminates the loop\n'
+ 'without executing the "else" clause\'s suite. A "continue" '
+ 'statement\n'
+ 'executed in the first suite skips the rest of the suite and '
+ 'continues\n'
+ 'with the next item, or with the "else" clause if there was no next\n'
+ 'item.\n'
+ '\n'
+ 'The suite may assign to the variable(s) in the target list; this '
+ 'does\n'
+ 'not affect the next item assigned to it.\n'
+ '\n'
+ 'The target list is not deleted when the loop is finished, but if the\n'
+ 'sequence is empty, it will not have been assigned to at all by the\n'
+ 'loop. Hint: the built-in function "range()" returns a sequence of\n'
+ 'integers suitable to emulate the effect of Pascal\'s "for i := a to '
+ 'b\n'
+ 'do"; e.g., "range(3)" returns the list "[0, 1, 2]".\n'
+ '\n'
+ 'Note: There is a subtlety when the sequence is being modified by the\n'
+ ' loop (this can only occur for mutable sequences, i.e. lists). An\n'
+ ' internal counter is used to keep track of which item is used next,\n'
+ ' and this is incremented on each iteration. When this counter has\n'
+ ' reached the length of the sequence the loop terminates. This '
+ 'means\n'
+ ' that if the suite deletes the current (or a previous) item from '
+ 'the\n'
+ ' sequence, the next item will be skipped (since it gets the index '
+ 'of\n'
+ ' the current item which has already been treated). Likewise, if '
+ 'the\n'
+ ' suite inserts an item in the sequence before the current item, the\n'
+ ' current item will be treated again the next time through the loop.\n'
+ ' This can lead to nasty bugs that can be avoided by making a\n'
+ ' temporary copy using a slice of the whole sequence, e.g.,\n'
+ '\n'
+ ' for x in a[:]:\n'
+ ' if x < 0: a.remove(x)\n',
+ 'formatstrings': '\n'
+ 'Format String Syntax\n'
+ '********************\n'
+ '\n'
+ 'The "str.format()" method and the "Formatter" class share '
+ 'the same\n'
+ 'syntax for format strings (although in the case of '
+ '"Formatter",\n'
+ 'subclasses can define their own format string syntax).\n'
+ '\n'
+ 'Format strings contain "replacement fields" surrounded by '
+ 'curly braces\n'
+ '"{}". Anything that is not contained in braces is '
+ 'considered literal\n'
+ 'text, which is copied unchanged to the output. If you need '
+ 'to include\n'
+ 'a brace character in the literal text, it can be escaped by '
+ 'doubling:\n'
+ '"{{" and "}}".\n'
+ '\n'
+ 'The grammar for a replacement field is as follows:\n'
+ '\n'
+ ' replacement_field ::= "{" [field_name] ["!" '
+ 'conversion] [":" format_spec] "}"\n'
+ ' field_name ::= arg_name ("." attribute_name | '
+ '"[" element_index "]")*\n'
+ ' arg_name ::= [identifier | integer]\n'
+ ' attribute_name ::= identifier\n'
+ ' element_index ::= integer | index_string\n'
+ ' index_string ::= <any source character except '
+ '"]"> +\n'
+ ' conversion ::= "r" | "s"\n'
+ ' format_spec ::= <described in the next '
+ 'section>\n'
+ '\n'
+ 'In less formal terms, the replacement field can start with '
+ 'a\n'
+ '*field_name* that specifies the object whose value is to be '
+ 'formatted\n'
+ 'and inserted into the output instead of the replacement '
+ 'field. The\n'
+ '*field_name* is optionally followed by a *conversion* '
+ 'field, which is\n'
+ 'preceded by an exclamation point "\'!\'", and a '
+ '*format_spec*, which is\n'
+ 'preceded by a colon "\':\'". These specify a non-default '
+ 'format for the\n'
+ 'replacement value.\n'
+ '\n'
+ 'See also the Format Specification Mini-Language section.\n'
+ '\n'
+ 'The *field_name* itself begins with an *arg_name* that is '
+ 'either a\n'
+ "number or a keyword. If it's a number, it refers to a "
+ 'positional\n'
+ "argument, and if it's a keyword, it refers to a named "
+ 'keyword\n'
+ 'argument. If the numerical arg_names in a format string '
+ 'are 0, 1, 2,\n'
+ '... in sequence, they can all be omitted (not just some) '
+ 'and the\n'
+ 'numbers 0, 1, 2, ... will be automatically inserted in that '
+ 'order.\n'
+ 'Because *arg_name* is not quote-delimited, it is not '
+ 'possible to\n'
+ 'specify arbitrary dictionary keys (e.g., the strings '
+ '"\'10\'" or\n'
+ '"\':-]\'") within a format string. The *arg_name* can be '
+ 'followed by any\n'
+ 'number of index or attribute expressions. An expression of '
+ 'the form\n'
+ '"\'.name\'" selects the named attribute using "getattr()", '
+ 'while an\n'
+ 'expression of the form "\'[index]\'" does an index lookup '
+ 'using\n'
+ '"__getitem__()".\n'
+ '\n'
+ 'Changed in version 2.7: The positional argument specifiers '
+ 'can be\n'
+ 'omitted, so "\'{} {}\'" is equivalent to "\'{0} {1}\'".\n'
+ '\n'
+ 'Some simple format string examples:\n'
+ '\n'
+ ' "First, thou shalt count to {0}" # References first '
+ 'positional argument\n'
+ ' "Bring me a {}" # Implicitly '
+ 'references the first positional argument\n'
+ ' "From {} to {}" # Same as "From {0} to '
+ '{1}"\n'
+ ' "My quest is {name}" # References keyword '
+ "argument 'name'\n"
+ ' "Weight in tons {0.weight}" # \'weight\' attribute '
+ 'of first positional arg\n'
+ ' "Units destroyed: {players[0]}" # First element of '
+ "keyword argument 'players'.\n"
+ '\n'
+ 'The *conversion* field causes a type coercion before '
+ 'formatting.\n'
+ 'Normally, the job of formatting a value is done by the '
+ '"__format__()"\n'
+ 'method of the value itself. However, in some cases it is '
+ 'desirable to\n'
+ 'force a type to be formatted as a string, overriding its '
+ 'own\n'
+ 'definition of formatting. By converting the value to a '
+ 'string before\n'
+ 'calling "__format__()", the normal formatting logic is '
+ 'bypassed.\n'
+ '\n'
+ 'Two conversion flags are currently supported: "\'!s\'" '
+ 'which calls\n'
+ '"str()" on the value, and "\'!r\'" which calls "repr()".\n'
+ '\n'
+ 'Some examples:\n'
+ '\n'
+ ' "Harold\'s a clever {0!s}" # Calls str() on the '
+ 'argument first\n'
+ ' "Bring out the holy {name!r}" # Calls repr() on the '
+ 'argument first\n'
+ '\n'
+ 'The *format_spec* field contains a specification of how the '
+ 'value\n'
+ 'should be presented, including such details as field width, '
+ 'alignment,\n'
+ 'padding, decimal precision and so on. Each value type can '
+ 'define its\n'
+ 'own "formatting mini-language" or interpretation of the '
+ '*format_spec*.\n'
+ '\n'
+ 'Most built-in types support a common formatting '
+ 'mini-language, which\n'
+ 'is described in the next section.\n'
+ '\n'
+ 'A *format_spec* field can also include nested replacement '
+ 'fields\n'
+ 'within it. These nested replacement fields may contain a '
+ 'field name,\n'
+ 'conversion flag and format specification, but deeper '
+ 'nesting is not\n'
+ 'allowed. The replacement fields within the format_spec '
+ 'are\n'
+ 'substituted before the *format_spec* string is interpreted. '
+ 'This\n'
+ 'allows the formatting of a value to be dynamically '
+ 'specified.\n'
+ '\n'
+ 'See the Format examples section for some examples.\n'
+ '\n'
+ '\n'
+ 'Format Specification Mini-Language\n'
+ '==================================\n'
+ '\n'
+ '"Format specifications" are used within replacement fields '
+ 'contained\n'
+ 'within a format string to define how individual values are '
+ 'presented\n'
+ '(see Format String Syntax). They can also be passed '
+ 'directly to the\n'
+ 'built-in "format()" function. Each formattable type may '
+ 'define how\n'
+ 'the format specification is to be interpreted.\n'
+ '\n'
+ 'Most built-in types implement the following options for '
+ 'format\n'
+ 'specifications, although some of the formatting options are '
+ 'only\n'
+ 'supported by the numeric types.\n'
+ '\n'
+ 'A general convention is that an empty format string ("""") '
+ 'produces\n'
+ 'the same result as if you had called "str()" on the value. '
+ 'A non-empty\n'
+ 'format string typically modifies the result.\n'
+ '\n'
+ 'The general form of a *standard format specifier* is:\n'
+ '\n'
+ ' format_spec ::= '
+ '[[fill]align][sign][#][0][width][,][.precision][type]\n'
+ ' fill ::= <any character>\n'
+ ' align ::= "<" | ">" | "=" | "^"\n'
+ ' sign ::= "+" | "-" | " "\n'
+ ' width ::= integer\n'
+ ' precision ::= integer\n'
+ ' type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" '
+ '| "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"\n'
+ '\n'
+ 'If a valid *align* value is specified, it can be preceded '
+ 'by a *fill*\n'
+ 'character that can be any character and defaults to a space '
+ 'if\n'
+ 'omitted. It is not possible to use a literal curly brace '
+ '(""{"" or\n'
+ '""}"") as the *fill* character when using the '
+ '"str.format()" method.\n'
+ 'However, it is possible to insert a curly brace with a '
+ 'nested\n'
+ "replacement field. This limitation doesn't affect the "
+ '"format()"\n'
+ 'function.\n'
+ '\n'
+ 'The meaning of the various alignment options is as '
+ 'follows:\n'
+ '\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | Option | '
+ 'Meaning '
+ '|\n'
+ ' '
+ '+===========+============================================================+\n'
+ ' | "\'<\'" | Forces the field to be left-aligned '
+ 'within the available |\n'
+ ' | | space (this is the default for most '
+ 'objects). |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'>\'" | Forces the field to be right-aligned '
+ 'within the available |\n'
+ ' | | space (this is the default for '
+ 'numbers). |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'=\'" | Forces the padding to be placed after '
+ 'the sign (if any) |\n'
+ ' | | but before the digits. This is used for '
+ 'printing fields |\n'
+ " | | in the form '+000000120'. This alignment "
+ 'option is only |\n'
+ ' | | valid for numeric types. It becomes the '
+ "default when '0' |\n"
+ ' | | immediately precedes the field '
+ 'width. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'^\'" | Forces the field to be centered within '
+ 'the available |\n'
+ ' | | '
+ 'space. '
+ '|\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ '\n'
+ 'Note that unless a minimum field width is defined, the '
+ 'field width\n'
+ 'will always be the same size as the data to fill it, so '
+ 'that the\n'
+ 'alignment option has no meaning in this case.\n'
+ '\n'
+ 'The *sign* option is only valid for number types, and can '
+ 'be one of\n'
+ 'the following:\n'
+ '\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | Option | '
+ 'Meaning '
+ '|\n'
+ ' '
+ '+===========+============================================================+\n'
+ ' | "\'+\'" | indicates that a sign should be used for '
+ 'both positive as |\n'
+ ' | | well as negative '
+ 'numbers. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'-\'" | indicates that a sign should be used '
+ 'only for negative |\n'
+ ' | | numbers (this is the default '
+ 'behavior). |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | space | indicates that a leading space should be '
+ 'used on positive |\n'
+ ' | | numbers, and a minus sign on negative '
+ 'numbers. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ '\n'
+ 'The "\'#\'" option is only valid for integers, and only for '
+ 'binary,\n'
+ 'octal, or hexadecimal output. If present, it specifies '
+ 'that the\n'
+ 'output will be prefixed by "\'0b\'", "\'0o\'", or "\'0x\'", '
+ 'respectively.\n'
+ '\n'
+ 'The "\',\'" option signals the use of a comma for a '
+ 'thousands separator.\n'
+ 'For a locale aware separator, use the "\'n\'" integer '
+ 'presentation type\n'
+ 'instead.\n'
+ '\n'
+ 'Changed in version 2.7: Added the "\',\'" option (see also '
+ '**PEP 378**).\n'
+ '\n'
+ '*width* is a decimal integer defining the minimum field '
+ 'width. If not\n'
+ 'specified, then the field width will be determined by the '
+ 'content.\n'
+ '\n'
+ 'When no explicit alignment is given, preceding the *width* '
+ 'field by a\n'
+ 'zero ("\'0\'") character enables sign-aware zero-padding '
+ 'for numeric\n'
+ 'types. This is equivalent to a *fill* character of "\'0\'" '
+ 'with an\n'
+ '*alignment* type of "\'=\'".\n'
+ '\n'
+ 'The *precision* is a decimal number indicating how many '
+ 'digits should\n'
+ 'be displayed after the decimal point for a floating point '
+ 'value\n'
+ 'formatted with "\'f\'" and "\'F\'", or before and after the '
+ 'decimal point\n'
+ 'for a floating point value formatted with "\'g\'" or '
+ '"\'G\'". For non-\n'
+ 'number types the field indicates the maximum field size - '
+ 'in other\n'
+ 'words, how many characters will be used from the field '
+ 'content. The\n'
+ '*precision* is not allowed for integer values.\n'
+ '\n'
+ 'Finally, the *type* determines how the data should be '
+ 'presented.\n'
+ '\n'
+ 'The available string presentation types are:\n'
+ '\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | Type | '
+ 'Meaning '
+ '|\n'
+ ' '
+ '+===========+============================================================+\n'
+ ' | "\'s\'" | String format. This is the default type '
+ 'for strings and |\n'
+ ' | | may be '
+ 'omitted. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | None | The same as '
+ '"\'s\'". |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ '\n'
+ 'The available integer presentation types are:\n'
+ '\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | Type | '
+ 'Meaning '
+ '|\n'
+ ' '
+ '+===========+============================================================+\n'
+ ' | "\'b\'" | Binary format. Outputs the number in '
+ 'base 2. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'c\'" | Character. Converts the integer to the '
+ 'corresponding |\n'
+ ' | | unicode character before '
+ 'printing. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'d\'" | Decimal Integer. Outputs the number in '
+ 'base 10. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'o\'" | Octal format. Outputs the number in base '
+ '8. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'x\'" | Hex format. Outputs the number in base '
+ '16, using lower- |\n'
+ ' | | case letters for the digits above '
+ '9. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'X\'" | Hex format. Outputs the number in base '
+ '16, using upper- |\n'
+ ' | | case letters for the digits above '
+ '9. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'n\'" | Number. This is the same as "\'d\'", '
+ 'except that it uses the |\n'
+ ' | | current locale setting to insert the '
+ 'appropriate number |\n'
+ ' | | separator '
+ 'characters. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | None | The same as '
+ '"\'d\'". |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ '\n'
+ 'In addition to the above presentation types, integers can '
+ 'be formatted\n'
+ 'with the floating point presentation types listed below '
+ '(except "\'n\'"\n'
+ 'and "None"). When doing so, "float()" is used to convert '
+ 'the integer\n'
+ 'to a floating point number before formatting.\n'
+ '\n'
+ 'The available presentation types for floating point and '
+ 'decimal values\n'
+ 'are:\n'
+ '\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | Type | '
+ 'Meaning '
+ '|\n'
+ ' '
+ '+===========+============================================================+\n'
+ ' | "\'e\'" | Exponent notation. Prints the number in '
+ 'scientific |\n'
+ " | | notation using the letter 'e' to indicate "
+ 'the exponent. |\n'
+ ' | | The default precision is '
+ '"6". |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'E\'" | Exponent notation. Same as "\'e\'" '
+ 'except it uses an upper |\n'
+ " | | case 'E' as the separator "
+ 'character. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'f\'" | Fixed point. Displays the number as a '
+ 'fixed-point number. |\n'
+ ' | | The default precision is '
+ '"6". |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'F\'" | Fixed point. Same as '
+ '"\'f\'". |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'g\'" | General format. For a given precision '
+ '"p >= 1", this |\n'
+ ' | | rounds the number to "p" significant '
+ 'digits and then |\n'
+ ' | | formats the result in either fixed-point '
+ 'format or in |\n'
+ ' | | scientific notation, depending on its '
+ 'magnitude. The |\n'
+ ' | | precise rules are as follows: suppose that '
+ 'the result |\n'
+ ' | | formatted with presentation type "\'e\'" '
+ 'and precision "p-1" |\n'
+ ' | | would have exponent "exp". Then if "-4 <= '
+ 'exp < p", the |\n'
+ ' | | number is formatted with presentation type '
+ '"\'f\'" and |\n'
+ ' | | precision "p-1-exp". Otherwise, the '
+ 'number is formatted |\n'
+ ' | | with presentation type "\'e\'" and '
+ 'precision "p-1". In both |\n'
+ ' | | cases insignificant trailing zeros are '
+ 'removed from the |\n'
+ ' | | significand, and the decimal point is also '
+ 'removed if |\n'
+ ' | | there are no remaining digits following '
+ 'it. Positive and |\n'
+ ' | | negative infinity, positive and negative '
+ 'zero, and nans, |\n'
+ ' | | are formatted as "inf", "-inf", "0", "-0" '
+ 'and "nan" |\n'
+ ' | | respectively, regardless of the '
+ 'precision. A precision of |\n'
+ ' | | "0" is treated as equivalent to a '
+ 'precision of "1". The |\n'
+ ' | | default precision is '
+ '"6". |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'G\'" | General format. Same as "\'g\'" except '
+ 'switches to "\'E\'" if |\n'
+ ' | | the number gets too large. The '
+ 'representations of infinity |\n'
+ ' | | and NaN are uppercased, '
+ 'too. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'n\'" | Number. This is the same as "\'g\'", '
+ 'except that it uses the |\n'
+ ' | | current locale setting to insert the '
+ 'appropriate number |\n'
+ ' | | separator '
+ 'characters. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | "\'%\'" | Percentage. Multiplies the number by 100 '
+ 'and displays in |\n'
+ ' | | fixed ("\'f\'") format, followed by a '
+ 'percent sign. |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ ' | None | The same as '
+ '"\'g\'". |\n'
+ ' '
+ '+-----------+------------------------------------------------------------+\n'
+ '\n'
+ '\n'
+ 'Format examples\n'
+ '===============\n'
+ '\n'
+ 'This section contains examples of the "str.format()" syntax '
+ 'and\n'
+ 'comparison with the old "%"-formatting.\n'
+ '\n'
+ 'In most of the cases the syntax is similar to the old '
+ '"%"-formatting,\n'
+ 'with the addition of the "{}" and with ":" used instead of '
+ '"%". For\n'
+ 'example, "\'%03.2f\'" can be translated to "\'{:03.2f}\'".\n'
+ '\n'
+ 'The new format syntax also supports new and different '
+ 'options, shown\n'
+ 'in the follow examples.\n'
+ '\n'
+ 'Accessing arguments by position:\n'
+ '\n'
+ " >>> '{0}, {1}, {2}'.format('a', 'b', 'c')\n"
+ " 'a, b, c'\n"
+ " >>> '{}, {}, {}'.format('a', 'b', 'c') # 2.7+ only\n"
+ " 'a, b, c'\n"
+ " >>> '{2}, {1}, {0}'.format('a', 'b', 'c')\n"
+ " 'c, b, a'\n"
+ " >>> '{2}, {1}, {0}'.format(*'abc') # unpacking "
+ 'argument sequence\n'
+ " 'c, b, a'\n"
+ " >>> '{0}{1}{0}'.format('abra', 'cad') # arguments' "
+ 'indices can be repeated\n'
+ " 'abracadabra'\n"
+ '\n'
+ 'Accessing arguments by name:\n'
+ '\n'
+ " >>> 'Coordinates: {latitude}, "
+ "{longitude}'.format(latitude='37.24N', "
+ "longitude='-115.81W')\n"
+ " 'Coordinates: 37.24N, -115.81W'\n"
+ " >>> coord = {'latitude': '37.24N', 'longitude': "
+ "'-115.81W'}\n"
+ " >>> 'Coordinates: {latitude}, "
+ "{longitude}'.format(**coord)\n"
+ " 'Coordinates: 37.24N, -115.81W'\n"
+ '\n'
+ "Accessing arguments' attributes:\n"
+ '\n'
+ ' >>> c = 3-5j\n'
+ " >>> ('The complex number {0} is formed from the real "
+ "part {0.real} '\n"
+ " ... 'and the imaginary part {0.imag}.').format(c)\n"
+ " 'The complex number (3-5j) is formed from the real part "
+ "3.0 and the imaginary part -5.0.'\n"
+ ' >>> class Point(object):\n'
+ ' ... def __init__(self, x, y):\n'
+ ' ... self.x, self.y = x, y\n'
+ ' ... def __str__(self):\n'
+ " ... return 'Point({self.x}, "
+ "{self.y})'.format(self=self)\n"
+ ' ...\n'
+ ' >>> str(Point(4, 2))\n'
+ " 'Point(4, 2)'\n"
+ '\n'
+ "Accessing arguments' items:\n"
+ '\n'
+ ' >>> coord = (3, 5)\n'
+ " >>> 'X: {0[0]}; Y: {0[1]}'.format(coord)\n"
+ " 'X: 3; Y: 5'\n"
+ '\n'
+ 'Replacing "%s" and "%r":\n'
+ '\n'
+ ' >>> "repr() shows quotes: {!r}; str() doesn\'t: '
+ '{!s}".format(\'test1\', \'test2\')\n'
+ ' "repr() shows quotes: \'test1\'; str() doesn\'t: test2"\n'
+ '\n'
+ 'Aligning the text and specifying a width:\n'
+ '\n'
+ " >>> '{:<30}'.format('left aligned')\n"
+ " 'left aligned '\n"
+ " >>> '{:>30}'.format('right aligned')\n"
+ " ' right aligned'\n"
+ " >>> '{:^30}'.format('centered')\n"
+ " ' centered '\n"
+ " >>> '{:*^30}'.format('centered') # use '*' as a fill "
+ 'char\n'
+ " '***********centered***********'\n"
+ '\n'
+ 'Replacing "%+f", "%-f", and "% f" and specifying a sign:\n'
+ '\n'
+ " >>> '{:+f}; {:+f}'.format(3.14, -3.14) # show it "
+ 'always\n'
+ " '+3.140000; -3.140000'\n"
+ " >>> '{: f}; {: f}'.format(3.14, -3.14) # show a space "
+ 'for positive numbers\n'
+ " ' 3.140000; -3.140000'\n"
+ " >>> '{:-f}; {:-f}'.format(3.14, -3.14) # show only the "
+ "minus -- same as '{:f}; {:f}'\n"
+ " '3.140000; -3.140000'\n"
+ '\n'
+ 'Replacing "%x" and "%o" and converting the value to '
+ 'different bases:\n'
+ '\n'
+ ' >>> # format also supports binary numbers\n'
+ ' >>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: '
+ '{0:b}".format(42)\n'
+ " 'int: 42; hex: 2a; oct: 52; bin: 101010'\n"
+ ' >>> # with 0x, 0o, or 0b as prefix:\n'
+ ' >>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: '
+ '{0:#b}".format(42)\n'
+ " 'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'\n"
+ '\n'
+ 'Using the comma as a thousands separator:\n'
+ '\n'
+ " >>> '{:,}'.format(1234567890)\n"
+ " '1,234,567,890'\n"
+ '\n'
+ 'Expressing a percentage:\n'
+ '\n'
+ ' >>> points = 19.5\n'
+ ' >>> total = 22\n'
+ " >>> 'Correct answers: {:.2%}'.format(points/total)\n"
+ " 'Correct answers: 88.64%'\n"
+ '\n'
+ 'Using type-specific formatting:\n'
+ '\n'
+ ' >>> import datetime\n'
+ ' >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)\n'
+ " >>> '{:%Y-%m-%d %H:%M:%S}'.format(d)\n"
+ " '2010-07-04 12:15:58'\n"
+ '\n'
+ 'Nesting arguments and more complex examples:\n'
+ '\n'
+ " >>> for align, text in zip('<^>', ['left', 'center', "
+ "'right']):\n"
+ " ... '{0:{fill}{align}16}'.format(text, fill=align, "
+ 'align=align)\n'
+ ' ...\n'
+ " 'left<<<<<<<<<<<<'\n"
+ " '^^^^^center^^^^^'\n"
+ " '>>>>>>>>>>>right'\n"
+ ' >>>\n'
+ ' >>> octets = [192, 168, 0, 1]\n'
+ " >>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)\n"
+ " 'C0A80001'\n"
+ ' >>> int(_, 16)\n'
+ ' 3232235521\n'
+ ' >>>\n'
+ ' >>> width = 5\n'
+ ' >>> for num in range(5,12):\n'
+ " ... for base in 'dXob':\n"
+ " ... print '{0:{width}{base}}'.format(num, "
+ 'base=base, width=width),\n'
+ ' ... print\n'
+ ' ...\n'
+ ' 5 5 5 101\n'
+ ' 6 6 6 110\n'
+ ' 7 7 7 111\n'
+ ' 8 8 10 1000\n'
+ ' 9 9 11 1001\n'
+ ' 10 A 12 1010\n'
+ ' 11 B 13 1011\n',
+ 'function': '\n'
+ 'Function definitions\n'
+ '********************\n'
+ '\n'
+ 'A function definition defines a user-defined function object '
+ '(see\n'
+ 'section The standard type hierarchy):\n'
+ '\n'
+ ' decorated ::= decorators (classdef | funcdef)\n'
+ ' decorators ::= decorator+\n'
+ ' decorator ::= "@" dotted_name ["(" [argument_list [","]] '
+ '")"] NEWLINE\n'
+ ' funcdef ::= "def" funcname "(" [parameter_list] ")" '
+ '":" suite\n'
+ ' dotted_name ::= identifier ("." identifier)*\n'
+ ' parameter_list ::= (defparameter ",")*\n'
+ ' ( "*" identifier ["," "**" identifier]\n'
+ ' | "**" identifier\n'
+ ' | defparameter [","] )\n'
+ ' defparameter ::= parameter ["=" expression]\n'
+ ' sublist ::= parameter ("," parameter)* [","]\n'
+ ' parameter ::= identifier | "(" sublist ")"\n'
+ ' funcname ::= identifier\n'
+ '\n'
+ 'A function definition is an executable statement. Its execution '
+ 'binds\n'
+ 'the function name in the current local namespace to a function '
+ 'object\n'
+ '(a wrapper around the executable code for the function). This\n'
+ 'function object contains a reference to the current global '
+ 'namespace\n'
+ 'as the global namespace to be used when the function is called.\n'
+ '\n'
+ 'The function definition does not execute the function body; this '
+ 'gets\n'
+ 'executed only when the function is called. [3]\n'
+ '\n'
+ 'A function definition may be wrapped by one or more *decorator*\n'
+ 'expressions. Decorator expressions are evaluated when the '
+ 'function is\n'
+ 'defined, in the scope that contains the function definition. '
+ 'The\n'
+ 'result must be a callable, which is invoked with the function '
+ 'object\n'
+ 'as the only argument. The returned value is bound to the '
+ 'function name\n'
+ 'instead of the function object. Multiple decorators are applied '
+ 'in\n'
+ 'nested fashion. For example, the following code:\n'
+ '\n'
+ ' @f1(arg)\n'
+ ' @f2\n'
+ ' def func(): pass\n'
+ '\n'
+ 'is equivalent to:\n'
+ '\n'
+ ' def func(): pass\n'
+ ' func = f1(arg)(f2(func))\n'
+ '\n'
+ 'When one or more top-level *parameters* have the form '
+ '*parameter* "="\n'
+ '*expression*, the function is said to have "default parameter '
+ 'values."\n'
+ 'For a parameter with a default value, the corresponding '
+ '*argument* may\n'
+ "be omitted from a call, in which case the parameter's default "
+ 'value is\n'
+ 'substituted. If a parameter has a default value, all following\n'
+ 'parameters must also have a default value --- this is a '
+ 'syntactic\n'
+ 'restriction that is not expressed by the grammar.\n'
+ '\n'
+ '**Default parameter values are evaluated when the function '
+ 'definition\n'
+ 'is executed.** This means that the expression is evaluated '
+ 'once, when\n'
+ 'the function is defined, and that the same "pre-computed" value '
+ 'is\n'
+ 'used for each call. This is especially important to understand '
+ 'when a\n'
+ 'default parameter is a mutable object, such as a list or a '
+ 'dictionary:\n'
+ 'if the function modifies the object (e.g. by appending an item '
+ 'to a\n'
+ 'list), the default value is in effect modified. This is '
+ 'generally not\n'
+ 'what was intended. A way around this is to use "None" as the\n'
+ 'default, and explicitly test for it in the body of the function, '
+ 'e.g.:\n'
+ '\n'
+ ' def whats_on_the_telly(penguin=None):\n'
+ ' if penguin is None:\n'
+ ' penguin = []\n'
+ ' penguin.append("property of the zoo")\n'
+ ' return penguin\n'
+ '\n'
+ 'Function call semantics are described in more detail in section '
+ 'Calls.\n'
+ 'A function call always assigns values to all parameters '
+ 'mentioned in\n'
+ 'the parameter list, either from position arguments, from '
+ 'keyword\n'
+ 'arguments, or from default values. If the form ""*identifier"" '
+ 'is\n'
+ 'present, it is initialized to a tuple receiving any excess '
+ 'positional\n'
+ 'parameters, defaulting to the empty tuple. If the form\n'
+ '""**identifier"" is present, it is initialized to a new '
+ 'dictionary\n'
+ 'receiving any excess keyword arguments, defaulting to a new '
+ 'empty\n'
+ 'dictionary.\n'
+ '\n'
+ 'It is also possible to create anonymous functions (functions not '
+ 'bound\n'
+ 'to a name), for immediate use in expressions. This uses lambda\n'
+ 'expressions, described in section Lambdas. Note that the '
+ 'lambda\n'
+ 'expression is merely a shorthand for a simplified function '
+ 'definition;\n'
+ 'a function defined in a ""def"" statement can be passed around '
+ 'or\n'
+ 'assigned to another name just like a function defined by a '
+ 'lambda\n'
+ 'expression. The ""def"" form is actually more powerful since '
+ 'it\n'
+ 'allows the execution of multiple statements.\n'
+ '\n'
+ "**Programmer's note:** Functions are first-class objects. A "
+ '""def""\n'
+ 'form executed inside a function definition defines a local '
+ 'function\n'
+ 'that can be returned or passed around. Free variables used in '
+ 'the\n'
+ 'nested function can access the local variables of the function\n'
+ 'containing the def. See section Naming and binding for '
+ 'details.\n',
+ 'global': '\n'
+ 'The "global" statement\n'
+ '**********************\n'
+ '\n'
+ ' global_stmt ::= "global" identifier ("," identifier)*\n'
+ '\n'
+ 'The "global" statement is a declaration which holds for the '
+ 'entire\n'
+ 'current code block. It means that the listed identifiers are to '
+ 'be\n'
+ 'interpreted as globals. It would be impossible to assign to a '
+ 'global\n'
+ 'variable without "global", although free variables may refer to\n'
+ 'globals without being declared global.\n'
+ '\n'
+ 'Names listed in a "global" statement must not be used in the same '
+ 'code\n'
+ 'block textually preceding that "global" statement.\n'
+ '\n'
+ 'Names listed in a "global" statement must not be defined as '
+ 'formal\n'
+ 'parameters or in a "for" loop control target, "class" definition,\n'
+ 'function definition, or "import" statement.\n'
+ '\n'
+ '**CPython implementation detail:** The current implementation does '
+ 'not\n'
+ 'enforce the latter two restrictions, but programs should not '
+ 'abuse\n'
+ 'this freedom, as future implementations may enforce them or '
+ 'silently\n'
+ 'change the meaning of the program.\n'
+ '\n'
+ '**Programmer\'s note:** "global" is a directive to the parser. '
+ 'It\n'
+ 'applies only to code parsed at the same time as the "global"\n'
+ 'statement. In particular, a "global" statement contained in an '
+ '"exec"\n'
+ 'statement does not affect the code block *containing* the "exec"\n'
+ 'statement, and code contained in an "exec" statement is unaffected '
+ 'by\n'
+ '"global" statements in the code containing the "exec" statement. '
+ 'The\n'
+ 'same applies to the "eval()", "execfile()" and "compile()" '
+ 'functions.\n',
+ 'id-classes': '\n'
+ 'Reserved classes of identifiers\n'
+ '*******************************\n'
+ '\n'
+ 'Certain classes of identifiers (besides keywords) have '
+ 'special\n'
+ 'meanings. These classes are identified by the patterns of '
+ 'leading and\n'
+ 'trailing underscore characters:\n'
+ '\n'
+ '"_*"\n'
+ ' Not imported by "from module import *". The special '
+ 'identifier "_"\n'
+ ' is used in the interactive interpreter to store the result '
+ 'of the\n'
+ ' last evaluation; it is stored in the "__builtin__" module. '
+ 'When\n'
+ ' not in interactive mode, "_" has no special meaning and is '
+ 'not\n'
+ ' defined. See section The import statement.\n'
+ '\n'
+ ' Note: The name "_" is often used in conjunction with\n'
+ ' internationalization; refer to the documentation for the\n'
+ ' "gettext" module for more information on this '
+ 'convention.\n'
+ '\n'
+ '"__*__"\n'
+ ' System-defined names. These names are defined by the '
+ 'interpreter\n'
+ ' and its implementation (including the standard library). '
+ 'Current\n'
+ ' system names are discussed in the Special method names '
+ 'section and\n'
+ ' elsewhere. More will likely be defined in future versions '
+ 'of\n'
+ ' Python. *Any* use of "__*__" names, in any context, that '
+ 'does not\n'
+ ' follow explicitly documented use, is subject to breakage '
+ 'without\n'
+ ' warning.\n'
+ '\n'
+ '"__*"\n'
+ ' Class-private names. Names in this category, when used '
+ 'within the\n'
+ ' context of a class definition, are re-written to use a '
+ 'mangled form\n'
+ ' to help avoid name clashes between "private" attributes of '
+ 'base and\n'
+ ' derived classes. See section Identifiers (Names).\n',
+ 'identifiers': '\n'
+ 'Identifiers and keywords\n'
+ '************************\n'
+ '\n'
+ 'Identifiers (also referred to as *names*) are described by '
+ 'the\n'
+ 'following lexical definitions:\n'
+ '\n'
+ ' identifier ::= (letter|"_") (letter | digit | "_")*\n'
+ ' letter ::= lowercase | uppercase\n'
+ ' lowercase ::= "a"..."z"\n'
+ ' uppercase ::= "A"..."Z"\n'
+ ' digit ::= "0"..."9"\n'
+ '\n'
+ 'Identifiers are unlimited in length. Case is significant.\n'
+ '\n'
+ '\n'
+ 'Keywords\n'
+ '========\n'
+ '\n'
+ 'The following identifiers are used as reserved words, or '
+ '*keywords* of\n'
+ 'the language, and cannot be used as ordinary identifiers. '
+ 'They must\n'
+ 'be spelled exactly as written here:\n'
+ '\n'
+ ' and del from not while\n'
+ ' as elif global or with\n'
+ ' assert else if pass yield\n'
+ ' break except import print\n'
+ ' class exec in raise\n'
+ ' continue finally is return\n'
+ ' def for lambda try\n'
+ '\n'
+ 'Changed in version 2.4: "None" became a constant and is now '
+ 'recognized\n'
+ 'by the compiler as a name for the built-in object "None". '
+ 'Although it\n'
+ 'is not a keyword, you cannot assign a different object to '
+ 'it.\n'
+ '\n'
+ 'Changed in version 2.5: Using "as" and "with" as identifiers '
+ 'triggers\n'
+ 'a warning. To use them as keywords, enable the '
+ '"with_statement"\n'
+ 'future feature .\n'
+ '\n'
+ 'Changed in version 2.6: "as" and "with" are full keywords.\n'
+ '\n'
+ '\n'
+ 'Reserved classes of identifiers\n'
+ '===============================\n'
+ '\n'
+ 'Certain classes of identifiers (besides keywords) have '
+ 'special\n'
+ 'meanings. These classes are identified by the patterns of '
+ 'leading and\n'
+ 'trailing underscore characters:\n'
+ '\n'
+ '"_*"\n'
+ ' Not imported by "from module import *". The special '
+ 'identifier "_"\n'
+ ' is used in the interactive interpreter to store the result '
+ 'of the\n'
+ ' last evaluation; it is stored in the "__builtin__" '
+ 'module. When\n'
+ ' not in interactive mode, "_" has no special meaning and is '
+ 'not\n'
+ ' defined. See section The import statement.\n'
+ '\n'
+ ' Note: The name "_" is often used in conjunction with\n'
+ ' internationalization; refer to the documentation for '
+ 'the\n'
+ ' "gettext" module for more information on this '
+ 'convention.\n'
+ '\n'
+ '"__*__"\n'
+ ' System-defined names. These names are defined by the '
+ 'interpreter\n'
+ ' and its implementation (including the standard library). '
+ 'Current\n'
+ ' system names are discussed in the Special method names '
+ 'section and\n'
+ ' elsewhere. More will likely be defined in future versions '
+ 'of\n'
+ ' Python. *Any* use of "__*__" names, in any context, that '
+ 'does not\n'
+ ' follow explicitly documented use, is subject to breakage '
+ 'without\n'
+ ' warning.\n'
+ '\n'
+ '"__*"\n'
+ ' Class-private names. Names in this category, when used '
+ 'within the\n'
+ ' context of a class definition, are re-written to use a '
+ 'mangled form\n'
+ ' to help avoid name clashes between "private" attributes of '
+ 'base and\n'
+ ' derived classes. See section Identifiers (Names).\n',
+ 'if': '\n'
+ 'The "if" statement\n'
+ '******************\n'
+ '\n'
+ 'The "if" statement is used for conditional execution:\n'
+ '\n'
+ ' if_stmt ::= "if" expression ":" suite\n'
+ ' ( "elif" expression ":" suite )*\n'
+ ' ["else" ":" suite]\n'
+ '\n'
+ 'It selects exactly one of the suites by evaluating the expressions '
+ 'one\n'
+ 'by one until one is found to be true (see section Boolean operations\n'
+ 'for the definition of true and false); then that suite is executed\n'
+ '(and no other part of the "if" statement is executed or evaluated).\n'
+ 'If all expressions are false, the suite of the "else" clause, if\n'
+ 'present, is executed.\n',
+ 'imaginary': '\n'
+ 'Imaginary literals\n'
+ '******************\n'
+ '\n'
+ 'Imaginary literals are described by the following lexical '
+ 'definitions:\n'
+ '\n'
+ ' imagnumber ::= (floatnumber | intpart) ("j" | "J")\n'
+ '\n'
+ 'An imaginary literal yields a complex number with a real part '
+ 'of 0.0.\n'
+ 'Complex numbers are represented as a pair of floating point '
+ 'numbers\n'
+ 'and have the same restrictions on their range. To create a '
+ 'complex\n'
+ 'number with a nonzero real part, add a floating point number to '
+ 'it,\n'
+ 'e.g., "(3+4j)". Some examples of imaginary literals:\n'
+ '\n'
+ ' 3.14j 10.j 10j .001j 1e100j 3.14e-10j\n',
+ 'import': '\n'
+ 'The "import" statement\n'
+ '**********************\n'
+ '\n'
+ ' import_stmt ::= "import" module ["as" name] ( "," module '
+ '["as" name] )*\n'
+ ' | "from" relative_module "import" identifier '
+ '["as" name]\n'
+ ' ( "," identifier ["as" name] )*\n'
+ ' | "from" relative_module "import" "(" '
+ 'identifier ["as" name]\n'
+ ' ( "," identifier ["as" name] )* [","] ")"\n'
+ ' | "from" module "import" "*"\n'
+ ' module ::= (identifier ".")* identifier\n'
+ ' relative_module ::= "."* module | "."+\n'
+ ' name ::= identifier\n'
+ '\n'
+ 'Import statements are executed in two steps: (1) find a module, '
+ 'and\n'
+ 'initialize it if necessary; (2) define a name or names in the '
+ 'local\n'
+ 'namespace (of the scope where the "import" statement occurs). The\n'
+ 'statement comes in two forms differing on whether it uses the '
+ '"from"\n'
+ 'keyword. The first form (without "from") repeats these steps for '
+ 'each\n'
+ 'identifier in the list. The form with "from" performs step (1) '
+ 'once,\n'
+ 'and then performs step (2) repeatedly.\n'
+ '\n'
+ 'To understand how step (1) occurs, one must first understand how\n'
+ 'Python handles hierarchical naming of modules. To help organize\n'
+ 'modules and provide a hierarchy in naming, Python has a concept '
+ 'of\n'
+ 'packages. A package can contain other packages and modules while\n'
+ 'modules cannot contain other modules or packages. From a file '
+ 'system\n'
+ 'perspective, packages are directories and modules are files.\n'
+ '\n'
+ 'Once the name of the module is known (unless otherwise specified, '
+ 'the\n'
+ 'term "module" will refer to both packages and modules), searching '
+ 'for\n'
+ 'the module or package can begin. The first place checked is\n'
+ '"sys.modules", the cache of all modules that have been imported\n'
+ 'previously. If the module is found there then it is used in step '
+ '(2)\n'
+ 'of import.\n'
+ '\n'
+ 'If the module is not found in the cache, then "sys.meta_path" is\n'
+ 'searched (the specification for "sys.meta_path" can be found in '
+ '**PEP\n'
+ '302**). The object is a list of *finder* objects which are queried '
+ 'in\n'
+ 'order as to whether they know how to load the module by calling '
+ 'their\n'
+ '"find_module()" method with the name of the module. If the module\n'
+ 'happens to be contained within a package (as denoted by the '
+ 'existence\n'
+ 'of a dot in the name), then a second argument to "find_module()" '
+ 'is\n'
+ 'given as the value of the "__path__" attribute from the parent '
+ 'package\n'
+ '(everything up to the last dot in the name of the module being\n'
+ 'imported). If a finder can find the module it returns a *loader*\n'
+ '(discussed later) or returns "None".\n'
+ '\n'
+ 'If none of the finders on "sys.meta_path" are able to find the '
+ 'module\n'
+ 'then some implicitly defined finders are queried. Implementations '
+ 'of\n'
+ 'Python vary in what implicit meta path finders are defined. The '
+ 'one\n'
+ 'they all do define, though, is one that handles "sys.path_hooks",\n'
+ '"sys.path_importer_cache", and "sys.path".\n'
+ '\n'
+ 'The implicit finder searches for the requested module in the '
+ '"paths"\n'
+ 'specified in one of two places ("paths" do not have to be file '
+ 'system\n'
+ 'paths). If the module being imported is supposed to be contained\n'
+ 'within a package then the second argument passed to '
+ '"find_module()",\n'
+ '"__path__" on the parent package, is used as the source of paths. '
+ 'If\n'
+ 'the module is not contained in a package then "sys.path" is used '
+ 'as\n'
+ 'the source of paths.\n'
+ '\n'
+ 'Once the source of paths is chosen it is iterated over to find a\n'
+ 'finder that can handle that path. The dict at\n'
+ '"sys.path_importer_cache" caches finders for paths and is checked '
+ 'for\n'
+ 'a finder. If the path does not have a finder cached then\n'
+ '"sys.path_hooks" is searched by calling each object in the list '
+ 'with a\n'
+ 'single argument of the path, returning a finder or raises\n'
+ '"ImportError". If a finder is returned then it is cached in\n'
+ '"sys.path_importer_cache" and then used for that path entry. If '
+ 'no\n'
+ 'finder can be found but the path exists then a value of "None" is\n'
+ 'stored in "sys.path_importer_cache" to signify that an implicit, '
+ 'file-\n'
+ 'based finder that handles modules stored as individual files '
+ 'should be\n'
+ 'used for that path. If the path does not exist then a finder '
+ 'which\n'
+ 'always returns "None" is placed in the cache for the path.\n'
+ '\n'
+ 'If no finder can find the module then "ImportError" is raised.\n'
+ 'Otherwise some finder returned a loader whose "load_module()" '
+ 'method\n'
+ 'is called with the name of the module to load (see **PEP 302** for '
+ 'the\n'
+ 'original definition of loaders). A loader has several '
+ 'responsibilities\n'
+ 'to perform on a module it loads. First, if the module already '
+ 'exists\n'
+ 'in "sys.modules" (a possibility if the loader is called outside of '
+ 'the\n'
+ 'import machinery) then it is to use that module for initialization '
+ 'and\n'
+ 'not a new module. But if the module does not exist in '
+ '"sys.modules"\n'
+ 'then it is to be added to that dict before initialization begins. '
+ 'If\n'
+ 'an error occurs during loading of the module and it was added to\n'
+ '"sys.modules" it is to be removed from the dict. If an error '
+ 'occurs\n'
+ 'but the module was already in "sys.modules" it is left in the '
+ 'dict.\n'
+ '\n'
+ 'The loader must set several attributes on the module. "__name__" '
+ 'is to\n'
+ 'be set to the name of the module. "__file__" is to be the "path" '
+ 'to\n'
+ 'the file unless the module is built-in (and thus listed in\n'
+ '"sys.builtin_module_names") in which case the attribute is not '
+ 'set. If\n'
+ 'what is being imported is a package then "__path__" is to be set '
+ 'to a\n'
+ 'list of paths to be searched when looking for modules and '
+ 'packages\n'
+ 'contained within the package being imported. "__package__" is '
+ 'optional\n'
+ 'but should be set to the name of package that contains the module '
+ 'or\n'
+ 'package (the empty string is used for module not contained in a\n'
+ 'package). "__loader__" is also optional but should be set to the\n'
+ 'loader object that is loading the module.\n'
+ '\n'
+ 'If an error occurs during loading then the loader raises '
+ '"ImportError"\n'
+ 'if some other exception is not already being propagated. Otherwise '
+ 'the\n'
+ 'loader returns the module that was loaded and initialized.\n'
+ '\n'
+ 'When step (1) finishes without raising an exception, step (2) can\n'
+ 'begin.\n'
+ '\n'
+ 'The first form of "import" statement binds the module name in the\n'
+ 'local namespace to the module object, and then goes on to import '
+ 'the\n'
+ 'next identifier, if any. If the module name is followed by "as", '
+ 'the\n'
+ 'name following "as" is used as the local name for the module.\n'
+ '\n'
+ 'The "from" form does not bind the module name: it goes through '
+ 'the\n'
+ 'list of identifiers, looks each one of them up in the module found '
+ 'in\n'
+ 'step (1), and binds the name in the local namespace to the object '
+ 'thus\n'
+ 'found. As with the first form of "import", an alternate local '
+ 'name\n'
+ 'can be supplied by specifying ""as" localname". If a name is not\n'
+ 'found, "ImportError" is raised. If the list of identifiers is\n'
+ 'replaced by a star ("\'*\'"), all public names defined in the '
+ 'module are\n'
+ 'bound in the local namespace of the "import" statement..\n'
+ '\n'
+ 'The *public names* defined by a module are determined by checking '
+ 'the\n'
+ 'module\'s namespace for a variable named "__all__"; if defined, it '
+ 'must\n'
+ 'be a sequence of strings which are names defined or imported by '
+ 'that\n'
+ 'module. The names given in "__all__" are all considered public '
+ 'and\n'
+ 'are required to exist. If "__all__" is not defined, the set of '
+ 'public\n'
+ "names includes all names found in the module's namespace which do "
+ 'not\n'
+ 'begin with an underscore character ("\'_\'"). "__all__" should '
+ 'contain\n'
+ 'the entire public API. It is intended to avoid accidentally '
+ 'exporting\n'
+ 'items that are not part of the API (such as library modules which '
+ 'were\n'
+ 'imported and used within the module).\n'
+ '\n'
+ 'The "from" form with "*" may only occur in a module scope. If '
+ 'the\n'
+ 'wild card form of import --- "import *" --- is used in a function '
+ 'and\n'
+ 'the function contains or is a nested block with free variables, '
+ 'the\n'
+ 'compiler will raise a "SyntaxError".\n'
+ '\n'
+ 'When specifying what module to import you do not have to specify '
+ 'the\n'
+ 'absolute name of the module. When a module or package is '
+ 'contained\n'
+ 'within another package it is possible to make a relative import '
+ 'within\n'
+ 'the same top package without having to mention the package name. '
+ 'By\n'
+ 'using leading dots in the specified module or package after "from" '
+ 'you\n'
+ 'can specify how high to traverse up the current package hierarchy\n'
+ 'without specifying exact names. One leading dot means the current\n'
+ 'package where the module making the import exists. Two dots means '
+ 'up\n'
+ 'one package level. Three dots is up two levels, etc. So if you '
+ 'execute\n'
+ '"from . import mod" from a module in the "pkg" package then you '
+ 'will\n'
+ 'end up importing "pkg.mod". If you execute "from ..subpkg2 import '
+ 'mod"\n'
+ 'from within "pkg.subpkg1" you will import "pkg.subpkg2.mod". The\n'
+ 'specification for relative imports is contained within **PEP '
+ '328**.\n'
+ '\n'
+ '"importlib.import_module()" is provided to support applications '
+ 'that\n'
+ 'determine which modules need to be loaded dynamically.\n'
+ '\n'
+ '\n'
+ 'Future statements\n'
+ '=================\n'
+ '\n'
+ 'A *future statement* is a directive to the compiler that a '
+ 'particular\n'
+ 'module should be compiled using syntax or semantics that will be\n'
+ 'available in a specified future release of Python. The future\n'
+ 'statement is intended to ease migration to future versions of '
+ 'Python\n'
+ 'that introduce incompatible changes to the language. It allows '
+ 'use of\n'
+ 'the new features on a per-module basis before the release in which '
+ 'the\n'
+ 'feature becomes standard.\n'
+ '\n'
+ ' future_statement ::= "from" "__future__" "import" feature ["as" '
+ 'name]\n'
+ ' ("," feature ["as" name])*\n'
+ ' | "from" "__future__" "import" "(" feature '
+ '["as" name]\n'
+ ' ("," feature ["as" name])* [","] ")"\n'
+ ' feature ::= identifier\n'
+ ' name ::= identifier\n'
+ '\n'
+ 'A future statement must appear near the top of the module. The '
+ 'only\n'
+ 'lines that can appear before a future statement are:\n'
+ '\n'
+ '* the module docstring (if any),\n'
+ '\n'
+ '* comments,\n'
+ '\n'
+ '* blank lines, and\n'
+ '\n'
+ '* other future statements.\n'
+ '\n'
+ 'The features recognized by Python 2.6 are "unicode_literals",\n'
+ '"print_function", "absolute_import", "division", "generators",\n'
+ '"nested_scopes" and "with_statement". "generators", '
+ '"with_statement",\n'
+ '"nested_scopes" are redundant in Python version 2.6 and above '
+ 'because\n'
+ 'they are always enabled.\n'
+ '\n'
+ 'A future statement is recognized and treated specially at compile\n'
+ 'time: Changes to the semantics of core constructs are often\n'
+ 'implemented by generating different code. It may even be the '
+ 'case\n'
+ 'that a new feature introduces new incompatible syntax (such as a '
+ 'new\n'
+ 'reserved word), in which case the compiler may need to parse the\n'
+ 'module differently. Such decisions cannot be pushed off until\n'
+ 'runtime.\n'
+ '\n'
+ 'For any given release, the compiler knows which feature names '
+ 'have\n'
+ 'been defined, and raises a compile-time error if a future '
+ 'statement\n'
+ 'contains a feature not known to it.\n'
+ '\n'
+ 'The direct runtime semantics are the same as for any import '
+ 'statement:\n'
+ 'there is a standard module "__future__", described later, and it '
+ 'will\n'
+ 'be imported in the usual way at the time the future statement is\n'
+ 'executed.\n'
+ '\n'
+ 'The interesting runtime semantics depend on the specific feature\n'
+ 'enabled by the future statement.\n'
+ '\n'
+ 'Note that there is nothing special about the statement:\n'
+ '\n'
+ ' import __future__ [as name]\n'
+ '\n'
+ "That is not a future statement; it's an ordinary import statement "
+ 'with\n'
+ 'no special semantics or syntax restrictions.\n'
+ '\n'
+ 'Code compiled by an "exec" statement or calls to the built-in\n'
+ 'functions "compile()" and "execfile()" that occur in a module "M"\n'
+ 'containing a future statement will, by default, use the new '
+ 'syntax or\n'
+ 'semantics associated with the future statement. This can, '
+ 'starting\n'
+ 'with Python 2.2 be controlled by optional arguments to "compile()" '
+ '---\n'
+ 'see the documentation of that function for details.\n'
+ '\n'
+ 'A future statement typed at an interactive interpreter prompt '
+ 'will\n'
+ 'take effect for the rest of the interpreter session. If an\n'
+ 'interpreter is started with the "-i" option, is passed a script '
+ 'name\n'
+ 'to execute, and the script includes a future statement, it will be '
+ 'in\n'
+ 'effect in the interactive session started after the script is\n'
+ 'executed.\n'
+ '\n'
+ 'See also:\n'
+ '\n'
+ ' **PEP 236** - Back to the __future__\n'
+ ' The original proposal for the __future__ mechanism.\n',
+ 'in': '\n'
+ 'Membership test operations\n'
+ '**************************\n'
+ '\n'
+ 'The operators "in" and "not in" test for membership. "x in s"\n'
+ 'evaluates to "True" if *x* is a member of *s*, and "False" otherwise.\n'
+ '"x not in s" returns the negation of "x in s". All built-in '
+ 'sequences\n'
+ 'and set types support this as well as dictionary, for which "in" '
+ 'tests\n'
+ 'whether the dictionary has a given key. For container types such as\n'
+ 'list, tuple, set, frozenset, dict, or collections.deque, the\n'
+ 'expression "x in y" is equivalent to "any(x is e or x == e for e in\n'
+ 'y)".\n'
+ '\n'
+ 'For the string and bytes types, "x in y" is "True" if and only if *x*\n'
+ 'is a substring of *y*. An equivalent test is "y.find(x) != -1".\n'
+ 'Empty strings are always considered to be a substring of any other\n'
+ 'string, so """ in "abc"" will return "True".\n'
+ '\n'
+ 'For user-defined classes which define the "__contains__()" method, "x\n'
+ 'in y" returns "True" if "y.__contains__(x)" returns a true value, and\n'
+ '"False" otherwise.\n'
+ '\n'
+ 'For user-defined classes which do not define "__contains__()" but do\n'
+ 'define "__iter__()", "x in y" is "True" if some value "z" with "x ==\n'
+ 'z" is produced while iterating over "y". If an exception is raised\n'
+ 'during the iteration, it is as if "in" raised that exception.\n'
+ '\n'
+ 'Lastly, the old-style iteration protocol is tried: if a class defines\n'
+ '"__getitem__()", "x in y" is "True" if and only if there is a non-\n'
+ 'negative integer index *i* such that "x == y[i]", and all lower\n'
+ 'integer indices do not raise "IndexError" exception. (If any other\n'
+ 'exception is raised, it is as if "in" raised that exception).\n'
+ '\n'
+ 'The operator "not in" is defined to have the inverse true value of\n'
+ '"in".\n',
+ 'integers': '\n'
+ 'Integer and long integer literals\n'
+ '*********************************\n'
+ '\n'
+ 'Integer and long integer literals are described by the '
+ 'following\n'
+ 'lexical definitions:\n'
+ '\n'
+ ' longinteger ::= integer ("l" | "L")\n'
+ ' integer ::= decimalinteger | octinteger | hexinteger | '
+ 'bininteger\n'
+ ' decimalinteger ::= nonzerodigit digit* | "0"\n'
+ ' octinteger ::= "0" ("o" | "O") octdigit+ | "0" octdigit+\n'
+ ' hexinteger ::= "0" ("x" | "X") hexdigit+\n'
+ ' bininteger ::= "0" ("b" | "B") bindigit+\n'
+ ' nonzerodigit ::= "1"..."9"\n'
+ ' octdigit ::= "0"..."7"\n'
+ ' bindigit ::= "0" | "1"\n'
+ ' hexdigit ::= digit | "a"..."f" | "A"..."F"\n'
+ '\n'
+ 'Although both lower case "\'l\'" and upper case "\'L\'" are '
+ 'allowed as\n'
+ 'suffix for long integers, it is strongly recommended to always '
+ 'use\n'
+ '"\'L\'", since the letter "\'l\'" looks too much like the digit '
+ '"\'1\'".\n'
+ '\n'
+ 'Plain integer literals that are above the largest representable '
+ 'plain\n'
+ 'integer (e.g., 2147483647 when using 32-bit arithmetic) are '
+ 'accepted\n'
+ 'as if they were long integers instead. [1] There is no limit '
+ 'for long\n'
+ 'integer literals apart from what can be stored in available '
+ 'memory.\n'
+ '\n'
+ 'Some examples of plain integer literals (first row) and long '
+ 'integer\n'
+ 'literals (second and third rows):\n'
+ '\n'
+ ' 7 2147483647 0177\n'
+ ' 3L 79228162514264337593543950336L 0377L 0x100000000L\n'
+ ' 79228162514264337593543950336 0xdeadbeef\n',
+ 'lambda': '\n'
+ 'Lambdas\n'
+ '*******\n'
+ '\n'
+ ' lambda_expr ::= "lambda" [parameter_list]: expression\n'
+ ' old_lambda_expr ::= "lambda" [parameter_list]: old_expression\n'
+ '\n'
+ 'Lambda expressions (sometimes called lambda forms) have the same\n'
+ 'syntactic position as expressions. They are a shorthand to '
+ 'create\n'
+ 'anonymous functions; the expression "lambda arguments: '
+ 'expression"\n'
+ 'yields a function object. The unnamed object behaves like a '
+ 'function\n'
+ 'object defined with\n'
+ '\n'
+ ' def name(arguments):\n'
+ ' return expression\n'
+ '\n'
+ 'See section Function definitions for the syntax of parameter '
+ 'lists.\n'
+ 'Note that functions created with lambda expressions cannot '
+ 'contain\n'
+ 'statements.\n',
+ 'lists': '\n'
+ 'List displays\n'
+ '*************\n'
+ '\n'
+ 'A list display is a possibly empty series of expressions enclosed '
+ 'in\n'
+ 'square brackets:\n'
+ '\n'
+ ' list_display ::= "[" [expression_list | '
+ 'list_comprehension] "]"\n'
+ ' list_comprehension ::= expression list_for\n'
+ ' list_for ::= "for" target_list "in" '
+ 'old_expression_list [list_iter]\n'
+ ' old_expression_list ::= old_expression [("," old_expression)+ '
+ '[","]]\n'
+ ' old_expression ::= or_test | old_lambda_expr\n'
+ ' list_iter ::= list_for | list_if\n'
+ ' list_if ::= "if" old_expression [list_iter]\n'
+ '\n'
+ 'A list display yields a new list object. Its contents are '
+ 'specified\n'
+ 'by providing either a list of expressions or a list comprehension.\n'
+ 'When a comma-separated list of expressions is supplied, its '
+ 'elements\n'
+ 'are evaluated from left to right and placed into the list object '
+ 'in\n'
+ 'that order. When a list comprehension is supplied, it consists of '
+ 'a\n'
+ 'single expression followed by at least one "for" clause and zero '
+ 'or\n'
+ 'more "for" or "if" clauses. In this case, the elements of the new\n'
+ 'list are those that would be produced by considering each of the '
+ '"for"\n'
+ 'or "if" clauses a block, nesting from left to right, and '
+ 'evaluating\n'
+ 'the expression to produce a list element each time the innermost '
+ 'block\n'
+ 'is reached [1].\n',
+ 'naming': '\n'
+ 'Naming and binding\n'
+ '******************\n'
+ '\n'
+ '*Names* refer to objects. Names are introduced by name binding\n'
+ 'operations. Each occurrence of a name in the program text refers '
+ 'to\n'
+ 'the *binding* of that name established in the innermost function '
+ 'block\n'
+ 'containing the use.\n'
+ '\n'
+ 'A *block* is a piece of Python program text that is executed as a\n'
+ 'unit. The following are blocks: a module, a function body, and a '
+ 'class\n'
+ 'definition. Each command typed interactively is a block. A '
+ 'script\n'
+ 'file (a file given as standard input to the interpreter or '
+ 'specified\n'
+ 'on the interpreter command line the first argument) is a code '
+ 'block.\n'
+ 'A script command (a command specified on the interpreter command '
+ 'line\n'
+ "with the '**-c**' option) is a code block. The file read by the\n"
+ 'built-in function "execfile()" is a code block. The string '
+ 'argument\n'
+ 'passed to the built-in function "eval()" and to the "exec" '
+ 'statement\n'
+ 'is a code block. The expression read and evaluated by the '
+ 'built-in\n'
+ 'function "input()" is a code block.\n'
+ '\n'
+ 'A code block is executed in an *execution frame*. A frame '
+ 'contains\n'
+ 'some administrative information (used for debugging) and '
+ 'determines\n'
+ "where and how execution continues after the code block's execution "
+ 'has\n'
+ 'completed.\n'
+ '\n'
+ 'A *scope* defines the visibility of a name within a block. If a '
+ 'local\n'
+ 'variable is defined in a block, its scope includes that block. If '
+ 'the\n'
+ 'definition occurs in a function block, the scope extends to any '
+ 'blocks\n'
+ 'contained within the defining one, unless a contained block '
+ 'introduces\n'
+ 'a different binding for the name. The scope of names defined in '
+ 'a\n'
+ 'class block is limited to the class block; it does not extend to '
+ 'the\n'
+ 'code blocks of methods -- this includes generator expressions '
+ 'since\n'
+ 'they are implemented using a function scope. This means that the\n'
+ 'following will fail:\n'
+ '\n'
+ ' class A:\n'
+ ' a = 42\n'
+ ' b = list(a + i for i in range(10))\n'
+ '\n'
+ 'When a name is used in a code block, it is resolved using the '
+ 'nearest\n'
+ 'enclosing scope. The set of all such scopes visible to a code '
+ 'block\n'
+ "is called the block's *environment*.\n"
+ '\n'
+ 'If a name is bound in a block, it is a local variable of that '
+ 'block.\n'
+ 'If a name is bound at the module level, it is a global variable. '
+ '(The\n'
+ 'variables of the module code block are local and global.) If a\n'
+ 'variable is used in a code block but not defined there, it is a '
+ '*free\n'
+ 'variable*.\n'
+ '\n'
+ 'When a name is not found at all, a "NameError" exception is '
+ 'raised.\n'
+ 'If the name refers to a local variable that has not been bound, a\n'
+ '"UnboundLocalError" exception is raised. "UnboundLocalError" is '
+ 'a\n'
+ 'subclass of "NameError".\n'
+ '\n'
+ 'The following constructs bind names: formal parameters to '
+ 'functions,\n'
+ '"import" statements, class and function definitions (these bind '
+ 'the\n'
+ 'class or function name in the defining block), and targets that '
+ 'are\n'
+ 'identifiers if occurring in an assignment, "for" loop header, in '
+ 'the\n'
+ 'second position of an "except" clause header or after "as" in a '
+ '"with"\n'
+ 'statement. The "import" statement of the form "from ... import '
+ '*"\n'
+ 'binds all names defined in the imported module, except those '
+ 'beginning\n'
+ 'with an underscore. This form may only be used at the module '
+ 'level.\n'
+ '\n'
+ 'A target occurring in a "del" statement is also considered bound '
+ 'for\n'
+ 'this purpose (though the actual semantics are to unbind the '
+ 'name). It\n'
+ 'is illegal to unbind a name that is referenced by an enclosing '
+ 'scope;\n'
+ 'the compiler will report a "SyntaxError".\n'
+ '\n'
+ 'Each assignment or import statement occurs within a block defined '
+ 'by a\n'
+ 'class or function definition or at the module level (the '
+ 'top-level\n'
+ 'code block).\n'
+ '\n'
+ 'If a name binding operation occurs anywhere within a code block, '
+ 'all\n'
+ 'uses of the name within the block are treated as references to '
+ 'the\n'
+ 'current block. This can lead to errors when a name is used within '
+ 'a\n'
+ 'block before it is bound. This rule is subtle. Python lacks\n'
+ 'declarations and allows name binding operations to occur anywhere\n'
+ 'within a code block. The local variables of a code block can be\n'
+ 'determined by scanning the entire text of the block for name '
+ 'binding\n'
+ 'operations.\n'
+ '\n'
+ 'If the global statement occurs within a block, all uses of the '
+ 'name\n'
+ 'specified in the statement refer to the binding of that name in '
+ 'the\n'
+ 'top-level namespace. Names are resolved in the top-level namespace '
+ 'by\n'
+ 'searching the global namespace, i.e. the namespace of the module\n'
+ 'containing the code block, and the builtins namespace, the '
+ 'namespace\n'
+ 'of the module "__builtin__". The global namespace is searched '
+ 'first.\n'
+ 'If the name is not found there, the builtins namespace is '
+ 'searched.\n'
+ 'The global statement must precede all uses of the name.\n'
+ '\n'
+ 'The builtins namespace associated with the execution of a code '
+ 'block\n'
+ 'is actually found by looking up the name "__builtins__" in its '
+ 'global\n'
+ 'namespace; this should be a dictionary or a module (in the latter '
+ 'case\n'
+ "the module's dictionary is used). By default, when in the "
+ '"__main__"\n'
+ 'module, "__builtins__" is the built-in module "__builtin__" (note: '
+ 'no\n'
+ '\'s\'); when in any other module, "__builtins__" is an alias for '
+ 'the\n'
+ 'dictionary of the "__builtin__" module itself. "__builtins__" can '
+ 'be\n'
+ 'set to a user-created dictionary to create a weak form of '
+ 'restricted\n'
+ 'execution.\n'
+ '\n'
+ '**CPython implementation detail:** Users should not touch\n'
+ '"__builtins__"; it is strictly an implementation detail. Users\n'
+ 'wanting to override values in the builtins namespace should '
+ '"import"\n'
+ 'the "__builtin__" (no \'s\') module and modify its attributes\n'
+ 'appropriately.\n'
+ '\n'
+ 'The namespace for a module is automatically created the first time '
+ 'a\n'
+ 'module is imported. The main module for a script is always '
+ 'called\n'
+ '"__main__".\n'
+ '\n'
+ 'The "global" statement has the same scope as a name binding '
+ 'operation\n'
+ 'in the same block. If the nearest enclosing scope for a free '
+ 'variable\n'
+ 'contains a global statement, the free variable is treated as a '
+ 'global.\n'
+ '\n'
+ 'A class definition is an executable statement that may use and '
+ 'define\n'
+ 'names. These references follow the normal rules for name '
+ 'resolution.\n'
+ 'The namespace of the class definition becomes the attribute '
+ 'dictionary\n'
+ 'of the class. Names defined at the class scope are not visible '
+ 'in\n'
+ 'methods.\n'
+ '\n'
+ '\n'
+ 'Interaction with dynamic features\n'
+ '=================================\n'
+ '\n'
+ 'There are several cases where Python statements are illegal when '
+ 'used\n'
+ 'in conjunction with nested scopes that contain free variables.\n'
+ '\n'
+ 'If a variable is referenced in an enclosing scope, it is illegal '
+ 'to\n'
+ 'delete the name. An error will be reported at compile time.\n'
+ '\n'
+ 'If the wild card form of import --- "import *" --- is used in a\n'
+ 'function and the function contains or is a nested block with free\n'
+ 'variables, the compiler will raise a "SyntaxError".\n'
+ '\n'
+ 'If "exec" is used in a function and the function contains or is a\n'
+ 'nested block with free variables, the compiler will raise a\n'
+ '"SyntaxError" unless the exec explicitly specifies the local '
+ 'namespace\n'
+ 'for the "exec". (In other words, "exec obj" would be illegal, '
+ 'but\n'
+ '"exec obj in ns" would be legal.)\n'
+ '\n'
+ 'The "eval()", "execfile()", and "input()" functions and the '
+ '"exec"\n'
+ 'statement do not have access to the full environment for '
+ 'resolving\n'
+ 'names. Names may be resolved in the local and global namespaces '
+ 'of\n'
+ 'the caller. Free variables are not resolved in the nearest '
+ 'enclosing\n'
+ 'namespace, but in the global namespace. [1] The "exec" statement '
+ 'and\n'
+ 'the "eval()" and "execfile()" functions have optional arguments '
+ 'to\n'
+ 'override the global and local namespace. If only one namespace '
+ 'is\n'
+ 'specified, it is used for both.\n',
+ 'numbers': '\n'
+ 'Numeric literals\n'
+ '****************\n'
+ '\n'
+ 'There are four types of numeric literals: plain integers, long\n'
+ 'integers, floating point numbers, and imaginary numbers. There '
+ 'are no\n'
+ 'complex literals (complex numbers can be formed by adding a real\n'
+ 'number and an imaginary number).\n'
+ '\n'
+ 'Note that numeric literals do not include a sign; a phrase like '
+ '"-1"\n'
+ 'is actually an expression composed of the unary operator \'"-"\' '
+ 'and the\n'
+ 'literal "1".\n',
+ 'numeric-types': '\n'
+ 'Emulating numeric types\n'
+ '***********************\n'
+ '\n'
+ 'The following methods can be defined to emulate numeric '
+ 'objects.\n'
+ 'Methods corresponding to operations that are not supported '
+ 'by the\n'
+ 'particular kind of number implemented (e.g., bitwise '
+ 'operations for\n'
+ 'non-integral numbers) should be left undefined.\n'
+ '\n'
+ 'object.__add__(self, other)\n'
+ 'object.__sub__(self, other)\n'
+ 'object.__mul__(self, other)\n'
+ 'object.__floordiv__(self, other)\n'
+ 'object.__mod__(self, other)\n'
+ 'object.__divmod__(self, other)\n'
+ 'object.__pow__(self, other[, modulo])\n'
+ 'object.__lshift__(self, other)\n'
+ 'object.__rshift__(self, other)\n'
+ 'object.__and__(self, other)\n'
+ 'object.__xor__(self, other)\n'
+ 'object.__or__(self, other)\n'
+ '\n'
+ ' These methods are called to implement the binary '
+ 'arithmetic\n'
+ ' operations ("+", "-", "*", "//", "%", "divmod()", '
+ '"pow()", "**",\n'
+ ' "<<", ">>", "&", "^", "|"). For instance, to evaluate '
+ 'the\n'
+ ' expression "x + y", where *x* is an instance of a class '
+ 'that has an\n'
+ ' "__add__()" method, "x.__add__(y)" is called. The '
+ '"__divmod__()"\n'
+ ' method should be the equivalent to using '
+ '"__floordiv__()" and\n'
+ ' "__mod__()"; it should not be related to "__truediv__()" '
+ '(described\n'
+ ' below). Note that "__pow__()" should be defined to '
+ 'accept an\n'
+ ' optional third argument if the ternary version of the '
+ 'built-in\n'
+ ' "pow()" function is to be supported.\n'
+ '\n'
+ ' If one of those methods does not support the operation '
+ 'with the\n'
+ ' supplied arguments, it should return "NotImplemented".\n'
+ '\n'
+ 'object.__div__(self, other)\n'
+ 'object.__truediv__(self, other)\n'
+ '\n'
+ ' The division operator ("/") is implemented by these '
+ 'methods. The\n'
+ ' "__truediv__()" method is used when '
+ '"__future__.division" is in\n'
+ ' effect, otherwise "__div__()" is used. If only one of '
+ 'these two\n'
+ ' methods is defined, the object will not support division '
+ 'in the\n'
+ ' alternate context; "TypeError" will be raised instead.\n'
+ '\n'
+ 'object.__radd__(self, other)\n'
+ 'object.__rsub__(self, other)\n'
+ 'object.__rmul__(self, other)\n'
+ 'object.__rdiv__(self, other)\n'
+ 'object.__rtruediv__(self, other)\n'
+ 'object.__rfloordiv__(self, other)\n'
+ 'object.__rmod__(self, other)\n'
+ 'object.__rdivmod__(self, other)\n'
+ 'object.__rpow__(self, other)\n'
+ 'object.__rlshift__(self, other)\n'
+ 'object.__rrshift__(self, other)\n'
+ 'object.__rand__(self, other)\n'
+ 'object.__rxor__(self, other)\n'
+ 'object.__ror__(self, other)\n'
+ '\n'
+ ' These methods are called to implement the binary '
+ 'arithmetic\n'
+ ' operations ("+", "-", "*", "/", "%", "divmod()", '
+ '"pow()", "**",\n'
+ ' "<<", ">>", "&", "^", "|") with reflected (swapped) '
+ 'operands.\n'
+ ' These functions are only called if the left operand does '
+ 'not\n'
+ ' support the corresponding operation and the operands are '
+ 'of\n'
+ ' different types. [2] For instance, to evaluate the '
+ 'expression "x -\n'
+ ' y", where *y* is an instance of a class that has an '
+ '"__rsub__()"\n'
+ ' method, "y.__rsub__(x)" is called if "x.__sub__(y)" '
+ 'returns\n'
+ ' *NotImplemented*.\n'
+ '\n'
+ ' Note that ternary "pow()" will not try calling '
+ '"__rpow__()" (the\n'
+ ' coercion rules would become too complicated).\n'
+ '\n'
+ " Note: If the right operand's type is a subclass of the "
+ 'left\n'
+ " operand's type and that subclass provides the "
+ 'reflected method\n'
+ ' for the operation, this method will be called before '
+ 'the left\n'
+ " operand's non-reflected method. This behavior allows "
+ 'subclasses\n'
+ " to override their ancestors' operations.\n"
+ '\n'
+ 'object.__iadd__(self, other)\n'
+ 'object.__isub__(self, other)\n'
+ 'object.__imul__(self, other)\n'
+ 'object.__idiv__(self, other)\n'
+ 'object.__itruediv__(self, other)\n'
+ 'object.__ifloordiv__(self, other)\n'
+ 'object.__imod__(self, other)\n'
+ 'object.__ipow__(self, other[, modulo])\n'
+ 'object.__ilshift__(self, other)\n'
+ 'object.__irshift__(self, other)\n'
+ 'object.__iand__(self, other)\n'
+ 'object.__ixor__(self, other)\n'
+ 'object.__ior__(self, other)\n'
+ '\n'
+ ' These methods are called to implement the augmented '
+ 'arithmetic\n'
+ ' assignments ("+=", "-=", "*=", "/=", "//=", "%=", "**=", '
+ '"<<=",\n'
+ ' ">>=", "&=", "^=", "|="). These methods should attempt '
+ 'to do the\n'
+ ' operation in-place (modifying *self*) and return the '
+ 'result (which\n'
+ ' could be, but does not have to be, *self*). If a '
+ 'specific method\n'
+ ' is not defined, the augmented assignment falls back to '
+ 'the normal\n'
+ ' methods. For instance, to execute the statement "x += '
+ 'y", where\n'
+ ' *x* is an instance of a class that has an "__iadd__()" '
+ 'method,\n'
+ ' "x.__iadd__(y)" is called. If *x* is an instance of a '
+ 'class that\n'
+ ' does not define a "__iadd__()" method, "x.__add__(y)" '
+ 'and\n'
+ ' "y.__radd__(x)" are considered, as with the evaluation '
+ 'of "x + y".\n'
+ '\n'
+ 'object.__neg__(self)\n'
+ 'object.__pos__(self)\n'
+ 'object.__abs__(self)\n'
+ 'object.__invert__(self)\n'
+ '\n'
+ ' Called to implement the unary arithmetic operations '
+ '("-", "+",\n'
+ ' "abs()" and "~").\n'
+ '\n'
+ 'object.__complex__(self)\n'
+ 'object.__int__(self)\n'
+ 'object.__long__(self)\n'
+ 'object.__float__(self)\n'
+ '\n'
+ ' Called to implement the built-in functions "complex()", '
+ '"int()",\n'
+ ' "long()", and "float()". Should return a value of the '
+ 'appropriate\n'
+ ' type.\n'
+ '\n'
+ 'object.__oct__(self)\n'
+ 'object.__hex__(self)\n'
+ '\n'
+ ' Called to implement the built-in functions "oct()" and '
+ '"hex()".\n'
+ ' Should return a string value.\n'
+ '\n'
+ 'object.__index__(self)\n'
+ '\n'
+ ' Called to implement "operator.index()". Also called '
+ 'whenever\n'
+ ' Python needs an integer object (such as in slicing). '
+ 'Must return\n'
+ ' an integer (int or long).\n'
+ '\n'
+ ' New in version 2.5.\n'
+ '\n'
+ 'object.__coerce__(self, other)\n'
+ '\n'
+ ' Called to implement "mixed-mode" numeric arithmetic. '
+ 'Should either\n'
+ ' return a 2-tuple containing *self* and *other* converted '
+ 'to a\n'
+ ' common numeric type, or "None" if conversion is '
+ 'impossible. When\n'
+ ' the common type would be the type of "other", it is '
+ 'sufficient to\n'
+ ' return "None", since the interpreter will also ask the '
+ 'other object\n'
+ ' to attempt a coercion (but sometimes, if the '
+ 'implementation of the\n'
+ ' other type cannot be changed, it is useful to do the '
+ 'conversion to\n'
+ ' the other type here). A return value of '
+ '"NotImplemented" is\n'
+ ' equivalent to returning "None".\n',
+ 'objects': '\n'
+ 'Objects, values and types\n'
+ '*************************\n'
+ '\n'
+ "*Objects* are Python's abstraction for data. All data in a "
+ 'Python\n'
+ 'program is represented by objects or by relations between '
+ 'objects. (In\n'
+ 'a sense, and in conformance to Von Neumann\'s model of a "stored\n'
+ 'program computer," code is also represented by objects.)\n'
+ '\n'
+ "Every object has an identity, a type and a value. An object's\n"
+ '*identity* never changes once it has been created; you may think '
+ 'of it\n'
+ 'as the object\'s address in memory. The \'"is"\' operator '
+ 'compares the\n'
+ 'identity of two objects; the "id()" function returns an integer\n'
+ 'representing its identity (currently implemented as its address). '
+ 'An\n'
+ "object's *type* is also unchangeable. [1] An object's type "
+ 'determines\n'
+ 'the operations that the object supports (e.g., "does it have a\n'
+ 'length?") and also defines the possible values for objects of '
+ 'that\n'
+ 'type. The "type()" function returns an object\'s type (which is '
+ 'an\n'
+ 'object itself). The *value* of some objects can change. '
+ 'Objects\n'
+ 'whose value can change are said to be *mutable*; objects whose '
+ 'value\n'
+ 'is unchangeable once they are created are called *immutable*. '
+ '(The\n'
+ 'value of an immutable container object that contains a reference '
+ 'to a\n'
+ "mutable object can change when the latter's value is changed; "
+ 'however\n'
+ 'the container is still considered immutable, because the '
+ 'collection of\n'
+ 'objects it contains cannot be changed. So, immutability is not\n'
+ 'strictly the same as having an unchangeable value, it is more '
+ 'subtle.)\n'
+ "An object's mutability is determined by its type; for instance,\n"
+ 'numbers, strings and tuples are immutable, while dictionaries '
+ 'and\n'
+ 'lists are mutable.\n'
+ '\n'
+ 'Objects are never explicitly destroyed; however, when they '
+ 'become\n'
+ 'unreachable they may be garbage-collected. An implementation is\n'
+ 'allowed to postpone garbage collection or omit it altogether --- '
+ 'it is\n'
+ 'a matter of implementation quality how garbage collection is\n'
+ 'implemented, as long as no objects are collected that are still\n'
+ 'reachable.\n'
+ '\n'
+ '**CPython implementation detail:** CPython currently uses a '
+ 'reference-\n'
+ 'counting scheme with (optional) delayed detection of cyclically '
+ 'linked\n'
+ 'garbage, which collects most objects as soon as they become\n'
+ 'unreachable, but is not guaranteed to collect garbage containing\n'
+ 'circular references. See the documentation of the "gc" module '
+ 'for\n'
+ 'information on controlling the collection of cyclic garbage. '
+ 'Other\n'
+ 'implementations act differently and CPython may change. Do not '
+ 'depend\n'
+ 'on immediate finalization of objects when they become unreachable '
+ '(ex:\n'
+ 'always close files).\n'
+ '\n'
+ "Note that the use of the implementation's tracing or debugging\n"
+ 'facilities may keep objects alive that would normally be '
+ 'collectable.\n'
+ 'Also note that catching an exception with a \'"try"..."except"\'\n'
+ 'statement may keep objects alive.\n'
+ '\n'
+ 'Some objects contain references to "external" resources such as '
+ 'open\n'
+ 'files or windows. It is understood that these resources are '
+ 'freed\n'
+ 'when the object is garbage-collected, but since garbage '
+ 'collection is\n'
+ 'not guaranteed to happen, such objects also provide an explicit '
+ 'way to\n'
+ 'release the external resource, usually a "close()" method. '
+ 'Programs\n'
+ 'are strongly recommended to explicitly close such objects. The\n'
+ '\'"try"..."finally"\' statement provides a convenient way to do '
+ 'this.\n'
+ '\n'
+ 'Some objects contain references to other objects; these are '
+ 'called\n'
+ '*containers*. Examples of containers are tuples, lists and\n'
+ "dictionaries. The references are part of a container's value. "
+ 'In\n'
+ 'most cases, when we talk about the value of a container, we imply '
+ 'the\n'
+ 'values, not the identities of the contained objects; however, '
+ 'when we\n'
+ 'talk about the mutability of a container, only the identities of '
+ 'the\n'
+ 'immediately contained objects are implied. So, if an immutable\n'
+ 'container (like a tuple) contains a reference to a mutable '
+ 'object, its\n'
+ 'value changes if that mutable object is changed.\n'
+ '\n'
+ 'Types affect almost all aspects of object behavior. Even the\n'
+ 'importance of object identity is affected in some sense: for '
+ 'immutable\n'
+ 'types, operations that compute new values may actually return a\n'
+ 'reference to any existing object with the same type and value, '
+ 'while\n'
+ 'for mutable objects this is not allowed. E.g., after "a = 1; b = '
+ '1",\n'
+ '"a" and "b" may or may not refer to the same object with the '
+ 'value\n'
+ 'one, depending on the implementation, but after "c = []; d = []", '
+ '"c"\n'
+ 'and "d" are guaranteed to refer to two different, unique, newly\n'
+ 'created empty lists. (Note that "c = d = []" assigns the same '
+ 'object\n'
+ 'to both "c" and "d".)\n',
+ 'operator-summary': '\n'
+ 'Operator precedence\n'
+ '*******************\n'
+ '\n'
+ 'The following table summarizes the operator precedences '
+ 'in Python,\n'
+ 'from lowest precedence (least binding) to highest '
+ 'precedence (most\n'
+ 'binding). Operators in the same box have the same '
+ 'precedence. Unless\n'
+ 'the syntax is explicitly given, operators are binary. '
+ 'Operators in\n'
+ 'the same box group left to right (except for '
+ 'comparisons, including\n'
+ 'tests, which all have the same precedence and chain from '
+ 'left to right\n'
+ '--- see section Comparisons --- and exponentiation, '
+ 'which groups from\n'
+ 'right to left).\n'
+ '\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| Operator | '
+ 'Description |\n'
+ '+=================================================+=======================================+\n'
+ '| "lambda" | '
+ 'Lambda expression |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "if" -- "else" | '
+ 'Conditional expression |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "or" | '
+ 'Boolean OR |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "and" | '
+ 'Boolean AND |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "not" "x" | '
+ 'Boolean NOT |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "in", "not in", "is", "is not", "<", "<=", ">", | '
+ 'Comparisons, including membership |\n'
+ '| ">=", "<>", "!=", "==" | '
+ 'tests and identity tests |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "|" | '
+ 'Bitwise OR |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "^" | '
+ 'Bitwise XOR |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "&" | '
+ 'Bitwise AND |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "<<", ">>" | '
+ 'Shifts |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "+", "-" | '
+ 'Addition and subtraction |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "*", "/", "//", "%" | '
+ 'Multiplication, division, remainder |\n'
+ '| | '
+ '[7] |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "+x", "-x", "~x" | '
+ 'Positive, negative, bitwise NOT |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "**" | '
+ 'Exponentiation [8] |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "x[index]", "x[index:index]", | '
+ 'Subscription, slicing, call, |\n'
+ '| "x(arguments...)", "x.attribute" | '
+ 'attribute reference |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '| "(expressions...)", "[expressions...]", "{key: | '
+ 'Binding or tuple display, list |\n'
+ '| value...}", "`expressions...`" | '
+ 'display, dictionary display, string |\n'
+ '| | '
+ 'conversion |\n'
+ '+-------------------------------------------------+---------------------------------------+\n'
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ '[1] In Python 2.3 and later releases, a list '
+ 'comprehension "leaks"\n'
+ ' the control variables of each "for" it contains into '
+ 'the\n'
+ ' containing scope. However, this behavior is '
+ 'deprecated, and\n'
+ ' relying on it will not work in Python 3.\n'
+ '\n'
+ '[2] While "abs(x%y) < abs(y)" is true mathematically, '
+ 'for floats\n'
+ ' it may not be true numerically due to roundoff. For '
+ 'example, and\n'
+ ' assuming a platform on which a Python float is an '
+ 'IEEE 754 double-\n'
+ ' precision number, in order that "-1e-100 % 1e100" '
+ 'have the same\n'
+ ' sign as "1e100", the computed result is "-1e-100 + '
+ '1e100", which\n'
+ ' is numerically exactly equal to "1e100". The '
+ 'function\n'
+ ' "math.fmod()" returns a result whose sign matches '
+ 'the sign of the\n'
+ ' first argument instead, and so returns "-1e-100" in '
+ 'this case.\n'
+ ' Which approach is more appropriate depends on the '
+ 'application.\n'
+ '\n'
+ '[3] If x is very close to an exact integer multiple of '
+ "y, it's\n"
+ ' possible for "floor(x/y)" to be one larger than '
+ '"(x-x%y)/y" due to\n'
+ ' rounding. In such cases, Python returns the latter '
+ 'result, in\n'
+ ' order to preserve that "divmod(x,y)[0] * y + x % y" '
+ 'be very close\n'
+ ' to "x".\n'
+ '\n'
+ '[4] The Unicode standard distinguishes between *code '
+ 'points* (e.g.\n'
+ ' U+0041) and *abstract characters* (e.g. "LATIN '
+ 'CAPITAL LETTER A").\n'
+ ' While most abstract characters in Unicode are only '
+ 'represented\n'
+ ' using one code point, there is a number of abstract '
+ 'characters\n'
+ ' that can in addition be represented using a sequence '
+ 'of more than\n'
+ ' one code point. For example, the abstract character '
+ '"LATIN\n'
+ ' CAPITAL LETTER C WITH CEDILLA" can be represented as '
+ 'a single\n'
+ ' *precomposed character* at code position U+00C7, or '
+ 'as a sequence\n'
+ ' of a *base character* at code position U+0043 (LATIN '
+ 'CAPITAL\n'
+ ' LETTER C), followed by a *combining character* at '
+ 'code position\n'
+ ' U+0327 (COMBINING CEDILLA).\n'
+ '\n'
+ ' The comparison operators on unicode strings compare '
+ 'at the level\n'
+ ' of Unicode code points. This may be '
+ 'counter-intuitive to humans.\n'
+ ' For example, "u"\\u00C7" == u"\\u0043\\u0327"" is '
+ '"False", even\n'
+ ' though both strings represent the same abstract '
+ 'character "LATIN\n'
+ ' CAPITAL LETTER C WITH CEDILLA".\n'
+ '\n'
+ ' To compare strings at the level of abstract '
+ 'characters (that is,\n'
+ ' in a way intuitive to humans), use '
+ '"unicodedata.normalize()".\n'
+ '\n'
+ '[5] Earlier versions of Python used lexicographic '
+ 'comparison of\n'
+ ' the sorted (key, value) lists, but this was very '
+ 'expensive for the\n'
+ ' common case of comparing for equality. An even '
+ 'earlier version of\n'
+ ' Python compared dictionaries by identity only, but '
+ 'this caused\n'
+ ' surprises because people expected to be able to test '
+ 'a dictionary\n'
+ ' for emptiness by comparing it to "{}".\n'
+ '\n'
+ '[6] Due to automatic garbage-collection, free lists, and '
+ 'the\n'
+ ' dynamic nature of descriptors, you may notice '
+ 'seemingly unusual\n'
+ ' behaviour in certain uses of the "is" operator, like '
+ 'those\n'
+ ' involving comparisons between instance methods, or '
+ 'constants.\n'
+ ' Check their documentation for more info.\n'
+ '\n'
+ '[7] The "%" operator is also used for string formatting; '
+ 'the same\n'
+ ' precedence applies.\n'
+ '\n'
+ '[8] The power operator "**" binds less tightly than an '
+ 'arithmetic\n'
+ ' or bitwise unary operator on its right, that is, '
+ '"2**-1" is "0.5".\n',
+ 'pass': '\n'
+ 'The "pass" statement\n'
+ '********************\n'
+ '\n'
+ ' pass_stmt ::= "pass"\n'
+ '\n'
+ '"pass" is a null operation --- when it is executed, nothing '
+ 'happens.\n'
+ 'It is useful as a placeholder when a statement is required\n'
+ 'syntactically, but no code needs to be executed, for example:\n'
+ '\n'
+ ' def f(arg): pass # a function that does nothing (yet)\n'
+ '\n'
+ ' class C: pass # a class with no methods (yet)\n',
+ 'power': '\n'
+ 'The power operator\n'
+ '******************\n'
+ '\n'
+ 'The power operator binds more tightly than unary operators on its\n'
+ 'left; it binds less tightly than unary operators on its right. '
+ 'The\n'
+ 'syntax is:\n'
+ '\n'
+ ' power ::= primary ["**" u_expr]\n'
+ '\n'
+ 'Thus, in an unparenthesized sequence of power and unary operators, '
+ 'the\n'
+ 'operators are evaluated from right to left (this does not '
+ 'constrain\n'
+ 'the evaluation order for the operands): "-1**2" results in "-1".\n'
+ '\n'
+ 'The power operator has the same semantics as the built-in "pow()"\n'
+ 'function, when called with two arguments: it yields its left '
+ 'argument\n'
+ 'raised to the power of its right argument. The numeric arguments '
+ 'are\n'
+ 'first converted to a common type. The result type is that of the\n'
+ 'arguments after coercion.\n'
+ '\n'
+ 'With mixed operand types, the coercion rules for binary arithmetic\n'
+ 'operators apply. For int and long int operands, the result has the\n'
+ 'same type as the operands (after coercion) unless the second '
+ 'argument\n'
+ 'is negative; in that case, all arguments are converted to float and '
+ 'a\n'
+ 'float result is delivered. For example, "10**2" returns "100", but\n'
+ '"10**-2" returns "0.01". (This last feature was added in Python '
+ '2.2.\n'
+ 'In Python 2.1 and before, if both arguments were of integer types '
+ 'and\n'
+ 'the second argument was negative, an exception was raised).\n'
+ '\n'
+ 'Raising "0.0" to a negative power results in a '
+ '"ZeroDivisionError".\n'
+ 'Raising a negative number to a fractional power results in a\n'
+ '"ValueError".\n',
+ 'print': '\n'
+ 'The "print" statement\n'
+ '*********************\n'
+ '\n'
+ ' print_stmt ::= "print" ([expression ("," expression)* [","]]\n'
+ ' | ">>" expression [("," expression)+ [","]])\n'
+ '\n'
+ '"print" evaluates each expression in turn and writes the resulting\n'
+ 'object to standard output (see below). If an object is not a '
+ 'string,\n'
+ 'it is first converted to a string using the rules for string\n'
+ 'conversions. The (resulting or original) string is then written. '
+ 'A\n'
+ 'space is written before each object is (converted and) written, '
+ 'unless\n'
+ 'the output system believes it is positioned at the beginning of a\n'
+ 'line. This is the case (1) when no characters have yet been '
+ 'written\n'
+ 'to standard output, (2) when the last character written to '
+ 'standard\n'
+ 'output is a whitespace character except "\' \'", or (3) when the '
+ 'last\n'
+ 'write operation on standard output was not a "print" statement. '
+ '(In\n'
+ 'some cases it may be functional to write an empty string to '
+ 'standard\n'
+ 'output for this reason.)\n'
+ '\n'
+ 'Note: Objects which act like file objects but which are not the\n'
+ ' built-in file objects often do not properly emulate this aspect '
+ 'of\n'
+ " the file object's behavior, so it is best not to rely on this.\n"
+ '\n'
+ 'A "\'\\n\'" character is written at the end, unless the "print" '
+ 'statement\n'
+ 'ends with a comma. This is the only action if the statement '
+ 'contains\n'
+ 'just the keyword "print".\n'
+ '\n'
+ 'Standard output is defined as the file object named "stdout" in '
+ 'the\n'
+ 'built-in module "sys". If no such object exists, or if it does '
+ 'not\n'
+ 'have a "write()" method, a "RuntimeError" exception is raised.\n'
+ '\n'
+ '"print" also has an extended form, defined by the second portion '
+ 'of\n'
+ 'the syntax described above. This form is sometimes referred to as\n'
+ '""print" chevron." In this form, the first expression after the '
+ '">>"\n'
+ 'must evaluate to a "file-like" object, specifically an object that '
+ 'has\n'
+ 'a "write()" method as described above. With this extended form, '
+ 'the\n'
+ 'subsequent expressions are printed to this file object. If the '
+ 'first\n'
+ 'expression evaluates to "None", then "sys.stdout" is used as the '
+ 'file\n'
+ 'for output.\n',
+ 'raise': '\n'
+ 'The "raise" statement\n'
+ '*********************\n'
+ '\n'
+ ' raise_stmt ::= "raise" [expression ["," expression ["," '
+ 'expression]]]\n'
+ '\n'
+ 'If no expressions are present, "raise" re-raises the last '
+ 'exception\n'
+ 'that was active in the current scope. If no exception is active '
+ 'in\n'
+ 'the current scope, a "TypeError" exception is raised indicating '
+ 'that\n'
+ 'this is an error (if running under IDLE, a "Queue.Empty" exception '
+ 'is\n'
+ 'raised instead).\n'
+ '\n'
+ 'Otherwise, "raise" evaluates the expressions to get three objects,\n'
+ 'using "None" as the value of omitted expressions. The first two\n'
+ 'objects are used to determine the *type* and *value* of the '
+ 'exception.\n'
+ '\n'
+ 'If the first object is an instance, the type of the exception is '
+ 'the\n'
+ 'class of the instance, the instance itself is the value, and the\n'
+ 'second object must be "None".\n'
+ '\n'
+ 'If the first object is a class, it becomes the type of the '
+ 'exception.\n'
+ 'The second object is used to determine the exception value: If it '
+ 'is\n'
+ 'an instance of the class, the instance becomes the exception value. '
+ 'If\n'
+ 'the second object is a tuple, it is used as the argument list for '
+ 'the\n'
+ 'class constructor; if it is "None", an empty argument list is '
+ 'used,\n'
+ 'and any other object is treated as a single argument to the\n'
+ 'constructor. The instance so created by calling the constructor '
+ 'is\n'
+ 'used as the exception value.\n'
+ '\n'
+ 'If a third object is present and not "None", it must be a '
+ 'traceback\n'
+ 'object (see section The standard type hierarchy), and it is\n'
+ 'substituted instead of the current location as the place where the\n'
+ 'exception occurred. If the third object is present and not a\n'
+ 'traceback object or "None", a "TypeError" exception is raised. '
+ 'The\n'
+ 'three-expression form of "raise" is useful to re-raise an '
+ 'exception\n'
+ 'transparently in an except clause, but "raise" with no expressions\n'
+ 'should be preferred if the exception to be re-raised was the most\n'
+ 'recently active exception in the current scope.\n'
+ '\n'
+ 'Additional information on exceptions can be found in section\n'
+ 'Exceptions, and information about handling exceptions is in '
+ 'section\n'
+ 'The try statement.\n',
+ 'return': '\n'
+ 'The "return" statement\n'
+ '**********************\n'
+ '\n'
+ ' return_stmt ::= "return" [expression_list]\n'
+ '\n'
+ '"return" may only occur syntactically nested in a function '
+ 'definition,\n'
+ 'not within a nested class definition.\n'
+ '\n'
+ 'If an expression list is present, it is evaluated, else "None" is\n'
+ 'substituted.\n'
+ '\n'
+ '"return" leaves the current function call with the expression list '
+ '(or\n'
+ '"None") as return value.\n'
+ '\n'
+ 'When "return" passes control out of a "try" statement with a '
+ '"finally"\n'
+ 'clause, that "finally" clause is executed before really leaving '
+ 'the\n'
+ 'function.\n'
+ '\n'
+ 'In a generator function, the "return" statement is not allowed to\n'
+ 'include an "expression_list". In that context, a bare "return"\n'
+ 'indicates that the generator is done and will cause '
+ '"StopIteration" to\n'
+ 'be raised.\n',
+ 'sequence-types': '\n'
+ 'Emulating container types\n'
+ '*************************\n'
+ '\n'
+ 'The following methods can be defined to implement '
+ 'container objects.\n'
+ 'Containers usually are sequences (such as lists or tuples) '
+ 'or mappings\n'
+ '(like dictionaries), but can represent other containers as '
+ 'well. The\n'
+ 'first set of methods is used either to emulate a sequence '
+ 'or to\n'
+ 'emulate a mapping; the difference is that for a sequence, '
+ 'the\n'
+ 'allowable keys should be the integers *k* for which "0 <= '
+ 'k < N" where\n'
+ '*N* is the length of the sequence, or slice objects, which '
+ 'define a\n'
+ 'range of items. (For backwards compatibility, the method\n'
+ '"__getslice__()" (see below) can also be defined to handle '
+ 'simple, but\n'
+ 'not extended slices.) It is also recommended that mappings '
+ 'provide the\n'
+ 'methods "keys()", "values()", "items()", "has_key()", '
+ '"get()",\n'
+ '"clear()", "setdefault()", "iterkeys()", "itervalues()",\n'
+ '"iteritems()", "pop()", "popitem()", "copy()", and '
+ '"update()" behaving\n'
+ "similar to those for Python's standard dictionary "
+ 'objects. The\n'
+ '"UserDict" module provides a "DictMixin" class to help '
+ 'create those\n'
+ 'methods from a base set of "__getitem__()", '
+ '"__setitem__()",\n'
+ '"__delitem__()", and "keys()". Mutable sequences should '
+ 'provide\n'
+ 'methods "append()", "count()", "index()", "extend()", '
+ '"insert()",\n'
+ '"pop()", "remove()", "reverse()" and "sort()", like Python '
+ 'standard\n'
+ 'list objects. Finally, sequence types should implement '
+ 'addition\n'
+ '(meaning concatenation) and multiplication (meaning '
+ 'repetition) by\n'
+ 'defining the methods "__add__()", "__radd__()", '
+ '"__iadd__()",\n'
+ '"__mul__()", "__rmul__()" and "__imul__()" described '
+ 'below; they\n'
+ 'should not define "__coerce__()" or other numerical '
+ 'operators. It is\n'
+ 'recommended that both mappings and sequences implement '
+ 'the\n'
+ '"__contains__()" method to allow efficient use of the "in" '
+ 'operator;\n'
+ 'for mappings, "in" should be equivalent of "has_key()"; '
+ 'for sequences,\n'
+ 'it should search through the values. It is further '
+ 'recommended that\n'
+ 'both mappings and sequences implement the "__iter__()" '
+ 'method to allow\n'
+ 'efficient iteration through the container; for mappings, '
+ '"__iter__()"\n'
+ 'should be the same as "iterkeys()"; for sequences, it '
+ 'should iterate\n'
+ 'through the values.\n'
+ '\n'
+ 'object.__len__(self)\n'
+ '\n'
+ ' Called to implement the built-in function "len()". '
+ 'Should return\n'
+ ' the length of the object, an integer ">=" 0. Also, an '
+ 'object that\n'
+ ' doesn\'t define a "__nonzero__()" method and whose '
+ '"__len__()"\n'
+ ' method returns zero is considered to be false in a '
+ 'Boolean context.\n'
+ '\n'
+ ' **CPython implementation detail:** In CPython, the '
+ 'length is\n'
+ ' required to be at most "sys.maxsize". If the length is '
+ 'larger than\n'
+ ' "sys.maxsize" some features (such as "len()") may '
+ 'raise\n'
+ ' "OverflowError". To prevent raising "OverflowError" by '
+ 'truth value\n'
+ ' testing, an object must define a "__nonzero__()" '
+ 'method.\n'
+ '\n'
+ 'object.__getitem__(self, key)\n'
+ '\n'
+ ' Called to implement evaluation of "self[key]". For '
+ 'sequence types,\n'
+ ' the accepted keys should be integers and slice '
+ 'objects. Note that\n'
+ ' the special interpretation of negative indexes (if the '
+ 'class wishes\n'
+ ' to emulate a sequence type) is up to the '
+ '"__getitem__()" method. If\n'
+ ' *key* is of an inappropriate type, "TypeError" may be '
+ 'raised; if of\n'
+ ' a value outside the set of indexes for the sequence '
+ '(after any\n'
+ ' special interpretation of negative values), '
+ '"IndexError" should be\n'
+ ' raised. For mapping types, if *key* is missing (not in '
+ 'the\n'
+ ' container), "KeyError" should be raised.\n'
+ '\n'
+ ' Note: "for" loops expect that an "IndexError" will be '
+ 'raised for\n'
+ ' illegal indexes to allow proper detection of the end '
+ 'of the\n'
+ ' sequence.\n'
+ '\n'
+ 'object.__missing__(self, key)\n'
+ '\n'
+ ' Called by "dict"."__getitem__()" to implement '
+ '"self[key]" for dict\n'
+ ' subclasses when key is not in the dictionary.\n'
+ '\n'
+ 'object.__setitem__(self, key, value)\n'
+ '\n'
+ ' Called to implement assignment to "self[key]". Same '
+ 'note as for\n'
+ ' "__getitem__()". This should only be implemented for '
+ 'mappings if\n'
+ ' the objects support changes to the values for keys, or '
+ 'if new keys\n'
+ ' can be added, or for sequences if elements can be '
+ 'replaced. The\n'
+ ' same exceptions should be raised for improper *key* '
+ 'values as for\n'
+ ' the "__getitem__()" method.\n'
+ '\n'
+ 'object.__delitem__(self, key)\n'
+ '\n'
+ ' Called to implement deletion of "self[key]". Same note '
+ 'as for\n'
+ ' "__getitem__()". This should only be implemented for '
+ 'mappings if\n'
+ ' the objects support removal of keys, or for sequences '
+ 'if elements\n'
+ ' can be removed from the sequence. The same exceptions '
+ 'should be\n'
+ ' raised for improper *key* values as for the '
+ '"__getitem__()" method.\n'
+ '\n'
+ 'object.__iter__(self)\n'
+ '\n'
+ ' This method is called when an iterator is required for '
+ 'a container.\n'
+ ' This method should return a new iterator object that '
+ 'can iterate\n'
+ ' over all the objects in the container. For mappings, '
+ 'it should\n'
+ ' iterate over the keys of the container, and should also '
+ 'be made\n'
+ ' available as the method "iterkeys()".\n'
+ '\n'
+ ' Iterator objects also need to implement this method; '
+ 'they are\n'
+ ' required to return themselves. For more information on '
+ 'iterator\n'
+ ' objects, see Iterator Types.\n'
+ '\n'
+ 'object.__reversed__(self)\n'
+ '\n'
+ ' Called (if present) by the "reversed()" built-in to '
+ 'implement\n'
+ ' reverse iteration. It should return a new iterator '
+ 'object that\n'
+ ' iterates over all the objects in the container in '
+ 'reverse order.\n'
+ '\n'
+ ' If the "__reversed__()" method is not provided, the '
+ '"reversed()"\n'
+ ' built-in will fall back to using the sequence protocol '
+ '("__len__()"\n'
+ ' and "__getitem__()"). Objects that support the '
+ 'sequence protocol\n'
+ ' should only provide "__reversed__()" if they can '
+ 'provide an\n'
+ ' implementation that is more efficient than the one '
+ 'provided by\n'
+ ' "reversed()".\n'
+ '\n'
+ ' New in version 2.6.\n'
+ '\n'
+ 'The membership test operators ("in" and "not in") are '
+ 'normally\n'
+ 'implemented as an iteration through a sequence. However, '
+ 'container\n'
+ 'objects can supply the following special method with a '
+ 'more efficient\n'
+ 'implementation, which also does not require the object be '
+ 'a sequence.\n'
+ '\n'
+ 'object.__contains__(self, item)\n'
+ '\n'
+ ' Called to implement membership test operators. Should '
+ 'return true\n'
+ ' if *item* is in *self*, false otherwise. For mapping '
+ 'objects, this\n'
+ ' should consider the keys of the mapping rather than the '
+ 'values or\n'
+ ' the key-item pairs.\n'
+ '\n'
+ ' For objects that don\'t define "__contains__()", the '
+ 'membership test\n'
+ ' first tries iteration via "__iter__()", then the old '
+ 'sequence\n'
+ ' iteration protocol via "__getitem__()", see this '
+ 'section in the\n'
+ ' language reference.\n',
+ 'shifting': '\n'
+ 'Shifting operations\n'
+ '*******************\n'
+ '\n'
+ 'The shifting operations have lower priority than the arithmetic\n'
+ 'operations:\n'
+ '\n'
+ ' shift_expr ::= a_expr | shift_expr ( "<<" | ">>" ) a_expr\n'
+ '\n'
+ 'These operators accept plain or long integers as arguments. '
+ 'The\n'
+ 'arguments are converted to a common type. They shift the first\n'
+ 'argument to the left or right by the number of bits given by '
+ 'the\n'
+ 'second argument.\n'
+ '\n'
+ 'A right shift by *n* bits is defined as division by "pow(2, '
+ 'n)". A\n'
+ 'left shift by *n* bits is defined as multiplication with "pow(2, '
+ 'n)".\n'
+ 'Negative shift counts raise a "ValueError" exception.\n'
+ '\n'
+ 'Note: In the current implementation, the right-hand operand is\n'
+ ' required to be at most "sys.maxsize". If the right-hand '
+ 'operand is\n'
+ ' larger than "sys.maxsize" an "OverflowError" exception is '
+ 'raised.\n',
+ 'slicings': '\n'
+ 'Slicings\n'
+ '********\n'
+ '\n'
+ 'A slicing selects a range of items in a sequence object (e.g., '
+ 'a\n'
+ 'string, tuple or list). Slicings may be used as expressions or '
+ 'as\n'
+ 'targets in assignment or "del" statements. The syntax for a '
+ 'slicing:\n'
+ '\n'
+ ' slicing ::= simple_slicing | extended_slicing\n'
+ ' simple_slicing ::= primary "[" short_slice "]"\n'
+ ' extended_slicing ::= primary "[" slice_list "]"\n'
+ ' slice_list ::= slice_item ("," slice_item)* [","]\n'
+ ' slice_item ::= expression | proper_slice | ellipsis\n'
+ ' proper_slice ::= short_slice | long_slice\n'
+ ' short_slice ::= [lower_bound] ":" [upper_bound]\n'
+ ' long_slice ::= short_slice ":" [stride]\n'
+ ' lower_bound ::= expression\n'
+ ' upper_bound ::= expression\n'
+ ' stride ::= expression\n'
+ ' ellipsis ::= "..."\n'
+ '\n'
+ 'There is ambiguity in the formal syntax here: anything that '
+ 'looks like\n'
+ 'an expression list also looks like a slice list, so any '
+ 'subscription\n'
+ 'can be interpreted as a slicing. Rather than further '
+ 'complicating the\n'
+ 'syntax, this is disambiguated by defining that in this case the\n'
+ 'interpretation as a subscription takes priority over the\n'
+ 'interpretation as a slicing (this is the case if the slice list\n'
+ 'contains no proper slice nor ellipses). Similarly, when the '
+ 'slice\n'
+ 'list has exactly one short slice and no trailing comma, the\n'
+ 'interpretation as a simple slicing takes priority over that as '
+ 'an\n'
+ 'extended slicing.\n'
+ '\n'
+ 'The semantics for a simple slicing are as follows. The primary '
+ 'must\n'
+ 'evaluate to a sequence object. The lower and upper bound '
+ 'expressions,\n'
+ 'if present, must evaluate to plain integers; defaults are zero '
+ 'and the\n'
+ '"sys.maxint", respectively. If either bound is negative, the\n'
+ "sequence's length is added to it. The slicing now selects all "
+ 'items\n'
+ 'with index *k* such that "i <= k < j" where *i* and *j* are the\n'
+ 'specified lower and upper bounds. This may be an empty '
+ 'sequence. It\n'
+ 'is not an error if *i* or *j* lie outside the range of valid '
+ 'indexes\n'
+ "(such items don't exist so they aren't selected).\n"
+ '\n'
+ 'The semantics for an extended slicing are as follows. The '
+ 'primary\n'
+ 'must evaluate to a mapping object, and it is indexed with a key '
+ 'that\n'
+ 'is constructed from the slice list, as follows. If the slice '
+ 'list\n'
+ 'contains at least one comma, the key is a tuple containing the\n'
+ 'conversion of the slice items; otherwise, the conversion of the '
+ 'lone\n'
+ 'slice item is the key. The conversion of a slice item that is '
+ 'an\n'
+ 'expression is that expression. The conversion of an ellipsis '
+ 'slice\n'
+ 'item is the built-in "Ellipsis" object. The conversion of a '
+ 'proper\n'
+ 'slice is a slice object (see section The standard type '
+ 'hierarchy)\n'
+ 'whose "start", "stop" and "step" attributes are the values of '
+ 'the\n'
+ 'expressions given as lower bound, upper bound and stride,\n'
+ 'respectively, substituting "None" for missing expressions.\n',
+ 'specialattrs': '\n'
+ 'Special Attributes\n'
+ '******************\n'
+ '\n'
+ 'The implementation adds a few special read-only attributes '
+ 'to several\n'
+ 'object types, where they are relevant. Some of these are '
+ 'not reported\n'
+ 'by the "dir()" built-in function.\n'
+ '\n'
+ 'object.__dict__\n'
+ '\n'
+ ' A dictionary or other mapping object used to store an '
+ "object's\n"
+ ' (writable) attributes.\n'
+ '\n'
+ 'object.__methods__\n'
+ '\n'
+ ' Deprecated since version 2.2: Use the built-in function '
+ '"dir()" to\n'
+ " get a list of an object's attributes. This attribute is "
+ 'no longer\n'
+ ' available.\n'
+ '\n'
+ 'object.__members__\n'
+ '\n'
+ ' Deprecated since version 2.2: Use the built-in function '
+ '"dir()" to\n'
+ " get a list of an object's attributes. This attribute is "
+ 'no longer\n'
+ ' available.\n'
+ '\n'
+ 'instance.__class__\n'
+ '\n'
+ ' The class to which a class instance belongs.\n'
+ '\n'
+ 'class.__bases__\n'
+ '\n'
+ ' The tuple of base classes of a class object.\n'
+ '\n'
+ 'definition.__name__\n'
+ '\n'
+ ' The name of the class, type, function, method, '
+ 'descriptor, or\n'
+ ' generator instance.\n'
+ '\n'
+ 'The following attributes are only supported by *new-style '
+ 'class*es.\n'
+ '\n'
+ 'class.__mro__\n'
+ '\n'
+ ' This attribute is a tuple of classes that are considered '
+ 'when\n'
+ ' looking for base classes during method resolution.\n'
+ '\n'
+ 'class.mro()\n'
+ '\n'
+ ' This method can be overridden by a metaclass to customize '
+ 'the\n'
+ ' method resolution order for its instances. It is called '
+ 'at class\n'
+ ' instantiation, and its result is stored in "__mro__".\n'
+ '\n'
+ 'class.__subclasses__()\n'
+ '\n'
+ ' Each new-style class keeps a list of weak references to '
+ 'its\n'
+ ' immediate subclasses. This method returns a list of all '
+ 'those\n'
+ ' references still alive. Example:\n'
+ '\n'
+ ' >>> int.__subclasses__()\n'
+ " [<type 'bool'>]\n"
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ '[1] Additional information on these special methods may be '
+ 'found\n'
+ ' in the Python Reference Manual (Basic customization).\n'
+ '\n'
+ '[2] As a consequence, the list "[1, 2]" is considered equal '
+ 'to\n'
+ ' "[1.0, 2.0]", and similarly for tuples.\n'
+ '\n'
+ "[3] They must have since the parser can't tell the type of "
+ 'the\n'
+ ' operands.\n'
+ '\n'
+ '[4] Cased characters are those with general category '
+ 'property\n'
+ ' being one of "Lu" (Letter, uppercase), "Ll" (Letter, '
+ 'lowercase),\n'
+ ' or "Lt" (Letter, titlecase).\n'
+ '\n'
+ '[5] To format only a tuple you should therefore provide a\n'
+ ' singleton tuple whose only element is the tuple to be '
+ 'formatted.\n'
+ '\n'
+ '[6] The advantage of leaving the newline on is that '
+ 'returning an\n'
+ ' empty string is then an unambiguous EOF indication. It '
+ 'is also\n'
+ ' possible (in cases where it might matter, for example, '
+ 'if you want\n'
+ ' to make an exact copy of a file while scanning its '
+ 'lines) to tell\n'
+ ' whether the last line of a file ended in a newline or '
+ 'not (yes\n'
+ ' this happens!).\n',
+ 'specialnames': '\n'
+ 'Special method names\n'
+ '********************\n'
+ '\n'
+ 'A class can implement certain operations that are invoked by '
+ 'special\n'
+ 'syntax (such as arithmetic operations or subscripting and '
+ 'slicing) by\n'
+ "defining methods with special names. This is Python's "
+ 'approach to\n'
+ '*operator overloading*, allowing classes to define their own '
+ 'behavior\n'
+ 'with respect to language operators. For instance, if a '
+ 'class defines\n'
+ 'a method named "__getitem__()", and "x" is an instance of '
+ 'this class,\n'
+ 'then "x[i]" is roughly equivalent to "x.__getitem__(i)" for '
+ 'old-style\n'
+ 'classes and "type(x).__getitem__(x, i)" for new-style '
+ 'classes. Except\n'
+ 'where mentioned, attempts to execute an operation raise an '
+ 'exception\n'
+ 'when no appropriate method is defined (typically '
+ '"AttributeError" or\n'
+ '"TypeError").\n'
+ '\n'
+ 'When implementing a class that emulates any built-in type, '
+ 'it is\n'
+ 'important that the emulation only be implemented to the '
+ 'degree that it\n'
+ 'makes sense for the object being modelled. For example, '
+ 'some\n'
+ 'sequences may work well with retrieval of individual '
+ 'elements, but\n'
+ 'extracting a slice may not make sense. (One example of this '
+ 'is the\n'
+ '"NodeList" interface in the W3C\'s Document Object Model.)\n'
+ '\n'
+ '\n'
+ 'Basic customization\n'
+ '===================\n'
+ '\n'
+ 'object.__new__(cls[, ...])\n'
+ '\n'
+ ' Called to create a new instance of class *cls*. '
+ '"__new__()" is a\n'
+ ' static method (special-cased so you need not declare it '
+ 'as such)\n'
+ ' that takes the class of which an instance was requested '
+ 'as its\n'
+ ' first argument. The remaining arguments are those passed '
+ 'to the\n'
+ ' object constructor expression (the call to the class). '
+ 'The return\n'
+ ' value of "__new__()" should be the new object instance '
+ '(usually an\n'
+ ' instance of *cls*).\n'
+ '\n'
+ ' Typical implementations create a new instance of the '
+ 'class by\n'
+ ' invoking the superclass\'s "__new__()" method using\n'
+ ' "super(currentclass, cls).__new__(cls[, ...])" with '
+ 'appropriate\n'
+ ' arguments and then modifying the newly-created instance '
+ 'as\n'
+ ' necessary before returning it.\n'
+ '\n'
+ ' If "__new__()" returns an instance of *cls*, then the '
+ 'new\n'
+ ' instance\'s "__init__()" method will be invoked like\n'
+ ' "__init__(self[, ...])", where *self* is the new instance '
+ 'and the\n'
+ ' remaining arguments are the same as were passed to '
+ '"__new__()".\n'
+ '\n'
+ ' If "__new__()" does not return an instance of *cls*, then '
+ 'the new\n'
+ ' instance\'s "__init__()" method will not be invoked.\n'
+ '\n'
+ ' "__new__()" is intended mainly to allow subclasses of '
+ 'immutable\n'
+ ' types (like int, str, or tuple) to customize instance '
+ 'creation. It\n'
+ ' is also commonly overridden in custom metaclasses in '
+ 'order to\n'
+ ' customize class creation.\n'
+ '\n'
+ 'object.__init__(self[, ...])\n'
+ '\n'
+ ' Called after the instance has been created (by '
+ '"__new__()"), but\n'
+ ' before it is returned to the caller. The arguments are '
+ 'those\n'
+ ' passed to the class constructor expression. If a base '
+ 'class has an\n'
+ ' "__init__()" method, the derived class\'s "__init__()" '
+ 'method, if\n'
+ ' any, must explicitly call it to ensure proper '
+ 'initialization of the\n'
+ ' base class part of the instance; for example:\n'
+ ' "BaseClass.__init__(self, [args...])".\n'
+ '\n'
+ ' Because "__new__()" and "__init__()" work together in '
+ 'constructing\n'
+ ' objects ("__new__()" to create it, and "__init__()" to '
+ 'customise\n'
+ ' it), no non-"None" value may be returned by "__init__()"; '
+ 'doing so\n'
+ ' will cause a "TypeError" to be raised at runtime.\n'
+ '\n'
+ 'object.__del__(self)\n'
+ '\n'
+ ' Called when the instance is about to be destroyed. This '
+ 'is also\n'
+ ' called a destructor. If a base class has a "__del__()" '
+ 'method, the\n'
+ ' derived class\'s "__del__()" method, if any, must '
+ 'explicitly call it\n'
+ ' to ensure proper deletion of the base class part of the '
+ 'instance.\n'
+ ' Note that it is possible (though not recommended!) for '
+ 'the\n'
+ ' "__del__()" method to postpone destruction of the '
+ 'instance by\n'
+ ' creating a new reference to it. It may then be called at '
+ 'a later\n'
+ ' time when this new reference is deleted. It is not '
+ 'guaranteed that\n'
+ ' "__del__()" methods are called for objects that still '
+ 'exist when\n'
+ ' the interpreter exits.\n'
+ '\n'
+ ' Note: "del x" doesn\'t directly call "x.__del__()" --- '
+ 'the former\n'
+ ' decrements the reference count for "x" by one, and the '
+ 'latter is\n'
+ ' only called when "x"\'s reference count reaches zero. '
+ 'Some common\n'
+ ' situations that may prevent the reference count of an '
+ 'object from\n'
+ ' going to zero include: circular references between '
+ 'objects (e.g.,\n'
+ ' a doubly-linked list or a tree data structure with '
+ 'parent and\n'
+ ' child pointers); a reference to the object on the stack '
+ 'frame of\n'
+ ' a function that caught an exception (the traceback '
+ 'stored in\n'
+ ' "sys.exc_traceback" keeps the stack frame alive); or a '
+ 'reference\n'
+ ' to the object on the stack frame that raised an '
+ 'unhandled\n'
+ ' exception in interactive mode (the traceback stored in\n'
+ ' "sys.last_traceback" keeps the stack frame alive). The '
+ 'first\n'
+ ' situation can only be remedied by explicitly breaking '
+ 'the cycles;\n'
+ ' the latter two situations can be resolved by storing '
+ '"None" in\n'
+ ' "sys.exc_traceback" or "sys.last_traceback". Circular '
+ 'references\n'
+ ' which are garbage are detected when the option cycle '
+ 'detector is\n'
+ " enabled (it's on by default), but can only be cleaned "
+ 'up if there\n'
+ ' are no Python-level "__del__()" methods involved. Refer '
+ 'to the\n'
+ ' documentation for the "gc" module for more information '
+ 'about how\n'
+ ' "__del__()" methods are handled by the cycle detector,\n'
+ ' particularly the description of the "garbage" value.\n'
+ '\n'
+ ' Warning: Due to the precarious circumstances under which\n'
+ ' "__del__()" methods are invoked, exceptions that occur '
+ 'during\n'
+ ' their execution are ignored, and a warning is printed '
+ 'to\n'
+ ' "sys.stderr" instead. Also, when "__del__()" is invoked '
+ 'in\n'
+ ' response to a module being deleted (e.g., when '
+ 'execution of the\n'
+ ' program is done), other globals referenced by the '
+ '"__del__()"\n'
+ ' method may already have been deleted or in the process '
+ 'of being\n'
+ ' torn down (e.g. the import machinery shutting down). '
+ 'For this\n'
+ ' reason, "__del__()" methods should do the absolute '
+ 'minimum needed\n'
+ ' to maintain external invariants. Starting with version '
+ '1.5,\n'
+ ' Python guarantees that globals whose name begins with a '
+ 'single\n'
+ ' underscore are deleted from their module before other '
+ 'globals are\n'
+ ' deleted; if no other references to such globals exist, '
+ 'this may\n'
+ ' help in assuring that imported modules are still '
+ 'available at the\n'
+ ' time when the "__del__()" method is called.\n'
+ '\n'
+ ' See also the "-R" command-line option.\n'
+ '\n'
+ 'object.__repr__(self)\n'
+ '\n'
+ ' Called by the "repr()" built-in function and by string '
+ 'conversions\n'
+ ' (reverse quotes) to compute the "official" string '
+ 'representation of\n'
+ ' an object. If at all possible, this should look like a '
+ 'valid\n'
+ ' Python expression that could be used to recreate an '
+ 'object with the\n'
+ ' same value (given an appropriate environment). If this '
+ 'is not\n'
+ ' possible, a string of the form "<...some useful '
+ 'description...>"\n'
+ ' should be returned. The return value must be a string '
+ 'object. If a\n'
+ ' class defines "__repr__()" but not "__str__()", then '
+ '"__repr__()"\n'
+ ' is also used when an "informal" string representation of '
+ 'instances\n'
+ ' of that class is required.\n'
+ '\n'
+ ' This is typically used for debugging, so it is important '
+ 'that the\n'
+ ' representation is information-rich and unambiguous.\n'
+ '\n'
+ 'object.__str__(self)\n'
+ '\n'
+ ' Called by the "str()" built-in function and by the '
+ '"print"\n'
+ ' statement to compute the "informal" string representation '
+ 'of an\n'
+ ' object. This differs from "__repr__()" in that it does '
+ 'not have to\n'
+ ' be a valid Python expression: a more convenient or '
+ 'concise\n'
+ ' representation may be used instead. The return value must '
+ 'be a\n'
+ ' string object.\n'
+ '\n'
+ 'object.__lt__(self, other)\n'
+ 'object.__le__(self, other)\n'
+ 'object.__eq__(self, other)\n'
+ 'object.__ne__(self, other)\n'
+ 'object.__gt__(self, other)\n'
+ 'object.__ge__(self, other)\n'
+ '\n'
+ ' New in version 2.1.\n'
+ '\n'
+ ' These are the so-called "rich comparison" methods, and '
+ 'are called\n'
+ ' for comparison operators in preference to "__cmp__()" '
+ 'below. The\n'
+ ' correspondence between operator symbols and method names '
+ 'is as\n'
+ ' follows: "x<y" calls "x.__lt__(y)", "x<=y" calls '
+ '"x.__le__(y)",\n'
+ ' "x==y" calls "x.__eq__(y)", "x!=y" and "x<>y" call '
+ '"x.__ne__(y)",\n'
+ ' "x>y" calls "x.__gt__(y)", and "x>=y" calls '
+ '"x.__ge__(y)".\n'
+ '\n'
+ ' A rich comparison method may return the singleton '
+ '"NotImplemented"\n'
+ ' if it does not implement the operation for a given pair '
+ 'of\n'
+ ' arguments. By convention, "False" and "True" are returned '
+ 'for a\n'
+ ' successful comparison. However, these methods can return '
+ 'any value,\n'
+ ' so if the comparison operator is used in a Boolean '
+ 'context (e.g.,\n'
+ ' in the condition of an "if" statement), Python will call '
+ '"bool()"\n'
+ ' on the value to determine if the result is true or '
+ 'false.\n'
+ '\n'
+ ' There are no implied relationships among the comparison '
+ 'operators.\n'
+ ' The truth of "x==y" does not imply that "x!=y" is false.\n'
+ ' Accordingly, when defining "__eq__()", one should also '
+ 'define\n'
+ ' "__ne__()" so that the operators will behave as '
+ 'expected. See the\n'
+ ' paragraph on "__hash__()" for some important notes on '
+ 'creating\n'
+ ' *hashable* objects which support custom comparison '
+ 'operations and\n'
+ ' are usable as dictionary keys.\n'
+ '\n'
+ ' There are no swapped-argument versions of these methods '
+ '(to be used\n'
+ ' when the left argument does not support the operation but '
+ 'the right\n'
+ ' argument does); rather, "__lt__()" and "__gt__()" are '
+ "each other's\n"
+ ' reflection, "__le__()" and "__ge__()" are each other\'s '
+ 'reflection,\n'
+ ' and "__eq__()" and "__ne__()" are their own reflection.\n'
+ '\n'
+ ' Arguments to rich comparison methods are never coerced.\n'
+ '\n'
+ ' To automatically generate ordering operations from a '
+ 'single root\n'
+ ' operation, see "functools.total_ordering()".\n'
+ '\n'
+ 'object.__cmp__(self, other)\n'
+ '\n'
+ ' Called by comparison operations if rich comparison (see '
+ 'above) is\n'
+ ' not defined. Should return a negative integer if "self < '
+ 'other",\n'
+ ' zero if "self == other", a positive integer if "self > '
+ 'other". If\n'
+ ' no "__cmp__()", "__eq__()" or "__ne__()" operation is '
+ 'defined,\n'
+ ' class instances are compared by object identity '
+ '("address"). See\n'
+ ' also the description of "__hash__()" for some important '
+ 'notes on\n'
+ ' creating *hashable* objects which support custom '
+ 'comparison\n'
+ ' operations and are usable as dictionary keys. (Note: the\n'
+ ' restriction that exceptions are not propagated by '
+ '"__cmp__()" has\n'
+ ' been removed since Python 1.5.)\n'
+ '\n'
+ 'object.__rcmp__(self, other)\n'
+ '\n'
+ ' Changed in version 2.1: No longer supported.\n'
+ '\n'
+ 'object.__hash__(self)\n'
+ '\n'
+ ' Called by built-in function "hash()" and for operations '
+ 'on members\n'
+ ' of hashed collections including "set", "frozenset", and '
+ '"dict".\n'
+ ' "__hash__()" should return an integer. The only required '
+ 'property\n'
+ ' is that objects which compare equal have the same hash '
+ 'value; it is\n'
+ ' advised to mix together the hash values of the components '
+ 'of the\n'
+ ' object that also play a part in comparison of objects by '
+ 'packing\n'
+ ' them into a tuple and hashing the tuple. Example:\n'
+ '\n'
+ ' def __hash__(self):\n'
+ ' return hash((self.name, self.nick, self.color))\n'
+ '\n'
+ ' If a class does not define a "__cmp__()" or "__eq__()" '
+ 'method it\n'
+ ' should not define a "__hash__()" operation either; if it '
+ 'defines\n'
+ ' "__cmp__()" or "__eq__()" but not "__hash__()", its '
+ 'instances will\n'
+ ' not be usable in hashed collections. If a class defines '
+ 'mutable\n'
+ ' objects and implements a "__cmp__()" or "__eq__()" '
+ 'method, it\n'
+ ' should not implement "__hash__()", since hashable '
+ 'collection\n'
+ " implementations require that an object's hash value is "
+ 'immutable\n'
+ " (if the object's hash value changes, it will be in the "
+ 'wrong hash\n'
+ ' bucket).\n'
+ '\n'
+ ' User-defined classes have "__cmp__()" and "__hash__()" '
+ 'methods by\n'
+ ' default; with them, all objects compare unequal (except '
+ 'with\n'
+ ' themselves) and "x.__hash__()" returns a result derived '
+ 'from\n'
+ ' "id(x)".\n'
+ '\n'
+ ' Classes which inherit a "__hash__()" method from a parent '
+ 'class but\n'
+ ' change the meaning of "__cmp__()" or "__eq__()" such that '
+ 'the hash\n'
+ ' value returned is no longer appropriate (e.g. by '
+ 'switching to a\n'
+ ' value-based concept of equality instead of the default '
+ 'identity\n'
+ ' based equality) can explicitly flag themselves as being '
+ 'unhashable\n'
+ ' by setting "__hash__ = None" in the class definition. '
+ 'Doing so\n'
+ ' means that not only will instances of the class raise an\n'
+ ' appropriate "TypeError" when a program attempts to '
+ 'retrieve their\n'
+ ' hash value, but they will also be correctly identified '
+ 'as\n'
+ ' unhashable when checking "isinstance(obj, '
+ 'collections.Hashable)"\n'
+ ' (unlike classes which define their own "__hash__()" to '
+ 'explicitly\n'
+ ' raise "TypeError").\n'
+ '\n'
+ ' Changed in version 2.5: "__hash__()" may now also return '
+ 'a long\n'
+ ' integer object; the 32-bit integer is then derived from '
+ 'the hash of\n'
+ ' that object.\n'
+ '\n'
+ ' Changed in version 2.6: "__hash__" may now be set to '
+ '"None" to\n'
+ ' explicitly flag instances of a class as unhashable.\n'
+ '\n'
+ 'object.__nonzero__(self)\n'
+ '\n'
+ ' Called to implement truth value testing and the built-in '
+ 'operation\n'
+ ' "bool()"; should return "False" or "True", or their '
+ 'integer\n'
+ ' equivalents "0" or "1". When this method is not '
+ 'defined,\n'
+ ' "__len__()" is called, if it is defined, and the object '
+ 'is\n'
+ ' considered true if its result is nonzero. If a class '
+ 'defines\n'
+ ' neither "__len__()" nor "__nonzero__()", all its '
+ 'instances are\n'
+ ' considered true.\n'
+ '\n'
+ 'object.__unicode__(self)\n'
+ '\n'
+ ' Called to implement "unicode()" built-in; should return a '
+ 'Unicode\n'
+ ' object. When this method is not defined, string '
+ 'conversion is\n'
+ ' attempted, and the result of string conversion is '
+ 'converted to\n'
+ ' Unicode using the system default encoding.\n'
+ '\n'
+ '\n'
+ 'Customizing attribute access\n'
+ '============================\n'
+ '\n'
+ 'The following methods can be defined to customize the '
+ 'meaning of\n'
+ 'attribute access (use of, assignment to, or deletion of '
+ '"x.name") for\n'
+ 'class instances.\n'
+ '\n'
+ 'object.__getattr__(self, name)\n'
+ '\n'
+ ' Called when an attribute lookup has not found the '
+ 'attribute in the\n'
+ ' usual places (i.e. it is not an instance attribute nor is '
+ 'it found\n'
+ ' in the class tree for "self"). "name" is the attribute '
+ 'name. This\n'
+ ' method should return the (computed) attribute value or '
+ 'raise an\n'
+ ' "AttributeError" exception.\n'
+ '\n'
+ ' Note that if the attribute is found through the normal '
+ 'mechanism,\n'
+ ' "__getattr__()" is not called. (This is an intentional '
+ 'asymmetry\n'
+ ' between "__getattr__()" and "__setattr__()".) This is '
+ 'done both for\n'
+ ' efficiency reasons and because otherwise "__getattr__()" '
+ 'would have\n'
+ ' no way to access other attributes of the instance. Note '
+ 'that at\n'
+ ' least for instance variables, you can fake total control '
+ 'by not\n'
+ ' inserting any values in the instance attribute dictionary '
+ '(but\n'
+ ' instead inserting them in another object). See the\n'
+ ' "__getattribute__()" method below for a way to actually '
+ 'get total\n'
+ ' control in new-style classes.\n'
+ '\n'
+ 'object.__setattr__(self, name, value)\n'
+ '\n'
+ ' Called when an attribute assignment is attempted. This '
+ 'is called\n'
+ ' instead of the normal mechanism (i.e. store the value in '
+ 'the\n'
+ ' instance dictionary). *name* is the attribute name, '
+ '*value* is the\n'
+ ' value to be assigned to it.\n'
+ '\n'
+ ' If "__setattr__()" wants to assign to an instance '
+ 'attribute, it\n'
+ ' should not simply execute "self.name = value" --- this '
+ 'would cause\n'
+ ' a recursive call to itself. Instead, it should insert '
+ 'the value in\n'
+ ' the dictionary of instance attributes, e.g., '
+ '"self.__dict__[name] =\n'
+ ' value". For new-style classes, rather than accessing the '
+ 'instance\n'
+ ' dictionary, it should call the base class method with the '
+ 'same\n'
+ ' name, for example, "object.__setattr__(self, name, '
+ 'value)".\n'
+ '\n'
+ 'object.__delattr__(self, name)\n'
+ '\n'
+ ' Like "__setattr__()" but for attribute deletion instead '
+ 'of\n'
+ ' assignment. This should only be implemented if "del '
+ 'obj.name" is\n'
+ ' meaningful for the object.\n'
+ '\n'
+ '\n'
+ 'More attribute access for new-style classes\n'
+ '-------------------------------------------\n'
+ '\n'
+ 'The following methods only apply to new-style classes.\n'
+ '\n'
+ 'object.__getattribute__(self, name)\n'
+ '\n'
+ ' Called unconditionally to implement attribute accesses '
+ 'for\n'
+ ' instances of the class. If the class also defines '
+ '"__getattr__()",\n'
+ ' the latter will not be called unless "__getattribute__()" '
+ 'either\n'
+ ' calls it explicitly or raises an "AttributeError". This '
+ 'method\n'
+ ' should return the (computed) attribute value or raise an\n'
+ ' "AttributeError" exception. In order to avoid infinite '
+ 'recursion in\n'
+ ' this method, its implementation should always call the '
+ 'base class\n'
+ ' method with the same name to access any attributes it '
+ 'needs, for\n'
+ ' example, "object.__getattribute__(self, name)".\n'
+ '\n'
+ ' Note: This method may still be bypassed when looking up '
+ 'special\n'
+ ' methods as the result of implicit invocation via '
+ 'language syntax\n'
+ ' or built-in functions. See Special method lookup for '
+ 'new-style\n'
+ ' classes.\n'
+ '\n'
+ '\n'
+ 'Implementing Descriptors\n'
+ '------------------------\n'
+ '\n'
+ 'The following methods only apply when an instance of the '
+ 'class\n'
+ 'containing the method (a so-called *descriptor* class) '
+ 'appears in an\n'
+ "*owner* class (the descriptor must be in either the owner's "
+ 'class\n'
+ 'dictionary or in the class dictionary for one of its '
+ 'parents). In the\n'
+ 'examples below, "the attribute" refers to the attribute '
+ 'whose name is\n'
+ 'the key of the property in the owner class\' "__dict__".\n'
+ '\n'
+ 'object.__get__(self, instance, owner)\n'
+ '\n'
+ ' Called to get the attribute of the owner class (class '
+ 'attribute\n'
+ ' access) or of an instance of that class (instance '
+ 'attribute\n'
+ ' access). *owner* is always the owner class, while '
+ '*instance* is the\n'
+ ' instance that the attribute was accessed through, or '
+ '"None" when\n'
+ ' the attribute is accessed through the *owner*. This '
+ 'method should\n'
+ ' return the (computed) attribute value or raise an '
+ '"AttributeError"\n'
+ ' exception.\n'
+ '\n'
+ 'object.__set__(self, instance, value)\n'
+ '\n'
+ ' Called to set the attribute on an instance *instance* of '
+ 'the owner\n'
+ ' class to a new value, *value*.\n'
+ '\n'
+ 'object.__delete__(self, instance)\n'
+ '\n'
+ ' Called to delete the attribute on an instance *instance* '
+ 'of the\n'
+ ' owner class.\n'
+ '\n'
+ '\n'
+ 'Invoking Descriptors\n'
+ '--------------------\n'
+ '\n'
+ 'In general, a descriptor is an object attribute with '
+ '"binding\n'
+ 'behavior", one whose attribute access has been overridden by '
+ 'methods\n'
+ 'in the descriptor protocol: "__get__()", "__set__()", and\n'
+ '"__delete__()". If any of those methods are defined for an '
+ 'object, it\n'
+ 'is said to be a descriptor.\n'
+ '\n'
+ 'The default behavior for attribute access is to get, set, or '
+ 'delete\n'
+ "the attribute from an object's dictionary. For instance, "
+ '"a.x" has a\n'
+ 'lookup chain starting with "a.__dict__[\'x\']", then\n'
+ '"type(a).__dict__[\'x\']", and continuing through the base '
+ 'classes of\n'
+ '"type(a)" excluding metaclasses.\n'
+ '\n'
+ 'However, if the looked-up value is an object defining one of '
+ 'the\n'
+ 'descriptor methods, then Python may override the default '
+ 'behavior and\n'
+ 'invoke the descriptor method instead. Where this occurs in '
+ 'the\n'
+ 'precedence chain depends on which descriptor methods were '
+ 'defined and\n'
+ 'how they were called. Note that descriptors are only '
+ 'invoked for new\n'
+ 'style objects or classes (ones that subclass "object()" or '
+ '"type()").\n'
+ '\n'
+ 'The starting point for descriptor invocation is a binding, '
+ '"a.x". How\n'
+ 'the arguments are assembled depends on "a":\n'
+ '\n'
+ 'Direct Call\n'
+ ' The simplest and least common call is when user code '
+ 'directly\n'
+ ' invokes a descriptor method: "x.__get__(a)".\n'
+ '\n'
+ 'Instance Binding\n'
+ ' If binding to a new-style object instance, "a.x" is '
+ 'transformed\n'
+ ' into the call: "type(a).__dict__[\'x\'].__get__(a, '
+ 'type(a))".\n'
+ '\n'
+ 'Class Binding\n'
+ ' If binding to a new-style class, "A.x" is transformed '
+ 'into the\n'
+ ' call: "A.__dict__[\'x\'].__get__(None, A)".\n'
+ '\n'
+ 'Super Binding\n'
+ ' If "a" is an instance of "super", then the binding '
+ '"super(B,\n'
+ ' obj).m()" searches "obj.__class__.__mro__" for the base '
+ 'class "A"\n'
+ ' immediately preceding "B" and then invokes the descriptor '
+ 'with the\n'
+ ' call: "A.__dict__[\'m\'].__get__(obj, obj.__class__)".\n'
+ '\n'
+ 'For instance bindings, the precedence of descriptor '
+ 'invocation depends\n'
+ 'on the which descriptor methods are defined. A descriptor '
+ 'can define\n'
+ 'any combination of "__get__()", "__set__()" and '
+ '"__delete__()". If it\n'
+ 'does not define "__get__()", then accessing the attribute '
+ 'will return\n'
+ 'the descriptor object itself unless there is a value in the '
+ "object's\n"
+ 'instance dictionary. If the descriptor defines "__set__()" '
+ 'and/or\n'
+ '"__delete__()", it is a data descriptor; if it defines '
+ 'neither, it is\n'
+ 'a non-data descriptor. Normally, data descriptors define '
+ 'both\n'
+ '"__get__()" and "__set__()", while non-data descriptors have '
+ 'just the\n'
+ '"__get__()" method. Data descriptors with "__set__()" and '
+ '"__get__()"\n'
+ 'defined always override a redefinition in an instance '
+ 'dictionary. In\n'
+ 'contrast, non-data descriptors can be overridden by '
+ 'instances.\n'
+ '\n'
+ 'Python methods (including "staticmethod()" and '
+ '"classmethod()") are\n'
+ 'implemented as non-data descriptors. Accordingly, instances '
+ 'can\n'
+ 'redefine and override methods. This allows individual '
+ 'instances to\n'
+ 'acquire behaviors that differ from other instances of the '
+ 'same class.\n'
+ '\n'
+ 'The "property()" function is implemented as a data '
+ 'descriptor.\n'
+ 'Accordingly, instances cannot override the behavior of a '
+ 'property.\n'
+ '\n'
+ '\n'
+ '__slots__\n'
+ '---------\n'
+ '\n'
+ 'By default, instances of both old and new-style classes have '
+ 'a\n'
+ 'dictionary for attribute storage. This wastes space for '
+ 'objects\n'
+ 'having very few instance variables. The space consumption '
+ 'can become\n'
+ 'acute when creating large numbers of instances.\n'
+ '\n'
+ 'The default can be overridden by defining *__slots__* in a '
+ 'new-style\n'
+ 'class definition. The *__slots__* declaration takes a '
+ 'sequence of\n'
+ 'instance variables and reserves just enough space in each '
+ 'instance to\n'
+ 'hold a value for each variable. Space is saved because '
+ '*__dict__* is\n'
+ 'not created for each instance.\n'
+ '\n'
+ '__slots__\n'
+ '\n'
+ ' This class variable can be assigned a string, iterable, '
+ 'or sequence\n'
+ ' of strings with variable names used by instances. If '
+ 'defined in a\n'
+ ' new-style class, *__slots__* reserves space for the '
+ 'declared\n'
+ ' variables and prevents the automatic creation of '
+ '*__dict__* and\n'
+ ' *__weakref__* for each instance.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ 'Notes on using *__slots__*\n'
+ '\n'
+ '* When inheriting from a class without *__slots__*, the '
+ '*__dict__*\n'
+ ' attribute of that class will always be accessible, so a '
+ '*__slots__*\n'
+ ' definition in the subclass is meaningless.\n'
+ '\n'
+ '* Without a *__dict__* variable, instances cannot be '
+ 'assigned new\n'
+ ' variables not listed in the *__slots__* definition. '
+ 'Attempts to\n'
+ ' assign to an unlisted variable name raises '
+ '"AttributeError". If\n'
+ ' dynamic assignment of new variables is desired, then add\n'
+ ' "\'__dict__\'" to the sequence of strings in the '
+ '*__slots__*\n'
+ ' declaration.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, adding "\'__dict__\'" '
+ 'to the\n'
+ ' *__slots__* declaration would not enable the assignment of '
+ 'new\n'
+ ' attributes not specifically listed in the sequence of '
+ 'instance\n'
+ ' variable names.\n'
+ '\n'
+ '* Without a *__weakref__* variable for each instance, '
+ 'classes\n'
+ ' defining *__slots__* do not support weak references to '
+ 'its\n'
+ ' instances. If weak reference support is needed, then add\n'
+ ' "\'__weakref__\'" to the sequence of strings in the '
+ '*__slots__*\n'
+ ' declaration.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, adding '
+ '"\'__weakref__\'" to the\n'
+ ' *__slots__* declaration would not enable support for weak\n'
+ ' references.\n'
+ '\n'
+ '* *__slots__* are implemented at the class level by '
+ 'creating\n'
+ ' descriptors (Implementing Descriptors) for each variable '
+ 'name. As a\n'
+ ' result, class attributes cannot be used to set default '
+ 'values for\n'
+ ' instance variables defined by *__slots__*; otherwise, the '
+ 'class\n'
+ ' attribute would overwrite the descriptor assignment.\n'
+ '\n'
+ '* The action of a *__slots__* declaration is limited to the '
+ 'class\n'
+ ' where it is defined. As a result, subclasses will have a '
+ '*__dict__*\n'
+ ' unless they also define *__slots__* (which must only '
+ 'contain names\n'
+ ' of any *additional* slots).\n'
+ '\n'
+ '* If a class defines a slot also defined in a base class, '
+ 'the\n'
+ ' instance variable defined by the base class slot is '
+ 'inaccessible\n'
+ ' (except by retrieving its descriptor directly from the '
+ 'base class).\n'
+ ' This renders the meaning of the program undefined. In the '
+ 'future, a\n'
+ ' check may be added to prevent this.\n'
+ '\n'
+ '* Nonempty *__slots__* does not work for classes derived '
+ 'from\n'
+ ' "variable-length" built-in types such as "long", "str" and '
+ '"tuple".\n'
+ '\n'
+ '* Any non-string iterable may be assigned to *__slots__*. '
+ 'Mappings\n'
+ ' may also be used; however, in the future, special meaning '
+ 'may be\n'
+ ' assigned to the values corresponding to each key.\n'
+ '\n'
+ '* *__class__* assignment works only if both classes have the '
+ 'same\n'
+ ' *__slots__*.\n'
+ '\n'
+ ' Changed in version 2.6: Previously, *__class__* assignment '
+ 'raised an\n'
+ ' error if either new or old class had *__slots__*.\n'
+ '\n'
+ '\n'
+ 'Customizing class creation\n'
+ '==========================\n'
+ '\n'
+ 'By default, new-style classes are constructed using '
+ '"type()". A class\n'
+ 'definition is read into a separate namespace and the value '
+ 'of class\n'
+ 'name is bound to the result of "type(name, bases, dict)".\n'
+ '\n'
+ 'When the class definition is read, if *__metaclass__* is '
+ 'defined then\n'
+ 'the callable assigned to it will be called instead of '
+ '"type()". This\n'
+ 'allows classes or functions to be written which monitor or '
+ 'alter the\n'
+ 'class creation process:\n'
+ '\n'
+ '* Modifying the class dictionary prior to the class being '
+ 'created.\n'
+ '\n'
+ '* Returning an instance of another class -- essentially '
+ 'performing\n'
+ ' the role of a factory function.\n'
+ '\n'
+ "These steps will have to be performed in the metaclass's "
+ '"__new__()"\n'
+ 'method -- "type.__new__()" can then be called from this '
+ 'method to\n'
+ 'create a class with different properties. This example adds '
+ 'a new\n'
+ 'element to the class dictionary before creating the class:\n'
+ '\n'
+ ' class metacls(type):\n'
+ ' def __new__(mcs, name, bases, dict):\n'
+ " dict['foo'] = 'metacls was here'\n"
+ ' return type.__new__(mcs, name, bases, dict)\n'
+ '\n'
+ 'You can of course also override other class methods (or add '
+ 'new\n'
+ 'methods); for example defining a custom "__call__()" method '
+ 'in the\n'
+ 'metaclass allows custom behavior when the class is called, '
+ 'e.g. not\n'
+ 'always creating a new instance.\n'
+ '\n'
+ '__metaclass__\n'
+ '\n'
+ ' This variable can be any callable accepting arguments for '
+ '"name",\n'
+ ' "bases", and "dict". Upon class creation, the callable '
+ 'is used\n'
+ ' instead of the built-in "type()".\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ 'The appropriate metaclass is determined by the following '
+ 'precedence\n'
+ 'rules:\n'
+ '\n'
+ '* If "dict[\'__metaclass__\']" exists, it is used.\n'
+ '\n'
+ '* Otherwise, if there is at least one base class, its '
+ 'metaclass is\n'
+ ' used (this looks for a *__class__* attribute first and if '
+ 'not found,\n'
+ ' uses its type).\n'
+ '\n'
+ '* Otherwise, if a global variable named __metaclass__ '
+ 'exists, it is\n'
+ ' used.\n'
+ '\n'
+ '* Otherwise, the old-style, classic metaclass '
+ '(types.ClassType) is\n'
+ ' used.\n'
+ '\n'
+ 'The potential uses for metaclasses are boundless. Some ideas '
+ 'that have\n'
+ 'been explored including logging, interface checking, '
+ 'automatic\n'
+ 'delegation, automatic property creation, proxies, '
+ 'frameworks, and\n'
+ 'automatic resource locking/synchronization.\n'
+ '\n'
+ '\n'
+ 'Customizing instance and subclass checks\n'
+ '========================================\n'
+ '\n'
+ 'New in version 2.6.\n'
+ '\n'
+ 'The following methods are used to override the default '
+ 'behavior of the\n'
+ '"isinstance()" and "issubclass()" built-in functions.\n'
+ '\n'
+ 'In particular, the metaclass "abc.ABCMeta" implements these '
+ 'methods in\n'
+ 'order to allow the addition of Abstract Base Classes (ABCs) '
+ 'as\n'
+ '"virtual base classes" to any class or type (including '
+ 'built-in\n'
+ 'types), including other ABCs.\n'
+ '\n'
+ 'class.__instancecheck__(self, instance)\n'
+ '\n'
+ ' Return true if *instance* should be considered a (direct '
+ 'or\n'
+ ' indirect) instance of *class*. If defined, called to '
+ 'implement\n'
+ ' "isinstance(instance, class)".\n'
+ '\n'
+ 'class.__subclasscheck__(self, subclass)\n'
+ '\n'
+ ' Return true if *subclass* should be considered a (direct '
+ 'or\n'
+ ' indirect) subclass of *class*. If defined, called to '
+ 'implement\n'
+ ' "issubclass(subclass, class)".\n'
+ '\n'
+ 'Note that these methods are looked up on the type '
+ '(metaclass) of a\n'
+ 'class. They cannot be defined as class methods in the '
+ 'actual class.\n'
+ 'This is consistent with the lookup of special methods that '
+ 'are called\n'
+ 'on instances, only in this case the instance is itself a '
+ 'class.\n'
+ '\n'
+ 'See also:\n'
+ '\n'
+ ' **PEP 3119** - Introducing Abstract Base Classes\n'
+ ' Includes the specification for customizing '
+ '"isinstance()" and\n'
+ ' "issubclass()" behavior through "__instancecheck__()" '
+ 'and\n'
+ ' "__subclasscheck__()", with motivation for this '
+ 'functionality in\n'
+ ' the context of adding Abstract Base Classes (see the '
+ '"abc"\n'
+ ' module) to the language.\n'
+ '\n'
+ '\n'
+ 'Emulating callable objects\n'
+ '==========================\n'
+ '\n'
+ 'object.__call__(self[, args...])\n'
+ '\n'
+ ' Called when the instance is "called" as a function; if '
+ 'this method\n'
+ ' is defined, "x(arg1, arg2, ...)" is a shorthand for\n'
+ ' "x.__call__(arg1, arg2, ...)".\n'
+ '\n'
+ '\n'
+ 'Emulating container types\n'
+ '=========================\n'
+ '\n'
+ 'The following methods can be defined to implement container '
+ 'objects.\n'
+ 'Containers usually are sequences (such as lists or tuples) '
+ 'or mappings\n'
+ '(like dictionaries), but can represent other containers as '
+ 'well. The\n'
+ 'first set of methods is used either to emulate a sequence or '
+ 'to\n'
+ 'emulate a mapping; the difference is that for a sequence, '
+ 'the\n'
+ 'allowable keys should be the integers *k* for which "0 <= k '
+ '< N" where\n'
+ '*N* is the length of the sequence, or slice objects, which '
+ 'define a\n'
+ 'range of items. (For backwards compatibility, the method\n'
+ '"__getslice__()" (see below) can also be defined to handle '
+ 'simple, but\n'
+ 'not extended slices.) It is also recommended that mappings '
+ 'provide the\n'
+ 'methods "keys()", "values()", "items()", "has_key()", '
+ '"get()",\n'
+ '"clear()", "setdefault()", "iterkeys()", "itervalues()",\n'
+ '"iteritems()", "pop()", "popitem()", "copy()", and '
+ '"update()" behaving\n'
+ "similar to those for Python's standard dictionary objects. "
+ 'The\n'
+ '"UserDict" module provides a "DictMixin" class to help '
+ 'create those\n'
+ 'methods from a base set of "__getitem__()", '
+ '"__setitem__()",\n'
+ '"__delitem__()", and "keys()". Mutable sequences should '
+ 'provide\n'
+ 'methods "append()", "count()", "index()", "extend()", '
+ '"insert()",\n'
+ '"pop()", "remove()", "reverse()" and "sort()", like Python '
+ 'standard\n'
+ 'list objects. Finally, sequence types should implement '
+ 'addition\n'
+ '(meaning concatenation) and multiplication (meaning '
+ 'repetition) by\n'
+ 'defining the methods "__add__()", "__radd__()", '
+ '"__iadd__()",\n'
+ '"__mul__()", "__rmul__()" and "__imul__()" described below; '
+ 'they\n'
+ 'should not define "__coerce__()" or other numerical '
+ 'operators. It is\n'
+ 'recommended that both mappings and sequences implement the\n'
+ '"__contains__()" method to allow efficient use of the "in" '
+ 'operator;\n'
+ 'for mappings, "in" should be equivalent of "has_key()"; for '
+ 'sequences,\n'
+ 'it should search through the values. It is further '
+ 'recommended that\n'
+ 'both mappings and sequences implement the "__iter__()" '
+ 'method to allow\n'
+ 'efficient iteration through the container; for mappings, '
+ '"__iter__()"\n'
+ 'should be the same as "iterkeys()"; for sequences, it should '
+ 'iterate\n'
+ 'through the values.\n'
+ '\n'
+ 'object.__len__(self)\n'
+ '\n'
+ ' Called to implement the built-in function "len()". '
+ 'Should return\n'
+ ' the length of the object, an integer ">=" 0. Also, an '
+ 'object that\n'
+ ' doesn\'t define a "__nonzero__()" method and whose '
+ '"__len__()"\n'
+ ' method returns zero is considered to be false in a '
+ 'Boolean context.\n'
+ '\n'
+ ' **CPython implementation detail:** In CPython, the length '
+ 'is\n'
+ ' required to be at most "sys.maxsize". If the length is '
+ 'larger than\n'
+ ' "sys.maxsize" some features (such as "len()") may raise\n'
+ ' "OverflowError". To prevent raising "OverflowError" by '
+ 'truth value\n'
+ ' testing, an object must define a "__nonzero__()" method.\n'
+ '\n'
+ 'object.__getitem__(self, key)\n'
+ '\n'
+ ' Called to implement evaluation of "self[key]". For '
+ 'sequence types,\n'
+ ' the accepted keys should be integers and slice objects. '
+ 'Note that\n'
+ ' the special interpretation of negative indexes (if the '
+ 'class wishes\n'
+ ' to emulate a sequence type) is up to the "__getitem__()" '
+ 'method. If\n'
+ ' *key* is of an inappropriate type, "TypeError" may be '
+ 'raised; if of\n'
+ ' a value outside the set of indexes for the sequence '
+ '(after any\n'
+ ' special interpretation of negative values), "IndexError" '
+ 'should be\n'
+ ' raised. For mapping types, if *key* is missing (not in '
+ 'the\n'
+ ' container), "KeyError" should be raised.\n'
+ '\n'
+ ' Note: "for" loops expect that an "IndexError" will be '
+ 'raised for\n'
+ ' illegal indexes to allow proper detection of the end of '
+ 'the\n'
+ ' sequence.\n'
+ '\n'
+ 'object.__missing__(self, key)\n'
+ '\n'
+ ' Called by "dict"."__getitem__()" to implement "self[key]" '
+ 'for dict\n'
+ ' subclasses when key is not in the dictionary.\n'
+ '\n'
+ 'object.__setitem__(self, key, value)\n'
+ '\n'
+ ' Called to implement assignment to "self[key]". Same note '
+ 'as for\n'
+ ' "__getitem__()". This should only be implemented for '
+ 'mappings if\n'
+ ' the objects support changes to the values for keys, or if '
+ 'new keys\n'
+ ' can be added, or for sequences if elements can be '
+ 'replaced. The\n'
+ ' same exceptions should be raised for improper *key* '
+ 'values as for\n'
+ ' the "__getitem__()" method.\n'
+ '\n'
+ 'object.__delitem__(self, key)\n'
+ '\n'
+ ' Called to implement deletion of "self[key]". Same note '
+ 'as for\n'
+ ' "__getitem__()". This should only be implemented for '
+ 'mappings if\n'
+ ' the objects support removal of keys, or for sequences if '
+ 'elements\n'
+ ' can be removed from the sequence. The same exceptions '
+ 'should be\n'
+ ' raised for improper *key* values as for the '
+ '"__getitem__()" method.\n'
+ '\n'
+ 'object.__iter__(self)\n'
+ '\n'
+ ' This method is called when an iterator is required for a '
+ 'container.\n'
+ ' This method should return a new iterator object that can '
+ 'iterate\n'
+ ' over all the objects in the container. For mappings, it '
+ 'should\n'
+ ' iterate over the keys of the container, and should also '
+ 'be made\n'
+ ' available as the method "iterkeys()".\n'
+ '\n'
+ ' Iterator objects also need to implement this method; they '
+ 'are\n'
+ ' required to return themselves. For more information on '
+ 'iterator\n'
+ ' objects, see Iterator Types.\n'
+ '\n'
+ 'object.__reversed__(self)\n'
+ '\n'
+ ' Called (if present) by the "reversed()" built-in to '
+ 'implement\n'
+ ' reverse iteration. It should return a new iterator '
+ 'object that\n'
+ ' iterates over all the objects in the container in reverse '
+ 'order.\n'
+ '\n'
+ ' If the "__reversed__()" method is not provided, the '
+ '"reversed()"\n'
+ ' built-in will fall back to using the sequence protocol '
+ '("__len__()"\n'
+ ' and "__getitem__()"). Objects that support the sequence '
+ 'protocol\n'
+ ' should only provide "__reversed__()" if they can provide '
+ 'an\n'
+ ' implementation that is more efficient than the one '
+ 'provided by\n'
+ ' "reversed()".\n'
+ '\n'
+ ' New in version 2.6.\n'
+ '\n'
+ 'The membership test operators ("in" and "not in") are '
+ 'normally\n'
+ 'implemented as an iteration through a sequence. However, '
+ 'container\n'
+ 'objects can supply the following special method with a more '
+ 'efficient\n'
+ 'implementation, which also does not require the object be a '
+ 'sequence.\n'
+ '\n'
+ 'object.__contains__(self, item)\n'
+ '\n'
+ ' Called to implement membership test operators. Should '
+ 'return true\n'
+ ' if *item* is in *self*, false otherwise. For mapping '
+ 'objects, this\n'
+ ' should consider the keys of the mapping rather than the '
+ 'values or\n'
+ ' the key-item pairs.\n'
+ '\n'
+ ' For objects that don\'t define "__contains__()", the '
+ 'membership test\n'
+ ' first tries iteration via "__iter__()", then the old '
+ 'sequence\n'
+ ' iteration protocol via "__getitem__()", see this section '
+ 'in the\n'
+ ' language reference.\n'
+ '\n'
+ '\n'
+ 'Additional methods for emulation of sequence types\n'
+ '==================================================\n'
+ '\n'
+ 'The following optional methods can be defined to further '
+ 'emulate\n'
+ 'sequence objects. Immutable sequences methods should at '
+ 'most only\n'
+ 'define "__getslice__()"; mutable sequences might define all '
+ 'three\n'
+ 'methods.\n'
+ '\n'
+ 'object.__getslice__(self, i, j)\n'
+ '\n'
+ ' Deprecated since version 2.0: Support slice objects as '
+ 'parameters\n'
+ ' to the "__getitem__()" method. (However, built-in types '
+ 'in CPython\n'
+ ' currently still implement "__getslice__()". Therefore, '
+ 'you have to\n'
+ ' override it in derived classes when implementing '
+ 'slicing.)\n'
+ '\n'
+ ' Called to implement evaluation of "self[i:j]". The '
+ 'returned object\n'
+ ' should be of the same type as *self*. Note that missing '
+ '*i* or *j*\n'
+ ' in the slice expression are replaced by zero or '
+ '"sys.maxsize",\n'
+ ' respectively. If negative indexes are used in the slice, '
+ 'the\n'
+ ' length of the sequence is added to that index. If the '
+ 'instance does\n'
+ ' not implement the "__len__()" method, an "AttributeError" '
+ 'is\n'
+ ' raised. No guarantee is made that indexes adjusted this '
+ 'way are not\n'
+ ' still negative. Indexes which are greater than the '
+ 'length of the\n'
+ ' sequence are not modified. If no "__getslice__()" is '
+ 'found, a slice\n'
+ ' object is created instead, and passed to "__getitem__()" '
+ 'instead.\n'
+ '\n'
+ 'object.__setslice__(self, i, j, sequence)\n'
+ '\n'
+ ' Called to implement assignment to "self[i:j]". Same notes '
+ 'for *i*\n'
+ ' and *j* as for "__getslice__()".\n'
+ '\n'
+ ' This method is deprecated. If no "__setslice__()" is '
+ 'found, or for\n'
+ ' extended slicing of the form "self[i:j:k]", a slice '
+ 'object is\n'
+ ' created, and passed to "__setitem__()", instead of '
+ '"__setslice__()"\n'
+ ' being called.\n'
+ '\n'
+ 'object.__delslice__(self, i, j)\n'
+ '\n'
+ ' Called to implement deletion of "self[i:j]". Same notes '
+ 'for *i* and\n'
+ ' *j* as for "__getslice__()". This method is deprecated. '
+ 'If no\n'
+ ' "__delslice__()" is found, or for extended slicing of the '
+ 'form\n'
+ ' "self[i:j:k]", a slice object is created, and passed to\n'
+ ' "__delitem__()", instead of "__delslice__()" being '
+ 'called.\n'
+ '\n'
+ 'Notice that these methods are only invoked when a single '
+ 'slice with a\n'
+ 'single colon is used, and the slice method is available. '
+ 'For slice\n'
+ 'operations involving extended slice notation, or in absence '
+ 'of the\n'
+ 'slice methods, "__getitem__()", "__setitem__()" or '
+ '"__delitem__()" is\n'
+ 'called with a slice object as argument.\n'
+ '\n'
+ 'The following example demonstrate how to make your program '
+ 'or module\n'
+ 'compatible with earlier versions of Python (assuming that '
+ 'methods\n'
+ '"__getitem__()", "__setitem__()" and "__delitem__()" support '
+ 'slice\n'
+ 'objects as arguments):\n'
+ '\n'
+ ' class MyClass:\n'
+ ' ...\n'
+ ' def __getitem__(self, index):\n'
+ ' ...\n'
+ ' def __setitem__(self, index, value):\n'
+ ' ...\n'
+ ' def __delitem__(self, index):\n'
+ ' ...\n'
+ '\n'
+ ' if sys.version_info < (2, 0):\n'
+ " # They won't be defined if version is at least "
+ '2.0 final\n'
+ '\n'
+ ' def __getslice__(self, i, j):\n'
+ ' return self[max(0, i):max(0, j):]\n'
+ ' def __setslice__(self, i, j, seq):\n'
+ ' self[max(0, i):max(0, j):] = seq\n'
+ ' def __delslice__(self, i, j):\n'
+ ' del self[max(0, i):max(0, j):]\n'
+ ' ...\n'
+ '\n'
+ 'Note the calls to "max()"; these are necessary because of '
+ 'the handling\n'
+ 'of negative indices before the "__*slice__()" methods are '
+ 'called.\n'
+ 'When negative indexes are used, the "__*item__()" methods '
+ 'receive them\n'
+ 'as provided, but the "__*slice__()" methods get a "cooked" '
+ 'form of the\n'
+ 'index values. For each negative index value, the length of '
+ 'the\n'
+ 'sequence is added to the index before calling the method '
+ '(which may\n'
+ 'still result in a negative index); this is the customary '
+ 'handling of\n'
+ 'negative indexes by the built-in sequence types, and the '
+ '"__*item__()"\n'
+ 'methods are expected to do this as well. However, since '
+ 'they should\n'
+ 'already be doing that, negative indexes cannot be passed in; '
+ 'they must\n'
+ 'be constrained to the bounds of the sequence before being '
+ 'passed to\n'
+ 'the "__*item__()" methods. Calling "max(0, i)" conveniently '
+ 'returns\n'
+ 'the proper value.\n'
+ '\n'
+ '\n'
+ 'Emulating numeric types\n'
+ '=======================\n'
+ '\n'
+ 'The following methods can be defined to emulate numeric '
+ 'objects.\n'
+ 'Methods corresponding to operations that are not supported '
+ 'by the\n'
+ 'particular kind of number implemented (e.g., bitwise '
+ 'operations for\n'
+ 'non-integral numbers) should be left undefined.\n'
+ '\n'
+ 'object.__add__(self, other)\n'
+ 'object.__sub__(self, other)\n'
+ 'object.__mul__(self, other)\n'
+ 'object.__floordiv__(self, other)\n'
+ 'object.__mod__(self, other)\n'
+ 'object.__divmod__(self, other)\n'
+ 'object.__pow__(self, other[, modulo])\n'
+ 'object.__lshift__(self, other)\n'
+ 'object.__rshift__(self, other)\n'
+ 'object.__and__(self, other)\n'
+ 'object.__xor__(self, other)\n'
+ 'object.__or__(self, other)\n'
+ '\n'
+ ' These methods are called to implement the binary '
+ 'arithmetic\n'
+ ' operations ("+", "-", "*", "//", "%", "divmod()", '
+ '"pow()", "**",\n'
+ ' "<<", ">>", "&", "^", "|"). For instance, to evaluate '
+ 'the\n'
+ ' expression "x + y", where *x* is an instance of a class '
+ 'that has an\n'
+ ' "__add__()" method, "x.__add__(y)" is called. The '
+ '"__divmod__()"\n'
+ ' method should be the equivalent to using "__floordiv__()" '
+ 'and\n'
+ ' "__mod__()"; it should not be related to "__truediv__()" '
+ '(described\n'
+ ' below). Note that "__pow__()" should be defined to '
+ 'accept an\n'
+ ' optional third argument if the ternary version of the '
+ 'built-in\n'
+ ' "pow()" function is to be supported.\n'
+ '\n'
+ ' If one of those methods does not support the operation '
+ 'with the\n'
+ ' supplied arguments, it should return "NotImplemented".\n'
+ '\n'
+ 'object.__div__(self, other)\n'
+ 'object.__truediv__(self, other)\n'
+ '\n'
+ ' The division operator ("/") is implemented by these '
+ 'methods. The\n'
+ ' "__truediv__()" method is used when "__future__.division" '
+ 'is in\n'
+ ' effect, otherwise "__div__()" is used. If only one of '
+ 'these two\n'
+ ' methods is defined, the object will not support division '
+ 'in the\n'
+ ' alternate context; "TypeError" will be raised instead.\n'
+ '\n'
+ 'object.__radd__(self, other)\n'
+ 'object.__rsub__(self, other)\n'
+ 'object.__rmul__(self, other)\n'
+ 'object.__rdiv__(self, other)\n'
+ 'object.__rtruediv__(self, other)\n'
+ 'object.__rfloordiv__(self, other)\n'
+ 'object.__rmod__(self, other)\n'
+ 'object.__rdivmod__(self, other)\n'
+ 'object.__rpow__(self, other)\n'
+ 'object.__rlshift__(self, other)\n'
+ 'object.__rrshift__(self, other)\n'
+ 'object.__rand__(self, other)\n'
+ 'object.__rxor__(self, other)\n'
+ 'object.__ror__(self, other)\n'
+ '\n'
+ ' These methods are called to implement the binary '
+ 'arithmetic\n'
+ ' operations ("+", "-", "*", "/", "%", "divmod()", "pow()", '
+ '"**",\n'
+ ' "<<", ">>", "&", "^", "|") with reflected (swapped) '
+ 'operands.\n'
+ ' These functions are only called if the left operand does '
+ 'not\n'
+ ' support the corresponding operation and the operands are '
+ 'of\n'
+ ' different types. [2] For instance, to evaluate the '
+ 'expression "x -\n'
+ ' y", where *y* is an instance of a class that has an '
+ '"__rsub__()"\n'
+ ' method, "y.__rsub__(x)" is called if "x.__sub__(y)" '
+ 'returns\n'
+ ' *NotImplemented*.\n'
+ '\n'
+ ' Note that ternary "pow()" will not try calling '
+ '"__rpow__()" (the\n'
+ ' coercion rules would become too complicated).\n'
+ '\n'
+ " Note: If the right operand's type is a subclass of the "
+ 'left\n'
+ " operand's type and that subclass provides the reflected "
+ 'method\n'
+ ' for the operation, this method will be called before '
+ 'the left\n'
+ " operand's non-reflected method. This behavior allows "
+ 'subclasses\n'
+ " to override their ancestors' operations.\n"
+ '\n'
+ 'object.__iadd__(self, other)\n'
+ 'object.__isub__(self, other)\n'
+ 'object.__imul__(self, other)\n'
+ 'object.__idiv__(self, other)\n'
+ 'object.__itruediv__(self, other)\n'
+ 'object.__ifloordiv__(self, other)\n'
+ 'object.__imod__(self, other)\n'
+ 'object.__ipow__(self, other[, modulo])\n'
+ 'object.__ilshift__(self, other)\n'
+ 'object.__irshift__(self, other)\n'
+ 'object.__iand__(self, other)\n'
+ 'object.__ixor__(self, other)\n'
+ 'object.__ior__(self, other)\n'
+ '\n'
+ ' These methods are called to implement the augmented '
+ 'arithmetic\n'
+ ' assignments ("+=", "-=", "*=", "/=", "//=", "%=", "**=", '
+ '"<<=",\n'
+ ' ">>=", "&=", "^=", "|="). These methods should attempt '
+ 'to do the\n'
+ ' operation in-place (modifying *self*) and return the '
+ 'result (which\n'
+ ' could be, but does not have to be, *self*). If a '
+ 'specific method\n'
+ ' is not defined, the augmented assignment falls back to '
+ 'the normal\n'
+ ' methods. For instance, to execute the statement "x += '
+ 'y", where\n'
+ ' *x* is an instance of a class that has an "__iadd__()" '
+ 'method,\n'
+ ' "x.__iadd__(y)" is called. If *x* is an instance of a '
+ 'class that\n'
+ ' does not define a "__iadd__()" method, "x.__add__(y)" '
+ 'and\n'
+ ' "y.__radd__(x)" are considered, as with the evaluation of '
+ '"x + y".\n'
+ '\n'
+ 'object.__neg__(self)\n'
+ 'object.__pos__(self)\n'
+ 'object.__abs__(self)\n'
+ 'object.__invert__(self)\n'
+ '\n'
+ ' Called to implement the unary arithmetic operations ("-", '
+ '"+",\n'
+ ' "abs()" and "~").\n'
+ '\n'
+ 'object.__complex__(self)\n'
+ 'object.__int__(self)\n'
+ 'object.__long__(self)\n'
+ 'object.__float__(self)\n'
+ '\n'
+ ' Called to implement the built-in functions "complex()", '
+ '"int()",\n'
+ ' "long()", and "float()". Should return a value of the '
+ 'appropriate\n'
+ ' type.\n'
+ '\n'
+ 'object.__oct__(self)\n'
+ 'object.__hex__(self)\n'
+ '\n'
+ ' Called to implement the built-in functions "oct()" and '
+ '"hex()".\n'
+ ' Should return a string value.\n'
+ '\n'
+ 'object.__index__(self)\n'
+ '\n'
+ ' Called to implement "operator.index()". Also called '
+ 'whenever\n'
+ ' Python needs an integer object (such as in slicing). '
+ 'Must return\n'
+ ' an integer (int or long).\n'
+ '\n'
+ ' New in version 2.5.\n'
+ '\n'
+ 'object.__coerce__(self, other)\n'
+ '\n'
+ ' Called to implement "mixed-mode" numeric arithmetic. '
+ 'Should either\n'
+ ' return a 2-tuple containing *self* and *other* converted '
+ 'to a\n'
+ ' common numeric type, or "None" if conversion is '
+ 'impossible. When\n'
+ ' the common type would be the type of "other", it is '
+ 'sufficient to\n'
+ ' return "None", since the interpreter will also ask the '
+ 'other object\n'
+ ' to attempt a coercion (but sometimes, if the '
+ 'implementation of the\n'
+ ' other type cannot be changed, it is useful to do the '
+ 'conversion to\n'
+ ' the other type here). A return value of "NotImplemented" '
+ 'is\n'
+ ' equivalent to returning "None".\n'
+ '\n'
+ '\n'
+ 'Coercion rules\n'
+ '==============\n'
+ '\n'
+ 'This section used to document the rules for coercion. As '
+ 'the language\n'
+ 'has evolved, the coercion rules have become hard to '
+ 'document\n'
+ 'precisely; documenting what one version of one particular\n'
+ 'implementation does is undesirable. Instead, here are some '
+ 'informal\n'
+ 'guidelines regarding coercion. In Python 3, coercion will '
+ 'not be\n'
+ 'supported.\n'
+ '\n'
+ '* If the left operand of a % operator is a string or Unicode '
+ 'object,\n'
+ ' no coercion takes place and the string formatting '
+ 'operation is\n'
+ ' invoked instead.\n'
+ '\n'
+ '* It is no longer recommended to define a coercion '
+ 'operation. Mixed-\n'
+ " mode operations on types that don't define coercion pass "
+ 'the\n'
+ ' original arguments to the operation.\n'
+ '\n'
+ '* New-style classes (those derived from "object") never '
+ 'invoke the\n'
+ ' "__coerce__()" method in response to a binary operator; '
+ 'the only\n'
+ ' time "__coerce__()" is invoked is when the built-in '
+ 'function\n'
+ ' "coerce()" is called.\n'
+ '\n'
+ '* For most intents and purposes, an operator that returns\n'
+ ' "NotImplemented" is treated the same as one that is not '
+ 'implemented\n'
+ ' at all.\n'
+ '\n'
+ '* Below, "__op__()" and "__rop__()" are used to signify the '
+ 'generic\n'
+ ' method names corresponding to an operator; "__iop__()" is '
+ 'used for\n'
+ ' the corresponding in-place operator. For example, for the '
+ 'operator\n'
+ ' \'"+"\', "__add__()" and "__radd__()" are used for the '
+ 'left and right\n'
+ ' variant of the binary operator, and "__iadd__()" for the '
+ 'in-place\n'
+ ' variant.\n'
+ '\n'
+ '* For objects *x* and *y*, first "x.__op__(y)" is tried. If '
+ 'this is\n'
+ ' not implemented or returns "NotImplemented", '
+ '"y.__rop__(x)" is\n'
+ ' tried. If this is also not implemented or returns '
+ '"NotImplemented",\n'
+ ' a "TypeError" exception is raised. But see the following '
+ 'exception:\n'
+ '\n'
+ '* Exception to the previous item: if the left operand is an '
+ 'instance\n'
+ ' of a built-in type or a new-style class, and the right '
+ 'operand is an\n'
+ ' instance of a proper subclass of that type or class and '
+ 'overrides\n'
+ ' the base\'s "__rop__()" method, the right operand\'s '
+ '"__rop__()"\n'
+ ' method is tried *before* the left operand\'s "__op__()" '
+ 'method.\n'
+ '\n'
+ ' This is done so that a subclass can completely override '
+ 'binary\n'
+ ' operators. Otherwise, the left operand\'s "__op__()" '
+ 'method would\n'
+ ' always accept the right operand: when an instance of a '
+ 'given class\n'
+ ' is expected, an instance of a subclass of that class is '
+ 'always\n'
+ ' acceptable.\n'
+ '\n'
+ '* When either operand type defines a coercion, this coercion '
+ 'is\n'
+ ' called before that type\'s "__op__()" or "__rop__()" '
+ 'method is\n'
+ ' called, but no sooner. If the coercion returns an object '
+ 'of a\n'
+ ' different type for the operand whose coercion is invoked, '
+ 'part of\n'
+ ' the process is redone using the new object.\n'
+ '\n'
+ '* When an in-place operator (like \'"+="\') is used, if the '
+ 'left\n'
+ ' operand implements "__iop__()", it is invoked without any '
+ 'coercion.\n'
+ ' When the operation falls back to "__op__()" and/or '
+ '"__rop__()", the\n'
+ ' normal coercion rules apply.\n'
+ '\n'
+ '* In "x + y", if *x* is a sequence that implements sequence\n'
+ ' concatenation, sequence concatenation is invoked.\n'
+ '\n'
+ '* In "x * y", if one operand is a sequence that implements '
+ 'sequence\n'
+ ' repetition, and the other is an integer ("int" or "long"), '
+ 'sequence\n'
+ ' repetition is invoked.\n'
+ '\n'
+ '* Rich comparisons (implemented by methods "__eq__()" and so '
+ 'on)\n'
+ ' never use coercion. Three-way comparison (implemented by\n'
+ ' "__cmp__()") does use coercion under the same conditions '
+ 'as other\n'
+ ' binary operations use it.\n'
+ '\n'
+ '* In the current implementation, the built-in numeric types '
+ '"int",\n'
+ ' "long", "float", and "complex" do not use coercion. All '
+ 'these types\n'
+ ' implement a "__coerce__()" method, for use by the '
+ 'built-in\n'
+ ' "coerce()" function.\n'
+ '\n'
+ ' Changed in version 2.7: The complex type no longer makes '
+ 'implicit\n'
+ ' calls to the "__coerce__()" method for mixed-type binary '
+ 'arithmetic\n'
+ ' operations.\n'
+ '\n'
+ '\n'
+ 'With Statement Context Managers\n'
+ '===============================\n'
+ '\n'
+ 'New in version 2.5.\n'
+ '\n'
+ 'A *context manager* is an object that defines the runtime '
+ 'context to\n'
+ 'be established when executing a "with" statement. The '
+ 'context manager\n'
+ 'handles the entry into, and the exit from, the desired '
+ 'runtime context\n'
+ 'for the execution of the block of code. Context managers '
+ 'are normally\n'
+ 'invoked using the "with" statement (described in section The '
+ 'with\n'
+ 'statement), but can also be used by directly invoking their '
+ 'methods.\n'
+ '\n'
+ 'Typical uses of context managers include saving and '
+ 'restoring various\n'
+ 'kinds of global state, locking and unlocking resources, '
+ 'closing opened\n'
+ 'files, etc.\n'
+ '\n'
+ 'For more information on context managers, see Context '
+ 'Manager Types.\n'
+ '\n'
+ 'object.__enter__(self)\n'
+ '\n'
+ ' Enter the runtime context related to this object. The '
+ '"with"\n'
+ " statement will bind this method's return value to the "
+ 'target(s)\n'
+ ' specified in the "as" clause of the statement, if any.\n'
+ '\n'
+ 'object.__exit__(self, exc_type, exc_value, traceback)\n'
+ '\n'
+ ' Exit the runtime context related to this object. The '
+ 'parameters\n'
+ ' describe the exception that caused the context to be '
+ 'exited. If the\n'
+ ' context was exited without an exception, all three '
+ 'arguments will\n'
+ ' be "None".\n'
+ '\n'
+ ' If an exception is supplied, and the method wishes to '
+ 'suppress the\n'
+ ' exception (i.e., prevent it from being propagated), it '
+ 'should\n'
+ ' return a true value. Otherwise, the exception will be '
+ 'processed\n'
+ ' normally upon exit from this method.\n'
+ '\n'
+ ' Note that "__exit__()" methods should not reraise the '
+ 'passed-in\n'
+ " exception; this is the caller's responsibility.\n"
+ '\n'
+ 'See also:\n'
+ '\n'
+ ' **PEP 343** - The "with" statement\n'
+ ' The specification, background, and examples for the '
+ 'Python "with"\n'
+ ' statement.\n'
+ '\n'
+ '\n'
+ 'Special method lookup for old-style classes\n'
+ '===========================================\n'
+ '\n'
+ 'For old-style classes, special methods are always looked up '
+ 'in exactly\n'
+ 'the same way as any other method or attribute. This is the '
+ 'case\n'
+ 'regardless of whether the method is being looked up '
+ 'explicitly as in\n'
+ '"x.__getitem__(i)" or implicitly as in "x[i]".\n'
+ '\n'
+ 'This behaviour means that special methods may exhibit '
+ 'different\n'
+ 'behaviour for different instances of a single old-style '
+ 'class if the\n'
+ 'appropriate special attributes are set differently:\n'
+ '\n'
+ ' >>> class C:\n'
+ ' ... pass\n'
+ ' ...\n'
+ ' >>> c1 = C()\n'
+ ' >>> c2 = C()\n'
+ ' >>> c1.__len__ = lambda: 5\n'
+ ' >>> c2.__len__ = lambda: 9\n'
+ ' >>> len(c1)\n'
+ ' 5\n'
+ ' >>> len(c2)\n'
+ ' 9\n'
+ '\n'
+ '\n'
+ 'Special method lookup for new-style classes\n'
+ '===========================================\n'
+ '\n'
+ 'For new-style classes, implicit invocations of special '
+ 'methods are\n'
+ "only guaranteed to work correctly if defined on an object's "
+ 'type, not\n'
+ "in the object's instance dictionary. That behaviour is the "
+ 'reason why\n'
+ 'the following code raises an exception (unlike the '
+ 'equivalent example\n'
+ 'with old-style classes):\n'
+ '\n'
+ ' >>> class C(object):\n'
+ ' ... pass\n'
+ ' ...\n'
+ ' >>> c = C()\n'
+ ' >>> c.__len__ = lambda: 5\n'
+ ' >>> len(c)\n'
+ ' Traceback (most recent call last):\n'
+ ' File "<stdin>", line 1, in <module>\n'
+ " TypeError: object of type 'C' has no len()\n"
+ '\n'
+ 'The rationale behind this behaviour lies with a number of '
+ 'special\n'
+ 'methods such as "__hash__()" and "__repr__()" that are '
+ 'implemented by\n'
+ 'all objects, including type objects. If the implicit lookup '
+ 'of these\n'
+ 'methods used the conventional lookup process, they would '
+ 'fail when\n'
+ 'invoked on the type object itself:\n'
+ '\n'
+ ' >>> 1 .__hash__() == hash(1)\n'
+ ' True\n'
+ ' >>> int.__hash__() == hash(int)\n'
+ ' Traceback (most recent call last):\n'
+ ' File "<stdin>", line 1, in <module>\n'
+ " TypeError: descriptor '__hash__' of 'int' object needs an "
+ 'argument\n'
+ '\n'
+ 'Incorrectly attempting to invoke an unbound method of a '
+ 'class in this\n'
+ "way is sometimes referred to as 'metaclass confusion', and "
+ 'is avoided\n'
+ 'by bypassing the instance when looking up special methods:\n'
+ '\n'
+ ' >>> type(1).__hash__(1) == hash(1)\n'
+ ' True\n'
+ ' >>> type(int).__hash__(int) == hash(int)\n'
+ ' True\n'
+ '\n'
+ 'In addition to bypassing any instance attributes in the '
+ 'interest of\n'
+ 'correctness, implicit special method lookup generally also '
+ 'bypasses\n'
+ 'the "__getattribute__()" method even of the object\'s '
+ 'metaclass:\n'
+ '\n'
+ ' >>> class Meta(type):\n'
+ ' ... def __getattribute__(*args):\n'
+ ' ... print "Metaclass getattribute invoked"\n'
+ ' ... return type.__getattribute__(*args)\n'
+ ' ...\n'
+ ' >>> class C(object):\n'
+ ' ... __metaclass__ = Meta\n'
+ ' ... def __len__(self):\n'
+ ' ... return 10\n'
+ ' ... def __getattribute__(*args):\n'
+ ' ... print "Class getattribute invoked"\n'
+ ' ... return object.__getattribute__(*args)\n'
+ ' ...\n'
+ ' >>> c = C()\n'
+ ' >>> c.__len__() # Explicit lookup via '
+ 'instance\n'
+ ' Class getattribute invoked\n'
+ ' 10\n'
+ ' >>> type(c).__len__(c) # Explicit lookup via '
+ 'type\n'
+ ' Metaclass getattribute invoked\n'
+ ' 10\n'
+ ' >>> len(c) # Implicit lookup\n'
+ ' 10\n'
+ '\n'
+ 'Bypassing the "__getattribute__()" machinery in this fashion '
+ 'provides\n'
+ 'significant scope for speed optimisations within the '
+ 'interpreter, at\n'
+ 'the cost of some flexibility in the handling of special '
+ 'methods (the\n'
+ 'special method *must* be set on the class object itself in '
+ 'order to be\n'
+ 'consistently invoked by the interpreter).\n'
+ '\n'
+ '-[ Footnotes ]-\n'
+ '\n'
+ "[1] It *is* possible in some cases to change an object's "
+ 'type,\n'
+ " under certain controlled conditions. It generally isn't "
+ 'a good\n'
+ ' idea though, since it can lead to some very strange '
+ 'behaviour if\n'
+ ' it is handled incorrectly.\n'
+ '\n'
+ '[2] For operands of the same type, it is assumed that if the '
+ 'non-\n'
+ ' reflected method (such as "__add__()") fails the '
+ 'operation is not\n'
+ ' supported, which is why the reflected method is not '
+ 'called.\n',
+ 'string-methods': '\n'
+ 'String Methods\n'
+ '**************\n'
+ '\n'
+ 'Below are listed the string methods which both 8-bit '
+ 'strings and\n'
+ 'Unicode objects support. Some of them are also available '
+ 'on\n'
+ '"bytearray" objects.\n'
+ '\n'
+ "In addition, Python's strings support the sequence type "
+ 'methods\n'
+ 'described in the Sequence Types --- str, unicode, list, '
+ 'tuple,\n'
+ 'bytearray, buffer, xrange section. To output formatted '
+ 'strings use\n'
+ 'template strings or the "%" operator described in the '
+ 'String\n'
+ 'Formatting Operations section. Also, see the "re" module '
+ 'for string\n'
+ 'functions based on regular expressions.\n'
+ '\n'
+ 'str.capitalize()\n'
+ '\n'
+ ' Return a copy of the string with its first character '
+ 'capitalized\n'
+ ' and the rest lowercased.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.center(width[, fillchar])\n'
+ '\n'
+ ' Return centered in a string of length *width*. Padding '
+ 'is done\n'
+ ' using the specified *fillchar* (default is a space).\n'
+ '\n'
+ ' Changed in version 2.4: Support for the *fillchar* '
+ 'argument.\n'
+ '\n'
+ 'str.count(sub[, start[, end]])\n'
+ '\n'
+ ' Return the number of non-overlapping occurrences of '
+ 'substring *sub*\n'
+ ' in the range [*start*, *end*]. Optional arguments '
+ '*start* and\n'
+ ' *end* are interpreted as in slice notation.\n'
+ '\n'
+ 'str.decode([encoding[, errors]])\n'
+ '\n'
+ ' Decodes the string using the codec registered for '
+ '*encoding*.\n'
+ ' *encoding* defaults to the default string encoding. '
+ '*errors* may\n'
+ ' be given to set a different error handling scheme. The '
+ 'default is\n'
+ ' "\'strict\'", meaning that encoding errors raise '
+ '"UnicodeError".\n'
+ ' Other possible values are "\'ignore\'", "\'replace\'" '
+ 'and any other\n'
+ ' name registered via "codecs.register_error()", see '
+ 'section Codec\n'
+ ' Base Classes.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' Changed in version 2.3: Support for other error '
+ 'handling schemes\n'
+ ' added.\n'
+ '\n'
+ ' Changed in version 2.7: Support for keyword arguments '
+ 'added.\n'
+ '\n'
+ 'str.encode([encoding[, errors]])\n'
+ '\n'
+ ' Return an encoded version of the string. Default '
+ 'encoding is the\n'
+ ' current default string encoding. *errors* may be given '
+ 'to set a\n'
+ ' different error handling scheme. The default for '
+ '*errors* is\n'
+ ' "\'strict\'", meaning that encoding errors raise a '
+ '"UnicodeError".\n'
+ ' Other possible values are "\'ignore\'", "\'replace\'",\n'
+ ' "\'xmlcharrefreplace\'", "\'backslashreplace\'" and any '
+ 'other name\n'
+ ' registered via "codecs.register_error()", see section '
+ 'Codec Base\n'
+ ' Classes. For a list of possible encodings, see section '
+ 'Standard\n'
+ ' Encodings.\n'
+ '\n'
+ ' New in version 2.0.\n'
+ '\n'
+ ' Changed in version 2.3: Support for '
+ '"\'xmlcharrefreplace\'" and\n'
+ ' "\'backslashreplace\'" and other error handling schemes '
+ 'added.\n'
+ '\n'
+ ' Changed in version 2.7: Support for keyword arguments '
+ 'added.\n'
+ '\n'
+ 'str.endswith(suffix[, start[, end]])\n'
+ '\n'
+ ' Return "True" if the string ends with the specified '
+ '*suffix*,\n'
+ ' otherwise return "False". *suffix* can also be a tuple '
+ 'of suffixes\n'
+ ' to look for. With optional *start*, test beginning at '
+ 'that\n'
+ ' position. With optional *end*, stop comparing at that '
+ 'position.\n'
+ '\n'
+ ' Changed in version 2.5: Accept tuples as *suffix*.\n'
+ '\n'
+ 'str.expandtabs([tabsize])\n'
+ '\n'
+ ' Return a copy of the string where all tab characters '
+ 'are replaced\n'
+ ' by one or more spaces, depending on the current column '
+ 'and the\n'
+ ' given tab size. Tab positions occur every *tabsize* '
+ 'characters\n'
+ ' (default is 8, giving tab positions at columns 0, 8, 16 '
+ 'and so on).\n'
+ ' To expand the string, the current column is set to zero '
+ 'and the\n'
+ ' string is examined character by character. If the '
+ 'character is a\n'
+ ' tab ("\\t"), one or more space characters are inserted '
+ 'in the result\n'
+ ' until the current column is equal to the next tab '
+ 'position. (The\n'
+ ' tab character itself is not copied.) If the character '
+ 'is a newline\n'
+ ' ("\\n") or return ("\\r"), it is copied and the current '
+ 'column is\n'
+ ' reset to zero. Any other character is copied unchanged '
+ 'and the\n'
+ ' current column is incremented by one regardless of how '
+ 'the\n'
+ ' character is represented when printed.\n'
+ '\n'
+ " >>> '01\\t012\\t0123\\t01234'.expandtabs()\n"
+ " '01 012 0123 01234'\n"
+ " >>> '01\\t012\\t0123\\t01234'.expandtabs(4)\n"
+ " '01 012 0123 01234'\n"
+ '\n'
+ 'str.find(sub[, start[, end]])\n'
+ '\n'
+ ' Return the lowest index in the string where substring '
+ '*sub* is\n'
+ ' found within the slice "s[start:end]". Optional '
+ 'arguments *start*\n'
+ ' and *end* are interpreted as in slice notation. Return '
+ '"-1" if\n'
+ ' *sub* is not found.\n'
+ '\n'
+ ' Note: The "find()" method should be used only if you '
+ 'need to know\n'
+ ' the position of *sub*. To check if *sub* is a '
+ 'substring or not,\n'
+ ' use the "in" operator:\n'
+ '\n'
+ " >>> 'Py' in 'Python'\n"
+ ' True\n'
+ '\n'
+ 'str.format(*args, **kwargs)\n'
+ '\n'
+ ' Perform a string formatting operation. The string on '
+ 'which this\n'
+ ' method is called can contain literal text or '
+ 'replacement fields\n'
+ ' delimited by braces "{}". Each replacement field '
+ 'contains either\n'
+ ' the numeric index of a positional argument, or the name '
+ 'of a\n'
+ ' keyword argument. Returns a copy of the string where '
+ 'each\n'
+ ' replacement field is replaced with the string value of '
+ 'the\n'
+ ' corresponding argument.\n'
+ '\n'
+ ' >>> "The sum of 1 + 2 is {0}".format(1+2)\n'
+ " 'The sum of 1 + 2 is 3'\n"
+ '\n'
+ ' See Format String Syntax for a description of the '
+ 'various\n'
+ ' formatting options that can be specified in format '
+ 'strings.\n'
+ '\n'
+ ' This method of string formatting is the new standard in '
+ 'Python 3,\n'
+ ' and should be preferred to the "%" formatting described '
+ 'in String\n'
+ ' Formatting Operations in new code.\n'
+ '\n'
+ ' New in version 2.6.\n'
+ '\n'
+ 'str.index(sub[, start[, end]])\n'
+ '\n'
+ ' Like "find()", but raise "ValueError" when the '
+ 'substring is not\n'
+ ' found.\n'
+ '\n'
+ 'str.isalnum()\n'
+ '\n'
+ ' Return true if all characters in the string are '
+ 'alphanumeric and\n'
+ ' there is at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isalpha()\n'
+ '\n'
+ ' Return true if all characters in the string are '
+ 'alphabetic and\n'
+ ' there is at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isdigit()\n'
+ '\n'
+ ' Return true if all characters in the string are digits '
+ 'and there is\n'
+ ' at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.islower()\n'
+ '\n'
+ ' Return true if all cased characters [4] in the string '
+ 'are lowercase\n'
+ ' and there is at least one cased character, false '
+ 'otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isspace()\n'
+ '\n'
+ ' Return true if there are only whitespace characters in '
+ 'the string\n'
+ ' and there is at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.istitle()\n'
+ '\n'
+ ' Return true if the string is a titlecased string and '
+ 'there is at\n'
+ ' least one character, for example uppercase characters '
+ 'may only\n'
+ ' follow uncased characters and lowercase characters only '
+ 'cased ones.\n'
+ ' Return false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isupper()\n'
+ '\n'
+ ' Return true if all cased characters [4] in the string '
+ 'are uppercase\n'
+ ' and there is at least one cased character, false '
+ 'otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.join(iterable)\n'
+ '\n'
+ ' Return a string which is the concatenation of the '
+ 'strings in\n'
+ ' *iterable*. A "TypeError" will be raised if there are '
+ 'any non-\n'
+ ' string values in *iterable*, including "bytes" '
+ 'objects. The\n'
+ ' separator between elements is the string providing this '
+ 'method.\n'
+ '\n'
+ 'str.ljust(width[, fillchar])\n'
+ '\n'
+ ' Return the string left justified in a string of length '
+ '*width*.\n'
+ ' Padding is done using the specified *fillchar* (default '
+ 'is a\n'
+ ' space). The original string is returned if *width* is '
+ 'less than or\n'
+ ' equal to "len(s)".\n'
+ '\n'
+ ' Changed in version 2.4: Support for the *fillchar* '
+ 'argument.\n'
+ '\n'
+ 'str.lower()\n'
+ '\n'
+ ' Return a copy of the string with all the cased '
+ 'characters [4]\n'
+ ' converted to lowercase.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.lstrip([chars])\n'
+ '\n'
+ ' Return a copy of the string with leading characters '
+ 'removed. The\n'
+ ' *chars* argument is a string specifying the set of '
+ 'characters to be\n'
+ ' removed. If omitted or "None", the *chars* argument '
+ 'defaults to\n'
+ ' removing whitespace. The *chars* argument is not a '
+ 'prefix; rather,\n'
+ ' all combinations of its values are stripped:\n'
+ '\n'
+ " >>> ' spacious '.lstrip()\n"
+ " 'spacious '\n"
+ " >>> 'www.example.com'.lstrip('cmowz.')\n"
+ " 'example.com'\n"
+ '\n'
+ ' Changed in version 2.2.2: Support for the *chars* '
+ 'argument.\n'
+ '\n'
+ 'str.partition(sep)\n'
+ '\n'
+ ' Split the string at the first occurrence of *sep*, and '
+ 'return a\n'
+ ' 3-tuple containing the part before the separator, the '
+ 'separator\n'
+ ' itself, and the part after the separator. If the '
+ 'separator is not\n'
+ ' found, return a 3-tuple containing the string itself, '
+ 'followed by\n'
+ ' two empty strings.\n'
+ '\n'
+ ' New in version 2.5.\n'
+ '\n'
+ 'str.replace(old, new[, count])\n'
+ '\n'
+ ' Return a copy of the string with all occurrences of '
+ 'substring *old*\n'
+ ' replaced by *new*. If the optional argument *count* is '
+ 'given, only\n'
+ ' the first *count* occurrences are replaced.\n'
+ '\n'
+ 'str.rfind(sub[, start[, end]])\n'
+ '\n'
+ ' Return the highest index in the string where substring '
+ '*sub* is\n'
+ ' found, such that *sub* is contained within '
+ '"s[start:end]".\n'
+ ' Optional arguments *start* and *end* are interpreted as '
+ 'in slice\n'
+ ' notation. Return "-1" on failure.\n'
+ '\n'
+ 'str.rindex(sub[, start[, end]])\n'
+ '\n'
+ ' Like "rfind()" but raises "ValueError" when the '
+ 'substring *sub* is\n'
+ ' not found.\n'
+ '\n'
+ 'str.rjust(width[, fillchar])\n'
+ '\n'
+ ' Return the string right justified in a string of length '
+ '*width*.\n'
+ ' Padding is done using the specified *fillchar* (default '
+ 'is a\n'
+ ' space). The original string is returned if *width* is '
+ 'less than or\n'
+ ' equal to "len(s)".\n'
+ '\n'
+ ' Changed in version 2.4: Support for the *fillchar* '
+ 'argument.\n'
+ '\n'
+ 'str.rpartition(sep)\n'
+ '\n'
+ ' Split the string at the last occurrence of *sep*, and '
+ 'return a\n'
+ ' 3-tuple containing the part before the separator, the '
+ 'separator\n'
+ ' itself, and the part after the separator. If the '
+ 'separator is not\n'
+ ' found, return a 3-tuple containing two empty strings, '
+ 'followed by\n'
+ ' the string itself.\n'
+ '\n'
+ ' New in version 2.5.\n'
+ '\n'
+ 'str.rsplit([sep[, maxsplit]])\n'
+ '\n'
+ ' Return a list of the words in the string, using *sep* '
+ 'as the\n'
+ ' delimiter string. If *maxsplit* is given, at most '
+ '*maxsplit* splits\n'
+ ' are done, the *rightmost* ones. If *sep* is not '
+ 'specified or\n'
+ ' "None", any whitespace string is a separator. Except '
+ 'for splitting\n'
+ ' from the right, "rsplit()" behaves like "split()" which '
+ 'is\n'
+ ' described in detail below.\n'
+ '\n'
+ ' New in version 2.4.\n'
+ '\n'
+ 'str.rstrip([chars])\n'
+ '\n'
+ ' Return a copy of the string with trailing characters '
+ 'removed. The\n'
+ ' *chars* argument is a string specifying the set of '
+ 'characters to be\n'
+ ' removed. If omitted or "None", the *chars* argument '
+ 'defaults to\n'
+ ' removing whitespace. The *chars* argument is not a '
+ 'suffix; rather,\n'
+ ' all combinations of its values are stripped:\n'
+ '\n'
+ " >>> ' spacious '.rstrip()\n"
+ " ' spacious'\n"
+ " >>> 'mississippi'.rstrip('ipz')\n"
+ " 'mississ'\n"
+ '\n'
+ ' Changed in version 2.2.2: Support for the *chars* '
+ 'argument.\n'
+ '\n'
+ 'str.split([sep[, maxsplit]])\n'
+ '\n'
+ ' Return a list of the words in the string, using *sep* '
+ 'as the\n'
+ ' delimiter string. If *maxsplit* is given, at most '
+ '*maxsplit*\n'
+ ' splits are done (thus, the list will have at most '
+ '"maxsplit+1"\n'
+ ' elements). If *maxsplit* is not specified or "-1", '
+ 'then there is\n'
+ ' no limit on the number of splits (all possible splits '
+ 'are made).\n'
+ '\n'
+ ' If *sep* is given, consecutive delimiters are not '
+ 'grouped together\n'
+ ' and are deemed to delimit empty strings (for example,\n'
+ ' "\'1,,2\'.split(\',\')" returns "[\'1\', \'\', '
+ '\'2\']"). The *sep* argument\n'
+ ' may consist of multiple characters (for example,\n'
+ ' "\'1<>2<>3\'.split(\'<>\')" returns "[\'1\', \'2\', '
+ '\'3\']"). Splitting an\n'
+ ' empty string with a specified separator returns '
+ '"[\'\']".\n'
+ '\n'
+ ' If *sep* is not specified or is "None", a different '
+ 'splitting\n'
+ ' algorithm is applied: runs of consecutive whitespace '
+ 'are regarded\n'
+ ' as a single separator, and the result will contain no '
+ 'empty strings\n'
+ ' at the start or end if the string has leading or '
+ 'trailing\n'
+ ' whitespace. Consequently, splitting an empty string or '
+ 'a string\n'
+ ' consisting of just whitespace with a "None" separator '
+ 'returns "[]".\n'
+ '\n'
+ ' For example, "\' 1 2 3 \'.split()" returns "[\'1\', '
+ '\'2\', \'3\']", and\n'
+ ' "\' 1 2 3 \'.split(None, 1)" returns "[\'1\', '
+ '\'2 3 \']".\n'
+ '\n'
+ 'str.splitlines([keepends])\n'
+ '\n'
+ ' Return a list of the lines in the string, breaking at '
+ 'line\n'
+ ' boundaries. This method uses the *universal newlines* '
+ 'approach to\n'
+ ' splitting lines. Line breaks are not included in the '
+ 'resulting list\n'
+ ' unless *keepends* is given and true.\n'
+ '\n'
+ ' Python recognizes ""\\r"", ""\\n"", and ""\\r\\n"" as '
+ 'line boundaries\n'
+ ' for 8-bit strings.\n'
+ '\n'
+ ' For example:\n'
+ '\n'
+ " >>> 'ab c\\n\\nde fg\\rkl\\r\\n'.splitlines()\n"
+ " ['ab c', '', 'de fg', 'kl']\n"
+ " >>> 'ab c\\n\\nde fg\\rkl\\r\\n'.splitlines(True)\n"
+ " ['ab c\\n', '\\n', 'de fg\\r', 'kl\\r\\n']\n"
+ '\n'
+ ' Unlike "split()" when a delimiter string *sep* is '
+ 'given, this\n'
+ ' method returns an empty list for the empty string, and '
+ 'a terminal\n'
+ ' line break does not result in an extra line:\n'
+ '\n'
+ ' >>> "".splitlines()\n'
+ ' []\n'
+ ' >>> "One line\\n".splitlines()\n'
+ " ['One line']\n"
+ '\n'
+ ' For comparison, "split(\'\\n\')" gives:\n'
+ '\n'
+ " >>> ''.split('\\n')\n"
+ " ['']\n"
+ " >>> 'Two lines\\n'.split('\\n')\n"
+ " ['Two lines', '']\n"
+ '\n'
+ 'unicode.splitlines([keepends])\n'
+ '\n'
+ ' Return a list of the lines in the string, like '
+ '"str.splitlines()".\n'
+ ' However, the Unicode method splits on the following '
+ 'line\n'
+ ' boundaries, which are a superset of the *universal '
+ 'newlines*\n'
+ ' recognized for 8-bit strings.\n'
+ '\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | Representation | '
+ 'Description |\n'
+ ' '
+ '+=========================+===============================+\n'
+ ' | "\\n" | Line '
+ 'Feed |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\r" | Carriage '
+ 'Return |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\r\\n" | Carriage Return + Line '
+ 'Feed |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\v" or "\\x0b" | Line '
+ 'Tabulation |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\f" or "\\x0c" | Form '
+ 'Feed |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\x1c" | File '
+ 'Separator |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\x1d" | Group '
+ 'Separator |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\x1e" | Record '
+ 'Separator |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\x85" | Next Line (C1 Control '
+ 'Code) |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\u2028" | Line '
+ 'Separator |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ ' | "\\u2029" | Paragraph '
+ 'Separator |\n'
+ ' '
+ '+-------------------------+-------------------------------+\n'
+ '\n'
+ ' Changed in version 2.7: "\\v" and "\\f" added to list '
+ 'of line\n'
+ ' boundaries.\n'
+ '\n'
+ 'str.startswith(prefix[, start[, end]])\n'
+ '\n'
+ ' Return "True" if string starts with the *prefix*, '
+ 'otherwise return\n'
+ ' "False". *prefix* can also be a tuple of prefixes to '
+ 'look for.\n'
+ ' With optional *start*, test string beginning at that '
+ 'position.\n'
+ ' With optional *end*, stop comparing string at that '
+ 'position.\n'
+ '\n'
+ ' Changed in version 2.5: Accept tuples as *prefix*.\n'
+ '\n'
+ 'str.strip([chars])\n'
+ '\n'
+ ' Return a copy of the string with the leading and '
+ 'trailing\n'
+ ' characters removed. The *chars* argument is a string '
+ 'specifying the\n'
+ ' set of characters to be removed. If omitted or "None", '
+ 'the *chars*\n'
+ ' argument defaults to removing whitespace. The *chars* '
+ 'argument is\n'
+ ' not a prefix or suffix; rather, all combinations of its '
+ 'values are\n'
+ ' stripped:\n'
+ '\n'
+ " >>> ' spacious '.strip()\n"
+ " 'spacious'\n"
+ " >>> 'www.example.com'.strip('cmowz.')\n"
+ " 'example'\n"
+ '\n'
+ ' Changed in version 2.2.2: Support for the *chars* '
+ 'argument.\n'
+ '\n'
+ 'str.swapcase()\n'
+ '\n'
+ ' Return a copy of the string with uppercase characters '
+ 'converted to\n'
+ ' lowercase and vice versa.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.title()\n'
+ '\n'
+ ' Return a titlecased version of the string where words '
+ 'start with an\n'
+ ' uppercase character and the remaining characters are '
+ 'lowercase.\n'
+ '\n'
+ ' The algorithm uses a simple language-independent '
+ 'definition of a\n'
+ ' word as groups of consecutive letters. The definition '
+ 'works in\n'
+ ' many contexts but it means that apostrophes in '
+ 'contractions and\n'
+ ' possessives form word boundaries, which may not be the '
+ 'desired\n'
+ ' result:\n'
+ '\n'
+ ' >>> "they\'re bill\'s friends from the UK".title()\n'
+ ' "They\'Re Bill\'S Friends From The Uk"\n'
+ '\n'
+ ' A workaround for apostrophes can be constructed using '
+ 'regular\n'
+ ' expressions:\n'
+ '\n'
+ ' >>> import re\n'
+ ' >>> def titlecase(s):\n'
+ ' ... return re.sub(r"[A-Za-z]+(\'[A-Za-z]+)?",\n'
+ ' ... lambda mo: '
+ 'mo.group(0)[0].upper() +\n'
+ ' ... '
+ 'mo.group(0)[1:].lower(),\n'
+ ' ... s)\n'
+ ' ...\n'
+ ' >>> titlecase("they\'re bill\'s friends.")\n'
+ ' "They\'re Bill\'s Friends."\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.translate(table[, deletechars])\n'
+ '\n'
+ ' Return a copy of the string where all characters '
+ 'occurring in the\n'
+ ' optional argument *deletechars* are removed, and the '
+ 'remaining\n'
+ ' characters have been mapped through the given '
+ 'translation table,\n'
+ ' which must be a string of length 256.\n'
+ '\n'
+ ' You can use the "maketrans()" helper function in the '
+ '"string"\n'
+ ' module to create a translation table. For string '
+ 'objects, set the\n'
+ ' *table* argument to "None" for translations that only '
+ 'delete\n'
+ ' characters:\n'
+ '\n'
+ " >>> 'read this short text'.translate(None, 'aeiou')\n"
+ " 'rd ths shrt txt'\n"
+ '\n'
+ ' New in version 2.6: Support for a "None" *table* '
+ 'argument.\n'
+ '\n'
+ ' For Unicode objects, the "translate()" method does not '
+ 'accept the\n'
+ ' optional *deletechars* argument. Instead, it returns a '
+ 'copy of the\n'
+ ' *s* where all characters have been mapped through the '
+ 'given\n'
+ ' translation table which must be a mapping of Unicode '
+ 'ordinals to\n'
+ ' Unicode ordinals, Unicode strings or "None". Unmapped '
+ 'characters\n'
+ ' are left untouched. Characters mapped to "None" are '
+ 'deleted. Note,\n'
+ ' a more flexible approach is to create a custom '
+ 'character mapping\n'
+ ' codec using the "codecs" module (see "encodings.cp1251" '
+ 'for an\n'
+ ' example).\n'
+ '\n'
+ 'str.upper()\n'
+ '\n'
+ ' Return a copy of the string with all the cased '
+ 'characters [4]\n'
+ ' converted to uppercase. Note that '
+ '"str.upper().isupper()" might be\n'
+ ' "False" if "s" contains uncased characters or if the '
+ 'Unicode\n'
+ ' category of the resulting character(s) is not "Lu" '
+ '(Letter,\n'
+ ' uppercase), but e.g. "Lt" (Letter, titlecase).\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.zfill(width)\n'
+ '\n'
+ ' Return the numeric string left filled with zeros in a '
+ 'string of\n'
+ ' length *width*. A sign prefix is handled correctly. '
+ 'The original\n'
+ ' string is returned if *width* is less than or equal to '
+ '"len(s)".\n'
+ '\n'
+ ' New in version 2.2.2.\n'
+ '\n'
+ 'The following methods are present only on unicode '
+ 'objects:\n'
+ '\n'
+ 'unicode.isnumeric()\n'
+ '\n'
+ ' Return "True" if there are only numeric characters in '
+ 'S, "False"\n'
+ ' otherwise. Numeric characters include digit characters, '
+ 'and all\n'
+ ' characters that have the Unicode numeric value '
+ 'property, e.g.\n'
+ ' U+2155, VULGAR FRACTION ONE FIFTH.\n'
+ '\n'
+ 'unicode.isdecimal()\n'
+ '\n'
+ ' Return "True" if there are only decimal characters in '
+ 'S, "False"\n'
+ ' otherwise. Decimal characters include digit characters, '
+ 'and all\n'
+ ' characters that can be used to form decimal-radix '
+ 'numbers, e.g.\n'
+ ' U+0660, ARABIC-INDIC DIGIT ZERO.\n',
+ 'strings': '\n'
+ 'String literals\n'
+ '***************\n'
+ '\n'
+ 'String literals are described by the following lexical '
+ 'definitions:\n'
+ '\n'
+ ' stringliteral ::= [stringprefix](shortstring | longstring)\n'
+ ' stringprefix ::= "r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" '
+ '| "uR"\n'
+ ' | "b" | "B" | "br" | "Br" | "bR" | "BR"\n'
+ ' shortstring ::= "\'" shortstringitem* "\'" | \'"\' '
+ 'shortstringitem* \'"\'\n'
+ ' longstring ::= "\'\'\'" longstringitem* "\'\'\'"\n'
+ ' | \'"""\' longstringitem* \'"""\'\n'
+ ' shortstringitem ::= shortstringchar | escapeseq\n'
+ ' longstringitem ::= longstringchar | escapeseq\n'
+ ' shortstringchar ::= <any source character except "\\" or '
+ 'newline or the quote>\n'
+ ' longstringchar ::= <any source character except "\\">\n'
+ ' escapeseq ::= "\\" <any ASCII character>\n'
+ '\n'
+ 'One syntactic restriction not indicated by these productions is '
+ 'that\n'
+ 'whitespace is not allowed between the "stringprefix" and the rest '
+ 'of\n'
+ 'the string literal. The source character set is defined by the\n'
+ 'encoding declaration; it is ASCII if no encoding declaration is '
+ 'given\n'
+ 'in the source file; see section Encoding declarations.\n'
+ '\n'
+ 'In plain English: String literals can be enclosed in matching '
+ 'single\n'
+ 'quotes ("\'") or double quotes ("""). They can also be enclosed '
+ 'in\n'
+ 'matching groups of three single or double quotes (these are '
+ 'generally\n'
+ 'referred to as *triple-quoted strings*). The backslash ("\\")\n'
+ 'character is used to escape characters that otherwise have a '
+ 'special\n'
+ 'meaning, such as newline, backslash itself, or the quote '
+ 'character.\n'
+ 'String literals may optionally be prefixed with a letter "\'r\'" '
+ 'or\n'
+ '"\'R\'"; such strings are called *raw strings* and use different '
+ 'rules\n'
+ 'for interpreting backslash escape sequences. A prefix of "\'u\'" '
+ 'or\n'
+ '"\'U\'" makes the string a Unicode string. Unicode strings use '
+ 'the\n'
+ 'Unicode character set as defined by the Unicode Consortium and '
+ 'ISO\n'
+ '10646. Some additional escape sequences, described below, are\n'
+ 'available in Unicode strings. A prefix of "\'b\'" or "\'B\'" is '
+ 'ignored in\n'
+ 'Python 2; it indicates that the literal should become a bytes '
+ 'literal\n'
+ 'in Python 3 (e.g. when code is automatically converted with '
+ '2to3). A\n'
+ '"\'u\'" or "\'b\'" prefix may be followed by an "\'r\'" prefix.\n'
+ '\n'
+ 'In triple-quoted strings, unescaped newlines and quotes are '
+ 'allowed\n'
+ '(and are retained), except that three unescaped quotes in a row\n'
+ 'terminate the string. (A "quote" is the character used to open '
+ 'the\n'
+ 'string, i.e. either "\'" or """.)\n'
+ '\n'
+ 'Unless an "\'r\'" or "\'R\'" prefix is present, escape sequences '
+ 'in\n'
+ 'strings are interpreted according to rules similar to those used '
+ 'by\n'
+ 'Standard C. The recognized escape sequences are:\n'
+ '\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| Escape Sequence | Meaning | Notes '
+ '|\n'
+ '+===================+===================================+=========+\n'
+ '| "\\newline" | Ignored '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\\\" | Backslash ("\\") '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\\'" | Single quote ("\'") '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\"" | Double quote (""") '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\a" | ASCII Bell (BEL) '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\b" | ASCII Backspace (BS) '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\f" | ASCII Formfeed (FF) '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\n" | ASCII Linefeed (LF) '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\N{name}" | Character named *name* in the '
+ '| |\n'
+ '| | Unicode database (Unicode only) | '
+ '|\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\r" | ASCII Carriage Return (CR) '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\t" | ASCII Horizontal Tab (TAB) '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\uxxxx" | Character with 16-bit hex value | '
+ '(1) |\n'
+ '| | *xxxx* (Unicode only) | '
+ '|\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\Uxxxxxxxx" | Character with 32-bit hex value | '
+ '(2) |\n'
+ '| | *xxxxxxxx* (Unicode only) | '
+ '|\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\v" | ASCII Vertical Tab (VT) '
+ '| |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\ooo" | Character with octal value *ooo* | '
+ '(3,5) |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '| "\\xhh" | Character with hex value *hh* | '
+ '(4,5) |\n'
+ '+-------------------+-----------------------------------+---------+\n'
+ '\n'
+ 'Notes:\n'
+ '\n'
+ '1. Individual code units which form parts of a surrogate pair '
+ 'can\n'
+ ' be encoded using this escape sequence.\n'
+ '\n'
+ '2. Any Unicode character can be encoded this way, but characters\n'
+ ' outside the Basic Multilingual Plane (BMP) will be encoded '
+ 'using a\n'
+ ' surrogate pair if Python is compiled to use 16-bit code units '
+ '(the\n'
+ ' default).\n'
+ '\n'
+ '3. As in Standard C, up to three octal digits are accepted.\n'
+ '\n'
+ '4. Unlike in Standard C, exactly two hex digits are required.\n'
+ '\n'
+ '5. In a string literal, hexadecimal and octal escapes denote the\n'
+ ' byte with the given value; it is not necessary that the byte\n'
+ ' encodes a character in the source character set. In a Unicode\n'
+ ' literal, these escapes denote a Unicode character with the '
+ 'given\n'
+ ' value.\n'
+ '\n'
+ 'Unlike Standard C, all unrecognized escape sequences are left in '
+ 'the\n'
+ 'string unchanged, i.e., *the backslash is left in the string*. '
+ '(This\n'
+ 'behavior is useful when debugging: if an escape sequence is '
+ 'mistyped,\n'
+ 'the resulting output is more easily recognized as broken.) It is '
+ 'also\n'
+ 'important to note that the escape sequences marked as "(Unicode '
+ 'only)"\n'
+ 'in the table above fall into the category of unrecognized escapes '
+ 'for\n'
+ 'non-Unicode string literals.\n'
+ '\n'
+ 'When an "\'r\'" or "\'R\'" prefix is present, a character '
+ 'following a\n'
+ 'backslash is included in the string without change, and *all\n'
+ 'backslashes are left in the string*. For example, the string '
+ 'literal\n'
+ '"r"\\n"" consists of two characters: a backslash and a lowercase '
+ '"\'n\'".\n'
+ 'String quotes can be escaped with a backslash, but the backslash\n'
+ 'remains in the string; for example, "r"\\""" is a valid string '
+ 'literal\n'
+ 'consisting of two characters: a backslash and a double quote; '
+ '"r"\\""\n'
+ 'is not a valid string literal (even a raw string cannot end in an '
+ 'odd\n'
+ 'number of backslashes). Specifically, *a raw string cannot end '
+ 'in a\n'
+ 'single backslash* (since the backslash would escape the '
+ 'following\n'
+ 'quote character). Note also that a single backslash followed by '
+ 'a\n'
+ 'newline is interpreted as those two characters as part of the '
+ 'string,\n'
+ '*not* as a line continuation.\n'
+ '\n'
+ 'When an "\'r\'" or "\'R\'" prefix is used in conjunction with a '
+ '"\'u\'" or\n'
+ '"\'U\'" prefix, then the "\\uXXXX" and "\\UXXXXXXXX" escape '
+ 'sequences are\n'
+ 'processed while *all other backslashes are left in the string*. '
+ 'For\n'
+ 'example, the string literal "ur"\\u0062\\n"" consists of three '
+ 'Unicode\n'
+ "characters: 'LATIN SMALL LETTER B', 'REVERSE SOLIDUS', and "
+ "'LATIN\n"
+ "SMALL LETTER N'. Backslashes can be escaped with a preceding\n"
+ 'backslash; however, both remain in the string. As a result, '
+ '"\\uXXXX"\n'
+ 'escape sequences are only recognized when there are an odd number '
+ 'of\n'
+ 'backslashes.\n',
+ 'subscriptions': '\n'
+ 'Subscriptions\n'
+ '*************\n'
+ '\n'
+ 'A subscription selects an item of a sequence (string, tuple '
+ 'or list)\n'
+ 'or mapping (dictionary) object:\n'
+ '\n'
+ ' subscription ::= primary "[" expression_list "]"\n'
+ '\n'
+ 'The primary must evaluate to an object of a sequence or '
+ 'mapping type.\n'
+ '\n'
+ 'If the primary is a mapping, the expression list must '
+ 'evaluate to an\n'
+ 'object whose value is one of the keys of the mapping, and '
+ 'the\n'
+ 'subscription selects the value in the mapping that '
+ 'corresponds to that\n'
+ 'key. (The expression list is a tuple except if it has '
+ 'exactly one\n'
+ 'item.)\n'
+ '\n'
+ 'If the primary is a sequence, the expression (list) must '
+ 'evaluate to a\n'
+ 'plain integer. If this value is negative, the length of '
+ 'the sequence\n'
+ 'is added to it (so that, e.g., "x[-1]" selects the last '
+ 'item of "x".)\n'
+ 'The resulting value must be a nonnegative integer less than '
+ 'the number\n'
+ 'of items in the sequence, and the subscription selects the '
+ 'item whose\n'
+ 'index is that value (counting from zero).\n'
+ '\n'
+ "A string's items are characters. A character is not a "
+ 'separate data\n'
+ 'type but a string of exactly one character.\n',
+ 'truth': '\n'
+ 'Truth Value Testing\n'
+ '*******************\n'
+ '\n'
+ 'Any object can be tested for truth value, for use in an "if" or\n'
+ '"while" condition or as operand of the Boolean operations below. '
+ 'The\n'
+ 'following values are considered false:\n'
+ '\n'
+ '* "None"\n'
+ '\n'
+ '* "False"\n'
+ '\n'
+ '* zero of any numeric type, for example, "0", "0L", "0.0", "0j".\n'
+ '\n'
+ '* any empty sequence, for example, "\'\'", "()", "[]".\n'
+ '\n'
+ '* any empty mapping, for example, "{}".\n'
+ '\n'
+ '* instances of user-defined classes, if the class defines a\n'
+ ' "__nonzero__()" or "__len__()" method, when that method returns '
+ 'the\n'
+ ' integer zero or "bool" value "False". [1]\n'
+ '\n'
+ 'All other values are considered true --- so objects of many types '
+ 'are\n'
+ 'always true.\n'
+ '\n'
+ 'Operations and built-in functions that have a Boolean result '
+ 'always\n'
+ 'return "0" or "False" for false and "1" or "True" for true, unless\n'
+ 'otherwise stated. (Important exception: the Boolean operations '
+ '"or"\n'
+ 'and "and" always return one of their operands.)\n',
+ 'try': '\n'
+ 'The "try" statement\n'
+ '*******************\n'
+ '\n'
+ 'The "try" statement specifies exception handlers and/or cleanup code\n'
+ 'for a group of statements:\n'
+ '\n'
+ ' try_stmt ::= try1_stmt | try2_stmt\n'
+ ' try1_stmt ::= "try" ":" suite\n'
+ ' ("except" [expression [("as" | ",") identifier]] ":" '
+ 'suite)+\n'
+ ' ["else" ":" suite]\n'
+ ' ["finally" ":" suite]\n'
+ ' try2_stmt ::= "try" ":" suite\n'
+ ' "finally" ":" suite\n'
+ '\n'
+ 'Changed in version 2.5: In previous versions of Python,\n'
+ '"try"..."except"..."finally" did not work. "try"..."except" had to '
+ 'be\n'
+ 'nested in "try"..."finally".\n'
+ '\n'
+ 'The "except" clause(s) specify one or more exception handlers. When '
+ 'no\n'
+ 'exception occurs in the "try" clause, no exception handler is\n'
+ 'executed. When an exception occurs in the "try" suite, a search for '
+ 'an\n'
+ 'exception handler is started. This search inspects the except '
+ 'clauses\n'
+ 'in turn until one is found that matches the exception. An '
+ 'expression-\n'
+ 'less except clause, if present, must be last; it matches any\n'
+ 'exception. For an except clause with an expression, that expression\n'
+ 'is evaluated, and the clause matches the exception if the resulting\n'
+ 'object is "compatible" with the exception. An object is compatible\n'
+ 'with an exception if it is the class or a base class of the '
+ 'exception\n'
+ 'object, or a tuple containing an item compatible with the exception.\n'
+ '\n'
+ 'If no except clause matches the exception, the search for an '
+ 'exception\n'
+ 'handler continues in the surrounding code and on the invocation '
+ 'stack.\n'
+ '[1]\n'
+ '\n'
+ 'If the evaluation of an expression in the header of an except clause\n'
+ 'raises an exception, the original search for a handler is canceled '
+ 'and\n'
+ 'a search starts for the new exception in the surrounding code and on\n'
+ 'the call stack (it is treated as if the entire "try" statement '
+ 'raised\n'
+ 'the exception).\n'
+ '\n'
+ 'When a matching except clause is found, the exception is assigned to\n'
+ 'the target specified in that except clause, if present, and the '
+ 'except\n'
+ "clause's suite is executed. All except clauses must have an\n"
+ 'executable block. When the end of this block is reached, execution\n'
+ 'continues normally after the entire try statement. (This means that\n'
+ 'if two nested handlers exist for the same exception, and the '
+ 'exception\n'
+ 'occurs in the try clause of the inner handler, the outer handler '
+ 'will\n'
+ 'not handle the exception.)\n'
+ '\n'
+ "Before an except clause's suite is executed, details about the\n"
+ 'exception are assigned to three variables in the "sys" module:\n'
+ '"sys.exc_type" receives the object identifying the exception;\n'
+ '"sys.exc_value" receives the exception\'s parameter;\n'
+ '"sys.exc_traceback" receives a traceback object (see section The\n'
+ 'standard type hierarchy) identifying the point in the program where\n'
+ 'the exception occurred. These details are also available through the\n'
+ '"sys.exc_info()" function, which returns a tuple "(exc_type,\n'
+ 'exc_value, exc_traceback)". Use of the corresponding variables is\n'
+ 'deprecated in favor of this function, since their use is unsafe in a\n'
+ 'threaded program. As of Python 1.5, the variables are restored to\n'
+ 'their previous values (before the call) when returning from a '
+ 'function\n'
+ 'that handled an exception.\n'
+ '\n'
+ 'The optional "else" clause is executed if and when control flows off\n'
+ 'the end of the "try" clause. [2] Exceptions in the "else" clause are\n'
+ 'not handled by the preceding "except" clauses.\n'
+ '\n'
+ 'If "finally" is present, it specifies a \'cleanup\' handler. The '
+ '"try"\n'
+ 'clause is executed, including any "except" and "else" clauses. If '
+ 'an\n'
+ 'exception occurs in any of the clauses and is not handled, the\n'
+ 'exception is temporarily saved. The "finally" clause is executed. '
+ 'If\n'
+ 'there is a saved exception, it is re-raised at the end of the\n'
+ '"finally" clause. If the "finally" clause raises another exception '
+ 'or\n'
+ 'executes a "return" or "break" statement, the saved exception is\n'
+ 'discarded:\n'
+ '\n'
+ ' >>> def f():\n'
+ ' ... try:\n'
+ ' ... 1/0\n'
+ ' ... finally:\n'
+ ' ... return 42\n'
+ ' ...\n'
+ ' >>> f()\n'
+ ' 42\n'
+ '\n'
+ 'The exception information is not available to the program during\n'
+ 'execution of the "finally" clause.\n'
+ '\n'
+ 'When a "return", "break" or "continue" statement is executed in the\n'
+ '"try" suite of a "try"..."finally" statement, the "finally" clause '
+ 'is\n'
+ 'also executed \'on the way out.\' A "continue" statement is illegal '
+ 'in\n'
+ 'the "finally" clause. (The reason is a problem with the current\n'
+ 'implementation --- this restriction may be lifted in the future).\n'
+ '\n'
+ 'The return value of a function is determined by the last "return"\n'
+ 'statement executed. Since the "finally" clause always executes, a\n'
+ '"return" statement executed in the "finally" clause will always be '
+ 'the\n'
+ 'last one executed:\n'
+ '\n'
+ ' >>> def foo():\n'
+ ' ... try:\n'
+ " ... return 'try'\n"
+ ' ... finally:\n'
+ " ... return 'finally'\n"
+ ' ...\n'
+ ' >>> foo()\n'
+ " 'finally'\n"
+ '\n'
+ 'Additional information on exceptions can be found in section\n'
+ 'Exceptions, and information on using the "raise" statement to '
+ 'generate\n'
+ 'exceptions may be found in section The raise statement.\n',
+ 'types': '\n'
+ 'The standard type hierarchy\n'
+ '***************************\n'
+ '\n'
+ 'Below is a list of the types that are built into Python. '
+ 'Extension\n'
+ 'modules (written in C, Java, or other languages, depending on the\n'
+ 'implementation) can define additional types. Future versions of\n'
+ 'Python may add types to the type hierarchy (e.g., rational '
+ 'numbers,\n'
+ 'efficiently stored arrays of integers, etc.).\n'
+ '\n'
+ 'Some of the type descriptions below contain a paragraph listing\n'
+ "'special attributes.' These are attributes that provide access to "
+ 'the\n'
+ 'implementation and are not intended for general use. Their '
+ 'definition\n'
+ 'may change in the future.\n'
+ '\n'
+ 'None\n'
+ ' This type has a single value. There is a single object with '
+ 'this\n'
+ ' value. This object is accessed through the built-in name "None". '
+ 'It\n'
+ ' is used to signify the absence of a value in many situations, '
+ 'e.g.,\n'
+ " it is returned from functions that don't explicitly return\n"
+ ' anything. Its truth value is false.\n'
+ '\n'
+ 'NotImplemented\n'
+ ' This type has a single value. There is a single object with '
+ 'this\n'
+ ' value. This object is accessed through the built-in name\n'
+ ' "NotImplemented". Numeric methods and rich comparison methods '
+ 'may\n'
+ ' return this value if they do not implement the operation for '
+ 'the\n'
+ ' operands provided. (The interpreter will then try the '
+ 'reflected\n'
+ ' operation, or some other fallback, depending on the operator.) '
+ 'Its\n'
+ ' truth value is true.\n'
+ '\n'
+ 'Ellipsis\n'
+ ' This type has a single value. There is a single object with '
+ 'this\n'
+ ' value. This object is accessed through the built-in name\n'
+ ' "Ellipsis". It is used to indicate the presence of the "..." '
+ 'syntax\n'
+ ' in a slice. Its truth value is true.\n'
+ '\n'
+ '"numbers.Number"\n'
+ ' These are created by numeric literals and returned as results '
+ 'by\n'
+ ' arithmetic operators and arithmetic built-in functions. '
+ 'Numeric\n'
+ ' objects are immutable; once created their value never changes.\n'
+ ' Python numbers are of course strongly related to mathematical\n'
+ ' numbers, but subject to the limitations of numerical '
+ 'representation\n'
+ ' in computers.\n'
+ '\n'
+ ' Python distinguishes between integers, floating point numbers, '
+ 'and\n'
+ ' complex numbers:\n'
+ '\n'
+ ' "numbers.Integral"\n'
+ ' These represent elements from the mathematical set of '
+ 'integers\n'
+ ' (positive and negative).\n'
+ '\n'
+ ' There are three types of integers:\n'
+ '\n'
+ ' Plain integers\n'
+ ' These represent numbers in the range -2147483648 through\n'
+ ' 2147483647. (The range may be larger on machines with a\n'
+ ' larger natural word size, but not smaller.) When the '
+ 'result\n'
+ ' of an operation would fall outside this range, the result '
+ 'is\n'
+ ' normally returned as a long integer (in some cases, the\n'
+ ' exception "OverflowError" is raised instead). For the\n'
+ ' purpose of shift and mask operations, integers are assumed '
+ 'to\n'
+ " have a binary, 2's complement notation using 32 or more "
+ 'bits,\n'
+ ' and hiding no bits from the user (i.e., all 4294967296\n'
+ ' different bit patterns correspond to different values).\n'
+ '\n'
+ ' Long integers\n'
+ ' These represent numbers in an unlimited range, subject to\n'
+ ' available (virtual) memory only. For the purpose of '
+ 'shift\n'
+ ' and mask operations, a binary representation is assumed, '
+ 'and\n'
+ " negative numbers are represented in a variant of 2's\n"
+ ' complement which gives the illusion of an infinite string '
+ 'of\n'
+ ' sign bits extending to the left.\n'
+ '\n'
+ ' Booleans\n'
+ ' These represent the truth values False and True. The two\n'
+ ' objects representing the values "False" and "True" are '
+ 'the\n'
+ ' only Boolean objects. The Boolean type is a subtype of '
+ 'plain\n'
+ ' integers, and Boolean values behave like the values 0 and '
+ '1,\n'
+ ' respectively, in almost all contexts, the exception being\n'
+ ' that when converted to a string, the strings ""False"" or\n'
+ ' ""True"" are returned, respectively.\n'
+ '\n'
+ ' The rules for integer representation are intended to give '
+ 'the\n'
+ ' most meaningful interpretation of shift and mask operations\n'
+ ' involving negative integers and the least surprises when\n'
+ ' switching between the plain and long integer domains. Any\n'
+ ' operation, if it yields a result in the plain integer '
+ 'domain,\n'
+ ' will yield the same result in the long integer domain or '
+ 'when\n'
+ ' using mixed operands. The switch between domains is '
+ 'transparent\n'
+ ' to the programmer.\n'
+ '\n'
+ ' "numbers.Real" ("float")\n'
+ ' These represent machine-level double precision floating '
+ 'point\n'
+ ' numbers. You are at the mercy of the underlying machine\n'
+ ' architecture (and C or Java implementation) for the accepted\n'
+ ' range and handling of overflow. Python does not support '
+ 'single-\n'
+ ' precision floating point numbers; the savings in processor '
+ 'and\n'
+ ' memory usage that are usually the reason for using these are\n'
+ ' dwarfed by the overhead of using objects in Python, so there '
+ 'is\n'
+ ' no reason to complicate the language with two kinds of '
+ 'floating\n'
+ ' point numbers.\n'
+ '\n'
+ ' "numbers.Complex"\n'
+ ' These represent complex numbers as a pair of machine-level\n'
+ ' double precision floating point numbers. The same caveats '
+ 'apply\n'
+ ' as for floating point numbers. The real and imaginary parts '
+ 'of a\n'
+ ' complex number "z" can be retrieved through the read-only\n'
+ ' attributes "z.real" and "z.imag".\n'
+ '\n'
+ 'Sequences\n'
+ ' These represent finite ordered sets indexed by non-negative\n'
+ ' numbers. The built-in function "len()" returns the number of '
+ 'items\n'
+ ' of a sequence. When the length of a sequence is *n*, the index '
+ 'set\n'
+ ' contains the numbers 0, 1, ..., *n*-1. Item *i* of sequence *a* '
+ 'is\n'
+ ' selected by "a[i]".\n'
+ '\n'
+ ' Sequences also support slicing: "a[i:j]" selects all items with\n'
+ ' index *k* such that *i* "<=" *k* "<" *j*. When used as an\n'
+ ' expression, a slice is a sequence of the same type. This '
+ 'implies\n'
+ ' that the index set is renumbered so that it starts at 0.\n'
+ '\n'
+ ' Some sequences also support "extended slicing" with a third '
+ '"step"\n'
+ ' parameter: "a[i:j:k]" selects all items of *a* with index *x* '
+ 'where\n'
+ ' "x = i + n*k", *n* ">=" "0" and *i* "<=" *x* "<" *j*.\n'
+ '\n'
+ ' Sequences are distinguished according to their mutability:\n'
+ '\n'
+ ' Immutable sequences\n'
+ ' An object of an immutable sequence type cannot change once it '
+ 'is\n'
+ ' created. (If the object contains references to other '
+ 'objects,\n'
+ ' these other objects may be mutable and may be changed; '
+ 'however,\n'
+ ' the collection of objects directly referenced by an '
+ 'immutable\n'
+ ' object cannot change.)\n'
+ '\n'
+ ' The following types are immutable sequences:\n'
+ '\n'
+ ' Strings\n'
+ ' The items of a string are characters. There is no '
+ 'separate\n'
+ ' character type; a character is represented by a string of '
+ 'one\n'
+ ' item. Characters represent (at least) 8-bit bytes. The\n'
+ ' built-in functions "chr()" and "ord()" convert between\n'
+ ' characters and nonnegative integers representing the byte\n'
+ ' values. Bytes with the values 0--127 usually represent '
+ 'the\n'
+ ' corresponding ASCII values, but the interpretation of '
+ 'values\n'
+ ' is up to the program. The string data type is also used '
+ 'to\n'
+ ' represent arrays of bytes, e.g., to hold data read from a\n'
+ ' file.\n'
+ '\n'
+ ' (On systems whose native character set is not ASCII, '
+ 'strings\n'
+ ' may use EBCDIC in their internal representation, provided '
+ 'the\n'
+ ' functions "chr()" and "ord()" implement a mapping between\n'
+ ' ASCII and EBCDIC, and string comparison preserves the '
+ 'ASCII\n'
+ ' order. Or perhaps someone can propose a better rule?)\n'
+ '\n'
+ ' Unicode\n'
+ ' The items of a Unicode object are Unicode code units. A\n'
+ ' Unicode code unit is represented by a Unicode object of '
+ 'one\n'
+ ' item and can hold either a 16-bit or 32-bit value\n'
+ ' representing a Unicode ordinal (the maximum value for the\n'
+ ' ordinal is given in "sys.maxunicode", and depends on how\n'
+ ' Python is configured at compile time). Surrogate pairs '
+ 'may\n'
+ ' be present in the Unicode object, and will be reported as '
+ 'two\n'
+ ' separate items. The built-in functions "unichr()" and\n'
+ ' "ord()" convert between code units and nonnegative '
+ 'integers\n'
+ ' representing the Unicode ordinals as defined in the '
+ 'Unicode\n'
+ ' Standard 3.0. Conversion from and to other encodings are\n'
+ ' possible through the Unicode method "encode()" and the '
+ 'built-\n'
+ ' in function "unicode()".\n'
+ '\n'
+ ' Tuples\n'
+ ' The items of a tuple are arbitrary Python objects. Tuples '
+ 'of\n'
+ ' two or more items are formed by comma-separated lists of\n'
+ " expressions. A tuple of one item (a 'singleton') can be\n"
+ ' formed by affixing a comma to an expression (an expression '
+ 'by\n'
+ ' itself does not create a tuple, since parentheses must be\n'
+ ' usable for grouping of expressions). An empty tuple can '
+ 'be\n'
+ ' formed by an empty pair of parentheses.\n'
+ '\n'
+ ' Mutable sequences\n'
+ ' Mutable sequences can be changed after they are created. '
+ 'The\n'
+ ' subscription and slicing notations can be used as the target '
+ 'of\n'
+ ' assignment and "del" (delete) statements.\n'
+ '\n'
+ ' There are currently two intrinsic mutable sequence types:\n'
+ '\n'
+ ' Lists\n'
+ ' The items of a list are arbitrary Python objects. Lists '
+ 'are\n'
+ ' formed by placing a comma-separated list of expressions '
+ 'in\n'
+ ' square brackets. (Note that there are no special cases '
+ 'needed\n'
+ ' to form lists of length 0 or 1.)\n'
+ '\n'
+ ' Byte Arrays\n'
+ ' A bytearray object is a mutable array. They are created '
+ 'by\n'
+ ' the built-in "bytearray()" constructor. Aside from being\n'
+ ' mutable (and hence unhashable), byte arrays otherwise '
+ 'provide\n'
+ ' the same interface and functionality as immutable bytes\n'
+ ' objects.\n'
+ '\n'
+ ' The extension module "array" provides an additional example '
+ 'of a\n'
+ ' mutable sequence type.\n'
+ '\n'
+ 'Set types\n'
+ ' These represent unordered, finite sets of unique, immutable\n'
+ ' objects. As such, they cannot be indexed by any subscript. '
+ 'However,\n'
+ ' they can be iterated over, and the built-in function "len()"\n'
+ ' returns the number of items in a set. Common uses for sets are '
+ 'fast\n'
+ ' membership testing, removing duplicates from a sequence, and\n'
+ ' computing mathematical operations such as intersection, union,\n'
+ ' difference, and symmetric difference.\n'
+ '\n'
+ ' For set elements, the same immutability rules apply as for\n'
+ ' dictionary keys. Note that numeric types obey the normal rules '
+ 'for\n'
+ ' numeric comparison: if two numbers compare equal (e.g., "1" and\n'
+ ' "1.0"), only one of them can be contained in a set.\n'
+ '\n'
+ ' There are currently two intrinsic set types:\n'
+ '\n'
+ ' Sets\n'
+ ' These represent a mutable set. They are created by the '
+ 'built-in\n'
+ ' "set()" constructor and can be modified afterwards by '
+ 'several\n'
+ ' methods, such as "add()".\n'
+ '\n'
+ ' Frozen sets\n'
+ ' These represent an immutable set. They are created by the\n'
+ ' built-in "frozenset()" constructor. As a frozenset is '
+ 'immutable\n'
+ ' and *hashable*, it can be used again as an element of '
+ 'another\n'
+ ' set, or as a dictionary key.\n'
+ '\n'
+ 'Mappings\n'
+ ' These represent finite sets of objects indexed by arbitrary '
+ 'index\n'
+ ' sets. The subscript notation "a[k]" selects the item indexed by '
+ '"k"\n'
+ ' from the mapping "a"; this can be used in expressions and as '
+ 'the\n'
+ ' target of assignments or "del" statements. The built-in '
+ 'function\n'
+ ' "len()" returns the number of items in a mapping.\n'
+ '\n'
+ ' There is currently a single intrinsic mapping type:\n'
+ '\n'
+ ' Dictionaries\n'
+ ' These represent finite sets of objects indexed by nearly\n'
+ ' arbitrary values. The only types of values not acceptable '
+ 'as\n'
+ ' keys are values containing lists or dictionaries or other\n'
+ ' mutable types that are compared by value rather than by '
+ 'object\n'
+ ' identity, the reason being that the efficient implementation '
+ 'of\n'
+ " dictionaries requires a key's hash value to remain constant.\n"
+ ' Numeric types used for keys obey the normal rules for '
+ 'numeric\n'
+ ' comparison: if two numbers compare equal (e.g., "1" and '
+ '"1.0")\n'
+ ' then they can be used interchangeably to index the same\n'
+ ' dictionary entry.\n'
+ '\n'
+ ' Dictionaries are mutable; they can be created by the "{...}"\n'
+ ' notation (see section Dictionary displays).\n'
+ '\n'
+ ' The extension modules "dbm", "gdbm", and "bsddb" provide\n'
+ ' additional examples of mapping types.\n'
+ '\n'
+ 'Callable types\n'
+ ' These are the types to which the function call operation (see\n'
+ ' section Calls) can be applied:\n'
+ '\n'
+ ' User-defined functions\n'
+ ' A user-defined function object is created by a function\n'
+ ' definition (see section Function definitions). It should be\n'
+ ' called with an argument list containing the same number of '
+ 'items\n'
+ " as the function's formal parameter list.\n"
+ '\n'
+ ' Special attributes:\n'
+ '\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | Attribute | Meaning '
+ '| |\n'
+ ' '
+ '+=========================+=================================+=============+\n'
+ ' | "__doc__" "func_doc" | The function\'s documentation '
+ '| Writable |\n'
+ ' | | string, or "None" if '
+ '| |\n'
+ ' | | unavailable. '
+ '| |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | "__name__" "func_name" | The function\'s name '
+ '| Writable |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | "__module__" | The name of the module the | '
+ 'Writable |\n'
+ ' | | function was defined in, or '
+ '| |\n'
+ ' | | "None" if unavailable. '
+ '| |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | "__defaults__" | A tuple containing default | '
+ 'Writable |\n'
+ ' | "func_defaults" | argument values for those '
+ '| |\n'
+ ' | | arguments that have defaults, '
+ '| |\n'
+ ' | | or "None" if no arguments have '
+ '| |\n'
+ ' | | a default value. '
+ '| |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | "__code__" "func_code" | The code object representing | '
+ 'Writable |\n'
+ ' | | the compiled function body. '
+ '| |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | "__globals__" | A reference to the dictionary | '
+ 'Read-only |\n'
+ ' | "func_globals" | that holds the function\'s '
+ '| |\n'
+ ' | | global variables --- the global '
+ '| |\n'
+ ' | | namespace of the module in '
+ '| |\n'
+ ' | | which the function was defined. '
+ '| |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | "__dict__" "func_dict" | The namespace supporting | '
+ 'Writable |\n'
+ ' | | arbitrary function attributes. '
+ '| |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ ' | "__closure__" | "None" or a tuple of cells that | '
+ 'Read-only |\n'
+ ' | "func_closure" | contain bindings for the '
+ '| |\n'
+ " | | function's free variables. "
+ '| |\n'
+ ' '
+ '+-------------------------+---------------------------------+-------------+\n'
+ '\n'
+ ' Most of the attributes labelled "Writable" check the type of '
+ 'the\n'
+ ' assigned value.\n'
+ '\n'
+ ' Changed in version 2.4: "func_name" is now writable.\n'
+ '\n'
+ ' Changed in version 2.6: The double-underscore attributes\n'
+ ' "__closure__", "__code__", "__defaults__", and "__globals__"\n'
+ ' were introduced as aliases for the corresponding "func_*"\n'
+ ' attributes for forwards compatibility with Python 3.\n'
+ '\n'
+ ' Function objects also support getting and setting arbitrary\n'
+ ' attributes, which can be used, for example, to attach '
+ 'metadata\n'
+ ' to functions. Regular attribute dot-notation is used to get '
+ 'and\n'
+ ' set such attributes. *Note that the current implementation '
+ 'only\n'
+ ' supports function attributes on user-defined functions. '
+ 'Function\n'
+ ' attributes on built-in functions may be supported in the\n'
+ ' future.*\n'
+ '\n'
+ " Additional information about a function's definition can be\n"
+ ' retrieved from its code object; see the description of '
+ 'internal\n'
+ ' types below.\n'
+ '\n'
+ ' User-defined methods\n'
+ ' A user-defined method object combines a class, a class '
+ 'instance\n'
+ ' (or "None") and any callable object (normally a user-defined\n'
+ ' function).\n'
+ '\n'
+ ' Special read-only attributes: "im_self" is the class '
+ 'instance\n'
+ ' object, "im_func" is the function object; "im_class" is the\n'
+ ' class of "im_self" for bound methods or the class that asked '
+ 'for\n'
+ ' the method for unbound methods; "__doc__" is the method\'s\n'
+ ' documentation (same as "im_func.__doc__"); "__name__" is the\n'
+ ' method name (same as "im_func.__name__"); "__module__" is '
+ 'the\n'
+ ' name of the module the method was defined in, or "None" if\n'
+ ' unavailable.\n'
+ '\n'
+ ' Changed in version 2.2: "im_self" used to refer to the class\n'
+ ' that defined the method.\n'
+ '\n'
+ ' Changed in version 2.6: For Python 3 forward-compatibility,\n'
+ ' "im_func" is also available as "__func__", and "im_self" as\n'
+ ' "__self__".\n'
+ '\n'
+ ' Methods also support accessing (but not setting) the '
+ 'arbitrary\n'
+ ' function attributes on the underlying function object.\n'
+ '\n'
+ ' User-defined method objects may be created when getting an\n'
+ ' attribute of a class (perhaps via an instance of that class), '
+ 'if\n'
+ ' that attribute is a user-defined function object, an unbound\n'
+ ' user-defined method object, or a class method object. When '
+ 'the\n'
+ ' attribute is a user-defined method object, a new method '
+ 'object\n'
+ ' is only created if the class from which it is being retrieved '
+ 'is\n'
+ ' the same as, or a derived class of, the class stored in the\n'
+ ' original method object; otherwise, the original method object '
+ 'is\n'
+ ' used as it is.\n'
+ '\n'
+ ' When a user-defined method object is created by retrieving a\n'
+ ' user-defined function object from a class, its "im_self"\n'
+ ' attribute is "None" and the method object is said to be '
+ 'unbound.\n'
+ ' When one is created by retrieving a user-defined function '
+ 'object\n'
+ ' from a class via one of its instances, its "im_self" '
+ 'attribute\n'
+ ' is the instance, and the method object is said to be bound. '
+ 'In\n'
+ ' either case, the new method\'s "im_class" attribute is the '
+ 'class\n'
+ ' from which the retrieval takes place, and its "im_func"\n'
+ ' attribute is the original function object.\n'
+ '\n'
+ ' When a user-defined method object is created by retrieving\n'
+ ' another method object from a class or instance, the behaviour '
+ 'is\n'
+ ' the same as for a function object, except that the "im_func"\n'
+ ' attribute of the new instance is not the original method '
+ 'object\n'
+ ' but its "im_func" attribute.\n'
+ '\n'
+ ' When a user-defined method object is created by retrieving a\n'
+ ' class method object from a class or instance, its "im_self"\n'
+ ' attribute is the class itself, and its "im_func" attribute '
+ 'is\n'
+ ' the function object underlying the class method.\n'
+ '\n'
+ ' When an unbound user-defined method object is called, the\n'
+ ' underlying function ("im_func") is called, with the '
+ 'restriction\n'
+ ' that the first argument must be an instance of the proper '
+ 'class\n'
+ ' ("im_class") or of a derived class thereof.\n'
+ '\n'
+ ' When a bound user-defined method object is called, the\n'
+ ' underlying function ("im_func") is called, inserting the '
+ 'class\n'
+ ' instance ("im_self") in front of the argument list. For\n'
+ ' instance, when "C" is a class which contains a definition for '
+ 'a\n'
+ ' function "f()", and "x" is an instance of "C", calling '
+ '"x.f(1)"\n'
+ ' is equivalent to calling "C.f(x, 1)".\n'
+ '\n'
+ ' When a user-defined method object is derived from a class '
+ 'method\n'
+ ' object, the "class instance" stored in "im_self" will '
+ 'actually\n'
+ ' be the class itself, so that calling either "x.f(1)" or '
+ '"C.f(1)"\n'
+ ' is equivalent to calling "f(C,1)" where "f" is the '
+ 'underlying\n'
+ ' function.\n'
+ '\n'
+ ' Note that the transformation from function object to (unbound '
+ 'or\n'
+ ' bound) method object happens each time the attribute is\n'
+ ' retrieved from the class or instance. In some cases, a '
+ 'fruitful\n'
+ ' optimization is to assign the attribute to a local variable '
+ 'and\n'
+ ' call that local variable. Also notice that this '
+ 'transformation\n'
+ ' only happens for user-defined functions; other callable '
+ 'objects\n'
+ ' (and all non-callable objects) are retrieved without\n'
+ ' transformation. It is also important to note that '
+ 'user-defined\n'
+ ' functions which are attributes of a class instance are not\n'
+ ' converted to bound methods; this *only* happens when the\n'
+ ' function is an attribute of the class.\n'
+ '\n'
+ ' Generator functions\n'
+ ' A function or method which uses the "yield" statement (see\n'
+ ' section The yield statement) is called a *generator '
+ 'function*.\n'
+ ' Such a function, when called, always returns an iterator '
+ 'object\n'
+ ' which can be used to execute the body of the function: '
+ 'calling\n'
+ ' the iterator\'s "next()" method will cause the function to\n'
+ ' execute until it provides a value using the "yield" '
+ 'statement.\n'
+ ' When the function executes a "return" statement or falls off '
+ 'the\n'
+ ' end, a "StopIteration" exception is raised and the iterator '
+ 'will\n'
+ ' have reached the end of the set of values to be returned.\n'
+ '\n'
+ ' Built-in functions\n'
+ ' A built-in function object is a wrapper around a C function.\n'
+ ' Examples of built-in functions are "len()" and "math.sin()"\n'
+ ' ("math" is a standard built-in module). The number and type '
+ 'of\n'
+ ' the arguments are determined by the C function. Special '
+ 'read-\n'
+ ' only attributes: "__doc__" is the function\'s documentation\n'
+ ' string, or "None" if unavailable; "__name__" is the '
+ "function's\n"
+ ' name; "__self__" is set to "None" (but see the next item);\n'
+ ' "__module__" is the name of the module the function was '
+ 'defined\n'
+ ' in or "None" if unavailable.\n'
+ '\n'
+ ' Built-in methods\n'
+ ' This is really a different disguise of a built-in function, '
+ 'this\n'
+ ' time containing an object passed to the C function as an\n'
+ ' implicit extra argument. An example of a built-in method is\n'
+ ' "alist.append()", assuming *alist* is a list object. In this\n'
+ ' case, the special read-only attribute "__self__" is set to '
+ 'the\n'
+ ' object denoted by *alist*.\n'
+ '\n'
+ ' Class Types\n'
+ ' Class types, or "new-style classes," are callable. These\n'
+ ' objects normally act as factories for new instances of\n'
+ ' themselves, but variations are possible for class types that\n'
+ ' override "__new__()". The arguments of the call are passed '
+ 'to\n'
+ ' "__new__()" and, in the typical case, to "__init__()" to\n'
+ ' initialize the new instance.\n'
+ '\n'
+ ' Classic Classes\n'
+ ' Class objects are described below. When a class object is\n'
+ ' called, a new class instance (also described below) is '
+ 'created\n'
+ " and returned. This implies a call to the class's "
+ '"__init__()"\n'
+ ' method if it has one. Any arguments are passed on to the\n'
+ ' "__init__()" method. If there is no "__init__()" method, '
+ 'the\n'
+ ' class must be called without arguments.\n'
+ '\n'
+ ' Class instances\n'
+ ' Class instances are described below. Class instances are\n'
+ ' callable only when the class has a "__call__()" method;\n'
+ ' "x(arguments)" is a shorthand for "x.__call__(arguments)".\n'
+ '\n'
+ 'Modules\n'
+ ' Modules are imported by the "import" statement (see section The\n'
+ ' import statement). A module object has a namespace implemented '
+ 'by a\n'
+ ' dictionary object (this is the dictionary referenced by the\n'
+ ' func_globals attribute of functions defined in the module).\n'
+ ' Attribute references are translated to lookups in this '
+ 'dictionary,\n'
+ ' e.g., "m.x" is equivalent to "m.__dict__["x"]". A module object\n'
+ ' does not contain the code object used to initialize the module\n'
+ " (since it isn't needed once the initialization is done).\n"
+ '\n'
+ " Attribute assignment updates the module's namespace dictionary,\n"
+ ' e.g., "m.x = 1" is equivalent to "m.__dict__["x"] = 1".\n'
+ '\n'
+ ' Special read-only attribute: "__dict__" is the module\'s '
+ 'namespace\n'
+ ' as a dictionary object.\n'
+ '\n'
+ ' **CPython implementation detail:** Because of the way CPython\n'
+ ' clears module dictionaries, the module dictionary will be '
+ 'cleared\n'
+ ' when the module falls out of scope even if the dictionary still '
+ 'has\n'
+ ' live references. To avoid this, copy the dictionary or keep '
+ 'the\n'
+ ' module around while using its dictionary directly.\n'
+ '\n'
+ ' Predefined (writable) attributes: "__name__" is the module\'s '
+ 'name;\n'
+ ' "__doc__" is the module\'s documentation string, or "None" if\n'
+ ' unavailable; "__file__" is the pathname of the file from which '
+ 'the\n'
+ ' module was loaded, if it was loaded from a file. The "__file__"\n'
+ ' attribute is not present for C modules that are statically '
+ 'linked\n'
+ ' into the interpreter; for extension modules loaded dynamically '
+ 'from\n'
+ ' a shared library, it is the pathname of the shared library '
+ 'file.\n'
+ '\n'
+ 'Classes\n'
+ ' Both class types (new-style classes) and class objects (old-\n'
+ ' style/classic classes) are typically created by class '
+ 'definitions\n'
+ ' (see section Class definitions). A class has a namespace\n'
+ ' implemented by a dictionary object. Class attribute references '
+ 'are\n'
+ ' translated to lookups in this dictionary, e.g., "C.x" is '
+ 'translated\n'
+ ' to "C.__dict__["x"]" (although for new-style classes in '
+ 'particular\n'
+ ' there are a number of hooks which allow for other means of '
+ 'locating\n'
+ ' attributes). When the attribute name is not found there, the\n'
+ ' attribute search continues in the base classes. For old-style\n'
+ ' classes, the search is depth-first, left-to-right in the order '
+ 'of\n'
+ ' occurrence in the base class list. New-style classes use the '
+ 'more\n'
+ ' complex C3 method resolution order which behaves correctly even '
+ 'in\n'
+ " the presence of 'diamond' inheritance structures where there "
+ 'are\n'
+ ' multiple inheritance paths leading back to a common ancestor.\n'
+ ' Additional details on the C3 MRO used by new-style classes can '
+ 'be\n'
+ ' found in the documentation accompanying the 2.3 release at\n'
+ ' https://www.python.org/download/releases/2.3/mro/.\n'
+ '\n'
+ ' When a class attribute reference (for class "C", say) would '
+ 'yield a\n'
+ ' user-defined function object or an unbound user-defined method\n'
+ ' object whose associated class is either "C" or one of its base\n'
+ ' classes, it is transformed into an unbound user-defined method\n'
+ ' object whose "im_class" attribute is "C". When it would yield a\n'
+ ' class method object, it is transformed into a bound '
+ 'user-defined\n'
+ ' method object whose "im_self" attribute is "C". When it would\n'
+ ' yield a static method object, it is transformed into the object\n'
+ ' wrapped by the static method object. See section Implementing\n'
+ ' Descriptors for another way in which attributes retrieved from '
+ 'a\n'
+ ' class may differ from those actually contained in its '
+ '"__dict__"\n'
+ ' (note that only new-style classes support descriptors).\n'
+ '\n'
+ " Class attribute assignments update the class's dictionary, "
+ 'never\n'
+ ' the dictionary of a base class.\n'
+ '\n'
+ ' A class object can be called (see above) to yield a class '
+ 'instance\n'
+ ' (see below).\n'
+ '\n'
+ ' Special attributes: "__name__" is the class name; "__module__" '
+ 'is\n'
+ ' the module name in which the class was defined; "__dict__" is '
+ 'the\n'
+ ' dictionary containing the class\'s namespace; "__bases__" is a '
+ 'tuple\n'
+ ' (possibly empty or a singleton) containing the base classes, in '
+ 'the\n'
+ ' order of their occurrence in the base class list; "__doc__" is '
+ 'the\n'
+ ' class\'s documentation string, or "None" if undefined.\n'
+ '\n'
+ 'Class instances\n'
+ ' A class instance is created by calling a class object (see '
+ 'above).\n'
+ ' A class instance has a namespace implemented as a dictionary '
+ 'which\n'
+ ' is the first place in which attribute references are searched.\n'
+ " When an attribute is not found there, and the instance's class "
+ 'has\n'
+ ' an attribute by that name, the search continues with the class\n'
+ ' attributes. If a class attribute is found that is a '
+ 'user-defined\n'
+ ' function object or an unbound user-defined method object whose\n'
+ ' associated class is the class (call it "C") of the instance for\n'
+ ' which the attribute reference was initiated or one of its bases, '
+ 'it\n'
+ ' is transformed into a bound user-defined method object whose\n'
+ ' "im_class" attribute is "C" and whose "im_self" attribute is '
+ 'the\n'
+ ' instance. Static method and class method objects are also\n'
+ ' transformed, as if they had been retrieved from class "C"; see\n'
+ ' above under "Classes". See section Implementing Descriptors for\n'
+ ' another way in which attributes of a class retrieved via its\n'
+ ' instances may differ from the objects actually stored in the\n'
+ ' class\'s "__dict__". If no class attribute is found, and the\n'
+ ' object\'s class has a "__getattr__()" method, that is called to\n'
+ ' satisfy the lookup.\n'
+ '\n'
+ " Attribute assignments and deletions update the instance's\n"
+ " dictionary, never a class's dictionary. If the class has a\n"
+ ' "__setattr__()" or "__delattr__()" method, this is called '
+ 'instead\n'
+ ' of updating the instance dictionary directly.\n'
+ '\n'
+ ' Class instances can pretend to be numbers, sequences, or '
+ 'mappings\n'
+ ' if they have methods with certain special names. See section\n'
+ ' Special method names.\n'
+ '\n'
+ ' Special attributes: "__dict__" is the attribute dictionary;\n'
+ ' "__class__" is the instance\'s class.\n'
+ '\n'
+ 'Files\n'
+ ' A file object represents an open file. File objects are created '
+ 'by\n'
+ ' the "open()" built-in function, and also by "os.popen()",\n'
+ ' "os.fdopen()", and the "makefile()" method of socket objects '
+ '(and\n'
+ ' perhaps by other functions or methods provided by extension\n'
+ ' modules). The objects "sys.stdin", "sys.stdout" and '
+ '"sys.stderr"\n'
+ ' are initialized to file objects corresponding to the '
+ "interpreter's\n"
+ ' standard input, output and error streams. See File Objects for\n'
+ ' complete documentation of file objects.\n'
+ '\n'
+ 'Internal types\n'
+ ' A few types used internally by the interpreter are exposed to '
+ 'the\n'
+ ' user. Their definitions may change with future versions of the\n'
+ ' interpreter, but they are mentioned here for completeness.\n'
+ '\n'
+ ' Code objects\n'
+ ' Code objects represent *byte-compiled* executable Python '
+ 'code,\n'
+ ' or *bytecode*. The difference between a code object and a\n'
+ ' function object is that the function object contains an '
+ 'explicit\n'
+ " reference to the function's globals (the module in which it "
+ 'was\n'
+ ' defined), while a code object contains no context; also the\n'
+ ' default argument values are stored in the function object, '
+ 'not\n'
+ ' in the code object (because they represent values calculated '
+ 'at\n'
+ ' run-time). Unlike function objects, code objects are '
+ 'immutable\n'
+ ' and contain no references (directly or indirectly) to '
+ 'mutable\n'
+ ' objects.\n'
+ '\n'
+ ' Special read-only attributes: "co_name" gives the function '
+ 'name;\n'
+ ' "co_argcount" is the number of positional arguments '
+ '(including\n'
+ ' arguments with default values); "co_nlocals" is the number '
+ 'of\n'
+ ' local variables used by the function (including arguments);\n'
+ ' "co_varnames" is a tuple containing the names of the local\n'
+ ' variables (starting with the argument names); "co_cellvars" '
+ 'is a\n'
+ ' tuple containing the names of local variables that are\n'
+ ' referenced by nested functions; "co_freevars" is a tuple\n'
+ ' containing the names of free variables; "co_code" is a '
+ 'string\n'
+ ' representing the sequence of bytecode instructions; '
+ '"co_consts"\n'
+ ' is a tuple containing the literals used by the bytecode;\n'
+ ' "co_names" is a tuple containing the names used by the '
+ 'bytecode;\n'
+ ' "co_filename" is the filename from which the code was '
+ 'compiled;\n'
+ ' "co_firstlineno" is the first line number of the function;\n'
+ ' "co_lnotab" is a string encoding the mapping from bytecode\n'
+ ' offsets to line numbers (for details see the source code of '
+ 'the\n'
+ ' interpreter); "co_stacksize" is the required stack size\n'
+ ' (including local variables); "co_flags" is an integer '
+ 'encoding a\n'
+ ' number of flags for the interpreter.\n'
+ '\n'
+ ' The following flag bits are defined for "co_flags": bit '
+ '"0x04"\n'
+ ' is set if the function uses the "*arguments" syntax to accept '
+ 'an\n'
+ ' arbitrary number of positional arguments; bit "0x08" is set '
+ 'if\n'
+ ' the function uses the "**keywords" syntax to accept '
+ 'arbitrary\n'
+ ' keyword arguments; bit "0x20" is set if the function is a\n'
+ ' generator.\n'
+ '\n'
+ ' Future feature declarations ("from __future__ import '
+ 'division")\n'
+ ' also use bits in "co_flags" to indicate whether a code '
+ 'object\n'
+ ' was compiled with a particular feature enabled: bit "0x2000" '
+ 'is\n'
+ ' set if the function was compiled with future division '
+ 'enabled;\n'
+ ' bits "0x10" and "0x1000" were used in earlier versions of\n'
+ ' Python.\n'
+ '\n'
+ ' Other bits in "co_flags" are reserved for internal use.\n'
+ '\n'
+ ' If a code object represents a function, the first item in\n'
+ ' "co_consts" is the documentation string of the function, or\n'
+ ' "None" if undefined.\n'
+ '\n'
+ ' Frame objects\n'
+ ' Frame objects represent execution frames. They may occur in\n'
+ ' traceback objects (see below).\n'
+ '\n'
+ ' Special read-only attributes: "f_back" is to the previous '
+ 'stack\n'
+ ' frame (towards the caller), or "None" if this is the bottom\n'
+ ' stack frame; "f_code" is the code object being executed in '
+ 'this\n'
+ ' frame; "f_locals" is the dictionary used to look up local\n'
+ ' variables; "f_globals" is used for global variables;\n'
+ ' "f_builtins" is used for built-in (intrinsic) names;\n'
+ ' "f_restricted" is a flag indicating whether the function is\n'
+ ' executing in restricted execution mode; "f_lasti" gives the\n'
+ ' precise instruction (this is an index into the bytecode '
+ 'string\n'
+ ' of the code object).\n'
+ '\n'
+ ' Special writable attributes: "f_trace", if not "None", is a\n'
+ ' function called at the start of each source code line (this '
+ 'is\n'
+ ' used by the debugger); "f_exc_type", "f_exc_value",\n'
+ ' "f_exc_traceback" represent the last exception raised in the\n'
+ ' parent frame provided another exception was ever raised in '
+ 'the\n'
+ ' current frame (in all other cases they are "None"); '
+ '"f_lineno"\n'
+ ' is the current line number of the frame --- writing to this '
+ 'from\n'
+ ' within a trace function jumps to the given line (only for '
+ 'the\n'
+ ' bottom-most frame). A debugger can implement a Jump command\n'
+ ' (aka Set Next Statement) by writing to f_lineno.\n'
+ '\n'
+ ' Traceback objects\n'
+ ' Traceback objects represent a stack trace of an exception. '
+ 'A\n'
+ ' traceback object is created when an exception occurs. When '
+ 'the\n'
+ ' search for an exception handler unwinds the execution stack, '
+ 'at\n'
+ ' each unwound level a traceback object is inserted in front '
+ 'of\n'
+ ' the current traceback. When an exception handler is '
+ 'entered,\n'
+ ' the stack trace is made available to the program. (See '
+ 'section\n'
+ ' The try statement.) It is accessible as "sys.exc_traceback", '
+ 'and\n'
+ ' also as the third item of the tuple returned by\n'
+ ' "sys.exc_info()". The latter is the preferred interface, '
+ 'since\n'
+ ' it works correctly when the program is using multiple '
+ 'threads.\n'
+ ' When the program contains no suitable handler, the stack '
+ 'trace\n'
+ ' is written (nicely formatted) to the standard error stream; '
+ 'if\n'
+ ' the interpreter is interactive, it is also made available to '
+ 'the\n'
+ ' user as "sys.last_traceback".\n'
+ '\n'
+ ' Special read-only attributes: "tb_next" is the next level in '
+ 'the\n'
+ ' stack trace (towards the frame where the exception occurred), '
+ 'or\n'
+ ' "None" if there is no next level; "tb_frame" points to the\n'
+ ' execution frame of the current level; "tb_lineno" gives the '
+ 'line\n'
+ ' number where the exception occurred; "tb_lasti" indicates '
+ 'the\n'
+ ' precise instruction. The line number and last instruction '
+ 'in\n'
+ ' the traceback may differ from the line number of its frame\n'
+ ' object if the exception occurred in a "try" statement with '
+ 'no\n'
+ ' matching except clause or with a finally clause.\n'
+ '\n'
+ ' Slice objects\n'
+ ' Slice objects are used to represent slices when *extended '
+ 'slice\n'
+ ' syntax* is used. This is a slice using two colons, or '
+ 'multiple\n'
+ ' slices or ellipses separated by commas, e.g., "a[i:j:step]",\n'
+ ' "a[i:j, k:l]", or "a[..., i:j]". They are also created by '
+ 'the\n'
+ ' built-in "slice()" function.\n'
+ '\n'
+ ' Special read-only attributes: "start" is the lower bound; '
+ '"stop"\n'
+ ' is the upper bound; "step" is the step value; each is "None" '
+ 'if\n'
+ ' omitted. These attributes can have any type.\n'
+ '\n'
+ ' Slice objects support one method:\n'
+ '\n'
+ ' slice.indices(self, length)\n'
+ '\n'
+ ' This method takes a single integer argument *length* and\n'
+ ' computes information about the extended slice that the '
+ 'slice\n'
+ ' object would describe if applied to a sequence of '
+ '*length*\n'
+ ' items. It returns a tuple of three integers; '
+ 'respectively\n'
+ ' these are the *start* and *stop* indices and the *step* '
+ 'or\n'
+ ' stride length of the slice. Missing or out-of-bounds '
+ 'indices\n'
+ ' are handled in a manner consistent with regular slices.\n'
+ '\n'
+ ' New in version 2.3.\n'
+ '\n'
+ ' Static method objects\n'
+ ' Static method objects provide a way of defeating the\n'
+ ' transformation of function objects to method objects '
+ 'described\n'
+ ' above. A static method object is a wrapper around any other\n'
+ ' object, usually a user-defined method object. When a static\n'
+ ' method object is retrieved from a class or a class instance, '
+ 'the\n'
+ ' object actually returned is the wrapped object, which is not\n'
+ ' subject to any further transformation. Static method objects '
+ 'are\n'
+ ' not themselves callable, although the objects they wrap '
+ 'usually\n'
+ ' are. Static method objects are created by the built-in\n'
+ ' "staticmethod()" constructor.\n'
+ '\n'
+ ' Class method objects\n'
+ ' A class method object, like a static method object, is a '
+ 'wrapper\n'
+ ' around another object that alters the way in which that '
+ 'object\n'
+ ' is retrieved from classes and class instances. The behaviour '
+ 'of\n'
+ ' class method objects upon such retrieval is described above,\n'
+ ' under "User-defined methods". Class method objects are '
+ 'created\n'
+ ' by the built-in "classmethod()" constructor.\n',
+ 'typesfunctions': '\n'
+ 'Functions\n'
+ '*********\n'
+ '\n'
+ 'Function objects are created by function definitions. The '
+ 'only\n'
+ 'operation on a function object is to call it: '
+ '"func(argument-list)".\n'
+ '\n'
+ 'There are really two flavors of function objects: built-in '
+ 'functions\n'
+ 'and user-defined functions. Both support the same '
+ 'operation (to call\n'
+ 'the function), but the implementation is different, hence '
+ 'the\n'
+ 'different object types.\n'
+ '\n'
+ 'See Function definitions for more information.\n',
+ 'typesmapping': '\n'
+ 'Mapping Types --- "dict"\n'
+ '************************\n'
+ '\n'
+ 'A *mapping* object maps *hashable* values to arbitrary '
+ 'objects.\n'
+ 'Mappings are mutable objects. There is currently only one '
+ 'standard\n'
+ 'mapping type, the *dictionary*. (For other containers see '
+ 'the built\n'
+ 'in "list", "set", and "tuple" classes, and the "collections" '
+ 'module.)\n'
+ '\n'
+ "A dictionary's keys are *almost* arbitrary values. Values "
+ 'that are\n'
+ 'not *hashable*, that is, values containing lists, '
+ 'dictionaries or\n'
+ 'other mutable types (that are compared by value rather than '
+ 'by object\n'
+ 'identity) may not be used as keys. Numeric types used for '
+ 'keys obey\n'
+ 'the normal rules for numeric comparison: if two numbers '
+ 'compare equal\n'
+ '(such as "1" and "1.0") then they can be used '
+ 'interchangeably to index\n'
+ 'the same dictionary entry. (Note however, that since '
+ 'computers store\n'
+ 'floating-point numbers as approximations it is usually '
+ 'unwise to use\n'
+ 'them as dictionary keys.)\n'
+ '\n'
+ 'Dictionaries can be created by placing a comma-separated '
+ 'list of "key:\n'
+ 'value" pairs within braces, for example: "{\'jack\': 4098, '
+ "'sjoerd':\n"
+ '4127}" or "{4098: \'jack\', 4127: \'sjoerd\'}", or by the '
+ '"dict"\n'
+ 'constructor.\n'
+ '\n'
+ 'class dict(**kwarg)\n'
+ 'class dict(mapping, **kwarg)\n'
+ 'class dict(iterable, **kwarg)\n'
+ '\n'
+ ' Return a new dictionary initialized from an optional '
+ 'positional\n'
+ ' argument and a possibly empty set of keyword arguments.\n'
+ '\n'
+ ' If no positional argument is given, an empty dictionary '
+ 'is created.\n'
+ ' If a positional argument is given and it is a mapping '
+ 'object, a\n'
+ ' dictionary is created with the same key-value pairs as '
+ 'the mapping\n'
+ ' object. Otherwise, the positional argument must be an '
+ '*iterable*\n'
+ ' object. Each item in the iterable must itself be an '
+ 'iterable with\n'
+ ' exactly two objects. The first object of each item '
+ 'becomes a key\n'
+ ' in the new dictionary, and the second object the '
+ 'corresponding\n'
+ ' value. If a key occurs more than once, the last value '
+ 'for that key\n'
+ ' becomes the corresponding value in the new dictionary.\n'
+ '\n'
+ ' If keyword arguments are given, the keyword arguments and '
+ 'their\n'
+ ' values are added to the dictionary created from the '
+ 'positional\n'
+ ' argument. If a key being added is already present, the '
+ 'value from\n'
+ ' the keyword argument replaces the value from the '
+ 'positional\n'
+ ' argument.\n'
+ '\n'
+ ' To illustrate, the following examples all return a '
+ 'dictionary equal\n'
+ ' to "{"one": 1, "two": 2, "three": 3}":\n'
+ '\n'
+ ' >>> a = dict(one=1, two=2, three=3)\n'
+ " >>> b = {'one': 1, 'two': 2, 'three': 3}\n"
+ " >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))\n"
+ " >>> d = dict([('two', 2), ('one', 1), ('three', 3)])\n"
+ " >>> e = dict({'three': 3, 'one': 1, 'two': 2})\n"
+ ' >>> a == b == c == d == e\n'
+ ' True\n'
+ '\n'
+ ' Providing keyword arguments as in the first example only '
+ 'works for\n'
+ ' keys that are valid Python identifiers. Otherwise, any '
+ 'valid keys\n'
+ ' can be used.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' Changed in version 2.3: Support for building a dictionary '
+ 'from\n'
+ ' keyword arguments added.\n'
+ '\n'
+ ' These are the operations that dictionaries support (and '
+ 'therefore,\n'
+ ' custom mapping types should support too):\n'
+ '\n'
+ ' len(d)\n'
+ '\n'
+ ' Return the number of items in the dictionary *d*.\n'
+ '\n'
+ ' d[key]\n'
+ '\n'
+ ' Return the item of *d* with key *key*. Raises a '
+ '"KeyError" if\n'
+ ' *key* is not in the map.\n'
+ '\n'
+ ' If a subclass of dict defines a method "__missing__()" '
+ 'and *key*\n'
+ ' is not present, the "d[key]" operation calls that '
+ 'method with\n'
+ ' the key *key* as argument. The "d[key]" operation '
+ 'then returns\n'
+ ' or raises whatever is returned or raised by the\n'
+ ' "__missing__(key)" call. No other operations or '
+ 'methods invoke\n'
+ ' "__missing__()". If "__missing__()" is not defined, '
+ '"KeyError"\n'
+ ' is raised. "__missing__()" must be a method; it cannot '
+ 'be an\n'
+ ' instance variable:\n'
+ '\n'
+ ' >>> class Counter(dict):\n'
+ ' ... def __missing__(self, key):\n'
+ ' ... return 0\n'
+ ' >>> c = Counter()\n'
+ " >>> c['red']\n"
+ ' 0\n'
+ " >>> c['red'] += 1\n"
+ " >>> c['red']\n"
+ ' 1\n'
+ '\n'
+ ' The example above shows part of the implementation of\n'
+ ' "collections.Counter". A different "__missing__" '
+ 'method is used\n'
+ ' by "collections.defaultdict".\n'
+ '\n'
+ ' New in version 2.5: Recognition of __missing__ methods '
+ 'of dict\n'
+ ' subclasses.\n'
+ '\n'
+ ' d[key] = value\n'
+ '\n'
+ ' Set "d[key]" to *value*.\n'
+ '\n'
+ ' del d[key]\n'
+ '\n'
+ ' Remove "d[key]" from *d*. Raises a "KeyError" if '
+ '*key* is not\n'
+ ' in the map.\n'
+ '\n'
+ ' key in d\n'
+ '\n'
+ ' Return "True" if *d* has a key *key*, else "False".\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' key not in d\n'
+ '\n'
+ ' Equivalent to "not key in d".\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' iter(d)\n'
+ '\n'
+ ' Return an iterator over the keys of the dictionary. '
+ 'This is a\n'
+ ' shortcut for "iterkeys()".\n'
+ '\n'
+ ' clear()\n'
+ '\n'
+ ' Remove all items from the dictionary.\n'
+ '\n'
+ ' copy()\n'
+ '\n'
+ ' Return a shallow copy of the dictionary.\n'
+ '\n'
+ ' fromkeys(seq[, value])\n'
+ '\n'
+ ' Create a new dictionary with keys from *seq* and '
+ 'values set to\n'
+ ' *value*.\n'
+ '\n'
+ ' "fromkeys()" is a class method that returns a new '
+ 'dictionary.\n'
+ ' *value* defaults to "None".\n'
+ '\n'
+ ' New in version 2.3.\n'
+ '\n'
+ ' get(key[, default])\n'
+ '\n'
+ ' Return the value for *key* if *key* is in the '
+ 'dictionary, else\n'
+ ' *default*. If *default* is not given, it defaults to '
+ '"None", so\n'
+ ' that this method never raises a "KeyError".\n'
+ '\n'
+ ' has_key(key)\n'
+ '\n'
+ ' Test for the presence of *key* in the dictionary. '
+ '"has_key()"\n'
+ ' is deprecated in favor of "key in d".\n'
+ '\n'
+ ' items()\n'
+ '\n'
+ ' Return a copy of the dictionary\'s list of "(key, '
+ 'value)" pairs.\n'
+ '\n'
+ ' **CPython implementation detail:** Keys and values are '
+ 'listed in\n'
+ ' an arbitrary order which is non-random, varies across '
+ 'Python\n'
+ " implementations, and depends on the dictionary's "
+ 'history of\n'
+ ' insertions and deletions.\n'
+ '\n'
+ ' If "items()", "keys()", "values()", "iteritems()", '
+ '"iterkeys()",\n'
+ ' and "itervalues()" are called with no intervening '
+ 'modifications\n'
+ ' to the dictionary, the lists will directly '
+ 'correspond. This\n'
+ ' allows the creation of "(value, key)" pairs using '
+ '"zip()":\n'
+ ' "pairs = zip(d.values(), d.keys())". The same '
+ 'relationship\n'
+ ' holds for the "iterkeys()" and "itervalues()" methods: '
+ '"pairs =\n'
+ ' zip(d.itervalues(), d.iterkeys())" provides the same '
+ 'value for\n'
+ ' "pairs". Another way to create the same list is "pairs '
+ '= [(v, k)\n'
+ ' for (k, v) in d.iteritems()]".\n'
+ '\n'
+ ' iteritems()\n'
+ '\n'
+ ' Return an iterator over the dictionary\'s "(key, '
+ 'value)" pairs.\n'
+ ' See the note for "dict.items()".\n'
+ '\n'
+ ' Using "iteritems()" while adding or deleting entries '
+ 'in the\n'
+ ' dictionary may raise a "RuntimeError" or fail to '
+ 'iterate over\n'
+ ' all entries.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' iterkeys()\n'
+ '\n'
+ " Return an iterator over the dictionary's keys. See "
+ 'the note for\n'
+ ' "dict.items()".\n'
+ '\n'
+ ' Using "iterkeys()" while adding or deleting entries in '
+ 'the\n'
+ ' dictionary may raise a "RuntimeError" or fail to '
+ 'iterate over\n'
+ ' all entries.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' itervalues()\n'
+ '\n'
+ " Return an iterator over the dictionary's values. See "
+ 'the note\n'
+ ' for "dict.items()".\n'
+ '\n'
+ ' Using "itervalues()" while adding or deleting entries '
+ 'in the\n'
+ ' dictionary may raise a "RuntimeError" or fail to '
+ 'iterate over\n'
+ ' all entries.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' keys()\n'
+ '\n'
+ " Return a copy of the dictionary's list of keys. See "
+ 'the note\n'
+ ' for "dict.items()".\n'
+ '\n'
+ ' pop(key[, default])\n'
+ '\n'
+ ' If *key* is in the dictionary, remove it and return '
+ 'its value,\n'
+ ' else return *default*. If *default* is not given and '
+ '*key* is\n'
+ ' not in the dictionary, a "KeyError" is raised.\n'
+ '\n'
+ ' New in version 2.3.\n'
+ '\n'
+ ' popitem()\n'
+ '\n'
+ ' Remove and return an arbitrary "(key, value)" pair '
+ 'from the\n'
+ ' dictionary.\n'
+ '\n'
+ ' "popitem()" is useful to destructively iterate over a\n'
+ ' dictionary, as often used in set algorithms. If the '
+ 'dictionary\n'
+ ' is empty, calling "popitem()" raises a "KeyError".\n'
+ '\n'
+ ' setdefault(key[, default])\n'
+ '\n'
+ ' If *key* is in the dictionary, return its value. If '
+ 'not, insert\n'
+ ' *key* with a value of *default* and return *default*. '
+ '*default*\n'
+ ' defaults to "None".\n'
+ '\n'
+ ' update([other])\n'
+ '\n'
+ ' Update the dictionary with the key/value pairs from '
+ '*other*,\n'
+ ' overwriting existing keys. Return "None".\n'
+ '\n'
+ ' "update()" accepts either another dictionary object or '
+ 'an\n'
+ ' iterable of key/value pairs (as tuples or other '
+ 'iterables of\n'
+ ' length two). If keyword arguments are specified, the '
+ 'dictionary\n'
+ ' is then updated with those key/value pairs: '
+ '"d.update(red=1,\n'
+ ' blue=2)".\n'
+ '\n'
+ ' Changed in version 2.4: Allowed the argument to be an '
+ 'iterable\n'
+ ' of key/value pairs and allowed keyword arguments.\n'
+ '\n'
+ ' values()\n'
+ '\n'
+ " Return a copy of the dictionary's list of values. See "
+ 'the note\n'
+ ' for "dict.items()".\n'
+ '\n'
+ ' viewitems()\n'
+ '\n'
+ ' Return a new view of the dictionary\'s items ("(key, '
+ 'value)"\n'
+ ' pairs). See below for documentation of view objects.\n'
+ '\n'
+ ' New in version 2.7.\n'
+ '\n'
+ ' viewkeys()\n'
+ '\n'
+ " Return a new view of the dictionary's keys. See below "
+ 'for\n'
+ ' documentation of view objects.\n'
+ '\n'
+ ' New in version 2.7.\n'
+ '\n'
+ ' viewvalues()\n'
+ '\n'
+ " Return a new view of the dictionary's values. See "
+ 'below for\n'
+ ' documentation of view objects.\n'
+ '\n'
+ ' New in version 2.7.\n'
+ '\n'
+ ' Dictionaries compare equal if and only if they have the '
+ 'same "(key,\n'
+ ' value)" pairs.\n'
+ '\n'
+ '\n'
+ 'Dictionary view objects\n'
+ '=======================\n'
+ '\n'
+ 'The objects returned by "dict.viewkeys()", '
+ '"dict.viewvalues()" and\n'
+ '"dict.viewitems()" are *view objects*. They provide a '
+ 'dynamic view on\n'
+ "the dictionary's entries, which means that when the "
+ 'dictionary\n'
+ 'changes, the view reflects these changes.\n'
+ '\n'
+ 'Dictionary views can be iterated over to yield their '
+ 'respective data,\n'
+ 'and support membership tests:\n'
+ '\n'
+ 'len(dictview)\n'
+ '\n'
+ ' Return the number of entries in the dictionary.\n'
+ '\n'
+ 'iter(dictview)\n'
+ '\n'
+ ' Return an iterator over the keys, values or items '
+ '(represented as\n'
+ ' tuples of "(key, value)") in the dictionary.\n'
+ '\n'
+ ' Keys and values are iterated over in an arbitrary order '
+ 'which is\n'
+ ' non-random, varies across Python implementations, and '
+ 'depends on\n'
+ " the dictionary's history of insertions and deletions. If "
+ 'keys,\n'
+ ' values and items views are iterated over with no '
+ 'intervening\n'
+ ' modifications to the dictionary, the order of items will '
+ 'directly\n'
+ ' correspond. This allows the creation of "(value, key)" '
+ 'pairs using\n'
+ ' "zip()": "pairs = zip(d.values(), d.keys())". Another '
+ 'way to\n'
+ ' create the same list is "pairs = [(v, k) for (k, v) in '
+ 'd.items()]".\n'
+ '\n'
+ ' Iterating views while adding or deleting entries in the '
+ 'dictionary\n'
+ ' may raise a "RuntimeError" or fail to iterate over all '
+ 'entries.\n'
+ '\n'
+ 'x in dictview\n'
+ '\n'
+ ' Return "True" if *x* is in the underlying dictionary\'s '
+ 'keys, values\n'
+ ' or items (in the latter case, *x* should be a "(key, '
+ 'value)"\n'
+ ' tuple).\n'
+ '\n'
+ 'Keys views are set-like since their entries are unique and '
+ 'hashable.\n'
+ 'If all values are hashable, so that (key, value) pairs are '
+ 'unique and\n'
+ 'hashable, then the items view is also set-like. (Values '
+ 'views are not\n'
+ 'treated as set-like since the entries are generally not '
+ 'unique.) Then\n'
+ 'these set operations are available ("other" refers either to '
+ 'another\n'
+ 'view or a set):\n'
+ '\n'
+ 'dictview & other\n'
+ '\n'
+ ' Return the intersection of the dictview and the other '
+ 'object as a\n'
+ ' new set.\n'
+ '\n'
+ 'dictview | other\n'
+ '\n'
+ ' Return the union of the dictview and the other object as '
+ 'a new set.\n'
+ '\n'
+ 'dictview - other\n'
+ '\n'
+ ' Return the difference between the dictview and the other '
+ 'object\n'
+ " (all elements in *dictview* that aren't in *other*) as a "
+ 'new set.\n'
+ '\n'
+ 'dictview ^ other\n'
+ '\n'
+ ' Return the symmetric difference (all elements either in '
+ '*dictview*\n'
+ ' or *other*, but not in both) of the dictview and the '
+ 'other object\n'
+ ' as a new set.\n'
+ '\n'
+ 'An example of dictionary view usage:\n'
+ '\n'
+ " >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, "
+ "'spam': 500}\n"
+ ' >>> keys = dishes.viewkeys()\n'
+ ' >>> values = dishes.viewvalues()\n'
+ '\n'
+ ' >>> # iteration\n'
+ ' >>> n = 0\n'
+ ' >>> for val in values:\n'
+ ' ... n += val\n'
+ ' >>> print(n)\n'
+ ' 504\n'
+ '\n'
+ ' >>> # keys and values are iterated over in the same '
+ 'order\n'
+ ' >>> list(keys)\n'
+ " ['eggs', 'bacon', 'sausage', 'spam']\n"
+ ' >>> list(values)\n'
+ ' [2, 1, 1, 500]\n'
+ '\n'
+ ' >>> # view objects are dynamic and reflect dict changes\n'
+ " >>> del dishes['eggs']\n"
+ " >>> del dishes['sausage']\n"
+ ' >>> list(keys)\n'
+ " ['spam', 'bacon']\n"
+ '\n'
+ ' >>> # set operations\n'
+ " >>> keys & {'eggs', 'bacon', 'salad'}\n"
+ " {'bacon'}\n",
+ 'typesmethods': '\n'
+ 'Methods\n'
+ '*******\n'
+ '\n'
+ 'Methods are functions that are called using the attribute '
+ 'notation.\n'
+ 'There are two flavors: built-in methods (such as "append()" '
+ 'on lists)\n'
+ 'and class instance methods. Built-in methods are described '
+ 'with the\n'
+ 'types that support them.\n'
+ '\n'
+ 'The implementation adds two special read-only attributes to '
+ 'class\n'
+ 'instance methods: "m.im_self" is the object on which the '
+ 'method\n'
+ 'operates, and "m.im_func" is the function implementing the '
+ 'method.\n'
+ 'Calling "m(arg-1, arg-2, ..., arg-n)" is completely '
+ 'equivalent to\n'
+ 'calling "m.im_func(m.im_self, arg-1, arg-2, ..., arg-n)".\n'
+ '\n'
+ 'Class instance methods are either *bound* or *unbound*, '
+ 'referring to\n'
+ 'whether the method was accessed through an instance or a '
+ 'class,\n'
+ 'respectively. When a method is unbound, its "im_self" '
+ 'attribute will\n'
+ 'be "None" and if called, an explicit "self" object must be '
+ 'passed as\n'
+ 'the first argument. In this case, "self" must be an '
+ 'instance of the\n'
+ "unbound method's class (or a subclass of that class), "
+ 'otherwise a\n'
+ '"TypeError" is raised.\n'
+ '\n'
+ 'Like function objects, methods objects support getting '
+ 'arbitrary\n'
+ 'attributes. However, since method attributes are actually '
+ 'stored on\n'
+ 'the underlying function object ("meth.im_func"), setting '
+ 'method\n'
+ 'attributes on either bound or unbound methods is '
+ 'disallowed.\n'
+ 'Attempting to set an attribute on a method results in an\n'
+ '"AttributeError" being raised. In order to set a method '
+ 'attribute,\n'
+ 'you need to explicitly set it on the underlying function '
+ 'object:\n'
+ '\n'
+ ' >>> class C:\n'
+ ' ... def method(self):\n'
+ ' ... pass\n'
+ ' ...\n'
+ ' >>> c = C()\n'
+ " >>> c.method.whoami = 'my name is method' # can't set on "
+ 'the method\n'
+ ' Traceback (most recent call last):\n'
+ ' File "<stdin>", line 1, in <module>\n'
+ " AttributeError: 'instancemethod' object has no attribute "
+ "'whoami'\n"
+ " >>> c.method.im_func.whoami = 'my name is method'\n"
+ ' >>> c.method.whoami\n'
+ " 'my name is method'\n"
+ '\n'
+ 'See The standard type hierarchy for more information.\n',
+ 'typesmodules': '\n'
+ 'Modules\n'
+ '*******\n'
+ '\n'
+ 'The only special operation on a module is attribute access: '
+ '"m.name",\n'
+ 'where *m* is a module and *name* accesses a name defined in '
+ "*m*'s\n"
+ 'symbol table. Module attributes can be assigned to. (Note '
+ 'that the\n'
+ '"import" statement is not, strictly speaking, an operation '
+ 'on a module\n'
+ 'object; "import foo" does not require a module object named '
+ '*foo* to\n'
+ 'exist, rather it requires an (external) *definition* for a '
+ 'module\n'
+ 'named *foo* somewhere.)\n'
+ '\n'
+ 'A special attribute of every module is "__dict__". This is '
+ 'the\n'
+ "dictionary containing the module's symbol table. Modifying "
+ 'this\n'
+ "dictionary will actually change the module's symbol table, "
+ 'but direct\n'
+ 'assignment to the "__dict__" attribute is not possible (you '
+ 'can write\n'
+ '"m.__dict__[\'a\'] = 1", which defines "m.a" to be "1", but '
+ "you can't\n"
+ 'write "m.__dict__ = {}"). Modifying "__dict__" directly is '
+ 'not\n'
+ 'recommended.\n'
+ '\n'
+ 'Modules built into the interpreter are written like this: '
+ '"<module\n'
+ '\'sys\' (built-in)>". If loaded from a file, they are '
+ 'written as\n'
+ '"<module \'os\' from '
+ '\'/usr/local/lib/pythonX.Y/os.pyc\'>".\n',
+ 'typesseq': '\n'
+ 'Sequence Types --- "str", "unicode", "list", "tuple", '
+ '"bytearray", "buffer", "xrange"\n'
+ '*************************************************************************************\n'
+ '\n'
+ 'There are seven sequence types: strings, Unicode strings, '
+ 'lists,\n'
+ 'tuples, bytearrays, buffers, and xrange objects.\n'
+ '\n'
+ 'For other containers see the built in "dict" and "set" classes, '
+ 'and\n'
+ 'the "collections" module.\n'
+ '\n'
+ 'String literals are written in single or double quotes: '
+ '"\'xyzzy\'",\n'
+ '""frobozz"". See String literals for more about string '
+ 'literals.\n'
+ 'Unicode strings are much like strings, but are specified in the '
+ 'syntax\n'
+ 'using a preceding "\'u\'" character: "u\'abc\'", "u"def"". In '
+ 'addition to\n'
+ 'the functionality described here, there are also '
+ 'string-specific\n'
+ 'methods described in the String Methods section. Lists are '
+ 'constructed\n'
+ 'with square brackets, separating items with commas: "[a, b, '
+ 'c]".\n'
+ 'Tuples are constructed by the comma operator (not within square\n'
+ 'brackets), with or without enclosing parentheses, but an empty '
+ 'tuple\n'
+ 'must have the enclosing parentheses, such as "a, b, c" or "()". '
+ 'A\n'
+ 'single item tuple must have a trailing comma, such as "(d,)".\n'
+ '\n'
+ 'Bytearray objects are created with the built-in function\n'
+ '"bytearray()".\n'
+ '\n'
+ 'Buffer objects are not directly supported by Python syntax, but '
+ 'can be\n'
+ 'created by calling the built-in function "buffer()". They '
+ "don't\n"
+ 'support concatenation or repetition.\n'
+ '\n'
+ 'Objects of type xrange are similar to buffers in that there is '
+ 'no\n'
+ 'specific syntax to create them, but they are created using the\n'
+ '"xrange()" function. They don\'t support slicing, concatenation '
+ 'or\n'
+ 'repetition, and using "in", "not in", "min()" or "max()" on them '
+ 'is\n'
+ 'inefficient.\n'
+ '\n'
+ 'Most sequence types support the following operations. The "in" '
+ 'and\n'
+ '"not in" operations have the same priorities as the comparison\n'
+ 'operations. The "+" and "*" operations have the same priority '
+ 'as the\n'
+ 'corresponding numeric operations. [3] Additional methods are '
+ 'provided\n'
+ 'for Mutable Sequence Types.\n'
+ '\n'
+ 'This table lists the sequence operations sorted in ascending '
+ 'priority.\n'
+ 'In the table, *s* and *t* are sequences of the same type; *n*, '
+ '*i* and\n'
+ '*j* are integers:\n'
+ '\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| Operation | Result | '
+ 'Notes |\n'
+ '+====================+==================================+============+\n'
+ '| "x in s" | "True" if an item of *s* is | '
+ '(1) |\n'
+ '| | equal to *x*, else "False" '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "x not in s" | "False" if an item of *s* is | '
+ '(1) |\n'
+ '| | equal to *x*, else "True" '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "s + t" | the concatenation of *s* and *t* | '
+ '(6) |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "s * n, n * s" | equivalent to adding *s* to | '
+ '(2) |\n'
+ '| | itself *n* times '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "s[i]" | *i*th item of *s*, origin 0 | '
+ '(3) |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "s[i:j]" | slice of *s* from *i* to *j* | '
+ '(3)(4) |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "s[i:j:k]" | slice of *s* from *i* to *j* | '
+ '(3)(5) |\n'
+ '| | with step *k* '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "len(s)" | length of *s* '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "min(s)" | smallest item of *s* '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "max(s)" | largest item of *s* '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "s.index(x)" | index of the first occurrence of '
+ '| |\n'
+ '| | *x* in *s* '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '| "s.count(x)" | total number of occurrences of '
+ '| |\n'
+ '| | *x* in *s* '
+ '| |\n'
+ '+--------------------+----------------------------------+------------+\n'
+ '\n'
+ 'Sequence types also support comparisons. In particular, tuples '
+ 'and\n'
+ 'lists are compared lexicographically by comparing corresponding\n'
+ 'elements. This means that to compare equal, every element must '
+ 'compare\n'
+ 'equal and the two sequences must be of the same type and have '
+ 'the same\n'
+ 'length. (For full details see Comparisons in the language '
+ 'reference.)\n'
+ '\n'
+ 'Notes:\n'
+ '\n'
+ '1. When *s* is a string or Unicode string object the "in" and '
+ '"not\n'
+ ' in" operations act like a substring test. In Python '
+ 'versions\n'
+ ' before 2.3, *x* had to be a string of length 1. In Python 2.3 '
+ 'and\n'
+ ' beyond, *x* may be a string of any length.\n'
+ '\n'
+ '2. Values of *n* less than "0" are treated as "0" (which yields '
+ 'an\n'
+ ' empty sequence of the same type as *s*). Note that items in '
+ 'the\n'
+ ' sequence *s* are not copied; they are referenced multiple '
+ 'times.\n'
+ ' This often haunts new Python programmers; consider:\n'
+ '\n'
+ ' >>> lists = [[]] * 3\n'
+ ' >>> lists\n'
+ ' [[], [], []]\n'
+ ' >>> lists[0].append(3)\n'
+ ' >>> lists\n'
+ ' [[3], [3], [3]]\n'
+ '\n'
+ ' What has happened is that "[[]]" is a one-element list '
+ 'containing\n'
+ ' an empty list, so all three elements of "[[]] * 3" are '
+ 'references\n'
+ ' to this single empty list. Modifying any of the elements of\n'
+ ' "lists" modifies this single list. You can create a list of\n'
+ ' different lists this way:\n'
+ '\n'
+ ' >>> lists = [[] for i in range(3)]\n'
+ ' >>> lists[0].append(3)\n'
+ ' >>> lists[1].append(5)\n'
+ ' >>> lists[2].append(7)\n'
+ ' >>> lists\n'
+ ' [[3], [5], [7]]\n'
+ '\n'
+ ' Further explanation is available in the FAQ entry How do I '
+ 'create a\n'
+ ' multidimensional list?.\n'
+ '\n'
+ '3. If *i* or *j* is negative, the index is relative to the end '
+ 'of\n'
+ ' sequence *s*: "len(s) + i" or "len(s) + j" is substituted. '
+ 'But\n'
+ ' note that "-0" is still "0".\n'
+ '\n'
+ '4. The slice of *s* from *i* to *j* is defined as the sequence '
+ 'of\n'
+ ' items with index *k* such that "i <= k < j". If *i* or *j* '
+ 'is\n'
+ ' greater than "len(s)", use "len(s)". If *i* is omitted or '
+ '"None",\n'
+ ' use "0". If *j* is omitted or "None", use "len(s)". If *i* '
+ 'is\n'
+ ' greater than or equal to *j*, the slice is empty.\n'
+ '\n'
+ '5. The slice of *s* from *i* to *j* with step *k* is defined as '
+ 'the\n'
+ ' sequence of items with index "x = i + n*k" such that "0 <= n '
+ '<\n'
+ ' (j-i)/k". In other words, the indices are "i", "i+k", '
+ '"i+2*k",\n'
+ ' "i+3*k" and so on, stopping when *j* is reached (but never\n'
+ ' including *j*). When *k* is positive, *i* and *j* are '
+ 'reduced to\n'
+ ' "len(s)" if they are greater. When *k* is negative, *i* and '
+ '*j* are\n'
+ ' reduced to "len(s) - 1" if they are greater. If *i* or *j* '
+ 'are\n'
+ ' omitted or "None", they become "end" values (which end '
+ 'depends on\n'
+ ' the sign of *k*). Note, *k* cannot be zero. If *k* is '
+ '"None", it\n'
+ ' is treated like "1".\n'
+ '\n'
+ '6. **CPython implementation detail:** If *s* and *t* are both\n'
+ ' strings, some Python implementations such as CPython can '
+ 'usually\n'
+ ' perform an in-place optimization for assignments of the form '
+ '"s = s\n'
+ ' + t" or "s += t". When applicable, this optimization makes\n'
+ ' quadratic run-time much less likely. This optimization is '
+ 'both\n'
+ ' version and implementation dependent. For performance '
+ 'sensitive\n'
+ ' code, it is preferable to use the "str.join()" method which '
+ 'assures\n'
+ ' consistent linear concatenation performance across versions '
+ 'and\n'
+ ' implementations.\n'
+ '\n'
+ ' Changed in version 2.4: Formerly, string concatenation never\n'
+ ' occurred in-place.\n'
+ '\n'
+ '\n'
+ 'String Methods\n'
+ '==============\n'
+ '\n'
+ 'Below are listed the string methods which both 8-bit strings '
+ 'and\n'
+ 'Unicode objects support. Some of them are also available on\n'
+ '"bytearray" objects.\n'
+ '\n'
+ "In addition, Python's strings support the sequence type methods\n"
+ 'described in the Sequence Types --- str, unicode, list, tuple,\n'
+ 'bytearray, buffer, xrange section. To output formatted strings '
+ 'use\n'
+ 'template strings or the "%" operator described in the String\n'
+ 'Formatting Operations section. Also, see the "re" module for '
+ 'string\n'
+ 'functions based on regular expressions.\n'
+ '\n'
+ 'str.capitalize()\n'
+ '\n'
+ ' Return a copy of the string with its first character '
+ 'capitalized\n'
+ ' and the rest lowercased.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.center(width[, fillchar])\n'
+ '\n'
+ ' Return centered in a string of length *width*. Padding is '
+ 'done\n'
+ ' using the specified *fillchar* (default is a space).\n'
+ '\n'
+ ' Changed in version 2.4: Support for the *fillchar* argument.\n'
+ '\n'
+ 'str.count(sub[, start[, end]])\n'
+ '\n'
+ ' Return the number of non-overlapping occurrences of substring '
+ '*sub*\n'
+ ' in the range [*start*, *end*]. Optional arguments *start* '
+ 'and\n'
+ ' *end* are interpreted as in slice notation.\n'
+ '\n'
+ 'str.decode([encoding[, errors]])\n'
+ '\n'
+ ' Decodes the string using the codec registered for '
+ '*encoding*.\n'
+ ' *encoding* defaults to the default string encoding. *errors* '
+ 'may\n'
+ ' be given to set a different error handling scheme. The '
+ 'default is\n'
+ ' "\'strict\'", meaning that encoding errors raise '
+ '"UnicodeError".\n'
+ ' Other possible values are "\'ignore\'", "\'replace\'" and any '
+ 'other\n'
+ ' name registered via "codecs.register_error()", see section '
+ 'Codec\n'
+ ' Base Classes.\n'
+ '\n'
+ ' New in version 2.2.\n'
+ '\n'
+ ' Changed in version 2.3: Support for other error handling '
+ 'schemes\n'
+ ' added.\n'
+ '\n'
+ ' Changed in version 2.7: Support for keyword arguments added.\n'
+ '\n'
+ 'str.encode([encoding[, errors]])\n'
+ '\n'
+ ' Return an encoded version of the string. Default encoding is '
+ 'the\n'
+ ' current default string encoding. *errors* may be given to '
+ 'set a\n'
+ ' different error handling scheme. The default for *errors* '
+ 'is\n'
+ ' "\'strict\'", meaning that encoding errors raise a '
+ '"UnicodeError".\n'
+ ' Other possible values are "\'ignore\'", "\'replace\'",\n'
+ ' "\'xmlcharrefreplace\'", "\'backslashreplace\'" and any other '
+ 'name\n'
+ ' registered via "codecs.register_error()", see section Codec '
+ 'Base\n'
+ ' Classes. For a list of possible encodings, see section '
+ 'Standard\n'
+ ' Encodings.\n'
+ '\n'
+ ' New in version 2.0.\n'
+ '\n'
+ ' Changed in version 2.3: Support for "\'xmlcharrefreplace\'" '
+ 'and\n'
+ ' "\'backslashreplace\'" and other error handling schemes '
+ 'added.\n'
+ '\n'
+ ' Changed in version 2.7: Support for keyword arguments added.\n'
+ '\n'
+ 'str.endswith(suffix[, start[, end]])\n'
+ '\n'
+ ' Return "True" if the string ends with the specified '
+ '*suffix*,\n'
+ ' otherwise return "False". *suffix* can also be a tuple of '
+ 'suffixes\n'
+ ' to look for. With optional *start*, test beginning at that\n'
+ ' position. With optional *end*, stop comparing at that '
+ 'position.\n'
+ '\n'
+ ' Changed in version 2.5: Accept tuples as *suffix*.\n'
+ '\n'
+ 'str.expandtabs([tabsize])\n'
+ '\n'
+ ' Return a copy of the string where all tab characters are '
+ 'replaced\n'
+ ' by one or more spaces, depending on the current column and '
+ 'the\n'
+ ' given tab size. Tab positions occur every *tabsize* '
+ 'characters\n'
+ ' (default is 8, giving tab positions at columns 0, 8, 16 and '
+ 'so on).\n'
+ ' To expand the string, the current column is set to zero and '
+ 'the\n'
+ ' string is examined character by character. If the character '
+ 'is a\n'
+ ' tab ("\\t"), one or more space characters are inserted in the '
+ 'result\n'
+ ' until the current column is equal to the next tab position. '
+ '(The\n'
+ ' tab character itself is not copied.) If the character is a '
+ 'newline\n'
+ ' ("\\n") or return ("\\r"), it is copied and the current '
+ 'column is\n'
+ ' reset to zero. Any other character is copied unchanged and '
+ 'the\n'
+ ' current column is incremented by one regardless of how the\n'
+ ' character is represented when printed.\n'
+ '\n'
+ " >>> '01\\t012\\t0123\\t01234'.expandtabs()\n"
+ " '01 012 0123 01234'\n"
+ " >>> '01\\t012\\t0123\\t01234'.expandtabs(4)\n"
+ " '01 012 0123 01234'\n"
+ '\n'
+ 'str.find(sub[, start[, end]])\n'
+ '\n'
+ ' Return the lowest index in the string where substring *sub* '
+ 'is\n'
+ ' found within the slice "s[start:end]". Optional arguments '
+ '*start*\n'
+ ' and *end* are interpreted as in slice notation. Return "-1" '
+ 'if\n'
+ ' *sub* is not found.\n'
+ '\n'
+ ' Note: The "find()" method should be used only if you need to '
+ 'know\n'
+ ' the position of *sub*. To check if *sub* is a substring or '
+ 'not,\n'
+ ' use the "in" operator:\n'
+ '\n'
+ " >>> 'Py' in 'Python'\n"
+ ' True\n'
+ '\n'
+ 'str.format(*args, **kwargs)\n'
+ '\n'
+ ' Perform a string formatting operation. The string on which '
+ 'this\n'
+ ' method is called can contain literal text or replacement '
+ 'fields\n'
+ ' delimited by braces "{}". Each replacement field contains '
+ 'either\n'
+ ' the numeric index of a positional argument, or the name of a\n'
+ ' keyword argument. Returns a copy of the string where each\n'
+ ' replacement field is replaced with the string value of the\n'
+ ' corresponding argument.\n'
+ '\n'
+ ' >>> "The sum of 1 + 2 is {0}".format(1+2)\n'
+ " 'The sum of 1 + 2 is 3'\n"
+ '\n'
+ ' See Format String Syntax for a description of the various\n'
+ ' formatting options that can be specified in format strings.\n'
+ '\n'
+ ' This method of string formatting is the new standard in '
+ 'Python 3,\n'
+ ' and should be preferred to the "%" formatting described in '
+ 'String\n'
+ ' Formatting Operations in new code.\n'
+ '\n'
+ ' New in version 2.6.\n'
+ '\n'
+ 'str.index(sub[, start[, end]])\n'
+ '\n'
+ ' Like "find()", but raise "ValueError" when the substring is '
+ 'not\n'
+ ' found.\n'
+ '\n'
+ 'str.isalnum()\n'
+ '\n'
+ ' Return true if all characters in the string are alphanumeric '
+ 'and\n'
+ ' there is at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isalpha()\n'
+ '\n'
+ ' Return true if all characters in the string are alphabetic '
+ 'and\n'
+ ' there is at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isdigit()\n'
+ '\n'
+ ' Return true if all characters in the string are digits and '
+ 'there is\n'
+ ' at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.islower()\n'
+ '\n'
+ ' Return true if all cased characters [4] in the string are '
+ 'lowercase\n'
+ ' and there is at least one cased character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isspace()\n'
+ '\n'
+ ' Return true if there are only whitespace characters in the '
+ 'string\n'
+ ' and there is at least one character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.istitle()\n'
+ '\n'
+ ' Return true if the string is a titlecased string and there is '
+ 'at\n'
+ ' least one character, for example uppercase characters may '
+ 'only\n'
+ ' follow uncased characters and lowercase characters only cased '
+ 'ones.\n'
+ ' Return false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.isupper()\n'
+ '\n'
+ ' Return true if all cased characters [4] in the string are '
+ 'uppercase\n'
+ ' and there is at least one cased character, false otherwise.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.join(iterable)\n'
+ '\n'
+ ' Return a string which is the concatenation of the strings in\n'
+ ' *iterable*. A "TypeError" will be raised if there are any '
+ 'non-\n'
+ ' string values in *iterable*, including "bytes" objects. The\n'
+ ' separator between elements is the string providing this '
+ 'method.\n'
+ '\n'
+ 'str.ljust(width[, fillchar])\n'
+ '\n'
+ ' Return the string left justified in a string of length '
+ '*width*.\n'
+ ' Padding is done using the specified *fillchar* (default is a\n'
+ ' space). The original string is returned if *width* is less '
+ 'than or\n'
+ ' equal to "len(s)".\n'
+ '\n'
+ ' Changed in version 2.4: Support for the *fillchar* argument.\n'
+ '\n'
+ 'str.lower()\n'
+ '\n'
+ ' Return a copy of the string with all the cased characters '
+ '[4]\n'
+ ' converted to lowercase.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.lstrip([chars])\n'
+ '\n'
+ ' Return a copy of the string with leading characters removed. '
+ 'The\n'
+ ' *chars* argument is a string specifying the set of characters '
+ 'to be\n'
+ ' removed. If omitted or "None", the *chars* argument defaults '
+ 'to\n'
+ ' removing whitespace. The *chars* argument is not a prefix; '
+ 'rather,\n'
+ ' all combinations of its values are stripped:\n'
+ '\n'
+ " >>> ' spacious '.lstrip()\n"
+ " 'spacious '\n"
+ " >>> 'www.example.com'.lstrip('cmowz.')\n"
+ " 'example.com'\n"
+ '\n'
+ ' Changed in version 2.2.2: Support for the *chars* argument.\n'
+ '\n'
+ 'str.partition(sep)\n'
+ '\n'
+ ' Split the string at the first occurrence of *sep*, and return '
+ 'a\n'
+ ' 3-tuple containing the part before the separator, the '
+ 'separator\n'
+ ' itself, and the part after the separator. If the separator '
+ 'is not\n'
+ ' found, return a 3-tuple containing the string itself, '
+ 'followed by\n'
+ ' two empty strings.\n'
+ '\n'
+ ' New in version 2.5.\n'
+ '\n'
+ 'str.replace(old, new[, count])\n'
+ '\n'
+ ' Return a copy of the string with all occurrences of substring '
+ '*old*\n'
+ ' replaced by *new*. If the optional argument *count* is '
+ 'given, only\n'
+ ' the first *count* occurrences are replaced.\n'
+ '\n'
+ 'str.rfind(sub[, start[, end]])\n'
+ '\n'
+ ' Return the highest index in the string where substring *sub* '
+ 'is\n'
+ ' found, such that *sub* is contained within "s[start:end]".\n'
+ ' Optional arguments *start* and *end* are interpreted as in '
+ 'slice\n'
+ ' notation. Return "-1" on failure.\n'
+ '\n'
+ 'str.rindex(sub[, start[, end]])\n'
+ '\n'
+ ' Like "rfind()" but raises "ValueError" when the substring '
+ '*sub* is\n'
+ ' not found.\n'
+ '\n'
+ 'str.rjust(width[, fillchar])\n'
+ '\n'
+ ' Return the string right justified in a string of length '
+ '*width*.\n'
+ ' Padding is done using the specified *fillchar* (default is a\n'
+ ' space). The original string is returned if *width* is less '
+ 'than or\n'
+ ' equal to "len(s)".\n'
+ '\n'
+ ' Changed in version 2.4: Support for the *fillchar* argument.\n'
+ '\n'
+ 'str.rpartition(sep)\n'
+ '\n'
+ ' Split the string at the last occurrence of *sep*, and return '
+ 'a\n'
+ ' 3-tuple containing the part before the separator, the '
+ 'separator\n'
+ ' itself, and the part after the separator. If the separator '
+ 'is not\n'
+ ' found, return a 3-tuple containing two empty strings, '
+ 'followed by\n'
+ ' the string itself.\n'
+ '\n'
+ ' New in version 2.5.\n'
+ '\n'
+ 'str.rsplit([sep[, maxsplit]])\n'
+ '\n'
+ ' Return a list of the words in the string, using *sep* as the\n'
+ ' delimiter string. If *maxsplit* is given, at most *maxsplit* '
+ 'splits\n'
+ ' are done, the *rightmost* ones. If *sep* is not specified '
+ 'or\n'
+ ' "None", any whitespace string is a separator. Except for '
+ 'splitting\n'
+ ' from the right, "rsplit()" behaves like "split()" which is\n'
+ ' described in detail below.\n'
+ '\n'
+ ' New in version 2.4.\n'
+ '\n'
+ 'str.rstrip([chars])\n'
+ '\n'
+ ' Return a copy of the string with trailing characters '
+ 'removed. The\n'
+ ' *chars* argument is a string specifying the set of characters '
+ 'to be\n'
+ ' removed. If omitted or "None", the *chars* argument defaults '
+ 'to\n'
+ ' removing whitespace. The *chars* argument is not a suffix; '
+ 'rather,\n'
+ ' all combinations of its values are stripped:\n'
+ '\n'
+ " >>> ' spacious '.rstrip()\n"
+ " ' spacious'\n"
+ " >>> 'mississippi'.rstrip('ipz')\n"
+ " 'mississ'\n"
+ '\n'
+ ' Changed in version 2.2.2: Support for the *chars* argument.\n'
+ '\n'
+ 'str.split([sep[, maxsplit]])\n'
+ '\n'
+ ' Return a list of the words in the string, using *sep* as the\n'
+ ' delimiter string. If *maxsplit* is given, at most '
+ '*maxsplit*\n'
+ ' splits are done (thus, the list will have at most '
+ '"maxsplit+1"\n'
+ ' elements). If *maxsplit* is not specified or "-1", then '
+ 'there is\n'
+ ' no limit on the number of splits (all possible splits are '
+ 'made).\n'
+ '\n'
+ ' If *sep* is given, consecutive delimiters are not grouped '
+ 'together\n'
+ ' and are deemed to delimit empty strings (for example,\n'
+ ' "\'1,,2\'.split(\',\')" returns "[\'1\', \'\', \'2\']"). The '
+ '*sep* argument\n'
+ ' may consist of multiple characters (for example,\n'
+ ' "\'1<>2<>3\'.split(\'<>\')" returns "[\'1\', \'2\', \'3\']"). '
+ 'Splitting an\n'
+ ' empty string with a specified separator returns "[\'\']".\n'
+ '\n'
+ ' If *sep* is not specified or is "None", a different '
+ 'splitting\n'
+ ' algorithm is applied: runs of consecutive whitespace are '
+ 'regarded\n'
+ ' as a single separator, and the result will contain no empty '
+ 'strings\n'
+ ' at the start or end if the string has leading or trailing\n'
+ ' whitespace. Consequently, splitting an empty string or a '
+ 'string\n'
+ ' consisting of just whitespace with a "None" separator returns '
+ '"[]".\n'
+ '\n'
+ ' For example, "\' 1 2 3 \'.split()" returns "[\'1\', '
+ '\'2\', \'3\']", and\n'
+ ' "\' 1 2 3 \'.split(None, 1)" returns "[\'1\', \'2 3 '
+ '\']".\n'
+ '\n'
+ 'str.splitlines([keepends])\n'
+ '\n'
+ ' Return a list of the lines in the string, breaking at line\n'
+ ' boundaries. This method uses the *universal newlines* '
+ 'approach to\n'
+ ' splitting lines. Line breaks are not included in the '
+ 'resulting list\n'
+ ' unless *keepends* is given and true.\n'
+ '\n'
+ ' Python recognizes ""\\r"", ""\\n"", and ""\\r\\n"" as line '
+ 'boundaries\n'
+ ' for 8-bit strings.\n'
+ '\n'
+ ' For example:\n'
+ '\n'
+ " >>> 'ab c\\n\\nde fg\\rkl\\r\\n'.splitlines()\n"
+ " ['ab c', '', 'de fg', 'kl']\n"
+ " >>> 'ab c\\n\\nde fg\\rkl\\r\\n'.splitlines(True)\n"
+ " ['ab c\\n', '\\n', 'de fg\\r', 'kl\\r\\n']\n"
+ '\n'
+ ' Unlike "split()" when a delimiter string *sep* is given, '
+ 'this\n'
+ ' method returns an empty list for the empty string, and a '
+ 'terminal\n'
+ ' line break does not result in an extra line:\n'
+ '\n'
+ ' >>> "".splitlines()\n'
+ ' []\n'
+ ' >>> "One line\\n".splitlines()\n'
+ " ['One line']\n"
+ '\n'
+ ' For comparison, "split(\'\\n\')" gives:\n'
+ '\n'
+ " >>> ''.split('\\n')\n"
+ " ['']\n"
+ " >>> 'Two lines\\n'.split('\\n')\n"
+ " ['Two lines', '']\n"
+ '\n'
+ 'unicode.splitlines([keepends])\n'
+ '\n'
+ ' Return a list of the lines in the string, like '
+ '"str.splitlines()".\n'
+ ' However, the Unicode method splits on the following line\n'
+ ' boundaries, which are a superset of the *universal newlines*\n'
+ ' recognized for 8-bit strings.\n'
+ '\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | Representation | Description |\n'
+ ' +=========================+===============================+\n'
+ ' | "\\n" | Line Feed |\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\r" | Carriage Return |\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\r\\n" | Carriage Return + Line Feed '
+ '|\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\v" or "\\x0b" | Line Tabulation '
+ '|\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\f" or "\\x0c" | Form Feed '
+ '|\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\x1c" | File Separator |\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\x1d" | Group Separator |\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\x1e" | Record Separator |\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\x85" | Next Line (C1 Control Code) |\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\u2028" | Line Separator |\n'
+ ' +-------------------------+-------------------------------+\n'
+ ' | "\\u2029" | Paragraph Separator |\n'
+ ' +-------------------------+-------------------------------+\n'
+ '\n'
+ ' Changed in version 2.7: "\\v" and "\\f" added to list of '
+ 'line\n'
+ ' boundaries.\n'
+ '\n'
+ 'str.startswith(prefix[, start[, end]])\n'
+ '\n'
+ ' Return "True" if string starts with the *prefix*, otherwise '
+ 'return\n'
+ ' "False". *prefix* can also be a tuple of prefixes to look '
+ 'for.\n'
+ ' With optional *start*, test string beginning at that '
+ 'position.\n'
+ ' With optional *end*, stop comparing string at that position.\n'
+ '\n'
+ ' Changed in version 2.5: Accept tuples as *prefix*.\n'
+ '\n'
+ 'str.strip([chars])\n'
+ '\n'
+ ' Return a copy of the string with the leading and trailing\n'
+ ' characters removed. The *chars* argument is a string '
+ 'specifying the\n'
+ ' set of characters to be removed. If omitted or "None", the '
+ '*chars*\n'
+ ' argument defaults to removing whitespace. The *chars* '
+ 'argument is\n'
+ ' not a prefix or suffix; rather, all combinations of its '
+ 'values are\n'
+ ' stripped:\n'
+ '\n'
+ " >>> ' spacious '.strip()\n"
+ " 'spacious'\n"
+ " >>> 'www.example.com'.strip('cmowz.')\n"
+ " 'example'\n"
+ '\n'
+ ' Changed in version 2.2.2: Support for the *chars* argument.\n'
+ '\n'
+ 'str.swapcase()\n'
+ '\n'
+ ' Return a copy of the string with uppercase characters '
+ 'converted to\n'
+ ' lowercase and vice versa.\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.title()\n'
+ '\n'
+ ' Return a titlecased version of the string where words start '
+ 'with an\n'
+ ' uppercase character and the remaining characters are '
+ 'lowercase.\n'
+ '\n'
+ ' The algorithm uses a simple language-independent definition '
+ 'of a\n'
+ ' word as groups of consecutive letters. The definition works '
+ 'in\n'
+ ' many contexts but it means that apostrophes in contractions '
+ 'and\n'
+ ' possessives form word boundaries, which may not be the '
+ 'desired\n'
+ ' result:\n'
+ '\n'
+ ' >>> "they\'re bill\'s friends from the UK".title()\n'
+ ' "They\'Re Bill\'S Friends From The Uk"\n'
+ '\n'
+ ' A workaround for apostrophes can be constructed using '
+ 'regular\n'
+ ' expressions:\n'
+ '\n'
+ ' >>> import re\n'
+ ' >>> def titlecase(s):\n'
+ ' ... return re.sub(r"[A-Za-z]+(\'[A-Za-z]+)?",\n'
+ ' ... lambda mo: mo.group(0)[0].upper() +\n'
+ ' ... mo.group(0)[1:].lower(),\n'
+ ' ... s)\n'
+ ' ...\n'
+ ' >>> titlecase("they\'re bill\'s friends.")\n'
+ ' "They\'re Bill\'s Friends."\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.translate(table[, deletechars])\n'
+ '\n'
+ ' Return a copy of the string where all characters occurring in '
+ 'the\n'
+ ' optional argument *deletechars* are removed, and the '
+ 'remaining\n'
+ ' characters have been mapped through the given translation '
+ 'table,\n'
+ ' which must be a string of length 256.\n'
+ '\n'
+ ' You can use the "maketrans()" helper function in the '
+ '"string"\n'
+ ' module to create a translation table. For string objects, set '
+ 'the\n'
+ ' *table* argument to "None" for translations that only delete\n'
+ ' characters:\n'
+ '\n'
+ " >>> 'read this short text'.translate(None, 'aeiou')\n"
+ " 'rd ths shrt txt'\n"
+ '\n'
+ ' New in version 2.6: Support for a "None" *table* argument.\n'
+ '\n'
+ ' For Unicode objects, the "translate()" method does not accept '
+ 'the\n'
+ ' optional *deletechars* argument. Instead, it returns a copy '
+ 'of the\n'
+ ' *s* where all characters have been mapped through the given\n'
+ ' translation table which must be a mapping of Unicode ordinals '
+ 'to\n'
+ ' Unicode ordinals, Unicode strings or "None". Unmapped '
+ 'characters\n'
+ ' are left untouched. Characters mapped to "None" are deleted. '
+ 'Note,\n'
+ ' a more flexible approach is to create a custom character '
+ 'mapping\n'
+ ' codec using the "codecs" module (see "encodings.cp1251" for '
+ 'an\n'
+ ' example).\n'
+ '\n'
+ 'str.upper()\n'
+ '\n'
+ ' Return a copy of the string with all the cased characters '
+ '[4]\n'
+ ' converted to uppercase. Note that "str.upper().isupper()" '
+ 'might be\n'
+ ' "False" if "s" contains uncased characters or if the Unicode\n'
+ ' category of the resulting character(s) is not "Lu" (Letter,\n'
+ ' uppercase), but e.g. "Lt" (Letter, titlecase).\n'
+ '\n'
+ ' For 8-bit strings, this method is locale-dependent.\n'
+ '\n'
+ 'str.zfill(width)\n'
+ '\n'
+ ' Return the numeric string left filled with zeros in a string '
+ 'of\n'
+ ' length *width*. A sign prefix is handled correctly. The '
+ 'original\n'
+ ' string is returned if *width* is less than or equal to '
+ '"len(s)".\n'
+ '\n'
+ ' New in version 2.2.2.\n'
+ '\n'
+ 'The following methods are present only on unicode objects:\n'
+ '\n'
+ 'unicode.isnumeric()\n'
+ '\n'
+ ' Return "True" if there are only numeric characters in S, '
+ '"False"\n'
+ ' otherwise. Numeric characters include digit characters, and '
+ 'all\n'
+ ' characters that have the Unicode numeric value property, '
+ 'e.g.\n'
+ ' U+2155, VULGAR FRACTION ONE FIFTH.\n'
+ '\n'
+ 'unicode.isdecimal()\n'
+ '\n'
+ ' Return "True" if there are only decimal characters in S, '
+ '"False"\n'
+ ' otherwise. Decimal characters include digit characters, and '
+ 'all\n'
+ ' characters that can be used to form decimal-radix numbers, '
+ 'e.g.\n'
+ ' U+0660, ARABIC-INDIC DIGIT ZERO.\n'
+ '\n'
+ '\n'
+ 'String Formatting Operations\n'
+ '============================\n'
+ '\n'
+ 'String and Unicode objects have one unique built-in operation: '
+ 'the "%"\n'
+ 'operator (modulo). This is also known as the string '
+ '*formatting* or\n'
+ '*interpolation* operator. Given "format % values" (where '
+ '*format* is\n'
+ 'a string or Unicode object), "%" conversion specifications in '
+ '*format*\n'
+ 'are replaced with zero or more elements of *values*. The effect '
+ 'is\n'
+ 'similar to the using "sprintf()" in the C language. If *format* '
+ 'is a\n'
+ 'Unicode object, or if any of the objects being converted using '
+ 'the\n'
+ '"%s" conversion are Unicode objects, the result will also be a '
+ 'Unicode\n'
+ 'object.\n'
+ '\n'
+ 'If *format* requires a single argument, *values* may be a single '
+ 'non-\n'
+ 'tuple object. [5] Otherwise, *values* must be a tuple with '
+ 'exactly\n'
+ 'the number of items specified by the format string, or a single\n'
+ 'mapping object (for example, a dictionary).\n'
+ '\n'
+ 'A conversion specifier contains two or more characters and has '
+ 'the\n'
+ 'following components, which must occur in this order:\n'
+ '\n'
+ '1. The "\'%\'" character, which marks the start of the '
+ 'specifier.\n'
+ '\n'
+ '2. Mapping key (optional), consisting of a parenthesised '
+ 'sequence\n'
+ ' of characters (for example, "(somename)").\n'
+ '\n'
+ '3. Conversion flags (optional), which affect the result of some\n'
+ ' conversion types.\n'
+ '\n'
+ '4. Minimum field width (optional). If specified as an "\'*\'"\n'
+ ' (asterisk), the actual width is read from the next element of '
+ 'the\n'
+ ' tuple in *values*, and the object to convert comes after the\n'
+ ' minimum field width and optional precision.\n'
+ '\n'
+ '5. Precision (optional), given as a "\'.\'" (dot) followed by '
+ 'the\n'
+ ' precision. If specified as "\'*\'" (an asterisk), the actual '
+ 'width\n'
+ ' is read from the next element of the tuple in *values*, and '
+ 'the\n'
+ ' value to convert comes after the precision.\n'
+ '\n'
+ '6. Length modifier (optional).\n'
+ '\n'
+ '7. Conversion type.\n'
+ '\n'
+ 'When the right argument is a dictionary (or other mapping type), '
+ 'then\n'
+ 'the formats in the string *must* include a parenthesised mapping '
+ 'key\n'
+ 'into that dictionary inserted immediately after the "\'%\'" '
+ 'character.\n'
+ 'The mapping key selects the value to be formatted from the '
+ 'mapping.\n'
+ 'For example:\n'
+ '\n'
+ ">>> print '%(language)s has %(number)03d quote types.' % \\\n"
+ '... {"language": "Python", "number": 2}\n'
+ 'Python has 002 quote types.\n'
+ '\n'
+ 'In this case no "*" specifiers may occur in a format (since '
+ 'they\n'
+ 'require a sequential parameter list).\n'
+ '\n'
+ 'The conversion flag characters are:\n'
+ '\n'
+ '+-----------+-----------------------------------------------------------------------+\n'
+ '| Flag | '
+ 'Meaning '
+ '|\n'
+ '+===========+=======================================================================+\n'
+ '| "\'#\'" | The value conversion will use the "alternate '
+ 'form" (where defined |\n'
+ '| | '
+ 'below). '
+ '|\n'
+ '+-----------+-----------------------------------------------------------------------+\n'
+ '| "\'0\'" | The conversion will be zero padded for numeric '
+ 'values. |\n'
+ '+-----------+-----------------------------------------------------------------------+\n'
+ '| "\'-\'" | The converted value is left adjusted (overrides '
+ 'the "\'0\'" conversion |\n'
+ '| | if both are '
+ 'given). |\n'
+ '+-----------+-----------------------------------------------------------------------+\n'
+ '| "\' \'" | (a space) A blank should be left before a '
+ 'positive number (or empty |\n'
+ '| | string) produced by a signed '
+ 'conversion. |\n'
+ '+-----------+-----------------------------------------------------------------------+\n'
+ '| "\'+\'" | A sign character ("\'+\'" or "\'-\'") will '
+ 'precede the conversion |\n'
+ '| | (overrides a "space" '
+ 'flag). |\n'
+ '+-----------+-----------------------------------------------------------------------+\n'
+ '\n'
+ 'A length modifier ("h", "l", or "L") may be present, but is '
+ 'ignored as\n'
+ 'it is not necessary for Python -- so e.g. "%ld" is identical to '
+ '"%d".\n'
+ '\n'
+ 'The conversion types are:\n'
+ '\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| Conversion | '
+ 'Meaning | Notes '
+ '|\n'
+ '+==============+=======================================================+=========+\n'
+ '| "\'d\'" | Signed integer '
+ 'decimal. | |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'i\'" | Signed integer '
+ 'decimal. | |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'o\'" | Signed octal '
+ 'value. | (1) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'u\'" | Obsolete type -- it is identical to '
+ '"\'d\'". | (7) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'x\'" | Signed hexadecimal '
+ '(lowercase). | (2) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'X\'" | Signed hexadecimal '
+ '(uppercase). | (2) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'e\'" | Floating point exponential format '
+ '(lowercase). | (3) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'E\'" | Floating point exponential format '
+ '(uppercase). | (3) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'f\'" | Floating point decimal '
+ 'format. | (3) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'F\'" | Floating point decimal '
+ 'format. | (3) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'g\'" | Floating point format. Uses lowercase '
+ 'exponential | (4) |\n'
+ '| | format if exponent is less than -4 or not less '
+ 'than | |\n'
+ '| | precision, decimal format '
+ 'otherwise. | |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'G\'" | Floating point format. Uses uppercase '
+ 'exponential | (4) |\n'
+ '| | format if exponent is less than -4 or not less '
+ 'than | |\n'
+ '| | precision, decimal format '
+ 'otherwise. | |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'c\'" | Single character (accepts integer or single '
+ 'character | |\n'
+ '| | '
+ 'string). | '
+ '|\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'r\'" | String (converts any Python object using '
+ 'repr()). | (5) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'s\'" | String (converts any Python object using '
+ '"str()"). | (6) |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '| "\'%\'" | No argument is converted, results in a '
+ '"\'%\'" | |\n'
+ '| | character in the '
+ 'result. | |\n'
+ '+--------------+-------------------------------------------------------+---------+\n'
+ '\n'
+ 'Notes:\n'
+ '\n'
+ '1. The alternate form causes a leading zero ("\'0\'") to be '
+ 'inserted\n'
+ ' between left-hand padding and the formatting of the number if '
+ 'the\n'
+ ' leading character of the result is not already a zero.\n'
+ '\n'
+ '2. The alternate form causes a leading "\'0x\'" or "\'0X\'" '
+ '(depending\n'
+ ' on whether the "\'x\'" or "\'X\'" format was used) to be '
+ 'inserted\n'
+ ' before the first digit.\n'
+ '\n'
+ '3. The alternate form causes the result to always contain a '
+ 'decimal\n'
+ ' point, even if no digits follow it.\n'
+ '\n'
+ ' The precision determines the number of digits after the '
+ 'decimal\n'
+ ' point and defaults to 6.\n'
+ '\n'
+ '4. The alternate form causes the result to always contain a '
+ 'decimal\n'
+ ' point, and trailing zeroes are not removed as they would '
+ 'otherwise\n'
+ ' be.\n'
+ '\n'
+ ' The precision determines the number of significant digits '
+ 'before\n'
+ ' and after the decimal point and defaults to 6.\n'
+ '\n'
+ '5. The "%r" conversion was added in Python 2.0.\n'
+ '\n'
+ ' The precision determines the maximal number of characters '
+ 'used.\n'
+ '\n'
+ '6. If the object or format provided is a "unicode" string, the\n'
+ ' resulting string will also be "unicode".\n'
+ '\n'
+ ' The precision determines the maximal number of characters '
+ 'used.\n'
+ '\n'
+ '7. See **PEP 237**.\n'
+ '\n'
+ 'Since Python strings have an explicit length, "%s" conversions '
+ 'do not\n'
+ 'assume that "\'\\0\'" is the end of the string.\n'
+ '\n'
+ 'Changed in version 2.7: "%f" conversions for numbers whose '
+ 'absolute\n'
+ 'value is over 1e50 are no longer replaced by "%g" conversions.\n'
+ '\n'
+ 'Additional string operations are defined in standard modules '
+ '"string"\n'
+ 'and "re".\n'
+ '\n'
+ '\n'
+ 'XRange Type\n'
+ '===========\n'
+ '\n'
+ 'The "xrange" type is an immutable sequence which is commonly '
+ 'used for\n'
+ 'looping. The advantage of the "xrange" type is that an '
+ '"xrange"\n'
+ 'object will always take the same amount of memory, no matter the '
+ 'size\n'
+ 'of the range it represents. There are no consistent '
+ 'performance\n'
+ 'advantages.\n'
+ '\n'
+ 'XRange objects have very little behavior: they only support '
+ 'indexing,\n'
+ 'iteration, and the "len()" function.\n'
+ '\n'
+ '\n'
+ 'Mutable Sequence Types\n'
+ '======================\n'
+ '\n'
+ 'List and "bytearray" objects support additional operations that '
+ 'allow\n'
+ 'in-place modification of the object. Other mutable sequence '
+ 'types\n'
+ '(when added to the language) should also support these '
+ 'operations.\n'
+ 'Strings and tuples are immutable sequence types: such objects '
+ 'cannot\n'
+ 'be modified once created. The following operations are defined '
+ 'on\n'
+ 'mutable sequence types (where *x* is an arbitrary object):\n'
+ '\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| Operation | '
+ 'Result | Notes |\n'
+ '+================================+==================================+=======================+\n'
+ '| "s[i] = x" | item *i* of *s* is replaced '
+ 'by | |\n'
+ '| | '
+ '*x* | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s[i:j] = t" | slice of *s* from *i* to *j* '
+ 'is | |\n'
+ '| | replaced by the contents of '
+ 'the | |\n'
+ '| | iterable '
+ '*t* | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "del s[i:j]" | same as "s[i:j] = '
+ '[]" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s[i:j:k] = t" | the elements of "s[i:j:k]" '
+ 'are | (1) |\n'
+ '| | replaced by those of '
+ '*t* | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "del s[i:j:k]" | removes the elements '
+ 'of | |\n'
+ '| | "s[i:j:k]" from the '
+ 'list | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.append(x)" | same as "s[len(s):len(s)] = '
+ '[x]" | (2) |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.extend(t)" or "s += t" | for the most part the same '
+ 'as | (3) |\n'
+ '| | "s[len(s):len(s)] = '
+ 't" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s *= n" | updates *s* with its '
+ 'contents | (11) |\n'
+ '| | repeated *n* '
+ 'times | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.count(x)" | return number of *i*\'s for '
+ 'which | |\n'
+ '| | "s[i] == '
+ 'x" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.index(x[, i[, j]])" | return smallest *k* such '
+ 'that | (4) |\n'
+ '| | "s[k] == x" and "i <= k < '
+ 'j" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.insert(i, x)" | same as "s[i:i] = '
+ '[x]" | (5) |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.pop([i])" | same as "x = s[i]; del '
+ 's[i]; | (6) |\n'
+ '| | return '
+ 'x" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.remove(x)" | same as "del '
+ 's[s.index(x)]" | (4) |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.reverse()" | reverses the items of *s* '
+ 'in | (7) |\n'
+ '| | '
+ 'place | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.sort([cmp[, key[, | sort the items of *s* in '
+ 'place | (7)(8)(9)(10) |\n'
+ '| reverse]]])" '
+ '| | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '\n'
+ 'Notes:\n'
+ '\n'
+ '1. *t* must have the same length as the slice it is replacing.\n'
+ '\n'
+ '2. The C implementation of Python has historically accepted\n'
+ ' multiple parameters and implicitly joined them into a tuple; '
+ 'this\n'
+ ' no longer works in Python 2.0. Use of this misfeature has '
+ 'been\n'
+ ' deprecated since Python 1.4.\n'
+ '\n'
+ '3. *t* can be any iterable object.\n'
+ '\n'
+ '4. Raises "ValueError" when *x* is not found in *s*. When a\n'
+ ' negative index is passed as the second or third parameter to '
+ 'the\n'
+ ' "index()" method, the list length is added, as for slice '
+ 'indices.\n'
+ ' If it is still negative, it is truncated to zero, as for '
+ 'slice\n'
+ ' indices.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, "index()" didn\'t have '
+ 'arguments\n'
+ ' for specifying start and stop positions.\n'
+ '\n'
+ '5. When a negative index is passed as the first parameter to '
+ 'the\n'
+ ' "insert()" method, the list length is added, as for slice '
+ 'indices.\n'
+ ' If it is still negative, it is truncated to zero, as for '
+ 'slice\n'
+ ' indices.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, all negative indices '
+ 'were\n'
+ ' truncated to zero.\n'
+ '\n'
+ '6. The "pop()" method\'s optional argument *i* defaults to "-1", '
+ 'so\n'
+ ' that by default the last item is removed and returned.\n'
+ '\n'
+ '7. The "sort()" and "reverse()" methods modify the list in '
+ 'place\n'
+ ' for economy of space when sorting or reversing a large list. '
+ 'To\n'
+ " remind you that they operate by side effect, they don't "
+ 'return the\n'
+ ' sorted or reversed list.\n'
+ '\n'
+ '8. The "sort()" method takes optional arguments for controlling '
+ 'the\n'
+ ' comparisons.\n'
+ '\n'
+ ' *cmp* specifies a custom comparison function of two arguments '
+ '(list\n'
+ ' items) which should return a negative, zero or positive '
+ 'number\n'
+ ' depending on whether the first argument is considered smaller '
+ 'than,\n'
+ ' equal to, or larger than the second argument: "cmp=lambda '
+ 'x,y:\n'
+ ' cmp(x.lower(), y.lower())". The default value is "None".\n'
+ '\n'
+ ' *key* specifies a function of one argument that is used to '
+ 'extract\n'
+ ' a comparison key from each list element: "key=str.lower". '
+ 'The\n'
+ ' default value is "None".\n'
+ '\n'
+ ' *reverse* is a boolean value. If set to "True", then the '
+ 'list\n'
+ ' elements are sorted as if each comparison were reversed.\n'
+ '\n'
+ ' In general, the *key* and *reverse* conversion processes are '
+ 'much\n'
+ ' faster than specifying an equivalent *cmp* function. This '
+ 'is\n'
+ ' because *cmp* is called multiple times for each list element '
+ 'while\n'
+ ' *key* and *reverse* touch each element only once. Use\n'
+ ' "functools.cmp_to_key()" to convert an old-style *cmp* '
+ 'function to\n'
+ ' a *key* function.\n'
+ '\n'
+ ' Changed in version 2.3: Support for "None" as an equivalent '
+ 'to\n'
+ ' omitting *cmp* was added.\n'
+ '\n'
+ ' Changed in version 2.4: Support for *key* and *reverse* was '
+ 'added.\n'
+ '\n'
+ '9. Starting with Python 2.3, the "sort()" method is guaranteed '
+ 'to\n'
+ ' be stable. A sort is stable if it guarantees not to change '
+ 'the\n'
+ ' relative order of elements that compare equal --- this is '
+ 'helpful\n'
+ ' for sorting in multiple passes (for example, sort by '
+ 'department,\n'
+ ' then by salary grade).\n'
+ '\n'
+ '10. **CPython implementation detail:** While a list is being\n'
+ ' sorted, the effect of attempting to mutate, or even inspect, '
+ 'the\n'
+ ' list is undefined. The C implementation of Python 2.3 and '
+ 'newer\n'
+ ' makes the list appear empty for the duration, and raises\n'
+ ' "ValueError" if it can detect that the list has been '
+ 'mutated\n'
+ ' during a sort.\n'
+ '\n'
+ '11. The value *n* is an integer, or an object implementing\n'
+ ' "__index__()". Zero and negative values of *n* clear the\n'
+ ' sequence. Items in the sequence are not copied; they are\n'
+ ' referenced multiple times, as explained for "s * n" under '
+ 'Sequence\n'
+ ' Types --- str, unicode, list, tuple, bytearray, buffer, '
+ 'xrange.\n',
+ 'typesseq-mutable': '\n'
+ 'Mutable Sequence Types\n'
+ '**********************\n'
+ '\n'
+ 'List and "bytearray" objects support additional '
+ 'operations that allow\n'
+ 'in-place modification of the object. Other mutable '
+ 'sequence types\n'
+ '(when added to the language) should also support these '
+ 'operations.\n'
+ 'Strings and tuples are immutable sequence types: such '
+ 'objects cannot\n'
+ 'be modified once created. The following operations are '
+ 'defined on\n'
+ 'mutable sequence types (where *x* is an arbitrary '
+ 'object):\n'
+ '\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| Operation | '
+ 'Result | Notes '
+ '|\n'
+ '+================================+==================================+=======================+\n'
+ '| "s[i] = x" | item *i* of *s* is '
+ 'replaced by | |\n'
+ '| | '
+ '*x* | '
+ '|\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s[i:j] = t" | slice of *s* from *i* '
+ 'to *j* is | |\n'
+ '| | replaced by the '
+ 'contents of the | |\n'
+ '| | iterable '
+ '*t* | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "del s[i:j]" | same as "s[i:j] = '
+ '[]" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s[i:j:k] = t" | the elements of '
+ '"s[i:j:k]" are | (1) |\n'
+ '| | replaced by those of '
+ '*t* | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "del s[i:j:k]" | removes the elements '
+ 'of | |\n'
+ '| | "s[i:j:k]" from the '
+ 'list | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.append(x)" | same as '
+ '"s[len(s):len(s)] = [x]" | (2) |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.extend(t)" or "s += t" | for the most part the '
+ 'same as | (3) |\n'
+ '| | "s[len(s):len(s)] = '
+ 't" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s *= n" | updates *s* with its '
+ 'contents | (11) |\n'
+ '| | repeated *n* '
+ 'times | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.count(x)" | return number of '
+ "*i*'s for which | |\n"
+ '| | "s[i] == '
+ 'x" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.index(x[, i[, j]])" | return smallest *k* '
+ 'such that | (4) |\n'
+ '| | "s[k] == x" and "i <= '
+ 'k < j" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.insert(i, x)" | same as "s[i:i] = '
+ '[x]" | (5) |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.pop([i])" | same as "x = s[i]; '
+ 'del s[i]; | (6) |\n'
+ '| | return '
+ 'x" | |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.remove(x)" | same as "del '
+ 's[s.index(x)]" | (4) |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.reverse()" | reverses the items of '
+ '*s* in | (7) |\n'
+ '| | '
+ 'place | '
+ '|\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '| "s.sort([cmp[, key[, | sort the items of *s* '
+ 'in place | (7)(8)(9)(10) |\n'
+ '| reverse]]])" '
+ '| '
+ '| |\n'
+ '+--------------------------------+----------------------------------+-----------------------+\n'
+ '\n'
+ 'Notes:\n'
+ '\n'
+ '1. *t* must have the same length as the slice it is '
+ 'replacing.\n'
+ '\n'
+ '2. The C implementation of Python has historically '
+ 'accepted\n'
+ ' multiple parameters and implicitly joined them into a '
+ 'tuple; this\n'
+ ' no longer works in Python 2.0. Use of this '
+ 'misfeature has been\n'
+ ' deprecated since Python 1.4.\n'
+ '\n'
+ '3. *t* can be any iterable object.\n'
+ '\n'
+ '4. Raises "ValueError" when *x* is not found in *s*. '
+ 'When a\n'
+ ' negative index is passed as the second or third '
+ 'parameter to the\n'
+ ' "index()" method, the list length is added, as for '
+ 'slice indices.\n'
+ ' If it is still negative, it is truncated to zero, as '
+ 'for slice\n'
+ ' indices.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, "index()" didn\'t '
+ 'have arguments\n'
+ ' for specifying start and stop positions.\n'
+ '\n'
+ '5. When a negative index is passed as the first '
+ 'parameter to the\n'
+ ' "insert()" method, the list length is added, as for '
+ 'slice indices.\n'
+ ' If it is still negative, it is truncated to zero, as '
+ 'for slice\n'
+ ' indices.\n'
+ '\n'
+ ' Changed in version 2.3: Previously, all negative '
+ 'indices were\n'
+ ' truncated to zero.\n'
+ '\n'
+ '6. The "pop()" method\'s optional argument *i* defaults '
+ 'to "-1", so\n'
+ ' that by default the last item is removed and '
+ 'returned.\n'
+ '\n'
+ '7. The "sort()" and "reverse()" methods modify the list '
+ 'in place\n'
+ ' for economy of space when sorting or reversing a '
+ 'large list. To\n'
+ ' remind you that they operate by side effect, they '
+ "don't return the\n"
+ ' sorted or reversed list.\n'
+ '\n'
+ '8. The "sort()" method takes optional arguments for '
+ 'controlling the\n'
+ ' comparisons.\n'
+ '\n'
+ ' *cmp* specifies a custom comparison function of two '
+ 'arguments (list\n'
+ ' items) which should return a negative, zero or '
+ 'positive number\n'
+ ' depending on whether the first argument is considered '
+ 'smaller than,\n'
+ ' equal to, or larger than the second argument: '
+ '"cmp=lambda x,y:\n'
+ ' cmp(x.lower(), y.lower())". The default value is '
+ '"None".\n'
+ '\n'
+ ' *key* specifies a function of one argument that is '
+ 'used to extract\n'
+ ' a comparison key from each list element: '
+ '"key=str.lower". The\n'
+ ' default value is "None".\n'
+ '\n'
+ ' *reverse* is a boolean value. If set to "True", then '
+ 'the list\n'
+ ' elements are sorted as if each comparison were '
+ 'reversed.\n'
+ '\n'
+ ' In general, the *key* and *reverse* conversion '
+ 'processes are much\n'
+ ' faster than specifying an equivalent *cmp* function. '
+ 'This is\n'
+ ' because *cmp* is called multiple times for each list '
+ 'element while\n'
+ ' *key* and *reverse* touch each element only once. '
+ 'Use\n'
+ ' "functools.cmp_to_key()" to convert an old-style '
+ '*cmp* function to\n'
+ ' a *key* function.\n'
+ '\n'
+ ' Changed in version 2.3: Support for "None" as an '
+ 'equivalent to\n'
+ ' omitting *cmp* was added.\n'
+ '\n'
+ ' Changed in version 2.4: Support for *key* and '
+ '*reverse* was added.\n'
+ '\n'
+ '9. Starting with Python 2.3, the "sort()" method is '
+ 'guaranteed to\n'
+ ' be stable. A sort is stable if it guarantees not to '
+ 'change the\n'
+ ' relative order of elements that compare equal --- '
+ 'this is helpful\n'
+ ' for sorting in multiple passes (for example, sort by '
+ 'department,\n'
+ ' then by salary grade).\n'
+ '\n'
+ '10. **CPython implementation detail:** While a list is '
+ 'being\n'
+ ' sorted, the effect of attempting to mutate, or even '
+ 'inspect, the\n'
+ ' list is undefined. The C implementation of Python '
+ '2.3 and newer\n'
+ ' makes the list appear empty for the duration, and '
+ 'raises\n'
+ ' "ValueError" if it can detect that the list has been '
+ 'mutated\n'
+ ' during a sort.\n'
+ '\n'
+ '11. The value *n* is an integer, or an object '
+ 'implementing\n'
+ ' "__index__()". Zero and negative values of *n* '
+ 'clear the\n'
+ ' sequence. Items in the sequence are not copied; '
+ 'they are\n'
+ ' referenced multiple times, as explained for "s * n" '
+ 'under Sequence\n'
+ ' Types --- str, unicode, list, tuple, bytearray, '
+ 'buffer, xrange.\n',
+ 'unary': '\n'
+ 'Unary arithmetic and bitwise operations\n'
+ '***************************************\n'
+ '\n'
+ 'All unary arithmetic and bitwise operations have the same '
+ 'priority:\n'
+ '\n'
+ ' u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr\n'
+ '\n'
+ 'The unary "-" (minus) operator yields the negation of its numeric\n'
+ 'argument.\n'
+ '\n'
+ 'The unary "+" (plus) operator yields its numeric argument '
+ 'unchanged.\n'
+ '\n'
+ 'The unary "~" (invert) operator yields the bitwise inversion of '
+ 'its\n'
+ 'plain or long integer argument. The bitwise inversion of "x" is\n'
+ 'defined as "-(x+1)". It only applies to integral numbers.\n'
+ '\n'
+ 'In all three cases, if the argument does not have the proper type, '
+ 'a\n'
+ '"TypeError" exception is raised.\n',
+ 'while': '\n'
+ 'The "while" statement\n'
+ '*********************\n'
+ '\n'
+ 'The "while" statement is used for repeated execution as long as an\n'
+ 'expression is true:\n'
+ '\n'
+ ' while_stmt ::= "while" expression ":" suite\n'
+ ' ["else" ":" suite]\n'
+ '\n'
+ 'This repeatedly tests the expression and, if it is true, executes '
+ 'the\n'
+ 'first suite; if the expression is false (which may be the first '
+ 'time\n'
+ 'it is tested) the suite of the "else" clause, if present, is '
+ 'executed\n'
+ 'and the loop terminates.\n'
+ '\n'
+ 'A "break" statement executed in the first suite terminates the '
+ 'loop\n'
+ 'without executing the "else" clause\'s suite. A "continue" '
+ 'statement\n'
+ 'executed in the first suite skips the rest of the suite and goes '
+ 'back\n'
+ 'to testing the expression.\n',
+ 'with': '\n'
+ 'The "with" statement\n'
+ '********************\n'
+ '\n'
+ 'New in version 2.5.\n'
+ '\n'
+ 'The "with" statement is used to wrap the execution of a block with\n'
+ 'methods defined by a context manager (see section With Statement\n'
+ 'Context Managers). This allows common "try"..."except"..."finally"\n'
+ 'usage patterns to be encapsulated for convenient reuse.\n'
+ '\n'
+ ' with_stmt ::= "with" with_item ("," with_item)* ":" suite\n'
+ ' with_item ::= expression ["as" target]\n'
+ '\n'
+ 'The execution of the "with" statement with one "item" proceeds as\n'
+ 'follows:\n'
+ '\n'
+ '1. The context expression (the expression given in the "with_item")\n'
+ ' is evaluated to obtain a context manager.\n'
+ '\n'
+ '2. The context manager\'s "__exit__()" is loaded for later use.\n'
+ '\n'
+ '3. The context manager\'s "__enter__()" method is invoked.\n'
+ '\n'
+ '4. If a target was included in the "with" statement, the return\n'
+ ' value from "__enter__()" is assigned to it.\n'
+ '\n'
+ ' Note: The "with" statement guarantees that if the "__enter__()"\n'
+ ' method returns without an error, then "__exit__()" will always '
+ 'be\n'
+ ' called. Thus, if an error occurs during the assignment to the\n'
+ ' target list, it will be treated the same as an error occurring\n'
+ ' within the suite would be. See step 6 below.\n'
+ '\n'
+ '5. The suite is executed.\n'
+ '\n'
+ '6. The context manager\'s "__exit__()" method is invoked. If an\n'
+ ' exception caused the suite to be exited, its type, value, and\n'
+ ' traceback are passed as arguments to "__exit__()". Otherwise, '
+ 'three\n'
+ ' "None" arguments are supplied.\n'
+ '\n'
+ ' If the suite was exited due to an exception, and the return '
+ 'value\n'
+ ' from the "__exit__()" method was false, the exception is '
+ 'reraised.\n'
+ ' If the return value was true, the exception is suppressed, and\n'
+ ' execution continues with the statement following the "with"\n'
+ ' statement.\n'
+ '\n'
+ ' If the suite was exited for any reason other than an exception, '
+ 'the\n'
+ ' return value from "__exit__()" is ignored, and execution '
+ 'proceeds\n'
+ ' at the normal location for the kind of exit that was taken.\n'
+ '\n'
+ 'With more than one item, the context managers are processed as if\n'
+ 'multiple "with" statements were nested:\n'
+ '\n'
+ ' with A() as a, B() as b:\n'
+ ' suite\n'
+ '\n'
+ 'is equivalent to\n'
+ '\n'
+ ' with A() as a:\n'
+ ' with B() as b:\n'
+ ' suite\n'
+ '\n'
+ 'Note: In Python 2.5, the "with" statement is only allowed when the\n'
+ ' "with_statement" feature has been enabled. It is always enabled '
+ 'in\n'
+ ' Python 2.6.\n'
+ '\n'
+ 'Changed in version 2.7: Support for multiple context expressions.\n'
+ '\n'
+ 'See also:\n'
+ '\n'
+ ' **PEP 343** - The "with" statement\n'
+ ' The specification, background, and examples for the Python '
+ '"with"\n'
+ ' statement.\n',
+ 'yield': '\n'
+ 'The "yield" statement\n'
+ '*********************\n'
+ '\n'
+ ' yield_stmt ::= yield_expression\n'
+ '\n'
+ 'The "yield" statement is only used when defining a generator '
+ 'function,\n'
+ 'and is only used in the body of the generator function. Using a\n'
+ '"yield" statement in a function definition is sufficient to cause '
+ 'that\n'
+ 'definition to create a generator function instead of a normal\n'
+ 'function.\n'
+ '\n'
+ 'When a generator function is called, it returns an iterator known '
+ 'as a\n'
+ 'generator iterator, or more commonly, a generator. The body of '
+ 'the\n'
+ "generator function is executed by calling the generator's "
+ '"next()"\n'
+ 'method repeatedly until it raises an exception.\n'
+ '\n'
+ 'When a "yield" statement is executed, the state of the generator '
+ 'is\n'
+ 'frozen and the value of "expression_list" is returned to '
+ '"next()"\'s\n'
+ 'caller. By "frozen" we mean that all local state is retained,\n'
+ 'including the current bindings of local variables, the instruction\n'
+ 'pointer, and the internal evaluation stack: enough information is\n'
+ 'saved so that the next time "next()" is invoked, the function can\n'
+ 'proceed exactly as if the "yield" statement were just another '
+ 'external\n'
+ 'call.\n'
+ '\n'
+ 'As of Python version 2.5, the "yield" statement is now allowed in '
+ 'the\n'
+ '"try" clause of a "try" ... "finally" construct. If the generator '
+ 'is\n'
+ 'not resumed before it is finalized (by reaching a zero reference '
+ 'count\n'
+ "or by being garbage collected), the generator-iterator's "
+ '"close()"\n'
+ 'method will be called, allowing any pending "finally" clauses to\n'
+ 'execute.\n'
+ '\n'
+ 'For full details of "yield" semantics, refer to the Yield '
+ 'expressions\n'
+ 'section.\n'
+ '\n'
+ 'Note: In Python 2.2, the "yield" statement was only allowed when '
+ 'the\n'
+ ' "generators" feature has been enabled. This "__future__" import\n'
+ ' statement was used to enable the feature:\n'
+ '\n'
+ ' from __future__ import generators\n'
+ '\n'
+ 'See also:\n'
+ '\n'
+ ' **PEP 255** - Simple Generators\n'
+ ' The proposal for adding generators and the "yield" statement '
+ 'to\n'
+ ' Python.\n'
+ '\n'
+ ' **PEP 342** - Coroutines via Enhanced Generators\n'
+ ' The proposal that, among other generator enhancements, '
+ 'proposed\n'
+ ' allowing "yield" to appear inside a "try" ... "finally" '
+ 'block.\n'}
self.gauss_next = None
def seed(self, a=None):
- """Initialize internal state from hashable object.
+ """Initialize internal state of the random number generator.
None or no argument seeds from current time or from an operating
system specific randomness source if available.
- If a is not None or an int or long, hash(a) is used instead.
+ If a is not None or is an int or long, hash(a) is used instead.
+ Hash values for some types are nondeterministic when the
+ PYTHONHASHSEED environment variable is enabled.
"""
if a is None:
import errno
try:
+ import zlib
+ del zlib
+ _ZLIB_SUPPORTED = True
+except ImportError:
+ _ZLIB_SUPPORTED = False
+
+try:
+ import bz2
+ del bz2
+ _BZ2_SUPPORTED = True
+except ImportError:
+ _BZ2_SUPPORTED = False
+
+try:
from pwd import getpwnam
except ImportError:
getpwnam = None
Returns the output filename.
"""
- tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', None: ''}
- compress_ext = {'gzip': '.gz', 'bzip2': '.bz2'}
-
- # flags for compression program, each element of list will be an argument
- if compress is not None and compress not in compress_ext.keys():
- raise ValueError, \
- ("bad value for 'compress': must be None, 'gzip' or 'bzip2'")
+ if compress is None:
+ tar_compression = ''
+ elif _ZLIB_SUPPORTED and compress == 'gzip':
+ tar_compression = 'gz'
+ elif _BZ2_SUPPORTED and compress == 'bzip2':
+ tar_compression = 'bz2'
+ else:
+ raise ValueError("bad value for 'compress', or compression format not "
+ "supported : {0}".format(compress))
- archive_name = base_name + '.tar' + compress_ext.get(compress, '')
+ compress_ext = '.' + tar_compression if compress else ''
+ archive_name = base_name + '.tar' + compress_ext
archive_dir = os.path.dirname(archive_name)
if archive_dir and not os.path.exists(archive_dir):
return tarinfo
if not dry_run:
- tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
+ tar = tarfile.open(archive_name, 'w|%s' % tar_compression)
try:
tar.add(base_dir, filter=_set_uid_gid)
finally:
# If zipfile module is not available, try spawning an external 'zip'
# command.
try:
+ import zlib
import zipfile
except ImportError:
zipfile = None
return zip_filename
_ARCHIVE_FORMATS = {
- 'gztar': (_make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
- 'bztar': (_make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
'tar': (_make_tarball, [('compress', None)], "uncompressed tar file"),
- 'zip': (_make_zipfile, [],"ZIP file")
- }
+ 'zip': (_make_zipfile, [], "ZIP file")
+}
+
+if _ZLIB_SUPPORTED:
+ _ARCHIVE_FORMATS['gztar'] = (_make_tarball, [('compress', 'gzip')],
+ "gzip'ed tar-file")
+
+if _BZ2_SUPPORTED:
+ _ARCHIVE_FORMATS['bztar'] = (_make_tarball, [('compress', 'bzip2')],
+ "bzip2'ed tar-file")
def get_archive_formats():
"""Returns a list of supported formats for archiving and unarchiving.
"""Create an archive file (eg. zip or tar).
'base_name' is the name of the file to create, minus any format-specific
- extension; 'format' is the archive format: one of "zip", "tar", "bztar"
- or "gztar".
+ extension; 'format' is the archive format: one of "zip", "tar", "gztar",
+ or "bztar". Or any other registered format.
'root_dir' is a directory that will be the root directory of the
archive; ie. we typically chdir into 'root_dir' before creating the
if host:
(code, msg) = self.connect(host, port)
if code != 220:
+ self.close()
raise SMTPConnectError(code, msg)
if local_hostname is not None:
self.local_hostname = local_hostname
if sqlite.sqlite_version_info < (3, 1):
return
- # SQLite's current_timestamp uses UTC time, while datetime.datetime.now() uses local time.
- now = datetime.datetime.now()
+ now = datetime.datetime.utcnow()
self.cur.execute("insert into test(ts) values (current_timestamp)")
self.cur.execute("select ts from test")
ts = self.cur.fetchone()[0]
# this contains min/max pattern width, and an optional literal
# prefix or a character map
lo, hi = pattern.getwidth()
- if lo == 0:
+ if not lo and hi:
return # not worth it
# look for a literal prefix
prefix = []
OCTDIGITS = set("01234567")
HEXDIGITS = set("0123456789abcdefABCDEF")
+ASCIILETTERS = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
WHITESPACE = set(" \t\n\r\v\f")
return False
return True
-def _class_escape(source, escape):
+def _class_escape(source, escape, nested):
# handle escape code inside character class
code = ESCAPES.get(escape)
if code:
elif c in DIGITS:
raise error, "bogus escape: %s" % repr(escape)
if len(escape) == 2:
+ if sys.py3kwarning and c in ASCIILETTERS:
+ import warnings
+ if c in 'Uu':
+ warnings.warn('bad escape %s; Unicode escapes are '
+ 'supported only since Python 3.3' % escape,
+ FutureWarning, stacklevel=nested + 6)
+ else:
+ warnings.warnpy3k('bad escape %s' % escape,
+ DeprecationWarning, stacklevel=nested + 6)
return LITERAL, ord(escape[1])
except ValueError:
pass
raise error, "bogus escape: %s" % repr(escape)
-def _escape(source, escape, state):
+def _escape(source, escape, state, nested):
# handle escape code in expression
code = CATEGORIES.get(escape)
if code:
import warnings
warnings.warn('group references in lookbehind '
'assertions are not supported',
- RuntimeWarning)
+ RuntimeWarning, stacklevel=nested + 6)
return GROUPREF, group
raise ValueError
if len(escape) == 2:
+ if sys.py3kwarning and c in ASCIILETTERS:
+ import warnings
+ if c in 'Uu':
+ warnings.warn('bad escape %s; Unicode escapes are '
+ 'supported only since Python 3.3' % escape,
+ FutureWarning, stacklevel=nested + 6)
+ else:
+ warnings.warnpy3k('bad escape %s' % escape,
+ DeprecationWarning, stacklevel=nested + 6)
return LITERAL, ord(escape[1])
except ValueError:
pass
raise error, "bogus escape: %s" % repr(escape)
-def _parse_sub(source, state, nested=1):
+def _parse_sub(source, state, nested):
# parse an alternation: a|b|c
items = []
itemsappend = items.append
sourcematch = source.match
while 1:
- itemsappend(_parse(source, state))
+ itemsappend(_parse(source, state, nested + 1))
if sourcematch("|"):
continue
if not nested:
subpattern.append((BRANCH, (None, items)))
return subpattern
-def _parse_sub_cond(source, state, condgroup):
- item_yes = _parse(source, state)
+def _parse_sub_cond(source, state, condgroup, nested):
+ item_yes = _parse(source, state, nested + 1)
if source.match("|"):
- item_no = _parse(source, state)
+ item_no = _parse(source, state, nested + 1)
if source.match("|"):
raise error, "conditional backref with more than two branches"
else:
_LOOKBEHINDASSERTCHARS = set("=!")
_REPEATCODES = set([MIN_REPEAT, MAX_REPEAT])
-def _parse(source, state):
+def _parse(source, state, nested):
# parse a simple pattern
subpattern = SubPattern(state)
if this == "]" and set != start:
break
elif this and this[0] == "\\":
- code1 = _class_escape(source, this)
+ code1 = _class_escape(source, this, nested + 1)
elif this:
code1 = LITERAL, ord(this)
else:
break
elif this:
if this[0] == "\\":
- code2 = _class_escape(source, this)
+ code2 = _class_escape(source, this, nested + 1)
else:
code2 = LITERAL, ord(this)
if code1[0] != LITERAL or code2[0] != LITERAL:
import warnings
warnings.warn('group references in lookbehind '
'assertions are not supported',
- RuntimeWarning)
+ RuntimeWarning, stacklevel=nested + 6)
subpatternappend((GROUPREF, gid))
continue
else:
dir = -1 # lookbehind
char = sourceget()
state.lookbehind += 1
- p = _parse_sub(source, state)
+ p = _parse_sub(source, state, nested + 1)
if dir < 0:
state.lookbehind -= 1
if not sourcematch(")"):
import warnings
warnings.warn('group references in lookbehind '
'assertions are not supported',
- RuntimeWarning)
+ RuntimeWarning, stacklevel=nested + 6)
else:
# flags
if not source.next in FLAGS:
else:
group = state.opengroup(name)
if condgroup:
- p = _parse_sub_cond(source, state, condgroup)
+ p = _parse_sub_cond(source, state, condgroup, nested + 1)
else:
- p = _parse_sub(source, state)
+ p = _parse_sub(source, state, nested + 1)
if not sourcematch(")"):
raise error, "unbalanced parenthesis"
if group is not None:
subpattern.append((AT, AT_END))
elif this and this[0] == "\\":
- code = _escape(source, this, state)
+ code = _escape(source, this, state, nested + 1)
subpatternappend(code)
else:
pattern.str = str
p = _parse_sub(source, pattern, 0)
+ if (sys.py3kwarning and
+ (p.pattern.flags & SRE_FLAG_LOCALE) and
+ (p.pattern.flags & SRE_FLAG_UNICODE)):
+ import warnings
+ warnings.warnpy3k("LOCALE and UNICODE flags are incompatible",
+ DeprecationWarning, stacklevel=5)
tail = source.get()
if tail == ")":
try:
this = makechar(ESCAPES[this][1])
except KeyError:
- pass
+ if sys.py3kwarning and c in ASCIILETTERS:
+ import warnings
+ warnings.warnpy3k('bad escape %s' % this,
+ DeprecationWarning, stacklevel=4)
literal(this)
else:
literal(this)
p2cread, _ = _subprocess.CreatePipe(None, 0)
elif stdin == PIPE:
p2cread, p2cwrite = _subprocess.CreatePipe(None, 0)
- elif isinstance(stdin, int):
+ elif isinstance(stdin, (int, long)):
p2cread = msvcrt.get_osfhandle(stdin)
else:
# Assuming file-like object
_, c2pwrite = _subprocess.CreatePipe(None, 0)
elif stdout == PIPE:
c2pread, c2pwrite = _subprocess.CreatePipe(None, 0)
- elif isinstance(stdout, int):
+ elif isinstance(stdout, (int, long)):
c2pwrite = msvcrt.get_osfhandle(stdout)
else:
# Assuming file-like object
errread, errwrite = _subprocess.CreatePipe(None, 0)
elif stderr == STDOUT:
errwrite = c2pwrite
- elif isinstance(stderr, int):
+ elif isinstance(stderr, (int, long)):
errwrite = msvcrt.get_osfhandle(stderr)
else:
# Assuming file-like object
if e.errno == errno.EPIPE:
# communicate() should ignore broken pipe error
pass
- elif (e.errno == errno.EINVAL
- and self.poll() is not None):
- # Issue #19612: stdin.write() fails with EINVAL
- # if the process already exited before the write
+ elif e.errno == errno.EINVAL:
+ # bpo-19612, bpo-30418: On Windows, stdin.write()
+ # fails with EINVAL if the child process exited or
+ # if the child process is still running but closed
+ # the pipe.
pass
else:
raise
elif stdin == PIPE:
p2cread, p2cwrite = self.pipe_cloexec()
to_close.update((p2cread, p2cwrite))
- elif isinstance(stdin, int):
+ elif isinstance(stdin, (int, long)):
p2cread = stdin
else:
# Assuming file-like object
elif stdout == PIPE:
c2pread, c2pwrite = self.pipe_cloexec()
to_close.update((c2pread, c2pwrite))
- elif isinstance(stdout, int):
+ elif isinstance(stdout, (int, long)):
c2pwrite = stdout
else:
# Assuming file-like object
errwrite = c2pwrite
else: # child's stdout is not set, use parent's stdout
errwrite = sys.__stdout__.fileno()
- elif isinstance(stderr, int):
+ elif isinstance(stderr, (int, long)):
errwrite = stderr
else:
# Assuming file-like object
def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
_WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED,
- _WEXITSTATUS=os.WEXITSTATUS):
+ _WEXITSTATUS=os.WEXITSTATUS, _WIFSTOPPED=os.WIFSTOPPED,
+ _WSTOPSIG=os.WSTOPSIG):
# This method is called (indirectly) by __del__, so it cannot
# refer to anything outside of its local scope.
if _WIFSIGNALED(sts):
self.returncode = -_WTERMSIG(sts)
elif _WIFEXITED(sts):
self.returncode = _WEXITSTATUS(sts)
+ elif _WIFSTOPPED(sts):
+ self.returncode = -_WSTOPSIG(sts)
else:
# Should never happen
raise RuntimeError("Unknown child exit status!")
# PC/VS7.1
if os.name == "nt" and "\\pc\\v" in _PROJECT_BASE[-10:].lower():
_PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
+# PC/VS9.0/amd64
+if (os.name == "nt"
+ and os.path.basename(os.path.dirname(os.path.dirname(_PROJECT_BASE))).lower() == "pc"
+ and os.path.basename(os.path.dirname(_PROJECT_BASE)).lower() == "vs9.0"):
+ _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir, pardir))
# PC/AMD64
if os.name == "nt" and "\\pcbuild\\amd64" in _PROJECT_BASE[-14:].lower():
_PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
class NannyNag(Exception):
"""
- Raised by tokeneater() if detecting an ambiguous indent.
+ Raised by process_tokens() if detecting an ambiguous indent.
Captured and handled in check().
"""
def __init__(self, lineno, msg, line):
--- /dev/null
+from test import regrtest
+
+regrtest.main_in_temp_cwd()
--- /dev/null
+#!/usr/bin/env python3
+"""
+Command line tool to bisect failing CPython tests.
+
+Find the test_os test method which alters the environment:
+
+ ./python -m test.bisect --fail-env-changed test_os
+
+Find a reference leak in "test_os", write the list of failing tests into the
+"bisect" file:
+
+ ./python -m test.bisect -o bisect -R 3:3 test_os
+
+Load an existing list of tests from a file using -i option:
+
+ ./python -m test --list-cases -m FileTests test_os > tests
+ ./python -m test.bisect -i tests test_os
+"""
+from __future__ import print_function
+
+import argparse
+import datetime
+import os.path
+import math
+import random
+import subprocess
+import sys
+import tempfile
+import time
+
+
+def write_tests(filename, tests):
+ with open(filename, "w") as fp:
+ for name in tests:
+ print(name, file=fp)
+ fp.flush()
+
+
+def write_output(filename, tests):
+ if not filename:
+ return
+ print("Write %s tests into %s" % (len(tests), filename))
+ write_tests(filename, tests)
+ return filename
+
+
+def format_shell_args(args):
+ return ' '.join(args)
+
+
+def list_cases(args):
+ cmd = [sys.executable, '-m', 'test', '--list-cases']
+ cmd.extend(args.test_args)
+ proc = subprocess.Popen(cmd,
+ stdout=subprocess.PIPE,
+ universal_newlines=True)
+ try:
+ stdout = proc.communicate()[0]
+ except:
+ proc.stdout.close()
+ proc.kill()
+ proc.wait()
+ raise
+ exitcode = proc.wait()
+ if exitcode:
+ cmd = format_shell_args(cmd)
+ print("Failed to list tests: %s failed with exit code %s"
+ % (cmd, exitcode))
+ sys.exit(exitcode)
+ tests = stdout.splitlines()
+ return tests
+
+
+def run_tests(args, tests, huntrleaks=None):
+ tmp = tempfile.mktemp()
+ try:
+ write_tests(tmp, tests)
+
+ cmd = [sys.executable, '-m', 'test', '--matchfile', tmp]
+ cmd.extend(args.test_args)
+ print("+ %s" % format_shell_args(cmd))
+ proc = subprocess.Popen(cmd)
+ try:
+ exitcode = proc.wait()
+ except:
+ proc.kill()
+ proc.wait()
+ raise
+ return exitcode
+ finally:
+ if os.path.exists(tmp):
+ os.unlink(tmp)
+
+
+def parse_args():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-i', '--input',
+ help='Test names produced by --list-tests written '
+ 'into a file. If not set, run --list-tests')
+ parser.add_argument('-o', '--output',
+ help='Result of the bisection')
+ parser.add_argument('-n', '--max-tests', type=int, default=1,
+ help='Maximum number of tests to stop the bisection '
+ '(default: 1)')
+ parser.add_argument('-N', '--max-iter', type=int, default=100,
+ help='Maximum number of bisection iterations '
+ '(default: 100)')
+ # FIXME: document that following arguments are test arguments
+
+ args, test_args = parser.parse_known_args()
+ args.test_args = test_args
+ return args
+
+
+def main():
+ args = parse_args()
+
+ if args.input:
+ with open(args.input) as fp:
+ tests = [line.strip() for line in fp]
+ else:
+ tests = list_cases(args)
+
+ print("Start bisection with %s tests" % len(tests))
+ print("Test arguments: %s" % format_shell_args(args.test_args))
+ print("Bisection will stop when getting %s or less tests "
+ "(-n/--max-tests option), or after %s iterations "
+ "(-N/--max-iter option)"
+ % (args.max_tests, args.max_iter))
+ output = write_output(args.output, tests)
+ print()
+
+ start_time = time.time()
+ iteration = 1
+ try:
+ while len(tests) > args.max_tests and iteration <= args.max_iter:
+ ntest = len(tests)
+ ntest = max(ntest // 2, 1)
+ subtests = random.sample(tests, ntest)
+
+ print("[+] Iteration %s: run %s tests/%s"
+ % (iteration, len(subtests), len(tests)))
+ print()
+
+ exitcode = run_tests(args, subtests)
+
+ print("ran %s tests/%s" % (ntest, len(tests)))
+ print("exit", exitcode)
+ if exitcode:
+ print("Tests failed: use this new subtest")
+ tests = subtests
+ output = write_output(args.output, tests)
+ else:
+ print("Tests succeeded: skip this subtest, try a new subbset")
+ print()
+ iteration += 1
+ except KeyboardInterrupt:
+ print()
+ print("Bisection interrupted!")
+ print()
+
+ print("Tests (%s):" % len(tests))
+ for test in tests:
+ print("* %s" % test)
+ print()
+
+ if output:
+ print("Output written into %s" % output)
+
+ dt = math.ceil(time.time() - start_time)
+ if len(tests) <= args.max_tests:
+ print("Bisection completed in %s iterations and %s"
+ % (iteration, datetime.timedelta(seconds=dt)))
+ sys.exit(1)
+ else:
+ print("Bisection failed after %s iterations and %s"
+ % (iteration, datetime.timedelta(seconds=dt)))
+
+
+if __name__ == "__main__":
+ main()
self.assertRaises(RuntimeError, cond.notify)
def _check_notify(self, cond):
+ # Note that this test is sensitive to timing. If the worker threads
+ # don't execute in a timely fashion, the main thread may think they
+ # are further along then they are. The main thread therefore issues
+ # _wait() statements to try to make sure that it doesn't race ahead
+ # of the workers.
+ # Secondly, this test assumes that condition variables are not subject
+ # to spurious wakeups. The absence of spurious wakeups is an implementation
+ # detail of Condition Cariables in current CPython, but in general, not
+ # a guaranteed property of condition variables as a programming
+ # construct. In particular, it is possible that this can no longer
+ # be conveniently guaranteed should their implementation ever change.
N = 5
+ ready = []
results1 = []
results2 = []
phase_num = 0
def f():
cond.acquire()
+ ready.append(phase_num)
cond.wait()
cond.release()
results1.append(phase_num)
cond.acquire()
+ ready.append(phase_num)
cond.wait()
cond.release()
results2.append(phase_num)
b = Bunch(f, N)
b.wait_for_started()
- _wait()
+ # first wait, to ensure all workers settle into cond.wait() before
+ # we continue. See issues #8799 and #30727.
+ while len(ready) < 5:
+ _wait()
+ ready = []
self.assertEqual(results1, [])
# Notify 3 threads at first
cond.acquire()
_wait()
self.assertEqual(results1, [1] * 3)
self.assertEqual(results2, [])
+ # make sure all awaken workers settle into cond.wait()
+ while len(ready) < 3:
+ _wait()
# Notify 5 threads: they might be in their first or second wait
cond.acquire()
cond.notify(5)
_wait()
self.assertEqual(results1, [1] * 3 + [2] * 2)
self.assertEqual(results2, [2] * 3)
+ # make sure all workers settle into cond.wait()
+ while len(ready) < 5:
+ _wait()
# Notify all threads: they are all in their second wait
cond.acquire()
cond.notify_all()
-# test_multibytecodec_support.py
+# multibytecodec_support.py
# Common Unittest Routines for CJK codecs
#
class H(object):
pass
+class MyErr(Exception):
+ def __init__(self):
+ pass
+
+class I:
+ def __init__(self, *args, **kwargs):
+ raise MyErr()
+
+ def __getinitargs__(self):
+ return ()
+
# Hashable mutable key
class K(object):
def __init__(self, value):
# Shouldn't support the recursion itself
return K, (self.value,)
-import __main__
+__main__ = sys.modules['__main__']
__main__.C = C
C.__module__ = "__main__"
__main__.D = D
E.__module__ = "__main__"
__main__.H = H
H.__module__ = "__main__"
+__main__.I = I
+I.__module__ = "__main__"
__main__.K = K
K.__module__ = "__main__"
'q\x00oq\x01}q\x02b.').replace('X', xname)
self.assert_is_copy(X(*args), self.loads(pickle2))
+ def test_load_classic_instance_error(self):
+ # Issue #28925.
+ # Protocol 0 (text mode pickle):
+ """
+ 0: ( MARK
+ 1: i INST '__main__ I' (MARK at 0)
+ 13: ( MARK
+ 14: d DICT (MARK at 13)
+ 15: b BUILD
+ 16: . STOP
+ """
+ pickle0 = ('(i__main__\n'
+ 'I\n'
+ '(db.')
+ self.assertRaises(MyErr, self.loads, pickle0)
+
+ # Protocol 1 (binary mode pickle)
+ """
+ 0: ( MARK
+ 1: c GLOBAL '__main__ I'
+ 13: o OBJ (MARK at 0)
+ 14: } EMPTY_DICT
+ 15: b BUILD
+ 16: . STOP
+ """
+ pickle1 = ('(c__main__\n'
+ 'I\n'
+ 'o}b.')
+ self.assertRaises(MyErr, self.loads, pickle1)
+
def test_load_str(self):
# From Python 2: pickle.dumps('a\x00\xa0', protocol=0)
self.assertEqual(self.loads("S'a\\x00\\xa0'\n."), 'a\x00\xa0')
--- /dev/null
+"""
+Collect various informations about Python to help debugging test failures.
+"""
+from __future__ import print_function
+import re
+import sys
+import traceback
+
+
+def normalize_text(text):
+ if text is None:
+ return None
+ text = str(text)
+ text = re.sub(r'\s+', ' ', text)
+ return text.strip()
+
+
+class PythonInfo:
+ def __init__(self):
+ self.info = {}
+
+ def add(self, key, value):
+ if key in self.info:
+ raise ValueError("duplicate key: %r" % key)
+
+ if value is None:
+ return
+
+ if not isinstance(value, (int, long)):
+ if not isinstance(value, basestring):
+ # convert other objects like sys.flags to string
+ value = str(value)
+
+ value = value.strip()
+ if not value:
+ return
+
+ self.info[key] = value
+
+ def get_infos(self):
+ """
+ Get informations as a key:value dictionary where values are strings.
+ """
+ return {key: str(value) for key, value in self.info.items()}
+
+
+def copy_attributes(info_add, obj, name_fmt, attributes, formatter=None):
+ for attr in attributes:
+ value = getattr(obj, attr, None)
+ if value is None:
+ continue
+ name = name_fmt % attr
+ if formatter is not None:
+ value = formatter(attr, value)
+ info_add(name, value)
+
+
+def call_func(info_add, name, mod, func_name, formatter=None):
+ try:
+ func = getattr(mod, func_name)
+ except AttributeError:
+ return
+ value = func()
+ if formatter is not None:
+ value = formatter(value)
+ info_add(name, value)
+
+
+def collect_sys(info_add):
+ attributes = (
+ 'api_version',
+ 'builtin_module_names',
+ 'byteorder',
+ 'dont_write_bytecode',
+ 'executable',
+ 'flags',
+ 'float_info',
+ 'float_repr_style',
+ 'hexversion',
+ 'maxint',
+ 'maxsize',
+ 'maxunicode',
+ 'path',
+ 'platform',
+ 'prefix',
+ 'version',
+ 'version_info',
+ 'winver',
+ )
+ copy_attributes(info_add, sys, 'sys.%s', attributes)
+
+ encoding = sys.getfilesystemencoding()
+ info_add('sys.filesystem_encoding', encoding)
+
+ for name in ('stdin', 'stdout', 'stderr'):
+ stream = getattr(sys, name)
+ if stream is None:
+ continue
+ encoding = getattr(stream, 'encoding', None)
+ if not encoding:
+ continue
+ errors = getattr(stream, 'errors', None)
+ if errors:
+ encoding = '%s/%s' % (encoding, errors)
+ info_add('sys.%s.encoding' % name, encoding)
+
+
+def collect_platform(info_add):
+ import platform
+
+ arch = platform.architecture()
+ arch = ' '.join(filter(bool, arch))
+ info_add('platform.architecture', arch)
+
+ info_add('platform.python_implementation',
+ platform.python_implementation())
+ info_add('platform.platform',
+ platform.platform(aliased=True))
+
+
+def collect_locale(info_add):
+ import locale
+
+ info_add('locale.encoding', locale.getpreferredencoding(True))
+
+
+def collect_os(info_add):
+ import os
+
+ attributes = ('name',)
+ copy_attributes(info_add, os, 'os.%s', attributes)
+
+ info_add("os.cwd", os.getcwd())
+
+ call_func(info_add, 'os.uid', os, 'getuid')
+ call_func(info_add, 'os.gid', os, 'getgid')
+ call_func(info_add, 'os.uname', os, 'uname')
+
+ if hasattr(os, 'getgroups'):
+ groups = os.getgroups()
+ groups = map(str, groups)
+ groups = ', '.join(groups)
+ info_add("os.groups", groups)
+
+ if hasattr(os, 'getlogin'):
+ try:
+ login = os.getlogin()
+ except OSError:
+ # getlogin() fails with "OSError: [Errno 25] Inappropriate ioctl
+ # for device" on Travis CI
+ pass
+ else:
+ info_add("os.login", login)
+
+ call_func(info_add, 'os.loadavg', os, 'getloadavg')
+
+ # Get environment variables: filter to list
+ # to not leak sensitive information
+ ENV_VARS = (
+ "CC",
+ "COMSPEC",
+ "DISPLAY",
+ "DISTUTILS_USE_SDK",
+ "DYLD_LIBRARY_PATH",
+ "HOME",
+ "HOMEDRIVE",
+ "HOMEPATH",
+ "LANG",
+ "LD_LIBRARY_PATH",
+ "MACOSX_DEPLOYMENT_TARGET",
+ "MAKEFLAGS",
+ "MSSDK",
+ "PATH",
+ "SDK_TOOLS_BIN",
+ "SHELL",
+ "TEMP",
+ "TERM",
+ "TMP",
+ "TMPDIR",
+ "USERPROFILE",
+ "WAYLAND_DISPLAY",
+ )
+ for name, value in os.environ.items():
+ uname = name.upper()
+ if (uname in ENV_VARS or uname.startswith(("PYTHON", "LC_"))
+ # Visual Studio: VS140COMNTOOLS
+ or (uname.startswith("VS") and uname.endswith("COMNTOOLS"))):
+ info_add('os.environ[%s]' % name, value)
+
+ if hasattr(os, 'umask'):
+ mask = os.umask(0)
+ os.umask(mask)
+ info_add("os.umask", '%03o' % mask)
+
+ try:
+ cpu_count = os.sysconf('SC_NPROCESSORS_ONLN')
+ except (AttributeError, ValueError):
+ pass
+ else:
+ if cpu_count:
+ info_add('os.sysconf(SC_NPROCESSORS_ONLN)', cpu_count)
+
+
+def collect_readline(info_add):
+ try:
+ import readline
+ except ImportError:
+ return
+
+ def format_attr(attr, value):
+ if isinstance(value, (int, long)):
+ return "%#x" % value
+ else:
+ return value
+
+ attributes = (
+ "_READLINE_VERSION",
+ "_READLINE_RUNTIME_VERSION",
+ )
+ copy_attributes(info_add, readline, 'readline.%s', attributes,
+ formatter=format_attr)
+
+
+def collect_gdb(info_add):
+ import subprocess
+
+ try:
+ proc = subprocess.Popen(["gdb", "-nx", "--version"],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ universal_newlines=True)
+ version = proc.communicate()[0]
+ except OSError:
+ return
+
+ # Only keep the first line
+ version = version.splitlines()[0]
+ info_add('gdb_version', version)
+
+
+def collect_tkinter(info_add):
+ try:
+ import _tkinter
+ except ImportError:
+ pass
+ else:
+ attributes = ('TK_VERSION', 'TCL_VERSION')
+ copy_attributes(info_add, _tkinter, 'tkinter.%s', attributes)
+
+ try:
+ import Tkinter
+ except ImportError:
+ pass
+ else:
+ tcl = Tkinter.Tcl()
+ patchlevel = tcl.call('info', 'patchlevel')
+ info_add('tkinter.info_patchlevel', patchlevel)
+
+
+def collect_time(info_add):
+ import time
+
+ attributes = (
+ 'altzone',
+ 'daylight',
+ 'timezone',
+ 'tzname',
+ )
+ copy_attributes(info_add, time, 'time.%s', attributes)
+
+
+def collect_sysconfig(info_add):
+ import sysconfig
+
+ for name in (
+ 'ABIFLAGS',
+ 'ANDROID_API_LEVEL',
+ 'CC',
+ 'CCSHARED',
+ 'CFLAGS',
+ 'CFLAGSFORSHARED',
+ 'PY_LDFLAGS',
+ 'CONFIG_ARGS',
+ 'HOST_GNU_TYPE',
+ 'MACHDEP',
+ 'MULTIARCH',
+ 'OPT',
+ 'PY_CFLAGS',
+ 'PY_CFLAGS_NODIST',
+ 'Py_DEBUG',
+ 'Py_ENABLE_SHARED',
+ 'SHELL',
+ 'SOABI',
+ 'prefix',
+ ):
+ value = sysconfig.get_config_var(name)
+ if name == 'ANDROID_API_LEVEL' and not value:
+ # skip ANDROID_API_LEVEL=0
+ continue
+ value = normalize_text(value)
+ info_add('sysconfig[%s]' % name, value)
+
+
+def collect_ssl(info_add):
+ try:
+ import ssl
+ except ImportError:
+ return
+
+ def format_attr(attr, value):
+ if attr.startswith('OP_'):
+ return '%#8x' % value
+ else:
+ return value
+
+ attributes = (
+ 'OPENSSL_VERSION',
+ 'OPENSSL_VERSION_INFO',
+ 'HAS_SNI',
+ 'OP_ALL',
+ 'OP_NO_TLSv1_1',
+ )
+ copy_attributes(info_add, ssl, 'ssl.%s', attributes, formatter=format_attr)
+
+
+def collect_socket(info_add):
+ import socket
+
+ hostname = socket.gethostname()
+ info_add('socket.hostname', hostname)
+
+
+def collect_sqlite(info_add):
+ try:
+ import sqlite3
+ except ImportError:
+ return
+
+ attributes = ('version', 'sqlite_version')
+ copy_attributes(info_add, sqlite3, 'sqlite3.%s', attributes)
+
+
+def collect_zlib(info_add):
+ try:
+ import zlib
+ except ImportError:
+ return
+
+ attributes = ('ZLIB_VERSION', 'ZLIB_RUNTIME_VERSION')
+ copy_attributes(info_add, zlib, 'zlib.%s', attributes)
+
+
+def collect_expat(info_add):
+ try:
+ from xml.parsers import expat
+ except ImportError:
+ return
+
+ attributes = ('EXPAT_VERSION',)
+ copy_attributes(info_add, expat, 'expat.%s', attributes)
+
+
+def collect_multiprocessing(info_add):
+ try:
+ import multiprocessing
+ except ImportError:
+ return
+
+ cpu_count = multiprocessing.cpu_count()
+ if cpu_count:
+ info_add('multiprocessing.cpu_count', cpu_count)
+
+
+def collect_info(info):
+ error = False
+ info_add = info.add
+
+ for collect_func in (
+ collect_expat,
+ collect_gdb,
+ collect_locale,
+ collect_os,
+ collect_platform,
+ collect_readline,
+ collect_socket,
+ collect_sqlite,
+ collect_ssl,
+ collect_sys,
+ collect_sysconfig,
+ collect_time,
+ collect_tkinter,
+ collect_zlib,
+ collect_multiprocessing,
+ ):
+ try:
+ collect_func(info_add)
+ except Exception as exc:
+ error = True
+ print("ERROR: %s() failed" % (collect_func.__name__),
+ file=sys.stderr)
+ traceback.print_exc(file=sys.stderr)
+ print(file=sys.stderr)
+ sys.stderr.flush()
+
+ return error
+
+
+def dump_info(info, file=None):
+ title = "Python debug information"
+ print(title)
+ print("=" * len(title))
+ print()
+
+ infos = info.get_infos()
+ infos = sorted(infos.items())
+ for key, value in infos:
+ value = value.replace("\n", " ")
+ print("%s: %s" % (key, value))
+ print()
+
+
+def main():
+ info = PythonInfo()
+ error = collect_info(info)
+ dump_info(info)
+
+ if error:
+ print("Collection failed: exit with error", file=sys.stderr)
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
-w/--verbose2 -- re-run failed tests in verbose mode
-W/--verbose3 -- re-run failed tests in verbose mode immediately
-q/--quiet -- no output unless one or more tests fail
--S/--slow -- print the slowest 10 tests
+-S/--slowest -- print the slowest 10 tests
--header -- print header with interpreter info
Selecting tests
-f/--fromfile -- read names of tests to run from a file (see below)
-x/--exclude -- arguments are tests to *exclude*
-s/--single -- single step through a set of tests (see below)
+-m/--match PAT -- match test cases and methods with glob pattern PAT
+--matchfile FILENAME -- filters tests using a text file, one pattern per line
+-G/--failfast -- fail as soon as a test fails (only with -v or -W)
-u/--use RES1,RES2,...
-- specify which special resource intensive tests to run
-M/--memlimit LIMIT
-- call gc.set_threshold(THRESHOLD)
-F/--forever -- run the specified tests in a loop, until an error happens
-P/--pgo -- enable Profile Guided Optimization training
+--testdir -- execute test files in the specified directory
+ (instead of the Python stdlib test suite)
+--list-tests -- only write the name of tests that will be run,
+ don't execute them
+--list-cases -- only write the name of test cases that will be run,
+ don't execute them
+--fail-env-changed -- if a test file alters the environment, mark the test
+ as failed
Additional Option Details:
To enable all resources except one, use '-uall,-<resource>'. For
example, to run all the tests except for the bsddb tests, give the
option '-uall,-bsddb'.
+
+--matchfile filters tests using a text file, one pattern per line.
+Pattern examples:
+
+- test method: test_stat_attributes
+- test class: FileTests
+- test identifier: test_os.FileTests.test_stat_attributes
"""
import StringIO
+import datetime
import getopt
import json
import os
SKIPPED = -2
RESOURCE_DENIED = -3
INTERRUPTED = -4
+CHILD_ERROR = -5 # error in a child process
+
+# Minimum duration of a test to display its duration or to mention that
+# the test is running in background
+PROGRESS_MIN_TIME = 30.0 # seconds
+
+# Display the running tests if nothing happened last N seconds
+PROGRESS_UPDATE = 30.0 # seconds
from test import test_support
-RESOURCE_NAMES = ('audio', 'curses', 'largefile', 'network', 'bsddb',
- 'decimal', 'cpu', 'subprocess', 'urlfetch', 'gui',
- 'xpickle')
+ALL_RESOURCES = ('audio', 'curses', 'largefile', 'network', 'bsddb',
+ 'decimal', 'cpu', 'subprocess', 'urlfetch', 'gui',
+ 'xpickle')
+
+# Other resources excluded from --use=all:
+#
+# - extralagefile (ex: test_zipfile64): really too slow to be enabled
+# "by default"
+RESOURCE_NAMES = ALL_RESOURCES + ('extralargefile',)
TEMPDIR = os.path.abspath(tempfile.gettempdir())
sys.exit(code)
+def format_duration(seconds):
+ if seconds < 1.0:
+ return '%.0f ms' % (seconds * 1e3)
+ if seconds < 60.0:
+ return '%.0f sec' % seconds
+
+ minutes, seconds = divmod(seconds, 60.0)
+ return '%.0f min %.0f sec' % (minutes, seconds)
+
+
+_FORMAT_TEST_RESULT = {
+ PASSED: '%s passed',
+ FAILED: '%s failed',
+ ENV_CHANGED: '%s failed (env changed)',
+ SKIPPED: '%s skipped',
+ RESOURCE_DENIED: '%s skipped (resource denied)',
+ INTERRUPTED: '%s interrupted',
+ CHILD_ERROR: '%s crashed',
+}
+
+
+def format_test_result(test_name, result):
+ fmt = _FORMAT_TEST_RESULT.get(result, "%s")
+ return fmt % test_name
+
+
+def cpu_count():
+ # first try os.sysconf() to prevent loading the big multiprocessing module
+ try:
+ return os.sysconf('SC_NPROCESSORS_ONLN')
+ except (AttributeError, ValueError):
+ pass
+
+ # try multiprocessing.cpu_count()
+ try:
+ import multiprocessing
+ except ImportError:
+ pass
+ else:
+ return multiprocessing.cpu_count()
+
+ return None
+
+
+def unload_test_modules(save_modules):
+ # Unload the newly imported modules (best effort finalization)
+ for module in sys.modules.keys():
+ if module not in save_modules and module.startswith("test."):
+ test_support.unload(module)
+
+
def main(tests=None, testdir=None, verbose=0, quiet=False,
exclude=False, single=False, randomize=False, fromfile=None,
findleaks=False, use_resources=None, trace=False, coverdir='coverage',
runleaks=False, huntrleaks=False, verbose2=False, print_slow=False,
random_seed=None, use_mp=None, verbose3=False, forever=False,
- header=False, pgo=False):
+ header=False, pgo=False, failfast=False, match_tests=None):
"""Execute a test suite.
This also parses command-line options and modifies its behavior
directly to set the values that would normally be set by flags
on the command line.
"""
+ regrtest_start_time = time.time()
test_support.record_original_stdout(sys.stdout)
try:
- opts, args = getopt.getopt(sys.argv[1:], 'hvqxsSrf:lu:t:TD:NLR:FwWM:j:P',
+ opts, args = getopt.getopt(sys.argv[1:], 'hvqxsSrf:lu:t:TD:NLR:FwWM:j:PGm:',
['help', 'verbose', 'verbose2', 'verbose3', 'quiet',
- 'exclude', 'single', 'slow', 'randomize', 'fromfile=', 'findleaks',
+ 'exclude', 'single', 'slow', 'slowest', 'randomize', 'fromfile=',
+ 'findleaks',
'use=', 'threshold=', 'trace', 'coverdir=', 'nocoverdir',
'runleaks', 'huntrleaks=', 'memlimit=', 'randseed=',
- 'multiprocess=', 'slaveargs=', 'forever', 'header', 'pgo'])
+ 'multiprocess=', 'slaveargs=', 'forever', 'header', 'pgo',
+ 'failfast', 'match=', 'testdir=', 'list-tests', 'list-cases',
+ 'coverage', 'matchfile=', 'fail-env-changed'])
except getopt.error, msg:
usage(2, msg)
random_seed = random.randrange(10000000)
if use_resources is None:
use_resources = []
+ slaveargs = None
+ list_tests = False
+ list_cases_opt = False
+ fail_env_changed = False
for o, a in opts:
if o in ('-h', '--help'):
usage(0)
verbose2 = True
elif o in ('-W', '--verbose3'):
verbose3 = True
+ elif o in ('-G', '--failfast'):
+ failfast = True
elif o in ('-q', '--quiet'):
quiet = True;
verbose = 0
exclude = True
elif o in ('-s', '--single'):
single = True
- elif o in ('-S', '--slow'):
+ elif o in ('-S', '--slow', '--slowest'):
print_slow = True
elif o in ('-r', '--randomize'):
randomize = True
random_seed = int(a)
elif o in ('-f', '--fromfile'):
fromfile = a
+ elif o in ('-m', '--match'):
+ if match_tests is None:
+ match_tests = []
+ match_tests.append(a)
+ elif o == '--matchfile':
+ if match_tests is None:
+ match_tests = []
+ filename = os.path.join(test_support.SAVEDCWD, a)
+ with open(filename) as fp:
+ for line in fp:
+ match_tests.append(line.strip())
elif o in ('-l', '--findleaks'):
findleaks = True
elif o in ('-L', '--runleaks'):
u = [x.lower() for x in a.split(',')]
for r in u:
if r == 'all':
- use_resources[:] = RESOURCE_NAMES
+ use_resources[:] = ALL_RESOURCES
continue
remove = False
if r[0] == '-':
elif o == '--header':
header = True
elif o == '--slaveargs':
- args, kwargs = json.loads(a)
- try:
- result = runtest(*args, **kwargs)
- except BaseException, e:
- result = INTERRUPTED, e.__class__.__name__
- print # Force a newline (just in case)
- print json.dumps(result)
- sys.exit(0)
+ slaveargs = a
elif o in ('-P', '--pgo'):
pgo = True
+ elif o == '--testdir':
+ testdir = a
+ elif o == '--list-tests':
+ list_tests = True
+ elif o == '--list-cases':
+ list_cases_opt = True
+ elif o == '--fail-env-changed':
+ fail_env_changed = True
else:
print >>sys.stderr, ("No handler for option {}. Please "
"report this as a bug at http://bugs.python.org.").format(o)
usage(2, "-T and -j don't go together!")
if use_mp and findleaks:
usage(2, "-l and -j don't go together!")
+ if failfast and not (verbose or verbose3):
+ usage("-G/--failfast needs either -v or -W")
+
+ if testdir:
+ testdir = os.path.abspath(testdir)
+
+ # Prepend test directory to sys.path, so runtest() will be able
+ # to locate tests
+ sys.path.insert(0, testdir)
+
+ # Make sure that '' and Lib/test/ are not in sys.path
+ regrtest_dir = os.path.abspath(os.path.dirname(__file__))
+ for path in ('', regrtest_dir):
+ try:
+ sys.path.remove(path)
+ except ValueError:
+ pass
+
+ if slaveargs is not None:
+ args, kwargs = json.loads(slaveargs)
+ if kwargs['huntrleaks']:
+ warm_caches()
+ if testdir:
+ kwargs['testdir'] = testdir
+ try:
+ result = runtest(*args, **kwargs)
+ except BaseException, e:
+ result = INTERRUPTED, e.__class__.__name__
+ print # Force a newline (just in case)
+ print json.dumps(result)
+ sys.exit(0)
+
+ if huntrleaks:
+ warm_caches()
good = []
bad = []
nottests.add(arg)
args = []
- # For a partial run, we do not need to clutter the output.
- if verbose or header or not (quiet or single or tests or args):
- if not pgo:
- # Print basic platform information
- print "==", platform.python_implementation(), \
- " ".join(sys.version.split())
- print "== ", platform.platform(aliased=True), \
- "%s-endian" % sys.byteorder
- print "== ", os.getcwd()
- print "Testing with flags:", sys.flags
-
+ display_header = (verbose or header or not (quiet or single or tests or args)) and (not pgo)
alltests = findtests(testdir, stdtests, nottests)
selected = tests or args or alltests
if single:
next_single_test = alltests[alltests.index(selected[0])+1]
except IndexError:
next_single_test = None
- if randomize:
- random.seed(random_seed)
- print "Using random seed", random_seed
- random.shuffle(selected)
+
+ if list_tests:
+ for name in selected:
+ print(name)
+ sys.exit(0)
+
+ if list_cases_opt:
+ list_cases(testdir, selected, match_tests)
+ sys.exit(0)
+
if trace:
import trace
- tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix],
- trace=False, count=True)
+ tracer = trace.Trace(trace=False, count=True)
test_times = []
test_support.use_resources = use_resources
def accumulate_result(test, result):
ok, test_time = result
- test_times.append((test_time, test))
+ if ok not in (CHILD_ERROR, INTERRUPTED):
+ test_times.append((test_time, test))
if ok == PASSED:
good.append(test)
- elif ok == FAILED:
+ elif ok in (FAILED, CHILD_ERROR):
bad.append(test)
elif ok == ENV_CHANGED:
environment_changed.append(test)
elif ok == RESOURCE_DENIED:
skipped.append(test)
resource_denieds.append(test)
+ elif ok != INTERRUPTED:
+ raise ValueError("invalid test result: %r" % ok)
if forever:
def test_forever(tests=list(selected)):
yield test
if bad:
return
+ if fail_env_changed and environment_changed:
+ return
tests = test_forever()
test_count = ''
test_count_width = 3
test_count = '/{}'.format(len(selected))
test_count_width = len(test_count) - 1
+ def display_progress(test_index, test):
+ # "[ 51/405/1] test_tcl"
+ line = "{1:{0}}{2}".format(test_count_width, test_index, test_count)
+ if bad and not pgo:
+ line = '{}/{}'.format(line, len(bad))
+ line = '[{}]'.format(line)
+
+ # add the system load prefix: "load avg: 1.80 "
+ if hasattr(os, 'getloadavg'):
+ load_avg_1min = os.getloadavg()[0]
+ line = "load avg: {:.2f} {}".format(load_avg_1min, line)
+
+ # add the timestamp prefix: "0:01:05 "
+ test_time = time.time() - regrtest_start_time
+ test_time = datetime.timedelta(seconds=int(test_time))
+ line = "%s %s" % (test_time, line)
+
+ # add the test name
+ line = "{} {}".format(line, test)
+
+ print(line)
+ sys.stdout.flush()
+
+ # For a partial run, we do not need to clutter the output.
+ if display_header:
+ # Print basic platform information
+ print "==", platform.python_implementation(), \
+ " ".join(sys.version.split())
+ print "== ", platform.platform(aliased=True), \
+ "%s-endian" % sys.byteorder
+ print "== ", os.getcwd()
+ ncpu = cpu_count()
+ if ncpu:
+ print "== CPU count:", ncpu
+
+ if randomize:
+ random.seed(random_seed)
+ print "Using random seed", random_seed
+ random.shuffle(selected)
+
if use_mp:
try:
from threading import Thread
except ImportError:
print "Multiprocess option requires thread support"
sys.exit(2)
- from Queue import Queue
+ from Queue import Queue, Empty
from subprocess import Popen, PIPE
debug_output_pat = re.compile(r"\[\d+ refs\]$")
output = Queue()
args_tuple = (
(test, verbose, quiet),
dict(huntrleaks=huntrleaks, use_resources=use_resources,
+ failfast=failfast,
+ match_tests=match_tests,
pgo=pgo)
)
yield (test, args_tuple)
# required to spawn a new process with PGO flag on/off
if pgo:
base_cmd = base_cmd + ['--pgo']
- def work():
- # A worker thread.
- try:
- while True:
- try:
- test, args_tuple = next(pending)
- except StopIteration:
- output.put((None, None, None, None))
- return
- # -E is needed by some tests, e.g. test_import
- popen = Popen(base_cmd + ['--slaveargs', json.dumps(args_tuple)],
- stdout=PIPE, stderr=PIPE,
- universal_newlines=True,
- close_fds=(os.name != 'nt'))
+
+ class MultiprocessThread(Thread):
+ current_test = None
+ start_time = None
+
+ def runtest(self):
+ try:
+ test, args_tuple = next(pending)
+ except StopIteration:
+ output.put((None, None, None, None))
+ return True
+
+ # -E is needed by some tests, e.g. test_import
+ args = base_cmd + ['--slaveargs', json.dumps(args_tuple)]
+ if testdir:
+ args.extend(('--testdir', testdir))
+ try:
+ self.start_time = time.time()
+ self.current_test = test
+ popen = Popen(args,
+ stdout=PIPE, stderr=PIPE,
+ universal_newlines=True,
+ close_fds=(os.name != 'nt'))
stdout, stderr = popen.communicate()
- # Strip last refcount output line if it exists, since it
- # comes from the shutdown of the interpreter in the subcommand.
- stderr = debug_output_pat.sub("", stderr)
+ retcode = popen.wait()
+ finally:
+ self.current_test = None
+
+ # Strip last refcount output line if it exists, since it
+ # comes from the shutdown of the interpreter in the subcommand.
+ stderr = debug_output_pat.sub("", stderr)
+
+ if retcode == 0:
stdout, _, result = stdout.strip().rpartition("\n")
if not result:
output.put((None, None, None, None))
- return
+ return True
+
result = json.loads(result)
- output.put((test, stdout.rstrip(), stderr.rstrip(), result))
- except BaseException:
- output.put((None, None, None, None))
- raise
- workers = [Thread(target=work) for i in range(use_mp)]
+ else:
+ result = (CHILD_ERROR, "Exit code %s" % retcode)
+
+ output.put((test, stdout.rstrip(), stderr.rstrip(), result))
+ return False
+
+ def run(self):
+ try:
+ stop = False
+ while not stop:
+ stop = self.runtest()
+ except BaseException:
+ output.put((None, None, None, None))
+ raise
+
+ workers = [MultiprocessThread() for i in range(use_mp)]
+ print("Run tests in parallel using %s child processes"
+ % len(workers))
for worker in workers:
worker.start()
+
+ def get_running(workers):
+ running = []
+ for worker in workers:
+ current_test = worker.current_test
+ if not current_test:
+ continue
+ dt = time.time() - worker.start_time
+ if dt >= PROGRESS_MIN_TIME:
+ running.append('%s (%.0f sec)' % (current_test, dt))
+ return running
+
finished = 0
test_index = 1
+ get_timeout = max(PROGRESS_UPDATE, PROGRESS_MIN_TIME)
try:
while finished < use_mp:
- test, stdout, stderr, result = output.get()
+ try:
+ item = output.get(timeout=get_timeout)
+ except Empty:
+ running = get_running(workers)
+ if running and not pgo:
+ print('running: %s' % ', '.join(running))
+ continue
+
+ test, stdout, stderr, result = item
if test is None:
finished += 1
continue
+ accumulate_result(test, result)
+ if not quiet:
+ ok, test_time = result
+ text = format_test_result(test, ok)
+ if (ok not in (CHILD_ERROR, INTERRUPTED)
+ and test_time >= PROGRESS_MIN_TIME
+ and not pgo):
+ text += ' (%.0f sec)' % test_time
+ running = get_running(workers)
+ if running and not pgo:
+ text += ' -- running: %s' % ', '.join(running)
+ display_progress(test_index, text)
+
if stdout:
print stdout
+ sys.stdout.flush()
if stderr and not pgo:
print >>sys.stderr, stderr
- sys.stdout.flush()
sys.stderr.flush()
+
if result[0] == INTERRUPTED:
assert result[1] == 'KeyboardInterrupt'
raise KeyboardInterrupt # What else?
- accumulate_result(test, result)
- if not quiet:
- fmt = "[{1:{0}}{2}/{3}] {4}" if bad else "[{1:{0}}{2}] {4}"
- print(fmt.format(
- test_count_width, test_index, test_count,
- len(bad), test))
+
test_index += 1
except KeyboardInterrupt:
interrupted = True
for worker in workers:
worker.join()
else:
+ print("Run tests sequentially")
+
+ previous_test = None
for test_index, test in enumerate(tests, 1):
if not quiet:
- fmt = "[{1:{0}}{2}/{3}] {4}" if bad else "[{1:{0}}{2}] {4}"
- print(fmt.format(
- test_count_width, test_index, test_count, len(bad), test))
- sys.stdout.flush()
+ text = test
+ if previous_test:
+ text = '%s -- %s' % (text, previous_test)
+ display_progress(test_index, text)
+
+ def local_runtest():
+ result = runtest(test, verbose, quiet, huntrleaks, None, pgo,
+ failfast=failfast,
+ match_tests=match_tests,
+ testdir=testdir)
+ accumulate_result(test, result)
+ return result
+
+ start_time = time.time()
if trace:
# If we're tracing code coverage, then we don't exit with status
# if on a false return value from main.
- tracer.runctx('runtest(test, verbose, quiet)',
- globals=globals(), locals=vars())
+ ns = dict(locals())
+ tracer.runctx('result = local_runtest()',
+ globals=globals(), locals=ns)
+ result = ns['result']
else:
try:
- result = runtest(test, verbose, quiet, huntrleaks, None, pgo)
- accumulate_result(test, result)
+ result = local_runtest()
if verbose3 and result[0] == FAILED:
if not pgo:
print "Re-running test %r in verbose mode" % test
- runtest(test, True, quiet, huntrleaks, None, pgo)
+ runtest(test, True, quiet, huntrleaks, None, pgo,
+ testdir=testdir)
except KeyboardInterrupt:
interrupted = True
break
except:
raise
+
+ test_time = time.time() - start_time
+ previous_test = format_test_result(test, result[0])
+ if test_time >= PROGRESS_MIN_TIME:
+ previous_test = "%s in %s" % (previous_test,
+ format_duration(test_time))
+ elif result[0] == PASSED:
+ # be quiet: say nothing if the test passed shortly
+ previous_test = None
+
if findleaks:
gc.collect()
if gc.garbage:
# them again
found_garbage.extend(gc.garbage)
del gc.garbage[:]
- # Unload the newly imported modules (best effort finalization)
- for module in sys.modules.keys():
- if module not in save_modules and module.startswith("test."):
- test_support.unload(module)
+
+ unload_test_modules(save_modules)
if interrupted and not pgo:
# print a newline after ^C
if print_slow:
test_times.sort(reverse=True)
print "10 slowest tests:"
- for time, test in test_times[:10]:
- print "%s: %.1fs" % (test, time)
+ for test_time, test in test_times[:10]:
+ print("- %s: %.1fs" % (test, test_time))
if bad and not pgo:
print count(len(bad), "test"), "failed:"
printlist(bad)
sys.stdout.flush()
try:
test_support.verbose = True
- ok = runtest(test, True, quiet, huntrleaks, None, pgo)
+ ok = runtest(test, True, quiet, huntrleaks, None, pgo,
+ testdir=testdir)
except KeyboardInterrupt:
# print a newline separate from the ^C
print
if runleaks:
os.system("leaks %d" % os.getpid())
- sys.exit(len(bad) > 0 or interrupted)
+ print
+ duration = time.time() - regrtest_start_time
+ print("Total duration: %s" % format_duration(duration))
+
+ if bad:
+ result = "FAILURE"
+ elif interrupted:
+ result = "INTERRUPTED"
+ elif fail_env_changed and environment_changed:
+ result = "ENV CHANGED"
+ else:
+ result = "SUCCESS"
+ print("Tests result: %s" % result)
+
+ if bad:
+ sys.exit(2)
+ if interrupted:
+ sys.exit(130)
+ if fail_env_changed and environment_changed:
+ sys.exit(3)
+ sys.exit(0)
STDTESTS = [
return stdtests + sorted(tests)
def runtest(test, verbose, quiet,
- huntrleaks=False, use_resources=None, pgo=False):
+ huntrleaks=False, use_resources=None, pgo=False,
+ failfast=False, match_tests=None, testdir=None):
"""Run a single test.
test -- the name of the test
for Profile Guided Optimization build
Returns one of the test result constants:
+ CHILD_ERROR Child process crashed
INTERRUPTED KeyboardInterrupt when run under -j
RESOURCE_DENIED test skipped because resource denied
SKIPPED test skipped for some other reason
if use_resources is not None:
test_support.use_resources = use_resources
try:
- return runtest_inner(test, verbose, quiet, huntrleaks, pgo)
+ test_support.match_tests = match_tests
+ if failfast:
+ test_support.failfast = True
+ return runtest_inner(test, verbose, quiet, huntrleaks, pgo, testdir)
finally:
cleanup_test_droppings(test, verbose)
print >>sys.stderr, (
"Warning -- {} was modified by {}".format(
name, self.testname))
- if self.verbose > 1 and not self.pgo:
- print >>sys.stderr, (
- " Before: {}\n After: {} ".format(
- original, current))
+ print >>sys.stderr, (
+ " Before: {}\n After: {} ".format(
+ original, current))
# XXX (ncoghlan): for most resources (e.g. sys.path) identity
# matters at least as much as value. For others (e.g. cwd),
# identity is irrelevant. Should we add a mechanism to check
return False
-def runtest_inner(test, verbose, quiet, huntrleaks=False, pgo=False):
+def post_test_cleanup():
+ test_support.reap_children()
+
+def runtest_inner(test, verbose, quiet, huntrleaks=False, pgo=False, testdir=None):
test_support.unload(test)
if verbose:
capture_stdout = None
try:
if capture_stdout:
sys.stdout = capture_stdout
- if test.startswith('test.'):
- abstest = test
- else:
- # Always import it from the test package
- abstest = 'test.' + test
+ abstest = get_abs_module(testdir, test)
clear_caches()
with saved_test_environment(test, verbose, quiet, pgo) as environment:
start_time = time.time()
the_package = __import__(abstest, globals(), locals(), [])
- the_module = getattr(the_package, test)
+ if abstest.startswith('test.'):
+ the_module = getattr(the_package, test)
+ else:
+ the_module = the_package
# Old tests run to completion simply as a side-effect of
# being imported. For tests based on unittest or doctest,
# explicitly invoke their test_main() function (if it exists).
refleak = dash_R(the_module, test, indirect_test,
huntrleaks)
test_time = time.time() - start_time
+ post_test_cleanup()
finally:
sys.stdout = save_stdout
except test_support.ResourceDenied, msg:
if i >= nwarmup:
deltas.append(rc_after - rc_before)
print >> sys.stderr
- if any(deltas):
+
+ # bpo-30776: Try to ignore false positives:
+ #
+ # [3, 0, 0]
+ # [0, 1, 0]
+ # [8, -8, 1]
+ #
+ # Expected leaks:
+ #
+ # [5, 5, 6]
+ # [10, 1, 1]
+ if all(delta >= 1 for delta in deltas):
msg = '%s leaked %s references, sum=%s' % (test, deltas, sum(deltas))
print >> sys.stderr, msg
with open(fname, "a") as refrep:
# Collect cyclic trash.
gc.collect()
+def warm_caches():
+ """Create explicitly internal singletons which are created on demand
+ to prevent false positive when hunting reference leaks."""
+ # char cache
+ for i in range(256):
+ chr(i)
+ # unicode cache
+ for i in range(256):
+ unichr(i)
+ # int cache
+ list(range(-5, 257))
+
def findtestdir(path=None):
return path or os.path.dirname(__file__) or os.curdir
else:
return "%d %ss" % (n, word)
-def printlist(x, width=70, indent=4):
+def printlist(x, width=70, indent=4, file=None):
"""Print the elements of iterable x to stdout.
Optional arg width (default 70) is the maximum line length.
from textwrap import fill
blanks = ' ' * indent
# Print the sorted list: 'x' may be a '--random' list or a set()
- print fill(' '.join(str(elt) for elt in sorted(x)), width,
- initial_indent=blanks, subsequent_indent=blanks)
+ print >>file, fill(' '.join(str(elt) for elt in sorted(x)), width,
+ initial_indent=blanks, subsequent_indent=blanks)
+
+def get_abs_module(testdir, test):
+ if test.startswith('test.') or testdir:
+ return test
+ else:
+ # Always import it from the test package
+ return 'test.' + test
+
+def _list_cases(suite):
+ for test in suite:
+ if isinstance(test, unittest.TestSuite):
+ _list_cases(test)
+ elif isinstance(test, unittest.TestCase):
+ if test_support._match_test(test):
+ print(test.id())
+
+def list_cases(testdir, selected, match_tests):
+ test_support.verbose = False
+ test_support.match_tests = match_tests
+
+ save_modules = set(sys.modules)
+ skipped = []
+ for test in selected:
+ abstest = get_abs_module(testdir, test)
+ try:
+ suite = unittest.defaultTestLoader.loadTestsFromName(abstest)
+ _list_cases(suite)
+ except unittest.SkipTest:
+ skipped.append(test)
+
+ unload_test_modules(save_modules)
+
+ if skipped:
+ print >>sys.stderr
+ print >>sys.stderr, count(len(skipped), "test"), "skipped:"
+ printlist(skipped, file=sys.stderr)
# Map sys.platform to a string containing the basenames of tests
# expected to be skipped on that platform.
assert self.isvalid()
return self.expected
-if __name__ == '__main__':
- # findtestdir() gets the dirname out of __file__, so we have to make it
- # absolute before changing the working directory.
- # For example __file__ may be relative when running trace or profile.
- # See issue #9323.
- __file__ = os.path.abspath(__file__)
-
- # sanity check
- assert __file__ == os.path.abspath(sys.argv[0])
+def main_in_temp_cwd():
+ """Run main() in a temporary working directory."""
+ global TEMPDIR
# When tests are run from the Python build directory, it is best practice
# to keep the test files in a subfolder. It eases the cleanup of leftover
# available from test_support.SAVEDCWD.
with test_support.temp_cwd(TESTCWD, quiet=True):
main()
+
+if __name__ == '__main__':
+ # findtestdir() gets the dirname out of __file__, so we have to make it
+ # absolute before changing the working directory.
+ # For example __file__ may be relative when running trace or profile.
+ # See issue #9323.
+ global __file__
+ __file__ = os.path.abspath(__file__)
+
+ # sanity check
+ assert __file__ == os.path.abspath(sys.argv[0])
+
+ main_in_temp_cwd()
-# Common utility functions used by various script execution tests
-# e.g. test_cmd_line, test_cmd_line_script and test_runpy
-
-import sys
-import os
-import re
-import os.path
-import tempfile
-import subprocess
-import py_compile
-import contextlib
-import shutil
-try:
- import zipfile
-except ImportError:
- # If Python is build without Unicode support, importing _io will
- # fail, which, in turn, means that zipfile cannot be imported
- # Most of this module can then still be used.
- pass
-
-from test.test_support import strip_python_stderr
-
-# Executing the interpreter in a subprocess
-def _assert_python(expected_success, *args, **env_vars):
- cmd_line = [sys.executable]
- if not env_vars:
- cmd_line.append('-E')
- cmd_line.extend(args)
- # Need to preserve the original environment, for in-place testing of
- # shared library builds.
- env = os.environ.copy()
- env.update(env_vars)
- p = subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE,
- env=env)
- try:
- out, err = p.communicate()
- finally:
- subprocess._cleanup()
- p.stdout.close()
- p.stderr.close()
- rc = p.returncode
- err = strip_python_stderr(err)
- if (rc and expected_success) or (not rc and not expected_success):
- raise AssertionError(
- "Process return code is %d, "
- "stderr follows:\n%s" % (rc, err.decode('ascii', 'ignore')))
- return rc, out, err
-
-def assert_python_ok(*args, **env_vars):
- """
- Assert that running the interpreter with `args` and optional environment
- variables `env_vars` is ok and return a (return code, stdout, stderr) tuple.
- """
- return _assert_python(True, *args, **env_vars)
-
-def assert_python_failure(*args, **env_vars):
- """
- Assert that running the interpreter with `args` and optional environment
- variables `env_vars` fails and return a (return code, stdout, stderr) tuple.
- """
- return _assert_python(False, *args, **env_vars)
-
-def python_exit_code(*args):
- cmd_line = [sys.executable, '-E']
- cmd_line.extend(args)
- with open(os.devnull, 'w') as devnull:
- return subprocess.call(cmd_line, stdout=devnull,
- stderr=subprocess.STDOUT)
-
-def spawn_python(*args, **kwargs):
- cmd_line = [sys.executable, '-E']
- cmd_line.extend(args)
- return subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
- **kwargs)
-
-def kill_python(p):
- p.stdin.close()
- data = p.stdout.read()
- p.stdout.close()
- # try to cleanup the child so we don't appear to leak when running
- # with regrtest -R.
- p.wait()
- subprocess._cleanup()
- return data
-
-def run_python(*args, **kwargs):
- if __debug__:
- p = spawn_python(*args, **kwargs)
- else:
- p = spawn_python('-O', *args, **kwargs)
- stdout_data = kill_python(p)
- return p.wait(), stdout_data
-
-# Script creation utilities
-@contextlib.contextmanager
-def temp_dir():
- dirname = tempfile.mkdtemp()
- dirname = os.path.realpath(dirname)
- try:
- yield dirname
- finally:
- shutil.rmtree(dirname)
-
-def make_script(script_dir, script_basename, source):
- script_filename = script_basename+os.extsep+'py'
- script_name = os.path.join(script_dir, script_filename)
- script_file = open(script_name, 'w')
- script_file.write(source)
- script_file.close()
- return script_name
-
-def compile_script(script_name):
- py_compile.compile(script_name, doraise=True)
- if __debug__:
- compiled_name = script_name + 'c'
- else:
- compiled_name = script_name + 'o'
- return compiled_name
-
-def make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None):
- zip_filename = zip_basename+os.extsep+'zip'
- zip_name = os.path.join(zip_dir, zip_filename)
- zip_file = zipfile.ZipFile(zip_name, 'w')
- if name_in_zip is None:
- name_in_zip = os.path.basename(script_name)
- zip_file.write(script_name, name_in_zip)
- zip_file.close()
- #if test.test_support.verbose:
- # zip_file = zipfile.ZipFile(zip_name, 'r')
- # print 'Contents of %r:' % zip_name
- # zip_file.printdir()
- # zip_file.close()
- return zip_name, os.path.join(zip_name, name_in_zip)
-
-def make_pkg(pkg_dir, init_source=''):
- os.mkdir(pkg_dir)
- make_script(pkg_dir, '__init__', init_source)
-
-def make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
- source, depth=1, compiled=False):
- unlink = []
- init_name = make_script(zip_dir, '__init__', '')
- unlink.append(init_name)
- init_basename = os.path.basename(init_name)
- script_name = make_script(zip_dir, script_basename, source)
- unlink.append(script_name)
- if compiled:
- init_name = compile_script(init_name)
- script_name = compile_script(script_name)
- unlink.extend((init_name, script_name))
- pkg_names = [os.sep.join([pkg_name]*i) for i in range(1, depth+1)]
- script_name_in_zip = os.path.join(pkg_names[-1], os.path.basename(script_name))
- zip_filename = zip_basename+os.extsep+'zip'
- zip_name = os.path.join(zip_dir, zip_filename)
- zip_file = zipfile.ZipFile(zip_name, 'w')
- for name in pkg_names:
- init_name_in_zip = os.path.join(name, init_basename)
- zip_file.write(init_name, init_name_in_zip)
- zip_file.write(script_name, script_name_in_zip)
- zip_file.close()
- for name in unlink:
- os.unlink(name)
- #if test.test_support.verbose:
- # zip_file = zipfile.ZipFile(zip_name, 'r')
- # print 'Contents of %r:' % zip_name
- # zip_file.printdir()
- # zip_file.close()
- return zip_name, os.path.join(zip_name, script_name_in_zip)
+from test.support.script_helper import *
--- /dev/null
+"""Supporting definitions for the Python regression tests."""
+
+if __name__ != 'test.support':
+ raise ImportError('test.support must be imported from the test package')
+
+import contextlib
+import errno
+import fnmatch
+import functools
+import gc
+import socket
+import stat
+import sys
+import os
+import platform
+import shutil
+import warnings
+import unittest
+import importlib
+import UserDict
+import re
+import time
+import struct
+import sysconfig
+import types
+
+try:
+ import thread
+except ImportError:
+ thread = None
+
+__all__ = ["Error", "TestFailed", "ResourceDenied", "import_module",
+ "verbose", "use_resources", "max_memuse", "record_original_stdout",
+ "get_original_stdout", "unload", "unlink", "rmtree", "forget",
+ "is_resource_enabled", "requires", "requires_mac_ver",
+ "find_unused_port", "bind_port",
+ "fcmp", "have_unicode", "is_jython", "TESTFN", "HOST", "FUZZ",
+ "SAVEDCWD", "temp_cwd", "findfile", "sortdict", "check_syntax_error",
+ "open_urlresource", "check_warnings", "check_py3k_warnings",
+ "CleanImport", "EnvironmentVarGuard", "captured_output",
+ "captured_stdout", "TransientResource", "transient_internet",
+ "run_with_locale", "set_memlimit", "bigmemtest", "bigaddrspacetest",
+ "BasicTestRunner", "run_unittest", "run_doctest", "threading_setup",
+ "threading_cleanup", "reap_threads", "start_threads", "cpython_only",
+ "check_impl_detail", "get_attribute", "py3k_bytes",
+ "import_fresh_module", "threading_cleanup", "reap_children",
+ "strip_python_stderr", "IPV6_ENABLED", "run_with_tz",
+ "SuppressCrashReport"]
+
+class Error(Exception):
+ """Base class for regression test exceptions."""
+
+class TestFailed(Error):
+ """Test failed."""
+
+class ResourceDenied(unittest.SkipTest):
+ """Test skipped because it requested a disallowed resource.
+
+ This is raised when a test calls requires() for a resource that
+ has not been enabled. It is used to distinguish between expected
+ and unexpected skips.
+ """
+
+@contextlib.contextmanager
+def _ignore_deprecated_imports(ignore=True):
+ """Context manager to suppress package and module deprecation
+ warnings when importing them.
+
+ If ignore is False, this context manager has no effect."""
+ if ignore:
+ with warnings.catch_warnings():
+ warnings.filterwarnings("ignore", ".+ (module|package)",
+ DeprecationWarning)
+ yield
+ else:
+ yield
+
+
+def import_module(name, deprecated=False):
+ """Import and return the module to be tested, raising SkipTest if
+ it is not available.
+
+ If deprecated is True, any module or package deprecation messages
+ will be suppressed."""
+ with _ignore_deprecated_imports(deprecated):
+ try:
+ return importlib.import_module(name)
+ except ImportError, msg:
+ raise unittest.SkipTest(str(msg))
+
+
+def _save_and_remove_module(name, orig_modules):
+ """Helper function to save and remove a module from sys.modules
+
+ Raise ImportError if the module can't be imported."""
+ # try to import the module and raise an error if it can't be imported
+ if name not in sys.modules:
+ __import__(name)
+ del sys.modules[name]
+ for modname in list(sys.modules):
+ if modname == name or modname.startswith(name + '.'):
+ orig_modules[modname] = sys.modules[modname]
+ del sys.modules[modname]
+
+def _save_and_block_module(name, orig_modules):
+ """Helper function to save and block a module in sys.modules
+
+ Return True if the module was in sys.modules, False otherwise."""
+ saved = True
+ try:
+ orig_modules[name] = sys.modules[name]
+ except KeyError:
+ saved = False
+ sys.modules[name] = None
+ return saved
+
+
+def import_fresh_module(name, fresh=(), blocked=(), deprecated=False):
+ """Imports and returns a module, deliberately bypassing the sys.modules cache
+ and importing a fresh copy of the module. Once the import is complete,
+ the sys.modules cache is restored to its original state.
+
+ Modules named in fresh are also imported anew if needed by the import.
+ If one of these modules can't be imported, None is returned.
+
+ Importing of modules named in blocked is prevented while the fresh import
+ takes place.
+
+ If deprecated is True, any module or package deprecation messages
+ will be suppressed."""
+ # NOTE: test_heapq, test_json, and test_warnings include extra sanity
+ # checks to make sure that this utility function is working as expected
+ with _ignore_deprecated_imports(deprecated):
+ # Keep track of modules saved for later restoration as well
+ # as those which just need a blocking entry removed
+ orig_modules = {}
+ names_to_remove = []
+ _save_and_remove_module(name, orig_modules)
+ try:
+ for fresh_name in fresh:
+ _save_and_remove_module(fresh_name, orig_modules)
+ for blocked_name in blocked:
+ if not _save_and_block_module(blocked_name, orig_modules):
+ names_to_remove.append(blocked_name)
+ fresh_module = importlib.import_module(name)
+ except ImportError:
+ fresh_module = None
+ finally:
+ for orig_name, module in orig_modules.items():
+ sys.modules[orig_name] = module
+ for name_to_remove in names_to_remove:
+ del sys.modules[name_to_remove]
+ return fresh_module
+
+
+def get_attribute(obj, name):
+ """Get an attribute, raising SkipTest if AttributeError is raised."""
+ try:
+ attribute = getattr(obj, name)
+ except AttributeError:
+ if isinstance(obj, types.ModuleType):
+ msg = "module %r has no attribute %r" % (obj.__name__, name)
+ elif isinstance(obj, types.ClassType):
+ msg = "class %s has no attribute %r" % (obj.__name__, name)
+ elif isinstance(obj, types.InstanceType):
+ msg = "%s instance has no attribute %r" % (obj.__class__.__name__, name)
+ elif isinstance(obj, type):
+ msg = "type object %r has no attribute %r" % (obj.__name__, name)
+ else:
+ msg = "%r object has no attribute %r" % (type(obj).__name__, name)
+ raise unittest.SkipTest(msg)
+ else:
+ return attribute
+
+
+verbose = 1 # Flag set to 0 by regrtest.py
+use_resources = None # Flag set to [] by regrtest.py
+max_memuse = 0 # Disable bigmem tests (they will still be run with
+ # small sizes, to make sure they work.)
+real_max_memuse = 0
+failfast = False
+match_tests = None
+
+# _original_stdout is meant to hold stdout at the time regrtest began.
+# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
+# The point is to have some flavor of stdout the user can actually see.
+_original_stdout = None
+def record_original_stdout(stdout):
+ global _original_stdout
+ _original_stdout = stdout
+
+def get_original_stdout():
+ return _original_stdout or sys.stdout
+
+def unload(name):
+ try:
+ del sys.modules[name]
+ except KeyError:
+ pass
+
+def _force_run(path, func, *args):
+ try:
+ return func(*args)
+ except EnvironmentError as err:
+ if verbose >= 2:
+ print('%s: %s' % (err.__class__.__name__, err))
+ print('re-run %s%r' % (func.__name__, args))
+ os.chmod(path, stat.S_IRWXU)
+ return func(*args)
+
+if sys.platform.startswith("win"):
+ def _waitfor(func, pathname, waitall=False):
+ # Perform the operation
+ func(pathname)
+ # Now setup the wait loop
+ if waitall:
+ dirname = pathname
+ else:
+ dirname, name = os.path.split(pathname)
+ dirname = dirname or '.'
+ # Check for `pathname` to be removed from the filesystem.
+ # The exponential backoff of the timeout amounts to a total
+ # of ~1 second after which the deletion is probably an error
+ # anyway.
+ # Testing on an i7@4.3GHz shows that usually only 1 iteration is
+ # required when contention occurs.
+ timeout = 0.001
+ while timeout < 1.0:
+ # Note we are only testing for the existence of the file(s) in
+ # the contents of the directory regardless of any security or
+ # access rights. If we have made it this far, we have sufficient
+ # permissions to do that much using Python's equivalent of the
+ # Windows API FindFirstFile.
+ # Other Windows APIs can fail or give incorrect results when
+ # dealing with files that are pending deletion.
+ L = os.listdir(dirname)
+ if not (L if waitall else name in L):
+ return
+ # Increase the timeout and try again
+ time.sleep(timeout)
+ timeout *= 2
+ warnings.warn('tests may fail, delete still pending for ' + pathname,
+ RuntimeWarning, stacklevel=4)
+
+ def _unlink(filename):
+ _waitfor(os.unlink, filename)
+
+ def _rmdir(dirname):
+ _waitfor(os.rmdir, dirname)
+
+ def _rmtree(path):
+ def _rmtree_inner(path):
+ for name in _force_run(path, os.listdir, path):
+ fullname = os.path.join(path, name)
+ if os.path.isdir(fullname):
+ _waitfor(_rmtree_inner, fullname, waitall=True)
+ _force_run(fullname, os.rmdir, fullname)
+ else:
+ _force_run(fullname, os.unlink, fullname)
+ _waitfor(_rmtree_inner, path, waitall=True)
+ _waitfor(lambda p: _force_run(p, os.rmdir, p), path)
+else:
+ _unlink = os.unlink
+ _rmdir = os.rmdir
+
+ def _rmtree(path):
+ try:
+ shutil.rmtree(path)
+ return
+ except EnvironmentError:
+ pass
+
+ def _rmtree_inner(path):
+ for name in _force_run(path, os.listdir, path):
+ fullname = os.path.join(path, name)
+ try:
+ mode = os.lstat(fullname).st_mode
+ except EnvironmentError:
+ mode = 0
+ if stat.S_ISDIR(mode):
+ _rmtree_inner(fullname)
+ _force_run(path, os.rmdir, fullname)
+ else:
+ _force_run(path, os.unlink, fullname)
+ _rmtree_inner(path)
+ os.rmdir(path)
+
+def unlink(filename):
+ try:
+ _unlink(filename)
+ except OSError as exc:
+ if exc.errno not in (errno.ENOENT, errno.ENOTDIR):
+ raise
+
+def rmdir(dirname):
+ try:
+ _rmdir(dirname)
+ except OSError as error:
+ # The directory need not exist.
+ if error.errno != errno.ENOENT:
+ raise
+
+def rmtree(path):
+ try:
+ _rmtree(path)
+ except OSError, e:
+ # Unix returns ENOENT, Windows returns ESRCH.
+ if e.errno not in (errno.ENOENT, errno.ESRCH):
+ raise
+
+def forget(modname):
+ '''"Forget" a module was ever imported by removing it from sys.modules and
+ deleting any .pyc and .pyo files.'''
+ unload(modname)
+ for dirname in sys.path:
+ unlink(os.path.join(dirname, modname + os.extsep + 'pyc'))
+ # Deleting the .pyo file cannot be within the 'try' for the .pyc since
+ # the chance exists that there is no .pyc (and thus the 'try' statement
+ # is exited) but there is a .pyo file.
+ unlink(os.path.join(dirname, modname + os.extsep + 'pyo'))
+
+# Check whether a gui is actually available
+def _is_gui_available():
+ if hasattr(_is_gui_available, 'result'):
+ return _is_gui_available.result
+ reason = None
+ if sys.platform.startswith('win'):
+ # if Python is running as a service (such as the buildbot service),
+ # gui interaction may be disallowed
+ import ctypes
+ import ctypes.wintypes
+ UOI_FLAGS = 1
+ WSF_VISIBLE = 0x0001
+ class USEROBJECTFLAGS(ctypes.Structure):
+ _fields_ = [("fInherit", ctypes.wintypes.BOOL),
+ ("fReserved", ctypes.wintypes.BOOL),
+ ("dwFlags", ctypes.wintypes.DWORD)]
+ dll = ctypes.windll.user32
+ h = dll.GetProcessWindowStation()
+ if not h:
+ raise ctypes.WinError()
+ uof = USEROBJECTFLAGS()
+ needed = ctypes.wintypes.DWORD()
+ res = dll.GetUserObjectInformationW(h,
+ UOI_FLAGS,
+ ctypes.byref(uof),
+ ctypes.sizeof(uof),
+ ctypes.byref(needed))
+ if not res:
+ raise ctypes.WinError()
+ if not bool(uof.dwFlags & WSF_VISIBLE):
+ reason = "gui not available (WSF_VISIBLE flag not set)"
+ elif sys.platform == 'darwin':
+ # The Aqua Tk implementations on OS X can abort the process if
+ # being called in an environment where a window server connection
+ # cannot be made, for instance when invoked by a buildbot or ssh
+ # process not running under the same user id as the current console
+ # user. To avoid that, raise an exception if the window manager
+ # connection is not available.
+ from ctypes import cdll, c_int, pointer, Structure
+ from ctypes.util import find_library
+
+ app_services = cdll.LoadLibrary(find_library("ApplicationServices"))
+
+ if app_services.CGMainDisplayID() == 0:
+ reason = "gui tests cannot run without OS X window manager"
+ else:
+ class ProcessSerialNumber(Structure):
+ _fields_ = [("highLongOfPSN", c_int),
+ ("lowLongOfPSN", c_int)]
+ psn = ProcessSerialNumber()
+ psn_p = pointer(psn)
+ if ( (app_services.GetCurrentProcess(psn_p) < 0) or
+ (app_services.SetFrontProcess(psn_p) < 0) ):
+ reason = "cannot run without OS X gui process"
+
+ # check on every platform whether tkinter can actually do anything
+ if not reason:
+ try:
+ from Tkinter import Tk
+ root = Tk()
+ root.withdraw()
+ root.update()
+ root.destroy()
+ except Exception as e:
+ err_string = str(e)
+ if len(err_string) > 50:
+ err_string = err_string[:50] + ' [...]'
+ reason = 'Tk unavailable due to {}: {}'.format(type(e).__name__,
+ err_string)
+
+ _is_gui_available.reason = reason
+ _is_gui_available.result = not reason
+
+ return _is_gui_available.result
+
+def is_resource_enabled(resource):
+ """Test whether a resource is enabled.
+
+ Known resources are set by regrtest.py. If not running under regrtest.py,
+ all resources are assumed enabled unless use_resources has been set.
+ """
+ return use_resources is None or resource in use_resources
+
+def requires(resource, msg=None):
+ """Raise ResourceDenied if the specified resource is not available."""
+ if not is_resource_enabled(resource):
+ if msg is None:
+ msg = "Use of the `%s' resource not enabled" % resource
+ raise ResourceDenied(msg)
+ if resource == 'gui' and not _is_gui_available():
+ raise ResourceDenied(_is_gui_available.reason)
+
+def requires_mac_ver(*min_version):
+ """Decorator raising SkipTest if the OS is Mac OS X and the OS X
+ version if less than min_version.
+
+ For example, @requires_mac_ver(10, 5) raises SkipTest if the OS X version
+ is lesser than 10.5.
+ """
+ def decorator(func):
+ @functools.wraps(func)
+ def wrapper(*args, **kw):
+ if sys.platform == 'darwin':
+ version_txt = platform.mac_ver()[0]
+ try:
+ version = tuple(map(int, version_txt.split('.')))
+ except ValueError:
+ pass
+ else:
+ if version < min_version:
+ min_version_txt = '.'.join(map(str, min_version))
+ raise unittest.SkipTest(
+ "Mac OS X %s or higher required, not %s"
+ % (min_version_txt, version_txt))
+ return func(*args, **kw)
+ wrapper.min_version = min_version
+ return wrapper
+ return decorator
+
+
+# Don't use "localhost", since resolving it uses the DNS under recent
+# Windows versions (see issue #18792).
+HOST = "127.0.0.1"
+HOSTv6 = "::1"
+
+
+def find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM):
+ """Returns an unused port that should be suitable for binding. This is
+ achieved by creating a temporary socket with the same family and type as
+ the 'sock' parameter (default is AF_INET, SOCK_STREAM), and binding it to
+ the specified host address (defaults to 0.0.0.0) with the port set to 0,
+ eliciting an unused ephemeral port from the OS. The temporary socket is
+ then closed and deleted, and the ephemeral port is returned.
+
+ Either this method or bind_port() should be used for any tests where a
+ server socket needs to be bound to a particular port for the duration of
+ the test. Which one to use depends on whether the calling code is creating
+ a python socket, or if an unused port needs to be provided in a constructor
+ or passed to an external program (i.e. the -accept argument to openssl's
+ s_server mode). Always prefer bind_port() over find_unused_port() where
+ possible. Hard coded ports should *NEVER* be used. As soon as a server
+ socket is bound to a hard coded port, the ability to run multiple instances
+ of the test simultaneously on the same host is compromised, which makes the
+ test a ticking time bomb in a buildbot environment. On Unix buildbots, this
+ may simply manifest as a failed test, which can be recovered from without
+ intervention in most cases, but on Windows, the entire python process can
+ completely and utterly wedge, requiring someone to log in to the buildbot
+ and manually kill the affected process.
+
+ (This is easy to reproduce on Windows, unfortunately, and can be traced to
+ the SO_REUSEADDR socket option having different semantics on Windows versus
+ Unix/Linux. On Unix, you can't have two AF_INET SOCK_STREAM sockets bind,
+ listen and then accept connections on identical host/ports. An EADDRINUSE
+ socket.error will be raised at some point (depending on the platform and
+ the order bind and listen were called on each socket).
+
+ However, on Windows, if SO_REUSEADDR is set on the sockets, no EADDRINUSE
+ will ever be raised when attempting to bind two identical host/ports. When
+ accept() is called on each socket, the second caller's process will steal
+ the port from the first caller, leaving them both in an awkwardly wedged
+ state where they'll no longer respond to any signals or graceful kills, and
+ must be forcibly killed via OpenProcess()/TerminateProcess().
+
+ The solution on Windows is to use the SO_EXCLUSIVEADDRUSE socket option
+ instead of SO_REUSEADDR, which effectively affords the same semantics as
+ SO_REUSEADDR on Unix. Given the propensity of Unix developers in the Open
+ Source world compared to Windows ones, this is a common mistake. A quick
+ look over OpenSSL's 0.9.8g source shows that they use SO_REUSEADDR when
+ openssl.exe is called with the 's_server' option, for example. See
+ http://bugs.python.org/issue2550 for more info. The following site also
+ has a very thorough description about the implications of both REUSEADDR
+ and EXCLUSIVEADDRUSE on Windows:
+ http://msdn2.microsoft.com/en-us/library/ms740621(VS.85).aspx)
+
+ XXX: although this approach is a vast improvement on previous attempts to
+ elicit unused ports, it rests heavily on the assumption that the ephemeral
+ port returned to us by the OS won't immediately be dished back out to some
+ other process when we close and delete our temporary socket but before our
+ calling code has a chance to bind the returned port. We can deal with this
+ issue if/when we come across it."""
+ tempsock = socket.socket(family, socktype)
+ port = bind_port(tempsock)
+ tempsock.close()
+ del tempsock
+ return port
+
+def bind_port(sock, host=HOST):
+ """Bind the socket to a free port and return the port number. Relies on
+ ephemeral ports in order to ensure we are using an unbound port. This is
+ important as many tests may be running simultaneously, especially in a
+ buildbot environment. This method raises an exception if the sock.family
+ is AF_INET and sock.type is SOCK_STREAM, *and* the socket has SO_REUSEADDR
+ or SO_REUSEPORT set on it. Tests should *never* set these socket options
+ for TCP/IP sockets. The only case for setting these options is testing
+ multicasting via multiple UDP sockets.
+
+ Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e.
+ on Windows), it will be set on the socket. This will prevent anyone else
+ from bind()'ing to our host/port for the duration of the test.
+ """
+ if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM:
+ if hasattr(socket, 'SO_REUSEADDR'):
+ if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1:
+ raise TestFailed("tests should never set the SO_REUSEADDR " \
+ "socket option on TCP/IP sockets!")
+ if hasattr(socket, 'SO_REUSEPORT'):
+ try:
+ if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1:
+ raise TestFailed("tests should never set the SO_REUSEPORT " \
+ "socket option on TCP/IP sockets!")
+ except EnvironmentError:
+ # Python's socket module was compiled using modern headers
+ # thus defining SO_REUSEPORT but this process is running
+ # under an older kernel that does not support SO_REUSEPORT.
+ pass
+ if hasattr(socket, 'SO_EXCLUSIVEADDRUSE'):
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+
+ sock.bind((host, 0))
+ port = sock.getsockname()[1]
+ return port
+
+def _is_ipv6_enabled():
+ """Check whether IPv6 is enabled on this host."""
+ if socket.has_ipv6:
+ sock = None
+ try:
+ sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+ sock.bind((HOSTv6, 0))
+ return True
+ except socket.error:
+ pass
+ finally:
+ if sock:
+ sock.close()
+ return False
+
+IPV6_ENABLED = _is_ipv6_enabled()
+
+def system_must_validate_cert(f):
+ """Skip the test on TLS certificate validation failures."""
+ @functools.wraps(f)
+ def dec(*args, **kwargs):
+ try:
+ f(*args, **kwargs)
+ except IOError as e:
+ if "CERTIFICATE_VERIFY_FAILED" in str(e):
+ raise unittest.SkipTest("system does not contain "
+ "necessary certificates")
+ raise
+ return dec
+
+FUZZ = 1e-6
+
+def fcmp(x, y): # fuzzy comparison function
+ if isinstance(x, float) or isinstance(y, float):
+ try:
+ fuzz = (abs(x) + abs(y)) * FUZZ
+ if abs(x-y) <= fuzz:
+ return 0
+ except:
+ pass
+ elif type(x) == type(y) and isinstance(x, (tuple, list)):
+ for i in range(min(len(x), len(y))):
+ outcome = fcmp(x[i], y[i])
+ if outcome != 0:
+ return outcome
+ return (len(x) > len(y)) - (len(x) < len(y))
+ return (x > y) - (x < y)
+
+
+# A constant likely larger than the underlying OS pipe buffer size, to
+# make writes blocking.
+# Windows limit seems to be around 512 B, and many Unix kernels have a
+# 64 KiB pipe buffer size or 16 * PAGE_SIZE: take a few megs to be sure.
+# (see issue #17835 for a discussion of this number).
+PIPE_MAX_SIZE = 4 * 1024 * 1024 + 1
+
+# A constant likely larger than the underlying OS socket buffer size, to make
+# writes blocking.
+# The socket buffer sizes can usually be tuned system-wide (e.g. through sysctl
+# on Linux), or on a per-socket basis (SO_SNDBUF/SO_RCVBUF). See issue #18643
+# for a discussion of this number).
+SOCK_MAX_SIZE = 16 * 1024 * 1024 + 1
+
+is_jython = sys.platform.startswith('java')
+
+try:
+ unicode
+ have_unicode = True
+except NameError:
+ have_unicode = False
+
+requires_unicode = unittest.skipUnless(have_unicode, 'no unicode support')
+
+def u(s):
+ return unicode(s, 'unicode-escape')
+
+# FS_NONASCII: non-ASCII Unicode character encodable by
+# sys.getfilesystemencoding(), or None if there is no such character.
+FS_NONASCII = None
+if have_unicode:
+ for character in (
+ # First try printable and common characters to have a readable filename.
+ # For each character, the encoding list are just example of encodings able
+ # to encode the character (the list is not exhaustive).
+
+ # U+00E6 (Latin Small Letter Ae): cp1252, iso-8859-1
+ unichr(0x00E6),
+ # U+0130 (Latin Capital Letter I With Dot Above): cp1254, iso8859_3
+ unichr(0x0130),
+ # U+0141 (Latin Capital Letter L With Stroke): cp1250, cp1257
+ unichr(0x0141),
+ # U+03C6 (Greek Small Letter Phi): cp1253
+ unichr(0x03C6),
+ # U+041A (Cyrillic Capital Letter Ka): cp1251
+ unichr(0x041A),
+ # U+05D0 (Hebrew Letter Alef): Encodable to cp424
+ unichr(0x05D0),
+ # U+060C (Arabic Comma): cp864, cp1006, iso8859_6, mac_arabic
+ unichr(0x060C),
+ # U+062A (Arabic Letter Teh): cp720
+ unichr(0x062A),
+ # U+0E01 (Thai Character Ko Kai): cp874
+ unichr(0x0E01),
+
+ # Then try more "special" characters. "special" because they may be
+ # interpreted or displayed differently depending on the exact locale
+ # encoding and the font.
+
+ # U+00A0 (No-Break Space)
+ unichr(0x00A0),
+ # U+20AC (Euro Sign)
+ unichr(0x20AC),
+ ):
+ try:
+ character.encode(sys.getfilesystemencoding())\
+ .decode(sys.getfilesystemencoding())
+ except UnicodeError:
+ pass
+ else:
+ FS_NONASCII = character
+ break
+
+# Filename used for testing
+if os.name == 'java':
+ # Jython disallows @ in module names
+ TESTFN = '$test'
+elif os.name == 'riscos':
+ TESTFN = 'testfile'
+else:
+ TESTFN = '@test'
+ # Unicode name only used if TEST_FN_ENCODING exists for the platform.
+ if have_unicode:
+ # Assuming sys.getfilesystemencoding()!=sys.getdefaultencoding()
+ # TESTFN_UNICODE is a filename that can be encoded using the
+ # file system encoding, but *not* with the default (ascii) encoding
+ if isinstance('', unicode):
+ # python -U
+ # XXX perhaps unicode() should accept Unicode strings?
+ TESTFN_UNICODE = "@test-\xe0\xf2"
+ else:
+ # 2 latin characters.
+ TESTFN_UNICODE = unicode("@test-\xe0\xf2", "latin-1")
+ TESTFN_ENCODING = sys.getfilesystemencoding()
+ # TESTFN_UNENCODABLE is a filename that should *not* be
+ # able to be encoded by *either* the default or filesystem encoding.
+ # This test really only makes sense on Windows NT platforms
+ # which have special Unicode support in posixmodule.
+ if (not hasattr(sys, "getwindowsversion") or
+ sys.getwindowsversion()[3] < 2): # 0=win32s or 1=9x/ME
+ TESTFN_UNENCODABLE = None
+ else:
+ # Japanese characters (I think - from bug 846133)
+ TESTFN_UNENCODABLE = eval('u"@test-\u5171\u6709\u3055\u308c\u308b"')
+ try:
+ # XXX - Note - should be using TESTFN_ENCODING here - but for
+ # Windows, "mbcs" currently always operates as if in
+ # errors=ignore' mode - hence we get '?' characters rather than
+ # the exception. 'Latin1' operates as we expect - ie, fails.
+ # See [ 850997 ] mbcs encoding ignores errors
+ TESTFN_UNENCODABLE.encode("Latin1")
+ except UnicodeEncodeError:
+ pass
+ else:
+ print \
+ 'WARNING: The filename %r CAN be encoded by the filesystem. ' \
+ 'Unicode filename tests may not be effective' \
+ % TESTFN_UNENCODABLE
+
+
+# Disambiguate TESTFN for parallel testing, while letting it remain a valid
+# module name.
+TESTFN = "{}_{}_tmp".format(TESTFN, os.getpid())
+
+# Save the initial cwd
+SAVEDCWD = os.getcwd()
+
+@contextlib.contextmanager
+def temp_dir(path=None, quiet=False):
+ """Return a context manager that creates a temporary directory.
+
+ Arguments:
+
+ path: the directory to create temporarily. If omitted or None,
+ defaults to creating a temporary directory using tempfile.mkdtemp.
+
+ quiet: if False (the default), the context manager raises an exception
+ on error. Otherwise, if the path is specified and cannot be
+ created, only a warning is issued.
+
+ """
+ dir_created = False
+ if path is None:
+ import tempfile
+ path = tempfile.mkdtemp()
+ dir_created = True
+ path = os.path.realpath(path)
+ else:
+ if (have_unicode and isinstance(path, unicode) and
+ not os.path.supports_unicode_filenames):
+ try:
+ path = path.encode(sys.getfilesystemencoding() or 'ascii')
+ except UnicodeEncodeError:
+ if not quiet:
+ raise unittest.SkipTest('unable to encode the cwd name with '
+ 'the filesystem encoding.')
+ try:
+ os.mkdir(path)
+ dir_created = True
+ except OSError:
+ if not quiet:
+ raise
+ warnings.warn('tests may fail, unable to create temp dir: ' + path,
+ RuntimeWarning, stacklevel=3)
+ try:
+ yield path
+ finally:
+ if dir_created:
+ rmtree(path)
+
+@contextlib.contextmanager
+def change_cwd(path, quiet=False):
+ """Return a context manager that changes the current working directory.
+
+ Arguments:
+
+ path: the directory to use as the temporary current working directory.
+
+ quiet: if False (the default), the context manager raises an exception
+ on error. Otherwise, it issues only a warning and keeps the current
+ working directory the same.
+
+ """
+ saved_dir = os.getcwd()
+ try:
+ os.chdir(path)
+ except OSError:
+ if not quiet:
+ raise
+ warnings.warn('tests may fail, unable to change CWD to: ' + path,
+ RuntimeWarning, stacklevel=3)
+ try:
+ yield os.getcwd()
+ finally:
+ os.chdir(saved_dir)
+
+
+@contextlib.contextmanager
+def temp_cwd(name='tempcwd', quiet=False):
+ """
+ Context manager that temporarily creates and changes the CWD.
+
+ The function temporarily changes the current working directory
+ after creating a temporary directory in the current directory with
+ name *name*. If *name* is None, the temporary directory is
+ created using tempfile.mkdtemp.
+
+ If *quiet* is False (default) and it is not possible to
+ create or change the CWD, an error is raised. If *quiet* is True,
+ only a warning is raised and the original CWD is used.
+
+ """
+ with temp_dir(path=name, quiet=quiet) as temp_path:
+ with change_cwd(temp_path, quiet=quiet) as cwd_dir:
+ yield cwd_dir
+
+# TEST_HOME_DIR refers to the top level directory of the "test" package
+# that contains Python's regression test suite
+TEST_SUPPORT_DIR = os.path.dirname(os.path.abspath(__file__))
+TEST_HOME_DIR = os.path.dirname(TEST_SUPPORT_DIR)
+
+# TEST_DATA_DIR is used as a target download location for remote resources
+TEST_DATA_DIR = os.path.join(TEST_HOME_DIR, "data")
+
+def findfile(file, subdir=None):
+ """Try to find a file on sys.path and the working directory. If it is not
+ found the argument passed to the function is returned (this does not
+ necessarily signal failure; could still be the legitimate path)."""
+ if os.path.isabs(file):
+ return file
+ if subdir is not None:
+ file = os.path.join(subdir, file)
+ path = [TEST_HOME_DIR] + sys.path
+ for dn in path:
+ fn = os.path.join(dn, file)
+ if os.path.exists(fn): return fn
+ return file
+
+def sortdict(dict):
+ "Like repr(dict), but in sorted order."
+ items = dict.items()
+ items.sort()
+ reprpairs = ["%r: %r" % pair for pair in items]
+ withcommas = ", ".join(reprpairs)
+ return "{%s}" % withcommas
+
+def make_bad_fd():
+ """
+ Create an invalid file descriptor by opening and closing a file and return
+ its fd.
+ """
+ file = open(TESTFN, "wb")
+ try:
+ return file.fileno()
+ finally:
+ file.close()
+ unlink(TESTFN)
+
+def check_syntax_error(testcase, statement, lineno=None, offset=None):
+ with testcase.assertRaises(SyntaxError) as cm:
+ compile(statement, '<test string>', 'exec')
+ err = cm.exception
+ if lineno is not None:
+ testcase.assertEqual(err.lineno, lineno)
+ if offset is not None:
+ testcase.assertEqual(err.offset, offset)
+
+def open_urlresource(url, check=None):
+ import urlparse, urllib2
+
+ filename = urlparse.urlparse(url)[2].split('/')[-1] # '/': it's URL!
+
+ fn = os.path.join(TEST_DATA_DIR, filename)
+
+ def check_valid_file(fn):
+ f = open(fn)
+ if check is None:
+ return f
+ elif check(f):
+ f.seek(0)
+ return f
+ f.close()
+
+ if os.path.exists(fn):
+ f = check_valid_file(fn)
+ if f is not None:
+ return f
+ unlink(fn)
+
+ # Verify the requirement before downloading the file
+ requires('urlfetch')
+
+ print >> get_original_stdout(), '\tfetching %s ...' % url
+ f = urllib2.urlopen(url, timeout=15)
+ try:
+ with open(fn, "wb") as out:
+ s = f.read()
+ while s:
+ out.write(s)
+ s = f.read()
+ finally:
+ f.close()
+
+ f = check_valid_file(fn)
+ if f is not None:
+ return f
+ raise TestFailed('invalid resource "%s"' % fn)
+
+
+class WarningsRecorder(object):
+ """Convenience wrapper for the warnings list returned on
+ entry to the warnings.catch_warnings() context manager.
+ """
+ def __init__(self, warnings_list):
+ self._warnings = warnings_list
+ self._last = 0
+
+ def __getattr__(self, attr):
+ if len(self._warnings) > self._last:
+ return getattr(self._warnings[-1], attr)
+ elif attr in warnings.WarningMessage._WARNING_DETAILS:
+ return None
+ raise AttributeError("%r has no attribute %r" % (self, attr))
+
+ @property
+ def warnings(self):
+ return self._warnings[self._last:]
+
+ def reset(self):
+ self._last = len(self._warnings)
+
+
+def _filterwarnings(filters, quiet=False):
+ """Catch the warnings, then check if all the expected
+ warnings have been raised and re-raise unexpected warnings.
+ If 'quiet' is True, only re-raise the unexpected warnings.
+ """
+ # Clear the warning registry of the calling module
+ # in order to re-raise the warnings.
+ frame = sys._getframe(2)
+ registry = frame.f_globals.get('__warningregistry__')
+ if registry:
+ registry.clear()
+ with warnings.catch_warnings(record=True) as w:
+ # Set filter "always" to record all warnings. Because
+ # test_warnings swap the module, we need to look up in
+ # the sys.modules dictionary.
+ sys.modules['warnings'].simplefilter("always")
+ yield WarningsRecorder(w)
+ # Filter the recorded warnings
+ reraise = [warning.message for warning in w]
+ missing = []
+ for msg, cat in filters:
+ seen = False
+ for exc in reraise[:]:
+ message = str(exc)
+ # Filter out the matching messages
+ if (re.match(msg, message, re.I) and
+ issubclass(exc.__class__, cat)):
+ seen = True
+ reraise.remove(exc)
+ if not seen and not quiet:
+ # This filter caught nothing
+ missing.append((msg, cat.__name__))
+ if reraise:
+ raise AssertionError("unhandled warning %r" % reraise[0])
+ if missing:
+ raise AssertionError("filter (%r, %s) did not catch any warning" %
+ missing[0])
+
+
+@contextlib.contextmanager
+def check_warnings(*filters, **kwargs):
+ """Context manager to silence warnings.
+
+ Accept 2-tuples as positional arguments:
+ ("message regexp", WarningCategory)
+
+ Optional argument:
+ - if 'quiet' is True, it does not fail if a filter catches nothing
+ (default True without argument,
+ default False if some filters are defined)
+
+ Without argument, it defaults to:
+ check_warnings(("", Warning), quiet=True)
+ """
+ quiet = kwargs.get('quiet')
+ if not filters:
+ filters = (("", Warning),)
+ # Preserve backward compatibility
+ if quiet is None:
+ quiet = True
+ return _filterwarnings(filters, quiet)
+
+
+@contextlib.contextmanager
+def check_py3k_warnings(*filters, **kwargs):
+ """Context manager to silence py3k warnings.
+
+ Accept 2-tuples as positional arguments:
+ ("message regexp", WarningCategory)
+
+ Optional argument:
+ - if 'quiet' is True, it does not fail if a filter catches nothing
+ (default False)
+
+ Without argument, it defaults to:
+ check_py3k_warnings(("", DeprecationWarning), quiet=False)
+ """
+ if sys.py3kwarning:
+ if not filters:
+ filters = (("", DeprecationWarning),)
+ else:
+ # It should not raise any py3k warning
+ filters = ()
+ return _filterwarnings(filters, kwargs.get('quiet'))
+
+
+class CleanImport(object):
+ """Context manager to force import to return a new module reference.
+
+ This is useful for testing module-level behaviours, such as
+ the emission of a DeprecationWarning on import.
+
+ Use like this:
+
+ with CleanImport("foo"):
+ importlib.import_module("foo") # new reference
+ """
+
+ def __init__(self, *module_names):
+ self.original_modules = sys.modules.copy()
+ for module_name in module_names:
+ if module_name in sys.modules:
+ module = sys.modules[module_name]
+ # It is possible that module_name is just an alias for
+ # another module (e.g. stub for modules renamed in 3.x).
+ # In that case, we also need delete the real module to clear
+ # the import cache.
+ if module.__name__ != module_name:
+ del sys.modules[module.__name__]
+ del sys.modules[module_name]
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *ignore_exc):
+ sys.modules.update(self.original_modules)
+
+
+class EnvironmentVarGuard(UserDict.DictMixin):
+
+ """Class to help protect the environment variable properly. Can be used as
+ a context manager."""
+
+ def __init__(self):
+ self._environ = os.environ
+ self._changed = {}
+
+ def __getitem__(self, envvar):
+ return self._environ[envvar]
+
+ def __setitem__(self, envvar, value):
+ # Remember the initial value on the first access
+ if envvar not in self._changed:
+ self._changed[envvar] = self._environ.get(envvar)
+ self._environ[envvar] = value
+
+ def __delitem__(self, envvar):
+ # Remember the initial value on the first access
+ if envvar not in self._changed:
+ self._changed[envvar] = self._environ.get(envvar)
+ if envvar in self._environ:
+ del self._environ[envvar]
+
+ def keys(self):
+ return self._environ.keys()
+
+ def set(self, envvar, value):
+ self[envvar] = value
+
+ def unset(self, envvar):
+ del self[envvar]
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *ignore_exc):
+ for (k, v) in self._changed.items():
+ if v is None:
+ if k in self._environ:
+ del self._environ[k]
+ else:
+ self._environ[k] = v
+ os.environ = self._environ
+
+
+class DirsOnSysPath(object):
+ """Context manager to temporarily add directories to sys.path.
+
+ This makes a copy of sys.path, appends any directories given
+ as positional arguments, then reverts sys.path to the copied
+ settings when the context ends.
+
+ Note that *all* sys.path modifications in the body of the
+ context manager, including replacement of the object,
+ will be reverted at the end of the block.
+ """
+
+ def __init__(self, *paths):
+ self.original_value = sys.path[:]
+ self.original_object = sys.path
+ sys.path.extend(paths)
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *ignore_exc):
+ sys.path = self.original_object
+ sys.path[:] = self.original_value
+
+
+class TransientResource(object):
+
+ """Raise ResourceDenied if an exception is raised while the context manager
+ is in effect that matches the specified exception and attributes."""
+
+ def __init__(self, exc, **kwargs):
+ self.exc = exc
+ self.attrs = kwargs
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, type_=None, value=None, traceback=None):
+ """If type_ is a subclass of self.exc and value has attributes matching
+ self.attrs, raise ResourceDenied. Otherwise let the exception
+ propagate (if any)."""
+ if type_ is not None and issubclass(self.exc, type_):
+ for attr, attr_value in self.attrs.iteritems():
+ if not hasattr(value, attr):
+ break
+ if getattr(value, attr) != attr_value:
+ break
+ else:
+ raise ResourceDenied("an optional resource is not available")
+
+
+@contextlib.contextmanager
+def transient_internet(resource_name, timeout=30.0, errnos=()):
+ """Return a context manager that raises ResourceDenied when various issues
+ with the Internet connection manifest themselves as exceptions."""
+ default_errnos = [
+ ('ECONNREFUSED', 111),
+ ('ECONNRESET', 104),
+ ('EHOSTUNREACH', 113),
+ ('ENETUNREACH', 101),
+ ('ETIMEDOUT', 110),
+ ]
+ default_gai_errnos = [
+ ('EAI_AGAIN', -3),
+ ('EAI_FAIL', -4),
+ ('EAI_NONAME', -2),
+ ('EAI_NODATA', -5),
+ # Windows defines EAI_NODATA as 11001 but idiotic getaddrinfo()
+ # implementation actually returns WSANO_DATA i.e. 11004.
+ ('WSANO_DATA', 11004),
+ ]
+
+ denied = ResourceDenied("Resource '%s' is not available" % resource_name)
+ captured_errnos = errnos
+ gai_errnos = []
+ if not captured_errnos:
+ captured_errnos = [getattr(errno, name, num)
+ for (name, num) in default_errnos]
+ gai_errnos = [getattr(socket, name, num)
+ for (name, num) in default_gai_errnos]
+
+ def filter_error(err):
+ n = getattr(err, 'errno', None)
+ if (isinstance(err, socket.timeout) or
+ (isinstance(err, socket.gaierror) and n in gai_errnos) or
+ n in captured_errnos):
+ if not verbose:
+ sys.stderr.write(denied.args[0] + "\n")
+ raise denied
+
+ old_timeout = socket.getdefaulttimeout()
+ try:
+ if timeout is not None:
+ socket.setdefaulttimeout(timeout)
+ yield
+ except IOError as err:
+ # urllib can wrap original socket errors multiple times (!), we must
+ # unwrap to get at the original error.
+ while True:
+ a = err.args
+ if len(a) >= 1 and isinstance(a[0], IOError):
+ err = a[0]
+ # The error can also be wrapped as args[1]:
+ # except socket.error as msg:
+ # raise IOError('socket error', msg).with_traceback(sys.exc_info()[2])
+ elif len(a) >= 2 and isinstance(a[1], IOError):
+ err = a[1]
+ else:
+ break
+ filter_error(err)
+ raise
+ # XXX should we catch generic exceptions and look for their
+ # __cause__ or __context__?
+ finally:
+ socket.setdefaulttimeout(old_timeout)
+
+
+@contextlib.contextmanager
+def captured_output(stream_name):
+ """Return a context manager used by captured_stdout and captured_stdin
+ that temporarily replaces the sys stream *stream_name* with a StringIO."""
+ import StringIO
+ orig_stdout = getattr(sys, stream_name)
+ setattr(sys, stream_name, StringIO.StringIO())
+ try:
+ yield getattr(sys, stream_name)
+ finally:
+ setattr(sys, stream_name, orig_stdout)
+
+def captured_stdout():
+ """Capture the output of sys.stdout:
+
+ with captured_stdout() as s:
+ print "hello"
+ self.assertEqual(s.getvalue(), "hello")
+ """
+ return captured_output("stdout")
+
+def captured_stderr():
+ return captured_output("stderr")
+
+def captured_stdin():
+ return captured_output("stdin")
+
+def gc_collect():
+ """Force as many objects as possible to be collected.
+
+ In non-CPython implementations of Python, this is needed because timely
+ deallocation is not guaranteed by the garbage collector. (Even in CPython
+ this can be the case in case of reference cycles.) This means that __del__
+ methods may be called later than expected and weakrefs may remain alive for
+ longer than expected. This function tries its best to force all garbage
+ objects to disappear.
+ """
+ gc.collect()
+ if is_jython:
+ time.sleep(0.1)
+ gc.collect()
+ gc.collect()
+
+
+_header = '2P'
+if hasattr(sys, "gettotalrefcount"):
+ _header = '2P' + _header
+_vheader = _header + 'P'
+
+def calcobjsize(fmt):
+ return struct.calcsize(_header + fmt + '0P')
+
+def calcvobjsize(fmt):
+ return struct.calcsize(_vheader + fmt + '0P')
+
+
+_TPFLAGS_HAVE_GC = 1<<14
+_TPFLAGS_HEAPTYPE = 1<<9
+
+def check_sizeof(test, o, size):
+ import _testcapi
+ result = sys.getsizeof(o)
+ # add GC header size
+ if ((type(o) == type) and (o.__flags__ & _TPFLAGS_HEAPTYPE) or\
+ ((type(o) != type) and (type(o).__flags__ & _TPFLAGS_HAVE_GC))):
+ size += _testcapi.SIZEOF_PYGC_HEAD
+ msg = 'wrong size for %s: got %d, expected %d' \
+ % (type(o), result, size)
+ test.assertEqual(result, size, msg)
+
+
+#=======================================================================
+# Decorator for running a function in a different locale, correctly resetting
+# it afterwards.
+
+def run_with_locale(catstr, *locales):
+ def decorator(func):
+ def inner(*args, **kwds):
+ try:
+ import locale
+ category = getattr(locale, catstr)
+ orig_locale = locale.setlocale(category)
+ except AttributeError:
+ # if the test author gives us an invalid category string
+ raise
+ except:
+ # cannot retrieve original locale, so do nothing
+ locale = orig_locale = None
+ else:
+ for loc in locales:
+ try:
+ locale.setlocale(category, loc)
+ break
+ except:
+ pass
+
+ # now run the function, resetting the locale on exceptions
+ try:
+ return func(*args, **kwds)
+ finally:
+ if locale and orig_locale:
+ locale.setlocale(category, orig_locale)
+ inner.func_name = func.func_name
+ inner.__doc__ = func.__doc__
+ return inner
+ return decorator
+
+#=======================================================================
+# Decorator for running a function in a specific timezone, correctly
+# resetting it afterwards.
+
+def run_with_tz(tz):
+ def decorator(func):
+ def inner(*args, **kwds):
+ try:
+ tzset = time.tzset
+ except AttributeError:
+ raise unittest.SkipTest("tzset required")
+ if 'TZ' in os.environ:
+ orig_tz = os.environ['TZ']
+ else:
+ orig_tz = None
+ os.environ['TZ'] = tz
+ tzset()
+
+ # now run the function, resetting the tz on exceptions
+ try:
+ return func(*args, **kwds)
+ finally:
+ if orig_tz is None:
+ del os.environ['TZ']
+ else:
+ os.environ['TZ'] = orig_tz
+ time.tzset()
+
+ inner.__name__ = func.__name__
+ inner.__doc__ = func.__doc__
+ return inner
+ return decorator
+
+#=======================================================================
+# Big-memory-test support. Separate from 'resources' because memory use should be configurable.
+
+# Some handy shorthands. Note that these are used for byte-limits as well
+# as size-limits, in the various bigmem tests
+_1M = 1024*1024
+_1G = 1024 * _1M
+_2G = 2 * _1G
+_4G = 4 * _1G
+
+MAX_Py_ssize_t = sys.maxsize
+
+def set_memlimit(limit):
+ global max_memuse
+ global real_max_memuse
+ sizes = {
+ 'k': 1024,
+ 'm': _1M,
+ 'g': _1G,
+ 't': 1024*_1G,
+ }
+ m = re.match(r'(\d+(\.\d+)?) (K|M|G|T)b?$', limit,
+ re.IGNORECASE | re.VERBOSE)
+ if m is None:
+ raise ValueError('Invalid memory limit %r' % (limit,))
+ memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
+ real_max_memuse = memlimit
+ if memlimit > MAX_Py_ssize_t:
+ memlimit = MAX_Py_ssize_t
+ if memlimit < _2G - 1:
+ raise ValueError('Memory limit %r too low to be useful' % (limit,))
+ max_memuse = memlimit
+
+def bigmemtest(minsize, memuse, overhead=5*_1M):
+ """Decorator for bigmem tests.
+
+ 'minsize' is the minimum useful size for the test (in arbitrary,
+ test-interpreted units.) 'memuse' is the number of 'bytes per size' for
+ the test, or a good estimate of it. 'overhead' specifies fixed overhead,
+ independent of the testsize, and defaults to 5Mb.
+
+ The decorator tries to guess a good value for 'size' and passes it to
+ the decorated test function. If minsize * memuse is more than the
+ allowed memory use (as defined by max_memuse), the test is skipped.
+ Otherwise, minsize is adjusted upward to use up to max_memuse.
+ """
+ def decorator(f):
+ def wrapper(self):
+ if not max_memuse:
+ # If max_memuse is 0 (the default),
+ # we still want to run the tests with size set to a few kb,
+ # to make sure they work. We still want to avoid using
+ # too much memory, though, but we do that noisily.
+ maxsize = 5147
+ self.assertFalse(maxsize * memuse + overhead > 20 * _1M)
+ else:
+ maxsize = int((max_memuse - overhead) / memuse)
+ if maxsize < minsize:
+ # Really ought to print 'test skipped' or something
+ if verbose:
+ sys.stderr.write("Skipping %s because of memory "
+ "constraint\n" % (f.__name__,))
+ return
+ # Try to keep some breathing room in memory use
+ maxsize = max(maxsize - 50 * _1M, minsize)
+ return f(self, maxsize)
+ wrapper.minsize = minsize
+ wrapper.memuse = memuse
+ wrapper.overhead = overhead
+ return wrapper
+ return decorator
+
+def precisionbigmemtest(size, memuse, overhead=5*_1M, dry_run=True):
+ def decorator(f):
+ def wrapper(self):
+ if not real_max_memuse:
+ maxsize = 5147
+ else:
+ maxsize = size
+
+ if ((real_max_memuse or not dry_run)
+ and real_max_memuse < maxsize * memuse):
+ if verbose:
+ sys.stderr.write("Skipping %s because of memory "
+ "constraint\n" % (f.__name__,))
+ return
+
+ return f(self, maxsize)
+ wrapper.size = size
+ wrapper.memuse = memuse
+ wrapper.overhead = overhead
+ return wrapper
+ return decorator
+
+def bigaddrspacetest(f):
+ """Decorator for tests that fill the address space."""
+ def wrapper(self):
+ if max_memuse < MAX_Py_ssize_t:
+ if verbose:
+ sys.stderr.write("Skipping %s because of memory "
+ "constraint\n" % (f.__name__,))
+ else:
+ return f(self)
+ return wrapper
+
+#=======================================================================
+# unittest integration.
+
+class BasicTestRunner:
+ def run(self, test):
+ result = unittest.TestResult()
+ test(result)
+ return result
+
+def _id(obj):
+ return obj
+
+def requires_resource(resource):
+ if resource == 'gui' and not _is_gui_available():
+ return unittest.skip(_is_gui_available.reason)
+ if is_resource_enabled(resource):
+ return _id
+ else:
+ return unittest.skip("resource {0!r} is not enabled".format(resource))
+
+def cpython_only(test):
+ """
+ Decorator for tests only applicable on CPython.
+ """
+ return impl_detail(cpython=True)(test)
+
+def impl_detail(msg=None, **guards):
+ if check_impl_detail(**guards):
+ return _id
+ if msg is None:
+ guardnames, default = _parse_guards(guards)
+ if default:
+ msg = "implementation detail not available on {0}"
+ else:
+ msg = "implementation detail specific to {0}"
+ guardnames = sorted(guardnames.keys())
+ msg = msg.format(' or '.join(guardnames))
+ return unittest.skip(msg)
+
+def _parse_guards(guards):
+ # Returns a tuple ({platform_name: run_me}, default_value)
+ if not guards:
+ return ({'cpython': True}, False)
+ is_true = guards.values()[0]
+ assert guards.values() == [is_true] * len(guards) # all True or all False
+ return (guards, not is_true)
+
+# Use the following check to guard CPython's implementation-specific tests --
+# or to run them only on the implementation(s) guarded by the arguments.
+def check_impl_detail(**guards):
+ """This function returns True or False depending on the host platform.
+ Examples:
+ if check_impl_detail(): # only on CPython (default)
+ if check_impl_detail(jython=True): # only on Jython
+ if check_impl_detail(cpython=False): # everywhere except on CPython
+ """
+ guards, default = _parse_guards(guards)
+ return guards.get(platform.python_implementation().lower(), default)
+
+
+def _filter_suite(suite, pred):
+ """Recursively filter test cases in a suite based on a predicate."""
+ newtests = []
+ for test in suite._tests:
+ if isinstance(test, unittest.TestSuite):
+ _filter_suite(test, pred)
+ newtests.append(test)
+ else:
+ if pred(test):
+ newtests.append(test)
+ suite._tests = newtests
+
+def _run_suite(suite):
+ """Run tests from a unittest.TestSuite-derived class."""
+ if verbose:
+ runner = unittest.TextTestRunner(sys.stdout, verbosity=2,
+ failfast=failfast)
+ else:
+ runner = BasicTestRunner()
+
+ result = runner.run(suite)
+ if not result.wasSuccessful():
+ if len(result.errors) == 1 and not result.failures:
+ err = result.errors[0][1]
+ elif len(result.failures) == 1 and not result.errors:
+ err = result.failures[0][1]
+ else:
+ err = "multiple errors occurred"
+ if not verbose:
+ err += "; run in verbose mode for details"
+ raise TestFailed(err)
+
+
+def _match_test(test):
+ global match_tests
+
+ if match_tests is None:
+ return True
+ test_id = test.id()
+
+ for match_test in match_tests:
+ if fnmatch.fnmatchcase(test_id, match_test):
+ return True
+
+ for name in test_id.split("."):
+ if fnmatch.fnmatchcase(name, match_test):
+ return True
+ return False
+
+
+def run_unittest(*classes):
+ """Run tests from unittest.TestCase-derived classes."""
+ valid_types = (unittest.TestSuite, unittest.TestCase)
+ suite = unittest.TestSuite()
+ for cls in classes:
+ if isinstance(cls, str):
+ if cls in sys.modules:
+ suite.addTest(unittest.findTestCases(sys.modules[cls]))
+ else:
+ raise ValueError("str arguments must be keys in sys.modules")
+ elif isinstance(cls, valid_types):
+ suite.addTest(cls)
+ else:
+ suite.addTest(unittest.makeSuite(cls))
+ _filter_suite(suite, _match_test)
+ _run_suite(suite)
+
+#=======================================================================
+# Check for the presence of docstrings.
+
+HAVE_DOCSTRINGS = (check_impl_detail(cpython=False) or
+ sys.platform == 'win32' or
+ sysconfig.get_config_var('WITH_DOC_STRINGS'))
+
+requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS,
+ "test requires docstrings")
+
+
+#=======================================================================
+# doctest driver.
+
+def run_doctest(module, verbosity=None):
+ """Run doctest on the given module. Return (#failures, #tests).
+
+ If optional argument verbosity is not specified (or is None), pass
+ test.support's belief about verbosity on to doctest. Else doctest's
+ usual behavior is used (it searches sys.argv for -v).
+ """
+
+ import doctest
+
+ if verbosity is None:
+ verbosity = verbose
+ else:
+ verbosity = None
+
+ # Direct doctest output (normally just errors) to real stdout; doctest
+ # output shouldn't be compared by regrtest.
+ save_stdout = sys.stdout
+ sys.stdout = get_original_stdout()
+ try:
+ f, t = doctest.testmod(module, verbose=verbosity)
+ if f:
+ raise TestFailed("%d of %d doctests failed" % (f, t))
+ finally:
+ sys.stdout = save_stdout
+ if verbose:
+ print 'doctest (%s) ... %d tests with zero failures' % (module.__name__, t)
+ return f, t
+
+#=======================================================================
+# Threading support to prevent reporting refleaks when running regrtest.py -R
+
+# NOTE: we use thread._count() rather than threading.enumerate() (or the
+# moral equivalent thereof) because a threading.Thread object is still alive
+# until its __bootstrap() method has returned, even after it has been
+# unregistered from the threading module.
+# thread._count(), on the other hand, only gets decremented *after* the
+# __bootstrap() method has returned, which gives us reliable reference counts
+# at the end of a test run.
+
+def threading_setup():
+ if thread:
+ return thread._count(),
+ else:
+ return 1,
+
+def threading_cleanup(nb_threads):
+ if not thread:
+ return
+
+ _MAX_COUNT = 10
+ for count in range(_MAX_COUNT):
+ n = thread._count()
+ if n == nb_threads:
+ break
+ time.sleep(0.1)
+ # XXX print a warning in case of failure?
+
+def reap_threads(func):
+ """Use this function when threads are being used. This will
+ ensure that the threads are cleaned up even when the test fails.
+ If threading is unavailable this function does nothing.
+ """
+ if not thread:
+ return func
+
+ @functools.wraps(func)
+ def decorator(*args):
+ key = threading_setup()
+ try:
+ return func(*args)
+ finally:
+ threading_cleanup(*key)
+ return decorator
+
+def reap_children():
+ """Use this function at the end of test_main() whenever sub-processes
+ are started. This will help ensure that no extra children (zombies)
+ stick around to hog resources and create problems when looking
+ for refleaks.
+ """
+
+ # Reap all our dead child processes so we don't leave zombies around.
+ # These hog resources and might be causing some of the buildbots to die.
+ if hasattr(os, 'waitpid'):
+ any_process = -1
+ while True:
+ try:
+ # This will raise an exception on Windows. That's ok.
+ pid, status = os.waitpid(any_process, os.WNOHANG)
+ if pid == 0:
+ break
+ except:
+ break
+
+@contextlib.contextmanager
+def start_threads(threads, unlock=None):
+ threads = list(threads)
+ started = []
+ try:
+ try:
+ for t in threads:
+ t.start()
+ started.append(t)
+ except:
+ if verbose:
+ print("Can't start %d threads, only %d threads started" %
+ (len(threads), len(started)))
+ raise
+ yield
+ finally:
+ if unlock:
+ unlock()
+ endtime = starttime = time.time()
+ for timeout in range(1, 16):
+ endtime += 60
+ for t in started:
+ t.join(max(endtime - time.time(), 0.01))
+ started = [t for t in started if t.isAlive()]
+ if not started:
+ break
+ if verbose:
+ print('Unable to join %d threads during a period of '
+ '%d minutes' % (len(started), timeout))
+ started = [t for t in started if t.isAlive()]
+ if started:
+ raise AssertionError('Unable to join %d threads' % len(started))
+
+@contextlib.contextmanager
+def swap_attr(obj, attr, new_val):
+ """Temporary swap out an attribute with a new object.
+
+ Usage:
+ with swap_attr(obj, "attr", 5):
+ ...
+
+ This will set obj.attr to 5 for the duration of the with: block,
+ restoring the old value at the end of the block. If `attr` doesn't
+ exist on `obj`, it will be created and then deleted at the end of the
+ block.
+
+ The old value (or None if it doesn't exist) will be assigned to the
+ target of the "as" clause, if there is one.
+ """
+ if hasattr(obj, attr):
+ real_val = getattr(obj, attr)
+ setattr(obj, attr, new_val)
+ try:
+ yield real_val
+ finally:
+ setattr(obj, attr, real_val)
+ else:
+ setattr(obj, attr, new_val)
+ try:
+ yield
+ finally:
+ if hasattr(obj, attr):
+ delattr(obj, attr)
+
+@contextlib.contextmanager
+def swap_item(obj, item, new_val):
+ """Temporary swap out an item with a new object.
+
+ Usage:
+ with swap_item(obj, "item", 5):
+ ...
+
+ This will set obj["item"] to 5 for the duration of the with: block,
+ restoring the old value at the end of the block. If `item` doesn't
+ exist on `obj`, it will be created and then deleted at the end of the
+ block.
+
+ The old value (or None if it doesn't exist) will be assigned to the
+ target of the "as" clause, if there is one.
+ """
+ if item in obj:
+ real_val = obj[item]
+ obj[item] = new_val
+ try:
+ yield real_val
+ finally:
+ obj[item] = real_val
+ else:
+ obj[item] = new_val
+ try:
+ yield
+ finally:
+ if item in obj:
+ del obj[item]
+
+def py3k_bytes(b):
+ """Emulate the py3k bytes() constructor.
+
+ NOTE: This is only a best effort function.
+ """
+ try:
+ # memoryview?
+ return b.tobytes()
+ except AttributeError:
+ try:
+ # iterable of ints?
+ return b"".join(chr(x) for x in b)
+ except TypeError:
+ return bytes(b)
+
+def args_from_interpreter_flags():
+ """Return a list of command-line arguments reproducing the current
+ settings in sys.flags."""
+ import subprocess
+ return subprocess._args_from_interpreter_flags()
+
+def strip_python_stderr(stderr):
+ """Strip the stderr of a Python process from potential debug output
+ emitted by the interpreter.
+
+ This will typically be run on the result of the communicate() method
+ of a subprocess.Popen object.
+ """
+ stderr = re.sub(br"\[\d+ refs\]\r?\n?$", b"", stderr).strip()
+ return stderr
+
+
+def check_free_after_iterating(test, iter, cls, args=()):
+ class A(cls):
+ def __del__(self):
+ done[0] = True
+ try:
+ next(it)
+ except StopIteration:
+ pass
+
+ done = [False]
+ it = iter(A(*args))
+ # Issue 26494: Shouldn't crash
+ test.assertRaises(StopIteration, next, it)
+ # The sequence should be deallocated just after the end of iterating
+ gc_collect()
+ test.assertTrue(done[0])
+
+@contextlib.contextmanager
+def disable_gc():
+ have_gc = gc.isenabled()
+ gc.disable()
+ try:
+ yield
+ finally:
+ if have_gc:
+ gc.enable()
+
+
+def python_is_optimized():
+ """Find if Python was built with optimizations."""
+ cflags = sysconfig.get_config_var('PY_CFLAGS') or ''
+ final_opt = ""
+ for opt in cflags.split():
+ if opt.startswith('-O'):
+ final_opt = opt
+ return final_opt not in ('', '-O0', '-Og')
+
+
+class SuppressCrashReport:
+ """Try to prevent a crash report from popping up.
+
+ On Windows, don't display the Windows Error Reporting dialog. On UNIX,
+ disable the creation of coredump file.
+ """
+ old_value = None
+ old_modes = None
+
+ def __enter__(self):
+ """On Windows, disable Windows Error Reporting dialogs using
+ SetErrorMode.
+
+ On UNIX, try to save the previous core file size limit, then set
+ soft limit to 0.
+ """
+ if sys.platform.startswith('win'):
+ # see http://msdn.microsoft.com/en-us/library/windows/desktop/ms680621.aspx
+ # GetErrorMode is not available on Windows XP and Windows Server 2003,
+ # but SetErrorMode returns the previous value, so we can use that
+ import ctypes
+ self._k32 = ctypes.windll.kernel32
+ SEM_NOGPFAULTERRORBOX = 0x02
+ self.old_value = self._k32.SetErrorMode(SEM_NOGPFAULTERRORBOX)
+ self._k32.SetErrorMode(self.old_value | SEM_NOGPFAULTERRORBOX)
+
+ # Suppress assert dialogs in debug builds
+ # (see http://bugs.python.org/issue23314)
+ try:
+ import _testcapi
+ _testcapi.CrtSetReportMode
+ except (AttributeError, ImportError):
+ # no _testcapi or a release build
+ pass
+ else:
+ self.old_modes = {}
+ for report_type in [_testcapi.CRT_WARN,
+ _testcapi.CRT_ERROR,
+ _testcapi.CRT_ASSERT]:
+ old_mode = _testcapi.CrtSetReportMode(report_type,
+ _testcapi.CRTDBG_MODE_FILE)
+ old_file = _testcapi.CrtSetReportFile(report_type,
+ _testcapi.CRTDBG_FILE_STDERR)
+ self.old_modes[report_type] = old_mode, old_file
+
+ else:
+ try:
+ import resource
+ except ImportError:
+ resource = None
+
+ if resource is not None:
+ try:
+ self.old_value = resource.getrlimit(resource.RLIMIT_CORE)
+ resource.setrlimit(resource.RLIMIT_CORE,
+ (0, self.old_value[1]))
+ except (ValueError, OSError):
+ pass
+
+ if sys.platform == 'darwin':
+ # Check if the 'Crash Reporter' on OSX was configured
+ # in 'Developer' mode and warn that it will get triggered
+ # when it is.
+ #
+ # This assumes that this context manager is used in tests
+ # that might trigger the next manager.
+ import subprocess
+ cmd = ['/usr/bin/defaults', 'read',
+ 'com.apple.CrashReporter', 'DialogType']
+ proc = subprocess.Popen(cmd,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ stdout = proc.communicate()[0]
+ if stdout.strip() == b'developer':
+ sys.stdout.write("this test triggers the Crash Reporter, "
+ "that is intentional")
+ sys.stdout.flush()
+
+ return self
+
+ def __exit__(self, *ignore_exc):
+ """Restore Windows ErrorMode or core file behavior to initial value."""
+ if self.old_value is None:
+ return
+
+ if sys.platform.startswith('win'):
+ self._k32.SetErrorMode(self.old_value)
+
+ if self.old_modes:
+ import _testcapi
+ for report_type, (old_mode, old_file) in self.old_modes.items():
+ _testcapi.CrtSetReportMode(report_type, old_mode)
+ _testcapi.CrtSetReportFile(report_type, old_file)
+ else:
+ import resource
+ try:
+ resource.setrlimit(resource.RLIMIT_CORE, self.old_value)
+ except (ValueError, OSError):
+ pass
+
+
+def _crash_python():
+ """Deliberate crash of Python.
+
+ Python can be killed by a segmentation fault (SIGSEGV), a bus error
+ (SIGBUS), or a different error depending on the platform.
+
+ Use SuppressCrashReport() to prevent a crash report from popping up.
+ """
+
+ import ctypes
+ with SuppressCrashReport():
+ ctypes.string_at(0)
--- /dev/null
+# Common utility functions used by various script execution tests
+# e.g. test_cmd_line, test_cmd_line_script and test_runpy
+
+import sys
+import os
+import re
+import os.path
+import tempfile
+import subprocess
+import py_compile
+import contextlib
+import shutil
+try:
+ import zipfile
+except ImportError:
+ # If Python is build without Unicode support, importing _io will
+ # fail, which, in turn, means that zipfile cannot be imported
+ # Most of this module can then still be used.
+ pass
+
+from test.support import strip_python_stderr
+
+# Executing the interpreter in a subprocess
+def _assert_python(expected_success, *args, **env_vars):
+ cmd_line = [sys.executable]
+ if not env_vars:
+ cmd_line.append('-E')
+ cmd_line.extend(args)
+ # Need to preserve the original environment, for in-place testing of
+ # shared library builds.
+ env = os.environ.copy()
+ env.update(env_vars)
+ p = subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+ env=env)
+ try:
+ out, err = p.communicate()
+ finally:
+ subprocess._cleanup()
+ p.stdout.close()
+ p.stderr.close()
+ rc = p.returncode
+ err = strip_python_stderr(err)
+ if (rc and expected_success) or (not rc and not expected_success):
+ raise AssertionError(
+ "Process return code is %d, "
+ "stderr follows:\n%s" % (rc, err.decode('ascii', 'ignore')))
+ return rc, out, err
+
+def assert_python_ok(*args, **env_vars):
+ """
+ Assert that running the interpreter with `args` and optional environment
+ variables `env_vars` is ok and return a (return code, stdout, stderr) tuple.
+ """
+ return _assert_python(True, *args, **env_vars)
+
+def assert_python_failure(*args, **env_vars):
+ """
+ Assert that running the interpreter with `args` and optional environment
+ variables `env_vars` fails and return a (return code, stdout, stderr) tuple.
+ """
+ return _assert_python(False, *args, **env_vars)
+
+def python_exit_code(*args):
+ cmd_line = [sys.executable, '-E']
+ cmd_line.extend(args)
+ with open(os.devnull, 'w') as devnull:
+ return subprocess.call(cmd_line, stdout=devnull,
+ stderr=subprocess.STDOUT)
+
+def spawn_python(*args, **kwargs):
+ cmd_line = [sys.executable, '-E']
+ cmd_line.extend(args)
+ return subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+ **kwargs)
+
+def kill_python(p):
+ p.stdin.close()
+ data = p.stdout.read()
+ p.stdout.close()
+ # try to cleanup the child so we don't appear to leak when running
+ # with regrtest -R.
+ p.wait()
+ subprocess._cleanup()
+ return data
+
+def run_python(*args, **kwargs):
+ if __debug__:
+ p = spawn_python(*args, **kwargs)
+ else:
+ p = spawn_python('-O', *args, **kwargs)
+ stdout_data = kill_python(p)
+ return p.wait(), stdout_data
+
+# Script creation utilities
+@contextlib.contextmanager
+def temp_dir():
+ dirname = tempfile.mkdtemp()
+ dirname = os.path.realpath(dirname)
+ try:
+ yield dirname
+ finally:
+ shutil.rmtree(dirname)
+
+def make_script(script_dir, script_basename, source):
+ script_filename = script_basename+os.extsep+'py'
+ script_name = os.path.join(script_dir, script_filename)
+ script_file = open(script_name, 'w')
+ script_file.write(source)
+ script_file.close()
+ return script_name
+
+def compile_script(script_name):
+ py_compile.compile(script_name, doraise=True)
+ if __debug__:
+ compiled_name = script_name + 'c'
+ else:
+ compiled_name = script_name + 'o'
+ return compiled_name
+
+def make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None):
+ zip_filename = zip_basename+os.extsep+'zip'
+ zip_name = os.path.join(zip_dir, zip_filename)
+ zip_file = zipfile.ZipFile(zip_name, 'w')
+ if name_in_zip is None:
+ name_in_zip = os.path.basename(script_name)
+ zip_file.write(script_name, name_in_zip)
+ zip_file.close()
+ #if test.test_support.verbose:
+ # zip_file = zipfile.ZipFile(zip_name, 'r')
+ # print 'Contents of %r:' % zip_name
+ # zip_file.printdir()
+ # zip_file.close()
+ return zip_name, os.path.join(zip_name, name_in_zip)
+
+def make_pkg(pkg_dir, init_source=''):
+ os.mkdir(pkg_dir)
+ make_script(pkg_dir, '__init__', init_source)
+
+def make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
+ source, depth=1, compiled=False):
+ unlink = []
+ init_name = make_script(zip_dir, '__init__', '')
+ unlink.append(init_name)
+ init_basename = os.path.basename(init_name)
+ script_name = make_script(zip_dir, script_basename, source)
+ unlink.append(script_name)
+ if compiled:
+ init_name = compile_script(init_name)
+ script_name = compile_script(script_name)
+ unlink.extend((init_name, script_name))
+ pkg_names = [os.sep.join([pkg_name]*i) for i in range(1, depth+1)]
+ script_name_in_zip = os.path.join(pkg_names[-1], os.path.basename(script_name))
+ zip_filename = zip_basename+os.extsep+'zip'
+ zip_name = os.path.join(zip_dir, zip_filename)
+ zip_file = zipfile.ZipFile(zip_name, 'w')
+ for name in pkg_names:
+ init_name_in_zip = os.path.join(name, init_basename)
+ zip_file.write(init_name, init_name_in_zip)
+ zip_file.write(script_name, script_name_in_zip)
+ zip_file.close()
+ for name in unlink:
+ os.unlink(name)
+ #if test.test_support.verbose:
+ # zip_file = zipfile.ZipFile(zip_name, 'r')
+ # print 'Contents of %r:' % zip_name
+ # zip_file.printdir()
+ # zip_file.close()
+ return zip_name, os.path.join(zip_name, script_name_in_zip)
#This file contains chunk types aifc doesn't recognize.
self.f = aifc.open(findfile('Sine-1000Hz-300ms.aif'))
+ def test_close_opened_files_on_error(self):
+ non_aifc_file = findfile('pluck-pcm8.wav', subdir='audiodata')
+
+ class Aifc(aifc.Aifc_read):
+ def __init__(self):
+ pass
+
+ a = Aifc()
+ with self.assertRaises(aifc.Error):
+ aifc.Aifc_read.__init__(a, non_aifc_file)
+ self.assertTrue(a._file.closed)
+
def test_write_markers_values(self):
fout = aifc.open(io.BytesIO(), 'wb')
self.assertEqual(fout.getmarkers(), None)
asyncore.loop(timeout=0.01, use_poll=True, count=2)
self.assertEqual(b"".join(data), self.d)
+ def test_close_twice(self):
+ fd = os.open(TESTFN, os.O_RDONLY)
+ f = asyncore.file_wrapper(fd)
+ os.close(fd)
+
+ os.close(f.fd) # file_wrapper dupped fd
+ with self.assertRaises(OSError):
+ f.close()
+
+ self.assertEqual(f.fd, -1)
+ # calling close twice should not fail
+ f.close()
+
class BaseTestHandler(asyncore.dispatcher):
# Note: this might fail on some platforms as OOB data is
# tenuously supported and rarely used.
+ if sys.platform == "darwin" and self.use_poll:
+ self.skipTest("poll may fail on macOS; see issue #28087")
+
class TestClient(BaseClient):
def handle_expt(self):
self.flag = True
from imp import reload
from test import test_support
+
+def exit():
+ raise SystemExit
+
+
class TestCase(unittest.TestCase):
def setUp(self):
- s = StringIO.StringIO()
self.save_stdout = sys.stdout
self.save_stderr = sys.stderr
- sys.stdout = sys.stderr = self.subst_io = s
+ self.stream = StringIO.StringIO()
+ sys.stdout = sys.stderr = self.subst_io = self.stream
self.save_handlers = atexit._exithandlers
atexit._exithandlers = []
atexit.register(self.raise2)
self.assertRaises(TypeError, atexit._run_exitfuncs)
+ def test_exit(self):
+ # be sure a SystemExit is handled properly
+ atexit.register(exit)
+
+ self.assertRaises(SystemExit, atexit._run_exitfuncs)
+ self.assertEqual(self.stream.getvalue(), '')
+
### helpers
def h1(self):
print "h1"
+from __future__ import absolute_import
import sys
import unittest
from test import test_support
def test_first_while_deleting(self):
# Test for bug 1725856
- self.assertTrue(len(self.d) >= 2, "test requires >=2 items")
+ self.assertGreaterEqual(len(self.d), 2, "test requires >=2 items")
for _ in self.d:
key = self.f.first()[0]
del self.f[key]
def test_last_while_deleting(self):
# Test for bug 1725856's evil twin
- self.assertTrue(len(self.d) >= 2, "test requires >=2 items")
+ self.assertGreaterEqual(len(self.d), 2, "test requires >=2 items")
for _ in self.d:
key = self.f.last()[0]
del self.f[key]
def test_has_key(self):
for k in self.d:
self.assertTrue(self.f.has_key(k))
- self.assertTrue(not self.f.has_key('not here'))
+ self.assertFalse(self.f.has_key('not here'))
def test_clear(self):
self.f.clear()
self.assertEqual(nc1, nc2)
self.assertEqual(nc1, nc4)
- self.assertTrue(nc3 == nc1+1)
+ self.assertEqual(nc3, nc1+1)
def test_popitem(self):
k, v = self.f.popitem()
verbose = False
sys.argv.remove('silent')
+# bpo-30778: test_bsddb3 crashs randomly on Windows XP
+if hasattr(sys, 'getwindowsversion') and sys.getwindowsversion()[:2] < (6, 0):
+ raise unittest.SkipTest("bpo-30778: skip tests on Windows XP")
+
class TimingCheck(unittest.TestCase):
import pickle
import sys
import unittest
+import warnings
from test import test_support
class BufferTests(unittest.TestCase):
def test_copy(self):
buf = buffer(b'abc')
- with self.assertRaises(TypeError):
+ with self.assertRaises(TypeError), warnings.catch_warnings():
+ warnings.filterwarnings('ignore', ".*buffer", DeprecationWarning)
copy.copy(buf)
- # See issue #22995
- ## def test_pickle(self):
- ## buf = buffer(b'abc')
- ## for proto in range(pickle.HIGHEST_PROTOCOL + 1):
- ## with self.assertRaises(TypeError):
- ## pickle.dumps(buf, proto)
+ @test_support.cpython_only
+ def test_pickle(self):
+ buf = buffer(b'abc')
+ for proto in range(2):
+ with self.assertRaises(TypeError):
+ pickle.dumps(buf, proto)
+ with test_support.check_py3k_warnings(
+ (".*buffer", DeprecationWarning)):
+ pickle.dumps(buf, 2)
def test_main():
self.assertRaises(TypeError, type(c).__getattribute__, c, [])
self.assertRaises(TypeError, type(c).__setattr__, c, [], [])
+ def testSetattrWrapperNameIntern(self):
+ # Issue #25794: __setattr__ should intern the attribute name
+ class A(object):
+ pass
+
+ def add(self, other):
+ return 'summa'
+
+ name = ''.join(list('__add__')) # shouldn't be optimized
+ self.assertIsNot(name, '__add__') # not interned
+ type.__setattr__(A, name, add)
+ self.assertEqual(A() + 1, 'summa')
+
+ name2 = ''.join(list('__add__'))
+ self.assertIsNot(name2, '__add__')
+ self.assertIsNot(name2, name)
+ type.__delattr__(A, name2)
+ with self.assertRaises(TypeError):
+ A() + 1
+
+ @test_support.requires_unicode
+ def testSetattrWrapperNameUnicode(self):
+ # Issue #25794: __setattr__ should intern the attribute name
+ class A(object):
+ pass
+
+ def add(self, other):
+ return 'summa'
+
+ type.__setattr__(A, u'__add__', add)
+ self.assertEqual(A() + 1, 'summa')
+
+ type.__delattr__(A, u'__add__')
+ with self.assertRaises(TypeError):
+ A() + 1
+
+ def testSetattrNonStringName(self):
+ class A(object):
+ pass
+
+ with self.assertRaises(TypeError):
+ type.__setattr__(A, bytearray(b'x'), None)
+
def test_main():
with test_support.check_py3k_warnings(
(".+__(get|set|del)slice__ has been removed", DeprecationWarning),
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class Test_GB2312(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_GB2312(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'gb2312'
- tstring = test_multibytecodec_support.load_teststring('gb2312')
+ tstring = multibytecodec_support.load_teststring('gb2312')
codectests = (
# invalid bytes
("abc\x81\x81\xc1\xc4", "strict", None),
("\xc1\x64", "strict", None),
)
-class Test_GBK(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_GBK(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'gbk'
- tstring = test_multibytecodec_support.load_teststring('gbk')
+ tstring = multibytecodec_support.load_teststring('gbk')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
(u"\u30fb", "strict", None),
)
-class Test_GB18030(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_GB18030(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'gb18030'
- tstring = test_multibytecodec_support.load_teststring('gb18030')
+ tstring = multibytecodec_support.load_teststring('gb18030')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
("abc\x80\x80\xc1\xc4", "ignore", u"abc\u804a"),
("abc\x84\x39\x84\x39\xc1\xc4", "replace", u"abc\ufffd\u804a"),
(u"\u30fb", "strict", "\x819\xa79"),
+ # issue29990
+ ("\xff\x30\x81\x30", "strict", None),
+ ("\x81\x30\xff\x30", "strict", None),
+ ("abc\x81\x39\xff\x39\xc1\xc4", "replace", u"abc\ufffd\u804a"),
+ ("abc\xab\x36\xff\x30def", "replace", u'abc\ufffddef'),
+ ("abc\xbf\x38\xff\x32\xc1\xc4", "ignore", u"abc\u804a"),
)
has_iso10646 = True
-class Test_HZ(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_HZ(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'hz'
- tstring = test_multibytecodec_support.load_teststring('hz')
+ tstring = multibytecodec_support.load_teststring('hz')
codectests = (
# test '~\n' (3 lines)
(b'This sentence is in ASCII.\n'
(b'ab~cd', 'replace', u'ab\uFFFDd'),
(b'ab\xffcd', 'replace', u'ab\uFFFDcd'),
(b'ab~{\x81\x81\x41\x44~}cd', 'replace', u'ab\uFFFD\uFFFD\u804Acd'),
+ # issue 30003
+ (u'ab~cd', 'strict', b'ab~~cd'), # escape ~
+ (b'~{Dc~~:C~}', 'strict', None), # ~~ only in ASCII mode
+ (b'~{Dc~\n:C~}', 'strict', None), # ~\n only in ASCII mode
)
def test_main():
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class Test_Big5HKSCS(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_Big5HKSCS(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'big5hkscs'
- tstring = test_multibytecodec_support.load_teststring('big5hkscs')
+ tstring = multibytecodec_support.load_teststring('big5hkscs')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
# Codec encoding tests for ISO 2022 encodings.
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
COMMON_CODEC_TESTS = (
(b'ab\x1B$def', 'replace', u'ab\uFFFD'),
)
-class Test_ISO2022_JP(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_ISO2022_JP(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'iso2022_jp'
- tstring = test_multibytecodec_support.load_teststring('iso2022_jp')
+ tstring = multibytecodec_support.load_teststring('iso2022_jp')
codectests = COMMON_CODEC_TESTS + (
(b'ab\x1BNdef', 'replace', u'ab\x1BNdef'),
)
-class Test_ISO2022_JP2(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_ISO2022_JP2(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'iso2022_jp_2'
- tstring = test_multibytecodec_support.load_teststring('iso2022_jp')
+ tstring = multibytecodec_support.load_teststring('iso2022_jp')
codectests = COMMON_CODEC_TESTS + (
(b'ab\x1BNdef', 'replace', u'abdef'),
)
-class Test_ISO2022_KR(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_ISO2022_KR(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'iso2022_kr'
- tstring = test_multibytecodec_support.load_teststring('iso2022_kr')
+ tstring = multibytecodec_support.load_teststring('iso2022_kr')
codectests = COMMON_CODEC_TESTS + (
(b'ab\x1BNdef', 'replace', u'ab\x1BNdef'),
)
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class Test_CP932(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_CP932(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'cp932'
- tstring = test_multibytecodec_support.load_teststring('shift_jis')
+ tstring = multibytecodec_support.load_teststring('shift_jis')
codectests = (
# invalid bytes
("abc\x81\x00\x81\x00\x82\x84", "strict", None),
("\x81\x5f\x81\x61\x81\x7c", "replace", u"\uff3c\u2225\uff0d"),
)
-class Test_EUC_JISX0213(test_multibytecodec_support.TestBase,
+class Test_EUC_JISX0213(multibytecodec_support.TestBase,
unittest.TestCase):
encoding = 'euc_jisx0213'
- tstring = test_multibytecodec_support.load_teststring('euc_jisx0213')
+ tstring = multibytecodec_support.load_teststring('euc_jisx0213')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
("\xc1\x64", "strict", None),
)
-class Test_EUC_JP_COMPAT(test_multibytecodec_support.TestBase,
+class Test_EUC_JP_COMPAT(multibytecodec_support.TestBase,
unittest.TestCase):
encoding = 'euc_jp'
- tstring = test_multibytecodec_support.load_teststring('euc_jp')
+ tstring = multibytecodec_support.load_teststring('euc_jp')
codectests = eucjp_commontests + (
("\xa1\xc0\\", "strict", u"\uff3c\\"),
(u"\xa5", "strict", "\x5c"),
("abc\x80\x80\x82\x84def", "ignore", u"abc\uff44def"),
)
-class Test_SJIS_COMPAT(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_SJIS_COMPAT(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'shift_jis'
- tstring = test_multibytecodec_support.load_teststring('shift_jis')
+ tstring = multibytecodec_support.load_teststring('shift_jis')
codectests = shiftjis_commonenctests + (
("\\\x7e", "strict", u"\\\x7e"),
("\x81\x5f\x81\x61\x81\x7c", "strict", u"\uff3c\u2016\u2212"),
)
-class Test_SJISX0213(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_SJISX0213(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'shift_jisx0213'
- tstring = test_multibytecodec_support.load_teststring('shift_jisx0213')
+ tstring = multibytecodec_support.load_teststring('shift_jisx0213')
codectests = (
# invalid bytes
("abc\x80\x80\x82\x84", "strict", None),
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class Test_CP949(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_CP949(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'cp949'
- tstring = test_multibytecodec_support.load_teststring('cp949')
+ tstring = multibytecodec_support.load_teststring('cp949')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
("abc\x80\x80\xc1\xc4", "ignore", u"abc\uc894"),
)
-class Test_EUCKR(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_EUCKR(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'euc_kr'
- tstring = test_multibytecodec_support.load_teststring('euc_kr')
+ tstring = multibytecodec_support.load_teststring('euc_kr')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
("\xc1\xc4", "strict", u"\uc894"),
)
-class Test_JOHAB(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_JOHAB(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'johab'
- tstring = test_multibytecodec_support.load_teststring('johab')
+ tstring = multibytecodec_support.load_teststring('johab')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class Test_Big5(test_multibytecodec_support.TestBase, unittest.TestCase):
+class Test_Big5(multibytecodec_support.TestBase, unittest.TestCase):
encoding = 'big5'
- tstring = test_multibytecodec_support.load_teststring('big5')
+ tstring = multibytecodec_support.load_teststring('big5')
codectests = (
# invalid bytes
("abc\x80\x80\xc1\xc4", "strict", None),
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class TestGB2312Map(test_multibytecodec_support.TestBase_Mapping,
+class TestGB2312Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'gb2312'
mapfileurl = 'http://www.pythontest.net/unicode/EUC-CN.TXT'
-class TestGBKMap(test_multibytecodec_support.TestBase_Mapping,
+class TestGBKMap(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'gbk'
mapfileurl = 'http://www.pythontest.net/unicode/CP936.TXT'
-class TestGB18030Map(test_multibytecodec_support.TestBase_Mapping,
+class TestGB18030Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'gb18030'
mapfileurl = 'http://www.pythontest.net/unicode/gb-18030-2000.xml'
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class TestBig5HKSCSMap(test_multibytecodec_support.TestBase_Mapping,
+class TestBig5HKSCSMap(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'big5hkscs'
mapfileurl = 'http://www.pythontest.net/unicode/BIG5HKSCS-2004.TXT'
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class TestCP932Map(test_multibytecodec_support.TestBase_Mapping,
+class TestCP932Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'cp932'
mapfileurl = 'http://www.pythontest.net/unicode/CP932.TXT'
supmaps.append((chr(i), unichr(i+0xfec0)))
-class TestEUCJPCOMPATMap(test_multibytecodec_support.TestBase_Mapping,
+class TestEUCJPCOMPATMap(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'euc_jp'
mapfilename = 'EUC-JP.TXT'
mapfileurl = 'http://www.pythontest.net/unicode/EUC-JP.TXT'
-class TestSJISCOMPATMap(test_multibytecodec_support.TestBase_Mapping,
+class TestSJISCOMPATMap(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'shift_jis'
mapfilename = 'SHIFTJIS.TXT'
('\x81_', u'\\'),
]
-class TestEUCJISX0213Map(test_multibytecodec_support.TestBase_Mapping,
+class TestEUCJISX0213Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'euc_jisx0213'
mapfilename = 'EUC-JISX0213.TXT'
mapfileurl = 'http://www.pythontest.net/unicode/EUC-JISX0213.TXT'
-class TestSJISX0213Map(test_multibytecodec_support.TestBase_Mapping,
+class TestSJISX0213Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'shift_jisx0213'
mapfilename = 'SHIFT_JISX0213.TXT'
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class TestCP949Map(test_multibytecodec_support.TestBase_Mapping,
+class TestCP949Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'cp949'
mapfileurl = 'http://www.pythontest.net/unicode/CP949.TXT'
-class TestEUCKRMap(test_multibytecodec_support.TestBase_Mapping,
+class TestEUCKRMap(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'euc_kr'
mapfileurl = 'http://www.pythontest.net/unicode/EUC-KR.TXT'
pass_dectest = [('\xa4\xd4', u'\u3164')]
-class TestJOHABMap(test_multibytecodec_support.TestBase_Mapping,
+class TestJOHABMap(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'johab'
mapfileurl = 'http://www.pythontest.net/unicode/JOHAB.TXT'
#
from test import test_support
-from test import test_multibytecodec_support
+from test import multibytecodec_support
import unittest
-class TestBIG5Map(test_multibytecodec_support.TestBase_Mapping,
+class TestBIG5Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'big5'
mapfileurl = 'http://www.pythontest.net/unicode/BIG5.TXT'
-class TestCP950Map(test_multibytecodec_support.TestBase_Mapping,
+class TestCP950Map(multibytecodec_support.TestBase_Mapping,
unittest.TestCase):
encoding = 'cp950'
mapfileurl = 'http://www.pythontest.net/unicode/CP950.TXT'
# warning: if 'os' or 'test_support' are moved in some other dir,
# they should be changed here.
libdir = os.path.dirname(os.__file__)
- testdir = os.path.dirname(test.test_support.__file__)
+ testdir = test.test_support.TEST_HOME_DIR
for dir in [testdir]:
for basename in "test_os.py",:
NAN = float("nan")
# These tests ensure that complex math does the right thing
+# decorator for skipping tests on non-IEEE 754 platforms
+have_getformat = hasattr(float, "__getformat__")
+requires_IEEE_754 = unittest.skipUnless(have_getformat and
+ float.__getformat__("double").startswith("IEEE"),
+ "test requires IEEE 754 doubles")
+
+
class ComplexTest(unittest.TestCase):
def assertAlmostEqual(self, a, b):
b = 'y %s x' % op
self.assertTrue(type(eval(a)) is type(eval(b)) is xcomplex)
+ @requires_IEEE_754
+ def test_constructor_special_numbers(self):
+ class complex2(complex):
+ pass
+ for x in 0.0, -0.0, INF, -INF, NAN:
+ for y in 0.0, -0.0, INF, -INF, NAN:
+ z = complex(x, y)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+ z = complex2(x, y)
+ self.assertIs(type(z), complex2)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+ z = complex(complex2(x, y))
+ self.assertIs(type(z), complex)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+ z = complex2(complex(x, y))
+ self.assertIs(type(z), complex2)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+
def test_hash(self):
for x in xrange(-30, 30):
self.assertEqual(hash(x), hash(complex(x, 0)))
class WithPrivate(object):
__slots__ = ('__spam',)
+class _WithLeadingUnderscoreAndPrivate(object):
+ __slots__ = ('__spam',)
+
+class ___(object):
+ __slots__ = ('__spam',)
+
class WithSingleString(object):
__slots__ = 'spam'
self.assertEqual(copy_reg._slotnames(WithWeakref), [])
expected = ['_WithPrivate__spam']
self.assertEqual(copy_reg._slotnames(WithPrivate), expected)
+ expected = ['_WithLeadingUnderscoreAndPrivate__spam']
+ self.assertEqual(copy_reg._slotnames(_WithLeadingUnderscoreAndPrivate),
+ expected)
+ self.assertEqual(copy_reg._slotnames(___), ['__spam'])
self.assertEqual(copy_reg._slotnames(WithSingleString), ['spam'])
expected = ['eggs', 'spam']
expected.sort()
curses = import_module('curses')
import_module('curses.panel')
import_module('curses.ascii')
+import_module('curses.textpad')
def requires_curses_func(name):
return unittest.skipUnless(hasattr(curses, name),
# Functions only available on a few platforms
def test_colors_funcs(self):
if not curses.has_colors():
- self.skip('requires colors support')
+ self.skipTest('requires colors support')
curses.start_color()
curses.init_pair(2, 1,1)
curses.color_content(1)
def test_getmouse(self):
(availmask, oldmask) = curses.mousemask(curses.BUTTON1_PRESSED)
if availmask == 0:
- self.skip('mouse stuff not available')
+ self.skipTest('mouse stuff not available')
curses.mouseinterval(10)
# just verify these don't cause errors
curses.ungetmouse(0, 0, 0, 0, curses.BUTTON1_PRESSED)
b = curses.tparm(curses.tigetstr("cup"), 5, 3)
self.assertIs(type(b), bytes)
+ def test_issue13051(self):
+ stdscr = self.stdscr
+ box = curses.textpad.Textbox(stdscr, insert_mode=True)
+ lines, cols = stdscr.getmaxyx()
+ stdscr.resize(lines-2, cols-2)
+ # this may cause infinite recursion, leading to a RuntimeError
+ box._insert_printable_char('a')
+
class TestAscii(unittest.TestCase):
check(curses.ascii.ispunct, c in string.punctuation)
check(curses.ascii.isxdigit, c in string.hexdigits)
+ for i in (-2, -1, 256, sys.maxunicode, sys.maxunicode+1):
+ self.assertFalse(curses.ascii.isalnum(i))
+ self.assertFalse(curses.ascii.isalpha(i))
+ self.assertFalse(curses.ascii.isdigit(i))
+ self.assertFalse(curses.ascii.islower(i))
+ self.assertFalse(curses.ascii.isspace(i))
+ self.assertFalse(curses.ascii.isupper(i))
+
+ self.assertFalse(curses.ascii.isascii(i))
+ self.assertFalse(curses.ascii.isctrl(i))
+ self.assertFalse(curses.ascii.iscntrl(i))
+ self.assertFalse(curses.ascii.isblank(i))
+ self.assertFalse(curses.ascii.isgraph(i))
+ self.assertFalse(curses.ascii.isprint(i))
+ self.assertFalse(curses.ascii.ispunct(i))
+ self.assertFalse(curses.ascii.isxdigit(i))
+
+ self.assertFalse(curses.ascii.ismeta(-1))
+
def test_ascii(self):
ascii = curses.ascii.ascii
self.assertEqual(ascii('\xc1'), 'A')
import __builtin__
+import copy
import gc
+import pickle
import sys
import types
import unittest
+import warnings
import weakref
from copy import deepcopy
from test import test_support
+def func(*args):
+ return args
+
+
class OperatorsTest(unittest.TestCase):
def __init__(self, *args, **kwargs):
else:
self.fail("classmethod shouldn't accept keyword args")
+ @test_support.cpython_only
+ def test_classmethod_copy_pickle(self):
+ cm = classmethod(func)
+ with test_support.check_py3k_warnings(
+ (".*classmethod", DeprecationWarning)):
+ copy.copy(cm)
+ with test_support.check_py3k_warnings(
+ (".*classmethod", DeprecationWarning)):
+ copy.deepcopy(cm)
+ for proto in range(2):
+ self.assertRaises(TypeError, pickle.dumps, cm, proto)
+ with test_support.check_py3k_warnings(
+ (".*classmethod", DeprecationWarning)):
+ pickle.dumps(cm, 2)
+
@test_support.impl_detail("the module 'xxsubtype' is internal")
def test_classmethods_in_c(self):
# Testing C-based class methods...
self.assertEqual(d.foo(1), (d, 1))
self.assertEqual(D.foo(d, 1), (d, 1))
+ @test_support.cpython_only
+ def test_staticmethod_copy_pickle(self):
+ sm = staticmethod(func)
+ with test_support.check_py3k_warnings(
+ (".*staticmethod", DeprecationWarning)):
+ copy.copy(sm)
+ with test_support.check_py3k_warnings(
+ (".*staticmethod", DeprecationWarning)):
+ copy.deepcopy(sm)
+ for proto in range(2):
+ self.assertRaises(TypeError, pickle.dumps, sm, proto)
+ with test_support.check_py3k_warnings(
+ (".*staticmethod", DeprecationWarning)):
+ pickle.dumps(sm, 2)
+
@test_support.impl_detail("the module 'xxsubtype' is internal")
def test_staticmethods_in_c(self):
# Testing C-based static methods...
self.assertEqual(b.foo, 3)
self.assertEqual(b.__class__, D)
+ @unittest.expectedFailure
+ def test_bad_new(self):
+ self.assertRaises(TypeError, object.__new__)
+ self.assertRaises(TypeError, object.__new__, '')
+ self.assertRaises(TypeError, list.__new__, object)
+ self.assertRaises(TypeError, object.__new__, list)
+ class C(object):
+ __new__ = list.__new__
+ self.assertRaises(TypeError, C)
+ class C(list):
+ __new__ = object.__new__
+ self.assertRaises(TypeError, C)
+
+ def test_object_new(self):
+ class A(object):
+ pass
+ object.__new__(A)
+ self.assertRaises(TypeError, object.__new__, A, 5)
+ object.__init__(A())
+ self.assertRaises(TypeError, object.__init__, A(), 5)
+
+ class A(object):
+ def __init__(self, foo):
+ self.foo = foo
+ object.__new__(A)
+ object.__new__(A, 5)
+ object.__init__(A(3))
+ self.assertRaises(TypeError, object.__init__, A(3), 5)
+
+ class A(object):
+ def __new__(cls, foo):
+ return object.__new__(cls)
+ object.__new__(A)
+ self.assertRaises(TypeError, object.__new__, A, 5)
+ object.__init__(A(3))
+ object.__init__(A(3), 5)
+
+ class A(object):
+ def __new__(cls, foo):
+ return object.__new__(cls)
+ def __init__(self, foo):
+ self.foo = foo
+ object.__new__(A)
+ with warnings.catch_warnings(record=True) as w:
+ warnings.simplefilter('always', DeprecationWarning)
+ a = object.__new__(A, 5)
+ self.assertEqual(type(a), A)
+ self.assertEqual(len(w), 1)
+ object.__init__(A(3))
+ a = A(3)
+ with warnings.catch_warnings(record=True) as w:
+ warnings.simplefilter('always', DeprecationWarning)
+ object.__init__(a, 5)
+ self.assertEqual(a.foo, 3)
+ self.assertEqual(len(w), 1)
+
+ @unittest.expectedFailure
+ def test_restored_object_new(self):
+ class A(object):
+ def __new__(cls, *args, **kwargs):
+ raise AssertionError
+ self.assertRaises(AssertionError, A)
+ class B(A):
+ __new__ = object.__new__
+ def __init__(self, foo):
+ self.foo = foo
+ with warnings.catch_warnings():
+ warnings.simplefilter('error', DeprecationWarning)
+ b = B(3)
+ self.assertEqual(b.foo, 3)
+ self.assertEqual(b.__class__, B)
+ del B.__new__
+ self.assertRaises(AssertionError, B)
+ del A.__new__
+ with warnings.catch_warnings():
+ warnings.simplefilter('error', DeprecationWarning)
+ b = B(3)
+ self.assertEqual(b.foo, 3)
+ self.assertEqual(b.__class__, B)
+
def test_altmro(self):
# Testing mro() and overriding it...
class A(object):
else:
self.fail("expected ZeroDivisionError from bad property")
+ @test_support.cpython_only
+ def test_property_copy_pickle(self):
+ p = property(func)
+ with test_support.check_py3k_warnings(
+ (".*property", DeprecationWarning)):
+ copy.copy(p)
+ with test_support.check_py3k_warnings(
+ (".*property", DeprecationWarning)):
+ copy.deepcopy(p)
+ for proto in range(2):
+ self.assertRaises(TypeError, pickle.dumps, p, proto)
+ with test_support.check_py3k_warnings(
+ (".*property", DeprecationWarning)):
+ pickle.dumps(p, 2)
+
@unittest.skipIf(sys.flags.optimize >= 2,
"Docstrings are omitted with -O2 and above")
def test_properties_doc_attrib(self):
self.assertEqual(isinstance(d, D), True)
self.assertEqual(d.foo, 1)
+ class C(object):
+ @staticmethod
+ def __new__(*args):
+ return args
+ self.assertEqual(C(1, 2), (C, 1, 2))
+ class D(C):
+ pass
+ self.assertEqual(D(1, 2), (D, 1, 2))
+
+ class C(object):
+ @classmethod
+ def __new__(*args):
+ return args
+ self.assertEqual(C(1, 2), (C, C, 1, 2))
+ class D(C):
+ pass
+ self.assertEqual(D(1, 2), (D, D, 1, 2))
+
def test_imul_bug(self):
# Testing for __imul__ problems...
# SF bug 544647
test_support.check_free_after_iterating(self, lambda d: iter(d.viewvalues()), dict)
test_support.check_free_after_iterating(self, lambda d: iter(d.viewitems()), dict)
+ def test_equal_operator_modifying_operand(self):
+ # test fix for seg fault reported in issue 27945 part 3.
+ class X(object):
+ def __del__(self):
+ dict_b.clear()
+
+ def __eq__(self, other):
+ dict_a.clear()
+ return True
+
+ def __hash__(self):
+ return 13
+
+ dict_a = {X(): 0}
+ dict_b = {X(): X()}
+ self.assertTrue(dict_a == dict_b)
+
+ def test_fromkeys_operator_modifying_dict_operand(self):
+ # test fix for seg fault reported in issue 27945 part 4a.
+ class X(int):
+ def __hash__(self):
+ return 13
+
+ def __eq__(self, other):
+ if len(d) > 1:
+ d.clear()
+ return False
+
+ d = {} # this is required to exist so that d can be constructed!
+ d = {X(1): 1, X(2): 2}
+ try:
+ dict.fromkeys(d) # shouldn't crash
+ except RuntimeError: # implementation defined
+ pass
+
+ def test_fromkeys_operator_modifying_set_operand(self):
+ # test fix for seg fault reported in issue 27945 part 4b.
+ class X(int):
+ def __hash__(self):
+ return 13
+
+ def __eq__(self, other):
+ if len(d) > 1:
+ d.clear()
+ return False
+
+ d = {} # this is required to exist so that d can be constructed!
+ d = {X(1), X(2)}
+ try:
+ dict.fromkeys(d) # shouldn't crash
+ except RuntimeError: # implementation defined
+ pass
+
+ def test_dictitems_contains_use_after_free(self):
+ class X(object):
+ def __eq__(self, other):
+ d.clear()
+ return NotImplemented
+
+ __hash__ = object.__hash__ # silence Py3k warning
+
+ d = {0: set()}
+ try:
+ (0, X()) in d.iteritems() # shouldn't crash
+ except RuntimeError: # implementation defined
+ pass
+
+ def test_init_use_after_free(self):
+ class X(object):
+ def __hash__(self):
+ pair[:] = []
+ return 13
+
+ pair = [X(), 123]
+ dict([pair])
+
+ def test_oob_indexing_dictiter_iternextitem(self):
+ class X(int):
+ def __del__(self):
+ d.clear()
+
+ d = {i: X(i) for i in range(8)}
+
+ def iter_and_mutate():
+ for result in d.iteritems():
+ if result[0] == 2:
+ d[2] = None # free d[2] --> X(2).__del__ was called
+
+ self.assertRaises(RuntimeError, iter_and_mutate)
+
+
from test import mapping_tests
class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):
from test import test_support
import unittest
+import os
-from fnmatch import fnmatch, fnmatchcase, _MAXCACHE, _cache
-from fnmatch import fnmatch, fnmatchcase, _MAXCACHE, _cache, _purge
+from fnmatch import (fnmatch, fnmatchcase, translate, filter,
+ _MAXCACHE, _cache, _purge)
class FnmatchTestCase(unittest.TestCase):
def tearDown(self):
_purge()
- def check_match(self, filename, pattern, should_match=1, fn=fnmatch):
+ def check_match(self, filename, pattern, should_match=True, fn=fnmatch):
if should_match:
self.assertTrue(fn(filename, pattern),
"expected %r to match pattern %r"
% (filename, pattern))
else:
- self.assertTrue(not fn(filename, pattern),
+ self.assertFalse(fn(filename, pattern),
"expected %r not to match pattern %r"
% (filename, pattern))
check('abc', '*')
check('abc', 'ab[cd]')
check('abc', 'ab[!de]')
- check('abc', 'ab[de]', 0)
- check('a', '??', 0)
- check('a', 'b', 0)
+ check('abc', 'ab[de]', False)
+ check('a', '??', False)
+ check('a', 'b', False)
# these test that '\' is handled correctly in character sets;
# see SF bug #409651
check('\\', r'[\]')
check('a', r'[!\]')
- check('\\', r'[!\]', 0)
+ check('\\', r'[!\]', False)
# test that filenames with newlines in them are handled correctly.
# http://bugs.python.org/issue6665
check('\nfoo', 'foo*', False)
check('\n', '*')
+ def test_mix_unicode_str(self):
+ check = self.check_match
+ check('test', u'*')
+ check(u'test', '*')
+ check('test', u'*', fn=fnmatchcase)
+ check(u'test', '*', fn=fnmatchcase)
+ with test_support.check_warnings(("", UnicodeWarning), quiet=True):
+ check('test\xff', u'*\xff')
+ check(u'test\xff', '*\xff')
+ check('test\xff', u'*\xff', fn=fnmatchcase)
+ check(u'test\xff', '*\xff', fn=fnmatchcase)
+
def test_fnmatchcase(self):
check = self.check_match
- check('AbC', 'abc', 0, fnmatchcase)
- check('abc', 'AbC', 0, fnmatchcase)
+ check('abc', 'abc', True, fnmatchcase)
+ check('AbC', 'abc', False, fnmatchcase)
+ check('abc', 'AbC', False, fnmatchcase)
+ check('AbC', 'AbC', True, fnmatchcase)
+
+ check('usr/bin', 'usr/bin', True, fnmatchcase)
+ check('usr\\bin', 'usr/bin', False, fnmatchcase)
+ check('usr/bin', 'usr\\bin', False, fnmatchcase)
+ check('usr\\bin', 'usr\\bin', True, fnmatchcase)
def test_cache_clearing(self):
# check that caches do not grow too large
self.assertLessEqual(len(_cache), _MAXCACHE)
+ @test_support.requires_unicode
+ def test_unicode(self):
+ with test_support.check_warnings(("", UnicodeWarning), quiet=True):
+ self.check_match(u'test', u'te*')
+ self.check_match(u'test\xff', u'te*\xff')
+ self.check_match(u'test'+unichr(0x20ac), u'te*'+unichr(0x20ac))
+ self.check_match(u'foo\nbar', u'foo*')
+
+ def test_case(self):
+ ignorecase = os.path.normcase('ABC') == os.path.normcase('abc')
+ check = self.check_match
+ check('abc', 'abc')
+ check('AbC', 'abc', ignorecase)
+ check('abc', 'AbC', ignorecase)
+ check('AbC', 'AbC')
+
+ def test_sep(self):
+ normsep = os.path.normcase('\\') == os.path.normcase('/')
+ check = self.check_match
+ check('usr/bin', 'usr/bin')
+ check('usr\\bin', 'usr/bin', normsep)
+ check('usr/bin', 'usr\\bin', normsep)
+ check('usr\\bin', 'usr\\bin')
+
+
+class TranslateTestCase(unittest.TestCase):
+
+ def test_translate(self):
+ self.assertEqual(translate('*'), r'.*\Z(?ms)')
+ self.assertEqual(translate('?'), r'.\Z(?ms)')
+ self.assertEqual(translate('a?b*'), r'a.b.*\Z(?ms)')
+ self.assertEqual(translate('[abc]'), r'[abc]\Z(?ms)')
+ self.assertEqual(translate('[]]'), r'[]]\Z(?ms)')
+ self.assertEqual(translate('[!x]'), r'[^x]\Z(?ms)')
+ self.assertEqual(translate('[^x]'), r'[\^x]\Z(?ms)')
+ self.assertEqual(translate('[x'), r'\[x\Z(?ms)')
+
+
+class FilterTestCase(unittest.TestCase):
+
+ def test_filter(self):
+ self.assertEqual(filter(['Python', 'Ruby', 'Perl', 'Tcl'], 'P*'),
+ ['Python', 'Perl'])
+ self.assertEqual(filter([u'Python', u'Ruby', u'Perl', u'Tcl'], u'P*'),
+ [u'Python', u'Perl'])
+ with test_support.check_warnings(("", UnicodeWarning), quiet=True):
+ self.assertEqual(filter([u'test\xff'], u'*\xff'), [u'test\xff'])
+
+ @test_support.requires_unicode
+ def test_mix_bytes_str(self):
+ with test_support.check_warnings(("", UnicodeWarning), quiet=True):
+ self.assertEqual(filter(['test'], u'*'), ['test'])
+ self.assertEqual(filter([u'test'], '*'), [u'test'])
+ self.assertEqual(filter(['test\xff'], u'*'), ['test\xff'])
+ self.assertEqual(filter([u'test\xff'], '*'), [u'test\xff'])
+ self.assertEqual(filter(['test\xff'], u'*\xff'), ['test\xff'])
+ self.assertEqual(filter([u'test\xff'], '*\xff'), [u'test\xff'])
+
+ def test_case(self):
+ ignorecase = os.path.normcase('P') == os.path.normcase('p')
+ self.assertEqual(filter(['Test.py', 'Test.rb', 'Test.PL'], '*.p*'),
+ ['Test.py', 'Test.PL'] if ignorecase else ['Test.py'])
+ self.assertEqual(filter(['Test.py', 'Test.rb', 'Test.PL'], '*.P*'),
+ ['Test.py', 'Test.PL'] if ignorecase else ['Test.PL'])
+
+ def test_sep(self):
+ normsep = os.path.normcase('\\') == os.path.normcase('/')
+ self.assertEqual(filter(['usr/bin', 'usr', 'usr\\lib'], 'usr/*'),
+ ['usr/bin', 'usr\\lib'] if normsep else ['usr/bin'])
+ self.assertEqual(filter(['usr/bin', 'usr', 'usr\\lib'], 'usr\\*'),
+ ['usr/bin', 'usr\\lib'] if normsep else ['usr\\lib'])
+
+
def test_main():
- test_support.run_unittest(FnmatchTestCase)
+ test_support.run_unittest(FnmatchTestCase, TranslateTestCase, FilterTestCase)
if __name__ == "__main__":
threading.Thread.__init__(self)
asyncore.dispatcher.__init__(self)
self.create_socket(af, socket.SOCK_STREAM)
- self.bind(address)
- self.listen(5)
- self.active = False
- self.active_lock = threading.Lock()
- self.host, self.port = self.socket.getsockname()[:2]
- self.handler_instance = None
+ try:
+ self.bind(address)
+ self.listen(5)
+ self.active = False
+ self.active_lock = threading.Lock()
+ self.host, self.port = self.socket.getsockname()[:2]
+ self.handler_instance = None
+ except:
+ # unregister the server on bind() error,
+ # needed by TestIPv6Environment.setUpClass()
+ self.del_channel()
+ raise
def start(self):
assert not self.active
self.assertEqual(self.client.sanitize('PASS 12345'), repr('PASS *****'))
def test_exceptions(self):
+ self.assertRaises(ValueError, self.client.sendcmd, 'echo 40\r\n0')
+ self.assertRaises(ValueError, self.client.sendcmd, 'echo 40\n0')
+ self.assertRaises(ValueError, self.client.sendcmd, 'echo 40\r0')
self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 400')
self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 499')
self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 500')
# Ignore some benign messages on stderr.
ignore_patterns = (
'Function "%s" not defined.' % breakpoint,
- "warning: no loadable sections found in added symbol-file"
- " system-supplied DSO",
- "warning: Unable to find libthread_db matching"
- " inferior's thread library, thread debugging will"
- " not be available.",
- "warning: Cannot initialize thread debugging"
- " library: Debugger service failed",
- 'warning: Could not load shared library symbols for '
- 'linux-vdso.so',
- 'warning: Could not load shared library symbols for '
- 'linux-gate.so',
- 'warning: Could not load shared library symbols for '
- 'linux-vdso64.so',
'Do you need "set solib-search-path" or '
'"set sysroot"?',
- 'warning: Source file is more recent than executable.',
- # Issue #19753: missing symbols on System Z
- 'Missing separate debuginfo for ',
- 'Try: zypper install -C ',
+ # BFD: /usr/lib/debug/(...): unable to initialize decompress
+ # status for section .debug_aranges
+ 'BFD: ',
+ # ignore all warnings
+ 'warning: ',
)
for line in errlines:
+ if not line:
+ continue
if not line.startswith(ignore_patterns):
unexpected_errlines.append(line)
def test_replace_parent_in_sys_modules(self):
dir_name = os.path.abspath(TESTFN)
os.mkdir(dir_name)
- try:
- pkg_dir = os.path.join(dir_name, 'sa')
- os.mkdir(pkg_dir)
- with open(os.path.join(pkg_dir, '__init__.py'), 'w') as init_file:
- init_file.write("import v1")
- with open(os.path.join(pkg_dir, 'v1.py'), 'w') as v1_file:
- v1_file.write("import sys;"
- "sys.modules['sa'] = sys.modules[__name__];"
- "import sa")
- sys.path.insert(0, dir_name)
- # a segfault means the test failed!
- import sa
- finally:
- rmtree(dir_name)
+ self.addCleanup(rmtree, dir_name)
+ pkg_dir = os.path.join(dir_name, 'sa')
+ os.mkdir(pkg_dir)
+ with open(os.path.join(pkg_dir, '__init__.py'), 'w') as init_file:
+ init_file.write("import v1")
+ with open(os.path.join(pkg_dir, 'v1.py'), 'w') as v1_file:
+ v1_file.write("import sys;"
+ "sys.modules['sa'] = sys.modules[__name__];"
+ "import sa")
+ sys.path.insert(0, dir_name)
+ self.addCleanup(sys.path.pop, 0)
+ # a segfault means the test failed!
+ import sa
def test_fromlist_type(self):
with self.assertRaises(TypeError) as cm:
try:
os.listdir(unc)
except OSError as e:
- if e.errno in (errno.EPERM, errno.EACCES):
+ if e.errno in (errno.EPERM, errno.EACCES, errno.ENOENT):
# See issue #15338
self.skipTest("cannot access administrative share %r" % (unc,))
raise
--- /dev/null
+import imp
+import sys
+
+import unittest
+
+# Note:
+# In Python 3.x, this test case is in Lib/test/test_importlib/test_util.py
+
+class MagicNumberTests(unittest.TestCase):
+ """
+ Test release compatibility issues relating to precompiled bytecode
+ """
+ @unittest.skipUnless(
+ sys.version_info.releaselevel in ('final', 'release'),
+ 'only applies to candidate or final python release levels'
+ )
+ def test_magic_number(self):
+ """
+ Each python minor release should generally have a MAGIC_NUMBER
+ that does not change once the release reaches candidate status.
+
+ Once a release reaches candidate status, the value of the constant
+ EXPECTED_MAGIC_NUMBER in this test should be changed.
+ This test will then check that the actual MAGIC_NUMBER matches
+ the expected value for the release.
+
+ In exceptional cases, it may be required to change the MAGIC_NUMBER
+ for a maintenance release. In this case the change should be
+ discussed in python-dev. If a change is required, community
+ stakeholders such as OS package maintainers must be notified
+ in advance. Such exceptional releases will then require an
+ adjustment to this test case.
+ """
+ EXPECTED_MAGIC_NUMBER = 62211
+ raw_magic = imp.get_magic()
+ actual = (ord(raw_magic[1]) << 8) + ord(raw_magic[0])
+
+ msg = (
+ "To avoid breaking backwards compatibility with cached bytecode "
+ "files that can't be automatically regenerated by the current "
+ "user, candidate and final releases require the current "
+ "importlib.util.MAGIC_NUMBER to match the expected "
+ "magic number in this test. Set the expected "
+ "magic number in this test to the current MAGIC_NUMBER to "
+ "continue with the release.\n\n"
+ "Changing the MAGIC_NUMBER for a maintenance release "
+ "requires discussion in python-dev and notification of "
+ "community stakeholders."
+ )
+ self.assertEqual(EXPECTED_MAGIC_NUMBER, actual)#, msg)
+
+
+def test_main():
+ from test.support import run_unittest
+ run_unittest(MagicNumberTests)
+
+if __name__ == '__main__':
+ test_main()
import inspect
import linecache
import datetime
+import textwrap
from UserList import UserList
from UserDict import UserDict
-from test.test_support import run_unittest, check_py3k_warnings, have_unicode
+from test.support import run_unittest, check_py3k_warnings, have_unicode
with check_py3k_warnings(
("tuple parameter unpacking has been removed", SyntaxWarning),
'g', 'h', (3, (4, (5,))),
'(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h)')
+ with check_py3k_warnings(("tuple parameter unpacking has been removed",
+ SyntaxWarning),
+ quiet=True):
+ exec(textwrap.dedent('''
+ def spam_deref(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h):
+ def eggs():
+ return a + b + c + d + e + f + g + h
+ return eggs
+ '''))
+ self.assertArgSpecEquals(spam_deref,
+ ['a', 'b', 'c', 'd', ['e', ['f']]],
+ 'g', 'h', (3, (4, (5,))),
+ '(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h)')
+
def test_getargspec_method(self):
class A(object):
def m(self):
exec 'def sublistOfOne((foo,)): return 1'
self.assertArgSpecEquals(sublistOfOne, [['foo']])
+ exec 'def sublistOfOne((foo,)): return (lambda: foo)'
+ self.assertArgSpecEquals(sublistOfOne, [['foo']])
+
exec 'def fakeSublistOfOne((foo)): return 1'
self.assertArgSpecEquals(fakeSublistOfOne, ['foo'])
+ exec 'def sublistOfOne((foo)): return (lambda: foo)'
+ self.assertArgSpecEquals(sublistOfOne, ['foo'])
+
def _classify_test(self, newstyle):
"""Helper for testing that classify_class_attrs finds a bunch of
self.assertEqualException(f3, '1, 2')
self.assertEqualException(f3, '1, 2, a=1, b=2')
+
+class TestGetcallargsFunctionsCellVars(TestGetcallargsFunctions):
+
+ def makeCallable(self, signature):
+ """Create a function that returns its locals(), excluding the
+ autogenerated '.1', '.2', etc. tuple param names (if any)."""
+ with check_py3k_warnings(
+ ("tuple parameter unpacking has been removed", SyntaxWarning),
+ quiet=True):
+ code = """lambda %s: (
+ (lambda: a+b+c+d+d+e+f+g+h), # make parameters cell vars
+ dict(i for i in locals().items()
+ if not is_tuplename(i[0]))
+ )[1]"""
+ return eval(code % signature, {'is_tuplename' : self.is_tuplename})
+
+
class TestGetcallargsMethods(TestGetcallargsFunctions):
def setUp(self):
run_unittest(
TestDecorators, TestRetrievingSourceCode, TestOneliners, TestBuggyCases,
TestInterpreterStack, TestClassesAndFunctions, TestPredicates,
- TestGetcallargsFunctions, TestGetcallargsMethods,
- TestGetcallargsUnboundMethods)
+ TestGetcallargsFunctions, TestGetcallargsFunctionsCellVars,
+ TestGetcallargsMethods, TestGetcallargsUnboundMethods)
if __name__ == "__main__":
test_main()
with self.open(support.TESTFN, "r") as f:
self.assertRaises(TypeError, f.readline, 5.3)
+ def test_readline_nonsizeable(self):
+ # Issue #30061
+ # Crash when readline() returns an object without __len__
+ class R(self.IOBase):
+ def readline(self):
+ return None
+ self.assertRaises((TypeError, StopIteration), next, R())
+
+ def test_next_nonsizeable(self):
+ # Issue #30061
+ # Crash when next() returns an object without __len__
+ class R(self.IOBase):
+ def next(self):
+ return None
+ self.assertRaises(TypeError, R().readlines, 1)
+
def test_raw_bytes_io(self):
f = self.BytesIO()
self.write_ops(f)
self.assertRaises(ValueError, f.readinto, bytearray(1024))
self.assertRaises(ValueError, f.readline)
self.assertRaises(ValueError, f.readlines)
+ self.assertRaises(ValueError, f.readlines, 1)
self.assertRaises(ValueError, f.seek, 0)
self.assertRaises(ValueError, f.tell)
self.assertRaises(ValueError, f.truncate)
self.assertRaises(AssertionError, list, cycle(gen1()))
self.assertEqual(hist, [0,1])
+ def test_long_chain_of_empty_iterables(self):
+ # Make sure itertools.chain doesn't run into recursion limits when
+ # dealing with long chains of empty iterables. Even with a high
+ # number this would probably only fail in Py_DEBUG mode.
+ it = chain.from_iterable(() for unused in xrange(10000000))
+ with self.assertRaises(StopIteration):
+ next(it)
+
class SubclassWithKwargsTest(unittest.TestCase):
def test_keywords_in_subclass(self):
# count is not subclassable...
import linecache
import unittest
import os.path
-from test import test_support as support
+from test import support
FILENAME = linecache.__file__
EMPTY = ''
TESTS = 'inspect_fodder inspect_fodder2 mapping_tests'
TESTS = TESTS.split()
-TEST_PATH = os.path.dirname(support.__file__)
+TEST_PATH = support.TEST_HOME_DIR
MODULES = "linecache abc".split()
MODULE_PATH = os.path.dirname(FILENAME)
from __future__ import unicode_literals
from __future__ import print_function
+from __future__ import absolute_import
import unittest
from test import test_support as support
import io
import copy
import pickle
+import warnings
class AbstractMemoryTests:
class OtherTest(unittest.TestCase):
def test_copy(self):
m = memoryview(b'abc')
- with self.assertRaises(TypeError):
+ with self.assertRaises(TypeError), warnings.catch_warnings():
+ warnings.filterwarnings('ignore', ".*memoryview", DeprecationWarning)
copy.copy(m)
- # See issue #22995
- ## def test_pickle(self):
- ## m = memoryview(b'abc')
- ## for proto in range(pickle.HIGHEST_PROTOCOL + 1):
- ## with self.assertRaises(TypeError):
- ## pickle.dumps(m, proto)
+ @test_support.cpython_only
+ def test_pickle(self):
+ m = memoryview(b'abc')
+ for proto in range(2):
+ with self.assertRaises(TypeError):
+ pickle.dumps(m, proto)
+ with test_support.check_py3k_warnings(
+ (".*memoryview", DeprecationWarning)):
+ pickle.dumps(m, 2)
+
def test_main():
import random
import logging
import errno
+import weakref
import test.script_helper
from test import test_support
from StringIO import StringIO
# Testcases
#
+class DummyCallable(object):
+ def __call__(self, q, c):
+ assert isinstance(c, DummyCallable)
+ q.put(5)
+
+
class _TestProcess(BaseTestCase):
ALLOWED_TYPES = ('processes', 'threads')
p.join(5)
self.assertEqual(p.exitcode, reason)
+ def test_lose_target_ref(self):
+ c = DummyCallable()
+ wr = weakref.ref(c)
+ q = self.Queue()
+ p = self.Process(target=c, args=(q, c))
+ del c
+ p.start()
+ p.join()
+ self.assertIs(wr(), None)
+ self.assertEqual(q.get(), 5)
+
+
#
#
#
self.fail("Probable regression on import lock contention;"
" see Issue #22853")
+ def test_queue_feeder_donot_stop_onexc(self):
+ # bpo-30414: verify feeder handles exceptions correctly
+ if self.TYPE != 'processes':
+ self.skipTest('test not appropriate for {}'.format(self.TYPE))
+
+ class NotSerializable(object):
+ def __reduce__(self):
+ raise AttributeError
+ with test.support.captured_stderr():
+ q = self.Queue()
+ q.put(NotSerializable())
+ q.put(True)
+ self.assertTrue(q.get(timeout=0.1))
+
+
#
#
#
cond.release()
# check they have all woken
- time.sleep(DELTA)
+ for i in range(10):
+ try:
+ if get_value(woken) == 6:
+ break
+ except NotImplementedError:
+ break
+ time.sleep(DELTA)
self.assertReturnsIfImplemented(6, get_value, woken)
# check state is not mucked up
time.sleep(wait)
return x*x
+def identity(x):
+ return x
+
+class CountedObject(object):
+ n_instances = 0
+
+ def __new__(cls):
+ cls.n_instances += 1
+ return object.__new__(cls)
+
+ def __del__(self):
+ type(self).n_instances -= 1
+
class SayWhenError(ValueError): pass
def exception_throwing_generator(total, when):
p.close()
p.join()
+ def test_release_task_refs(self):
+ # Issue #29861: task arguments and results should not be kept
+ # alive after we are done with them.
+ objs = list(CountedObject() for i in range(10))
+ refs = list(weakref.ref(o) for o in objs)
+ self.pool.map(identity, objs)
+
+ del objs
+ time.sleep(DELTA) # let threaded cleanup code run
+ self.assertEqual(set(wr() for wr in refs), {None})
+ # With a process pool, copies of the objects are returned, check
+ # they were released too.
+ self.assertEqual(CountedObject.n_instances, 0)
+
+
def unpickleable_result():
return lambda: 42
manager.start()
p = self.Process(target=self._putter, args=(manager.address, authkey))
- p.daemon = True
p.start()
+ p.join()
queue = manager.get_queue()
self.assertEqual(queue.get(), 'hello world')
del queue
manager.shutdown()
+
manager = QueueManager(
address=addr, authkey=authkey, serializer=SERIALIZER)
manager.start()
ALLOWED_TYPES = ('processes',)
+ def setUp(self):
+ self.registry_backup = util._finalizer_registry.copy()
+ util._finalizer_registry.clear()
+
+ def tearDown(self):
+ self.assertFalse(util._finalizer_registry)
+ util._finalizer_registry.update(self.registry_backup)
+
@classmethod
def _test_finalize(cls, conn):
class Foo(object):
result = [obj for obj in iter(conn.recv, 'STOP')]
self.assertEqual(result, ['a', 'b', 'd10', 'd03', 'd02', 'd01', 'e'])
+ def test_thread_safety(self):
+ # bpo-24484: _run_finalizers() should be thread-safe
+ def cb():
+ pass
+
+ class Foo(object):
+ def __init__(self):
+ self.ref = self # create reference cycle
+ # insert finalizer at random key
+ util.Finalize(self, cb, exitpriority=random.randint(1, 100))
+
+ finish = False
+ exc = []
+
+ def run_finalizers():
+ while not finish:
+ time.sleep(random.random() * 1e-1)
+ try:
+ # A GC run will eventually happen during this,
+ # collecting stale Foo's and mutating the registry
+ util._run_finalizers()
+ except Exception as e:
+ exc.append(e)
+
+ def make_finalizers():
+ d = {}
+ while not finish:
+ try:
+ # Old Foo's get gradually replaced and later
+ # collected by the GC (because of the cyclic ref)
+ d[random.getrandbits(5)] = {Foo() for i in range(10)}
+ except Exception as e:
+ exc.append(e)
+ d.clear()
+
+ old_interval = sys.getcheckinterval()
+ old_threshold = gc.get_threshold()
+ try:
+ sys.setcheckinterval(10)
+ gc.set_threshold(5, 5, 5)
+ threads = [threading.Thread(target=run_finalizers),
+ threading.Thread(target=make_finalizers)]
+ with test_support.start_threads(threads):
+ time.sleep(4.0) # Wait a bit to trigger race condition
+ finish = True
+ if exc:
+ raise exc[0]
+ finally:
+ sys.setcheckinterval(old_interval)
+ gc.set_threshold(*old_threshold)
+ gc.collect() # Collect remaining Foo's
+
+
#
# Test that from ... import * works for each module
#
assert_python_ok('-c', code)
-class ExecvpeTests(unittest.TestCase):
+class ExecTests(unittest.TestCase):
def test_execvpe_with_bad_arglist(self):
self.assertRaises(ValueError, os.execvpe, 'notepad', [], None)
+ def test_execve_invalid_env(self):
+ args = [sys.executable, '-c', 'pass']
+
+ # null character in the enviroment variable name
+ newenv = os.environ.copy()
+ newenv["FRUIT\0VEGETABLE"] = "cabbage"
+ with self.assertRaises(TypeError):
+ os.execve(args[0], args, newenv)
+
+ # null character in the enviroment variable value
+ newenv = os.environ.copy()
+ newenv["FRUIT"] = "orange\0VEGETABLE=cabbage"
+ with self.assertRaises(TypeError):
+ os.execve(args[0], args, newenv)
+
+ # equal character in the enviroment variable name
+ newenv = os.environ.copy()
+ newenv["FRUIT=ORANGE"] = "lemon"
+ with self.assertRaises(ValueError):
+ os.execve(args[0], args, newenv)
+
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
class Win32ErrorTests(unittest.TestCase):
self._kill_with_event(signal.CTRL_BREAK_EVENT, "CTRL_BREAK_EVENT")
+class SpawnTests(unittest.TestCase):
+ def _test_invalid_env(self, spawn):
+ args = [sys.executable, '-c', 'pass']
+
+ # null character in the enviroment variable name
+ newenv = os.environ.copy()
+ newenv["FRUIT\0VEGETABLE"] = "cabbage"
+ try:
+ exitcode = spawn(os.P_WAIT, args[0], args, newenv)
+ except TypeError:
+ pass
+ else:
+ self.assertEqual(exitcode, 127)
+
+ # null character in the enviroment variable value
+ newenv = os.environ.copy()
+ newenv["FRUIT"] = "orange\0VEGETABLE=cabbage"
+ try:
+ exitcode = spawn(os.P_WAIT, args[0], args, newenv)
+ except TypeError:
+ pass
+ else:
+ self.assertEqual(exitcode, 127)
+
+ # equal character in the enviroment variable name
+ newenv = os.environ.copy()
+ newenv["FRUIT=ORANGE"] = "lemon"
+ try:
+ exitcode = spawn(os.P_WAIT, args[0], args, newenv)
+ except ValueError:
+ pass
+ else:
+ self.assertEqual(exitcode, 127)
+
+ # equal character in the enviroment variable value
+ filename = test_support.TESTFN
+ self.addCleanup(test_support.unlink, filename)
+ with open(filename, "w") as fp:
+ fp.write('import sys, os\n'
+ 'if os.getenv("FRUIT") != "orange=lemon":\n'
+ ' raise AssertionError')
+ args = [sys.executable, filename]
+ newenv = os.environ.copy()
+ newenv["FRUIT"] = "orange=lemon"
+ exitcode = spawn(os.P_WAIT, args[0], args, newenv)
+ self.assertEqual(exitcode, 0)
+
+ @unittest.skipUnless(hasattr(os, 'spawnve'), 'test needs os.spawnve()')
+ def test_spawnve_invalid_env(self):
+ self._test_invalid_env(os.spawnve)
+
+ @unittest.skipUnless(hasattr(os, 'spawnvpe'), 'test needs os.spawnvpe()')
+ def test_spawnvpe_invalid_env(self):
+ self._test_invalid_env(os.spawnvpe)
+
+
def test_main():
test_support.run_unittest(
FileTests,
DevNullTests,
URandomTests,
URandomFDTests,
- ExecvpeTests,
+ ExecTests,
Win32ErrorTests,
TestInvalidFD,
PosixUidGidTests,
- Win32KillTests
+ Win32KillTests,
+ SpawnTests,
)
if __name__ == "__main__":
+import copy
import parser
+import pickle
import unittest
import sys
import struct
# not even remotely valid:
self.check_bad_tree((1, 2, 3), "<junk>")
+ def test_illegal_terminal(self):
+ tree = \
+ (257,
+ (267,
+ (268,
+ (269,
+ (274,
+ (1,))),
+ (4, ''))),
+ (4, ''),
+ (0, ''))
+ self.check_bad_tree(tree, "too small items in terminal node")
+ tree = \
+ (257,
+ (267,
+ (268,
+ (269,
+ (274,
+ (1, u'pass'))),
+ (4, ''))),
+ (4, ''),
+ (0, ''))
+ self.check_bad_tree(tree, "non-string second item in terminal node")
+ tree = \
+ (257,
+ (267,
+ (268,
+ (269,
+ (274,
+ (1, 'pass', '0', 0))),
+ (4, ''))),
+ (4, ''),
+ (0, ''))
+ self.check_bad_tree(tree, "non-integer third item in terminal node")
+ tree = \
+ (257,
+ (267,
+ (268,
+ (269,
+ (274,
+ (1, 'pass', 0, 0))),
+ (4, ''))),
+ (4, ''),
+ (0, ''))
+ self.check_bad_tree(tree, "too many items in terminal node")
+
def test_illegal_yield_1(self):
# Illegal yield statement: def f(): return 1; yield 1
tree = \
(4, ''), (0, ''))
self.check_bad_tree(tree, "from import a")
+ def test_illegal_encoding(self):
+ # Illegal encoding declaration
+ tree = \
+ (339,
+ (257, (0, '')))
+ self.check_bad_tree(tree, "missed encoding")
+ tree = \
+ (339,
+ (257, (0, '')),
+ u'iso-8859-1')
+ self.check_bad_tree(tree, "non-string encoding")
+
class CompileTestCase(unittest.TestCase):
class STObjectTestCase(unittest.TestCase):
"""Test operations on ST objects themselves"""
+ def test_copy_pickle(self):
+ sts = [
+ parser.expr('2 + 3'),
+ parser.suite('x = 2; y = x + 3'),
+ parser.expr('list(x**3 for x in range(20))')
+ ]
+ for st in sts:
+ st_copy = copy.copy(st)
+ self.assertEqual(st_copy.totuple(), st.totuple())
+ st_copy = copy.deepcopy(st)
+ self.assertEqual(st_copy.totuple(), st.totuple())
+ for proto in range(pickle.HIGHEST_PROTOCOL+1):
+ st_copy = pickle.loads(pickle.dumps(st, proto))
+ self.assertEqual(st_copy.totuple(), st.totuple())
+
check_sizeof = support.check_sizeof
@support.cpython_only
self.assertRaises(TypeError, posix.minor)
self.assertRaises((ValueError, OverflowError), posix.minor, -1)
+ if sys.platform.startswith('freebsd') and dev >= 0x100000000:
+ self.skipTest("bpo-31044: on FreeBSD CURRENT, minor() truncates "
+ "64-bit dev to 32-bit")
+
self.assertEqual(posix.makedev(major, minor), dev)
self.assertEqual(posix.makedev(int(major), int(minor)), dev)
self.assertEqual(posix.makedev(long(major), long(minor)), dev)
finally:
posix.lchflags(_DUMMY_SYMLINK, dummy_symlink_st.st_flags)
+ @unittest.skipUnless(hasattr(os, "putenv"), "requires os.putenv()")
+ def test_putenv(self):
+ with self.assertRaises(TypeError):
+ os.putenv('FRUIT\0VEGETABLE', 'cabbage')
+ with self.assertRaises(TypeError):
+ os.putenv('FRUIT', 'orange\0VEGETABLE=cabbage')
+ with self.assertRaises(ValueError):
+ os.putenv('FRUIT=ORANGE', 'lemon')
+
@unittest.skipUnless(hasattr(posix, 'getcwd'),
'test needs posix.getcwd()')
def test_getcwd_long_pathnames(self):
def get_pydoc_link(module):
"Returns a documentation web link of a module"
dirname = os.path.dirname
- basedir = dirname(dirname(__file__))
+ basedir = dirname(dirname(os.path.realpath(__file__)))
doc = pydoc.TextDoc()
loc = doc.getdocloc(module, basedir=basedir)
return loc
self.assertRaises(ValueError, self.gen.setstate, (1, None, None))
def test_setstate_middle_arg(self):
+ start_state = self.gen.getstate()
# Wrong type, s/b tuple
self.assertRaises(TypeError, self.gen.setstate, (2, None, None))
# Wrong length, s/b 625
self.gen.setstate((2, (1,)*624+(625,), None))
with self.assertRaises((ValueError, OverflowError)):
self.gen.setstate((2, (1,)*624+(-1,), None))
+ # Failed calls to setstate() should not have changed the state.
+ bits100 = self.gen.getrandbits(100)
+ self.gen.setstate(start_state)
+ self.assertEqual(self.gen.getrandbits(100), bits100)
def test_referenceImplementation(self):
# Compare the python implementation with results from the original
verbose, run_unittest, import_module,
precisionbigmemtest, _2G, cpython_only,
captured_stdout, have_unicode, requires_unicode, u,
- check_warnings)
+ check_warnings, check_py3k_warnings)
import locale
import re
from re import Scanner
self.assertEqual(re.sub('(?P<unk>x)', '\g<unk>\g<unk>', 'xx'), 'xxxx')
self.assertEqual(re.sub('(?P<unk>x)', '\g<1>\g<1>', 'xx'), 'xxxx')
- self.assertEqual(re.sub('a',r'\t\n\v\r\f\a\b\B\Z\a\A\w\W\s\S\d\D','a'),
- '\t\n\v\r\f\a\b\\B\\Z\a\\A\\w\\W\\s\\S\\d\\D')
- self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'), '\t\n\v\r\f\a')
- self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'),
- (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)))
+ self.assertEqual(re.sub('a', r'\t\n\v\r\f\a\b', 'a'), '\t\n\v\r\f\a\b')
+ self.assertEqual(re.sub('a', '\t\n\v\r\f\a\b', 'a'), '\t\n\v\r\f\a\b')
+ self.assertEqual(re.sub('a', '\t\n\v\r\f\a\b', 'a'),
+ (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)+chr(8)))
+ for c in 'cdehijklmopqsuwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
+ with check_py3k_warnings():
+ self.assertEqual(re.sub('a', '\\' + c, 'a'), '\\' + c)
self.assertEqual(re.sub('^\s*', 'X', 'test'), 'Xtest')
def test_re_split(self):
self.assertEqual(re.split(":", ":a:b::c"), ['', 'a', 'b', '', 'c'])
- self.assertEqual(re.split(":*", ":a:b::c"), ['', 'a', 'b', 'c'])
- self.assertEqual(re.split("(:*)", ":a:b::c"),
+ self.assertEqual(re.split(":+", ":a:b::c"), ['', 'a', 'b', 'c'])
+ self.assertEqual(re.split("(:+)", ":a:b::c"),
['', ':', 'a', ':', 'b', '::', 'c'])
- self.assertEqual(re.split("(?::*)", ":a:b::c"), ['', 'a', 'b', 'c'])
- self.assertEqual(re.split("(:)*", ":a:b::c"),
+ self.assertEqual(re.split("(?::+)", ":a:b::c"), ['', 'a', 'b', 'c'])
+ self.assertEqual(re.split("(:)+", ":a:b::c"),
['', ':', 'a', ':', 'b', ':', 'c'])
self.assertEqual(re.split("([b:]+)", ":a:b::c"),
['', ':', 'a', ':b::', 'c'])
self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),
['', 'a', '', '', 'c'])
+ for sep, expected in [
+ (':*', ['', 'a', 'b', 'c']),
+ ('(?::*)', ['', 'a', 'b', 'c']),
+ ('(:*)', ['', ':', 'a', ':', 'b', '::', 'c']),
+ ('(:)*', ['', ':', 'a', ':', 'b', ':', 'c']),
+ ]:
+ with check_py3k_warnings(('', FutureWarning)):
+ self.assertEqual(re.split(sep, ':a:b::c'), expected)
+
+ for sep, expected in [
+ ('', [':a:b::c']),
+ (r'\b', [':a:b::c']),
+ (r'(?=:)', [':a:b::c']),
+ (r'(?<=:)', [':a:b::c']),
+ ]:
+ with check_py3k_warnings():
+ self.assertEqual(re.split(sep, ':a:b::c'), expected)
+
def test_qualified_re_split(self):
self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
self.assertEqual(re.split(':', 'a:b:c:d', 2), ['a', 'b', 'c:d'])
self.assertEqual(re.split("(:)", ":a:b::c", 2),
['', ':', 'a', ':', 'b::c'])
- self.assertEqual(re.split("(:*)", ":a:b::c", 2),
+ self.assertEqual(re.split("(:+)", ":a:b::c", 2),
['', ':', 'a', ':', 'b::c'])
+ with check_py3k_warnings(('', FutureWarning)):
+ self.assertEqual(re.split("(:*)", ":a:b::c", maxsplit=2),
+ ['', ':', 'a', ':', 'b::c'])
def test_re_findall(self):
self.assertEqual(re.findall(":+", "abc"), [])
self.assertEqual(re.search(r"\d\D\w\W\s\S",
"1aa! a", re.UNICODE).group(0), "1aa! a")
+ def test_other_escapes(self):
+ self.assertRaises(re.error, re.compile, "\\")
+ self.assertEqual(re.match(r"\(", '(').group(), '(')
+ self.assertIsNone(re.match(r"\(", ')'))
+ self.assertEqual(re.match(r"\\", '\\').group(), '\\')
+ self.assertEqual(re.match(r"[\]]", ']').group(), ']')
+ self.assertIsNone(re.match(r"[\]]", '['))
+ self.assertEqual(re.match(r"[a\-c]", '-').group(), '-')
+ self.assertIsNone(re.match(r"[a\-c]", 'b'))
+ self.assertEqual(re.match(r"[\^a]+", 'a^').group(), 'a^')
+ self.assertIsNone(re.match(r"[\^a]+", 'b'))
+ re.purge() # for warnings
+ for c in 'ceghijklmopquyzCEFGHIJKLMNOPQRTUVXY':
+ warn = FutureWarning if c in 'Uu' else DeprecationWarning
+ with check_py3k_warnings(('', warn)):
+ self.assertEqual(re.match('\\%c$' % c, c).group(), c)
+ self.assertIsNone(re.match('\\%c' % c, 'a'))
+ for c in 'ceghijklmopquyzABCEFGHIJKLMNOPQRTUVXYZ':
+ warn = FutureWarning if c in 'Uu' else DeprecationWarning
+ with check_py3k_warnings(('', warn)):
+ self.assertEqual(re.match('[\\%c]$' % c, c).group(), c)
+ self.assertIsNone(re.match('[\\%c]' % c, 'a'))
+
def test_string_boundaries(self):
# See http://bugs.python.org/issue10713
self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
self.assertTrue(re.match('(?ixu) ' + upper_char, lower_char))
self.assertTrue(re.match('(?ixu) ' + lower_char, upper_char))
+ # Incompatibilities
+ re.purge()
+ with check_py3k_warnings():
+ re.compile('', re.LOCALE|re.UNICODE)
+ with check_py3k_warnings():
+ re.compile('(?L)', re.UNICODE)
+ with check_py3k_warnings():
+ re.compile('(?u)', re.LOCALE)
+ with check_py3k_warnings():
+ re.compile('(?Lu)')
+ with check_py3k_warnings():
+ re.compile('(?uL)')
+
def test_dollar_matches_twice(self):
"$ matches the end of string, and just before the terminating \n"
pattern = re.compile('$')
def test_bug_13899(self):
# Issue #13899: re pattern r"[\A]" should work like "A" but matches
# nothing. Ditto B and Z.
- self.assertEqual(re.findall(r'[\A\B\b\C\Z]', 'AB\bCZ'),
- ['A', 'B', '\b', 'C', 'Z'])
+ with check_py3k_warnings():
+ self.assertEqual(re.findall(r'[\A\B\b\C\Z]', 'AB\bCZ'),
+ ['A', 'B', '\b', 'C', 'Z'])
@precisionbigmemtest(size=_2G, memuse=1)
def test_large_search(self, size):
def test_main():
run_unittest(ReTests)
- run_re_tests()
+ deprecations = [
+ ('bad escape', DeprecationWarning),
+ ]
+ with check_py3k_warnings(*deprecations):
+ run_re_tests()
if __name__ == "__main__":
test_main()
--- /dev/null
+"""
+Tests of regrtest.py.
+
+Note: test_regrtest cannot be run twice in parallel.
+"""
+from __future__ import print_function
+
+import collections
+import errno
+import os.path
+import platform
+import re
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import textwrap
+import unittest
+from test import support
+
+
+Py_DEBUG = hasattr(sys, 'getobjects')
+ROOT_DIR = os.path.join(os.path.dirname(__file__), '..', '..')
+ROOT_DIR = os.path.abspath(os.path.normpath(ROOT_DIR))
+
+TEST_INTERRUPTED = textwrap.dedent("""
+ from signal import SIGINT
+ try:
+ from _testcapi import raise_signal
+ raise_signal(SIGINT)
+ except ImportError:
+ import os
+ os.kill(os.getpid(), SIGINT)
+ """)
+
+
+SubprocessRun = collections.namedtuple('SubprocessRun',
+ 'returncode stdout stderr')
+
+
+class BaseTestCase(unittest.TestCase):
+ TEST_UNIQUE_ID = 1
+ TESTNAME_PREFIX = 'test_regrtest_'
+ TESTNAME_REGEX = r'test_[a-zA-Z0-9_]+'
+
+ def setUp(self):
+ self.testdir = os.path.realpath(os.path.dirname(__file__))
+
+ self.tmptestdir = tempfile.mkdtemp()
+ self.addCleanup(support.rmtree, self.tmptestdir)
+
+ def create_test(self, name=None, code=''):
+ if not name:
+ name = 'noop%s' % BaseTestCase.TEST_UNIQUE_ID
+ BaseTestCase.TEST_UNIQUE_ID += 1
+
+ # test_regrtest cannot be run twice in parallel because
+ # of setUp() and create_test()
+ name = self.TESTNAME_PREFIX + name
+ path = os.path.join(self.tmptestdir, name + '.py')
+
+ self.addCleanup(support.unlink, path)
+ # Use O_EXCL to ensure that we do not override existing tests
+ try:
+ fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL)
+ except OSError as exc:
+ if (exc.errno in (errno.EACCES, errno.EPERM)
+ and not sysconfig.is_python_build()):
+ self.skipTest("cannot write %s: %s" % (path, exc))
+ else:
+ raise
+ else:
+ with os.fdopen(fd, 'w') as fp:
+ fp.write(code)
+ return name
+
+ def regex_search(self, regex, output):
+ match = re.search(regex, output, re.MULTILINE)
+ if not match:
+ self.fail("%r not found in %r" % (regex, output))
+ return match
+
+ def check_line(self, output, regex):
+ regex = re.compile(r'^' + regex, re.MULTILINE)
+ self.assertRegexpMatches(output, regex)
+
+ def parse_executed_tests(self, output):
+ regex = (r'^[0-9]+:[0-9]+:[0-9]+ (?:load avg: [0-9]+\.[0-9]{2} )?\[ *[0-9]+(?:/ *[0-9]+)*\] (%s)'
+ % self.TESTNAME_REGEX)
+ parser = re.finditer(regex, output, re.MULTILINE)
+ return list(match.group(1) for match in parser)
+
+ def check_executed_tests(self, output, tests, skipped=(), failed=(),
+ env_changed=(), omitted=(),
+ randomize=False, interrupted=False,
+ fail_env_changed=False):
+ if isinstance(tests, str):
+ tests = [tests]
+ if isinstance(skipped, str):
+ skipped = [skipped]
+ if isinstance(failed, str):
+ failed = [failed]
+ if isinstance(env_changed, str):
+ env_changed = [env_changed]
+ if isinstance(omitted, str):
+ omitted = [omitted]
+
+ executed = self.parse_executed_tests(output)
+ if randomize:
+ self.assertEqual(set(executed), set(tests), output)
+ else:
+ self.assertEqual(executed, tests, (executed, tests, output))
+
+ def plural(count):
+ return 's' if count != 1 else ''
+
+ def list_regex(line_format, tests):
+ count = len(tests)
+ names = ' '.join(sorted(tests))
+ regex = line_format % (count, plural(count))
+ regex = r'%s:\n %s$' % (regex, names)
+ return regex
+
+ if skipped:
+ regex = list_regex('%s test%s skipped', skipped)
+ self.check_line(output, regex)
+
+ if failed:
+ regex = list_regex('%s test%s failed', failed)
+ self.check_line(output, regex)
+
+ if env_changed:
+ regex = list_regex('%s test%s altered the execution environment',
+ env_changed)
+ self.check_line(output, regex)
+
+ if omitted:
+ regex = list_regex('%s test%s omitted', omitted)
+ self.check_line(output, regex)
+
+ good = (len(tests) - len(skipped) - len(failed)
+ - len(omitted) - len(env_changed))
+ if good:
+ regex = r'%s test%s OK\.$' % (good, plural(good))
+ if not skipped and not failed and good > 1:
+ regex = 'All %s' % regex
+ self.check_line(output, regex)
+
+ if interrupted:
+ self.check_line(output, 'Test suite interrupted by signal SIGINT.')
+
+ if failed:
+ result = 'FAILURE'
+ elif interrupted:
+ result = 'INTERRUPTED'
+ elif fail_env_changed and env_changed:
+ result = 'ENV CHANGED'
+ else:
+ result = 'SUCCESS'
+ self.check_line(output, 'Tests result: %s' % result)
+
+ def parse_random_seed(self, output):
+ match = self.regex_search(r'Using random seed ([0-9]+)', output)
+ randseed = int(match.group(1))
+ self.assertTrue(0 <= randseed <= 10000000, randseed)
+ return randseed
+
+ def run_command(self, args, input=None, exitcode=0, **kw):
+ if not input:
+ input = ''
+ if 'stderr' not in kw:
+ kw['stderr'] = subprocess.PIPE
+ proc = subprocess.Popen(args,
+ universal_newlines=True,
+ stdout=subprocess.PIPE,
+ **kw)
+ stdout, stderr = proc.communicate(input=input)
+ if proc.returncode != exitcode:
+ msg = ("Command %s failed with exit code %s\n"
+ "\n"
+ "stdout:\n"
+ "---\n"
+ "%s\n"
+ "---\n"
+ % (str(args), proc.returncode, stdout))
+ if proc.stderr:
+ msg += ("\n"
+ "stderr:\n"
+ "---\n"
+ "%s"
+ "---\n"
+ % stderr)
+ self.fail(msg)
+ return SubprocessRun(proc.returncode, stdout, stderr)
+
+ def run_python(self, args, **kw):
+ args = [sys.executable] + list(args)
+ proc = self.run_command(args, **kw)
+ return proc.stdout
+
+
+class ProgramsTestCase(BaseTestCase):
+ """
+ Test various ways to run the Python test suite. Use options close
+ to options used on the buildbot.
+ """
+
+ NTEST = 4
+
+ def setUp(self):
+ super(ProgramsTestCase, self).setUp()
+
+ # Create NTEST tests doing nothing
+ self.tests = [self.create_test() for index in range(self.NTEST)]
+
+ self.python_args = ['-Wd', '-3', '-E', '-bb', '-tt']
+ self.regrtest_args = ['-uall', '-rwW',
+ '--testdir=%s' % self.tmptestdir]
+
+ def check_output(self, output):
+ self.parse_random_seed(output)
+ self.check_executed_tests(output, self.tests, randomize=True)
+
+ def run_tests(self, args):
+ output = self.run_python(args)
+ self.check_output(output)
+
+ def test_script_regrtest(self):
+ # Lib/test/regrtest.py
+ script = os.path.join(self.testdir, 'regrtest.py')
+
+ args = self.python_args + [script] + self.regrtest_args + self.tests
+ self.run_tests(args)
+
+ def test_module_test(self):
+ # -m test
+ args = self.python_args + ['-m', 'test'] + self.regrtest_args + self.tests
+ self.run_tests(args)
+
+ def test_module_regrtest(self):
+ # -m test.regrtest
+ args = self.python_args + ['-m', 'test.regrtest'] + self.regrtest_args + self.tests
+ self.run_tests(args)
+
+ def test_module_autotest(self):
+ # -m test.autotest
+ args = self.python_args + ['-m', 'test.autotest'] + self.regrtest_args + self.tests
+ self.run_tests(args)
+
+ def test_module_from_test_autotest(self):
+ # from test import autotest
+ code = 'from test import autotest'
+ args = self.python_args + ['-c', code] + self.regrtest_args + self.tests
+ self.run_tests(args)
+
+ def test_script_autotest(self):
+ # Lib/test/autotest.py
+ script = os.path.join(self.testdir, 'autotest.py')
+ args = self.python_args + [script] + self.regrtest_args + self.tests
+ self.run_tests(args)
+
+ def run_batch(self, *args):
+ proc = self.run_command(args)
+ self.check_output(proc.stdout)
+
+ def need_pcbuild(self):
+ exe = os.path.normpath(os.path.abspath(sys.executable))
+ parts = exe.split(os.path.sep)
+ if len(parts) < 3:
+ # it's not a python build, python is likely to be installed
+ return
+
+ build_dir = parts[-3]
+ if build_dir.lower() != 'pcbuild':
+ self.skipTest("Tools/buildbot/test.bat requires PCbuild build, "
+ "found %s" % build_dir)
+
+ @unittest.skipUnless(sysconfig.is_python_build(),
+ 'test.bat script is not installed')
+ @unittest.skipUnless(sys.platform == 'win32', 'Windows only')
+ def test_tools_buildbot_test(self):
+ self.need_pcbuild()
+
+ # Tools\buildbot\test.bat
+ script = os.path.join(ROOT_DIR, 'Tools', 'buildbot', 'test.bat')
+ test_args = ['--testdir=%s' % self.tmptestdir]
+ if platform.architecture()[0] == '64bit':
+ test_args.append('-x64') # 64-bit build
+ if not Py_DEBUG:
+ test_args.append('+d') # Release build, use python.exe
+
+ args = [script] + test_args + self.tests
+ self.run_batch(*args)
+
+ @unittest.skipUnless(sys.platform == 'win32', 'Windows only')
+ def test_pcbuild_rt(self):
+ self.need_pcbuild()
+
+ # PCbuild\rt.bat
+ script = os.path.join(ROOT_DIR, r'PCbuild\rt.bat')
+ rt_args = ["-q"] # Quick, don't run tests twice
+ if platform.architecture()[0] == '64bit':
+ rt_args.append('-x64') # 64-bit build
+ if Py_DEBUG:
+ rt_args.append('-d') # Debug build, use python_d.exe
+ args = [script] + rt_args + self.regrtest_args + self.tests
+ self.run_batch(*args)
+
+
+class ArgsTestCase(BaseTestCase):
+ """
+ Test arguments of the Python test suite.
+ """
+
+ def run_tests(self, *testargs, **kw):
+ cmdargs = ('-m', 'test', '--testdir=%s' % self.tmptestdir) + testargs
+ return self.run_python(cmdargs, **kw)
+
+ def test_failing_test(self):
+ # test a failing test
+ code = textwrap.dedent("""
+ import unittest
+ from test import support
+
+ class FailingTest(unittest.TestCase):
+ def test_failing(self):
+ self.fail("bug")
+
+ def test_main():
+ support.run_unittest(FailingTest)
+ """)
+ test_ok = self.create_test('ok')
+ test_failing = self.create_test('failing', code=code)
+ tests = [test_ok, test_failing]
+
+ output = self.run_tests(*tests, exitcode=2)
+ self.check_executed_tests(output, tests, failed=test_failing)
+
+ def test_resources(self):
+ # test -u command line option
+ tests = {}
+ for resource in ('audio', 'network'):
+ code = 'from test import support\nsupport.requires(%r)' % resource
+ tests[resource] = self.create_test(resource, code)
+ test_names = sorted(tests.values())
+
+ # -u all: 2 resources enabled
+ output = self.run_tests('-u', 'all', *test_names)
+ self.check_executed_tests(output, test_names)
+
+ # -u audio: 1 resource enabled
+ output = self.run_tests('-uaudio', *test_names)
+ self.check_executed_tests(output, test_names,
+ skipped=tests['network'])
+
+ # no option: 0 resources enabled
+ output = self.run_tests(*test_names)
+ self.check_executed_tests(output, test_names,
+ skipped=test_names)
+
+ def test_random(self):
+ # test -r and --randseed command line option
+ code = textwrap.dedent("""
+ import random
+ print("TESTRANDOM: %s" % random.randint(1, 1000))
+ """)
+ test = self.create_test('random', code)
+
+ # first run to get the output with the random seed
+ output = self.run_tests('-r', '-v', test)
+ randseed = self.parse_random_seed(output)
+ match = self.regex_search(r'TESTRANDOM: ([0-9]+)', output)
+ test_random = int(match.group(1))
+
+ # try to reproduce with the random seed
+ output = self.run_tests('-r', '-v', '--randseed=%s' % randseed, test)
+ randseed2 = self.parse_random_seed(output)
+ self.assertEqual(randseed2, randseed)
+
+ match = self.regex_search(r'TESTRANDOM: ([0-9]+)', output)
+ test_random2 = int(match.group(1))
+ self.assertEqual(test_random2, test_random)
+
+ def test_fromfile(self):
+ # test --fromfile
+ tests = [self.create_test() for index in range(5)]
+
+ # Write the list of files using a format similar to regrtest output:
+ # [1/2] test_1
+ # [2/2] test_2
+ filename = support.TESTFN
+ self.addCleanup(support.unlink, filename)
+
+ # test format 'test_opcodes'
+ with open(filename, "w") as fp:
+ for name in tests:
+ print(name, file=fp)
+
+ output = self.run_tests('--fromfile', filename)
+ self.check_executed_tests(output, tests)
+
+ def test_interrupted(self):
+ code = TEST_INTERRUPTED
+ test = self.create_test('sigint', code=code)
+ output = self.run_tests(test, exitcode=130)
+ self.check_executed_tests(output, test, omitted=test,
+ interrupted=True)
+
+ def test_slowest(self):
+ # test --slow
+ tests = [self.create_test() for index in range(3)]
+ output = self.run_tests("--slowest", *tests)
+ self.check_executed_tests(output, tests)
+ regex = ('10 slowest tests:\n'
+ '(?:- %s: .*\n){%s}'
+ % (self.TESTNAME_REGEX, len(tests)))
+ self.check_line(output, regex)
+
+ def test_slow_interrupted(self):
+ # Issue #25373: test --slowest with an interrupted test
+ code = TEST_INTERRUPTED
+ test = self.create_test("sigint", code=code)
+
+ try:
+ import threading
+ tests = (False, True)
+ except ImportError:
+ tests = (False,)
+ for multiprocessing in tests:
+ if multiprocessing:
+ args = ("--slowest", "-j2", test)
+ else:
+ args = ("--slowest", test)
+ output = self.run_tests(*args, exitcode=130)
+ self.check_executed_tests(output, test,
+ omitted=test, interrupted=True)
+
+ regex = ('10 slowest tests:\n')
+ self.check_line(output, regex)
+
+ def test_coverage(self):
+ # test --coverage
+ test = self.create_test('coverage')
+ output = self.run_tests("--coverage", test)
+ self.check_executed_tests(output, [test])
+ regex = (r'lines +cov% +module +\(path\)\n'
+ r'(?: *[0-9]+ *[0-9]{1,2}% *[^ ]+ +\([^)]+\)+)+')
+ self.check_line(output, regex)
+
+ def test_forever(self):
+ # test --forever
+ code = textwrap.dedent("""
+ import __builtin__
+ import unittest
+ from test import support
+
+ class ForeverTester(unittest.TestCase):
+ def test_run(self):
+ # Store the state in the __builtin__ module, because the test
+ # module is reload at each run
+ if 'RUN' in __builtin__.__dict__:
+ __builtin__.__dict__['RUN'] += 1
+ if __builtin__.__dict__['RUN'] >= 3:
+ self.fail("fail at the 3rd runs")
+ else:
+ __builtin__.__dict__['RUN'] = 1
+
+ def test_main():
+ support.run_unittest(ForeverTester)
+ """)
+ test = self.create_test('forever', code=code)
+ output = self.run_tests('--forever', test, exitcode=2)
+ self.check_executed_tests(output, [test]*3, failed=test)
+
+ def check_leak(self, code, what):
+ test = self.create_test('huntrleaks', code=code)
+
+ filename = 'reflog.txt'
+ self.addCleanup(support.unlink, filename)
+ output = self.run_tests('--huntrleaks', '3:3:', test,
+ exitcode=2,
+ stderr=subprocess.STDOUT)
+ self.check_executed_tests(output, [test], failed=test)
+
+ line = 'beginning 6 repetitions\n123456\n......\n'
+ self.check_line(output, re.escape(line))
+
+ line2 = '%s leaked [1, 1, 1] %s, sum=3\n' % (test, what)
+ self.assertIn(line2, output)
+
+ with open(filename) as fp:
+ reflog = fp.read()
+ self.assertIn(line2, reflog)
+
+ @unittest.skipUnless(Py_DEBUG, 'need a debug build')
+ def test_huntrleaks(self):
+ # test --huntrleaks
+ code = textwrap.dedent("""
+ import unittest
+ from test import support
+
+ GLOBAL_LIST = []
+
+ class RefLeakTest(unittest.TestCase):
+ def test_leak(self):
+ GLOBAL_LIST.append(object())
+
+ def test_main():
+ support.run_unittest(RefLeakTest)
+ """)
+ self.check_leak(code, 'references')
+
+ def test_list_tests(self):
+ # test --list-tests
+ tests = [self.create_test() for i in range(5)]
+ output = self.run_tests('--list-tests', *tests)
+ self.assertEqual(output.rstrip().splitlines(),
+ tests)
+
+ def test_list_cases(self):
+ # test --list-cases
+ code = textwrap.dedent("""
+ import unittest
+
+ class Tests(unittest.TestCase):
+ def test_method1(self):
+ pass
+ def test_method2(self):
+ pass
+ """)
+ testname = self.create_test(code=code)
+
+ # Test --list-cases
+ all_methods = ['%s.Tests.test_method1' % testname,
+ '%s.Tests.test_method2' % testname]
+ output = self.run_tests('--list-cases', testname)
+ self.assertEqual(output.splitlines(), all_methods)
+
+ # Test --list-cases with --match
+ all_methods = ['%s.Tests.test_method1' % testname]
+ output = self.run_tests('--list-cases',
+ '-m', 'test_method1',
+ testname)
+ self.assertEqual(output.splitlines(), all_methods)
+
+ def test_crashed(self):
+ # Any code which causes a crash
+ code = 'import test.support; test.support._crash_python()'
+ crash_test = self.create_test(name="crash", code=code)
+ ok_test = self.create_test(name="ok")
+
+ tests = [crash_test, ok_test]
+ output = self.run_tests("-j2", *tests, exitcode=2)
+ self.check_executed_tests(output, tests, failed=crash_test,
+ randomize=True)
+
+ def parse_methods(self, output):
+ regex = re.compile("^(test[^ ]+).*ok$", flags=re.MULTILINE)
+ return [match.group(1) for match in regex.finditer(output)]
+
+ def test_matchfile(self):
+ # Any code which causes a crash
+ code = textwrap.dedent("""
+ import unittest
+ from test import support
+
+ class Tests(unittest.TestCase):
+ def test_method1(self):
+ pass
+ def test_method2(self):
+ pass
+ def test_method3(self):
+ pass
+ def test_method4(self):
+ pass
+
+ def test_main():
+ support.run_unittest(Tests)
+ """)
+ all_methods = ['test_method1', 'test_method2',
+ 'test_method3', 'test_method4']
+ testname = self.create_test(code=code)
+
+ # by default, all methods should be run
+ output = self.run_tests("-v", testname)
+ methods = self.parse_methods(output)
+ self.assertEqual(methods, all_methods)
+
+ # only run a subset
+ filename = support.TESTFN
+ self.addCleanup(support.unlink, filename)
+
+ subset = [
+ # only match the method name
+ 'test_method1',
+ # match the full identifier
+ '%s.Tests.test_method3' % testname]
+ with open(filename, "w") as fp:
+ for name in subset:
+ print(name, file=fp)
+
+ output = self.run_tests("-v", "--matchfile", filename, testname)
+ methods = self.parse_methods(output)
+ subset = ['test_method1', 'test_method3']
+ self.assertEqual(methods, subset)
+
+ def test_env_changed(self):
+ code = textwrap.dedent("""
+ import unittest
+ from test import support
+
+ class Tests(unittest.TestCase):
+ def test_env_changed(self):
+ open("env_changed", "w").close()
+
+ def test_main():
+ support.run_unittest(Tests)
+ """)
+ testname = self.create_test(code=code)
+
+ # don't fail by default
+ output = self.run_tests(testname)
+ self.check_executed_tests(output, [testname], env_changed=testname)
+
+ # fail with --fail-env-changed
+ output = self.run_tests("--fail-env-changed", testname, exitcode=3)
+ self.check_executed_tests(output, [testname], env_changed=testname,
+ fail_env_changed=True)
+
+
+def test_main():
+ support.run_unittest(ProgramsTestCase, ArgsTestCase)
+
+
+if __name__ == "__main__":
+ test_main()
-import unittest, StringIO, robotparser
-from test import test_support
-from urllib2 import urlopen, HTTPError
-
-HAVE_HTTPS = True
+import os
+import robotparser
+import unittest
+from test import support
+from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+import StringIO
try:
- from urllib2 import HTTPSHandler
+ import threading
except ImportError:
- HAVE_HTTPS = False
-
-class RobotTestCase(unittest.TestCase):
- def __init__(self, index, parser, url, good, agent):
- unittest.TestCase.__init__(self)
- if good:
- self.str = "RobotTest(%d, good, %s)" % (index, url)
- else:
- self.str = "RobotTest(%d, bad, %s)" % (index, url)
- self.parser = parser
- self.url = url
- self.good = good
- self.agent = agent
-
- def runTest(self):
- if isinstance(self.url, tuple):
- agent, url = self.url
- else:
- url = self.url
- agent = self.agent
- if self.good:
- self.assertTrue(self.parser.can_fetch(agent, url))
- else:
- self.assertFalse(self.parser.can_fetch(agent, url))
-
- def __str__(self):
- return self.str
-
-tests = unittest.TestSuite()
+ threading = None
-def RobotTest(index, robots_txt, good_urls, bad_urls,
- agent="test_robotparser"):
- lines = StringIO.StringIO(robots_txt).readlines()
- parser = robotparser.RobotFileParser()
- parser.parse(lines)
- for url in good_urls:
- tests.addTest(RobotTestCase(index, parser, url, 1, agent))
- for url in bad_urls:
- tests.addTest(RobotTestCase(index, parser, url, 0, agent))
+class BaseRobotTest:
+ robots_txt = ''
+ agent = 'test_robotparser'
+ good = []
+ bad = []
-# Examples from http://www.robotstxt.org/wc/norobots.html (fetched 2002)
+ def setUp(self):
+ lines = StringIO.StringIO(self.robots_txt).readlines()
+ self.parser = robotparser.RobotFileParser()
+ self.parser.parse(lines)
-# 1.
-doc = """
-User-agent: *
-Disallow: /cyberworld/map/ # This is an infinite virtual URL space
-Disallow: /tmp/ # these will soon disappear
-Disallow: /foo.html
-"""
+ def get_agent_and_url(self, url):
+ if isinstance(url, tuple):
+ agent, url = url
+ return agent, url
+ return self.agent, url
-good = ['/','/test.html']
-bad = ['/cyberworld/map/index.html','/tmp/xxx','/foo.html']
+ def test_good_urls(self):
+ for url in self.good:
+ agent, url = self.get_agent_and_url(url)
+ self.assertTrue(self.parser.can_fetch(agent, url))
-RobotTest(1, doc, good, bad)
+ def test_bad_urls(self):
+ for url in self.bad:
+ agent, url = self.get_agent_and_url(url)
+ self.assertFalse(self.parser.can_fetch(agent, url))
-# 2.
-doc = """
-# robots.txt for http://www.example.com/
+class UserAgentWildcardTest(BaseRobotTest, unittest.TestCase):
+ robots_txt = """\
User-agent: *
Disallow: /cyberworld/map/ # This is an infinite virtual URL space
+Disallow: /tmp/ # these will soon disappear
+Disallow: /foo.html
+ """
+ good = ['/', '/test.html']
+ bad = ['/cyberworld/map/index.html', '/tmp/xxx', '/foo.html']
-# Cybermapper knows where to go.
-User-agent: cybermapper
-Disallow:
-
-"""
-
-good = ['/','/test.html',('cybermapper','/cyberworld/map/index.html')]
-bad = ['/cyberworld/map/index.html']
-
-RobotTest(2, doc, good, bad)
-# 3.
-doc = """
+class RejectAllRobotsTest(BaseRobotTest, unittest.TestCase):
+ robots_txt = """\
# go away
User-agent: *
Disallow: /
-"""
-
-good = []
-bad = ['/cyberworld/map/index.html','/','/tmp/']
-
-RobotTest(3, doc, good, bad)
-
-# Examples from http://www.robotstxt.org/wc/norobots-rfc.html (fetched 2002)
-
-# 4.
-doc = """
-User-agent: figtree
-Disallow: /tmp
-Disallow: /a%3cd.html
-Disallow: /a%2fb.html
-Disallow: /%7ejoe/index.html
-"""
-
-good = [] # XFAIL '/a/b.html'
-bad = ['/tmp','/tmp.html','/tmp/a.html',
- '/a%3cd.html','/a%3Cd.html','/a%2fb.html',
- '/~joe/index.html'
- ]
-
-RobotTest(4, doc, good, bad, 'figtree')
-RobotTest(5, doc, good, bad, 'FigTree Robot libwww-perl/5.04')
-
-# 6.
-doc = """
-User-agent: *
-Disallow: /tmp/
-Disallow: /a%3Cd.html
-Disallow: /a/b.html
-Disallow: /%7ejoe/index.html
-"""
-
-good = ['/tmp',] # XFAIL: '/a%2fb.html'
-bad = ['/tmp/','/tmp/a.html',
- '/a%3cd.html','/a%3Cd.html',"/a/b.html",
- '/%7Ejoe/index.html']
-
-RobotTest(6, doc, good, bad)
-
-# From bug report #523041
-
-# 7.
-doc = """
-User-Agent: *
-Disallow: /.
-"""
-
-good = ['/foo.html']
-bad = [] # Bug report says "/" should be denied, but that is not in the RFC
-
-RobotTest(7, doc, good, bad)
-
-# From Google: http://www.google.com/support/webmasters/bin/answer.py?hl=en&answer=40364
-
-# 8.
-doc = """
-User-agent: Googlebot
-Allow: /folder1/myfile.html
-Disallow: /folder1/
-"""
-
-good = ['/folder1/myfile.html']
-bad = ['/folder1/anotherfile.html']
+ """
+ good = []
+ bad = ['/cyberworld/map/index.html', '/', '/tmp/']
-RobotTest(8, doc, good, bad, agent="Googlebot")
-# 9. This file is incorrect because "Googlebot" is a substring of
-# "Googlebot-Mobile", so test 10 works just like test 9.
-doc = """
+class UserAgentOrderingTest(BaseRobotTest, unittest.TestCase):
+ # the order of User-agent should be correct. note
+ # that this file is incorrect because "Googlebot" is a
+ # substring of "Googlebot-Mobile"
+ robots_txt = """\
User-agent: Googlebot
Disallow: /
User-agent: Googlebot-Mobile
Allow: /
-"""
+ """
+ agent = 'Googlebot'
+ bad = ['/something.jpg']
-good = []
-bad = ['/something.jpg']
-RobotTest(9, doc, good, bad, agent="Googlebot")
+class UserAgentGoogleMobileTest(UserAgentOrderingTest):
+ agent = 'Googlebot-Mobile'
-good = []
-bad = ['/something.jpg']
-
-RobotTest(10, doc, good, bad, agent="Googlebot-Mobile")
-
-# 11. Get the order correct.
-doc = """
-User-agent: Googlebot-Mobile
-Allow: /
-User-agent: Googlebot
-Disallow: /
-"""
-
-good = []
-bad = ['/something.jpg']
-
-RobotTest(11, doc, good, bad, agent="Googlebot")
-
-good = ['/something.jpg']
-bad = []
-
-RobotTest(12, doc, good, bad, agent="Googlebot-Mobile")
-
-
-# 13. Google also got the order wrong in #8. You need to specify the
-# URLs from more specific to more general.
-doc = """
+class GoogleURLOrderingTest(BaseRobotTest, unittest.TestCase):
+ # Google also got the order wrong. You need
+ # to specify the URLs from more specific to more general
+ robots_txt = """\
User-agent: Googlebot
Allow: /folder1/myfile.html
Disallow: /folder1/
-"""
-
-good = ['/folder1/myfile.html']
-bad = ['/folder1/anotherfile.html']
-
-RobotTest(13, doc, good, bad, agent="googlebot")
+ """
+ agent = 'googlebot'
+ good = ['/folder1/myfile.html']
+ bad = ['/folder1/anotherfile.html']
-# 14. For issue #6325 (query string support)
-doc = """
+class DisallowQueryStringTest(BaseRobotTest, unittest.TestCase):
+ # see issue #6325 for details
+ robots_txt = """\
User-agent: *
Disallow: /some/path?name=value
-"""
+ """
+ good = ['/some/path']
+ bad = ['/some/path?name=value']
-good = ['/some/path']
-bad = ['/some/path?name=value']
-RobotTest(14, doc, good, bad)
-
-# 15. For issue #4108 (obey first * entry)
-doc = """
+class UseFirstUserAgentWildcardTest(BaseRobotTest, unittest.TestCase):
+ # obey first * entry (#4108)
+ robots_txt = """\
User-agent: *
Disallow: /some/path
User-agent: *
Disallow: /another/path
-"""
-
-good = ['/another/path']
-bad = ['/some/path']
+ """
+ good = ['/another/path']
+ bad = ['/some/path']
-RobotTest(15, doc, good, bad)
-# 16. Empty query (issue #17403). Normalizing the url first.
-doc = """
+class EmptyQueryStringTest(BaseRobotTest, unittest.TestCase):
+ # normalize the URL first (#17403)
+ robots_txt = """\
User-agent: *
Allow: /some/path?
Disallow: /another/path?
-"""
+ """
+ good = ['/some/path?']
+ bad = ['/another/path?']
-good = ['/some/path?']
-bad = ['/another/path?']
-RobotTest(16, doc, good, bad)
+class DefaultEntryTest(BaseRobotTest, unittest.TestCase):
+ robots_txt = """\
+User-agent: *
+Crawl-delay: 1
+Request-rate: 3/15
+Disallow: /cyberworld/map/
+ """
+ good = ['/', '/test.html']
+ bad = ['/cyberworld/map/index.html']
-class NetworkTestCase(unittest.TestCase):
+class RobotHandler(BaseHTTPRequestHandler):
+
+ def do_GET(self):
+ self.send_error(403, "Forbidden access")
+
+ def log_message(self, format, *args):
+ pass
+
+
+@unittest.skipUnless(threading, 'threading required for this test')
+class PasswordProtectedSiteTestCase(unittest.TestCase):
+ def setUp(self):
+ self.server = HTTPServer((support.HOST, 0), RobotHandler)
+
+ self.t = threading.Thread(
+ name='HTTPServer serving',
+ target=self.server.serve_forever,
+ # Short poll interval to make the test finish quickly.
+ # Time between requests is short enough that we won't wake
+ # up spuriously too many times.
+ kwargs={'poll_interval':0.01})
+ self.t.daemon = True # In case this function raises.
+ self.t.start()
+
+ def tearDown(self):
+ self.server.shutdown()
+ self.t.join()
+ self.server.server_close()
+
+ @support.reap_threads
def testPasswordProtectedSite(self):
- test_support.requires('network')
- with test_support.transient_internet('mueblesmoraleda.com'):
- url = 'http://mueblesmoraleda.com'
- robots_url = url + "/robots.txt"
- # First check the URL is usable for our purposes, since the
- # test site is a bit flaky.
- try:
- urlopen(robots_url)
- except HTTPError as e:
- if e.code not in {401, 403}:
- self.skipTest(
- "%r should return a 401 or 403 HTTP error, not %r"
- % (robots_url, e.code))
- else:
- self.skipTest(
- "%r should return a 401 or 403 HTTP error, not succeed"
- % (robots_url))
- parser = robotparser.RobotFileParser()
- parser.set_url(url)
- try:
- parser.read()
- except IOError:
- self.skipTest('%s is unavailable' % url)
- self.assertEqual(parser.can_fetch("*", robots_url), False)
-
- @unittest.skipUnless(HAVE_HTTPS, 'need SSL support to download license')
- @test_support.system_must_validate_cert
- def testPythonOrg(self):
- test_support.requires('network')
- with test_support.transient_internet('www.python.org'):
- parser = robotparser.RobotFileParser(
- "https://www.python.org/robots.txt")
- parser.read()
- self.assertTrue(
- parser.can_fetch("*", "https://www.python.org/robots.txt"))
+ addr = self.server.server_address
+ url = 'http://' + support.HOST + ':' + str(addr[1])
+ robots_url = url + "/robots.txt"
+ parser = robotparser.RobotFileParser()
+ parser.set_url(url)
+ parser.read()
+ self.assertFalse(parser.can_fetch("*", robots_url))
-def test_main():
- test_support.run_unittest(tests)
- test_support.run_unittest(NetworkTestCase)
+class NetworkTestCase(unittest.TestCase):
+
+ base_url = 'http://www.pythontest.net/'
+ robots_txt = '{}elsewhere/robots.txt'.format(base_url)
+
+ @classmethod
+ def setUpClass(cls):
+ support.requires('network')
+ with support.transient_internet(cls.base_url):
+ cls.parser = robotparser.RobotFileParser(cls.robots_txt)
+ cls.parser.read()
+
+ def url(self, path):
+ return '{}{}{}'.format(
+ self.base_url, path, '/' if not os.path.splitext(path)[1] else ''
+ )
+
+ def test_basic(self):
+ self.assertFalse(self.parser.disallow_all)
+ self.assertFalse(self.parser.allow_all)
+ self.assertGreater(self.parser.mtime(), 0)
+
+ def test_can_fetch(self):
+ self.assertTrue(self.parser.can_fetch('*', self.url('elsewhere')))
+ self.assertFalse(self.parser.can_fetch('Nutch', self.base_url))
+ self.assertFalse(self.parser.can_fetch('Nutch', self.url('brian')))
+ self.assertFalse(self.parser.can_fetch('Nutch', self.url('webstats')))
+ self.assertFalse(self.parser.can_fetch('*', self.url('webstats')))
+ self.assertTrue(self.parser.can_fetch('*', self.base_url))
+
+ def test_read_404(self):
+ parser = robotparser.RobotFileParser(self.url('i-robot.txt'))
+ parser.read()
+ self.assertTrue(parser.allow_all)
+ self.assertFalse(parser.disallow_all)
+ self.assertEqual(parser.mtime(), 0)
-if __name__=='__main__':
- test_support.verbose = 1
+
+def test_main():
+ support.run_unittest(
+ UserAgentWildcardTest,
+ RejectAllRobotsTest,
+ UserAgentOrderingTest,
+ UserAgentGoogleMobileTest,
+ GoogleURLOrderingTest,
+ DisallowQueryStringTest,
+ UseFirstUserAgentWildcardTest,
+ EmptyQueryStringTest,
+ DefaultEntryTest,
+ PasswordProtectedSiteTestCase,
+ NetworkTestCase)
+
+
+if __name__ == "__main__":
test_main()
# $Id$
from xml.sax import make_parser, ContentHandler, \
- SAXException, SAXReaderNotAvailable, SAXParseException
+ SAXException, SAXReaderNotAvailable, SAXParseException, \
+ saxutils
try:
make_parser()
except SAXReaderNotAvailable:
input.setEncoding('iso-8859-1')
self.check_parse(input)
+ def test_parse_close_source(self):
+ builtin_open = open
+ non_local = {'fileobj': None}
+
+ def mock_open(*args):
+ fileobj = builtin_open(*args)
+ non_local['fileobj'] = fileobj
+ return fileobj
+
+ with support.swap_attr(saxutils, 'open', mock_open):
+ make_xml_file(self.data, 'iso-8859-1', None)
+ with self.assertRaises(SAXException):
+ self.check_parse(TESTFN)
+ self.assertTrue(non_local['fileobj'].closed)
+
def check_parseString(self, s):
from xml.sax import parseString
result = StringIO()
try:
import zipfile
+ import zlib
ZIP_SUPPORT = True
except ImportError:
ZIP_SUPPORT = find_executable('zip')
self.assertEqual(tarball, base_name + '.tar')
self.assertTrue(os.path.isfile(tarball))
- @unittest.skipUnless(zlib, "Requires zlib")
@unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
def test_make_zipfile(self):
# creating something to zip
['dist/', 'dist/file1', 'dist/file2',
'dist/sub/', 'dist/sub/file3', 'dist/sub2/',
'outer'])
+ support.unlink(res)
with support.change_cwd(work_dir):
base_name = os.path.abspath(rel_base_name)
['dist/', 'dist/file1', 'dist/file2',
'dist/sub/', 'dist/sub/file3', 'dist/sub2/'])
- @unittest.skipUnless(zlib, "Requires zlib")
@unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
@unittest.skipUnless(find_executable('zip'),
'Need the zip command to run')
names2 = zf.namelist()
self.assertEqual(sorted(names), sorted(names2))
- @unittest.skipUnless(zlib, "Requires zlib")
@unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
@unittest.skipUnless(find_executable('unzip'),
'Need the unzip command to run')
self.fail('Test deadlocked after %d seconds.' %
self.MAX_DURATION)
+ # read the exit status to not leak a zombie process
+ os.waitpid(child, 0)
+
@unittest.skipIf(sys.platform == "win32", "Not valid on Windows")
class BasicSignalTests(unittest.TestCase):
# and the handler should have been called
self.assertEqual(self.hndl_called, True)
+ def test_setitimer_tiny(self):
+ # bpo-30807: C setitimer() takes a microsecond-resolution interval.
+ # Check that float -> timeval conversion doesn't round
+ # the interval down to zero, which would disable the timer.
+ self.itimer = signal.ITIMER_REAL
+ signal.setitimer(self.itimer, 1e-6)
+ time.sleep(1)
+ self.assertEqual(self.hndl_called, True)
+
+
def test_main():
test_support.run_unittest(BasicSignalTests, InterProcessSignalTests,
WakeupFDTests, WakeupSignalTests,
from test.test_support import run_unittest, TESTFN, EnvironmentVarGuard
from test.test_support import captured_output
import __builtin__
+import errno
import os
import sys
import re
else:
raise unittest.SkipTest("importation of site.py suppressed")
-if site.ENABLE_USER_SITE and not os.path.isdir(site.USER_SITE):
- # need to add user site directory for tests
- try:
- os.makedirs(site.USER_SITE)
- site.addsitedir(site.USER_SITE)
- except OSError as exc:
- raise unittest.SkipTest('unable to create user site directory (%r): %s'
- % (site.USER_SITE, exc))
+
+OLD_SYS_PATH = None
+
+
+def setUpModule():
+ global OLD_SYS_PATH
+ OLD_SYS_PATH = sys.path[:]
+
+ if site.ENABLE_USER_SITE and not os.path.isdir(site.USER_SITE):
+ # need to add user site directory for tests
+ try:
+ os.makedirs(site.USER_SITE)
+ # modify sys.path: will be restored by tearDownModule()
+ site.addsitedir(site.USER_SITE)
+ except OSError as exc:
+ if exc.errno in (errno.EACCES, errno.EPERM):
+ raise unittest.SkipTest('unable to create user site directory (%r): %s'
+ % (site.USER_SITE, exc))
+ else:
+ raise
+
+
+def tearDownModule():
+ sys.path[:] = OLD_SYS_PATH
class HelperFunctionsTests(unittest.TestCase):
"""
if not hasattr(socket, "AF_TIPC"):
return False
- if not os.path.isfile("/proc/modules"):
- return False
- with open("/proc/modules") as f:
+ try:
+ f = open("/proc/modules")
+ except IOError as e:
+ # It's ok if the file does not exist, is a directory or if we
+ # have not the permission to read it. In any other case it's a
+ # real error, so raise it again.
+ if e.errno in (errno.ENOENT, errno.EISDIR, errno.EACCES):
+ return False
+ else:
+ raise
+ with f:
for line in f:
if line.startswith("tipc "):
return True
ctx.options = (ctx.options & ~ssl.OP_NO_TLSv1)
self.assertEqual(default, ctx.options)
ctx.options = 0
- self.assertEqual(0, ctx.options)
+ # Ubuntu has OP_NO_SSLv3 forced on by default
+ self.assertEqual(0, ctx.options & ~ssl.OP_NO_SSLv3)
else:
with self.assertRaises(ValueError):
ctx.options = 0
self.join()
if support.verbose:
sys.stdout.write(" cleanup: successfully joined.\n")
+ # make sure that ConnectionHandler is removed from socket_map
+ asyncore.close_all(ignore_all=True)
def start(self, flag=None):
self.flag = flag
except ssl.SSLError as e:
stats = e
- if expected is None and IS_OPENSSL_1_1:
- # OpenSSL 1.1.0 raises handshake error
+ if (expected is None and IS_OPENSSL_1_1
+ and ssl.OPENSSL_VERSION_INFO < (1, 1, 0, 6)):
+ # OpenSSL 1.1.0 to 1.1.0e raises handshake error
self.assertIsInstance(stats, ssl.SSLError)
else:
msg = "failed trying %s (s) and %s (c).\n" \
import unittest
from test import test_support
import os
+import sys
from os import path
-from time import sleep
startfile = test_support.get_attribute(os, 'startfile')
def test_nonexisting_u(self):
self.assertRaises(OSError, startfile, u"nonexisting.vbs")
+ def check_empty(self, empty):
+ # We need to make sure the child process starts in a directory
+ # we're not about to delete. If we're running under -j, that
+ # means the test harness provided directory isn't a safe option.
+ # See http://bugs.python.org/issue15526 for more details
+ with test_support.change_cwd(path.dirname(sys.executable)):
+ startfile(empty)
+ startfile(empty, "open")
+
def test_empty(self):
empty = path.join(path.dirname(__file__), "empty.vbs")
- startfile(empty)
- startfile(empty, "open")
- # Give the child process some time to exit before we finish.
- # Otherwise the cleanup code will not be able to delete the cwd,
- # because it is still in use.
- sleep(0.1)
-
- def test_empty_u(self):
+ self.check_empty(empty)
+
+ def test_empty_unicode(self):
empty = path.join(path.dirname(__file__), "empty.vbs")
- startfile(unicode(empty, "mbcs"))
- startfile(unicode(empty, "mbcs"), "open")
- sleep(0.1)
+ empty = unicode(empty, "mbcs")
+ self.check_empty(empty)
def test_main():
test_support.run_unittest(TestCase)
self.assertIn('str', exc)
self.assertIn('tuple', exc)
+ def test_issue28598_strsubclass_rhs(self):
+ # A subclass of str with an __rmod__ method should be able to hook
+ # into the % operator
+ class SubclassedStr(str):
+ def __rmod__(self, other):
+ return 'Success, self.__rmod__({!r}) was called'.format(other)
+ self.assertEqual('lhs %% %r' % SubclassedStr('rhs'),
+ "Success, self.__rmod__('lhs %% %r') was called")
+
def test_main():
test_support.run_unittest(StrTest)
from test import test_support
import subprocess
import sys
+import platform
import signal
import os
import errno
import time
import re
import sysconfig
+import textwrap
+
+try:
+ import ctypes
+except ImportError:
+ ctypes = None
+else:
+ import ctypes.util
try:
import resource
except ImportError:
threading = None
+try:
+ import _testcapi
+except ImportError:
+ _testcapi = None
+
mswindows = (sys.platform == "win32")
#
inst.wait()
subprocess._cleanup()
self.assertFalse(subprocess._active, "subprocess._active not empty")
+ self.doCleanups()
+ test_support.reap_children()
def assertStderrEqual(self, stderr, expected, msg=None):
# In a debug build, stuff like "[6580 refs]" is printed to stderr at
self.addCleanup(p.stdout.close)
self.assertEqual(p.stdout.read(), "orange")
+ def test_invalid_cmd(self):
+ # null character in the command name
+ cmd = sys.executable + '\0'
+ with self.assertRaises(TypeError):
+ subprocess.Popen([cmd, "-c", "pass"])
+
+ # null character in the command argument
+ with self.assertRaises(TypeError):
+ subprocess.Popen([sys.executable, "-c", "pass#\0"])
+
+ def test_invalid_env(self):
+ # null character in the enviroment variable name
+ newenv = os.environ.copy()
+ newenv["FRUIT\0VEGETABLE"] = "cabbage"
+ with self.assertRaises(TypeError):
+ subprocess.Popen([sys.executable, "-c", "pass"], env=newenv)
+
+ # null character in the enviroment variable value
+ newenv = os.environ.copy()
+ newenv["FRUIT"] = "orange\0VEGETABLE=cabbage"
+ with self.assertRaises(TypeError):
+ subprocess.Popen([sys.executable, "-c", "pass"], env=newenv)
+
+ # equal character in the enviroment variable name
+ newenv = os.environ.copy()
+ newenv["FRUIT=ORANGE"] = "lemon"
+ with self.assertRaises(ValueError):
+ subprocess.Popen([sys.executable, "-c", "pass"], env=newenv)
+
+ # equal character in the enviroment variable value
+ newenv = os.environ.copy()
+ newenv["FRUIT"] = "orange=lemon"
+ p = subprocess.Popen([sys.executable, "-c",
+ 'import sys, os;'
+ 'sys.stdout.write(os.getenv("FRUIT"))'],
+ stdout=subprocess.PIPE,
+ env=newenv)
+ stdout, stderr = p.communicate()
+ self.assertEqual(stdout, "orange=lemon")
+
def test_communicate_stdin(self):
p = subprocess.Popen([sys.executable, "-c",
'import sys;'
self.assertEqual(p2.returncode, 0, "Unexpected error: " + repr(stderr))
+ @unittest.skipUnless(_testcapi is not None
+ and hasattr(_testcapi, 'W_STOPCODE'),
+ 'need _testcapi.W_STOPCODE')
+ def test_stopped(self):
+ """Test wait() behavior when waitpid returns WIFSTOPPED; issue29335."""
+ args = [sys.executable, '-c', 'pass']
+ proc = subprocess.Popen(args)
+
+ # Wait until the real process completes to avoid zombie process
+ pid = proc.pid
+ pid, status = os.waitpid(pid, 0)
+ self.assertEqual(status, 0)
+
+ status = _testcapi.W_STOPCODE(3)
+
+ def mock_waitpid(pid, flags):
+ return (pid, status)
+
+ with test_support.swap_attr(os, 'waitpid', mock_waitpid):
+ returncode = proc.wait()
+
+ self.assertEqual(returncode, -3)
+
@unittest.skipUnless(mswindows, "Windows specific tests")
class Win32ProcessTestCase(BaseTestCase):
-"""Supporting definitions for the Python regression tests."""
-
-if __name__ != 'test.test_support':
- raise ImportError('test_support must be imported from the test package')
-
-import contextlib
-import errno
-import functools
-import gc
-import socket
-import stat
import sys
-import os
-import platform
-import shutil
-import warnings
-import unittest
-import importlib
-import UserDict
-import re
-import time
-import struct
-import sysconfig
-try:
- import thread
-except ImportError:
- thread = None
-
-__all__ = ["Error", "TestFailed", "ResourceDenied", "import_module",
- "verbose", "use_resources", "max_memuse", "record_original_stdout",
- "get_original_stdout", "unload", "unlink", "rmtree", "forget",
- "is_resource_enabled", "requires", "requires_mac_ver",
- "find_unused_port", "bind_port",
- "fcmp", "have_unicode", "is_jython", "TESTFN", "HOST", "FUZZ",
- "SAVEDCWD", "temp_cwd", "findfile", "sortdict", "check_syntax_error",
- "open_urlresource", "check_warnings", "check_py3k_warnings",
- "CleanImport", "EnvironmentVarGuard", "captured_output",
- "captured_stdout", "TransientResource", "transient_internet",
- "run_with_locale", "set_memlimit", "bigmemtest", "bigaddrspacetest",
- "BasicTestRunner", "run_unittest", "run_doctest", "threading_setup",
- "threading_cleanup", "reap_threads", "start_threads", "cpython_only",
- "check_impl_detail", "get_attribute", "py3k_bytes",
- "import_fresh_module", "threading_cleanup", "reap_children",
- "strip_python_stderr", "IPV6_ENABLED", "run_with_tz"]
-
-class Error(Exception):
- """Base class for regression test exceptions."""
-
-class TestFailed(Error):
- """Test failed."""
-
-class ResourceDenied(unittest.SkipTest):
- """Test skipped because it requested a disallowed resource.
-
- This is raised when a test calls requires() for a resource that
- has not been enabled. It is used to distinguish between expected
- and unexpected skips.
- """
-
-@contextlib.contextmanager
-def _ignore_deprecated_imports(ignore=True):
- """Context manager to suppress package and module deprecation
- warnings when importing them.
-
- If ignore is False, this context manager has no effect."""
- if ignore:
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore", ".+ (module|package)",
- DeprecationWarning)
- yield
- else:
- yield
-
-
-def import_module(name, deprecated=False):
- """Import and return the module to be tested, raising SkipTest if
- it is not available.
-
- If deprecated is True, any module or package deprecation messages
- will be suppressed."""
- with _ignore_deprecated_imports(deprecated):
- try:
- return importlib.import_module(name)
- except ImportError, msg:
- raise unittest.SkipTest(str(msg))
-
-
-def _save_and_remove_module(name, orig_modules):
- """Helper function to save and remove a module from sys.modules
-
- Raise ImportError if the module can't be imported."""
- # try to import the module and raise an error if it can't be imported
- if name not in sys.modules:
- __import__(name)
- del sys.modules[name]
- for modname in list(sys.modules):
- if modname == name or modname.startswith(name + '.'):
- orig_modules[modname] = sys.modules[modname]
- del sys.modules[modname]
-
-def _save_and_block_module(name, orig_modules):
- """Helper function to save and block a module in sys.modules
-
- Return True if the module was in sys.modules, False otherwise."""
- saved = True
- try:
- orig_modules[name] = sys.modules[name]
- except KeyError:
- saved = False
- sys.modules[name] = None
- return saved
-
-
-def import_fresh_module(name, fresh=(), blocked=(), deprecated=False):
- """Imports and returns a module, deliberately bypassing the sys.modules cache
- and importing a fresh copy of the module. Once the import is complete,
- the sys.modules cache is restored to its original state.
-
- Modules named in fresh are also imported anew if needed by the import.
- If one of these modules can't be imported, None is returned.
-
- Importing of modules named in blocked is prevented while the fresh import
- takes place.
-
- If deprecated is True, any module or package deprecation messages
- will be suppressed."""
- # NOTE: test_heapq, test_json, and test_warnings include extra sanity
- # checks to make sure that this utility function is working as expected
- with _ignore_deprecated_imports(deprecated):
- # Keep track of modules saved for later restoration as well
- # as those which just need a blocking entry removed
- orig_modules = {}
- names_to_remove = []
- _save_and_remove_module(name, orig_modules)
- try:
- for fresh_name in fresh:
- _save_and_remove_module(fresh_name, orig_modules)
- for blocked_name in blocked:
- if not _save_and_block_module(blocked_name, orig_modules):
- names_to_remove.append(blocked_name)
- fresh_module = importlib.import_module(name)
- except ImportError:
- fresh_module = None
- finally:
- for orig_name, module in orig_modules.items():
- sys.modules[orig_name] = module
- for name_to_remove in names_to_remove:
- del sys.modules[name_to_remove]
- return fresh_module
-
-
-def get_attribute(obj, name):
- """Get an attribute, raising SkipTest if AttributeError is raised."""
- try:
- attribute = getattr(obj, name)
- except AttributeError:
- raise unittest.SkipTest("module %s has no attribute %s" % (
- obj.__name__, name))
- else:
- return attribute
-
-
-verbose = 1 # Flag set to 0 by regrtest.py
-use_resources = None # Flag set to [] by regrtest.py
-max_memuse = 0 # Disable bigmem tests (they will still be run with
- # small sizes, to make sure they work.)
-real_max_memuse = 0
-
-# _original_stdout is meant to hold stdout at the time regrtest began.
-# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
-# The point is to have some flavor of stdout the user can actually see.
-_original_stdout = None
-def record_original_stdout(stdout):
- global _original_stdout
- _original_stdout = stdout
-
-def get_original_stdout():
- return _original_stdout or sys.stdout
-
-def unload(name):
- try:
- del sys.modules[name]
- except KeyError:
- pass
-
-def _force_run(path, func, *args):
- try:
- return func(*args)
- except EnvironmentError as err:
- if verbose >= 2:
- print('%s: %s' % (err.__class__.__name__, err))
- print('re-run %s%r' % (func.__name__, args))
- os.chmod(path, stat.S_IRWXU)
- return func(*args)
-
-if sys.platform.startswith("win"):
- def _waitfor(func, pathname, waitall=False):
- # Perform the operation
- func(pathname)
- # Now setup the wait loop
- if waitall:
- dirname = pathname
- else:
- dirname, name = os.path.split(pathname)
- dirname = dirname or '.'
- # Check for `pathname` to be removed from the filesystem.
- # The exponential backoff of the timeout amounts to a total
- # of ~1 second after which the deletion is probably an error
- # anyway.
- # Testing on an i7@4.3GHz shows that usually only 1 iteration is
- # required when contention occurs.
- timeout = 0.001
- while timeout < 1.0:
- # Note we are only testing for the existence of the file(s) in
- # the contents of the directory regardless of any security or
- # access rights. If we have made it this far, we have sufficient
- # permissions to do that much using Python's equivalent of the
- # Windows API FindFirstFile.
- # Other Windows APIs can fail or give incorrect results when
- # dealing with files that are pending deletion.
- L = os.listdir(dirname)
- if not (L if waitall else name in L):
- return
- # Increase the timeout and try again
- time.sleep(timeout)
- timeout *= 2
- warnings.warn('tests may fail, delete still pending for ' + pathname,
- RuntimeWarning, stacklevel=4)
-
- def _unlink(filename):
- _waitfor(os.unlink, filename)
-
- def _rmdir(dirname):
- _waitfor(os.rmdir, dirname)
-
- def _rmtree(path):
- def _rmtree_inner(path):
- for name in _force_run(path, os.listdir, path):
- fullname = os.path.join(path, name)
- if os.path.isdir(fullname):
- _waitfor(_rmtree_inner, fullname, waitall=True)
- _force_run(fullname, os.rmdir, fullname)
- else:
- _force_run(fullname, os.unlink, fullname)
- _waitfor(_rmtree_inner, path, waitall=True)
- _waitfor(lambda p: _force_run(p, os.rmdir, p), path)
-else:
- _unlink = os.unlink
- _rmdir = os.rmdir
-
- def _rmtree(path):
- try:
- shutil.rmtree(path)
- return
- except EnvironmentError:
- pass
-
- def _rmtree_inner(path):
- for name in _force_run(path, os.listdir, path):
- fullname = os.path.join(path, name)
- try:
- mode = os.lstat(fullname).st_mode
- except EnvironmentError:
- mode = 0
- if stat.S_ISDIR(mode):
- _rmtree_inner(fullname)
- _force_run(path, os.rmdir, fullname)
- else:
- _force_run(path, os.unlink, fullname)
- _rmtree_inner(path)
- os.rmdir(path)
-
-def unlink(filename):
- try:
- _unlink(filename)
- except OSError:
- pass
-
-def rmdir(dirname):
- try:
- _rmdir(dirname)
- except OSError as error:
- # The directory need not exist.
- if error.errno != errno.ENOENT:
- raise
-
-def rmtree(path):
- try:
- _rmtree(path)
- except OSError, e:
- # Unix returns ENOENT, Windows returns ESRCH.
- if e.errno not in (errno.ENOENT, errno.ESRCH):
- raise
-
-def forget(modname):
- '''"Forget" a module was ever imported by removing it from sys.modules and
- deleting any .pyc and .pyo files.'''
- unload(modname)
- for dirname in sys.path:
- unlink(os.path.join(dirname, modname + os.extsep + 'pyc'))
- # Deleting the .pyo file cannot be within the 'try' for the .pyc since
- # the chance exists that there is no .pyc (and thus the 'try' statement
- # is exited) but there is a .pyo file.
- unlink(os.path.join(dirname, modname + os.extsep + 'pyo'))
-
-# Check whether a gui is actually available
-def _is_gui_available():
- if hasattr(_is_gui_available, 'result'):
- return _is_gui_available.result
- reason = None
- if sys.platform.startswith('win'):
- # if Python is running as a service (such as the buildbot service),
- # gui interaction may be disallowed
- import ctypes
- import ctypes.wintypes
- UOI_FLAGS = 1
- WSF_VISIBLE = 0x0001
- class USEROBJECTFLAGS(ctypes.Structure):
- _fields_ = [("fInherit", ctypes.wintypes.BOOL),
- ("fReserved", ctypes.wintypes.BOOL),
- ("dwFlags", ctypes.wintypes.DWORD)]
- dll = ctypes.windll.user32
- h = dll.GetProcessWindowStation()
- if not h:
- raise ctypes.WinError()
- uof = USEROBJECTFLAGS()
- needed = ctypes.wintypes.DWORD()
- res = dll.GetUserObjectInformationW(h,
- UOI_FLAGS,
- ctypes.byref(uof),
- ctypes.sizeof(uof),
- ctypes.byref(needed))
- if not res:
- raise ctypes.WinError()
- if not bool(uof.dwFlags & WSF_VISIBLE):
- reason = "gui not available (WSF_VISIBLE flag not set)"
- elif sys.platform == 'darwin':
- # The Aqua Tk implementations on OS X can abort the process if
- # being called in an environment where a window server connection
- # cannot be made, for instance when invoked by a buildbot or ssh
- # process not running under the same user id as the current console
- # user. To avoid that, raise an exception if the window manager
- # connection is not available.
- from ctypes import cdll, c_int, pointer, Structure
- from ctypes.util import find_library
-
- app_services = cdll.LoadLibrary(find_library("ApplicationServices"))
-
- if app_services.CGMainDisplayID() == 0:
- reason = "gui tests cannot run without OS X window manager"
- else:
- class ProcessSerialNumber(Structure):
- _fields_ = [("highLongOfPSN", c_int),
- ("lowLongOfPSN", c_int)]
- psn = ProcessSerialNumber()
- psn_p = pointer(psn)
- if ( (app_services.GetCurrentProcess(psn_p) < 0) or
- (app_services.SetFrontProcess(psn_p) < 0) ):
- reason = "cannot run without OS X gui process"
-
- # check on every platform whether tkinter can actually do anything
- if not reason:
- try:
- from Tkinter import Tk
- root = Tk()
- root.withdraw()
- root.update()
- root.destroy()
- except Exception as e:
- err_string = str(e)
- if len(err_string) > 50:
- err_string = err_string[:50] + ' [...]'
- reason = 'Tk unavailable due to {}: {}'.format(type(e).__name__,
- err_string)
-
- _is_gui_available.reason = reason
- _is_gui_available.result = not reason
-
- return _is_gui_available.result
-
-def is_resource_enabled(resource):
- """Test whether a resource is enabled.
-
- Known resources are set by regrtest.py. If not running under regrtest.py,
- all resources are assumed enabled unless use_resources has been set.
- """
- return use_resources is None or resource in use_resources
-
-def requires(resource, msg=None):
- """Raise ResourceDenied if the specified resource is not available."""
- if not is_resource_enabled(resource):
- if msg is None:
- msg = "Use of the `%s' resource not enabled" % resource
- raise ResourceDenied(msg)
- if resource == 'gui' and not _is_gui_available():
- raise ResourceDenied(_is_gui_available.reason)
-
-def requires_mac_ver(*min_version):
- """Decorator raising SkipTest if the OS is Mac OS X and the OS X
- version if less than min_version.
-
- For example, @requires_mac_ver(10, 5) raises SkipTest if the OS X version
- is lesser than 10.5.
- """
- def decorator(func):
- @functools.wraps(func)
- def wrapper(*args, **kw):
- if sys.platform == 'darwin':
- version_txt = platform.mac_ver()[0]
- try:
- version = tuple(map(int, version_txt.split('.')))
- except ValueError:
- pass
- else:
- if version < min_version:
- min_version_txt = '.'.join(map(str, min_version))
- raise unittest.SkipTest(
- "Mac OS X %s or higher required, not %s"
- % (min_version_txt, version_txt))
- return func(*args, **kw)
- wrapper.min_version = min_version
- return wrapper
- return decorator
-
-
-# Don't use "localhost", since resolving it uses the DNS under recent
-# Windows versions (see issue #18792).
-HOST = "127.0.0.1"
-HOSTv6 = "::1"
-
-
-def find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM):
- """Returns an unused port that should be suitable for binding. This is
- achieved by creating a temporary socket with the same family and type as
- the 'sock' parameter (default is AF_INET, SOCK_STREAM), and binding it to
- the specified host address (defaults to 0.0.0.0) with the port set to 0,
- eliciting an unused ephemeral port from the OS. The temporary socket is
- then closed and deleted, and the ephemeral port is returned.
-
- Either this method or bind_port() should be used for any tests where a
- server socket needs to be bound to a particular port for the duration of
- the test. Which one to use depends on whether the calling code is creating
- a python socket, or if an unused port needs to be provided in a constructor
- or passed to an external program (i.e. the -accept argument to openssl's
- s_server mode). Always prefer bind_port() over find_unused_port() where
- possible. Hard coded ports should *NEVER* be used. As soon as a server
- socket is bound to a hard coded port, the ability to run multiple instances
- of the test simultaneously on the same host is compromised, which makes the
- test a ticking time bomb in a buildbot environment. On Unix buildbots, this
- may simply manifest as a failed test, which can be recovered from without
- intervention in most cases, but on Windows, the entire python process can
- completely and utterly wedge, requiring someone to log in to the buildbot
- and manually kill the affected process.
-
- (This is easy to reproduce on Windows, unfortunately, and can be traced to
- the SO_REUSEADDR socket option having different semantics on Windows versus
- Unix/Linux. On Unix, you can't have two AF_INET SOCK_STREAM sockets bind,
- listen and then accept connections on identical host/ports. An EADDRINUSE
- socket.error will be raised at some point (depending on the platform and
- the order bind and listen were called on each socket).
-
- However, on Windows, if SO_REUSEADDR is set on the sockets, no EADDRINUSE
- will ever be raised when attempting to bind two identical host/ports. When
- accept() is called on each socket, the second caller's process will steal
- the port from the first caller, leaving them both in an awkwardly wedged
- state where they'll no longer respond to any signals or graceful kills, and
- must be forcibly killed via OpenProcess()/TerminateProcess().
-
- The solution on Windows is to use the SO_EXCLUSIVEADDRUSE socket option
- instead of SO_REUSEADDR, which effectively affords the same semantics as
- SO_REUSEADDR on Unix. Given the propensity of Unix developers in the Open
- Source world compared to Windows ones, this is a common mistake. A quick
- look over OpenSSL's 0.9.8g source shows that they use SO_REUSEADDR when
- openssl.exe is called with the 's_server' option, for example. See
- http://bugs.python.org/issue2550 for more info. The following site also
- has a very thorough description about the implications of both REUSEADDR
- and EXCLUSIVEADDRUSE on Windows:
- http://msdn2.microsoft.com/en-us/library/ms740621(VS.85).aspx)
-
- XXX: although this approach is a vast improvement on previous attempts to
- elicit unused ports, it rests heavily on the assumption that the ephemeral
- port returned to us by the OS won't immediately be dished back out to some
- other process when we close and delete our temporary socket but before our
- calling code has a chance to bind the returned port. We can deal with this
- issue if/when we come across it."""
- tempsock = socket.socket(family, socktype)
- port = bind_port(tempsock)
- tempsock.close()
- del tempsock
- return port
-
-def bind_port(sock, host=HOST):
- """Bind the socket to a free port and return the port number. Relies on
- ephemeral ports in order to ensure we are using an unbound port. This is
- important as many tests may be running simultaneously, especially in a
- buildbot environment. This method raises an exception if the sock.family
- is AF_INET and sock.type is SOCK_STREAM, *and* the socket has SO_REUSEADDR
- or SO_REUSEPORT set on it. Tests should *never* set these socket options
- for TCP/IP sockets. The only case for setting these options is testing
- multicasting via multiple UDP sockets.
-
- Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e.
- on Windows), it will be set on the socket. This will prevent anyone else
- from bind()'ing to our host/port for the duration of the test.
- """
- if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM:
- if hasattr(socket, 'SO_REUSEADDR'):
- if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1:
- raise TestFailed("tests should never set the SO_REUSEADDR " \
- "socket option on TCP/IP sockets!")
- if hasattr(socket, 'SO_REUSEPORT'):
- try:
- if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1:
- raise TestFailed("tests should never set the SO_REUSEPORT " \
- "socket option on TCP/IP sockets!")
- except EnvironmentError:
- # Python's socket module was compiled using modern headers
- # thus defining SO_REUSEPORT but this process is running
- # under an older kernel that does not support SO_REUSEPORT.
- pass
- if hasattr(socket, 'SO_EXCLUSIVEADDRUSE'):
- sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
-
- sock.bind((host, 0))
- port = sock.getsockname()[1]
- return port
-
-def _is_ipv6_enabled():
- """Check whether IPv6 is enabled on this host."""
- if socket.has_ipv6:
- sock = None
- try:
- sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
- sock.bind((HOSTv6, 0))
- return True
- except socket.error:
- pass
- finally:
- if sock:
- sock.close()
- return False
-
-IPV6_ENABLED = _is_ipv6_enabled()
-
-def system_must_validate_cert(f):
- """Skip the test on TLS certificate validation failures."""
- @functools.wraps(f)
- def dec(*args, **kwargs):
- try:
- f(*args, **kwargs)
- except IOError as e:
- if "CERTIFICATE_VERIFY_FAILED" in str(e):
- raise unittest.SkipTest("system does not contain "
- "necessary certificates")
- raise
- return dec
-
-FUZZ = 1e-6
-
-def fcmp(x, y): # fuzzy comparison function
- if isinstance(x, float) or isinstance(y, float):
- try:
- fuzz = (abs(x) + abs(y)) * FUZZ
- if abs(x-y) <= fuzz:
- return 0
- except:
- pass
- elif type(x) == type(y) and isinstance(x, (tuple, list)):
- for i in range(min(len(x), len(y))):
- outcome = fcmp(x[i], y[i])
- if outcome != 0:
- return outcome
- return (len(x) > len(y)) - (len(x) < len(y))
- return (x > y) - (x < y)
-
-
-# A constant likely larger than the underlying OS pipe buffer size, to
-# make writes blocking.
-# Windows limit seems to be around 512 B, and many Unix kernels have a
-# 64 KiB pipe buffer size or 16 * PAGE_SIZE: take a few megs to be sure.
-# (see issue #17835 for a discussion of this number).
-PIPE_MAX_SIZE = 4 * 1024 * 1024 + 1
-
-# A constant likely larger than the underlying OS socket buffer size, to make
-# writes blocking.
-# The socket buffer sizes can usually be tuned system-wide (e.g. through sysctl
-# on Linux), or on a per-socket basis (SO_SNDBUF/SO_RCVBUF). See issue #18643
-# for a discussion of this number).
-SOCK_MAX_SIZE = 16 * 1024 * 1024 + 1
-
-is_jython = sys.platform.startswith('java')
-
-try:
- unicode
- have_unicode = True
-except NameError:
- have_unicode = False
-
-requires_unicode = unittest.skipUnless(have_unicode, 'no unicode support')
-
-def u(s):
- return unicode(s, 'unicode-escape')
-
-# FS_NONASCII: non-ASCII Unicode character encodable by
-# sys.getfilesystemencoding(), or None if there is no such character.
-FS_NONASCII = None
-if have_unicode:
- for character in (
- # First try printable and common characters to have a readable filename.
- # For each character, the encoding list are just example of encodings able
- # to encode the character (the list is not exhaustive).
-
- # U+00E6 (Latin Small Letter Ae): cp1252, iso-8859-1
- unichr(0x00E6),
- # U+0130 (Latin Capital Letter I With Dot Above): cp1254, iso8859_3
- unichr(0x0130),
- # U+0141 (Latin Capital Letter L With Stroke): cp1250, cp1257
- unichr(0x0141),
- # U+03C6 (Greek Small Letter Phi): cp1253
- unichr(0x03C6),
- # U+041A (Cyrillic Capital Letter Ka): cp1251
- unichr(0x041A),
- # U+05D0 (Hebrew Letter Alef): Encodable to cp424
- unichr(0x05D0),
- # U+060C (Arabic Comma): cp864, cp1006, iso8859_6, mac_arabic
- unichr(0x060C),
- # U+062A (Arabic Letter Teh): cp720
- unichr(0x062A),
- # U+0E01 (Thai Character Ko Kai): cp874
- unichr(0x0E01),
-
- # Then try more "special" characters. "special" because they may be
- # interpreted or displayed differently depending on the exact locale
- # encoding and the font.
-
- # U+00A0 (No-Break Space)
- unichr(0x00A0),
- # U+20AC (Euro Sign)
- unichr(0x20AC),
- ):
- try:
- character.encode(sys.getfilesystemencoding())\
- .decode(sys.getfilesystemencoding())
- except UnicodeError:
- pass
- else:
- FS_NONASCII = character
- break
-
-# Filename used for testing
-if os.name == 'java':
- # Jython disallows @ in module names
- TESTFN = '$test'
-elif os.name == 'riscos':
- TESTFN = 'testfile'
-else:
- TESTFN = '@test'
- # Unicode name only used if TEST_FN_ENCODING exists for the platform.
- if have_unicode:
- # Assuming sys.getfilesystemencoding()!=sys.getdefaultencoding()
- # TESTFN_UNICODE is a filename that can be encoded using the
- # file system encoding, but *not* with the default (ascii) encoding
- if isinstance('', unicode):
- # python -U
- # XXX perhaps unicode() should accept Unicode strings?
- TESTFN_UNICODE = "@test-\xe0\xf2"
- else:
- # 2 latin characters.
- TESTFN_UNICODE = unicode("@test-\xe0\xf2", "latin-1")
- TESTFN_ENCODING = sys.getfilesystemencoding()
- # TESTFN_UNENCODABLE is a filename that should *not* be
- # able to be encoded by *either* the default or filesystem encoding.
- # This test really only makes sense on Windows NT platforms
- # which have special Unicode support in posixmodule.
- if (not hasattr(sys, "getwindowsversion") or
- sys.getwindowsversion()[3] < 2): # 0=win32s or 1=9x/ME
- TESTFN_UNENCODABLE = None
- else:
- # Japanese characters (I think - from bug 846133)
- TESTFN_UNENCODABLE = eval('u"@test-\u5171\u6709\u3055\u308c\u308b"')
- try:
- # XXX - Note - should be using TESTFN_ENCODING here - but for
- # Windows, "mbcs" currently always operates as if in
- # errors=ignore' mode - hence we get '?' characters rather than
- # the exception. 'Latin1' operates as we expect - ie, fails.
- # See [ 850997 ] mbcs encoding ignores errors
- TESTFN_UNENCODABLE.encode("Latin1")
- except UnicodeEncodeError:
- pass
- else:
- print \
- 'WARNING: The filename %r CAN be encoded by the filesystem. ' \
- 'Unicode filename tests may not be effective' \
- % TESTFN_UNENCODABLE
-
-
-# Disambiguate TESTFN for parallel testing, while letting it remain a valid
-# module name.
-TESTFN = "{}_{}_tmp".format(TESTFN, os.getpid())
-
-# Save the initial cwd
-SAVEDCWD = os.getcwd()
-
-@contextlib.contextmanager
-def change_cwd(path, quiet=False):
- """Return a context manager that changes the current working directory.
-
- Arguments:
-
- path: the directory to use as the temporary current working directory.
-
- quiet: if False (the default), the context manager raises an exception
- on error. Otherwise, it issues only a warning and keeps the current
- working directory the same.
-
- """
- saved_dir = os.getcwd()
- try:
- os.chdir(path)
- except OSError:
- if not quiet:
- raise
- warnings.warn('tests may fail, unable to change CWD to: ' + path,
- RuntimeWarning, stacklevel=3)
- try:
- yield os.getcwd()
- finally:
- os.chdir(saved_dir)
-
-
-@contextlib.contextmanager
-def temp_cwd(name='tempcwd', quiet=False):
- """
- Context manager that creates a temporary directory and set it as CWD.
-
- The new CWD is created in the current directory and it's named *name*.
- If *quiet* is False (default) and it's not possible to create or change
- the CWD, an error is raised. If it's True, only a warning is raised
- and the original CWD is used.
- """
- if (have_unicode and isinstance(name, unicode) and
- not os.path.supports_unicode_filenames):
- try:
- name = name.encode(sys.getfilesystemencoding() or 'ascii')
- except UnicodeEncodeError:
- if not quiet:
- raise unittest.SkipTest('unable to encode the cwd name with '
- 'the filesystem encoding.')
- saved_dir = os.getcwd()
- is_temporary = False
- try:
- os.mkdir(name)
- os.chdir(name)
- is_temporary = True
- except OSError:
- if not quiet:
- raise
- warnings.warn('tests may fail, unable to change the CWD to ' + name,
- RuntimeWarning, stacklevel=3)
- try:
- yield os.getcwd()
- finally:
- os.chdir(saved_dir)
- if is_temporary:
- rmtree(name)
-
-
-def findfile(file, here=__file__, subdir=None):
- """Try to find a file on sys.path and the working directory. If it is not
- found the argument passed to the function is returned (this does not
- necessarily signal failure; could still be the legitimate path)."""
- if os.path.isabs(file):
- return file
- if subdir is not None:
- file = os.path.join(subdir, file)
- path = sys.path
- path = [os.path.dirname(here)] + path
- for dn in path:
- fn = os.path.join(dn, file)
- if os.path.exists(fn): return fn
- return file
-
-def sortdict(dict):
- "Like repr(dict), but in sorted order."
- items = dict.items()
- items.sort()
- reprpairs = ["%r: %r" % pair for pair in items]
- withcommas = ", ".join(reprpairs)
- return "{%s}" % withcommas
-
-def make_bad_fd():
- """
- Create an invalid file descriptor by opening and closing a file and return
- its fd.
- """
- file = open(TESTFN, "wb")
- try:
- return file.fileno()
- finally:
- file.close()
- unlink(TESTFN)
-
-def check_syntax_error(testcase, statement):
- testcase.assertRaises(SyntaxError, compile, statement,
- '<test string>', 'exec')
-
-def open_urlresource(url, check=None):
- import urlparse, urllib2
-
- filename = urlparse.urlparse(url)[2].split('/')[-1] # '/': it's URL!
-
- fn = os.path.join(os.path.dirname(__file__), "data", filename)
-
- def check_valid_file(fn):
- f = open(fn)
- if check is None:
- return f
- elif check(f):
- f.seek(0)
- return f
- f.close()
-
- if os.path.exists(fn):
- f = check_valid_file(fn)
- if f is not None:
- return f
- unlink(fn)
-
- # Verify the requirement before downloading the file
- requires('urlfetch')
-
- print >> get_original_stdout(), '\tfetching %s ...' % url
- f = urllib2.urlopen(url, timeout=15)
- try:
- with open(fn, "wb") as out:
- s = f.read()
- while s:
- out.write(s)
- s = f.read()
- finally:
- f.close()
-
- f = check_valid_file(fn)
- if f is not None:
- return f
- raise TestFailed('invalid resource "%s"' % fn)
-
-
-class WarningsRecorder(object):
- """Convenience wrapper for the warnings list returned on
- entry to the warnings.catch_warnings() context manager.
- """
- def __init__(self, warnings_list):
- self._warnings = warnings_list
- self._last = 0
-
- def __getattr__(self, attr):
- if len(self._warnings) > self._last:
- return getattr(self._warnings[-1], attr)
- elif attr in warnings.WarningMessage._WARNING_DETAILS:
- return None
- raise AttributeError("%r has no attribute %r" % (self, attr))
-
- @property
- def warnings(self):
- return self._warnings[self._last:]
-
- def reset(self):
- self._last = len(self._warnings)
-
-
-def _filterwarnings(filters, quiet=False):
- """Catch the warnings, then check if all the expected
- warnings have been raised and re-raise unexpected warnings.
- If 'quiet' is True, only re-raise the unexpected warnings.
- """
- # Clear the warning registry of the calling module
- # in order to re-raise the warnings.
- frame = sys._getframe(2)
- registry = frame.f_globals.get('__warningregistry__')
- if registry:
- registry.clear()
- with warnings.catch_warnings(record=True) as w:
- # Set filter "always" to record all warnings. Because
- # test_warnings swap the module, we need to look up in
- # the sys.modules dictionary.
- sys.modules['warnings'].simplefilter("always")
- yield WarningsRecorder(w)
- # Filter the recorded warnings
- reraise = [warning.message for warning in w]
- missing = []
- for msg, cat in filters:
- seen = False
- for exc in reraise[:]:
- message = str(exc)
- # Filter out the matching messages
- if (re.match(msg, message, re.I) and
- issubclass(exc.__class__, cat)):
- seen = True
- reraise.remove(exc)
- if not seen and not quiet:
- # This filter caught nothing
- missing.append((msg, cat.__name__))
- if reraise:
- raise AssertionError("unhandled warning %r" % reraise[0])
- if missing:
- raise AssertionError("filter (%r, %s) did not catch any warning" %
- missing[0])
-
-
-@contextlib.contextmanager
-def check_warnings(*filters, **kwargs):
- """Context manager to silence warnings.
-
- Accept 2-tuples as positional arguments:
- ("message regexp", WarningCategory)
-
- Optional argument:
- - if 'quiet' is True, it does not fail if a filter catches nothing
- (default True without argument,
- default False if some filters are defined)
-
- Without argument, it defaults to:
- check_warnings(("", Warning), quiet=True)
- """
- quiet = kwargs.get('quiet')
- if not filters:
- filters = (("", Warning),)
- # Preserve backward compatibility
- if quiet is None:
- quiet = True
- return _filterwarnings(filters, quiet)
-
-
-@contextlib.contextmanager
-def check_py3k_warnings(*filters, **kwargs):
- """Context manager to silence py3k warnings.
-
- Accept 2-tuples as positional arguments:
- ("message regexp", WarningCategory)
-
- Optional argument:
- - if 'quiet' is True, it does not fail if a filter catches nothing
- (default False)
-
- Without argument, it defaults to:
- check_py3k_warnings(("", DeprecationWarning), quiet=False)
- """
- if sys.py3kwarning:
- if not filters:
- filters = (("", DeprecationWarning),)
- else:
- # It should not raise any py3k warning
- filters = ()
- return _filterwarnings(filters, kwargs.get('quiet'))
-
-
-class CleanImport(object):
- """Context manager to force import to return a new module reference.
-
- This is useful for testing module-level behaviours, such as
- the emission of a DeprecationWarning on import.
-
- Use like this:
-
- with CleanImport("foo"):
- importlib.import_module("foo") # new reference
- """
-
- def __init__(self, *module_names):
- self.original_modules = sys.modules.copy()
- for module_name in module_names:
- if module_name in sys.modules:
- module = sys.modules[module_name]
- # It is possible that module_name is just an alias for
- # another module (e.g. stub for modules renamed in 3.x).
- # In that case, we also need delete the real module to clear
- # the import cache.
- if module.__name__ != module_name:
- del sys.modules[module.__name__]
- del sys.modules[module_name]
-
- def __enter__(self):
- return self
-
- def __exit__(self, *ignore_exc):
- sys.modules.update(self.original_modules)
-
-
-class EnvironmentVarGuard(UserDict.DictMixin):
-
- """Class to help protect the environment variable properly. Can be used as
- a context manager."""
-
- def __init__(self):
- self._environ = os.environ
- self._changed = {}
-
- def __getitem__(self, envvar):
- return self._environ[envvar]
-
- def __setitem__(self, envvar, value):
- # Remember the initial value on the first access
- if envvar not in self._changed:
- self._changed[envvar] = self._environ.get(envvar)
- self._environ[envvar] = value
-
- def __delitem__(self, envvar):
- # Remember the initial value on the first access
- if envvar not in self._changed:
- self._changed[envvar] = self._environ.get(envvar)
- if envvar in self._environ:
- del self._environ[envvar]
-
- def keys(self):
- return self._environ.keys()
-
- def set(self, envvar, value):
- self[envvar] = value
-
- def unset(self, envvar):
- del self[envvar]
-
- def __enter__(self):
- return self
-
- def __exit__(self, *ignore_exc):
- for (k, v) in self._changed.items():
- if v is None:
- if k in self._environ:
- del self._environ[k]
- else:
- self._environ[k] = v
- os.environ = self._environ
-
-
-class DirsOnSysPath(object):
- """Context manager to temporarily add directories to sys.path.
-
- This makes a copy of sys.path, appends any directories given
- as positional arguments, then reverts sys.path to the copied
- settings when the context ends.
-
- Note that *all* sys.path modifications in the body of the
- context manager, including replacement of the object,
- will be reverted at the end of the block.
- """
-
- def __init__(self, *paths):
- self.original_value = sys.path[:]
- self.original_object = sys.path
- sys.path.extend(paths)
-
- def __enter__(self):
- return self
-
- def __exit__(self, *ignore_exc):
- sys.path = self.original_object
- sys.path[:] = self.original_value
-
-
-class TransientResource(object):
-
- """Raise ResourceDenied if an exception is raised while the context manager
- is in effect that matches the specified exception and attributes."""
-
- def __init__(self, exc, **kwargs):
- self.exc = exc
- self.attrs = kwargs
-
- def __enter__(self):
- return self
-
- def __exit__(self, type_=None, value=None, traceback=None):
- """If type_ is a subclass of self.exc and value has attributes matching
- self.attrs, raise ResourceDenied. Otherwise let the exception
- propagate (if any)."""
- if type_ is not None and issubclass(self.exc, type_):
- for attr, attr_value in self.attrs.iteritems():
- if not hasattr(value, attr):
- break
- if getattr(value, attr) != attr_value:
- break
- else:
- raise ResourceDenied("an optional resource is not available")
-
-
-@contextlib.contextmanager
-def transient_internet(resource_name, timeout=30.0, errnos=()):
- """Return a context manager that raises ResourceDenied when various issues
- with the Internet connection manifest themselves as exceptions."""
- default_errnos = [
- ('ECONNREFUSED', 111),
- ('ECONNRESET', 104),
- ('EHOSTUNREACH', 113),
- ('ENETUNREACH', 101),
- ('ETIMEDOUT', 110),
- ]
- default_gai_errnos = [
- ('EAI_AGAIN', -3),
- ('EAI_FAIL', -4),
- ('EAI_NONAME', -2),
- ('EAI_NODATA', -5),
- # Windows defines EAI_NODATA as 11001 but idiotic getaddrinfo()
- # implementation actually returns WSANO_DATA i.e. 11004.
- ('WSANO_DATA', 11004),
- ]
-
- denied = ResourceDenied("Resource '%s' is not available" % resource_name)
- captured_errnos = errnos
- gai_errnos = []
- if not captured_errnos:
- captured_errnos = [getattr(errno, name, num)
- for (name, num) in default_errnos]
- gai_errnos = [getattr(socket, name, num)
- for (name, num) in default_gai_errnos]
-
- def filter_error(err):
- n = getattr(err, 'errno', None)
- if (isinstance(err, socket.timeout) or
- (isinstance(err, socket.gaierror) and n in gai_errnos) or
- n in captured_errnos):
- if not verbose:
- sys.stderr.write(denied.args[0] + "\n")
- raise denied
-
- old_timeout = socket.getdefaulttimeout()
- try:
- if timeout is not None:
- socket.setdefaulttimeout(timeout)
- yield
- except IOError as err:
- # urllib can wrap original socket errors multiple times (!), we must
- # unwrap to get at the original error.
- while True:
- a = err.args
- if len(a) >= 1 and isinstance(a[0], IOError):
- err = a[0]
- # The error can also be wrapped as args[1]:
- # except socket.error as msg:
- # raise IOError('socket error', msg).with_traceback(sys.exc_info()[2])
- elif len(a) >= 2 and isinstance(a[1], IOError):
- err = a[1]
- else:
- break
- filter_error(err)
- raise
- # XXX should we catch generic exceptions and look for their
- # __cause__ or __context__?
- finally:
- socket.setdefaulttimeout(old_timeout)
-
-
-@contextlib.contextmanager
-def captured_output(stream_name):
- """Return a context manager used by captured_stdout and captured_stdin
- that temporarily replaces the sys stream *stream_name* with a StringIO."""
- import StringIO
- orig_stdout = getattr(sys, stream_name)
- setattr(sys, stream_name, StringIO.StringIO())
- try:
- yield getattr(sys, stream_name)
- finally:
- setattr(sys, stream_name, orig_stdout)
-
-def captured_stdout():
- """Capture the output of sys.stdout:
-
- with captured_stdout() as s:
- print "hello"
- self.assertEqual(s.getvalue(), "hello")
- """
- return captured_output("stdout")
-
-def captured_stderr():
- return captured_output("stderr")
-
-def captured_stdin():
- return captured_output("stdin")
-
-def gc_collect():
- """Force as many objects as possible to be collected.
-
- In non-CPython implementations of Python, this is needed because timely
- deallocation is not guaranteed by the garbage collector. (Even in CPython
- this can be the case in case of reference cycles.) This means that __del__
- methods may be called later than expected and weakrefs may remain alive for
- longer than expected. This function tries its best to force all garbage
- objects to disappear.
- """
- gc.collect()
- if is_jython:
- time.sleep(0.1)
- gc.collect()
- gc.collect()
-
-
-_header = '2P'
-if hasattr(sys, "gettotalrefcount"):
- _header = '2P' + _header
-_vheader = _header + 'P'
-
-def calcobjsize(fmt):
- return struct.calcsize(_header + fmt + '0P')
-
-def calcvobjsize(fmt):
- return struct.calcsize(_vheader + fmt + '0P')
-
-
-_TPFLAGS_HAVE_GC = 1<<14
-_TPFLAGS_HEAPTYPE = 1<<9
-
-def check_sizeof(test, o, size):
- import _testcapi
- result = sys.getsizeof(o)
- # add GC header size
- if ((type(o) == type) and (o.__flags__ & _TPFLAGS_HEAPTYPE) or\
- ((type(o) != type) and (type(o).__flags__ & _TPFLAGS_HAVE_GC))):
- size += _testcapi.SIZEOF_PYGC_HEAD
- msg = 'wrong size for %s: got %d, expected %d' \
- % (type(o), result, size)
- test.assertEqual(result, size, msg)
-
-
-#=======================================================================
-# Decorator for running a function in a different locale, correctly resetting
-# it afterwards.
-
-def run_with_locale(catstr, *locales):
- def decorator(func):
- def inner(*args, **kwds):
- try:
- import locale
- category = getattr(locale, catstr)
- orig_locale = locale.setlocale(category)
- except AttributeError:
- # if the test author gives us an invalid category string
- raise
- except:
- # cannot retrieve original locale, so do nothing
- locale = orig_locale = None
- else:
- for loc in locales:
- try:
- locale.setlocale(category, loc)
- break
- except:
- pass
-
- # now run the function, resetting the locale on exceptions
- try:
- return func(*args, **kwds)
- finally:
- if locale and orig_locale:
- locale.setlocale(category, orig_locale)
- inner.func_name = func.func_name
- inner.__doc__ = func.__doc__
- return inner
- return decorator
-
-#=======================================================================
-# Decorator for running a function in a specific timezone, correctly
-# resetting it afterwards.
-
-def run_with_tz(tz):
- def decorator(func):
- def inner(*args, **kwds):
- try:
- tzset = time.tzset
- except AttributeError:
- raise unittest.SkipTest("tzset required")
- if 'TZ' in os.environ:
- orig_tz = os.environ['TZ']
- else:
- orig_tz = None
- os.environ['TZ'] = tz
- tzset()
-
- # now run the function, resetting the tz on exceptions
- try:
- return func(*args, **kwds)
- finally:
- if orig_tz is None:
- del os.environ['TZ']
- else:
- os.environ['TZ'] = orig_tz
- time.tzset()
-
- inner.__name__ = func.__name__
- inner.__doc__ = func.__doc__
- return inner
- return decorator
-
-#=======================================================================
-# Big-memory-test support. Separate from 'resources' because memory use should be configurable.
-
-# Some handy shorthands. Note that these are used for byte-limits as well
-# as size-limits, in the various bigmem tests
-_1M = 1024*1024
-_1G = 1024 * _1M
-_2G = 2 * _1G
-_4G = 4 * _1G
-
-MAX_Py_ssize_t = sys.maxsize
-
-def set_memlimit(limit):
- global max_memuse
- global real_max_memuse
- sizes = {
- 'k': 1024,
- 'm': _1M,
- 'g': _1G,
- 't': 1024*_1G,
- }
- m = re.match(r'(\d+(\.\d+)?) (K|M|G|T)b?$', limit,
- re.IGNORECASE | re.VERBOSE)
- if m is None:
- raise ValueError('Invalid memory limit %r' % (limit,))
- memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
- real_max_memuse = memlimit
- if memlimit > MAX_Py_ssize_t:
- memlimit = MAX_Py_ssize_t
- if memlimit < _2G - 1:
- raise ValueError('Memory limit %r too low to be useful' % (limit,))
- max_memuse = memlimit
-
-def bigmemtest(minsize, memuse, overhead=5*_1M):
- """Decorator for bigmem tests.
-
- 'minsize' is the minimum useful size for the test (in arbitrary,
- test-interpreted units.) 'memuse' is the number of 'bytes per size' for
- the test, or a good estimate of it. 'overhead' specifies fixed overhead,
- independent of the testsize, and defaults to 5Mb.
-
- The decorator tries to guess a good value for 'size' and passes it to
- the decorated test function. If minsize * memuse is more than the
- allowed memory use (as defined by max_memuse), the test is skipped.
- Otherwise, minsize is adjusted upward to use up to max_memuse.
- """
- def decorator(f):
- def wrapper(self):
- if not max_memuse:
- # If max_memuse is 0 (the default),
- # we still want to run the tests with size set to a few kb,
- # to make sure they work. We still want to avoid using
- # too much memory, though, but we do that noisily.
- maxsize = 5147
- self.assertFalse(maxsize * memuse + overhead > 20 * _1M)
- else:
- maxsize = int((max_memuse - overhead) / memuse)
- if maxsize < minsize:
- # Really ought to print 'test skipped' or something
- if verbose:
- sys.stderr.write("Skipping %s because of memory "
- "constraint\n" % (f.__name__,))
- return
- # Try to keep some breathing room in memory use
- maxsize = max(maxsize - 50 * _1M, minsize)
- return f(self, maxsize)
- wrapper.minsize = minsize
- wrapper.memuse = memuse
- wrapper.overhead = overhead
- return wrapper
- return decorator
-
-def precisionbigmemtest(size, memuse, overhead=5*_1M, dry_run=True):
- def decorator(f):
- def wrapper(self):
- if not real_max_memuse:
- maxsize = 5147
- else:
- maxsize = size
-
- if ((real_max_memuse or not dry_run)
- and real_max_memuse < maxsize * memuse):
- if verbose:
- sys.stderr.write("Skipping %s because of memory "
- "constraint\n" % (f.__name__,))
- return
-
- return f(self, maxsize)
- wrapper.size = size
- wrapper.memuse = memuse
- wrapper.overhead = overhead
- return wrapper
- return decorator
-
-def bigaddrspacetest(f):
- """Decorator for tests that fill the address space."""
- def wrapper(self):
- if max_memuse < MAX_Py_ssize_t:
- if verbose:
- sys.stderr.write("Skipping %s because of memory "
- "constraint\n" % (f.__name__,))
- else:
- return f(self)
- return wrapper
-
-#=======================================================================
-# unittest integration.
-
-class BasicTestRunner:
- def run(self, test):
- result = unittest.TestResult()
- test(result)
- return result
-
-def _id(obj):
- return obj
-
-def requires_resource(resource):
- if resource == 'gui' and not _is_gui_available():
- return unittest.skip(_is_gui_available.reason)
- if is_resource_enabled(resource):
- return _id
- else:
- return unittest.skip("resource {0!r} is not enabled".format(resource))
-
-def cpython_only(test):
- """
- Decorator for tests only applicable on CPython.
- """
- return impl_detail(cpython=True)(test)
-
-def impl_detail(msg=None, **guards):
- if check_impl_detail(**guards):
- return _id
- if msg is None:
- guardnames, default = _parse_guards(guards)
- if default:
- msg = "implementation detail not available on {0}"
- else:
- msg = "implementation detail specific to {0}"
- guardnames = sorted(guardnames.keys())
- msg = msg.format(' or '.join(guardnames))
- return unittest.skip(msg)
-
-def _parse_guards(guards):
- # Returns a tuple ({platform_name: run_me}, default_value)
- if not guards:
- return ({'cpython': True}, False)
- is_true = guards.values()[0]
- assert guards.values() == [is_true] * len(guards) # all True or all False
- return (guards, not is_true)
-
-# Use the following check to guard CPython's implementation-specific tests --
-# or to run them only on the implementation(s) guarded by the arguments.
-def check_impl_detail(**guards):
- """This function returns True or False depending on the host platform.
- Examples:
- if check_impl_detail(): # only on CPython (default)
- if check_impl_detail(jython=True): # only on Jython
- if check_impl_detail(cpython=False): # everywhere except on CPython
- """
- guards, default = _parse_guards(guards)
- return guards.get(platform.python_implementation().lower(), default)
-
-
-
-def _run_suite(suite):
- """Run tests from a unittest.TestSuite-derived class."""
- if verbose:
- runner = unittest.TextTestRunner(sys.stdout, verbosity=2)
- else:
- runner = BasicTestRunner()
-
- result = runner.run(suite)
- if not result.wasSuccessful():
- if len(result.errors) == 1 and not result.failures:
- err = result.errors[0][1]
- elif len(result.failures) == 1 and not result.errors:
- err = result.failures[0][1]
- else:
- err = "multiple errors occurred"
- if not verbose:
- err += "; run in verbose mode for details"
- raise TestFailed(err)
-
-
-def run_unittest(*classes):
- """Run tests from unittest.TestCase-derived classes."""
- valid_types = (unittest.TestSuite, unittest.TestCase)
- suite = unittest.TestSuite()
- for cls in classes:
- if isinstance(cls, str):
- if cls in sys.modules:
- suite.addTest(unittest.findTestCases(sys.modules[cls]))
- else:
- raise ValueError("str arguments must be keys in sys.modules")
- elif isinstance(cls, valid_types):
- suite.addTest(cls)
- else:
- suite.addTest(unittest.makeSuite(cls))
- _run_suite(suite)
-
-#=======================================================================
-# Check for the presence of docstrings.
-
-HAVE_DOCSTRINGS = (check_impl_detail(cpython=False) or
- sys.platform == 'win32' or
- sysconfig.get_config_var('WITH_DOC_STRINGS'))
-
-requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS,
- "test requires docstrings")
-
-
-#=======================================================================
-# doctest driver.
-
-def run_doctest(module, verbosity=None):
- """Run doctest on the given module. Return (#failures, #tests).
-
- If optional argument verbosity is not specified (or is None), pass
- test_support's belief about verbosity on to doctest. Else doctest's
- usual behavior is used (it searches sys.argv for -v).
- """
-
- import doctest
-
- if verbosity is None:
- verbosity = verbose
- else:
- verbosity = None
-
- # Direct doctest output (normally just errors) to real stdout; doctest
- # output shouldn't be compared by regrtest.
- save_stdout = sys.stdout
- sys.stdout = get_original_stdout()
- try:
- f, t = doctest.testmod(module, verbose=verbosity)
- if f:
- raise TestFailed("%d of %d doctests failed" % (f, t))
- finally:
- sys.stdout = save_stdout
- if verbose:
- print 'doctest (%s) ... %d tests with zero failures' % (module.__name__, t)
- return f, t
-
-#=======================================================================
-# Threading support to prevent reporting refleaks when running regrtest.py -R
-
-# NOTE: we use thread._count() rather than threading.enumerate() (or the
-# moral equivalent thereof) because a threading.Thread object is still alive
-# until its __bootstrap() method has returned, even after it has been
-# unregistered from the threading module.
-# thread._count(), on the other hand, only gets decremented *after* the
-# __bootstrap() method has returned, which gives us reliable reference counts
-# at the end of a test run.
-
-def threading_setup():
- if thread:
- return thread._count(),
- else:
- return 1,
-
-def threading_cleanup(nb_threads):
- if not thread:
- return
-
- _MAX_COUNT = 10
- for count in range(_MAX_COUNT):
- n = thread._count()
- if n == nb_threads:
- break
- time.sleep(0.1)
- # XXX print a warning in case of failure?
-
-def reap_threads(func):
- """Use this function when threads are being used. This will
- ensure that the threads are cleaned up even when the test fails.
- If threading is unavailable this function does nothing.
- """
- if not thread:
- return func
-
- @functools.wraps(func)
- def decorator(*args):
- key = threading_setup()
- try:
- return func(*args)
- finally:
- threading_cleanup(*key)
- return decorator
-
-def reap_children():
- """Use this function at the end of test_main() whenever sub-processes
- are started. This will help ensure that no extra children (zombies)
- stick around to hog resources and create problems when looking
- for refleaks.
- """
-
- # Reap all our dead child processes so we don't leave zombies around.
- # These hog resources and might be causing some of the buildbots to die.
- if hasattr(os, 'waitpid'):
- any_process = -1
- while True:
- try:
- # This will raise an exception on Windows. That's ok.
- pid, status = os.waitpid(any_process, os.WNOHANG)
- if pid == 0:
- break
- except:
- break
-
-@contextlib.contextmanager
-def start_threads(threads, unlock=None):
- threads = list(threads)
- started = []
- try:
- try:
- for t in threads:
- t.start()
- started.append(t)
- except:
- if verbose:
- print("Can't start %d threads, only %d threads started" %
- (len(threads), len(started)))
- raise
- yield
- finally:
- if unlock:
- unlock()
- endtime = starttime = time.time()
- for timeout in range(1, 16):
- endtime += 60
- for t in started:
- t.join(max(endtime - time.time(), 0.01))
- started = [t for t in started if t.isAlive()]
- if not started:
- break
- if verbose:
- print('Unable to join %d threads during a period of '
- '%d minutes' % (len(started), timeout))
- started = [t for t in started if t.isAlive()]
- if started:
- raise AssertionError('Unable to join %d threads' % len(started))
-
-@contextlib.contextmanager
-def swap_attr(obj, attr, new_val):
- """Temporary swap out an attribute with a new object.
-
- Usage:
- with swap_attr(obj, "attr", 5):
- ...
-
- This will set obj.attr to 5 for the duration of the with: block,
- restoring the old value at the end of the block. If `attr` doesn't
- exist on `obj`, it will be created and then deleted at the end of the
- block.
- """
- if hasattr(obj, attr):
- real_val = getattr(obj, attr)
- setattr(obj, attr, new_val)
- try:
- yield
- finally:
- setattr(obj, attr, real_val)
- else:
- setattr(obj, attr, new_val)
- try:
- yield
- finally:
- delattr(obj, attr)
-
-def py3k_bytes(b):
- """Emulate the py3k bytes() constructor.
-
- NOTE: This is only a best effort function.
- """
- try:
- # memoryview?
- return b.tobytes()
- except AttributeError:
- try:
- # iterable of ints?
- return b"".join(chr(x) for x in b)
- except TypeError:
- return bytes(b)
-
-def args_from_interpreter_flags():
- """Return a list of command-line arguments reproducing the current
- settings in sys.flags."""
- import subprocess
- return subprocess._args_from_interpreter_flags()
-
-def strip_python_stderr(stderr):
- """Strip the stderr of a Python process from potential debug output
- emitted by the interpreter.
-
- This will typically be run on the result of the communicate() method
- of a subprocess.Popen object.
- """
- stderr = re.sub(br"\[\d+ refs\]\r?\n?$", b"", stderr).strip()
- return stderr
-
-
-def check_free_after_iterating(test, iter, cls, args=()):
- class A(cls):
- def __del__(self):
- done[0] = True
- try:
- next(it)
- except StopIteration:
- pass
-
- done = [False]
- it = iter(A(*args))
- # Issue 26494: Shouldn't crash
- test.assertRaises(StopIteration, next, it)
- # The sequence should be deallocated just after the end of iterating
- gc_collect()
- test.assertTrue(done[0])
+import test.support
+sys.modules['test.test_support'] = test.support
self.assertEqual(out, b'')
self.assertEqual(err, b'')
+ # test that the exit machinery handles long exit codes
+ rc, out, err = assert_python_failure('-c', 'raise SystemExit(47L)')
+ self.assertEqual(rc, 47)
+ self.assertEqual(out, b'')
+ self.assertEqual(err, b'')
+
+ rc, out, err = assert_python_ok('-c', 'raise SystemExit(0L)')
+ self.assertEqual(rc, 0)
+ self.assertEqual(out, b'')
+ self.assertEqual(err, b'')
+
def check_exit_message(code, expected, **env_vars):
rc, out, err = assert_python_failure('-c', code, **env_vars)
self.assertEqual(rc, 1)
try:
p = Popen(cmd, stdout=PIPE, stderr=PIPE)
except WindowsError as e:
- if e.winerror == 5:
+ if e.winerror == 5 or e.winerror == 2:
self.skipTest('Not permitted to start the child process')
else:
raise
try:
pid = os.fork()
if not pid:
+ # child process
os.close(read_fd)
os.write(write_fd, next(self.r).encode("ascii"))
os.close(write_fd)
# bypass the normal exit handlers- leave those to
# the parent.
os._exit(0)
+
+ # parent process
parent_value = next(self.r)
child_value = os.read(read_fd, len(parent_value)).decode("ascii")
finally:
os.kill(pid, signal.SIGKILL)
except EnvironmentError:
pass
+
+ # Read the process exit status to avoid zombie process
+ os.waitpid(pid, 0)
+
os.close(read_fd)
os.close(write_fd)
self.assertNotEqual(child_value, parent_value)
self.assertEqual(cm.exception.errno, errno.ENOENT)
self.assertEqual(os.listdir(our_temp_directory), [])
- open = io.open
def bad_writer(*args, **kwargs):
- fp = open(*args, **kwargs)
+ fp = orig_open(*args, **kwargs)
fp.write = raise_OSError
return fp
- with support.swap_attr(io, "open", bad_writer):
+ with support.swap_attr(io, "open", bad_writer) as orig_open:
# test again with failing write()
with self.assertRaises(IOError) as cm:
tempfile._get_default_tempdir()
--- /dev/null
+import importlib
+import shutil
+import stat
+import sys
+import os
+import unittest
+import socket
+import tempfile
+import errno
+from test import support
+
+TESTFN = support.TESTFN
+
+
+class ClassicClass:
+ pass
+
+class NewStyleClass(object):
+ pass
+
+
+class TestSupport(unittest.TestCase):
+
+ def test_import_module(self):
+ support.import_module("ftplib")
+ self.assertRaises(unittest.SkipTest, support.import_module, "foo")
+
+ def test_import_fresh_module(self):
+ support.import_fresh_module("ftplib")
+
+ def test_get_attribute(self):
+ self.assertEqual(support.get_attribute(self, "test_get_attribute"),
+ self.test_get_attribute)
+ self.assertRaises(unittest.SkipTest, support.get_attribute, self, "foo")
+ with self.assertRaisesRegexp(unittest.SkipTest, 'unittest'):
+ support.get_attribute(unittest, 'foo')
+ with self.assertRaisesRegexp(unittest.SkipTest, 'ClassicClass'):
+ support.get_attribute(ClassicClass, 'foo')
+ with self.assertRaisesRegexp(unittest.SkipTest, 'ClassicClass'):
+ support.get_attribute(ClassicClass(), 'foo')
+ with self.assertRaisesRegexp(unittest.SkipTest, 'NewStyleClass'):
+ support.get_attribute(NewStyleClass, 'foo')
+ with self.assertRaisesRegexp(unittest.SkipTest, 'NewStyleClass'):
+ support.get_attribute(NewStyleClass(), 'foo')
+
+ @unittest.skip("failing buildbots")
+ def test_get_original_stdout(self):
+ self.assertEqual(support.get_original_stdout(), sys.stdout)
+
+ def test_unload(self):
+ import sched
+ self.assertIn("sched", sys.modules)
+ support.unload("sched")
+ self.assertNotIn("sched", sys.modules)
+
+ def test_unlink(self):
+ with open(TESTFN, "w") as f:
+ pass
+ support.unlink(TESTFN)
+ self.assertFalse(os.path.exists(TESTFN))
+ support.unlink(TESTFN)
+
+ def test_rmtree(self):
+ dirpath = support.TESTFN + 'd'
+ subdirpath = os.path.join(dirpath, 'subdir')
+ os.mkdir(dirpath)
+ os.mkdir(subdirpath)
+ support.rmtree(dirpath)
+ self.assertFalse(os.path.exists(dirpath))
+ with support.swap_attr(support, 'verbose', 0):
+ support.rmtree(dirpath)
+
+ os.mkdir(dirpath)
+ os.mkdir(subdirpath)
+ os.chmod(dirpath, stat.S_IRUSR|stat.S_IXUSR)
+ with support.swap_attr(support, 'verbose', 0):
+ support.rmtree(dirpath)
+ self.assertFalse(os.path.exists(dirpath))
+
+ os.mkdir(dirpath)
+ os.mkdir(subdirpath)
+ os.chmod(dirpath, 0)
+ with support.swap_attr(support, 'verbose', 0):
+ support.rmtree(dirpath)
+ self.assertFalse(os.path.exists(dirpath))
+
+ def test_forget(self):
+ mod_filename = TESTFN + '.py'
+ with open(mod_filename, 'wt') as f:
+ f.write('foo = 1\n')
+ sys.path.insert(0, os.curdir)
+ try:
+ mod = __import__(TESTFN)
+ self.assertIn(TESTFN, sys.modules)
+
+ support.forget(TESTFN)
+ self.assertNotIn(TESTFN, sys.modules)
+ finally:
+ del sys.path[0]
+ support.unlink(mod_filename)
+ support.rmtree('__pycache__')
+
+ def test_HOST(self):
+ s = socket.socket()
+ s.bind((support.HOST, 0))
+ s.close()
+
+ def test_find_unused_port(self):
+ port = support.find_unused_port()
+ s = socket.socket()
+ s.bind((support.HOST, port))
+ s.close()
+
+ def test_bind_port(self):
+ s = socket.socket()
+ support.bind_port(s)
+ s.listen(5)
+ s.close()
+
+ # Tests for temp_dir()
+
+ def test_temp_dir(self):
+ """Test that temp_dir() creates and destroys its directory."""
+ parent_dir = tempfile.mkdtemp()
+ parent_dir = os.path.realpath(parent_dir)
+
+ try:
+ path = os.path.join(parent_dir, 'temp')
+ self.assertFalse(os.path.isdir(path))
+ with support.temp_dir(path) as temp_path:
+ self.assertEqual(temp_path, path)
+ self.assertTrue(os.path.isdir(path))
+ self.assertFalse(os.path.isdir(path))
+ finally:
+ support.rmtree(parent_dir)
+
+ def test_temp_dir__path_none(self):
+ """Test passing no path."""
+ with support.temp_dir() as temp_path:
+ self.assertTrue(os.path.isdir(temp_path))
+ self.assertFalse(os.path.isdir(temp_path))
+
+ def test_temp_dir__existing_dir__quiet_default(self):
+ """Test passing a directory that already exists."""
+ def call_temp_dir(path):
+ with support.temp_dir(path) as temp_path:
+ raise Exception("should not get here")
+
+ path = tempfile.mkdtemp()
+ path = os.path.realpath(path)
+ try:
+ self.assertTrue(os.path.isdir(path))
+ with self.assertRaises(OSError) as cm:
+ call_temp_dir(path)
+ self.assertEqual(cm.exception.errno, errno.EEXIST)
+ # Make sure temp_dir did not delete the original directory.
+ self.assertTrue(os.path.isdir(path))
+ finally:
+ shutil.rmtree(path)
+
+ def test_temp_dir__existing_dir__quiet_true(self):
+ """Test passing a directory that already exists with quiet=True."""
+ path = tempfile.mkdtemp()
+ path = os.path.realpath(path)
+
+ try:
+ with support.check_warnings() as recorder:
+ with support.temp_dir(path, quiet=True) as temp_path:
+ self.assertEqual(path, temp_path)
+ warnings = [str(w.message) for w in recorder.warnings]
+ # Make sure temp_dir did not delete the original directory.
+ self.assertTrue(os.path.isdir(path))
+ finally:
+ shutil.rmtree(path)
+
+ expected = ['tests may fail, unable to create temp dir: ' + path]
+ self.assertEqual(warnings, expected)
+
+ # Tests for change_cwd()
+
+ def test_change_cwd(self):
+ original_cwd = os.getcwd()
+
+ with support.temp_dir() as temp_path:
+ with support.change_cwd(temp_path) as new_cwd:
+ self.assertEqual(new_cwd, temp_path)
+ self.assertEqual(os.getcwd(), new_cwd)
+
+ self.assertEqual(os.getcwd(), original_cwd)
+
+ def test_change_cwd__non_existent_dir(self):
+ """Test passing a non-existent directory."""
+ original_cwd = os.getcwd()
+
+ def call_change_cwd(path):
+ with support.change_cwd(path) as new_cwd:
+ raise Exception("should not get here")
+
+ with support.temp_dir() as parent_dir:
+ non_existent_dir = os.path.join(parent_dir, 'does_not_exist')
+ with self.assertRaises(OSError) as cm:
+ call_change_cwd(non_existent_dir)
+ self.assertEqual(cm.exception.errno, errno.ENOENT)
+
+ self.assertEqual(os.getcwd(), original_cwd)
+
+ def test_change_cwd__non_existent_dir__quiet_true(self):
+ """Test passing a non-existent directory with quiet=True."""
+ original_cwd = os.getcwd()
+
+ with support.temp_dir() as parent_dir:
+ bad_dir = os.path.join(parent_dir, 'does_not_exist')
+ with support.check_warnings() as recorder:
+ with support.change_cwd(bad_dir, quiet=True) as new_cwd:
+ self.assertEqual(new_cwd, original_cwd)
+ self.assertEqual(os.getcwd(), new_cwd)
+ warnings = [str(w.message) for w in recorder.warnings]
+
+ expected = ['tests may fail, unable to change CWD to: ' + bad_dir]
+ self.assertEqual(warnings, expected)
+
+ # Tests for change_cwd()
+
+ def test_change_cwd__chdir_warning(self):
+ """Check the warning message when os.chdir() fails."""
+ path = TESTFN + '_does_not_exist'
+ with support.check_warnings() as recorder:
+ with support.change_cwd(path=path, quiet=True):
+ pass
+ messages = [str(w.message) for w in recorder.warnings]
+ self.assertEqual(messages, ['tests may fail, unable to change CWD to: ' + path])
+
+ # Tests for temp_cwd()
+
+ def test_temp_cwd(self):
+ here = os.getcwd()
+ with support.temp_cwd(name=TESTFN):
+ self.assertEqual(os.path.basename(os.getcwd()), TESTFN)
+ self.assertFalse(os.path.exists(TESTFN))
+ self.assertTrue(os.path.basename(os.getcwd()), here)
+
+
+ def test_temp_cwd__name_none(self):
+ """Test passing None to temp_cwd()."""
+ original_cwd = os.getcwd()
+ with support.temp_cwd(name=None) as new_cwd:
+ self.assertNotEqual(new_cwd, original_cwd)
+ self.assertTrue(os.path.isdir(new_cwd))
+ self.assertEqual(os.getcwd(), new_cwd)
+ self.assertEqual(os.getcwd(), original_cwd)
+
+ def test_sortdict(self):
+ self.assertEqual(support.sortdict({3:3, 2:2, 1:1}), "{1: 1, 2: 2, 3: 3}")
+
+ def test_make_bad_fd(self):
+ fd = support.make_bad_fd()
+ with self.assertRaises(OSError) as cm:
+ os.write(fd, b"foo")
+ self.assertEqual(cm.exception.errno, errno.EBADF)
+
+ def test_check_syntax_error(self):
+ support.check_syntax_error(self, "def class", lineno=1, offset=9)
+ with self.assertRaises(AssertionError):
+ support.check_syntax_error(self, "x=1")
+
+ def test_CleanImport(self):
+ import importlib
+ with support.CleanImport("asyncore"):
+ importlib.import_module("asyncore")
+
+ def test_DirsOnSysPath(self):
+ with support.DirsOnSysPath('foo', 'bar'):
+ self.assertIn("foo", sys.path)
+ self.assertIn("bar", sys.path)
+ self.assertNotIn("foo", sys.path)
+ self.assertNotIn("bar", sys.path)
+
+ def test_captured_stdout(self):
+ with support.captured_stdout() as stdout:
+ print "hello"
+ self.assertEqual(stdout.getvalue(), "hello\n")
+
+ def test_captured_stderr(self):
+ with support.captured_stderr() as stderr:
+ print >>sys.stderr, "hello"
+ self.assertEqual(stderr.getvalue(), "hello\n")
+
+ def test_captured_stdin(self):
+ with support.captured_stdin() as stdin:
+ stdin.write('hello\n')
+ stdin.seek(0)
+ # call test code that consumes from sys.stdin
+ captured = raw_input()
+ self.assertEqual(captured, "hello")
+
+ def test_gc_collect(self):
+ support.gc_collect()
+
+ def test_python_is_optimized(self):
+ self.assertIsInstance(support.python_is_optimized(), bool)
+
+ def test_swap_attr(self):
+ class Obj:
+ pass
+ obj = Obj()
+ obj.x = 1
+ with support.swap_attr(obj, "x", 5) as x:
+ self.assertEqual(obj.x, 5)
+ self.assertEqual(x, 1)
+ self.assertEqual(obj.x, 1)
+ with support.swap_attr(obj, "y", 5) as y:
+ self.assertEqual(obj.y, 5)
+ self.assertIsNone(y)
+ self.assertFalse(hasattr(obj, 'y'))
+ with support.swap_attr(obj, "y", 5):
+ del obj.y
+ self.assertFalse(hasattr(obj, 'y'))
+
+ def test_swap_item(self):
+ D = {"x":1}
+ with support.swap_item(D, "x", 5) as x:
+ self.assertEqual(D["x"], 5)
+ self.assertEqual(x, 1)
+ self.assertEqual(D["x"], 1)
+ with support.swap_item(D, "y", 5) as y:
+ self.assertEqual(D["y"], 5)
+ self.assertIsNone(y)
+ self.assertNotIn("y", D)
+ with support.swap_item(D, "y", 5):
+ del D["y"]
+ self.assertNotIn("y", D)
+
+ # XXX -follows a list of untested API
+ # make_legacy_pyc
+ # is_resource_enabled
+ # requires
+ # fcmp
+ # umaks
+ # findfile
+ # check_warnings
+ # EnvironmentVarGuard
+ # TransientResource
+ # transient_internet
+ # run_with_locale
+ # set_memlimit
+ # bigmemtest
+ # precisionbigmemtest
+ # bigaddrspacetest
+ # requires_resource
+ # run_doctest
+ # threading_cleanup
+ # reap_threads
+ # reap_children
+ # strip_python_stderr
+ # args_from_interpreter_flags
+ # can_symlink
+ # skip_unless_symlink
+ # SuppressCrashReport
+
+
+def test_main():
+ tests = [TestSupport]
+ support.run_unittest(*tests)
+
+if __name__ == '__main__':
+ test_main()
print arg
+
class BasicThreadTest(unittest.TestCase):
def setUp(self):
self.running = 0
self.next_ident = 0
+ key = test_support.threading_setup()
+ self.addCleanup(test_support.threading_cleanup, *key)
+
class ThreadRunningTests(BasicThreadTest):
os._exit(0)
else: # parent
os.close(self.write_fd)
+ pid, status = os.waitpid(pid, 0)
+ self.assertEqual(status, 0)
thread.start_new_thread(thread1, ())
self.assertEqual(os.read(self.read_fd, 2), "OK",
b'repr=%V', None, b'abc\xff')
# not supported: copy the raw format string. these tests are just here
- # to check for crashs and should not be considered as specifications
+ # to check for crashes and should not be considered as specifications
check_format(u'%s',
b'%1%s', b'abc')
check_format(u'%1abc',
def test_proxy_bypass_environment_host_match(self):
bypass = urllib.proxy_bypass_environment
self.env.set('NO_PROXY',
- 'localhost, anotherdomain.com, newdomain.com:1234')
+ 'localhost, anotherdomain.com, newdomain.com:1234, .d.o.t')
self.assertTrue(bypass('localhost'))
self.assertTrue(bypass('LocalHost')) # MixedCase
self.assertTrue(bypass('LOCALHOST')) # UPPERCASE
self.assertTrue(bypass('newdomain.com:1234'))
+ self.assertTrue(bypass('foo.d.o.t')) # issue 29142
self.assertTrue(bypass('anotherdomain.com:8888'))
self.assertTrue(bypass('www.newdomain.com:1234'))
self.assertFalse(bypass('prelocalhost'))
self.assertEqual(splithost('/foo/bar/baz.html'),
(None, '/foo/bar/baz.html'))
+ # bpo-30500: # starts a fragment.
+ self.assertEqual(splithost('//127.0.0.1#@host.com'),
+ ('127.0.0.1', '/#@host.com'))
+ self.assertEqual(splithost('//127.0.0.1#@host.com:80'),
+ ('127.0.0.1', '/#@host.com:80'))
+ self.assertEqual(splithost('//127.0.0.1:80#@host.com'),
+ ('127.0.0.1:80', '/#@host.com'))
+
+ # Empty host is returned as empty string.
+ self.assertEqual(splithost("///file"),
+ ('', '/file'))
+
+ # Trailing semicolon, question mark and hash symbol are kept.
+ self.assertEqual(splithost("//example.net/file;"),
+ ('example.net', '/file;'))
+ self.assertEqual(splithost("//example.net/file?"),
+ ('example.net', '/file?'))
+ self.assertEqual(splithost("//example.net/file#"),
+ ('example.net', '/file#'))
+
def test_splituser(self):
splituser = urllib.splituser
self.assertEqual(splituser('User:Pass@www.python.org:080'),
self._threads = test_support.threading_setup()
def tearDown(self):
+ self.doCleanups()
test_support.threading_cleanup(*self._threads)
self.server_url = 'http://127.0.0.1:%s' % self.server.port
self.server.start()
self.server.ready.wait()
-
- def tearDown(self):
- self.server.stop()
- super(BasicAuthTests, self).tearDown()
+ self.addCleanup(self.server.stop)
def test_basic_auth_success(self):
ah = urllib2.HTTPBasicAuthHandler()
self.server = LoopbackHttpServerThread(create_fake_proxy_handler)
self.server.start()
self.server.ready.wait()
+ self.addCleanup(self.server.stop)
proxy_url = "http://127.0.0.1:%d" % self.server.port
handler = urllib2.ProxyHandler({"http" : proxy_url})
self.proxy_digest_handler = urllib2.ProxyDigestAuthHandler()
self.opener = urllib2.build_opener(handler, self.proxy_digest_handler)
- def tearDown(self):
- self.server.stop()
- super(ProxyAuthTests, self).tearDown()
-
def test_proxy_with_bad_password_raises_httperror(self):
self.proxy_digest_handler.add_password(self.REALM, self.URL,
self.USER, self.PASSWD+"bad")
self.server = LoopbackHttpServerThread(handler)
self.server.start()
self.server.ready.wait()
+ self.addCleanup(self.server.stop)
port = self.server.port
handler.port = port
return handler
handler = self.start_server(responses)
- try:
- f = urllib2.urlopen('http://localhost:%s/' % handler.port)
- data = f.read()
- f.close()
+ f = urllib2.urlopen('http://localhost:%s/' % handler.port)
+ data = f.read()
+ f.close()
- self.assertEqual(data, expected_response)
- self.assertEqual(handler.requests, ['/', '/somewhere_else'])
- finally:
- self.server.stop()
+ self.assertEqual(data, expected_response)
+ self.assertEqual(handler.requests, ['/', '/somewhere_else'])
def test_404(self):
handler = self.start_server([(404, [], expected_response)])
try:
- try:
- urllib2.urlopen('http://localhost:%s/weeble' % handler.port)
- except urllib2.URLError, f:
- pass
- else:
- self.fail('404 should raise URLError')
+ urllib2.urlopen('http://localhost:%s/weeble' % handler.port)
+ except urllib2.URLError, f:
+ pass
+ else:
+ self.fail('404 should raise URLError')
- data = f.read()
- f.close()
+ data = f.read()
+ f.close()
- self.assertEqual(data, expected_response)
- self.assertEqual(handler.requests, ['/weeble'])
- finally:
- self.server.stop()
+ self.assertEqual(data, expected_response)
+ self.assertEqual(handler.requests, ['/weeble'])
def test_200(self):
expected_response = 'pycon 2008...'
handler = self.start_server([(200, [], expected_response)])
- try:
- f = urllib2.urlopen('http://localhost:%s/bizarre' % handler.port)
- data = f.read()
- f.close()
+ f = urllib2.urlopen('http://localhost:%s/bizarre' % handler.port)
+ data = f.read()
+ f.close()
- self.assertEqual(data, expected_response)
- self.assertEqual(handler.requests, ['/bizarre'])
- finally:
- self.server.stop()
+ self.assertEqual(data, expected_response)
+ self.assertEqual(handler.requests, ['/bizarre'])
def test_200_with_parameters(self):
expected_response = 'pycon 2008...'
handler = self.start_server([(200, [], expected_response)])
- try:
- f = urllib2.urlopen('http://localhost:%s/bizarre' % handler.port, 'get=with_feeling')
- data = f.read()
- f.close()
+ f = urllib2.urlopen('http://localhost:%s/bizarre' % handler.port, 'get=with_feeling')
+ data = f.read()
+ f.close()
- self.assertEqual(data, expected_response)
- self.assertEqual(handler.requests, ['/bizarre', 'get=with_feeling'])
- finally:
- self.server.stop()
+ self.assertEqual(data, expected_response)
+ self.assertEqual(handler.requests, ['/bizarre', 'get=with_feeling'])
def test_https(self):
handler = self.start_https_server()
def test_sending_headers(self):
handler = self.start_server([(200, [], "we don't care")])
- try:
- req = urllib2.Request("http://localhost:%s/" % handler.port,
- headers={'Range': 'bytes=20-39'})
- urllib2.urlopen(req)
- self.assertEqual(handler.headers_received['Range'], 'bytes=20-39')
- finally:
- self.server.stop()
+ req = urllib2.Request("http://localhost:%s/" % handler.port,
+ headers={'Range': 'bytes=20-39'})
+ urllib2.urlopen(req)
+ self.assertEqual(handler.headers_received['Range'], 'bytes=20-39')
def test_basic(self):
handler = self.start_server([(200, [], "we don't care")])
+ open_url = urllib2.urlopen("http://localhost:%s" % handler.port)
+ for attr in ("read", "close", "info", "geturl"):
+ self.assertTrue(hasattr(open_url, attr), "object returned from "
+ "urlopen lacks the %s attribute" % attr)
try:
- open_url = urllib2.urlopen("http://localhost:%s" % handler.port)
- for attr in ("read", "close", "info", "geturl"):
- self.assertTrue(hasattr(open_url, attr), "object returned from "
- "urlopen lacks the %s attribute" % attr)
- try:
- self.assertTrue(open_url.read(), "calling 'read' failed")
- finally:
- open_url.close()
+ self.assertTrue(open_url.read(), "calling 'read' failed")
finally:
- self.server.stop()
+ open_url.close()
def test_info(self):
handler = self.start_server([(200, [], "we don't care")])
- try:
- open_url = urllib2.urlopen("http://localhost:%s" % handler.port)
- info_obj = open_url.info()
- self.assertIsInstance(info_obj, mimetools.Message,
- "object returned by 'info' is not an "
- "instance of mimetools.Message")
- self.assertEqual(info_obj.getsubtype(), "plain")
- finally:
- self.server.stop()
+ open_url = urllib2.urlopen("http://localhost:%s" % handler.port)
+ info_obj = open_url.info()
+ self.assertIsInstance(info_obj, mimetools.Message,
+ "object returned by 'info' is not an "
+ "instance of mimetools.Message")
+ self.assertEqual(info_obj.getsubtype(), "plain")
def test_geturl(self):
# Make sure same URL as opened is returned by geturl.
handler = self.start_server([(200, [], "we don't care")])
- try:
- open_url = urllib2.urlopen("http://localhost:%s" % handler.port)
- url = open_url.geturl()
- self.assertEqual(url, "http://localhost:%s" % handler.port)
- finally:
- self.server.stop()
+ open_url = urllib2.urlopen("http://localhost:%s" % handler.port)
+ url = open_url.geturl()
+ self.assertEqual(url, "http://localhost:%s" % handler.port)
def test_bad_address(self):
def test_iteration(self):
expected_response = "pycon 2008..."
handler = self.start_server([(200, [], expected_response)])
- try:
- data = urllib2.urlopen("http://localhost:%s" % handler.port)
- for line in data:
- self.assertEqual(line, expected_response)
- finally:
- self.server.stop()
+
+ data = urllib2.urlopen("http://localhost:%s" % handler.port)
+ for line in data:
+ self.assertEqual(line, expected_response)
def ztest_line_iteration(self):
lines = ["We\n", "got\n", "here\n", "verylong " * 8192 + "\n"]
expected_response = "".join(lines)
handler = self.start_server([(200, [], expected_response)])
- try:
- data = urllib2.urlopen("http://localhost:%s" % handler.port)
- for index, line in enumerate(data):
- self.assertEqual(line, lines[index],
- "Fetched line number %s doesn't match expected:\n"
- " Expected length was %s, got %s" %
- (index, len(lines[index]), len(line)))
- finally:
- self.server.stop()
+ data = urllib2.urlopen("http://localhost:%s" % handler.port)
+ for index, line in enumerate(data):
+ self.assertEqual(line, lines[index],
+ "Fetched line number %s doesn't match expected:\n"
+ " Expected length was %s, got %s" %
+ (index, len(lines[index]), len(line)))
self.assertEqual(index + 1, len(lines))
def test_main():
def test_ftp(self):
urls = [
- 'ftp://ftp.debian.org/debian/README',
- ('ftp://ftp.debian.org/debian/non-existent-file',
+ 'ftp://www.pythontest.net/README',
+ ('ftp://www.pythontest.net/non-existent-file',
None, urllib2.URLError),
]
self._test_urls(urls, self._extra_handlers())
u = _urlopen_with_retry(url, timeout=120)
self.assertEqual(u.fp._sock.fp._sock.gettimeout(), 120)
- FTP_HOST = 'ftp://ftp.debian.org/debian/'
+ FTP_HOST = 'ftp://www.pythontest.net/'
def test_ftp_basic(self):
self.assertIsNone(socket.getdefaulttimeout())
import operator
import contextlib
import copy
+import time
from test import test_support
self.cycle = self
+@contextlib.contextmanager
+def collect_in_thread(period=0.001):
+ """
+ Ensure GC collections happen in a different thread, at a high frequency.
+ """
+ threading = test_support.import_module('threading')
+ please_stop = False
+
+ def collect():
+ while not please_stop:
+ time.sleep(period)
+ gc.collect()
+
+ with test_support.disable_gc():
+ old_interval = sys.getcheckinterval()
+ sys.setcheckinterval(20)
+ t = threading.Thread(target=collect)
+ t.start()
+ try:
+ yield
+ finally:
+ please_stop = True
+ t.join()
+ sys.setcheckinterval(old_interval)
+
+
class TestBase(unittest.TestCase):
def setUp(self):
self.assertEqual(len(d), 0)
self.assertEqual(count, 2)
+ def test_threaded_weak_valued_setdefault(self):
+ d = weakref.WeakValueDictionary()
+ with collect_in_thread():
+ for i in range(50000):
+ x = d.setdefault(10, RefCycle())
+ self.assertIsNot(x, None) # we never put None in there!
+ del x
+
+ def test_threaded_weak_valued_pop(self):
+ d = weakref.WeakValueDictionary()
+ with collect_in_thread():
+ for i in range(50000):
+ d[10] = RefCycle()
+ x = d.pop(10, 10)
+ self.assertIsNot(x, None) # we never put None in there!
+
+ def test_threaded_weak_valued_consistency(self):
+ # Issue #28427: old keys should not remove new values from
+ # WeakValueDictionary when collecting from another thread.
+ d = weakref.WeakValueDictionary()
+ with collect_in_thread():
+ for i in range(200000):
+ o = RefCycle()
+ d[10] = o
+ # o is still alive, so the dict can't be empty
+ self.assertEqual(len(d), 1)
+ o = None # lose ref
+
+
from test import mapping_tests
class WeakValueDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
-# xml.etree test. This file contains enough tests to make sure that
-# all included components work as they should.
-# Large parts are extracted from the upstream test suite.
-
-# IMPORTANT: the same doctests are run from "test_xml_etree_c" in
-# order to ensure consistency between the C implementation and the
-# Python implementation.
+# -*- coding: utf-8 -*-
+# IMPORTANT: the same tests are run from "test_xml_etree_c" in order
+# to ensure consistency between the C implementation and the Python
+# implementation.
#
# For this purpose, the module-level "ET" symbol is temporarily
# monkey-patched when running the "test_xml_etree_c" test suite.
-# Don't re-import "xml.etree.ElementTree" module in the docstring,
-# except if the test is specific to the Python implementation.
-import sys
import cgi
+import copy
+import functools
+import io
+import pickle
+import StringIO
+import sys
+import types
+import unittest
+import warnings
+import weakref
-from test import test_support
-from test.test_support import findfile
+from test import test_support as support
+from test.test_support import TESTFN, findfile, gc_collect, swap_attr
-from xml.etree import ElementTree as ET
+# pyET is the pure-Python implementation.
+#
+# ET is pyET in test_xml_etree and is the C accelerated version in
+# test_xml_etree_c.
+from xml.etree import ElementTree as pyET
+ET = None
SIMPLE_XMLFILE = findfile("simple.xml", subdir="xmltestdata")
SIMPLE_NS_XMLFILE = findfile("simple-ns.xml", subdir="xmltestdata")
</body>
"""
+SAMPLE_XML_NS_ELEMS = """
+<root>
+<h:table xmlns:h="hello">
+ <h:tr>
+ <h:td>Apples</h:td>
+ <h:td>Bananas</h:td>
+ </h:tr>
+</h:table>
+
+<f:table xmlns:f="foo">
+ <f:name>African Coffee Table</f:name>
+ <f:width>80</f:width>
+ <f:length>120</f:length>
+</f:table>
+</root>
+"""
+
+ENTITY_XML = """\
+<!DOCTYPE points [
+<!ENTITY % user-entities SYSTEM 'user-entities.xml'>
+%user-entities;
+]>
+<document>&entity;</document>
+"""
+
+
+def checkwarnings(*filters):
+ def decorator(test):
+ def newtest(*args, **kwargs):
+ with support.check_warnings(*filters):
+ test(*args, **kwargs)
+ functools.update_wrapper(newtest, test)
+ return newtest
+ return decorator
-def sanity():
- """
- Import sanity.
- >>> from xml.etree import ElementTree
- >>> from xml.etree import ElementInclude
- >>> from xml.etree import ElementPath
- """
+class ModuleTest(unittest.TestCase):
+ # TODO: this should be removed once we get rid of the global module vars
+
+ def test_sanity(self):
+ # Import sanity.
+
+ from xml.etree import ElementTree
+ from xml.etree import ElementInclude
+ from xml.etree import ElementPath
-def check_method(method):
- if not hasattr(method, '__call__'):
- print method, "not callable"
def serialize(elem, to_string=True, **options):
- import StringIO
file = StringIO.StringIO()
tree = ET.ElementTree(elem)
tree.write(file, **options)
file.seek(0)
return file
-def summarize(elem):
- if elem.tag == ET.Comment:
- return "<Comment>"
- return elem.tag
-
def summarize_list(seq):
- return [summarize(elem) for elem in seq]
+ return [elem.tag for elem in seq]
def normalize_crlf(tree):
for elem in tree.iter():
if elem.tail:
elem.tail = elem.tail.replace("\r\n", "\n")
-def check_string(string):
- len(string)
- for char in string:
- if len(char) != 1:
- print "expected one-character string, got %r" % char
- new_string = string + ""
- new_string = string + " "
- string[:0]
-
-def check_mapping(mapping):
- len(mapping)
- keys = mapping.keys()
- items = mapping.items()
- for key in keys:
- item = mapping[key]
- mapping["key"] = "value"
- if mapping["key"] != "value":
- print "expected value string, got %r" % mapping["key"]
-
-def check_element(element):
- if not ET.iselement(element):
- print "not an element"
- if not hasattr(element, "tag"):
- print "no tag member"
- if not hasattr(element, "attrib"):
- print "no attrib member"
- if not hasattr(element, "text"):
- print "no text member"
- if not hasattr(element, "tail"):
- print "no tail member"
-
- check_string(element.tag)
- check_mapping(element.attrib)
- if element.text is not None:
- check_string(element.text)
- if element.tail is not None:
- check_string(element.tail)
- for elem in element:
- check_element(elem)
+def python_only(test):
+ def wrapper(*args):
+ if ET is not pyET:
+ raise unittest.SkipTest('only for the Python version')
+ return test(*args)
+ return wrapper
# --------------------------------------------------------------------
# element tree tests
-def interface():
- r"""
- Test element tree interface.
-
- >>> element = ET.Element("tag")
- >>> check_element(element)
- >>> tree = ET.ElementTree(element)
- >>> check_element(tree.getroot())
-
- >>> element = ET.Element("t\xe4g", key="value")
- >>> tree = ET.ElementTree(element)
- >>> repr(element) # doctest: +ELLIPSIS
- "<Element 't\\xe4g' at 0x...>"
- >>> element = ET.Element("tag", key="value")
-
- Make sure all standard element methods exist.
-
- >>> check_method(element.append)
- >>> check_method(element.extend)
- >>> check_method(element.insert)
- >>> check_method(element.remove)
- >>> check_method(element.getchildren)
- >>> check_method(element.find)
- >>> check_method(element.iterfind)
- >>> check_method(element.findall)
- >>> check_method(element.findtext)
- >>> check_method(element.clear)
- >>> check_method(element.get)
- >>> check_method(element.set)
- >>> check_method(element.keys)
- >>> check_method(element.items)
- >>> check_method(element.iter)
- >>> check_method(element.itertext)
- >>> check_method(element.getiterator)
-
- These methods return an iterable. See bug 6472.
-
- >>> check_method(element.iter("tag").next)
- >>> check_method(element.iterfind("tag").next)
- >>> check_method(element.iterfind("*").next)
- >>> check_method(tree.iter("tag").next)
- >>> check_method(tree.iterfind("tag").next)
- >>> check_method(tree.iterfind("*").next)
-
- These aliases are provided:
-
- >>> assert ET.XML == ET.fromstring
- >>> assert ET.PI == ET.ProcessingInstruction
- >>> assert ET.XMLParser == ET.XMLTreeBuilder
- """
-
-def simpleops():
- """
- Basic method sanity checks.
-
- >>> elem = ET.XML("<body><tag/></body>")
- >>> serialize(elem)
- '<body><tag /></body>'
- >>> e = ET.Element("tag2")
- >>> elem.append(e)
- >>> serialize(elem)
- '<body><tag /><tag2 /></body>'
- >>> elem.remove(e)
- >>> serialize(elem)
- '<body><tag /></body>'
- >>> elem.insert(0, e)
- >>> serialize(elem)
- '<body><tag2 /><tag /></body>'
- >>> elem.remove(e)
- >>> elem.extend([e])
- >>> serialize(elem)
- '<body><tag /><tag2 /></body>'
- >>> elem.remove(e)
-
- >>> element = ET.Element("tag", key="value")
- >>> serialize(element) # 1
- '<tag key="value" />'
- >>> subelement = ET.Element("subtag")
- >>> element.append(subelement)
- >>> serialize(element) # 2
- '<tag key="value"><subtag /></tag>'
- >>> element.insert(0, subelement)
- >>> serialize(element) # 3
- '<tag key="value"><subtag /><subtag /></tag>'
- >>> element.remove(subelement)
- >>> serialize(element) # 4
- '<tag key="value"><subtag /></tag>'
- >>> element.remove(subelement)
- >>> serialize(element) # 5
- '<tag key="value" />'
- >>> element.remove(subelement)
- Traceback (most recent call last):
- ValueError: list.remove(x): x not in list
- >>> serialize(element) # 6
- '<tag key="value" />'
- >>> element[0:0] = [subelement, subelement, subelement]
- >>> serialize(element[1])
- '<subtag />'
- >>> element[1:9] == [element[1], element[2]]
- True
- >>> element[:9:2] == [element[0], element[2]]
- True
- >>> del element[1:2]
- >>> serialize(element)
- '<tag key="value"><subtag /><subtag /></tag>'
- """
-
-def cdata():
- """
- Test CDATA handling (etc).
-
- >>> serialize(ET.XML("<tag>hello</tag>"))
- '<tag>hello</tag>'
- >>> serialize(ET.XML("<tag>hello</tag>"))
- '<tag>hello</tag>'
- >>> serialize(ET.XML("<tag><![CDATA[hello]]></tag>"))
- '<tag>hello</tag>'
- """
-
-# Only with Python implementation
-def simplefind():
- """
- Test find methods using the elementpath fallback.
-
- >>> from xml.etree import ElementTree
-
- >>> CurrentElementPath = ElementTree.ElementPath
- >>> ElementTree.ElementPath = ElementTree._SimpleElementPath()
- >>> elem = ElementTree.XML(SAMPLE_XML)
- >>> elem.find("tag").tag
- 'tag'
- >>> ElementTree.ElementTree(elem).find("tag").tag
- 'tag'
- >>> elem.findtext("tag")
- 'text'
- >>> elem.findtext("tog")
- >>> elem.findtext("tog", "default")
- 'default'
- >>> ElementTree.ElementTree(elem).findtext("tag")
- 'text'
- >>> summarize_list(elem.findall("tag"))
- ['tag', 'tag']
- >>> summarize_list(elem.findall(".//tag"))
- ['tag', 'tag', 'tag']
-
- Path syntax doesn't work in this case.
-
- >>> elem.find("section/tag")
- >>> elem.findtext("section/tag")
- >>> summarize_list(elem.findall("section/tag"))
- []
-
- >>> ElementTree.ElementPath = CurrentElementPath
- """
-
-def find():
- """
- Test find methods (including xpath syntax).
-
- >>> elem = ET.XML(SAMPLE_XML)
- >>> elem.find("tag").tag
- 'tag'
- >>> ET.ElementTree(elem).find("tag").tag
- 'tag'
- >>> elem.find("section/tag").tag
- 'tag'
- >>> elem.find("./tag").tag
- 'tag'
- >>> ET.ElementTree(elem).find("./tag").tag
- 'tag'
- >>> ET.ElementTree(elem).find("/tag").tag
- 'tag'
- >>> elem[2] = ET.XML(SAMPLE_SECTION)
- >>> elem.find("section/nexttag").tag
- 'nexttag'
- >>> ET.ElementTree(elem).find("section/tag").tag
- 'tag'
- >>> ET.ElementTree(elem).find("tog")
- >>> ET.ElementTree(elem).find("tog/foo")
- >>> elem.findtext("tag")
- 'text'
- >>> elem.findtext("section/nexttag")
- ''
- >>> elem.findtext("section/nexttag", "default")
- ''
- >>> elem.findtext("tog")
- >>> elem.findtext("tog", "default")
- 'default'
- >>> ET.ElementTree(elem).findtext("tag")
- 'text'
- >>> ET.ElementTree(elem).findtext("tog/foo")
- >>> ET.ElementTree(elem).findtext("tog/foo", "default")
- 'default'
- >>> ET.ElementTree(elem).findtext("./tag")
- 'text'
- >>> ET.ElementTree(elem).findtext("/tag")
- 'text'
- >>> elem.findtext("section/tag")
- 'subtext'
- >>> ET.ElementTree(elem).findtext("section/tag")
- 'subtext'
- >>> summarize_list(elem.findall("."))
- ['body']
- >>> summarize_list(elem.findall("tag"))
- ['tag', 'tag']
- >>> summarize_list(elem.findall("tog"))
- []
- >>> summarize_list(elem.findall("tog/foo"))
- []
- >>> summarize_list(elem.findall("*"))
- ['tag', 'tag', 'section']
- >>> summarize_list(elem.findall(".//tag"))
- ['tag', 'tag', 'tag', 'tag']
- >>> summarize_list(elem.findall("section/tag"))
- ['tag']
- >>> summarize_list(elem.findall("section//tag"))
- ['tag', 'tag']
- >>> summarize_list(elem.findall("section/*"))
- ['tag', 'nexttag', 'nextsection']
- >>> summarize_list(elem.findall("section//*"))
- ['tag', 'nexttag', 'nextsection', 'tag']
- >>> summarize_list(elem.findall("section/.//*"))
- ['tag', 'nexttag', 'nextsection', 'tag']
- >>> summarize_list(elem.findall("*/*"))
- ['tag', 'nexttag', 'nextsection']
- >>> summarize_list(elem.findall("*//*"))
- ['tag', 'nexttag', 'nextsection', 'tag']
- >>> summarize_list(elem.findall("*/tag"))
- ['tag']
- >>> summarize_list(elem.findall("*/./tag"))
- ['tag']
- >>> summarize_list(elem.findall("./tag"))
- ['tag', 'tag']
- >>> summarize_list(elem.findall(".//tag"))
- ['tag', 'tag', 'tag', 'tag']
- >>> summarize_list(elem.findall("././tag"))
- ['tag', 'tag']
- >>> summarize_list(elem.findall(".//tag[@class]"))
- ['tag', 'tag', 'tag']
- >>> summarize_list(elem.findall(".//tag[@class='a']"))
- ['tag']
- >>> summarize_list(elem.findall(".//tag[@class='b']"))
- ['tag', 'tag']
- >>> summarize_list(elem.findall(".//tag[@id]"))
- ['tag']
- >>> summarize_list(elem.findall(".//section[tag]"))
- ['section']
- >>> summarize_list(elem.findall(".//section[element]"))
- []
- >>> summarize_list(elem.findall("../tag"))
- []
- >>> summarize_list(elem.findall("section/../tag"))
- ['tag', 'tag']
- >>> summarize_list(ET.ElementTree(elem).findall("./tag"))
- ['tag', 'tag']
-
- Following example is invalid in 1.2.
- A leading '*' is assumed in 1.3.
-
- >>> elem.findall("section//") == elem.findall("section//*")
- True
-
- ET's Path module handles this case incorrectly; this gives
- a warning in 1.3, and the behaviour will be modified in 1.4.
-
- >>> summarize_list(ET.ElementTree(elem).findall("/tag"))
- ['tag', 'tag']
-
- >>> elem = ET.XML(SAMPLE_XML_NS)
- >>> summarize_list(elem.findall("tag"))
- []
- >>> summarize_list(elem.findall("{http://effbot.org/ns}tag"))
- ['{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag']
- >>> summarize_list(elem.findall(".//{http://effbot.org/ns}tag"))
- ['{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag']
- """
-
-def file_init():
- """
- >>> import StringIO
-
- >>> stringfile = StringIO.StringIO(SAMPLE_XML)
- >>> tree = ET.ElementTree(file=stringfile)
- >>> tree.find("tag").tag
- 'tag'
- >>> tree.find("section/tag").tag
- 'tag'
-
- >>> tree = ET.ElementTree(file=SIMPLE_XMLFILE)
- >>> tree.find("element").tag
- 'element'
- >>> tree.find("element/../empty-element").tag
- 'empty-element'
- """
-
-def bad_find():
- """
- Check bad or unsupported path expressions.
-
- >>> elem = ET.XML(SAMPLE_XML)
- >>> elem.findall("/tag")
- Traceback (most recent call last):
- SyntaxError: cannot use absolute path on element
- """
-
-def path_cache():
- """
- Check that the path cache behaves sanely.
-
- >>> elem = ET.XML(SAMPLE_XML)
- >>> for i in range(10): ET.ElementTree(elem).find('./'+str(i))
- >>> cache_len_10 = len(ET.ElementPath._cache)
- >>> for i in range(10): ET.ElementTree(elem).find('./'+str(i))
- >>> len(ET.ElementPath._cache) == cache_len_10
- True
- >>> for i in range(20): ET.ElementTree(elem).find('./'+str(i))
- >>> len(ET.ElementPath._cache) > cache_len_10
- True
- >>> for i in range(600): ET.ElementTree(elem).find('./'+str(i))
- >>> len(ET.ElementPath._cache) < 500
- True
- """
-
-def copy():
- """
- Test copy handling (etc).
-
- >>> import copy
- >>> e1 = ET.XML("<tag>hello<foo/></tag>")
- >>> e2 = copy.copy(e1)
- >>> e3 = copy.deepcopy(e1)
- >>> e1.find("foo").tag = "bar"
- >>> serialize(e1)
- '<tag>hello<bar /></tag>'
- >>> serialize(e2)
- '<tag>hello<bar /></tag>'
- >>> serialize(e3)
- '<tag>hello<foo /></tag>'
-
- """
-
-def attrib():
- """
- Test attribute handling.
-
- >>> elem = ET.Element("tag")
- >>> elem.get("key") # 1.1
- >>> elem.get("key", "default") # 1.2
- 'default'
- >>> elem.set("key", "value")
- >>> elem.get("key") # 1.3
- 'value'
-
- >>> elem = ET.Element("tag", key="value")
- >>> elem.get("key") # 2.1
- 'value'
- >>> elem.attrib # 2.2
- {'key': 'value'}
-
- >>> attrib = {"key": "value"}
- >>> elem = ET.Element("tag", attrib)
- >>> attrib.clear() # check for aliasing issues
- >>> elem.get("key") # 3.1
- 'value'
- >>> elem.attrib # 3.2
- {'key': 'value'}
-
- >>> attrib = {"key": "value"}
- >>> elem = ET.Element("tag", **attrib)
- >>> attrib.clear() # check for aliasing issues
- >>> elem.get("key") # 4.1
- 'value'
- >>> elem.attrib # 4.2
- {'key': 'value'}
-
- >>> elem = ET.Element("tag", {"key": "other"}, key="value")
- >>> elem.get("key") # 5.1
- 'value'
- >>> elem.attrib # 5.2
- {'key': 'value'}
-
- >>> elem = ET.Element('test')
- >>> elem.text = "aa"
- >>> elem.set('testa', 'testval')
- >>> elem.set('testb', 'test2')
- >>> ET.tostring(elem)
- '<test testa="testval" testb="test2">aa</test>'
- >>> sorted(elem.keys())
- ['testa', 'testb']
- >>> sorted(elem.items())
- [('testa', 'testval'), ('testb', 'test2')]
- >>> elem.attrib['testb']
- 'test2'
- >>> elem.attrib['testb'] = 'test1'
- >>> elem.attrib['testc'] = 'test2'
- >>> ET.tostring(elem)
- '<test testa="testval" testb="test1" testc="test2">aa</test>'
- """
-
-def makeelement():
- """
- Test makeelement handling.
-
- >>> elem = ET.Element("tag")
- >>> attrib = {"key": "value"}
- >>> subelem = elem.makeelement("subtag", attrib)
- >>> if subelem.attrib is attrib:
- ... print "attrib aliasing"
- >>> elem.append(subelem)
- >>> serialize(elem)
- '<tag><subtag key="value" /></tag>'
-
- >>> elem.clear()
- >>> serialize(elem)
- '<tag />'
- >>> elem.append(subelem)
- >>> serialize(elem)
- '<tag><subtag key="value" /></tag>'
- >>> elem.extend([subelem, subelem])
- >>> serialize(elem)
- '<tag><subtag key="value" /><subtag key="value" /><subtag key="value" /></tag>'
- >>> elem[:] = [subelem]
- >>> serialize(elem)
- '<tag><subtag key="value" /></tag>'
- >>> elem[:] = tuple([subelem])
- >>> serialize(elem)
- '<tag><subtag key="value" /></tag>'
-
- """
-
-def parsefile():
- """
- Test parsing from file.
-
- >>> tree = ET.parse(SIMPLE_XMLFILE)
- >>> normalize_crlf(tree)
- >>> tree.write(sys.stdout)
- <root>
- <element key="value">text</element>
- <element>text</element>tail
- <empty-element />
- </root>
- >>> tree = ET.parse(SIMPLE_NS_XMLFILE)
- >>> normalize_crlf(tree)
- >>> tree.write(sys.stdout)
- <ns0:root xmlns:ns0="namespace">
- <ns0:element key="value">text</ns0:element>
- <ns0:element>text</ns0:element>tail
- <ns0:empty-element />
- </ns0:root>
-
- >>> with open(SIMPLE_XMLFILE) as f:
- ... data = f.read()
-
- >>> parser = ET.XMLParser()
- >>> parser.version # doctest: +ELLIPSIS
- 'Expat ...'
- >>> parser.feed(data)
- >>> print serialize(parser.close())
- <root>
- <element key="value">text</element>
- <element>text</element>tail
- <empty-element />
- </root>
-
- >>> parser = ET.XMLTreeBuilder() # 1.2 compatibility
- >>> parser.feed(data)
- >>> print serialize(parser.close())
- <root>
- <element key="value">text</element>
- <element>text</element>tail
- <empty-element />
- </root>
-
- >>> target = ET.TreeBuilder()
- >>> parser = ET.XMLParser(target=target)
- >>> parser.feed(data)
- >>> print serialize(parser.close())
- <root>
- <element key="value">text</element>
- <element>text</element>tail
- <empty-element />
- </root>
- """
-
-def parseliteral():
- """
- >>> element = ET.XML("<html><body>text</body></html>")
- >>> ET.ElementTree(element).write(sys.stdout)
- <html><body>text</body></html>
- >>> element = ET.fromstring("<html><body>text</body></html>")
- >>> ET.ElementTree(element).write(sys.stdout)
- <html><body>text</body></html>
- >>> sequence = ["<html><body>", "text</bo", "dy></html>"]
- >>> element = ET.fromstringlist(sequence)
- >>> print ET.tostring(element)
- <html><body>text</body></html>
- >>> print "".join(ET.tostringlist(element))
- <html><body>text</body></html>
- >>> ET.tostring(element, "ascii")
- "<?xml version='1.0' encoding='ascii'?>\\n<html><body>text</body></html>"
- >>> _, ids = ET.XMLID("<html><body>text</body></html>")
- >>> len(ids)
- 0
- >>> _, ids = ET.XMLID("<html><body id='body'>text</body></html>")
- >>> len(ids)
- 1
- >>> ids["body"].tag
- 'body'
- """
-
-def iterparse():
- """
- Test iterparse interface.
-
- >>> iterparse = ET.iterparse
-
- >>> context = iterparse(SIMPLE_XMLFILE)
- >>> action, elem = next(context)
- >>> print action, elem.tag
- end element
- >>> for action, elem in context:
- ... print action, elem.tag
- end element
- end empty-element
- end root
- >>> context.root.tag
- 'root'
-
- >>> context = iterparse(SIMPLE_NS_XMLFILE)
- >>> for action, elem in context:
- ... print action, elem.tag
- end {namespace}element
- end {namespace}element
- end {namespace}empty-element
- end {namespace}root
-
- >>> events = ()
- >>> context = iterparse(SIMPLE_XMLFILE, events)
- >>> for action, elem in context:
- ... print action, elem.tag
-
- >>> events = ()
- >>> context = iterparse(SIMPLE_XMLFILE, events=events)
- >>> for action, elem in context:
- ... print action, elem.tag
-
- >>> events = ("start", "end")
- >>> context = iterparse(SIMPLE_XMLFILE, events)
- >>> for action, elem in context:
- ... print action, elem.tag
- start root
- start element
- end element
- start element
- end element
- start empty-element
- end empty-element
- end root
-
- >>> events = ("start", "end", "start-ns", "end-ns")
- >>> context = iterparse(SIMPLE_NS_XMLFILE, events)
- >>> for action, elem in context:
- ... if action in ("start", "end"):
- ... print action, elem.tag
- ... else:
- ... print action, elem
- start-ns ('', 'namespace')
- start {namespace}root
- start {namespace}element
- end {namespace}element
- start {namespace}element
- end {namespace}element
- start {namespace}empty-element
- end {namespace}empty-element
- end {namespace}root
- end-ns None
-
- >>> import StringIO
-
- >>> events = ('start-ns', 'end-ns')
- >>> context = ET.iterparse(StringIO.StringIO(r"<root xmlns=''/>"), events)
- >>> for action, elem in context:
- ... print action, elem
- start-ns ('', '')
- end-ns None
-
- >>> events = ("start", "end", "bogus")
- >>> with open(SIMPLE_XMLFILE, "rb") as f:
- ... iterparse(f, events)
- Traceback (most recent call last):
- ValueError: unknown event 'bogus'
-
- >>> source = StringIO.StringIO(
- ... "<?xml version='1.0' encoding='iso-8859-1'?>\\n"
- ... "<body xmlns='http://éffbot.org/ns'\\n"
- ... " xmlns:cl\\xe9='http://effbot.org/ns'>text</body>\\n")
- >>> events = ("start-ns",)
- >>> context = iterparse(source, events)
- >>> for action, elem in context:
- ... print action, elem
- start-ns ('', u'http://\\xe9ffbot.org/ns')
- start-ns (u'cl\\xe9', 'http://effbot.org/ns')
-
- >>> source = StringIO.StringIO("<document />junk")
- >>> try:
- ... for action, elem in iterparse(source):
- ... print action, elem.tag
- ... except ET.ParseError, v:
- ... print v
- end document
- junk after document element: line 1, column 12
- """
-
-def writefile():
- """
- >>> elem = ET.Element("tag")
- >>> elem.text = "text"
- >>> serialize(elem)
- '<tag>text</tag>'
- >>> ET.SubElement(elem, "subtag").text = "subtext"
- >>> serialize(elem)
- '<tag>text<subtag>subtext</subtag></tag>'
-
- Test tag suppression
- >>> elem.tag = None
- >>> serialize(elem)
- 'text<subtag>subtext</subtag>'
- >>> elem.insert(0, ET.Comment("comment"))
- >>> serialize(elem) # assumes 1.3
- 'text<!--comment--><subtag>subtext</subtag>'
- >>> elem[0] = ET.PI("key", "value")
- >>> serialize(elem)
- 'text<?key value?><subtag>subtext</subtag>'
- """
-
-def custom_builder():
- """
- Test parser w. custom builder.
-
- >>> with open(SIMPLE_XMLFILE) as f:
- ... data = f.read()
- >>> class Builder:
- ... def start(self, tag, attrib):
- ... print "start", tag
- ... def end(self, tag):
- ... print "end", tag
- ... def data(self, text):
- ... pass
- >>> builder = Builder()
- >>> parser = ET.XMLParser(target=builder)
- >>> parser.feed(data)
- start root
- start element
- end element
- start element
- end element
- start empty-element
- end empty-element
- end root
-
- >>> with open(SIMPLE_NS_XMLFILE) as f:
- ... data = f.read()
- >>> class Builder:
- ... def start(self, tag, attrib):
- ... print "start", tag
- ... def end(self, tag):
- ... print "end", tag
- ... def data(self, text):
- ... pass
- ... def pi(self, target, data):
- ... print "pi", target, repr(data)
- ... def comment(self, data):
- ... print "comment", repr(data)
- >>> builder = Builder()
- >>> parser = ET.XMLParser(target=builder)
- >>> parser.feed(data)
- pi pi 'data'
- comment ' comment '
- start {namespace}root
- start {namespace}element
- end {namespace}element
- start {namespace}element
- end {namespace}element
- start {namespace}empty-element
- end {namespace}empty-element
- end {namespace}root
-
- """
-
-def getchildren():
- """
- Test Element.getchildren()
-
- >>> with open(SIMPLE_XMLFILE, "r") as f:
- ... tree = ET.parse(f)
- >>> for elem in tree.getroot().iter():
- ... summarize_list(elem.getchildren())
- ['element', 'element', 'empty-element']
- []
- []
- []
- >>> for elem in tree.getiterator():
- ... summarize_list(elem.getchildren())
- ['element', 'element', 'empty-element']
- []
- []
- []
-
- >>> elem = ET.XML(SAMPLE_XML)
- >>> len(elem.getchildren())
- 3
- >>> len(elem[2].getchildren())
- 1
- >>> elem[:] == elem.getchildren()
- True
- >>> child1 = elem[0]
- >>> child2 = elem[2]
- >>> del elem[1:2]
- >>> len(elem.getchildren())
- 2
- >>> child1 == elem[0]
- True
- >>> child2 == elem[1]
- True
- >>> elem[0:2] = [child2, child1]
- >>> child2 == elem[0]
- True
- >>> child1 == elem[1]
- True
- >>> child1 == elem[0]
- False
- >>> elem.clear()
- >>> elem.getchildren()
- []
- """
-
-def writestring():
- """
- >>> elem = ET.XML("<html><body>text</body></html>")
- >>> ET.tostring(elem)
- '<html><body>text</body></html>'
- >>> elem = ET.fromstring("<html><body>text</body></html>")
- >>> ET.tostring(elem)
- '<html><body>text</body></html>'
- """
-
-def check_encoding(encoding):
- """
- >>> check_encoding("ascii")
- >>> check_encoding("us-ascii")
- >>> check_encoding("iso-8859-1")
- >>> check_encoding("iso-8859-15")
- >>> check_encoding("cp437")
- >>> check_encoding("mac-roman")
- >>> check_encoding("gbk")
- Traceback (most recent call last):
- ValueError: multi-byte encodings are not supported
- >>> check_encoding("cp037")
- Traceback (most recent call last):
- ParseError: unknown encoding: line 1, column 30
- """
- ET.XML("<?xml version='1.0' encoding='%s'?><xml />" % encoding)
-
-def encoding():
- r"""
- Test encoding issues.
-
- >>> elem = ET.Element("tag")
- >>> elem.text = u"abc"
- >>> serialize(elem)
- '<tag>abc</tag>'
- >>> serialize(elem, encoding="utf-8")
- '<tag>abc</tag>'
- >>> serialize(elem, encoding="us-ascii")
- '<tag>abc</tag>'
- >>> serialize(elem, encoding="iso-8859-1")
- "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>abc</tag>"
-
- >>> elem.text = "<&\"\'>"
- >>> serialize(elem)
- '<tag><&"\'></tag>'
- >>> serialize(elem, encoding="utf-8")
- '<tag><&"\'></tag>'
- >>> serialize(elem, encoding="us-ascii") # cdata characters
- '<tag><&"\'></tag>'
- >>> serialize(elem, encoding="iso-8859-1")
- '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag><&"\'></tag>'
-
- >>> elem.attrib["key"] = "<&\"\'>"
- >>> elem.text = None
- >>> serialize(elem)
- '<tag key="<&"\'>" />'
- >>> serialize(elem, encoding="utf-8")
- '<tag key="<&"\'>" />'
- >>> serialize(elem, encoding="us-ascii")
- '<tag key="<&"\'>" />'
- >>> serialize(elem, encoding="iso-8859-1")
- '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="<&"\'>" />'
-
- >>> elem.text = u'\xe5\xf6\xf6<>'
- >>> elem.attrib.clear()
- >>> serialize(elem)
- '<tag>åöö<></tag>'
- >>> serialize(elem, encoding="utf-8")
- '<tag>\xc3\xa5\xc3\xb6\xc3\xb6<></tag>'
- >>> serialize(elem, encoding="us-ascii")
- '<tag>åöö<></tag>'
- >>> serialize(elem, encoding="iso-8859-1")
- "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>\xe5\xf6\xf6<></tag>"
-
- >>> elem.attrib["key"] = u'\xe5\xf6\xf6<>'
- >>> elem.text = None
- >>> serialize(elem)
- '<tag key="åöö<>" />'
- >>> serialize(elem, encoding="utf-8")
- '<tag key="\xc3\xa5\xc3\xb6\xc3\xb6<>" />'
- >>> serialize(elem, encoding="us-ascii")
- '<tag key="åöö<>" />'
- >>> serialize(elem, encoding="iso-8859-1")
- '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="\xe5\xf6\xf6<>" />'
- """
-
-def methods():
- r"""
- Test serialization methods.
-
- >>> e = ET.XML("<html><link/><script>1 < 2</script></html>")
- >>> e.tail = "\n"
- >>> serialize(e)
- '<html><link /><script>1 < 2</script></html>\n'
- >>> serialize(e, method=None)
- '<html><link /><script>1 < 2</script></html>\n'
- >>> serialize(e, method="xml")
- '<html><link /><script>1 < 2</script></html>\n'
- >>> serialize(e, method="html")
- '<html><link><script>1 < 2</script></html>\n'
- >>> serialize(e, method="text")
- '1 < 2\n'
- """
-
-def iterators():
- """
- Test iterators.
-
- >>> e = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>")
- >>> summarize_list(e.iter())
- ['html', 'body', 'i']
- >>> summarize_list(e.find("body").iter())
- ['body', 'i']
- >>> summarize(next(e.iter()))
- 'html'
- >>> "".join(e.itertext())
- 'this is a paragraph...'
- >>> "".join(e.find("body").itertext())
- 'this is a paragraph.'
- >>> next(e.itertext())
- 'this is a '
-
- Method iterparse should return an iterator. See bug 6472.
-
- >>> sourcefile = serialize(e, to_string=False)
- >>> next(ET.iterparse(sourcefile)) # doctest: +ELLIPSIS
- ('end', <Element 'i' at 0x...>)
-
- >>> tree = ET.ElementTree(None)
- >>> tree.iter()
- Traceback (most recent call last):
- AttributeError: 'NoneType' object has no attribute 'iter'
- """
+class ElementTreeTest(unittest.TestCase):
+
+ def serialize_check(self, elem, expected):
+ self.assertEqual(serialize(elem), expected)
+
+ def test_interface(self):
+ # Test element tree interface.
+
+ def check_string(string):
+ len(string)
+ for char in string:
+ self.assertEqual(len(char), 1,
+ msg="expected one-character string, got %r" % char)
+ new_string = string + ""
+ new_string = string + " "
+ string[:0]
+
+ def check_mapping(mapping):
+ len(mapping)
+ keys = mapping.keys()
+ items = mapping.items()
+ for key in keys:
+ item = mapping[key]
+ mapping["key"] = "value"
+ self.assertEqual(mapping["key"], "value",
+ msg="expected value string, got %r" % mapping["key"])
+
+ def check_element(element):
+ self.assertTrue(ET.iselement(element), msg="not an element")
+ self.assertTrue(hasattr(element, "tag"), msg="no tag member")
+ self.assertTrue(hasattr(element, "attrib"), msg="no attrib member")
+ self.assertTrue(hasattr(element, "text"), msg="no text member")
+ self.assertTrue(hasattr(element, "tail"), msg="no tail member")
+
+ check_string(element.tag)
+ check_mapping(element.attrib)
+ if element.text is not None:
+ check_string(element.text)
+ if element.tail is not None:
+ check_string(element.tail)
+ for elem in element:
+ check_element(elem)
+
+ element = ET.Element("tag")
+ check_element(element)
+ tree = ET.ElementTree(element)
+ check_element(tree.getroot())
+ element = ET.Element("t\xe4g", key="value")
+ tree = ET.ElementTree(element)
+ self.assertRegexpMatches(repr(element), r"^<Element 't\\xe4g' at 0x.*>$")
+ element = ET.Element("tag", key="value")
+
+ # Make sure all standard element methods exist.
+
+ def check_method(method):
+ self.assertTrue(hasattr(method, '__call__'),
+ msg="%s not callable" % method)
+
+ check_method(element.append)
+ check_method(element.extend)
+ check_method(element.insert)
+ check_method(element.remove)
+ check_method(element.getchildren)
+ check_method(element.find)
+ check_method(element.iterfind)
+ check_method(element.findall)
+ check_method(element.findtext)
+ check_method(element.clear)
+ check_method(element.get)
+ check_method(element.set)
+ check_method(element.keys)
+ check_method(element.items)
+ check_method(element.iter)
+ check_method(element.itertext)
+ check_method(element.getiterator)
+
+ # These methods return an iterable. See bug 6472.
+
+ def check_iter(it):
+ check_method(it.next)
+
+ check_iter(element.iter("tag"))
+ check_iter(element.iterfind("tag"))
+ check_iter(element.iterfind("*"))
+ check_iter(tree.iter("tag"))
+ check_iter(tree.iterfind("tag"))
+ check_iter(tree.iterfind("*"))
+
+ # These aliases are provided:
+
+ self.assertEqual(ET.XML, ET.fromstring)
+ self.assertEqual(ET.PI, ET.ProcessingInstruction)
+ self.assertEqual(ET.XMLParser, ET.XMLTreeBuilder)
+
+ def test_set_attribute(self):
+ element = ET.Element('tag')
+
+ self.assertEqual(element.tag, 'tag')
+ element.tag = 'Tag'
+ self.assertEqual(element.tag, 'Tag')
+ element.tag = 'TAG'
+ self.assertEqual(element.tag, 'TAG')
+
+ self.assertIsNone(element.text)
+ element.text = 'Text'
+ self.assertEqual(element.text, 'Text')
+ element.text = 'TEXT'
+ self.assertEqual(element.text, 'TEXT')
+
+ self.assertIsNone(element.tail)
+ element.tail = 'Tail'
+ self.assertEqual(element.tail, 'Tail')
+ element.tail = 'TAIL'
+ self.assertEqual(element.tail, 'TAIL')
+
+ self.assertEqual(element.attrib, {})
+ element.attrib = {'a': 'b', 'c': 'd'}
+ self.assertEqual(element.attrib, {'a': 'b', 'c': 'd'})
+ element.attrib = {'A': 'B', 'C': 'D'}
+ self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
+
+ def test_simpleops(self):
+ # Basic method sanity checks.
+
+ elem = ET.XML("<body><tag/></body>")
+ self.serialize_check(elem, '<body><tag /></body>')
+ e = ET.Element("tag2")
+ elem.append(e)
+ self.serialize_check(elem, '<body><tag /><tag2 /></body>')
+ elem.remove(e)
+ self.serialize_check(elem, '<body><tag /></body>')
+ elem.insert(0, e)
+ self.serialize_check(elem, '<body><tag2 /><tag /></body>')
+ elem.remove(e)
+ elem.extend([e])
+ self.serialize_check(elem, '<body><tag /><tag2 /></body>')
+ elem.remove(e)
+
+ element = ET.Element("tag", key="value")
+ self.serialize_check(element, '<tag key="value" />') # 1
+ subelement = ET.Element("subtag")
+ element.append(subelement)
+ self.serialize_check(element, '<tag key="value"><subtag /></tag>') # 2
+ element.insert(0, subelement)
+ self.serialize_check(element,
+ '<tag key="value"><subtag /><subtag /></tag>') # 3
+ element.remove(subelement)
+ self.serialize_check(element, '<tag key="value"><subtag /></tag>') # 4
+ element.remove(subelement)
+ self.serialize_check(element, '<tag key="value" />') # 5
+ with self.assertRaises(ValueError) as cm:
+ element.remove(subelement)
+ self.assertEqual(str(cm.exception), 'list.remove(x): x not in list')
+ self.serialize_check(element, '<tag key="value" />') # 6
+ element[0:0] = [subelement, subelement, subelement]
+ self.serialize_check(element[1], '<subtag />')
+ self.assertEqual(element[1:9], [element[1], element[2]])
+ self.assertEqual(element[:9:2], [element[0], element[2]])
+ del element[1:2]
+ self.serialize_check(element,
+ '<tag key="value"><subtag /><subtag /></tag>')
+
+ def test_cdata(self):
+ # Test CDATA handling (etc).
+
+ self.serialize_check(ET.XML("<tag>hello</tag>"),
+ '<tag>hello</tag>')
+ self.serialize_check(ET.XML("<tag>hello</tag>"),
+ '<tag>hello</tag>')
+ self.serialize_check(ET.XML("<tag><![CDATA[hello]]></tag>"),
+ '<tag>hello</tag>')
+
+ def test_file_init(self):
+ stringfile = StringIO.StringIO(SAMPLE_XML.encode("utf-8"))
+ tree = ET.ElementTree(file=stringfile)
+ self.assertEqual(tree.find("tag").tag, 'tag')
+ self.assertEqual(tree.find("section/tag").tag, 'tag')
+
+ tree = ET.ElementTree(file=SIMPLE_XMLFILE)
+ self.assertEqual(tree.find("element").tag, 'element')
+ self.assertEqual(tree.find("element/../empty-element").tag,
+ 'empty-element')
+
+ def test_path_cache(self):
+ # Check that the path cache behaves sanely.
+
+ from xml.etree import ElementPath
+
+ elem = ET.XML(SAMPLE_XML)
+ for i in range(10): ET.ElementTree(elem).find('./'+str(i))
+ cache_len_10 = len(ElementPath._cache)
+ for i in range(10): ET.ElementTree(elem).find('./'+str(i))
+ self.assertEqual(len(ElementPath._cache), cache_len_10)
+ for i in range(20): ET.ElementTree(elem).find('./'+str(i))
+ self.assertGreater(len(ElementPath._cache), cache_len_10)
+ for i in range(600): ET.ElementTree(elem).find('./'+str(i))
+ self.assertLess(len(ElementPath._cache), 500)
+
+ def test_copy(self):
+ # Test copy handling (etc).
+
+ import copy
+ e1 = ET.XML("<tag>hello<foo/></tag>")
+ e2 = copy.copy(e1)
+ e3 = copy.deepcopy(e1)
+ e1.find("foo").tag = "bar"
+ self.serialize_check(e1, '<tag>hello<bar /></tag>')
+ self.serialize_check(e2, '<tag>hello<bar /></tag>')
+ self.serialize_check(e3, '<tag>hello<foo /></tag>')
+
+ def test_attrib(self):
+ # Test attribute handling.
+
+ elem = ET.Element("tag")
+ elem.get("key") # 1.1
+ self.assertEqual(elem.get("key", "default"), 'default') # 1.2
+
+ elem.set("key", "value")
+ self.assertEqual(elem.get("key"), 'value') # 1.3
+
+ elem = ET.Element("tag", key="value")
+ self.assertEqual(elem.get("key"), 'value') # 2.1
+ self.assertEqual(elem.attrib, {'key': 'value'}) # 2.2
+
+ attrib = {"key": "value"}
+ elem = ET.Element("tag", attrib)
+ attrib.clear() # check for aliasing issues
+ self.assertEqual(elem.get("key"), 'value') # 3.1
+ self.assertEqual(elem.attrib, {'key': 'value'}) # 3.2
+
+ attrib = {"key": "value"}
+ elem = ET.Element("tag", **attrib)
+ attrib.clear() # check for aliasing issues
+ self.assertEqual(elem.get("key"), 'value') # 4.1
+ self.assertEqual(elem.attrib, {'key': 'value'}) # 4.2
+
+ elem = ET.Element("tag", {"key": "other"}, key="value")
+ self.assertEqual(elem.get("key"), 'value') # 5.1
+ self.assertEqual(elem.attrib, {'key': 'value'}) # 5.2
+
+ elem = ET.Element('test')
+ elem.text = "aa"
+ elem.set('testa', 'testval')
+ elem.set('testb', 'test2')
+ self.assertEqual(ET.tostring(elem),
+ b'<test testa="testval" testb="test2">aa</test>')
+ self.assertEqual(sorted(elem.keys()), ['testa', 'testb'])
+ self.assertEqual(sorted(elem.items()),
+ [('testa', 'testval'), ('testb', 'test2')])
+ self.assertEqual(elem.attrib['testb'], 'test2')
+ elem.attrib['testb'] = 'test1'
+ elem.attrib['testc'] = 'test2'
+ self.assertEqual(ET.tostring(elem),
+ b'<test testa="testval" testb="test1" testc="test2">aa</test>')
+
+ elem = ET.Element('test')
+ elem.set('a', '\r')
+ elem.set('b', '\r\n')
+ elem.set('c', '\t\n\r ')
+ elem.set('d', '\n\n')
+ self.assertEqual(ET.tostring(elem),
+ b'<test a="\r" b="\r " c="\t \r " d=" " />')
+
+ def test_makeelement(self):
+ # Test makeelement handling.
+
+ elem = ET.Element("tag")
+ attrib = {"key": "value"}
+ subelem = elem.makeelement("subtag", attrib)
+ self.assertIsNot(subelem.attrib, attrib, msg="attrib aliasing")
+ elem.append(subelem)
+ self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
+
+ elem.clear()
+ self.serialize_check(elem, '<tag />')
+ elem.append(subelem)
+ self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
+ elem.extend([subelem, subelem])
+ self.serialize_check(elem,
+ '<tag><subtag key="value" /><subtag key="value" /><subtag key="value" /></tag>')
+ elem[:] = [subelem]
+ self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
+ elem[:] = tuple([subelem])
+ self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
+
+ def test_parsefile(self):
+ # Test parsing from file.
+
+ tree = ET.parse(SIMPLE_XMLFILE)
+ normalize_crlf(tree)
+ stream = StringIO.StringIO()
+ tree.write(stream)
+ self.assertEqual(stream.getvalue(),
+ '<root>\n'
+ ' <element key="value">text</element>\n'
+ ' <element>text</element>tail\n'
+ ' <empty-element />\n'
+ '</root>')
+ tree = ET.parse(SIMPLE_NS_XMLFILE)
+ normalize_crlf(tree)
+ stream = StringIO.StringIO()
+ tree.write(stream)
+ self.assertEqual(stream.getvalue(),
+ '<ns0:root xmlns:ns0="namespace">\n'
+ ' <ns0:element key="value">text</ns0:element>\n'
+ ' <ns0:element>text</ns0:element>tail\n'
+ ' <ns0:empty-element />\n'
+ '</ns0:root>')
+
+ with open(SIMPLE_XMLFILE) as f:
+ data = f.read()
+
+ parser = ET.XMLParser()
+ self.assertRegexpMatches(parser.version, r'^Expat ')
+ parser.feed(data)
+ self.serialize_check(parser.close(),
+ '<root>\n'
+ ' <element key="value">text</element>\n'
+ ' <element>text</element>tail\n'
+ ' <empty-element />\n'
+ '</root>')
+
+ parser = ET.XMLTreeBuilder() # 1.2 compatibility
+ parser.feed(data)
+ self.serialize_check(parser.close(),
+ '<root>\n'
+ ' <element key="value">text</element>\n'
+ ' <element>text</element>tail\n'
+ ' <empty-element />\n'
+ '</root>')
+
+ target = ET.TreeBuilder()
+ parser = ET.XMLParser(target=target)
+ parser.feed(data)
+ self.serialize_check(parser.close(),
+ '<root>\n'
+ ' <element key="value">text</element>\n'
+ ' <element>text</element>tail\n'
+ ' <empty-element />\n'
+ '</root>')
+
+ def test_parseliteral(self):
+ element = ET.XML("<html><body>text</body></html>")
+ self.assertEqual(ET.tostring(element),
+ '<html><body>text</body></html>')
+ element = ET.fromstring("<html><body>text</body></html>")
+ self.assertEqual(ET.tostring(element),
+ '<html><body>text</body></html>')
+ sequence = ["<html><body>", "text</bo", "dy></html>"]
+ element = ET.fromstringlist(sequence)
+ self.assertEqual(ET.tostring(element),
+ '<html><body>text</body></html>')
+ self.assertEqual("".join(ET.tostringlist(element)),
+ '<html><body>text</body></html>')
+ self.assertEqual(ET.tostring(element, "ascii"),
+ "<?xml version='1.0' encoding='ascii'?>\n"
+ "<html><body>text</body></html>")
+ _, ids = ET.XMLID("<html><body>text</body></html>")
+ self.assertEqual(len(ids), 0)
+ _, ids = ET.XMLID("<html><body id='body'>text</body></html>")
+ self.assertEqual(len(ids), 1)
+ self.assertEqual(ids["body"].tag, 'body')
+
+ def test_iterparse(self):
+ # Test iterparse interface.
+
+ iterparse = ET.iterparse
+
+ context = iterparse(SIMPLE_XMLFILE)
+ action, elem = next(context)
+ self.assertEqual((action, elem.tag), ('end', 'element'))
+ self.assertEqual([(action, elem.tag) for action, elem in context], [
+ ('end', 'element'),
+ ('end', 'empty-element'),
+ ('end', 'root'),
+ ])
+ self.assertEqual(context.root.tag, 'root')
+
+ context = iterparse(SIMPLE_NS_XMLFILE)
+ self.assertEqual([(action, elem.tag) for action, elem in context], [
+ ('end', '{namespace}element'),
+ ('end', '{namespace}element'),
+ ('end', '{namespace}empty-element'),
+ ('end', '{namespace}root'),
+ ])
+
+ events = ()
+ context = iterparse(SIMPLE_XMLFILE, events)
+ self.assertEqual([(action, elem.tag) for action, elem in context], [])
+
+ events = ()
+ context = iterparse(SIMPLE_XMLFILE, events=events)
+ self.assertEqual([(action, elem.tag) for action, elem in context], [])
+
+ events = ("start", "end")
+ context = iterparse(SIMPLE_XMLFILE, events)
+ self.assertEqual([(action, elem.tag) for action, elem in context], [
+ ('start', 'root'),
+ ('start', 'element'),
+ ('end', 'element'),
+ ('start', 'element'),
+ ('end', 'element'),
+ ('start', 'empty-element'),
+ ('end', 'empty-element'),
+ ('end', 'root'),
+ ])
+
+ events = ("start", "end", "start-ns", "end-ns")
+ context = iterparse(SIMPLE_NS_XMLFILE, events)
+ self.assertEqual([(action, elem.tag) if action in ("start", "end")
+ else (action, elem)
+ for action, elem in context], [
+ ('start-ns', ('', 'namespace')),
+ ('start', '{namespace}root'),
+ ('start', '{namespace}element'),
+ ('end', '{namespace}element'),
+ ('start', '{namespace}element'),
+ ('end', '{namespace}element'),
+ ('start', '{namespace}empty-element'),
+ ('end', '{namespace}empty-element'),
+ ('end', '{namespace}root'),
+ ('end-ns', None),
+ ])
+
+ events = ('start-ns', 'end-ns')
+ context = iterparse(StringIO.StringIO(r"<root xmlns=''/>"), events)
+ res = [(action, elem) for action, elem in context]
+ self.assertEqual(res, [('start-ns', ('', '')), ('end-ns', None)])
+
+ events = ("start", "end", "bogus")
+ with open(SIMPLE_XMLFILE, "rb") as f:
+ with self.assertRaises(ValueError) as cm:
+ iterparse(f, events)
+ self.assertFalse(f.closed)
+ self.assertEqual(str(cm.exception), "unknown event 'bogus'")
+
+ source = StringIO.StringIO(
+ "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+ "<body xmlns='http://éffbot.org/ns'\n"
+ " xmlns:cl\xe9='http://effbot.org/ns'>text</body>\n")
+ events = ("start-ns",)
+ context = iterparse(source, events)
+ self.assertEqual([(action, elem) for action, elem in context], [
+ ('start-ns', ('', u'http://\xe9ffbot.org/ns')),
+ ('start-ns', (u'cl\xe9', 'http://effbot.org/ns')),
+ ])
+
+ source = StringIO.StringIO("<document />junk")
+ it = iterparse(source)
+ action, elem = next(it)
+ self.assertEqual((action, elem.tag), ('end', 'document'))
+ with self.assertRaises(ET.ParseError) as cm:
+ next(it)
+ self.assertEqual(str(cm.exception),
+ 'junk after document element: line 1, column 12')
+
+ def test_writefile(self):
+ elem = ET.Element("tag")
+ elem.text = "text"
+ self.serialize_check(elem, '<tag>text</tag>')
+ ET.SubElement(elem, "subtag").text = "subtext"
+ self.serialize_check(elem, '<tag>text<subtag>subtext</subtag></tag>')
+
+ # Test tag suppression
+ elem.tag = None
+ self.serialize_check(elem, 'text<subtag>subtext</subtag>')
+ elem.insert(0, ET.Comment("comment"))
+ self.serialize_check(elem,
+ 'text<!--comment--><subtag>subtext</subtag>') # assumes 1.3
+
+ elem[0] = ET.PI("key", "value")
+ self.serialize_check(elem, 'text<?key value?><subtag>subtext</subtag>')
+
+ def test_custom_builder(self):
+ # Test parser w. custom builder.
+
+ with open(SIMPLE_XMLFILE) as f:
+ data = f.read()
+ class Builder(list):
+ def start(self, tag, attrib):
+ self.append(("start", tag))
+ def end(self, tag):
+ self.append(("end", tag))
+ def data(self, text):
+ pass
+ builder = Builder()
+ parser = ET.XMLParser(target=builder)
+ parser.feed(data)
+ self.assertEqual(builder, [
+ ('start', 'root'),
+ ('start', 'element'),
+ ('end', 'element'),
+ ('start', 'element'),
+ ('end', 'element'),
+ ('start', 'empty-element'),
+ ('end', 'empty-element'),
+ ('end', 'root'),
+ ])
+
+ with open(SIMPLE_NS_XMLFILE) as f:
+ data = f.read()
+ class Builder(list):
+ def start(self, tag, attrib):
+ self.append(("start", tag))
+ def end(self, tag):
+ self.append(("end", tag))
+ def data(self, text):
+ pass
+ def pi(self, target, data):
+ self.append(("pi", target, data))
+ def comment(self, data):
+ self.append(("comment", data))
+ builder = Builder()
+ parser = ET.XMLParser(target=builder)
+ parser.feed(data)
+ self.assertEqual(builder, [
+ ('pi', 'pi', 'data'),
+ ('comment', ' comment '),
+ ('start', '{namespace}root'),
+ ('start', '{namespace}element'),
+ ('end', '{namespace}element'),
+ ('start', '{namespace}element'),
+ ('end', '{namespace}element'),
+ ('start', '{namespace}empty-element'),
+ ('end', '{namespace}empty-element'),
+ ('end', '{namespace}root'),
+ ])
+
+
+ # Element.getchildren() and ElementTree.getiterator() are deprecated.
+ @checkwarnings(("This method will be removed in future versions. "
+ "Use .+ instead.",
+ (DeprecationWarning, PendingDeprecationWarning)))
+ def test_getchildren(self):
+ # Test Element.getchildren()
+
+ with open(SIMPLE_XMLFILE, "r") as f:
+ tree = ET.parse(f)
+ self.assertEqual([summarize_list(elem.getchildren())
+ for elem in tree.getroot().iter()], [
+ ['element', 'element', 'empty-element'],
+ [],
+ [],
+ [],
+ ])
+ self.assertEqual([summarize_list(elem.getchildren())
+ for elem in tree.getiterator()], [
+ ['element', 'element', 'empty-element'],
+ [],
+ [],
+ [],
+ ])
+
+ elem = ET.XML(SAMPLE_XML)
+ self.assertEqual(len(elem.getchildren()), 3)
+ self.assertEqual(len(elem[2].getchildren()), 1)
+ self.assertEqual(elem[:], elem.getchildren())
+ child1 = elem[0]
+ child2 = elem[2]
+ del elem[1:2]
+ self.assertEqual(len(elem.getchildren()), 2)
+ self.assertEqual(child1, elem[0])
+ self.assertEqual(child2, elem[1])
+ elem[0:2] = [child2, child1]
+ self.assertEqual(child2, elem[0])
+ self.assertEqual(child1, elem[1])
+ self.assertNotEqual(child1, elem[0])
+ elem.clear()
+ self.assertEqual(elem.getchildren(), [])
+
+ def test_writestring(self):
+ elem = ET.XML("<html><body>text</body></html>")
+ self.assertEqual(ET.tostring(elem), b'<html><body>text</body></html>')
+ elem = ET.fromstring("<html><body>text</body></html>")
+ self.assertEqual(ET.tostring(elem), b'<html><body>text</body></html>')
+
+ def test_encoding(self):
+ def check(encoding, body=''):
+ xml = ("<?xml version='1.0' encoding='%s'?><xml>%s</xml>" %
+ (encoding, body))
+ self.assertEqual(ET.XML(xml.encode(encoding)).text, body)
+ check("ascii", 'a')
+ check("us-ascii", 'a')
+ check("iso-8859-1", u'\xbd')
+ check("iso-8859-15", u'\u20ac')
+ check("cp437", u'\u221a')
+ check("mac-roman", u'\u02da')
+
+ def xml(encoding):
+ return "<?xml version='1.0' encoding='%s'?><xml />" % encoding
+ def bxml(encoding):
+ return xml(encoding).encode(encoding)
+ supported_encodings = [
+ 'ascii', 'utf-8', 'utf-8-sig', 'utf-16', 'utf-16be', 'utf-16le',
+ 'iso8859-1', 'iso8859-2', 'iso8859-3', 'iso8859-4', 'iso8859-5',
+ 'iso8859-6', 'iso8859-7', 'iso8859-8', 'iso8859-9', 'iso8859-10',
+ 'iso8859-13', 'iso8859-14', 'iso8859-15', 'iso8859-16',
+ 'cp437', 'cp720', 'cp737', 'cp775', 'cp850', 'cp852',
+ 'cp855', 'cp856', 'cp857', 'cp858', 'cp860', 'cp861', 'cp862',
+ 'cp863', 'cp865', 'cp866', 'cp869', 'cp874', 'cp1006',
+ 'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
+ 'cp1256', 'cp1257', 'cp1258',
+ 'mac-cyrillic', 'mac-greek', 'mac-iceland', 'mac-latin2',
+ 'mac-roman', 'mac-turkish',
+ 'iso2022-jp', 'iso2022-jp-1', 'iso2022-jp-2', 'iso2022-jp-2004',
+ 'iso2022-jp-3', 'iso2022-jp-ext',
+ 'koi8-r', 'koi8-u',
+ 'ptcp154',
+ ]
+ for encoding in supported_encodings:
+ self.assertEqual(ET.tostring(ET.XML(bxml(encoding))), b'<xml />')
+
+ unsupported_ascii_compatible_encodings = [
+ 'big5', 'big5hkscs',
+ 'cp932', 'cp949', 'cp950',
+ 'euc-jp', 'euc-jis-2004', 'euc-jisx0213', 'euc-kr',
+ 'gb2312', 'gbk', 'gb18030',
+ 'iso2022-kr', 'johab', 'hz',
+ 'shift-jis', 'shift-jis-2004', 'shift-jisx0213',
+ 'utf-7',
+ ]
+ for encoding in unsupported_ascii_compatible_encodings:
+ self.assertRaises(ValueError, ET.XML, bxml(encoding))
+
+ unsupported_ascii_incompatible_encodings = [
+ 'cp037', 'cp424', 'cp500', 'cp864', 'cp875', 'cp1026', 'cp1140',
+ 'utf_32', 'utf_32_be', 'utf_32_le',
+ ]
+ for encoding in unsupported_ascii_incompatible_encodings:
+ self.assertRaises(ET.ParseError, ET.XML, bxml(encoding))
+
+ self.assertRaises(ValueError, ET.XML, xml('undefined').encode('ascii'))
+ self.assertRaises(LookupError, ET.XML, xml('xxx').encode('ascii'))
+
+ def test_methods(self):
+ # Test serialization methods.
+
+ e = ET.XML("<html><link/><script>1 < 2</script></html>")
+ e.tail = "\n"
+ self.assertEqual(serialize(e),
+ '<html><link /><script>1 < 2</script></html>\n')
+ self.assertEqual(serialize(e, method=None),
+ '<html><link /><script>1 < 2</script></html>\n')
+ self.assertEqual(serialize(e, method="xml"),
+ '<html><link /><script>1 < 2</script></html>\n')
+ self.assertEqual(serialize(e, method="html"),
+ '<html><link><script>1 < 2</script></html>\n')
+ self.assertEqual(serialize(e, method="text"), '1 < 2\n')
+
+ def test_issue18347(self):
+ e = ET.XML('<html><CamelCase>text</CamelCase></html>')
+ self.assertEqual(serialize(e),
+ '<html><CamelCase>text</CamelCase></html>')
+ self.assertEqual(serialize(e, method="html"),
+ '<html><CamelCase>text</CamelCase></html>')
+
+ def test_entity(self):
+ # Test entity handling.
+
+ # 1) good entities
+
+ e = ET.XML("<document title='舰'>test</document>")
+ self.assertEqual(serialize(e, encoding="us-ascii"),
+ '<document title="舰">test</document>')
+ self.serialize_check(e, '<document title="舰">test</document>')
+
+ # 2) bad entities
+
+ with self.assertRaises(ET.ParseError) as cm:
+ ET.XML("<document>&entity;</document>")
+ self.assertEqual(str(cm.exception),
+ 'undefined entity: line 1, column 10')
+
+ with self.assertRaises(ET.ParseError) as cm:
+ ET.XML(ENTITY_XML)
+ self.assertEqual(str(cm.exception),
+ 'undefined entity &entity;: line 5, column 10')
+
+ # 3) custom entity
+
+ parser = ET.XMLParser()
+ parser.entity["entity"] = "text"
+ parser.feed(ENTITY_XML)
+ root = parser.close()
+ self.serialize_check(root, '<document>text</document>')
+
+ def test_namespace(self):
+ # Test namespace issues.
+
+ # 1) xml namespace
+
+ elem = ET.XML("<tag xml:lang='en' />")
+ self.serialize_check(elem, '<tag xml:lang="en" />') # 1.1
+
+ # 2) other "well-known" namespaces
+
+ elem = ET.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />")
+ self.serialize_check(elem,
+ '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" />') # 2.1
+
+ elem = ET.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />")
+ self.serialize_check(elem,
+ '<html:html xmlns:html="http://www.w3.org/1999/xhtml" />') # 2.2
+
+ elem = ET.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />")
+ self.serialize_check(elem,
+ '<ns0:Envelope xmlns:ns0="http://schemas.xmlsoap.org/soap/envelope" />') # 2.3
+
+ # 3) unknown namespaces
+ elem = ET.XML(SAMPLE_XML_NS)
+ self.serialize_check(elem,
+ '<ns0:body xmlns:ns0="http://effbot.org/ns">\n'
+ ' <ns0:tag>text</ns0:tag>\n'
+ ' <ns0:tag />\n'
+ ' <ns0:section>\n'
+ ' <ns0:tag>subtext</ns0:tag>\n'
+ ' </ns0:section>\n'
+ '</ns0:body>')
+
+ def test_qname(self):
+ # Test QName handling.
+
+ # 1) decorated tags
+
+ elem = ET.Element("{uri}tag")
+ self.serialize_check(elem, '<ns0:tag xmlns:ns0="uri" />') # 1.1
+ elem = ET.Element(ET.QName("{uri}tag"))
+ self.serialize_check(elem, '<ns0:tag xmlns:ns0="uri" />') # 1.2
+ elem = ET.Element(ET.QName("uri", "tag"))
+ self.serialize_check(elem, '<ns0:tag xmlns:ns0="uri" />') # 1.3
+ elem = ET.Element(ET.QName("uri", "tag"))
+ subelem = ET.SubElement(elem, ET.QName("uri", "tag1"))
+ subelem = ET.SubElement(elem, ET.QName("uri", "tag2"))
+ self.serialize_check(elem,
+ '<ns0:tag xmlns:ns0="uri"><ns0:tag1 /><ns0:tag2 /></ns0:tag>') # 1.4
+
+ # 2) decorated attributes
+
+ elem.clear()
+ elem.attrib["{uri}key"] = "value"
+ self.serialize_check(elem,
+ '<ns0:tag xmlns:ns0="uri" ns0:key="value" />') # 2.1
+
+ elem.clear()
+ elem.attrib[ET.QName("{uri}key")] = "value"
+ self.serialize_check(elem,
+ '<ns0:tag xmlns:ns0="uri" ns0:key="value" />') # 2.2
+
+ # 3) decorated values are not converted by default, but the
+ # QName wrapper can be used for values
+
+ elem.clear()
+ elem.attrib["{uri}key"] = "{uri}value"
+ self.serialize_check(elem,
+ '<ns0:tag xmlns:ns0="uri" ns0:key="{uri}value" />') # 3.1
+
+ elem.clear()
+ elem.attrib["{uri}key"] = ET.QName("{uri}value")
+ self.serialize_check(elem,
+ '<ns0:tag xmlns:ns0="uri" ns0:key="ns0:value" />') # 3.2
+
+ elem.clear()
+ subelem = ET.Element("tag")
+ subelem.attrib["{uri1}key"] = ET.QName("{uri2}value")
+ elem.append(subelem)
+ elem.append(subelem)
+ self.serialize_check(elem,
+ '<ns0:tag xmlns:ns0="uri" xmlns:ns1="uri1" xmlns:ns2="uri2">'
+ '<tag ns1:key="ns2:value" />'
+ '<tag ns1:key="ns2:value" />'
+ '</ns0:tag>') # 3.3
+
+ # 4) Direct QName tests
+
+ self.assertEqual(str(ET.QName('ns', 'tag')), '{ns}tag')
+ self.assertEqual(str(ET.QName('{ns}tag')), '{ns}tag')
+ q1 = ET.QName('ns', 'tag')
+ q2 = ET.QName('ns', 'tag')
+ self.assertEqual(q1, q2)
+ q2 = ET.QName('ns', 'other-tag')
+ self.assertNotEqual(q1, q2)
+ self.assertNotEqual(q1, 'ns:tag')
+ self.assertEqual(q1, '{ns}tag')
+
+ def test_doctype_public(self):
+ # Test PUBLIC doctype.
+
+ elem = ET.XML('<!DOCTYPE html PUBLIC'
+ ' "-//W3C//DTD XHTML 1.0 Transitional//EN"'
+ ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+ '<html>text</html>')
+
+ def test_xpath_tokenizer(self):
+ # Test the XPath tokenizer.
+ from xml.etree import ElementPath
+ def check(p, expected):
+ self.assertEqual([op or tag
+ for op, tag in ElementPath.xpath_tokenizer(p)],
+ expected)
+
+ # tests from the xml specification
+ check("*", ['*'])
+ check("text()", ['text', '()'])
+ check("@name", ['@', 'name'])
+ check("@*", ['@', '*'])
+ check("para[1]", ['para', '[', '1', ']'])
+ check("para[last()]", ['para', '[', 'last', '()', ']'])
+ check("*/para", ['*', '/', 'para'])
+ check("/doc/chapter[5]/section[2]",
+ ['/', 'doc', '/', 'chapter', '[', '5', ']',
+ '/', 'section', '[', '2', ']'])
+ check("chapter//para", ['chapter', '//', 'para'])
+ check("//para", ['//', 'para'])
+ check("//olist/item", ['//', 'olist', '/', 'item'])
+ check(".", ['.'])
+ check(".//para", ['.', '//', 'para'])
+ check("..", ['..'])
+ check("../@lang", ['..', '/', '@', 'lang'])
+ check("chapter[title]", ['chapter', '[', 'title', ']'])
+ check("employee[@secretary and @assistant]", ['employee',
+ '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']'])
+
+ # additional tests
+ check("{http://spam}egg", ['{http://spam}egg'])
+ check("./spam.egg", ['.', '/', 'spam.egg'])
+ check(".//{http://spam}egg", ['.', '//', '{http://spam}egg'])
+
+ def test_processinginstruction(self):
+ # Test ProcessingInstruction directly
+
+ self.assertEqual(ET.tostring(ET.ProcessingInstruction('test', 'instruction')),
+ '<?test instruction?>')
+ self.assertEqual(ET.tostring(ET.PI('test', 'instruction')),
+ '<?test instruction?>')
+
+ # Issue #2746
+
+ self.assertEqual(ET.tostring(ET.PI('test', '<testing&>')),
+ '<?test <testing&>?>')
+ self.assertEqual(ET.tostring(ET.PI('test', u'<testing&>\xe3'), 'latin1'),
+ "<?xml version='1.0' encoding='latin1'?>\n"
+ "<?test <testing&>\xe3?>")
+
+ def test_html_empty_elems_serialization(self):
+ # issue 15970
+ # from http://www.w3.org/TR/html401/index/elements.html
+ for element in ['AREA', 'BASE', 'BASEFONT', 'BR', 'COL', 'FRAME', 'HR',
+ 'IMG', 'INPUT', 'ISINDEX', 'LINK', 'META', 'PARAM']:
+ for elem in [element, element.lower()]:
+ expected = '<%s>' % elem
+ serialized = serialize(ET.XML('<%s />' % elem), method='html')
+ self.assertEqual(serialized, expected)
+ serialized = serialize(ET.XML('<%s></%s>' % (elem,elem)),
+ method='html')
+ self.assertEqual(serialized, expected)
-ENTITY_XML = """\
-<!DOCTYPE points [
-<!ENTITY % user-entities SYSTEM 'user-entities.xml'>
-%user-entities;
-]>
-<document>&entity;</document>
-"""
-
-def entity():
- """
- Test entity handling.
-
- 1) good entities
-
- >>> e = ET.XML("<document title='舰'>test</document>")
- >>> serialize(e)
- '<document title="舰">test</document>'
-
- 2) bad entities
-
- >>> ET.XML("<document>&entity;</document>")
- Traceback (most recent call last):
- ParseError: undefined entity: line 1, column 10
-
- >>> ET.XML(ENTITY_XML)
- Traceback (most recent call last):
- ParseError: undefined entity &entity;: line 5, column 10
-
- 3) custom entity
-
- >>> parser = ET.XMLParser()
- >>> parser.entity["entity"] = "text"
- >>> parser.feed(ENTITY_XML)
- >>> root = parser.close()
- >>> serialize(root)
- '<document>text</document>'
- """
-
-def error(xml):
- """
-
- Test error handling.
-
- >>> issubclass(ET.ParseError, SyntaxError)
- True
- >>> error("foo").position
- (1, 0)
- >>> error("<tag>&foo;</tag>").position
- (1, 5)
- >>> error("foobar<").position
- (1, 6)
-
- """
- try:
- ET.XML(xml)
- except ET.ParseError:
- return sys.exc_value
-
-def namespace():
- """
- Test namespace issues.
-
- 1) xml namespace
-
- >>> elem = ET.XML("<tag xml:lang='en' />")
- >>> serialize(elem) # 1.1
- '<tag xml:lang="en" />'
-
- 2) other "well-known" namespaces
-
- >>> elem = ET.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />")
- >>> serialize(elem) # 2.1
- '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" />'
-
- >>> elem = ET.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />")
- >>> serialize(elem) # 2.2
- '<html:html xmlns:html="http://www.w3.org/1999/xhtml" />'
-
- >>> elem = ET.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />")
- >>> serialize(elem) # 2.3
- '<ns0:Envelope xmlns:ns0="http://schemas.xmlsoap.org/soap/envelope" />'
-
- 3) unknown namespaces
- >>> elem = ET.XML(SAMPLE_XML_NS)
- >>> print serialize(elem)
- <ns0:body xmlns:ns0="http://effbot.org/ns">
- <ns0:tag>text</ns0:tag>
- <ns0:tag />
- <ns0:section>
- <ns0:tag>subtext</ns0:tag>
- </ns0:section>
- </ns0:body>
- """
-
-def qname():
- """
- Test QName handling.
-
- 1) decorated tags
-
- >>> elem = ET.Element("{uri}tag")
- >>> serialize(elem) # 1.1
- '<ns0:tag xmlns:ns0="uri" />'
- >>> elem = ET.Element(ET.QName("{uri}tag"))
- >>> serialize(elem) # 1.2
- '<ns0:tag xmlns:ns0="uri" />'
- >>> elem = ET.Element(ET.QName("uri", "tag"))
- >>> serialize(elem) # 1.3
- '<ns0:tag xmlns:ns0="uri" />'
- >>> elem = ET.Element(ET.QName("uri", "tag"))
- >>> subelem = ET.SubElement(elem, ET.QName("uri", "tag1"))
- >>> subelem = ET.SubElement(elem, ET.QName("uri", "tag2"))
- >>> serialize(elem) # 1.4
- '<ns0:tag xmlns:ns0="uri"><ns0:tag1 /><ns0:tag2 /></ns0:tag>'
-
- 2) decorated attributes
-
- >>> elem.clear()
- >>> elem.attrib["{uri}key"] = "value"
- >>> serialize(elem) # 2.1
- '<ns0:tag xmlns:ns0="uri" ns0:key="value" />'
-
- >>> elem.clear()
- >>> elem.attrib[ET.QName("{uri}key")] = "value"
- >>> serialize(elem) # 2.2
- '<ns0:tag xmlns:ns0="uri" ns0:key="value" />'
-
- 3) decorated values are not converted by default, but the
- QName wrapper can be used for values
-
- >>> elem.clear()
- >>> elem.attrib["{uri}key"] = "{uri}value"
- >>> serialize(elem) # 3.1
- '<ns0:tag xmlns:ns0="uri" ns0:key="{uri}value" />'
-
- >>> elem.clear()
- >>> elem.attrib["{uri}key"] = ET.QName("{uri}value")
- >>> serialize(elem) # 3.2
- '<ns0:tag xmlns:ns0="uri" ns0:key="ns0:value" />'
-
- >>> elem.clear()
- >>> subelem = ET.Element("tag")
- >>> subelem.attrib["{uri1}key"] = ET.QName("{uri2}value")
- >>> elem.append(subelem)
- >>> elem.append(subelem)
- >>> serialize(elem) # 3.3
- '<ns0:tag xmlns:ns0="uri" xmlns:ns1="uri1" xmlns:ns2="uri2"><tag ns1:key="ns2:value" /><tag ns1:key="ns2:value" /></ns0:tag>'
-
- 4) Direct QName tests
-
- >>> str(ET.QName('ns', 'tag'))
- '{ns}tag'
- >>> str(ET.QName('{ns}tag'))
- '{ns}tag'
- >>> q1 = ET.QName('ns', 'tag')
- >>> q2 = ET.QName('ns', 'tag')
- >>> q1 == q2
- True
- >>> q2 = ET.QName('ns', 'other-tag')
- >>> q1 == q2
- False
- >>> q1 == 'ns:tag'
- False
- >>> q1 == '{ns}tag'
- True
- """
-
-def doctype_public():
- """
- Test PUBLIC doctype.
-
- >>> elem = ET.XML('<!DOCTYPE html PUBLIC'
- ... ' "-//W3C//DTD XHTML 1.0 Transitional//EN"'
- ... ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
- ... '<html>text</html>')
-
- """
-
-def xpath_tokenizer(p):
- """
- Test the XPath tokenizer.
-
- >>> # tests from the xml specification
- >>> xpath_tokenizer("*")
- ['*']
- >>> xpath_tokenizer("text()")
- ['text', '()']
- >>> xpath_tokenizer("@name")
- ['@', 'name']
- >>> xpath_tokenizer("@*")
- ['@', '*']
- >>> xpath_tokenizer("para[1]")
- ['para', '[', '1', ']']
- >>> xpath_tokenizer("para[last()]")
- ['para', '[', 'last', '()', ']']
- >>> xpath_tokenizer("*/para")
- ['*', '/', 'para']
- >>> xpath_tokenizer("/doc/chapter[5]/section[2]")
- ['/', 'doc', '/', 'chapter', '[', '5', ']', '/', 'section', '[', '2', ']']
- >>> xpath_tokenizer("chapter//para")
- ['chapter', '//', 'para']
- >>> xpath_tokenizer("//para")
- ['//', 'para']
- >>> xpath_tokenizer("//olist/item")
- ['//', 'olist', '/', 'item']
- >>> xpath_tokenizer(".")
- ['.']
- >>> xpath_tokenizer(".//para")
- ['.', '//', 'para']
- >>> xpath_tokenizer("..")
- ['..']
- >>> xpath_tokenizer("../@lang")
- ['..', '/', '@', 'lang']
- >>> xpath_tokenizer("chapter[title]")
- ['chapter', '[', 'title', ']']
- >>> xpath_tokenizer("employee[@secretary and @assistant]")
- ['employee', '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']']
-
- >>> # additional tests
- >>> xpath_tokenizer("{http://spam}egg")
- ['{http://spam}egg']
- >>> xpath_tokenizer("./spam.egg")
- ['.', '/', 'spam.egg']
- >>> xpath_tokenizer(".//{http://spam}egg")
- ['.', '//', '{http://spam}egg']
- """
- from xml.etree import ElementPath
- out = []
- for op, tag in ElementPath.xpath_tokenizer(p):
- out.append(op or tag)
- return out
-
-def processinginstruction():
- """
- Test ProcessingInstruction directly
-
- >>> ET.tostring(ET.ProcessingInstruction('test', 'instruction'))
- '<?test instruction?>'
- >>> ET.tostring(ET.PI('test', 'instruction'))
- '<?test instruction?>'
-
- Issue #2746
-
- >>> ET.tostring(ET.PI('test', '<testing&>'))
- '<?test <testing&>?>'
- >>> ET.tostring(ET.PI('test', u'<testing&>\xe3'), 'latin1')
- "<?xml version='1.0' encoding='latin1'?>\\n<?test <testing&>\\xe3?>"
- """
#
# xinclude tests (samples from appendix C of the xinclude specification)
</document>
""".format(cgi.escape(SIMPLE_XMLFILE, True))
-def xinclude_loader(href, parse="xml", encoding=None):
- try:
- data = XINCLUDE[href]
- except KeyError:
- raise IOError("resource not found")
- if parse == "xml":
- from xml.etree.ElementTree import XML
- return XML(data)
- return data
-
-def xinclude():
- r"""
- Basic inclusion example (XInclude C.1)
-
- >>> from xml.etree import ElementTree as ET
- >>> from xml.etree import ElementInclude
-
- >>> document = xinclude_loader("C1.xml")
- >>> ElementInclude.include(document, xinclude_loader)
- >>> print serialize(document) # C1
- <document>
- <p>120 Mz is adequate for an average home user.</p>
- <disclaimer>
- <p>The opinions represented herein represent those of the individual
- and should not be interpreted as official policy endorsed by this
- organization.</p>
- </disclaimer>
- </document>
-
- Textual inclusion example (XInclude C.2)
-
- >>> document = xinclude_loader("C2.xml")
- >>> ElementInclude.include(document, xinclude_loader)
- >>> print serialize(document) # C2
- <document>
- <p>This document has been accessed
- 324387 times.</p>
- </document>
-
- Textual inclusion after sibling element (based on modified XInclude C.2)
-
- >>> document = xinclude_loader("C2b.xml")
- >>> ElementInclude.include(document, xinclude_loader)
- >>> print(serialize(document)) # C2b
- <document>
- <p>This document has been <em>accessed</em>
- 324387 times.</p>
- </document>
-
- Textual inclusion of XML example (XInclude C.3)
-
- >>> document = xinclude_loader("C3.xml")
- >>> ElementInclude.include(document, xinclude_loader)
- >>> print serialize(document) # C3
- <document>
- <p>The following is the source of the "data.xml" resource:</p>
- <example><?xml version='1.0'?>
- <data>
- <item><![CDATA[Brooks & Shields]]></item>
- </data>
- </example>
- </document>
-
- Fallback example (XInclude C.5)
- Note! Fallback support is not yet implemented
-
- >>> document = xinclude_loader("C5.xml")
- >>> ElementInclude.include(document, xinclude_loader)
- Traceback (most recent call last):
- IOError: resource not found
- >>> # print serialize(document) # C5
- """
-
-def xinclude_default():
- """
- >>> from xml.etree import ElementInclude
-
- >>> document = xinclude_loader("default.xml")
- >>> ElementInclude.include(document)
- >>> print serialize(document) # default
- <document>
- <p>Example.</p>
- <root>
- <element key="value">text</element>
- <element>text</element>tail
- <empty-element />
- </root>
- </document>
- """
-
#
# badly formatted xi:include tags
</div>
"""
-def xinclude_failures():
- r"""
- Test failure to locate included XML file.
-
- >>> from xml.etree import ElementInclude
-
- >>> def none_loader(href, parser, encoding=None):
- ... return None
-
- >>> document = ET.XML(XINCLUDE["C1.xml"])
- >>> ElementInclude.include(document, loader=none_loader)
- Traceback (most recent call last):
- FatalIncludeError: cannot load 'disclaimer.xml' as 'xml'
-
- Test failure to locate included text file.
-
- >>> document = ET.XML(XINCLUDE["C2.xml"])
- >>> ElementInclude.include(document, loader=none_loader)
- Traceback (most recent call last):
- FatalIncludeError: cannot load 'count.txt' as 'text'
-
- Test bad parse type.
-
- >>> document = ET.XML(XINCLUDE_BAD["B1.xml"])
- >>> ElementInclude.include(document, loader=none_loader)
- Traceback (most recent call last):
- FatalIncludeError: unknown parse type in xi:include tag ('BAD_TYPE')
-
- Test xi:fallback outside xi:include.
-
- >>> document = ET.XML(XINCLUDE_BAD["B2.xml"])
- >>> ElementInclude.include(document, loader=none_loader)
- Traceback (most recent call last):
- FatalIncludeError: xi:fallback tag must be child of xi:include ('{http://www.w3.org/2001/XInclude}fallback')
- """
+class XIncludeTest(unittest.TestCase):
+
+ def xinclude_loader(self, href, parse="xml", encoding=None):
+ try:
+ data = XINCLUDE[href]
+ except KeyError:
+ raise IOError("resource not found")
+ if parse == "xml":
+ data = ET.XML(data)
+ return data
+
+ def none_loader(self, href, parser, encoding=None):
+ return None
+
+ def test_xinclude_default(self):
+ from xml.etree import ElementInclude
+ doc = self.xinclude_loader('default.xml')
+ ElementInclude.include(doc)
+ self.assertEqual(serialize(doc),
+ '<document>\n'
+ ' <p>Example.</p>\n'
+ ' <root>\n'
+ ' <element key="value">text</element>\n'
+ ' <element>text</element>tail\n'
+ ' <empty-element />\n'
+ '</root>\n'
+ '</document>')
+
+ def test_xinclude(self):
+ from xml.etree import ElementInclude
+
+ # Basic inclusion example (XInclude C.1)
+ document = self.xinclude_loader("C1.xml")
+ ElementInclude.include(document, self.xinclude_loader)
+ self.assertEqual(serialize(document),
+ '<document>\n'
+ ' <p>120 Mz is adequate for an average home user.</p>\n'
+ ' <disclaimer>\n'
+ ' <p>The opinions represented herein represent those of the individual\n'
+ ' and should not be interpreted as official policy endorsed by this\n'
+ ' organization.</p>\n'
+ '</disclaimer>\n'
+ '</document>') # C1
+
+ # Textual inclusion example (XInclude C.2)
+ document = self.xinclude_loader("C2.xml")
+ ElementInclude.include(document, self.xinclude_loader)
+ self.assertEqual(serialize(document),
+ '<document>\n'
+ ' <p>This document has been accessed\n'
+ ' 324387 times.</p>\n'
+ '</document>') # C2
+
+ # Textual inclusion after sibling element (based on modified XInclude C.2)
+ document = self.xinclude_loader("C2b.xml")
+ ElementInclude.include(document, self.xinclude_loader)
+ self.assertEqual(serialize(document),
+ '<document>\n'
+ ' <p>This document has been <em>accessed</em>\n'
+ ' 324387 times.</p>\n'
+ '</document>') # C2b
+
+ # Textual inclusion of XML example (XInclude C.3)
+ document = self.xinclude_loader("C3.xml")
+ ElementInclude.include(document, self.xinclude_loader)
+ self.assertEqual(serialize(document),
+ '<document>\n'
+ ' <p>The following is the source of the "data.xml" resource:</p>\n'
+ " <example><?xml version='1.0'?>\n"
+ '<data>\n'
+ ' <item><![CDATA[Brooks & Shields]]></item>\n'
+ '</data>\n'
+ '</example>\n'
+ '</document>') # C3
+
+ # Fallback example (XInclude C.5)
+ # Note! Fallback support is not yet implemented
+ document = self.xinclude_loader("C5.xml")
+ with self.assertRaises(IOError) as cm:
+ ElementInclude.include(document, self.xinclude_loader)
+ self.assertEqual(str(cm.exception), 'resource not found')
+ self.assertEqual(serialize(document),
+ '<div xmlns:ns0="http://www.w3.org/2001/XInclude">\n'
+ ' <ns0:include href="example.txt" parse="text">\n'
+ ' <ns0:fallback>\n'
+ ' <ns0:include href="fallback-example.txt" parse="text">\n'
+ ' <ns0:fallback><a href="mailto:bob@example.org">Report error</a></ns0:fallback>\n'
+ ' </ns0:include>\n'
+ ' </ns0:fallback>\n'
+ ' </ns0:include>\n'
+ '</div>') # C5
+
+ def test_xinclude_failures(self):
+ from xml.etree import ElementInclude
+
+ # Test failure to locate included XML file.
+ document = ET.XML(XINCLUDE["C1.xml"])
+ with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
+ ElementInclude.include(document, loader=self.none_loader)
+ self.assertEqual(str(cm.exception),
+ "cannot load 'disclaimer.xml' as 'xml'")
+
+ # Test failure to locate included text file.
+ document = ET.XML(XINCLUDE["C2.xml"])
+ with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
+ ElementInclude.include(document, loader=self.none_loader)
+ self.assertEqual(str(cm.exception),
+ "cannot load 'count.txt' as 'text'")
+
+ # Test bad parse type.
+ document = ET.XML(XINCLUDE_BAD["B1.xml"])
+ with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
+ ElementInclude.include(document, loader=self.none_loader)
+ self.assertEqual(str(cm.exception),
+ "unknown parse type in xi:include tag ('BAD_TYPE')")
+
+ # Test xi:fallback outside xi:include.
+ document = ET.XML(XINCLUDE_BAD["B2.xml"])
+ with self.assertRaises(ElementInclude.FatalIncludeError) as cm:
+ ElementInclude.include(document, loader=self.none_loader)
+ self.assertEqual(str(cm.exception),
+ "xi:fallback tag must be child of xi:include "
+ "('{http://www.w3.org/2001/XInclude}fallback')")
# --------------------------------------------------------------------
# reported bugs
-def bug_xmltoolkit21():
- """
-
- marshaller gives obscure errors for non-string values
-
- >>> elem = ET.Element(123)
- >>> serialize(elem) # tag
- Traceback (most recent call last):
- TypeError: cannot serialize 123 (type int)
- >>> elem = ET.Element("elem")
- >>> elem.text = 123
- >>> serialize(elem) # text
- Traceback (most recent call last):
- TypeError: cannot serialize 123 (type int)
- >>> elem = ET.Element("elem")
- >>> elem.tail = 123
- >>> serialize(elem) # tail
- Traceback (most recent call last):
- TypeError: cannot serialize 123 (type int)
- >>> elem = ET.Element("elem")
- >>> elem.set(123, "123")
- >>> serialize(elem) # attribute key
- Traceback (most recent call last):
- TypeError: cannot serialize 123 (type int)
- >>> elem = ET.Element("elem")
- >>> elem.set("123", 123)
- >>> serialize(elem) # attribute value
- Traceback (most recent call last):
- TypeError: cannot serialize 123 (type int)
-
- """
-
-def bug_xmltoolkit25():
- """
+class BugsTest(unittest.TestCase):
- typo in ElementTree.findtext
+ def test_bug_xmltoolkit21(self):
+ # marshaller gives obscure errors for non-string values
- >>> elem = ET.XML(SAMPLE_XML)
- >>> tree = ET.ElementTree(elem)
- >>> tree.findtext("tag")
- 'text'
- >>> tree.findtext("section/tag")
- 'subtext'
+ def check(elem):
+ with self.assertRaises(TypeError) as cm:
+ serialize(elem)
+ self.assertEqual(str(cm.exception),
+ 'cannot serialize 123 (type int)')
- """
+ elem = ET.Element(123)
+ check(elem) # tag
-def bug_xmltoolkit28():
- """
+ elem = ET.Element("elem")
+ elem.text = 123
+ check(elem) # text
- .//tag causes exceptions
+ elem = ET.Element("elem")
+ elem.tail = 123
+ check(elem) # tail
- >>> tree = ET.XML("<doc><table><tbody/></table></doc>")
- >>> summarize_list(tree.findall(".//thead"))
- []
- >>> summarize_list(tree.findall(".//tbody"))
- ['tbody']
+ elem = ET.Element("elem")
+ elem.set(123, "123")
+ check(elem) # attribute key
- """
+ elem = ET.Element("elem")
+ elem.set("123", 123)
+ check(elem) # attribute value
-def bug_xmltoolkitX1():
- """
+ def test_bug_xmltoolkit25(self):
+ # typo in ElementTree.findtext
- dump() doesn't flush the output buffer
+ elem = ET.XML(SAMPLE_XML)
+ tree = ET.ElementTree(elem)
+ self.assertEqual(tree.findtext("tag"), 'text')
+ self.assertEqual(tree.findtext("section/tag"), 'subtext')
- >>> tree = ET.XML("<doc><table><tbody/></table></doc>")
- >>> ET.dump(tree); sys.stdout.write("tail")
- <doc><table><tbody /></table></doc>
- tail
+ def test_bug_xmltoolkit28(self):
+ # .//tag causes exceptions
- """
+ tree = ET.XML("<doc><table><tbody/></table></doc>")
+ self.assertEqual(summarize_list(tree.findall(".//thead")), [])
+ self.assertEqual(summarize_list(tree.findall(".//tbody")), ['tbody'])
-def bug_xmltoolkit39():
- """
+ def test_bug_xmltoolkitX1(self):
+ # dump() doesn't flush the output buffer
- non-ascii element and attribute names doesn't work
+ tree = ET.XML("<doc><table><tbody/></table></doc>")
+ with support.captured_stdout() as stdout:
+ ET.dump(tree)
+ self.assertEqual(stdout.getvalue(), '<doc><table><tbody /></table></doc>\n')
- >>> tree = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><t\xe4g />")
- >>> ET.tostring(tree, "utf-8")
- '<t\\xc3\\xa4g />'
+ def test_bug_xmltoolkit39(self):
+ # non-ascii element and attribute names doesn't work
- >>> tree = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><tag \xe4ttr='välue' />")
- >>> tree.attrib
- {u'\\xe4ttr': u'v\\xe4lue'}
- >>> ET.tostring(tree, "utf-8")
- '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />'
+ tree = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?><t\xe4g />")
+ self.assertEqual(ET.tostring(tree, "utf-8"), b'<t\xc3\xa4g />')
- >>> tree = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><t\xe4g>text</t\xe4g>")
- >>> ET.tostring(tree, "utf-8")
- '<t\\xc3\\xa4g>text</t\\xc3\\xa4g>'
+ tree = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?>"
+ b"<tag \xe4ttr='välue' />")
+ self.assertEqual(tree.attrib, {u'\xe4ttr': u'v\xe4lue'})
+ self.assertEqual(ET.tostring(tree, "utf-8"),
+ b'<tag \xc3\xa4ttr="v\xc3\xa4lue" />')
- >>> tree = ET.Element(u"t\u00e4g")
- >>> ET.tostring(tree, "utf-8")
- '<t\\xc3\\xa4g />'
+ tree = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?>"
+ b'<t\xe4g>text</t\xe4g>')
+ self.assertEqual(ET.tostring(tree, "utf-8"),
+ b'<t\xc3\xa4g>text</t\xc3\xa4g>')
- >>> tree = ET.Element("tag")
- >>> tree.set(u"\u00e4ttr", u"v\u00e4lue")
- >>> ET.tostring(tree, "utf-8")
- '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />'
+ tree = ET.Element(u"t\u00e4g")
+ self.assertEqual(ET.tostring(tree, "utf-8"), b'<t\xc3\xa4g />')
- """
+ tree = ET.Element("tag")
+ tree.set(u"\u00e4ttr", u"v\u00e4lue")
+ self.assertEqual(ET.tostring(tree, "utf-8"),
+ b'<tag \xc3\xa4ttr="v\xc3\xa4lue" />')
-def bug_xmltoolkit54():
- """
+ def test_bug_xmltoolkit54(self):
+ # problems handling internally defined entities
- problems handling internally defined entities
+ e = ET.XML("<!DOCTYPE doc [<!ENTITY ldots '舰'>]>"
+ '<doc>&ldots;</doc>')
+ self.assertEqual(serialize(e), '<doc>舰</doc>')
- >>> e = ET.XML("<!DOCTYPE doc [<!ENTITY ldots '舰'>]><doc>&ldots;</doc>")
- >>> serialize(e)
- '<doc>舰</doc>'
+ def test_bug_xmltoolkit55(self):
+ # make sure we're reporting the first error, not the last
- """
+ with self.assertRaises(ET.ParseError) as cm:
+ ET.XML("<!DOCTYPE doc SYSTEM 'doc.dtd'>"
+ '<doc>&ldots;&ndots;&rdots;</doc>')
+ self.assertEqual(str(cm.exception),
+ 'undefined entity &ldots;: line 1, column 36')
-def bug_xmltoolkit55():
- """
+ def test_bug_xmltoolkit60(self):
+ # Handle crash in stream source.
- make sure we're reporting the first error, not the last
+ class ExceptionFile:
+ def read(self, x):
+ raise IOError
- >>> e = ET.XML("<!DOCTYPE doc SYSTEM 'doc.dtd'><doc>&ldots;&ndots;&rdots;</doc>")
- Traceback (most recent call last):
- ParseError: undefined entity &ldots;: line 1, column 36
+ self.assertRaises(IOError, ET.parse, ExceptionFile())
- """
+ def test_bug_xmltoolkit62(self):
+ # Don't crash when using custom entities.
-class ExceptionFile:
- def read(self, x):
- raise IOError
-
-def xmltoolkit60():
- """
-
- Handle crash in stream source.
- >>> tree = ET.parse(ExceptionFile())
- Traceback (most recent call last):
- IOError
-
- """
-
-XMLTOOLKIT62_DOC = """<?xml version="1.0" encoding="UTF-8"?>
+ ENTITIES = {u'rsquo': u'\u2019', u'lsquo': u'\u2018'}
+ parser = ET.XMLTreeBuilder()
+ parser.entity.update(ENTITIES)
+ parser.feed("""<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE patent-application-publication SYSTEM "pap-v15-2001-01-31.dtd" []>
<patent-application-publication>
<subdoc-abstract>
<paragraph id="A-0001" lvl="0">A new cultivar of Begonia plant named ‘BCT9801BEG’.</paragraph>
</subdoc-abstract>
-</patent-application-publication>"""
-
-
-def xmltoolkit62():
- """
+</patent-application-publication>""")
+ t = parser.close()
+ self.assertEqual(t.find('.//paragraph').text,
+ u'A new cultivar of Begonia plant named \u2018BCT9801BEG\u2019.')
+
+ def test_bug_xmltoolkit63(self):
+ # Check reference leak.
+ def xmltoolkit63():
+ tree = ET.TreeBuilder()
+ tree.start("tag", {})
+ tree.data("text")
+ tree.end("tag")
+
+ xmltoolkit63()
+ count = sys.getrefcount(None)
+ for i in range(1000):
+ xmltoolkit63()
+ self.assertEqual(sys.getrefcount(None), count)
+
+ def test_bug_200708_newline(self):
+ # Preserve newlines in attributes.
+
+ e = ET.Element('SomeTag', text="def _f():\n return 3\n")
+ self.assertEqual(ET.tostring(e),
+ b'<SomeTag text="def _f(): return 3 " />')
+ self.assertEqual(ET.XML(ET.tostring(e)).get("text"),
+ 'def _f():\n return 3\n')
+ self.assertEqual(ET.tostring(ET.XML(ET.tostring(e))),
+ b'<SomeTag text="def _f(): return 3 " />')
+
+ def test_bug_200708_close(self):
+ # Test default builder.
+ parser = ET.XMLParser() # default
+ parser.feed("<element>some text</element>")
+ self.assertEqual(parser.close().tag, 'element')
+
+ # Test custom builder.
+ class EchoTarget:
+ def start(self, tag, attrib):
+ pass
+ def end(self, tag):
+ pass
+ def data(self, text):
+ pass
+ def close(self):
+ return ET.Element("element") # simulate root
+ parser = ET.XMLParser(target=EchoTarget())
+ parser.feed("<element>some text</element>")
+ self.assertEqual(parser.close().tag, 'element')
+
+ def test_bug_200709_default_namespace(self):
+ e = ET.Element("{default}elem")
+ s = ET.SubElement(e, "{default}elem")
+ self.assertEqual(serialize(e, default_namespace="default"), # 1
+ '<elem xmlns="default"><elem /></elem>')
+
+ e = ET.Element("{default}elem")
+ s = ET.SubElement(e, "{default}elem")
+ s = ET.SubElement(e, "{not-default}elem")
+ self.assertEqual(serialize(e, default_namespace="default"), # 2
+ '<elem xmlns="default" xmlns:ns1="not-default">'
+ '<elem />'
+ '<ns1:elem />'
+ '</elem>')
+
+ e = ET.Element("{default}elem")
+ s = ET.SubElement(e, "{default}elem")
+ s = ET.SubElement(e, "elem") # unprefixed name
+ with self.assertRaises(ValueError) as cm:
+ serialize(e, default_namespace="default") # 3
+ self.assertEqual(str(cm.exception),
+ 'cannot use non-qualified names with default_namespace option')
+
+ def test_bug_200709_register_namespace(self):
+ e = ET.Element("{http://namespace.invalid/does/not/exist/}title")
+ self.assertEqual(ET.tostring(e),
+ '<ns0:title xmlns:ns0="http://namespace.invalid/does/not/exist/" />')
+ ET.register_namespace("foo", "http://namespace.invalid/does/not/exist/")
+ e = ET.Element("{http://namespace.invalid/does/not/exist/}title")
+ self.assertEqual(ET.tostring(e),
+ '<foo:title xmlns:foo="http://namespace.invalid/does/not/exist/" />')
+
+ # And the Dublin Core namespace is in the default list:
+
+ e = ET.Element("{http://purl.org/dc/elements/1.1/}title")
+ self.assertEqual(ET.tostring(e),
+ '<dc:title xmlns:dc="http://purl.org/dc/elements/1.1/" />')
+
+ def test_bug_200709_element_comment(self):
+ # Not sure if this can be fixed, really (since the serializer needs
+ # ET.Comment, not cET.comment).
+
+ a = ET.Element('a')
+ a.append(ET.Comment('foo'))
+ self.assertEqual(a[0].tag, ET.Comment)
+
+ a = ET.Element('a')
+ a.append(ET.PI('foo'))
+ self.assertEqual(a[0].tag, ET.PI)
+
+ def test_bug_200709_element_insert(self):
+ a = ET.Element('a')
+ b = ET.SubElement(a, 'b')
+ c = ET.SubElement(a, 'c')
+ d = ET.Element('d')
+ a.insert(0, d)
+ self.assertEqual(summarize_list(a), ['d', 'b', 'c'])
+ a.insert(-1, d)
+ self.assertEqual(summarize_list(a), ['d', 'b', 'd', 'c'])
+
+ def test_bug_200709_iter_comment(self):
+ a = ET.Element('a')
+ b = ET.SubElement(a, 'b')
+ comment_b = ET.Comment("TEST-b")
+ b.append(comment_b)
+ self.assertEqual(summarize_list(a.iter(ET.Comment)), [ET.Comment])
+
+ # --------------------------------------------------------------------
+ # reported on bugs.python.org
+
+ def test_bug_1534630(self):
+ bob = ET.TreeBuilder()
+ e = bob.data("data")
+ e = bob.start("tag", {})
+ e = bob.end("tag")
+ e = bob.close()
+ self.assertEqual(serialize(e), '<tag />')
+
+ def test_issue6233(self):
+ e = ET.XML(b"<?xml version='1.0' encoding='utf-8'?>"
+ b'<body>t\xc3\xa3g</body>')
+ self.assertEqual(ET.tostring(e, 'ascii'),
+ b"<?xml version='1.0' encoding='ascii'?>\n"
+ b'<body>tãg</body>')
+ e = ET.XML(b"<?xml version='1.0' encoding='iso-8859-1'?>"
+ b'<body>t\xe3g</body>')
+ self.assertEqual(ET.tostring(e, 'ascii'),
+ b"<?xml version='1.0' encoding='ascii'?>\n"
+ b'<body>tãg</body>')
+
+ def test_issue3151(self):
+ e = ET.XML('<prefix:localname xmlns:prefix="${stuff}"/>')
+ self.assertEqual(e.tag, '{${stuff}}localname')
+ t = ET.ElementTree(e)
+ self.assertEqual(ET.tostring(e), b'<ns0:localname xmlns:ns0="${stuff}" />')
+
+ def test_issue6565(self):
+ elem = ET.XML("<body><tag/></body>")
+ self.assertEqual(summarize_list(elem), ['tag'])
+ newelem = ET.XML(SAMPLE_XML)
+ elem[:] = newelem[:]
+ self.assertEqual(summarize_list(elem), ['tag', 'tag', 'section'])
+
+ def test_issue10777(self):
+ # Registering a namespace twice caused a "dictionary changed size during
+ # iteration" bug.
+
+ ET.register_namespace('test10777', 'http://myuri/')
+ ET.register_namespace('test10777', 'http://myuri/')
- Don't crash when using custom entities.
-
- >>> xmltoolkit62()
- u'A new cultivar of Begonia plant named \u2018BCT9801BEG\u2019.'
-
- """
- ENTITIES = {u'rsquo': u'\u2019', u'lsquo': u'\u2018'}
- parser = ET.XMLTreeBuilder()
- parser.entity.update(ENTITIES)
- parser.feed(XMLTOOLKIT62_DOC)
- t = parser.close()
- return t.find('.//paragraph').text
-
-def xmltoolkit63():
- """
-
- Check reference leak.
- >>> xmltoolkit63()
- >>> count = sys.getrefcount(None)
- >>> for i in range(1000):
- ... xmltoolkit63()
- >>> sys.getrefcount(None) - count
- 0
-
- """
- tree = ET.TreeBuilder()
- tree.start("tag", {})
- tree.data("text")
- tree.end("tag")
# --------------------------------------------------------------------
-def bug_200708_newline():
- r"""
-
- Preserve newlines in attributes.
-
- >>> e = ET.Element('SomeTag', text="def _f():\n return 3\n")
- >>> ET.tostring(e)
- '<SomeTag text="def _f(): return 3 " />'
- >>> ET.XML(ET.tostring(e)).get("text")
- 'def _f():\n return 3\n'
- >>> ET.tostring(ET.XML(ET.tostring(e)))
- '<SomeTag text="def _f(): return 3 " />'
-
- """
-
-def bug_200708_close():
- """
-
- Test default builder.
- >>> parser = ET.XMLParser() # default
- >>> parser.feed("<element>some text</element>")
- >>> summarize(parser.close())
- 'element'
-
- Test custom builder.
- >>> class EchoTarget:
- ... def close(self):
- ... return ET.Element("element") # simulate root
- >>> parser = ET.XMLParser(EchoTarget())
- >>> parser.feed("<element>some text</element>")
- >>> summarize(parser.close())
- 'element'
-
- """
-
-def bug_200709_default_namespace():
- """
+class BasicElementTest(unittest.TestCase):
+ @python_only
+ def test_cyclic_gc(self):
+ class Dummy:
+ pass
+
+ # Test the shortest cycle: d->element->d
+ d = Dummy()
+ d.dummyref = ET.Element('joe', attr=d)
+ wref = weakref.ref(d)
+ del d
+ gc_collect()
+ self.assertIsNone(wref())
+
+ # A longer cycle: d->e->e2->d
+ e = ET.Element('joe')
+ d = Dummy()
+ d.dummyref = e
+ wref = weakref.ref(d)
+ e2 = ET.SubElement(e, 'foo', attr=d)
+ del d, e, e2
+ gc_collect()
+ self.assertIsNone(wref())
+
+ # A cycle between Element objects as children of one another
+ # e1->e2->e3->e1
+ e1 = ET.Element('e1')
+ e2 = ET.Element('e2')
+ e3 = ET.Element('e3')
+ e1.append(e2)
+ e2.append(e2)
+ e3.append(e1)
+ wref = weakref.ref(e1)
+ del e1, e2, e3
+ gc_collect()
+ self.assertIsNone(wref())
+
+ @python_only
+ def test_weakref(self):
+ flag = []
+ def wref_cb(w):
+ flag.append(True)
+ e = ET.Element('e')
+ wref = weakref.ref(e, wref_cb)
+ self.assertEqual(wref().tag, 'e')
+ del e
+ self.assertEqual(flag, [True])
+ self.assertEqual(wref(), None)
+
+ @python_only
+ def test_get_keyword_args(self):
+ e1 = ET.Element('foo' , x=1, y=2, z=3)
+ self.assertEqual(e1.get('x', default=7), 1)
+ self.assertEqual(e1.get('w', default=7), 7)
+
+
+class BadElementTest(unittest.TestCase):
+ def test_extend_mutable_list(self):
+ class X(object):
+ @property
+ def __class__(self):
+ L[:] = [ET.Element('baz')]
+ return ET.Element
+ L = [X()]
+ e = ET.Element('foo')
+ try:
+ e.extend(L)
+ except TypeError:
+ pass
+
+ if ET is pyET:
+ class Y(X, ET.Element):
+ pass
+ L = [Y('x')]
+ e = ET.Element('foo')
+ e.extend(L)
+
+ def test_extend_mutable_list2(self):
+ class X(object):
+ @property
+ def __class__(self):
+ del L[:]
+ return ET.Element
+ L = [X(), ET.Element('baz')]
+ e = ET.Element('foo')
+ try:
+ e.extend(L)
+ except TypeError:
+ pass
+
+ if ET is pyET:
+ class Y(X, ET.Element):
+ pass
+ L = [Y('bar'), ET.Element('baz')]
+ e = ET.Element('foo')
+ e.extend(L)
+
+ @python_only
+ def test_remove_with_mutating(self):
+ class X(ET.Element):
+ def __eq__(self, o):
+ del e[:]
+ return False
+ __hash__ = object.__hash__
+ e = ET.Element('foo')
+ e.extend([X('bar')])
+ self.assertRaises(ValueError, e.remove, ET.Element('baz'))
+
+ e = ET.Element('foo')
+ e.extend([ET.Element('bar')])
+ self.assertRaises(ValueError, e.remove, X('baz'))
+
+ def test_recursive_repr(self):
+ # Issue #25455
+ e = ET.Element('foo')
+ with swap_attr(e, 'tag', e):
+ with self.assertRaises(RuntimeError):
+ repr(e) # Should not crash
+
+ def test_element_get_text(self):
+ # Issue #27863
+ class X(str):
+ def __del__(self):
+ try:
+ elem.text
+ except NameError:
+ pass
+
+ b = ET.TreeBuilder()
+ b.start('tag', {})
+ b.data('ABCD')
+ b.data(X('EFGH'))
+ b.data('IJKL')
+ b.end('tag')
+
+ elem = b.close()
+ self.assertEqual(elem.text, 'ABCDEFGHIJKL')
+
+ def test_element_get_tail(self):
+ # Issue #27863
+ class X(str):
+ def __del__(self):
+ try:
+ elem[0].tail
+ except NameError:
+ pass
+
+ b = ET.TreeBuilder()
+ b.start('root', {})
+ b.start('tag', {})
+ b.end('tag')
+ b.data('ABCD')
+ b.data(X('EFGH'))
+ b.data('IJKL')
+ b.end('root')
+
+ elem = b.close()
+ self.assertEqual(elem[0].tail, 'ABCDEFGHIJKL')
+
+ def test_element_iter(self):
+ # Issue #27863
+ e = ET.Element('tag')
+ e.extend([None]) # non-Element
+
+ it = e.iter()
+ self.assertIs(next(it), e)
+ self.assertRaises((AttributeError, TypeError), list, it)
+
+ def test_subscr(self):
+ # Issue #27863
+ class X:
+ def __index__(self):
+ del e[:]
+ return 1
+
+ e = ET.Element('elem')
+ e.append(ET.Element('child'))
+ e[:X()] # shouldn't crash
+
+ e.append(ET.Element('child'))
+ e[0:10:X()] # shouldn't crash
+
+ def test_ass_subscr(self):
+ # Issue #27863
+ class X:
+ def __index__(self):
+ e[:] = []
+ return 1
+
+ e = ET.Element('elem')
+ for _ in range(10):
+ e.insert(0, ET.Element('child'))
+
+ e[0:10:X()] = [] # shouldn't crash
+
+
+class MutatingElementPath(str):
+ def __new__(cls, elem, *args):
+ self = str.__new__(cls, *args)
+ self.elem = elem
+ return self
+ def __eq__(self, o):
+ del self.elem[:]
+ return True
+ __hash__ = str.__hash__
+
+class BadElementPath(str):
+ def __eq__(self, o):
+ raise 1.0/0.0
+ __hash__ = str.__hash__
+
+class BadElementPathTest(unittest.TestCase):
+ def setUp(self):
+ super(BadElementPathTest, self).setUp()
+ from xml.etree import ElementPath
+ self.path_cache = ElementPath._cache
+ ElementPath._cache = {}
+
+ def tearDown(self):
+ from xml.etree import ElementPath
+ ElementPath._cache = self.path_cache
+ super(BadElementPathTest, self).tearDown()
+
+ def test_find_with_mutating(self):
+ e = ET.Element('foo')
+ e.extend([ET.Element('bar')])
+ e.find(MutatingElementPath(e, 'x'))
+
+ def test_find_with_error(self):
+ e = ET.Element('foo')
+ e.extend([ET.Element('bar')])
+ try:
+ e.find(BadElementPath('x'))
+ except ZeroDivisionError:
+ pass
+
+ def test_findtext_with_mutating(self):
+ e = ET.Element('foo')
+ e.extend([ET.Element('bar')])
+ e.findtext(MutatingElementPath(e, 'x'))
+
+ def test_findtext_with_error(self):
+ e = ET.Element('foo')
+ e.extend([ET.Element('bar')])
+ try:
+ e.findtext(BadElementPath('x'))
+ except ZeroDivisionError:
+ pass
+
+ def test_findall_with_mutating(self):
+ e = ET.Element('foo')
+ e.extend([ET.Element('bar')])
+ e.findall(MutatingElementPath(e, 'x'))
+
+ def test_findall_with_error(self):
+ e = ET.Element('foo')
+ e.extend([ET.Element('bar')])
+ try:
+ e.findall(BadElementPath('x'))
+ except ZeroDivisionError:
+ pass
+
+
+class ElementTreeTypeTest(unittest.TestCase):
+ def test_istype(self):
+ self.assertIsInstance(ET.ParseError, type)
+ self.assertIsInstance(ET.QName, type)
+ self.assertIsInstance(ET.ElementTree, type)
+ if ET is pyET:
+ self.assertIsInstance(ET.Element, type)
+ self.assertIsInstance(ET.TreeBuilder, type)
+ self.assertIsInstance(ET.XMLParser, type)
+
+ @python_only
+ def test_Element_subclass_trivial(self):
+ class MyElement(ET.Element):
+ pass
+
+ mye = MyElement('foo')
+ self.assertIsInstance(mye, ET.Element)
+ self.assertIsInstance(mye, MyElement)
+ self.assertEqual(mye.tag, 'foo')
+
+ # test that attribute assignment works (issue 14849)
+ mye.text = "joe"
+ self.assertEqual(mye.text, "joe")
+
+ @python_only
+ def test_Element_subclass_constructor(self):
+ class MyElement(ET.Element):
+ def __init__(self, tag, attrib={}, **extra):
+ super(MyElement, self).__init__(tag + '__', attrib, **extra)
+
+ mye = MyElement('foo', {'a': 1, 'b': 2}, c=3, d=4)
+ self.assertEqual(mye.tag, 'foo__')
+ self.assertEqual(sorted(mye.items()),
+ [('a', 1), ('b', 2), ('c', 3), ('d', 4)])
+
+ @python_only
+ def test_Element_subclass_new_method(self):
+ class MyElement(ET.Element):
+ def newmethod(self):
+ return self.tag
+
+ mye = MyElement('joe')
+ self.assertEqual(mye.newmethod(), 'joe')
+
+
+class ElementFindTest(unittest.TestCase):
+ @python_only
+ def test_simplefind(self):
+ ET.ElementPath
+ with swap_attr(ET, 'ElementPath', ET._SimpleElementPath()):
+ e = ET.XML(SAMPLE_XML)
+ self.assertEqual(e.find('tag').tag, 'tag')
+ self.assertEqual(ET.ElementTree(e).find('tag').tag, 'tag')
+ self.assertEqual(e.findtext('tag'), 'text')
+ self.assertIsNone(e.findtext('tog'))
+ self.assertEqual(e.findtext('tog', 'default'), 'default')
+ self.assertEqual(ET.ElementTree(e).findtext('tag'), 'text')
+ self.assertEqual(summarize_list(e.findall('tag')), ['tag', 'tag'])
+ self.assertEqual(summarize_list(e.findall('.//tag')), ['tag', 'tag', 'tag'])
+
+ # Path syntax doesn't work in this case.
+ self.assertIsNone(e.find('section/tag'))
+ self.assertIsNone(e.findtext('section/tag'))
+ self.assertEqual(summarize_list(e.findall('section/tag')), [])
+
+ def test_find_simple(self):
+ e = ET.XML(SAMPLE_XML)
+ self.assertEqual(e.find('tag').tag, 'tag')
+ self.assertEqual(e.find('section/tag').tag, 'tag')
+ self.assertEqual(e.find('./tag').tag, 'tag')
+
+ e[2] = ET.XML(SAMPLE_SECTION)
+ self.assertEqual(e.find('section/nexttag').tag, 'nexttag')
+
+ self.assertEqual(e.findtext('./tag'), 'text')
+ self.assertEqual(e.findtext('section/tag'), 'subtext')
+
+ # section/nexttag is found but has no text
+ self.assertEqual(e.findtext('section/nexttag'), '')
+ self.assertEqual(e.findtext('section/nexttag', 'default'), '')
+
+ # tog doesn't exist and 'default' kicks in
+ self.assertIsNone(e.findtext('tog'))
+ self.assertEqual(e.findtext('tog', 'default'), 'default')
+
+ # Issue #16922
+ self.assertEqual(ET.XML('<tag><empty /></tag>').findtext('empty'), '')
+
+ def test_find_xpath(self):
+ LINEAR_XML = '''
+ <body>
+ <tag class='a'/>
+ <tag class='b'/>
+ <tag class='c'/>
+ <tag class='d'/>
+ </body>'''
+ e = ET.XML(LINEAR_XML)
+
+ # Test for numeric indexing and last()
+ self.assertEqual(e.find('./tag[1]').attrib['class'], 'a')
+ self.assertEqual(e.find('./tag[2]').attrib['class'], 'b')
+ self.assertEqual(e.find('./tag[last()]').attrib['class'], 'd')
+ self.assertEqual(e.find('./tag[last()-1]').attrib['class'], 'c')
+ self.assertEqual(e.find('./tag[last()-2]').attrib['class'], 'b')
+
+ def test_findall(self):
+ e = ET.XML(SAMPLE_XML)
+ e[2] = ET.XML(SAMPLE_SECTION)
+ self.assertEqual(summarize_list(e.findall('.')), ['body'])
+ self.assertEqual(summarize_list(e.findall('tag')), ['tag', 'tag'])
+ self.assertEqual(summarize_list(e.findall('tog')), [])
+ self.assertEqual(summarize_list(e.findall('tog/foo')), [])
+ self.assertEqual(summarize_list(e.findall('*')),
+ ['tag', 'tag', 'section'])
+ self.assertEqual(summarize_list(e.findall('.//tag')),
+ ['tag'] * 4)
+ self.assertEqual(summarize_list(e.findall('section/tag')), ['tag'])
+ self.assertEqual(summarize_list(e.findall('section//tag')), ['tag'] * 2)
+ self.assertEqual(summarize_list(e.findall('section/*')),
+ ['tag', 'nexttag', 'nextsection'])
+ self.assertEqual(summarize_list(e.findall('section//*')),
+ ['tag', 'nexttag', 'nextsection', 'tag'])
+ self.assertEqual(summarize_list(e.findall('section/.//*')),
+ ['tag', 'nexttag', 'nextsection', 'tag'])
+ self.assertEqual(summarize_list(e.findall('*/*')),
+ ['tag', 'nexttag', 'nextsection'])
+ self.assertEqual(summarize_list(e.findall('*//*')),
+ ['tag', 'nexttag', 'nextsection', 'tag'])
+ self.assertEqual(summarize_list(e.findall('*/tag')), ['tag'])
+ self.assertEqual(summarize_list(e.findall('*/./tag')), ['tag'])
+ self.assertEqual(summarize_list(e.findall('./tag')), ['tag'] * 2)
+ self.assertEqual(summarize_list(e.findall('././tag')), ['tag'] * 2)
+
+ self.assertEqual(summarize_list(e.findall('.//tag[@class]')),
+ ['tag'] * 3)
+ self.assertEqual(summarize_list(e.findall('.//tag[@class="a"]')),
+ ['tag'])
+ self.assertEqual(summarize_list(e.findall('.//tag[@class="b"]')),
+ ['tag'] * 2)
+ self.assertEqual(summarize_list(e.findall('.//tag[@id]')),
+ ['tag'])
+ self.assertEqual(summarize_list(e.findall('.//section[tag]')),
+ ['section'])
+ self.assertEqual(summarize_list(e.findall('.//section[element]')), [])
+ self.assertEqual(summarize_list(e.findall('../tag')), [])
+ self.assertEqual(summarize_list(e.findall('section/../tag')),
+ ['tag'] * 2)
+ self.assertEqual(e.findall('section//'), e.findall('section//*'))
+
+ def test_test_find_with_ns(self):
+ e = ET.XML(SAMPLE_XML_NS)
+ self.assertEqual(summarize_list(e.findall('tag')), [])
+ self.assertEqual(
+ summarize_list(e.findall("{http://effbot.org/ns}tag")),
+ ['{http://effbot.org/ns}tag'] * 2)
+ self.assertEqual(
+ summarize_list(e.findall(".//{http://effbot.org/ns}tag")),
+ ['{http://effbot.org/ns}tag'] * 3)
+
+ def test_bad_find(self):
+ e = ET.XML(SAMPLE_XML)
+ with self.assertRaisesRegexp(SyntaxError,
+ 'cannot use absolute path on element'):
+ e.findall('/tag')
+
+ def test_find_through_ElementTree(self):
+ e = ET.XML(SAMPLE_XML)
+ self.assertEqual(ET.ElementTree(e).find('tag').tag, 'tag')
+ self.assertEqual(ET.ElementTree(e).find('./tag').tag, 'tag')
+ # this produces a warning
+ msg = ("This search is broken in 1.3 and earlier, and will be fixed "
+ "in a future version. If you rely on the current behaviour, "
+ "change it to '.+'")
+ with support.check_warnings((msg, FutureWarning)):
+ self.assertEqual(ET.ElementTree(e).find('/tag').tag, 'tag')
+ e[2] = ET.XML(SAMPLE_SECTION)
+ self.assertEqual(ET.ElementTree(e).find('section/tag').tag, 'tag')
+ self.assertIsNone(ET.ElementTree(e).find('tog'))
+ self.assertIsNone(ET.ElementTree(e).find('tog/foo'))
+
+ self.assertEqual(ET.ElementTree(e).findtext('tag'), 'text')
+ self.assertIsNone(ET.ElementTree(e).findtext('tog/foo'))
+ self.assertEqual(ET.ElementTree(e).findtext('tog/foo', 'default'),
+ 'default')
+ self.assertEqual(ET.ElementTree(e).findtext('./tag'), 'text')
+ with support.check_warnings((msg, FutureWarning)):
+ self.assertEqual(ET.ElementTree(e).findtext('/tag'), 'text')
+ self.assertEqual(ET.ElementTree(e).findtext('section/tag'), 'subtext')
+
+ self.assertEqual(summarize_list(ET.ElementTree(e).findall('./tag')),
+ ['tag'] * 2)
+ with support.check_warnings((msg, FutureWarning)):
+ it = ET.ElementTree(e).findall('/tag')
+ self.assertEqual(summarize_list(it), ['tag'] * 2)
+
+
+class ElementIterTest(unittest.TestCase):
+ def _ilist(self, elem, tag=None):
+ return summarize_list(elem.iter(tag))
+
+ def test_basic(self):
+ doc = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>")
+ self.assertEqual(self._ilist(doc), ['html', 'body', 'i'])
+ self.assertEqual(self._ilist(doc.find('body')), ['body', 'i'])
+ self.assertEqual(next(doc.iter()).tag, 'html')
+ self.assertEqual(''.join(doc.itertext()), 'this is a paragraph...')
+ self.assertEqual(''.join(doc.find('body').itertext()),
+ 'this is a paragraph.')
+ self.assertEqual(next(doc.itertext()), 'this is a ')
+
+ # Method iterparse should return an iterator. See bug 6472.
+ sourcefile = serialize(doc, to_string=False)
+ self.assertEqual(next(ET.iterparse(sourcefile))[0], 'end')
+
+ if ET is pyET:
+ # With an explitit parser too (issue #9708)
+ sourcefile = serialize(doc, to_string=False)
+ parser = ET.XMLParser(target=ET.TreeBuilder())
+ self.assertEqual(next(ET.iterparse(sourcefile, parser=parser))[0],
+ 'end')
+
+ tree = ET.ElementTree(None)
+ self.assertRaises(AttributeError, tree.iter)
+
+ # Issue #16913
+ doc = ET.XML("<root>a&<sub>b&</sub>c&</root>")
+ self.assertEqual(''.join(doc.itertext()), 'a&b&c&')
+
+ def test_corners(self):
+ # single root, no subelements
+ a = ET.Element('a')
+ self.assertEqual(self._ilist(a), ['a'])
+
+ # one child
+ b = ET.SubElement(a, 'b')
+ self.assertEqual(self._ilist(a), ['a', 'b'])
+
+ # one child and one grandchild
+ c = ET.SubElement(b, 'c')
+ self.assertEqual(self._ilist(a), ['a', 'b', 'c'])
+
+ # two children, only first with grandchild
+ d = ET.SubElement(a, 'd')
+ self.assertEqual(self._ilist(a), ['a', 'b', 'c', 'd'])
+
+ # replace first child by second
+ a[0] = a[1]
+ del a[1]
+ self.assertEqual(self._ilist(a), ['a', 'd'])
+
+ def test_iter_by_tag(self):
+ doc = ET.XML('''
+ <document>
+ <house>
+ <room>bedroom1</room>
+ <room>bedroom2</room>
+ </house>
+ <shed>nothing here
+ </shed>
+ <house>
+ <room>bedroom8</room>
+ </house>
+ </document>''')
+
+ self.assertEqual(self._ilist(doc, 'room'), ['room'] * 3)
+ self.assertEqual(self._ilist(doc, 'house'), ['house'] * 2)
+
+ if ET is pyET:
+ # test that iter also accepts 'tag' as a keyword arg
+ self.assertEqual(
+ summarize_list(doc.iter(tag='room')),
+ ['room'] * 3)
+
+ # make sure both tag=None and tag='*' return all tags
+ all_tags = ['document', 'house', 'room', 'room',
+ 'shed', 'house', 'room']
+ self.assertEqual(summarize_list(doc.iter()), all_tags)
+ self.assertEqual(self._ilist(doc), all_tags)
+ self.assertEqual(self._ilist(doc, '*'), all_tags)
+
+ def test_getiterator(self):
+ # Element.getiterator() is deprecated.
+ if sys.py3kwarning or ET is pyET:
+ with support.check_warnings(("This method will be removed in future versions. "
+ "Use .+ instead.", PendingDeprecationWarning)):
+ self._test_getiterator()
+ else:
+ self._test_getiterator()
+
+ def _test_getiterator(self):
+ doc = ET.XML('''
+ <document>
+ <house>
+ <room>bedroom1</room>
+ <room>bedroom2</room>
+ </house>
+ <shed>nothing here
+ </shed>
+ <house>
+ <room>bedroom8</room>
+ </house>
+ </document>''')
+
+ self.assertEqual(summarize_list(doc.getiterator('room')),
+ ['room'] * 3)
+ self.assertEqual(summarize_list(doc.getiterator('house')),
+ ['house'] * 2)
+
+ if ET is pyET:
+ # test that getiterator also accepts 'tag' as a keyword arg
+ self.assertEqual(
+ summarize_list(doc.getiterator(tag='room')),
+ ['room'] * 3)
+
+ # make sure both tag=None and tag='*' return all tags
+ all_tags = ['document', 'house', 'room', 'room',
+ 'shed', 'house', 'room']
+ self.assertEqual(summarize_list(doc.getiterator()), all_tags)
+ self.assertEqual(summarize_list(doc.getiterator(None)), all_tags)
+ self.assertEqual(summarize_list(doc.getiterator('*')), all_tags)
+
+ def test_copy(self):
+ a = ET.Element('a')
+ it = a.iter()
+ with self.assertRaises(TypeError):
+ copy.copy(it)
+
+ def test_pickle(self):
+ a = ET.Element('a')
+ it = a.iter()
+ for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+ with self.assertRaises((TypeError, pickle.PicklingError)):
+ pickle.dumps(it, proto)
+
+
+class TreeBuilderTest(unittest.TestCase):
+ sample1 = ('<!DOCTYPE html PUBLIC'
+ ' "-//W3C//DTD XHTML 1.0 Transitional//EN"'
+ ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+ '<html>text<div>subtext</div>tail</html>')
+
+ sample2 = '''<toplevel>sometext</toplevel>'''
+
+ def _check_sample1_element(self, e):
+ self.assertEqual(e.tag, 'html')
+ self.assertEqual(e.text, 'text')
+ self.assertEqual(e.tail, None)
+ self.assertEqual(e.attrib, {})
+ children = list(e)
+ self.assertEqual(len(children), 1)
+ child = children[0]
+ self.assertEqual(child.tag, 'div')
+ self.assertEqual(child.text, 'subtext')
+ self.assertEqual(child.tail, 'tail')
+ self.assertEqual(child.attrib, {})
+
+ def test_dummy_builder(self):
+ class DummyBuilder:
+ data = start = end = lambda *a: None
+
+ def close(self):
+ return 42
+
+ parser = ET.XMLParser(target=DummyBuilder())
+ parser.feed(self.sample1)
+ self.assertEqual(parser.close(), 42)
+
+ @python_only
+ def test_treebuilder_elementfactory_none(self):
+ parser = ET.XMLParser(target=ET.TreeBuilder(element_factory=None))
+ parser.feed(self.sample1)
+ e = parser.close()
+ self._check_sample1_element(e)
+
+ @python_only
+ def test_subclass(self):
+ class MyTreeBuilder(ET.TreeBuilder):
+ def foobar(self, x):
+ return x * 2
+
+ tb = MyTreeBuilder()
+ self.assertEqual(tb.foobar(10), 20)
+
+ parser = ET.XMLParser(target=tb)
+ parser.feed(self.sample1)
+
+ e = parser.close()
+ self._check_sample1_element(e)
+
+ @python_only
+ def test_element_factory(self):
+ lst = []
+ def myfactory(tag, attrib):
+ lst.append(tag)
+ return ET.Element(tag, attrib)
+
+ tb = ET.TreeBuilder(element_factory=myfactory)
+ parser = ET.XMLParser(target=tb)
+ parser.feed(self.sample2)
+ parser.close()
+
+ self.assertEqual(lst, ['toplevel'])
+
+ @python_only
+ def test_element_factory_subclass(self):
+ class MyElement(ET.Element):
+ pass
+
+ tb = ET.TreeBuilder(element_factory=MyElement)
+
+ parser = ET.XMLParser(target=tb)
+ parser.feed(self.sample1)
+ e = parser.close()
+ self.assertIsInstance(e, MyElement)
+ self._check_sample1_element(e)
+
+
+ @python_only
+ def test_doctype(self):
+ class DoctypeParser:
+ _doctype = None
+
+ def doctype(self, name, pubid, system):
+ self._doctype = (name, pubid, system)
+
+ data = start = end = lambda *a: None
+
+ def close(self):
+ return self._doctype
+
+ parser = ET.XMLParser(target=DoctypeParser())
+ parser.feed(self.sample1)
+
+ self.assertEqual(parser.close(),
+ ('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
+ 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'))
+
+
+class XMLParserTest(unittest.TestCase):
+ sample1 = b'<file><line>22</line></file>'
+ sample2 = (b'<!DOCTYPE html PUBLIC'
+ b' "-//W3C//DTD XHTML 1.0 Transitional//EN"'
+ b' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+ b'<html>text</html>')
+
+ def _check_sample_element(self, e):
+ self.assertEqual(e.tag, 'file')
+ self.assertEqual(e[0].tag, 'line')
+ self.assertEqual(e[0].text, '22')
+
+ @python_only
+ def test_constructor_args(self):
+ # Positional args. The first (html) is not supported, but should be
+ # nevertheless correctly accepted.
+ with support.check_py3k_warnings((r'.*\bhtml\b', DeprecationWarning)):
+ parser = ET.XMLParser(None, ET.TreeBuilder(), 'utf-8')
+ parser.feed(self.sample1)
+ self._check_sample_element(parser.close())
+
+ # Now as keyword args.
+ parser2 = ET.XMLParser(encoding='utf-8',
+ target=ET.TreeBuilder())
+ parser2.feed(self.sample1)
+ self._check_sample_element(parser2.close())
+
+ @python_only
+ def test_subclass(self):
+ class MyParser(ET.XMLParser):
+ pass
+ parser = MyParser()
+ parser.feed(self.sample1)
+ self._check_sample_element(parser.close())
+
+ @python_only
+ def test_doctype_warning(self):
+ parser = ET.XMLParser()
+ with support.check_warnings(('', DeprecationWarning)):
+ parser.doctype('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
+ 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd')
+ parser.feed('<html/>')
+ parser.close()
+
+ @python_only
+ def test_subclass_doctype(self):
+ _doctype = []
+ class MyParserWithDoctype(ET.XMLParser):
+ def doctype(self, name, pubid, system):
+ _doctype.append((name, pubid, system))
+
+ parser = MyParserWithDoctype()
+ with support.check_warnings(('', DeprecationWarning)):
+ parser.feed(self.sample2)
+ parser.close()
+ self.assertEqual(_doctype,
+ [('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
+ 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd')])
+
+ _doctype = []
+ _doctype2 = []
+ with warnings.catch_warnings():
+ warnings.simplefilter('error', DeprecationWarning)
+ class DoctypeParser:
+ data = start = end = close = lambda *a: None
+
+ def doctype(self, name, pubid, system):
+ _doctype2.append((name, pubid, system))
+
+ parser = MyParserWithDoctype(target=DoctypeParser())
+ parser.feed(self.sample2)
+ parser.close()
+ self.assertEqual(_doctype, [])
+ self.assertEqual(_doctype2,
+ [('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
+ 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd')])
+
+
+class NamespaceParseTest(unittest.TestCase):
+ def test_find_with_namespace(self):
+ nsmap = {'h': 'hello', 'f': 'foo'}
+ doc = ET.fromstring(SAMPLE_XML_NS_ELEMS)
+
+ self.assertEqual(len(doc.findall('{hello}table', nsmap)), 1)
+ self.assertEqual(len(doc.findall('.//{hello}td', nsmap)), 2)
+ self.assertEqual(len(doc.findall('.//{foo}name', nsmap)), 1)
+
+
+class ElementSlicingTest(unittest.TestCase):
+ def _elem_tags(self, elemlist):
+ return [e.tag for e in elemlist]
+
+ def _subelem_tags(self, elem):
+ return self._elem_tags(list(elem))
+
+ def _make_elem_with_children(self, numchildren):
+ """Create an Element with a tag 'a', with the given amount of children
+ named 'a0', 'a1' ... and so on.
+
+ """
+ e = ET.Element('a')
+ for i in range(numchildren):
+ ET.SubElement(e, 'a%s' % i)
+ return e
+
+ def test_getslice_single_index(self):
+ e = self._make_elem_with_children(10)
+
+ self.assertEqual(e[1].tag, 'a1')
+ self.assertEqual(e[-2].tag, 'a8')
+
+ self.assertRaises(IndexError, lambda: e[12])
+ self.assertRaises(IndexError, lambda: e[-12])
+
+ def test_getslice_range(self):
+ e = self._make_elem_with_children(6)
+
+ self.assertEqual(self._elem_tags(e[3:]), ['a3', 'a4', 'a5'])
+ self.assertEqual(self._elem_tags(e[3:6]), ['a3', 'a4', 'a5'])
+ self.assertEqual(self._elem_tags(e[3:16]), ['a3', 'a4', 'a5'])
+ self.assertEqual(self._elem_tags(e[3:5]), ['a3', 'a4'])
+ self.assertEqual(self._elem_tags(e[3:-1]), ['a3', 'a4'])
+ self.assertEqual(self._elem_tags(e[:2]), ['a0', 'a1'])
+
+ def test_getslice_steps(self):
+ e = self._make_elem_with_children(10)
+
+ self.assertEqual(self._elem_tags(e[8:10:1]), ['a8', 'a9'])
+ self.assertEqual(self._elem_tags(e[::3]), ['a0', 'a3', 'a6', 'a9'])
+ self.assertEqual(self._elem_tags(e[::8]), ['a0', 'a8'])
+ self.assertEqual(self._elem_tags(e[1::8]), ['a1', 'a9'])
+ self.assertEqual(self._elem_tags(e[3::sys.maxsize]), ['a3'])
+ self.assertEqual(self._elem_tags(e[3::sys.maxsize<<64]), ['a3'])
+
+ def test_getslice_negative_steps(self):
+ e = self._make_elem_with_children(4)
+
+ self.assertEqual(self._elem_tags(e[::-1]), ['a3', 'a2', 'a1', 'a0'])
+ self.assertEqual(self._elem_tags(e[::-2]), ['a3', 'a1'])
+ self.assertEqual(self._elem_tags(e[3::-sys.maxsize]), ['a3'])
+ self.assertEqual(self._elem_tags(e[3::-sys.maxsize-1]), ['a3'])
+ self.assertEqual(self._elem_tags(e[3::-sys.maxsize<<64]), ['a3'])
+
+ def test_delslice(self):
+ e = self._make_elem_with_children(4)
+ del e[0:2]
+ self.assertEqual(self._subelem_tags(e), ['a2', 'a3'])
+
+ e = self._make_elem_with_children(4)
+ del e[0:]
+ self.assertEqual(self._subelem_tags(e), [])
+
+ if ET is pyET:
+ e = self._make_elem_with_children(4)
+ del e[::-1]
+ self.assertEqual(self._subelem_tags(e), [])
+
+ e = self._make_elem_with_children(4)
+ del e[::-2]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'a2'])
+
+ e = self._make_elem_with_children(4)
+ del e[1::2]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'a2'])
+
+ e = self._make_elem_with_children(2)
+ del e[::2]
+ self.assertEqual(self._subelem_tags(e), ['a1'])
+
+ def test_setslice_single_index(self):
+ e = self._make_elem_with_children(4)
+ e[1] = ET.Element('b')
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
+
+ e[-2] = ET.Element('c')
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])
+
+ with self.assertRaises(IndexError):
+ e[5] = ET.Element('d')
+ with self.assertRaises(IndexError):
+ e[-5] = ET.Element('d')
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])
+
+ def test_setslice_range(self):
+ e = self._make_elem_with_children(4)
+ e[1:3] = [ET.Element('b%s' % i) for i in range(2)]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'a3'])
+
+ e = self._make_elem_with_children(4)
+ e[1:3] = [ET.Element('b')]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a3'])
+
+ e = self._make_elem_with_children(4)
+ e[1:3] = [ET.Element('b%s' % i) for i in range(3)]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'b2', 'a3'])
+
+ def test_setslice_steps(self):
+ e = self._make_elem_with_children(6)
+ e[1:5:2] = [ET.Element('b%s' % i) for i in range(2)]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'a2', 'b1', 'a4', 'a5'])
+
+ e = self._make_elem_with_children(6)
+ with self.assertRaises(ValueError):
+ e[1:5:2] = [ET.Element('b')]
+ with self.assertRaises(ValueError):
+ e[1:5:2] = [ET.Element('b%s' % i) for i in range(3)]
+ with self.assertRaises(ValueError):
+ e[1:5:2] = []
+ self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3', 'a4', 'a5'])
+
+ e = self._make_elem_with_children(4)
+ e[1::sys.maxsize] = [ET.Element('b')]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
+ e[1::sys.maxsize<<64] = [ET.Element('c')]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])
+
+ def test_setslice_negative_steps(self):
+ e = self._make_elem_with_children(4)
+ e[2:0:-1] = [ET.Element('b%s' % i) for i in range(2)]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b1', 'b0', 'a3'])
+
+ e = self._make_elem_with_children(4)
+ with self.assertRaises(ValueError):
+ e[2:0:-1] = [ET.Element('b')]
+ with self.assertRaises(ValueError):
+ e[2:0:-1] = [ET.Element('b%s' % i) for i in range(3)]
+ with self.assertRaises(ValueError):
+ e[2:0:-1] = []
+ self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3'])
+
+ e = self._make_elem_with_children(4)
+ e[1::-sys.maxsize] = [ET.Element('b')]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])
+ e[1::-sys.maxsize-1] = [ET.Element('c')]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])
+ e[1::-sys.maxsize<<64] = [ET.Element('d')]
+ self.assertEqual(self._subelem_tags(e), ['a0', 'd', 'a2', 'a3'])
+
+
+class IOTest(unittest.TestCase):
+ def tearDown(self):
+ support.unlink(TESTFN)
+
+ def test_encoding(self):
+ # Test encoding issues.
+ elem = ET.Element("tag")
+ elem.text = u"abc"
+ self.assertEqual(serialize(elem), '<tag>abc</tag>')
+ self.assertEqual(serialize(elem, encoding="utf-8"),
+ '<tag>abc</tag>')
+ self.assertEqual(serialize(elem, encoding="us-ascii"),
+ '<tag>abc</tag>')
+ self.assertEqual(serialize(elem, encoding="iso-8859-1"),
+ "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+ "<tag>abc</tag>")
+
+ elem = ET.Element("tag")
+ elem.text = "<&\"\'>"
+ self.assertEqual(serialize(elem), '<tag><&"\'></tag>')
+ self.assertEqual(serialize(elem, encoding="utf-8"),
+ b'<tag><&"\'></tag>')
+ self.assertEqual(serialize(elem, encoding="us-ascii"),
+ b'<tag><&"\'></tag>')
+ self.assertEqual(serialize(elem, encoding="iso-8859-1"),
+ "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+ "<tag><&\"'></tag>")
+
+ elem = ET.Element("tag")
+ elem.attrib["key"] = "<&\"\'>"
+ self.assertEqual(serialize(elem), '<tag key="<&"\'>" />')
+ self.assertEqual(serialize(elem, encoding="utf-8"),
+ b'<tag key="<&"\'>" />')
+ self.assertEqual(serialize(elem, encoding="us-ascii"),
+ b'<tag key="<&"\'>" />')
+ self.assertEqual(serialize(elem, encoding="iso-8859-1"),
+ "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+ "<tag key=\"<&"'>\" />")
+
+ elem = ET.Element("tag")
+ elem.text = u'\xe5\xf6\xf6<>'
+ self.assertEqual(serialize(elem),
+ '<tag>åöö<></tag>')
+ self.assertEqual(serialize(elem, encoding="utf-8"),
+ '<tag>\xc3\xa5\xc3\xb6\xc3\xb6<></tag>')
+ self.assertEqual(serialize(elem, encoding="us-ascii"),
+ '<tag>åöö<></tag>')
+ self.assertEqual(serialize(elem, encoding="iso-8859-1"),
+ "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+ "<tag>\xe5\xf6\xf6<></tag>")
+
+ elem = ET.Element("tag")
+ elem.attrib["key"] = u'\xe5\xf6\xf6<>'
+ self.assertEqual(serialize(elem),
+ '<tag key="åöö<>" />')
+ self.assertEqual(serialize(elem, encoding="utf-8"),
+ '<tag key="\xc3\xa5\xc3\xb6\xc3\xb6<>" />')
+ self.assertEqual(serialize(elem, encoding="us-ascii"),
+ '<tag key="åöö<>" />')
+ self.assertEqual(serialize(elem, encoding="iso-8859-1"),
+ "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+ "<tag key=\"\xe5\xf6\xf6<>\" />")
+
+ def test_write_to_filename(self):
+ tree = ET.ElementTree(ET.XML('''<site />'''))
+ tree.write(TESTFN)
+ with open(TESTFN, 'rb') as f:
+ self.assertEqual(f.read(), b'''<site />''')
+
+ def test_write_to_file(self):
+ tree = ET.ElementTree(ET.XML('''<site />'''))
+ with open(TESTFN, 'wb') as f:
+ tree.write(f)
+ self.assertFalse(f.closed)
+ with open(TESTFN, 'rb') as f:
+ self.assertEqual(f.read(), b'''<site />''')
+
+ def test_read_from_stringio(self):
+ tree = ET.ElementTree()
+ stream = StringIO.StringIO('''<?xml version="1.0"?><site></site>''')
+ tree.parse(stream)
+ self.assertEqual(tree.getroot().tag, 'site')
+
+ def test_write_to_stringio(self):
+ tree = ET.ElementTree(ET.XML('''<site />'''))
+ stream = StringIO.StringIO()
+ tree.write(stream)
+ self.assertEqual(stream.getvalue(), '''<site />''')
+
+ class dummy:
+ pass
+
+ def test_read_from_user_reader(self):
+ stream = StringIO.StringIO('''<?xml version="1.0"?><site></site>''')
+ reader = self.dummy()
+ reader.read = stream.read
+ tree = ET.ElementTree()
+ tree.parse(reader)
+ self.assertEqual(tree.getroot().tag, 'site')
+
+ def test_write_to_user_writer(self):
+ tree = ET.ElementTree(ET.XML('''<site />'''))
+ stream = StringIO.StringIO()
+ writer = self.dummy()
+ writer.write = stream.write
+ tree.write(writer)
+ self.assertEqual(stream.getvalue(), '''<site />''')
+
+ def test_tostringlist_invariant(self):
+ root = ET.fromstring('<tag>foo</tag>')
+ self.assertEqual(
+ ET.tostring(root),
+ ''.join(ET.tostringlist(root)))
+ self.assertEqual(
+ ET.tostring(root, 'utf-16'),
+ b''.join(ET.tostringlist(root, 'utf-16')))
+
+
+class ParseErrorTest(unittest.TestCase):
+ def test_subclass(self):
+ self.assertIsInstance(ET.ParseError(), SyntaxError)
+
+ def _get_error(self, s):
+ try:
+ ET.fromstring(s)
+ except ET.ParseError as e:
+ return e
+
+ def test_error_position(self):
+ self.assertEqual(self._get_error('foo').position, (1, 0))
+ self.assertEqual(self._get_error('<tag>&foo;</tag>').position, (1, 5))
+ self.assertEqual(self._get_error('foobar<').position, (1, 6))
+
+ @python_only
+ def test_error_code(self):
+ from xml.parsers import expat
+ self.assertEqual(expat.ErrorString(self._get_error('foo').code),
+ expat.errors.XML_ERROR_SYNTAX)
+
+
+class KeywordArgsTest(unittest.TestCase):
+ # Test various issues with keyword arguments passed to ET.Element
+ # constructor and methods
+ def test_issue14818(self):
+ x = ET.XML("<a>foo</a>")
+ self.assertEqual(x.find('a', None),
+ x.find(path='a', namespaces=None))
+ self.assertEqual(x.findtext('a', None, None),
+ x.findtext(path='a', default=None, namespaces=None))
+ self.assertEqual(x.findall('a', None),
+ x.findall(path='a', namespaces=None))
+ self.assertEqual(list(x.iterfind('a', None)),
+ list(x.iterfind(path='a', namespaces=None)))
+
+ self.assertEqual(ET.Element('a').attrib, {})
+ elements = [
+ ET.Element('a', dict(href="#", id="foo")),
+ ET.Element('a', attrib=dict(href="#", id="foo")),
+ ET.Element('a', dict(href="#"), id="foo"),
+ ET.Element('a', href="#", id="foo"),
+ ET.Element('a', dict(href="#", id="foo"), href="#", id="foo"),
+ ]
+ for e in elements:
+ self.assertEqual(e.tag, 'a')
+ self.assertEqual(e.attrib, dict(href="#", id="foo"))
+
+ e2 = ET.SubElement(elements[0], 'foobar', attrib={'key1': 'value1'})
+ self.assertEqual(e2.attrib['key1'], 'value1')
+
+ with self.assertRaisesRegexp(TypeError, 'must be dict, not str'):
+ ET.Element('a', "I'm not a dict")
+ with self.assertRaisesRegexp(TypeError, 'must be dict, not str'):
+ ET.Element('a', attrib="I'm not a dict")
- >>> e = ET.Element("{default}elem")
- >>> s = ET.SubElement(e, "{default}elem")
- >>> serialize(e, default_namespace="default") # 1
- '<elem xmlns="default"><elem /></elem>'
-
- >>> e = ET.Element("{default}elem")
- >>> s = ET.SubElement(e, "{default}elem")
- >>> s = ET.SubElement(e, "{not-default}elem")
- >>> serialize(e, default_namespace="default") # 2
- '<elem xmlns="default" xmlns:ns1="not-default"><elem /><ns1:elem /></elem>'
-
- >>> e = ET.Element("{default}elem")
- >>> s = ET.SubElement(e, "{default}elem")
- >>> s = ET.SubElement(e, "elem") # unprefixed name
- >>> serialize(e, default_namespace="default") # 3
- Traceback (most recent call last):
- ValueError: cannot use non-qualified names with default_namespace option
-
- """
-
-def bug_200709_register_namespace():
- """
-
- >>> ET.tostring(ET.Element("{http://namespace.invalid/does/not/exist/}title"))
- '<ns0:title xmlns:ns0="http://namespace.invalid/does/not/exist/" />'
- >>> ET.register_namespace("foo", "http://namespace.invalid/does/not/exist/")
- >>> ET.tostring(ET.Element("{http://namespace.invalid/does/not/exist/}title"))
- '<foo:title xmlns:foo="http://namespace.invalid/does/not/exist/" />'
-
- And the Dublin Core namespace is in the default list:
-
- >>> ET.tostring(ET.Element("{http://purl.org/dc/elements/1.1/}title"))
- '<dc:title xmlns:dc="http://purl.org/dc/elements/1.1/" />'
-
- """
-
-def bug_200709_element_comment():
- """
-
- Not sure if this can be fixed, really (since the serializer needs
- ET.Comment, not cET.comment).
-
- >>> a = ET.Element('a')
- >>> a.append(ET.Comment('foo'))
- >>> a[0].tag == ET.Comment
- True
-
- >>> a = ET.Element('a')
- >>> a.append(ET.PI('foo'))
- >>> a[0].tag == ET.PI
- True
-
- """
-
-def bug_200709_element_insert():
- """
+# --------------------------------------------------------------------
- >>> a = ET.Element('a')
- >>> b = ET.SubElement(a, 'b')
- >>> c = ET.SubElement(a, 'c')
- >>> d = ET.Element('d')
- >>> a.insert(0, d)
- >>> summarize_list(a)
- ['d', 'b', 'c']
- >>> a.insert(-1, d)
- >>> summarize_list(a)
- ['d', 'b', 'd', 'c']
-
- """
-
-def bug_200709_iter_comment():
- """
-
- >>> a = ET.Element('a')
- >>> b = ET.SubElement(a, 'b')
- >>> comment_b = ET.Comment("TEST-b")
- >>> b.append(comment_b)
- >>> summarize_list(a.iter(ET.Comment))
- ['<Comment>']
-
- """
-
-def bug_18347():
- """
-
- >>> e = ET.XML('<html><CamelCase>text</CamelCase></html>')
- >>> serialize(e)
- '<html><CamelCase>text</CamelCase></html>'
- >>> serialize(e, method="html")
- '<html><CamelCase>text</CamelCase></html>'
- """
+class NoAcceleratorTest(unittest.TestCase):
+ def setUp(self):
+ if ET is not pyET:
+ raise unittest.SkipTest('only for the Python version')
-# --------------------------------------------------------------------
-# reported on bugs.python.org
-
-def bug_1534630():
- """
-
- >>> bob = ET.TreeBuilder()
- >>> e = bob.data("data")
- >>> e = bob.start("tag", {})
- >>> e = bob.end("tag")
- >>> e = bob.close()
- >>> serialize(e)
- '<tag />'
-
- """
-
-def check_issue6233():
- """
-
- >>> e = ET.XML("<?xml version='1.0' encoding='utf-8'?><body>t\\xc3\\xa3g</body>")
- >>> ET.tostring(e, 'ascii')
- "<?xml version='1.0' encoding='ascii'?>\\n<body>tãg</body>"
- >>> e = ET.XML("<?xml version='1.0' encoding='iso-8859-1'?><body>t\\xe3g</body>")
- >>> ET.tostring(e, 'ascii')
- "<?xml version='1.0' encoding='ascii'?>\\n<body>tãg</body>"
-
- """
-
-def check_issue3151():
- """
-
- >>> e = ET.XML('<prefix:localname xmlns:prefix="${stuff}"/>')
- >>> e.tag
- '{${stuff}}localname'
- >>> t = ET.ElementTree(e)
- >>> ET.tostring(e)
- '<ns0:localname xmlns:ns0="${stuff}" />'
-
- """
-
-def check_issue6565():
- """
-
- >>> elem = ET.XML("<body><tag/></body>")
- >>> summarize_list(elem)
- ['tag']
- >>> newelem = ET.XML(SAMPLE_XML)
- >>> elem[:] = newelem[:]
- >>> summarize_list(elem)
- ['tag', 'tag', 'section']
-
- """
-
-def check_html_empty_elems_serialization(self):
- # issue 15970
- # from http://www.w3.org/TR/html401/index/elements.html
- """
-
- >>> empty_elems = ['AREA', 'BASE', 'BASEFONT', 'BR', 'COL', 'FRAME', 'HR',
- ... 'IMG', 'INPUT', 'ISINDEX', 'LINK', 'META', 'PARAM']
- >>> elems = ''.join('<%s />' % elem for elem in empty_elems)
- >>> serialize(ET.XML('<html>%s</html>' % elems), method='html')
- '<html><AREA><BASE><BASEFONT><BR><COL><FRAME><HR><IMG><INPUT><ISINDEX><LINK><META><PARAM></html>'
- >>> serialize(ET.XML('<html>%s</html>' % elems.lower()), method='html')
- '<html><area><base><basefont><br><col><frame><hr><img><input><isindex><link><meta><param></html>'
- >>> elems = ''.join('<%s></%s>' % (elem, elem) for elem in empty_elems)
- >>> serialize(ET.XML('<html>%s</html>' % elems), method='html')
- '<html><AREA><BASE><BASEFONT><BR><COL><FRAME><HR><IMG><INPUT><ISINDEX><LINK><META><PARAM></html>'
- >>> serialize(ET.XML('<html>%s</html>' % elems.lower()), method='html')
- '<html><area><base><basefont><br><col><frame><hr><img><input><isindex><link><meta><param></html>'
-
- """
+ # Test that the C accelerator was not imported for pyET
+ def test_correct_import_pyET(self):
+ # The type of methods defined in Python code is types.FunctionType,
+ # while the type of methods defined inside _elementtree is
+ # <class 'wrapper_descriptor'>
+ self.assertIsInstance(pyET.Element.__init__, types.FunctionType)
+ self.assertIsInstance(pyET.XMLParser.__init__, types.FunctionType)
# --------------------------------------------------------------------
-class CleanContext(object):
- """Provide default namespace mapping and path cache."""
- checkwarnings = None
-
- def __init__(self, quiet=False):
- if sys.flags.optimize >= 2:
- # under -OO, doctests cannot be run and therefore not all warnings
- # will be emitted
- quiet = True
- deprecations = (
- # Search behaviour is broken if search path starts with "/".
- ("This search is broken in 1.3 and earlier, and will be fixed "
- "in a future version. If you rely on the current behaviour, "
- "change it to '.+'", FutureWarning),
- # Element.getchildren() and Element.getiterator() are deprecated.
- ("This method will be removed in future versions. "
- "Use .+ instead.", DeprecationWarning),
- ("This method will be removed in future versions. "
- "Use .+ instead.", PendingDeprecationWarning),
- # XMLParser.doctype() is deprecated.
- ("This method of XMLParser is deprecated. Define doctype.. "
- "method on the TreeBuilder target.", DeprecationWarning))
- self.checkwarnings = test_support.check_warnings(*deprecations,
- quiet=quiet)
-
- def __enter__(self):
- from xml.etree import ElementTree
- self._nsmap = ElementTree._namespace_map
- self._path_cache = ElementTree.ElementPath._cache
- # Copy the default namespace mapping
- ElementTree._namespace_map = self._nsmap.copy()
- # Copy the path cache (should be empty)
- ElementTree.ElementPath._cache = self._path_cache.copy()
- self.checkwarnings.__enter__()
-
- def __exit__(self, *args):
- from xml.etree import ElementTree
+def test_main(module=None):
+ # When invoked without a module, runs the Python ET tests by loading pyET.
+ # Otherwise, uses the given module as the ET.
+ if module is None:
+ module = pyET
+
+ global ET
+ ET = module
+
+ test_classes = [
+ ModuleTest,
+ ElementSlicingTest,
+ BasicElementTest,
+ BadElementTest,
+ BadElementPathTest,
+ ElementTreeTest,
+ IOTest,
+ ParseErrorTest,
+ XIncludeTest,
+ ElementTreeTypeTest,
+ ElementFindTest,
+ ElementIterTest,
+ TreeBuilderTest,
+ XMLParserTest,
+ BugsTest,
+ ]
+
+ # These tests will only run for the pure-Python version that doesn't import
+ # _elementtree. We can't use skipUnless here, because pyET is filled in only
+ # after the module is loaded.
+ if pyET is not ET:
+ test_classes.extend([
+ NoAcceleratorTest,
+ ])
+
+ # Provide default namespace mapping and path cache.
+ from xml.etree import ElementPath
+ nsmap = pyET._namespace_map
+ # Copy the default namespace mapping
+ nsmap_copy = nsmap.copy()
+ # Copy the path cache (should be empty)
+ path_cache = ElementPath._cache
+ ElementPath._cache = path_cache.copy()
+ try:
+ support.run_unittest(*test_classes)
+ finally:
+ from xml.etree import ElementPath
# Restore mapping and path cache
- ElementTree._namespace_map = self._nsmap
- ElementTree.ElementPath._cache = self._path_cache
- self.checkwarnings.__exit__(*args)
-
-
-def test_main(module_name='xml.etree.ElementTree'):
- from test import test_xml_etree
-
- use_py_module = (module_name == 'xml.etree.ElementTree')
-
- # The same doctests are used for both the Python and the C implementations
- assert test_xml_etree.ET.__name__ == module_name
-
- # XXX the C module should give the same warnings as the Python module
- with CleanContext(quiet=not use_py_module):
- test_support.run_doctest(test_xml_etree, verbosity=True)
+ nsmap.clear()
+ nsmap.update(nsmap_copy)
+ ElementPath._cache = path_cache
+ # don't interfere with subsequent tests
+ ET = None
- # The module should not be changed by the tests
- assert test_xml_etree.ET.__name__ == module_name
if __name__ == '__main__':
test_main()
cET = test_support.import_module('xml.etree.cElementTree')
-# cElementTree specific tests
-
-def sanity():
- """
- Import sanity.
-
- >>> from xml.etree import cElementTree
- """
-
-
+@unittest.skipUnless(cET, 'requires _elementtree')
class MiscTests(unittest.TestCase):
# Issue #8651.
@precisionbigmemtest(size=_2G + 100, memuse=1)
from test import test_xml_etree, test_xml_etree_c
# Run the tests specific to the C implementation
- test_support.run_doctest(test_xml_etree_c, verbosity=True)
+ test_support.run_unittest(MiscTests)
+
+ # Run the same test suite as the Python module
+ test_xml_etree.test_main(module=cET)
- # Assign the C implementation before running the doctests
- # Patch the __name__, to prevent confusion with the pure Python test
- pyET = test_xml_etree.ET
- py__name__ = test_xml_etree.__name__
- test_xml_etree.ET = cET
- if __name__ != '__main__':
- test_xml_etree.__name__ = __name__
- try:
- # Run the same test suite as xml.etree.ElementTree
- test_xml_etree.test_main(module_name='xml.etree.cElementTree')
- finally:
- test_xml_etree.ET = pyET
- test_xml_etree.__name__ = py__name__
if __name__ == '__main__':
test_main()
_top_level_dir = None
def loadTestsFromTestCase(self, testCaseClass):
- """Return a suite of all tests cases contained in testCaseClass"""
+ """Return a suite of all test cases contained in testCaseClass"""
if issubclass(testCaseClass, suite.TestSuite):
raise TypeError("Test cases should not be derived from TestSuite." \
" Maybe you meant to derive from TestCase?")
return loaded_suite
def loadTestsFromModule(self, module, use_load_tests=True):
- """Return a suite of all tests cases contained in the given module"""
+ """Return a suite of all test cases contained in the given module"""
tests = []
for name in dir(module):
obj = getattr(module, name)
return tests
def loadTestsFromName(self, name, module=None):
- """Return a suite of all tests cases given a string specifier.
+ """Return a suite of all test cases given a string specifier.
The name may resolve either to a module, a test case class, a
test method within a test case class, or a callable object which
raise TypeError("don't know how to make test from: %s" % obj)
def loadTestsFromNames(self, names, module=None):
- """Return a suite of all tests cases found using the given sequence
+ """Return a suite of all test cases found using the given sequence
of string specifiers. See 'loadTestsFromName()'.
"""
suites = [self.loadTestsFromName(name, module) for name in names]
def __init__(self, default_handler):
self.called = False
self.original_handler = default_handler
- if isinstance(default_handler, int):
+ if isinstance(default_handler, (int, long)):
if default_handler == signal.SIG_DFL:
# Pretend it's signal.default_int_handler instead.
default_handler = signal.default_int_handler
### Tests for TestLoader.loadTestsFromTestCase
################################################################
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
def test_loadTestsFromTestCase(self):
class Foo(unittest.TestCase):
loader = unittest.TestLoader()
self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
#
# Make sure it does the right thing even if no tests were found
loader = unittest.TestLoader()
self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite)
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
#
# What happens if loadTestsFromTestCase() is given an object
else:
self.fail('Should raise TypeError')
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
#
# Make sure loadTestsFromTestCase() picks up the default test method
"""splithost('//host[:port]/path') --> 'host[:port]', '/path'."""
global _hostprog
if _hostprog is None:
- import re
- _hostprog = re.compile('^//([^/?]*)(.*)$')
+ _hostprog = re.compile('//([^/#?]*)(.*)', re.DOTALL)
match = _hostprog.match(url)
if match:
no_proxy_list = [proxy.strip() for proxy in no_proxy.split(',')]
for name in no_proxy_list:
if name:
+ name = name.lstrip('.') # ignore leading dots
name = re.escape(name)
pattern = r'(.+\.)?%s$' % name
if (re.match(pattern, hostonly, re.I)
"category must be a class"
assert issubclass(category, Warning), "category must be a Warning subclass"
assert isinstance(module, basestring), "module must be a string"
- assert isinstance(lineno, int) and lineno >= 0, \
+ assert isinstance(lineno, (int, long)) and lineno >= 0, \
"lineno must be an int >= 0"
item = (action, re.compile(message, re.I), category,
- re.compile(module), lineno)
+ re.compile(module), int(lineno))
if append:
filters.append(item)
else:
"""
assert action in ("error", "ignore", "always", "default", "module",
"once"), "invalid action: %r" % (action,)
- assert isinstance(lineno, int) and lineno >= 0, \
+ assert isinstance(lineno, (int, long)) and lineno >= 0, \
"lineno must be an int >= 0"
- item = (action, None, category, None, lineno)
+ item = (action, None, category, None, int(lineno))
if append:
filters.append(item)
else:
def __init__(self, message, category, filename, lineno, file=None,
line=None):
- local_values = locals()
- for attr in self._WARNING_DETAILS:
- setattr(self, attr, local_values[attr])
+ self.message = message
+ self.category = category
+ self.filename = filename
+ self.lineno = lineno
+ self.file = file
+ self.line = line
self._category_name = category.__name__ if category else None
def __str__(self):
proxy,
CallableProxyType,
ProxyType,
- ReferenceType)
+ ReferenceType,
+ _remove_dead_weakref)
from _weakrefset import WeakSet, _IterationGuard
args = args[1:]
if len(args) > 1:
raise TypeError('expected at most 1 arguments, got %d' % len(args))
- def remove(wr, selfref=ref(self)):
+ def remove(wr, selfref=ref(self), _atomic_removal=_remove_dead_weakref):
self = selfref()
if self is not None:
if self._iterating:
self._pending_removals.append(wr.key)
else:
- del self.data[wr.key]
+ # Atomic removal is necessary since this function
+ # can be called asynchronously by the GC
+ _atomic_removal(self.data, wr.key)
self._remove = remove
# A list of keys to be removed
self._pending_removals = []
# We shouldn't encounter any KeyError, because this method should
# always be called *before* mutating the dict.
while l:
- del d[l.pop()]
+ key = l.pop()
+ _remove_dead_weakref(d, key)
def __getitem__(self, key):
+ if self._pending_removals:
+ self._commit_removals()
o = self.data[key]()
if o is None:
raise KeyError, key
del self.data[key]
def __contains__(self, key):
+ if self._pending_removals:
+ self._commit_removals()
try:
o = self.data[key]()
except KeyError:
return o is not None
def has_key(self, key):
+ if self._pending_removals:
+ self._commit_removals()
try:
o = self.data[key]()
except KeyError:
self.data.clear()
def copy(self):
+ if self._pending_removals:
+ self._commit_removals()
new = WeakValueDictionary()
for key, wr in self.data.items():
o = wr()
def __deepcopy__(self, memo):
from copy import deepcopy
+ if self._pending_removals:
+ self._commit_removals()
new = self.__class__()
for key, wr in self.data.items():
o = wr()
return new
def get(self, key, default=None):
+ if self._pending_removals:
+ self._commit_removals()
try:
wr = self.data[key]
except KeyError:
return o
def items(self):
+ if self._pending_removals:
+ self._commit_removals()
L = []
for key, wr in self.data.items():
o = wr()
return L
def iteritems(self):
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
for wr in self.data.itervalues():
value = wr()
yield wr.key, value
def iterkeys(self):
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
for k in self.data.iterkeys():
yield k
keep the values around longer than needed.
"""
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
for wr in self.data.itervalues():
yield wr
def itervalues(self):
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
for wr in self.data.itervalues():
obj = wr()
try:
o = self.data.pop(key)()
except KeyError:
+ o = None
+ if o is None:
if args:
return args[0]
- raise
- if o is None:
- raise KeyError, key
+ else:
+ raise KeyError, key
else:
return o
def setdefault(self, key, default=None):
+ if self._pending_removals:
+ self._commit_removals()
try:
- wr = self.data[key]
+ o = self.data[key]()
except KeyError:
- if self._pending_removals:
- self._commit_removals()
+ o = None
+ if o is None:
self.data[key] = KeyedRef(default, self._remove, key)
return default
else:
- return wr()
+ return o
def update(*args, **kwargs):
if not args:
keep the values around longer than needed.
"""
+ if self._pending_removals:
+ self._commit_removals()
return self.data.values()
def values(self):
+ if self._pending_removals:
+ self._commit_removals()
L = []
for wr in self.data.values():
o = wr()
self._tail = 1
return self._last
+_sentinel = ['sentinel']
+
##
# Element structure builder for XML source data, based on the
# <b>expat</b> parser.
class XMLParser(object):
- def __init__(self, html=0, target=None, encoding=None):
+ def __init__(self, html=_sentinel, target=None, encoding=None):
+ if html is not _sentinel:
+ warnings.warnpy3k(
+ "The html argument of XMLParser() is deprecated",
+ DeprecationWarning, stacklevel=2)
try:
from xml.parsers import expat
except ImportError:
pubid = pubid[1:-1]
if hasattr(self.target, "doctype"):
self.target.doctype(name, pubid, system[1:-1])
- elif self.doctype is not self._XMLParser__doctype:
+ elif self.doctype != self._XMLParser__doctype:
# warn about deprecated call
self._XMLParser__doctype(name, pubid, system[1:-1])
self.doctype(name, pubid, system[1:-1])
source = saxutils.prepare_input_source(source)
self._source = source
- self.reset()
- self._cont_handler.setDocumentLocator(ExpatLocator(self))
- xmlreader.IncrementalParser.parse(self, source)
+ try:
+ self.reset()
+ self._cont_handler.setDocumentLocator(ExpatLocator(self))
+ xmlreader.IncrementalParser.parse(self, source)
+ except:
+ # bpo-30264: Close the source on error to not leak resources:
+ # xml.sax.parse() doesn't give access to the underlying parser
+ # to the caller
+ self._close_source()
+ raise
def prepareParser(self, source):
if source.getSystemId() is not None:
# FIXME: when to invoke error()?
self._err_handler.fatalError(exc)
+ def _close_source(self):
+ source = self._source
+ try:
+ file = source.getCharacterStream()
+ if file is not None:
+ file.close()
+ finally:
+ file = source.getByteStream()
+ if file is not None:
+ file.close()
+
def close(self):
if (self._entity_stack or self._parser is None or
isinstance(self._parser, _ClosedParser)):
parser.ErrorColumnNumber = self._parser.ErrorColumnNumber
parser.ErrorLineNumber = self._parser.ErrorLineNumber
self._parser = parser
+ self._close_source()
def _reset_cont_handler(self):
self._parser.ProcessingInstructionHandler = \
# set the modified flag so central directory gets written
# even if no files are added to the archive
self._didModify = True
- self._start_disk = self.fp.tell()
elif key == 'a':
try:
# See if file is a zip file
# set the modified flag so central directory gets written
# even if no files are added to the archive
self._didModify = True
- self._start_disk = self.fp.tell()
else:
raise RuntimeError('Mode must be "r", "w" or "a"')
except:
offset_cd = endrec[_ECD_OFFSET] # offset of central directory
self._comment = endrec[_ECD_COMMENT] # archive comment
- # self._start_disk: Position of the start of ZIP archive
- # It is zero, unless ZIP was concatenated to another file
- self._start_disk = endrec[_ECD_LOCATION] - size_cd - offset_cd
+ # "concat" is zero, unless zip was concatenated to another file
+ concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
if endrec[_ECD_SIGNATURE] == stringEndArchive64:
# If Zip64 extension structures are present, account for them
- self._start_disk -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
+ concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
if self.debug > 2:
- inferred = self._start_disk + offset_cd
- print "given, inferred, offset", offset_cd, inferred, self._start_disk
+ inferred = concat + offset_cd
+ print "given, inferred, offset", offset_cd, inferred, concat
# self.start_dir: Position of start of central directory
- self.start_dir = offset_cd + self._start_disk
+ self.start_dir = offset_cd + concat
fp.seek(self.start_dir, 0)
data = fp.read(size_cd)
fp = cStringIO.StringIO(data)
t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
x._decodeExtra()
- x.header_offset = x.header_offset + self._start_disk
+ x.header_offset = x.header_offset + concat
x.filename = x._decodeFilename()
self.filelist.append(x)
self.NameToInfo[x.filename] = x
raise RuntimeError('Compressed size larger than uncompressed size')
# Seek backwards and write file header (which will now include
# correct CRC and file sizes)
- position = self.fp.tell() # Preserve current position in file
+ position = self.fp.tell() # Preserve current position in file
self.fp.seek(zinfo.header_offset, 0)
self.fp.write(zinfo.FileHeader(zip64))
self.fp.seek(position, 0)
file_size = zinfo.file_size
compress_size = zinfo.compress_size
- header_offset = zinfo.header_offset - self._start_disk
- if header_offset > ZIP64_LIMIT:
- extra.append(header_offset)
+ if zinfo.header_offset > ZIP64_LIMIT:
+ extra.append(zinfo.header_offset)
header_offset = 0xffffffffL
+ else:
+ header_offset = zinfo.header_offset
extra_data = zinfo.extra
if extra:
# Write end-of-zip-archive record
centDirCount = len(self.filelist)
centDirSize = pos2 - pos1
- centDirOffset = pos1 - self._start_disk
+ centDirOffset = pos1
requires_zip64 = None
if centDirCount > ZIP_FILECOUNT_LIMIT:
requires_zip64 = "Files count"
Python 2.6.
In addition to what is supplied with OS X 10.5+ and Xcode 3+, the script
-requires an installed version of hg and a third-party version of
+requires an installed third-party version of
Tcl/Tk 8.4 (for OS X 10.4 and 10.5 deployment targets) or Tcl/TK 8.5
(for 10.6 or later) installed in /Library/Frameworks. When installed,
the Python built by this script will attempt to dynamically link first to
32-bit-only installer builds are still possible on OS X 10.4 with Xcode 2.5
and the installation of additional components, such as a newer Python
-(2.5 is needed for Python parser updates), hg, and for the documentation
+(2.5 is needed for Python parser updates) and for the documentation
build either svn (pre-3.4.1) or sphinx-build (3.4.1 and later).
Usage: see USAGE variable in the script.
result.extend([
dict(
- name="OpenSSL 1.0.2j",
- url="https://www.openssl.org/source/openssl-1.0.2j.tar.gz",
- checksum='96322138f0b69e61b7212bc53d5e912b',
+ name="OpenSSL 1.0.2k",
+ url="https://www.openssl.org/source/openssl-1.0.2k.tar.gz",
+ checksum='f965fc0bf01bf882b31314b61391ae65',
patches=[
"openssl_sdk_makedepend.patch",
],
"""
try:
f = open(configfile, "r")
- except:
+ except OSError:
fatal("Framework configuration file not found: %s" % configfile)
for l in f:
base_path = base_path + ':' + OLD_DEVELOPER_TOOLS
os.environ['PATH'] = base_path
print("Setting default PATH: %s"%(os.environ['PATH']))
- # Ensure ws have access to hg and to sphinx-build.
- # You may have to create links in /usr/bin for them.
- runCommand('hg --version')
+ # Ensure we have access to sphinx-build.
+ # You may have to create a link in /usr/bin for it.
runCommand('sphinx-build --version')
def parseOptions(args=None):
except:
try:
os.unlink(fname)
- except:
+ except OSError:
pass
def verifyThirdPartyFile(url, checksum, fname):
docdir = os.path.join(rootDir, 'pydocs')
curDir = os.getcwd()
os.chdir(buildDir)
- # The Doc build changed for 3.4 (technically, for 3.4.1) and for 2.7.9
runCommand('make clean')
# Assume sphinx-build is on our PATH, checked in checkEnvironment
runCommand('make html')
shellQuote(WORKDIR)[1:-1],
shellQuote(WORKDIR)[1:-1]))
- print("Running make touch")
- runCommand("make touch")
-
- print("Running make")
- runCommand("make")
+ # Look for environment value BUILDINSTALLER_BUILDPYTHON_MAKE_EXTRAS
+ # and, if defined, append its value to the make command. This allows
+ # us to pass in version control tags, like GITTAG, to a build from a
+ # tarball rather than from a vcs checkout, thus eliminating the need
+ # to have a working copy of the vcs program on the build machine.
+ #
+ # A typical use might be:
+ # export BUILDINSTALLER_BUILDPYTHON_MAKE_EXTRAS=" \
+ # GITVERSION='echo 123456789a' \
+ # GITTAG='echo v3.6.0' \
+ # GITBRANCH='echo 3.6'"
+
+ make_extras = os.getenv("BUILDINSTALLER_BUILDPYTHON_MAKE_EXTRAS")
+ if make_extras:
+ make_cmd = "make " + make_extras
+ else:
+ make_cmd = "make"
+ print("Running " + make_cmd)
+ runCommand(make_cmd)
print("Running make install")
runCommand("make install DESTDIR=%s"%(
# HG changeset patch
#
-# using openssl 1.0.2j
+# using openssl 1.0.2k
#
# - support building with an OS X SDK
\b0 \
1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated documentation.\
\
-2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Python Software Foundation; All Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee.\
+2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee.\
\
3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python.\
\
\
\
\
-}
\ No newline at end of file
+}
<key>CFBundleExecutable</key>
<string>IDLE</string>
<key>CFBundleGetInfoString</key>
- <string>%VERSION%, © 2001-2016 Python Software Foundation</string>
+ <string>%VERSION%, © 2001-2017 Python Software Foundation</string>
<key>CFBundleIconFile</key>
<string>IDLE.icns</string>
<key>CFBundleIdentifier</key>
<key>CFBundleExecutable</key>
<string>PythonLauncher</string>
<key>CFBundleGetInfoString</key>
- <string>%VERSION%, © 2001-2016 Python Software Foundation</string>
+ <string>%VERSION%, © 2001-2017 Python Software Foundation</string>
<key>CFBundleIconFile</key>
<string>PythonLauncher.icns</string>
<key>CFBundleIdentifier</key>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleLongVersionString</key>
- <string>%version%, (c) 2001-2016 Python Software Foundation.</string>
+ <string>%version%, (c) 2001-2017 Python Software Foundation.</string>
<key>CFBundleName</key>
<string>Python</string>
<key>CFBundlePackageType</key>
<key>CFBundlePackageType</key>
<string>FMWK</string>
<key>CFBundleShortVersionString</key>
- <string>%VERSION%, (c) 2001-2016 Python Software Foundation.</string>
+ <string>%VERSION%, (c) 2001-2017 Python Software Foundation.</string>
<key>CFBundleLongVersionString</key>
- <string>%VERSION%, (c) 2001-2016 Python Software Foundation.</string>
+ <string>%VERSION%, (c) 2001-2017 Python Software Foundation.</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleVersion</key>
LINKCC= @LINKCC@
AR= @AR@
RANLIB= @RANLIB@
-SVNVERSION= @SVNVERSION@
-HGVERSION= @HGVERSION@
-HGTAG= @HGTAG@
-HGBRANCH= @HGBRANCH@
+GITVERSION= @GITVERSION@
+GITTAG= @GITTAG@
+GITBRANCH= @GITBRANCH@
PGO_PROF_GEN_FLAG=@PGO_PROF_GEN_FLAG@
PGO_PROF_USE_FLAG=@PGO_PROF_USE_FLAG@
LLVM_PROF_MERGER=@LLVM_PROF_MERGER@
PYTHON= python$(EXE)
BUILDPYTHON= python$(BUILDEXE)
+PYTHON_FOR_REGEN=@PYTHON_FOR_REGEN@
PYTHON_FOR_BUILD=@PYTHON_FOR_BUILD@
_PYTHON_HOST_PLATFORM=@_PYTHON_HOST_PLATFORM@
HOST_GNU_TYPE= @host@
##########################################################################
-# Grammar
-GRAMMAR_H= Include/graminit.h
-GRAMMAR_C= Python/graminit.c
-GRAMMAR_INPUT= $(srcdir)/Grammar/Grammar
-
LIBFFI_INCLUDEDIR= @LIBFFI_INCLUDEDIR@
PGENOBJS= $(POBJS) $(PGOBJS)
##########################################################################
-# AST
-AST_H_DIR= Include
-AST_H= $(AST_H_DIR)/Python-ast.h
-AST_C_DIR= Python
-AST_C= $(AST_C_DIR)/Python-ast.c
-AST_ASDL= $(srcdir)/Parser/Python.asdl
-
-ASDLGEN_FILES= $(srcdir)/Parser/asdl.py $(srcdir)/Parser/asdl_c.py
-# XXX Note that a build now requires Python exist before the build starts
-ASDLGEN= $(srcdir)/Parser/asdl_c.py
-
-##########################################################################
-# Python
-
-OPCODETARGETS_H= \
- $(srcdir)/Python/opcode_targets.h
-
-OPCODETARGETGEN= \
- $(srcdir)/Python/makeopcodetargets.py
-
-OPCODETARGETGEN_FILES= \
- $(OPCODETARGETGEN) $(srcdir)/Lib/opcode.py
-
PYTHON_OBJS= \
Python/_warnings.o \
Python/Python-ast.o \
@echo "lcov report at $(COVERAGE_REPORT)/index.html"
@echo
-coverage-report:
- : # force rebuilding of parser
- @touch $(GRAMMAR_INPUT)
+# Force regeneration of parser
+coverage-report: regen-grammar
: # build with coverage info
$(MAKE) coverage
: # run tests, ignore failures
echo "-----------------------------------------------"; \
fi
+
+############################################################################
+# Regenerate all generated files
+
+regen-all: regen-opcode-targets regen-grammar regen-ast
+
############################################################################
# Special rules for object files
$(MODOBJS) \
$(srcdir)/Modules/getbuildinfo.c
$(CC) -c $(PY_CFLAGS) \
- -DSVNVERSION="\"`LC_ALL=C $(SVNVERSION)`\"" \
- -DHGVERSION="\"`LC_ALL=C $(HGVERSION)`\"" \
- -DHGTAG="\"`LC_ALL=C $(HGTAG)`\"" \
- -DHGBRANCH="\"`LC_ALL=C $(HGBRANCH)`\"" \
+ -DGITVERSION="\"`LC_ALL=C $(GITVERSION)`\"" \
+ -DGITTAG="\"`LC_ALL=C $(GITTAG)`\"" \
+ -DGITBRANCH="\"`LC_ALL=C $(GITBRANCH)`\"" \
-o $@ $(srcdir)/Modules/getbuildinfo.c
Modules/getpath.o: $(srcdir)/Modules/getpath.c Makefile
Modules/pwdmodule.o: $(srcdir)/Modules/pwdmodule.c $(srcdir)/Modules/posixmodule.h
-$(GRAMMAR_H): @GENERATED_COMMENT@ $(GRAMMAR_INPUT) $(PGEN)
- @$(MKDIR_P) Include
- $(PGEN) $(GRAMMAR_INPUT) $(GRAMMAR_H) $(GRAMMAR_C)
-$(GRAMMAR_C): @GENERATED_COMMENT@ $(GRAMMAR_H)
- touch $(GRAMMAR_C)
-
$(PGEN): $(PGENOBJS)
$(CC) $(OPT) $(LDFLAGS) $(PGENOBJS) $(LIBS) -o $(PGEN)
+.PHONY: regen-grammar
+regen-grammar: $(PGEN)
+ # Regenerate Include/graminit.h and Python/graminit.c
+ # from Grammar/Grammar using pgen
+ @$(MKDIR_P) Include
+ $(PGEN) $(srcdir)/Grammar/Grammar \
+ $(srcdir)/Include/graminit.h \
+ $(srcdir)/Python/graminit.c
+
Parser/grammar.o: $(srcdir)/Parser/grammar.c \
$(srcdir)/Include/token.h \
$(srcdir)/Include/grammar.h
Parser/pgenmain.o: $(srcdir)/Include/parsetok.h
-$(AST_H): $(AST_ASDL) $(ASDLGEN_FILES)
- $(MKDIR_P) $(AST_H_DIR)
- $(ASDLGEN) -h $(AST_H_DIR) $(AST_ASDL)
-
-$(AST_C): $(AST_ASDL) $(ASDLGEN_FILES)
- $(MKDIR_P) $(AST_C_DIR)
- $(ASDLGEN) -c $(AST_C_DIR) $(AST_ASDL)
-
-Python/compile.o Python/symtable.o Python/ast.o: $(GRAMMAR_H) $(AST_H)
+.PHONY=regen-ast
+regen-ast:
+ # Regenerate Include/Python-ast.h using Parser/asdl_c.py -h
+ $(MKDIR_P) $(srcdir)/Include
+ $(PYTHON_FOR_REGEN) $(srcdir)/Parser/asdl_c.py \
+ -h $(srcdir)/Include \
+ $(srcdir)/Parser/Python.asdl
+ # Regenerate Python/Python-ast.c using Parser/asdl_c.py -c
+ $(MKDIR_P) $(srcdir)/Python
+ $(PYTHON_FOR_REGEN) $(srcdir)/Parser/asdl_c.py \
+ -c $(srcdir)/Python \
+ $(srcdir)/Parser/Python.asdl
+
+Python/compile.o Python/symtable.o Python/ast.o: $(srcdir)/Include/graminit.h $(srcdir)/Include/Python-ast.h
Python/getplatform.o: $(srcdir)/Python/getplatform.c
$(CC) -c $(PY_CFLAGS) -DPLATFORM='"$(MACHDEP)"' -o $@ $(srcdir)/Python/getplatform.c
Objects/stringobject.o: $(srcdir)/Objects/stringobject.c \
$(STRINGLIB_HEADERS)
-$(OPCODETARGETS_H): $(OPCODETARGETGEN_FILES)
- $(OPCODETARGETGEN) $(OPCODETARGETS_H)
+.PHONY: regen-opcode-targets
+regen-opcode-targets:
+ # Regenerate Python/opcode_targets.h from Lib/opcode.py
+ # using Python/makeopcodetargets.py
+ $(PYTHON_FOR_REGEN) $(srcdir)/Python/makeopcodetargets.py \
+ $(srcdir)/Python/opcode_targets.h
-Python/ceval.o: $(OPCODETARGETS_H)
+Python/ceval.o: $(srcdir)/Python/opcode_targets.h
Python/formatter_unicode.o: $(srcdir)/Python/formatter_unicode.c \
$(STRINGLIB_HEADERS)
Include/weakrefobject.h \
pyconfig.h \
$(PARSER_HEADERS) \
- $(AST_H)
+ $(srcdir)/Include/Python-ast.h
$(LIBRARY_OBJS) $(MODOBJS) Modules/python.o: $(PYTHON_HEADERS)
# generated bytecode. This is sometimes a very shy bug needing a lot of
# sample data.
+.PHONY: test testall testuniversal buildbottest pythoninfo
+
TESTOPTS= -l $(EXTRATESTOPTS)
TESTPROG= $(srcdir)/Lib/test/regrtest.py
TESTPYTHON= $(RUNSHARED) ./$(BUILDPYTHON) -Wd -3 -E -tt $(TESTPYTHONOPTS)
-test: all platform
+test: @DEF_MAKE_RULE@ platform
-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
-$(TESTPYTHON) $(TESTPROG) $(TESTOPTS)
$(TESTPYTHON) $(TESTPROG) $(TESTOPTS)
-testall: all platform
+testall: @DEF_MAKE_RULE@ platform
-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
$(TESTPYTHON) $(srcdir)/Lib/compileall.py
-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
# Run the unitests for both architectures in a Universal build on OSX
# Must be run on an Intel box.
-testuniversal: all platform
+testuniversal: @DEF_MAKE_RULE@ platform
if [ `arch` != 'i386' ];then \
echo "This can only be used on OSX/i386" ;\
exit 1 ;\
-@if which pybuildbot.identify >/dev/null 2>&1; then \
pybuildbot.identify "CC='$(CC)'" "CXX='$(CXX)'"; \
fi
- $(TESTPYTHON) -R $(TESTPROG) -uall -rwW $(TESTOPTS)
+ $(TESTPYTHON) -R $(TESTPROG) -uall --slowest -rwW $(TESTOPTS)
+
+pythoninfo: build_all
+ $(RUNSHARED) ./$(BUILDPYTHON) -m test.pythoninfo
QUICKTESTOPTS= $(TESTOPTS) -x test_subprocess test_io test_lib2to3 \
test_multibytecodec test_urllib2_localnet test_itertools \
test_multiprocessing test_mailbox test_socket test_poll \
test_select test_zipfile
-quicktest: all platform
+quicktest: @DEF_MAKE_RULE@ platform
-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
-$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)
$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)
MEMTESTOPTS= $(QUICKTESTOPTS) -x test_dl test___all__ test_fork1 \
test_longexp
-memtest: all platform
+memtest: @DEF_MAKE_RULE@ platform
-rm -f $(srcdir)/Lib/test/*.py[co]
-$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)
$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)
test/data test/cjkencodings test/decimaltestdata test/xmltestdata \
test/imghdrdata \
test/subprocessdata \
+ test/support \
test/tracedmodules \
encodings compiler hotshot \
email email/mime email/test email/test/data \
# pkgconfig directory
LIBPC= $(LIBDIR)/pkgconfig
-libainstall: all python-config
+libainstall: @DEF_MAKE_RULE@ python-config
@for i in $(LIBDIR) $(LIBP) $(LIBPL) $(LIBPC); \
do \
if test ! -d $(DESTDIR)$$i; then \
$(SHELL) config.status --recheck
$(SHELL) config.status
-# Rebuild the configure script from configure.ac; also rebuild pyconfig.h.in
+# Regenerate configure and pyconfig.h.in
+.PHONY: autoconf
autoconf:
+ # Regenerate the configure script from configure.ac using autoconf
(cd $(srcdir); autoconf)
+ # Regenerate pyconfig.h.in from configure.ac using autoheader
(cd $(srcdir); autoheader)
# Create a tags file for vi
tags::
cd $(srcdir); \
- ctags -w -t Include/*.h; \
- for i in $(SRCDIRS); do ctags -w -t -a $$i/*.[ch]; \
+ ctags -w Include/*.h; \
+ for i in $(SRCDIRS); do ctags -f tags -w -a $$i/*.[ch]; \
done; \
- sort -o tags tags
+ LC_ALL=C sort -o tags tags
# Create a tags file for GNU Emacs
TAGS::
etags Include/*.h; \
for i in $(SRCDIRS); do etags -a $$i/*.[ch]; done
-# Touch generated files
-touch:
- cd $(srcdir); \
- touch Include/Python-ast.h Python/Python-ast.c
-
# Sanitation targets -- clean leaves libraries, executables and tags
# files, which clobber removes as well
pycremoval:
-exec rm -f {} ';'
# Check for smelly exported symbols (not starting with Py/_Py)
-smelly: all
+smelly: @DEF_MAKE_RULE@
nm -p $(LIBRARY) | \
sed -n "/ [TDB] /s/.* //p" | grep -v "^_*Py" | sort -u; \
.PHONY: maninstall libinstall inclinstall libainstall sharedinstall
.PHONY: frameworkinstall frameworkinstallframework frameworkinstallstructure
.PHONY: frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools
-.PHONY: frameworkaltinstallunixtools recheck autoconf clean clobber distclean
-.PHONY: smelly funny patchcheck touch altmaninstall commoninstall
+.PHONY: frameworkaltinstallunixtools recheck clean clobber distclean
+.PHONY: smelly funny patchcheck altmaninstall commoninstall
.PHONY: gdbhooks
# IF YOU PUT ANYTHING HERE IT WILL GO AWAY
Mark Anacker
Shashwat Anand
Anders Andersen
+Tycho Andersen
John Anderson
Pehr Anderson
Erik Andersén
Matias Bordese
Jonas Borgström
Jurjen Bos
+Jay Bosamiya
Peter Bosch
Dan Boswell
Eric Bouck
Tim Graham
Nathaniel Gray
Eddy De Greef
+Duane Griffin
Grant Griffin
Andrea Griffini
Duncan Grisby
Eric Groo
Dag Gruneau
Filip Gruszczyński
+Grzegorz Grzywacz
Thomas Guettler
Anuj Gupta
Michael Guravage
Brian Harring
Jonathan Hartley
Travis B. Hartwell
+Shane Harvey
Larry Hastings
Tim Hatch
Shane Hathaway
Lawrence Kesteloot
Vivek Khera
Dhiru Kholia
+Sanyam Khurana
Mads Kiilerich
Jason Killen
Jan Kim
Taek Joo Kim
Sam Kimbrel
+Tomohiko Kinebuchi
W. Trevor King
Paul Kippes
Steve Kirsch
Lenny Kneler
Pat Knight
Jeff Knupp
+Nicholas Kobald
Kubilay Kocak
Greg Kochanski
Manvisha Kodali
Pam McA'Nulty
Matt McClure
Rebecca McCreary
+Sean McCully
Kirk McDonald
Chris McDonough
Greg McFarlane
Max Neunhöffer
George Neville-Neil
Hieu Nguyen
+Nam Nguyen
Johannes Nicolai
Samuel Nicolary
Jonathan Niehof
Pascal Oberndoerfer
Jeffrey Ollie
Adam Olsen
+Bryan Olson
Grant Olson
Koray Oner
Piet van Oostrum
Douglas Orr
William Orr
Michele Orrù
+Tomáš Orsava
Oleg Oshmyan
Denis S. Otkidach
Peter Otten
Florent Xicluna
Alakshendra Yadav
Hirokazu Yamamoto
+Masayuki Yamamoto
Ka-Ping Yee
Jason Yeo
EungJun Yi
Jelle Zijlstra
Gennadiy Zlobin
Peter Ã…strand
+Dhushyanth Ramasamy
Python News
+++++++++++
+What's New in Python 2.7.14?
+============================
+
+*Release date: 2017-09-16*
+
+Extension Modules
+-----------------
+
+- bpo-31170: Update vendorized expat to 2.2.4.
+
+
+What's New in Python 2.7.14 release candidate 1?
+================================================
+
+*Release date: 2017-08-26*
+
+Core and Builtins
+-----------------
+
+- bpo-30657: Fixed possible integer overflow in PyString_DecodeEscape.
+ Patch by Jay Bosamiya.
+
+- bpo-27945: Fixed various segfaults with dict when input collections are
+ mutated during searching, inserting or comparing. Based on patches by
+ Duane Griffin and Tim Mitchell.
+
+- bpo-25794: Fixed type.__setattr__() and type.__delattr__() for
+ non-interned or unicode attribute names. Based on patch by Eryk Sun.
+
+- bpo-29935: Fixed error messages in the index() method of tuple and list
+ when pass indices of wrong type.
+
+- bpo-28598: Support __rmod__ for subclasses of str being called before
+ str.__mod__. Patch by Martijn Pieters.
+
+- bpo-29602: Fix incorrect handling of signed zeros in complex constructor for
+ complex subclasses and for inputs having a __complex__ method. Patch
+ by Serhiy Storchaka.
+
+- bpo-29347: Fixed possibly dereferencing undefined pointers
+ when creating weakref objects.
+
+- Issue #14376: Allow sys.exit to accept longs as well as ints. Patch
+ by Gareth Rees.
+
+- Issue #29028: Fixed possible use-after-free bugs in the subscription of the
+ buffer object with custom index object.
+
+- Issue #29145: Fix overflow checks in string, bytearray and unicode.
+ Patch by jan matejek and Xiang Zhang.
+
+- Issue #28932: Do not include <sys/random.h> if it does not exist.
+
+Extension Modules
+-----------------
+
+- Issue #29169: Update zlib to 1.2.11.
+
+Library
+-------
+
+- bpo-30746: Prohibited the '=' character in environment variable names in
+ ``os.putenv()`` and ``os.spawn*()``.
+
+- [Security] bpo-30730: Prevent environment variables injection in subprocess on
+ Windows. Prevent passing other environment variables and command arguments.
+
+- [Security] bpo-30694: Upgrade expat copy from 2.2.0 to 2.2.1 to get fixes
+ of multiple security vulnerabilities including: CVE-2017-9233 (External
+ entity infinite loop DoS), CVE-2016-9063 (Integer overflow, re-fix),
+ CVE-2016-0718 (Fix regression bugs from 2.2.0's fix to CVE-2016-0718)
+ and CVE-2012-0876 (Counter hash flooding with SipHash).
+ Note: the CVE-2016-5300 (Use os-specific entropy sources like getrandom)
+ doesn't impact Python, since Python already gets entropy from the OS to set
+ the expat secret using ``XML_SetHashSalt()``.
+
+- [Security] bpo-30500: Fix urllib.splithost() to correctly parse
+ fragments. For example, ``splithost('//127.0.0.1#@evil.com/')`` now
+ correctly returns the ``127.0.0.1`` host, instead of treating ``@evil.com``
+ as the host in an authentification (``login@host``).
+
+- [Security] bpo-29591: Update expat copy from 2.1.1 to 2.2.0 to get fixes
+ of CVE-2016-0718 and CVE-2016-4472. See
+ https://sourceforge.net/p/expat/bugs/537/ for more information.
+
+- bpo-28994: The traceback no longer displayed for SystemExit raised in
+ a callback registered by atexit.
+
+- bpo-30418: On Windows, subprocess.Popen.communicate() now also ignore EINVAL
+ on stdin.write() if the child process is still running but closed the pipe.
+
+- bpo-30378: Fix the problem that logging.handlers.SysLogHandler cannot
+ handle IPv6 addresses.
+
+- bpo-29960: Preserve generator state when _random.Random.setstate()
+ raises an exception. Patch by Bryan Olson.
+
+- bpo-30310: tkFont now supports unicode options (e.g. font family).
+
+- bpo-30414: multiprocessing.Queue._feed background running
+ thread do not break from main loop on exception.
+
+- bpo-30003: Fix handling escape characters in HZ codec. Based on patch
+ by Ma Lin.
+
+- bpo-30375: Warnings emitted when compile a regular expression now always
+ point to the line in the user code. Previously they could point into inners
+ of the re module if emitted from inside of groups or conditionals.
+
+- bpo-30363: Running Python with the -3 option now warns about regular
+ expression syntax that is invalid or has different semantic in Python 3
+ or will change the behavior in future Python versions.
+
+- bpo-30365: Running Python with the -3 option now emits deprecation warnings
+ for getchildren() and getiterator() methods of the Element class in the
+ xml.etree.cElementTree module and when pass the html argument to
+ xml.etree.ElementTree.XMLParser().
+
+- bpo-30365: Fixed a deprecation warning about the doctype() method of the
+ xml.etree.ElementTree.XMLParser class. Now it is emitted only when define
+ the doctype() method in the subclass of XMLParser.
+
+- bpo-30329: imaplib now catchs the Windows socket WSAEINVAL error
+ (code 10022) on shutdown(SHUT_RDWR): An invalid operation was attempted.
+ This error occurs sometimes on SSL connections.
+
+- bpo-30342: Fix sysconfig.is_python_build() if Python is built with Visual
+ Studio 2008 (VS 9.0).
+
+- bpo-29990: Fix range checking in GB18030 decoder. Original patch by Ma Lin.
+
+- bpo-30243: Removed the __init__ methods of _json's scanner and encoder.
+ Misusing them could cause memory leaks or crashes. Now scanner and encoder
+ objects are completely initialized in the __new__ methods.
+
+- Revert bpo-26293 for zipfile breakage. See also bpo-29094.
+
+- bpo-30070: Fixed leaks and crashes in errors handling in the parser module.
+
+- bpo-30061: Fixed crashes in IOBase methods next() and readlines() when
+ readline() or next() respectively return non-sizeable object.
+ Fixed possible other errors caused by not checking results of PyObject_Size(),
+ PySequence_Size(), or PyMapping_Size().
+
+- bpo-30011: Fixed race condition in HTMLParser.unescape().
+
+- bpo-30068: _io._IOBase.readlines will check if it's closed first when
+ hint is present.
+
+- bpo-27863: Fixed multiple crashes in ElementTree caused by race conditions
+ and wrong types.
+
+- bpo-29942: Fix a crash in itertools.chain.from_iterable when encountering
+ long runs of empty iterables.
+
+- bpo-29861: Release references to tasks, their arguments and their results
+ as soon as they are finished in multiprocessing.Pool.
+
+- bpo-27880: Fixed integer overflow in cPickle when pickle large strings or
+ too many objects.
+
+- bpo-29110: Fix file object leak in aifc.open() when file is given as a
+ filesystem path and is not in valid AIFF format.
+ Original patch by Anthony Zhang.
+
+- Issue #29354: Fixed inspect.getargs() for parameters which are cell
+ variables.
+
+- Issue #29335: Fix subprocess.Popen.wait() when the child process has
+ exited to a stopped instead of terminated state (ex: when under ptrace).
+
+- Issue #29219: Fixed infinite recursion in the repr of uninitialized
+ ctypes.CDLL instances.
+
+- Issue #29082: Fixed loading libraries in ctypes by unicode names on Windows.
+ Original patch by Chi Hsuan Yen.
+
+- Issue #29188: Support glibc 2.24 on Linux: don't use getentropy() function
+ but read from /dev/urandom to get random bytes, for example in os.urandom().
+ On Linux, getentropy() is implemented which getrandom() is blocking mode,
+ whereas os.urandom() should not block.
+
+- Issue #29142: In urllib, suffixes in no_proxy environment variable with
+ leading dots could match related hostnames again (e.g. .b.c matches a.b.c).
+ Patch by Milan Oberkirch.
+
+- Issue #13051: Fixed recursion errors in large or resized
+ curses.textpad.Textbox. Based on patch by Tycho Andersen.
+
+- Issue #9770: curses.ascii predicates now work correctly with negative
+ integers.
+
+- Issue #28427: old keys should not remove new values from
+ WeakValueDictionary when collecting from another thread.
+
+- Issue #28998: More APIs now support longs as well as ints.
+
+- Issue 28923: Remove editor artifacts from Tix.py,
+ including encoding not recognized by codecs.lookup.
+
+- Issue #29019: Fix dict.fromkeys(x) overallocates when x is sparce dict.
+ Original patch by Rasmus Villemoes.
+
+- Issue #19542: Fix bugs in WeakValueDictionary.setdefault() and
+ WeakValueDictionary.pop() when a GC collection happens in another
+ thread.
+
+- Issue #28925: cPickle now correctly propagates errors when unpickle instances
+ of old-style classes.
+
+Documentation
+-------------
+
+- bpo-30176: Add missing attribute related constants in curses documentation.
+
+- bpo-28929: Link the documentation to its source file on GitHub.
+
+- Issue #26355: Add canonical header link on each page to corresponding major
+ version of the documentation. Patch by Matthias Bussonnier.
+
+- Issue #12067: Rewrite Comparisons section in the Expressions chapter of the
+ language reference. Some of the details of comparing mixed types were
+ incorrect or ambiguous. Added default behaviour and consistency suggestions
+ for user-defined classes. Based on patch from Andy Maier.
+
+Build
+-----
+
+ bpo-29243: Prevent unnecessary rebuilding of Python during ``make test``,
+ ``make install`` and some other make targets when configured with
+ ``--enable-optimizations``.
+
+- bpo-23404: Don't regenerate generated files based on file modification time
+ anymore: the action is now explicit. Replace ``make touch`` with
+ ``make regen-all``.
+
+- bpo-27593: sys.version and the platform module python_build(),
+ python_branch(), and python_revision() functions now use
+ git information rather than hg when building from a repo.
+
+- bpo-29643: Fix ``--enable-optimization`` configure option didn't work.
+
+- bpo-29572: Update Windows build and OS X installers to use OpenSSL 1.0.2k.
+
+- Issue #28768: Fix implicit declaration of function _setmode. Patch by
+ Masayuki Yamamoto
+
+Tests
+-----
+
+- bpo-11790: Fix sporadic failures in
+ test_multiprocessing.WithProcessesTestCondition.
+
+- bpo-30236: Backported test.regrtest options -m/--match and -G/--failfast
+ from Python 3.
+
+- bpo-30223: To unify running tests in Python 2.7 and Python 3, the test
+ package can be run as a script. This is equivalent to running the
+ test.regrtest module as a script.
+
+- bpo-30207: To simplify backports from Python 3, the test.test_support
+ module was converted into a package and renamed to test.support. The
+ test.script_helper module was moved into the test.support package.
+ Names test.test_support and test.script_helper are left as aliases to
+ test.support and test.support.script_helper.
+
+- bpo-30197: Enhanced function swap_attr() in the test.test_support module.
+ It now works when delete replaced attribute inside the with statement. The
+ old value of the attribute (or None if it doesn't exist) now will be
+ assigned to the target of the "as" clause, if there is one.
+ Also backported function swap_item().
+
+- bpo-28087: Skip test_asyncore and test_eintr poll failures on macOS.
+ Skip some tests of select.poll when running on macOS due to unresolved
+ issues with the underlying system poll function on some macOS versions.
+
+- bpo-15083: Convert ElementTree doctests to unittests.
+
+
What's New in Python 2.7.13
===========================
Core and Builtins
-----------------
+- Issue #5322: Fixed setting __new__ to a PyCFunction inside Python code.
+ Original patch by Andreas Stührk.
+
- Issue #28847: dumbdbm no longer writes the index file in when it is not
changed and supports reading read-only files.
C API
-----
+- bpo-30255: PySlice_GetIndicesEx now clips the step to
+ [-PY_SSIZE_T_MAX, PY_SSIZE_T_MAX] instead of
+ [-PY_SSIZE_T_MAX-1, PY_SSIZE_T_MAX]. This makes it safe to do "step = -step"
+ when reversing a slice.
+
- Issue #26476: Fixed compilation error when use PyErr_BadInternalCall() in C++.
Patch by Jeroen Demeyer.
- Issue #24091: Fixed various crashes in corner cases in cElementTree.
-- Issue #15267: HTTPConnection.request() now is compatibile with old-style
+- Issue #15267: HTTPConnection.request() now is compatible with old-style
classes (such as TemporaryFile). Original patch by Atsuo Ishimoto.
- Issue #20014: array.array() now accepts unicode typecodes. Based on patch by
Vajrasky Kok.
-- Issue #23637: Showing a warning no longer fails with UnicodeErrror.
+- Issue #23637: Showing a warning no longer fails with UnicodeError.
Formatting unicode warning in the file with the path containing non-ascii
- characters no longer fails with UnicodeErrror.
+ characters no longer fails with UnicodeError.
- Issue #24134: Reverted issue #24134 changes.
sequence is used on some terminal (ex: TERM=xterm-256color") to enable
support of 8 bit characters.
-- Issue #22017: Correct reference counting errror in the initialization of the
+- Issue #22017: Correct reference counting error in the initialization of the
_warnings module.
- Issue #21868: Prevent turtle crash when undo buffer set to a value less
- Issue #11973: Fix a problem in kevent. The flags and fflags fields are now
properly handled as unsigned.
-- Issue #16809: Fixed some tkinter incompabilities with Tcl/Tk 8.6.
+- Issue #16809: Fixed some tkinter incompatibilities with Tcl/Tk 8.6.
- Issue #16809: Tkinter's splitlist() and split() methods now accept Tcl_Obj
argument.
Tests
-----
+- bpo-30357: test_thread: setUp() now uses support.threading_setup() and
+ support.threading_cleanup() to wait until threads complete to avoid
+ random side effects on following tests. Initial patch written by Grzegorz
+ Grzywacz.
- Refactor test_logging to use unittest.
----
**(For information about older versions, consult the HISTORY file.)**
-
--- /dev/null
+.. bpo: 30947
+.. date: 2017-08-16-16-35-59
+.. nonce: iNMmm4
+.. release date: 2017-08-26
+.. section: Security
+
+Upgrade libexpat embedded copy from version 2.2.1 to 2.2.3 to get security
+fixes.
+
+..
+
+.. bpo: 30765
+.. date: 2017-06-26-14-29-50
+.. nonce: Q5iBmf
+.. section: Core and Builtins
+
+Avoid blocking in pthread_mutex_lock() when PyThread_acquire_lock() is asked
+not to block.
+
+..
+
+.. bpo: 31135
+.. date: 2017-08-08-14-59-26
+.. nonce: 9q1QdB
+.. section: Library
+
+ttk: Fix LabeledScale and OptionMenu destroy() method. Call the parent
+destroy() method even if the used attribute doesn't exist. The
+LabeledScale.destroy() method now also explicitly clears label and scale
+attributes to help the garbage collector to destroy all widgets.
+
+..
+
+.. bpo: 31107
+.. date: 2017-08-02-12-48-15
+.. nonce: 1t2hn5
+.. section: Library
+
+Fix `copy_reg._slotnames()` mangled attribute calculation for classes whose
+name begins with an underscore. Patch by Shane Harvey.
+
+..
+
+.. bpo: 29519
+.. date: 2017-07-31-19-32-57
+.. nonce: _j1awg
+.. section: Library
+
+Fix weakref spewing exceptions during interpreter shutdown when used with a
+rare combination of multiprocessing and custom codecs.
+
+..
+
+.. bpo: 30119
+.. date: 2017-07-26-22-02-07
+.. nonce: DZ6C_S
+.. section: Library
+
+ftplib.FTP.putline() now throws ValueError on commands that contains CR or
+LF. Patch by Dong-hee Na.
+
+..
+
+.. bpo: 30595
+.. date: 2017-07-26-04-46-12
+.. nonce: -zJ7d8
+.. section: Library
+
+multiprocessing.Queue.get() with a timeout now polls its reader in non-
+blocking mode if it succeeded to aquire the lock but the acquire took longer
+than the timeout.
+
+..
+
+.. bpo: 29902
+.. date: 2017-07-23-13-47-22
+.. nonce: CiuFdn
+.. section: Library
+
+Py3k deprecation warning now is emitted when pickling or copying some
+builtin and extension objects that don't support pickling explicitly and are
+pickled incorrectly by default (like memoryview or staticmethod). This is a
+TypeError in Python 3.6.
+
+..
+
+.. bpo: 29854
+.. date: 2017-07-07-02-18-57
+.. nonce: J8wKb_
+.. section: Library
+
+Fix segfault in readline when using readline's history-size option. Patch
+by Nir Soffer.
+
+..
+
+.. bpo: 30807
+.. date: 2017-06-29-22-04-44
+.. nonce: sLtjY-
+.. section: Library
+
+signal.setitimer() may disable the timer when passed a tiny value.
+
+Tiny values (such as 1e-6) are valid non-zero values for setitimer(), which
+is specified as taking microsecond-resolution intervals. However, on some
+platform, our conversion routine could convert 1e-6 into a zero interval,
+therefore disabling the timer instead of (re-)scheduling it.
+
+..
+
+.. bpo: 30715
+.. date: 2017-07-25-15-27-44
+.. nonce: Sp7bTF
+.. section: Tests
+
+Address ALPN callback changes for OpenSSL 1.1.0f. The latest version behaves
+like OpenSSL 1.0.2 and no longer aborts handshake.
+
+..
+
+.. bpo: 30822
+.. date: 2017-07-20-14-29-54
+.. nonce: X0wREo
+.. section: Tests
+
+Fix regrtest command line parser to allow passing -u extralargefile to run
+test_zipfile64.
+
+..
+
+.. bpo: 30283
+.. date: 2017-06-26-11-24-14
+.. nonce: qCQmlm
+.. section: Tests
+
+regrtest: Enhance regrtest and backport features from the master branch.
+
+Add options: --coverage, --testdir, --list-tests (list test files, don't run
+them), --list-cases (list test identifiers, don't run them, :issue:`30523`),
+--matchfile (load a list of test filters from a text file, :issue:`30540`),
+--slowest (alias to --slow).
+
+Enhance output: add timestamp, test result, currently running tests, "Tests
+result: xxx" summary with total duration, etc.
+
+Fix reference leak hunting in regrtest, --huntrleaks: regrtest now warms up
+caches, create explicitly all internal singletons which are created on
+demand to prevent false positives when checking for reference leaks.
+(:issue:`30675`).
--- /dev/null
+Put news entry ``blurb`` files for the *Build* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *C API* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *Core and Builtins* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *Documentation* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *IDLE* section in this directory.
--- /dev/null
+expat: Update libexpat from 2.2.3 to 2.2.4. Fix copying of partial
+characters for UTF-8 input (libexpat bug 115):
+https://github.com/libexpat/libexpat/issues/115
--- /dev/null
+Put news entry ``blurb`` files for the *Library* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *Security* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *Tests* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *Tools/Demos* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *Windows* section in this directory.
--- /dev/null
+Put news entry ``blurb`` files for the *macOS* section in this directory.
self->sibling_prev_p_txn=NULL;
self->sibling_next_txn=NULL;
- if (self->myenvobj)
+ if (self->myenvobj) {
self->moduleFlags = self->myenvobj->moduleFlags;
- else
+ }
+ else {
self->moduleFlags.getReturnsNone = DEFAULT_GET_RETURNS_NONE;
self->moduleFlags.cursorSetReturnsNone = DEFAULT_CURSOR_SET_RETURNS_NONE;
+ }
MYDB_BEGIN_ALLOW_THREADS;
err = db_create(&self->db, db_env, flags);
static int
_set_int(const char *name, int *target, PyObject *src, int dflt)
{
+ int value;
if (src == NULL)
*target = dflt;
else {
- if (!PyInt_Check(src)) {
+ if (!PyInt_Check(src) && !PyLong_Check(src)) {
PyErr_Format(PyExc_TypeError,
"\"%s\" must be an integer", name);
return -1;
}
- *target = PyInt_AsLong(src);
+ value = PyInt_AsLong(src);
+ if (value == -1 && PyErr_Occurred())
+ return -1;
+ *target = value;
}
return 0;
}
csv_field_size_limit(PyObject *module, PyObject *args)
{
PyObject *new_limit = NULL;
- long old_limit = field_limit;
+ long old_limit = field_limit, limit;
if (!PyArg_UnpackTuple(args, "field_size_limit", 0, 1, &new_limit))
return NULL;
if (new_limit != NULL) {
- if (!PyInt_Check(new_limit)) {
+ if (!PyInt_Check(new_limit) && !PyLong_Check(new_limit)) {
PyErr_Format(PyExc_TypeError,
"limit must be an integer");
return NULL;
}
- field_limit = PyInt_AsLong(new_limit);
+ limit = PyInt_AsLong(new_limit);
+ if (limit == -1 && PyErr_Occurred())
+ return NULL;
+ field_limit = limit;
}
return PyInt_FromLong(old_limit);
}
PyObject *np;
Py_ssize_t start, stop, step, slicelen, cur, i;
- if (PySlice_GetIndicesEx((PySliceObject *)item,
- self->b_length, &start, &stop,
- &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
assert(itemdict); /* proto is the item type of the array, a
ctypes type, so this cannot be NULL */
+ slicelen = _PySlice_AdjustIndices(self->b_length, &start, &stop, step);
if (itemdict->getfunc == _ctypes_get_fielddesc("c")->getfunc) {
char *ptr = (char *)self->b_ptr;
char *dest;
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen, otherlen, i, cur;
- if (PySlice_GetIndicesEx((PySliceObject *)item,
- self->b_length, &start, &stop,
- &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return -1;
}
+ slicelen = _PySlice_AdjustIndices(self->b_length, &start, &stop, step);
if ((step < 0 && start < stop) ||
(step > 0 && start > stop))
stop = start;
PyObject *nameobj;
PyObject *ignored;
HMODULE hMod;
- if (!PyArg_ParseTuple(args, "S|O:LoadLibrary", &nameobj, &ignored))
+ if (!PyArg_ParseTuple(args, "O|O:LoadLibrary", &nameobj, &ignored))
return NULL;
#ifdef _UNICODE
name = alloca((PyString_Size(nameobj) + 1) * sizeof(WCHAR));
static int
PyCurses_ConvertToChtype(PyObject *obj, chtype *ch)
{
- if (PyInt_Check(obj)) {
+ if (PyInt_Check(obj) || PyLong_Check(obj)) {
*ch = (chtype) PyInt_AsLong(obj);
+ if (*ch == (chtype) -1 && PyErr_Occurred())
+ return 0;
} else if(PyString_Check(obj)
&& (PyString_Size(obj) == 1)) {
*ch = (chtype) *PyString_AsString(obj);
if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
- if (PyInt_Check(temp))
+ if (PyInt_Check(temp) || PyLong_Check(temp)) {
ch = (chtype) PyInt_AsLong(temp);
+ if (ch == (chtype) -1 && PyErr_Occurred())
+ return NULL;
+ }
else if (PyString_Check(temp))
ch = (chtype) *PyString_AsString(temp);
else {
if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;
- if (PyInt_Check(temp))
+ if (PyInt_Check(temp) || PyLong_Check(temp)) {
ch = (int) PyInt_AsLong(temp);
+ if (ch == -1 && PyErr_Occurred())
+ return NULL;
+ }
else if (PyString_Check(temp))
ch = (int) *PyString_AsString(temp);
else {
LOCAL(PyObject*)
list_join(PyObject* list)
{
- /* join list elements (destroying the list in the process) */
-
+ /* join list elements */
PyObject* joiner;
PyObject* function;
PyObject* args;
switch (PyList_GET_SIZE(list)) {
case 0:
- Py_DECREF(list);
return PyString_FromString("");
case 1:
result = PyList_GET_ITEM(list, 0);
Py_INCREF(result);
- Py_DECREF(list);
return result;
}
}
args = PyTuple_New(1);
- if (!args)
+ if (!args) {
+ Py_DECREF(function);
+ Py_DECREF(joiner);
return NULL;
+ }
+ Py_INCREF(list);
PyTuple_SET_ITEM(args, 0, list);
result = PyObject_CallObject(function, args);
{
/* return borrowed reference to text attribute */
- PyObject* res = self->text;
+ PyObject *res = self->text;
if (JOIN_GET(res)) {
res = JOIN_OBJ(res);
if (PyList_CheckExact(res)) {
- res = list_join(res);
- if (!res)
+ PyObject *tmp = list_join(res);
+ if (!tmp)
return NULL;
- self->text = res;
+ self->text = tmp;
+ Py_DECREF(res);
+ res = tmp;
}
}
{
/* return borrowed reference to text attribute */
- PyObject* res = self->tail;
+ PyObject *res = self->tail;
if (JOIN_GET(res)) {
res = JOIN_OBJ(res);
if (PyList_CheckExact(res)) {
- res = list_join(res);
- if (!res)
+ PyObject *tmp = list_join(res);
+ if (!tmp)
return NULL;
- self->tail = res;
+ self->tail = tmp;
+ Py_DECREF(res);
+ res = tmp;
}
}
}
elem = element_new(tag, attrib);
-
Py_DECREF(attrib);
+ if (elem == NULL)
+ return NULL;
if (element_add_subelement(parent, elem) < 0) {
Py_DECREF(elem);
int i;
PyObject* list;
- /* FIXME: report as deprecated? */
+ if (PyErr_WarnPy3k("This method will be removed in future versions. "
+ "Use 'list(elem)' or iteration over elem instead.",
+ 1) < 0) {
+ return NULL;
+ }
if (!PyArg_ParseTuple(args, ":getchildren"))
return NULL;
}
static PyObject*
-element_iter(ElementObject* self, PyObject* args)
+element_iter_impl(ElementObject* self, PyObject* tag)
{
+ PyObject* args;
PyObject* result;
-
- PyObject* tag = Py_None;
- if (!PyArg_ParseTuple(args, "|O:iter", &tag))
- return NULL;
if (!elementtree_iter_obj) {
PyErr_SetString(
return result;
}
+static PyObject*
+element_iter(ElementObject* self, PyObject* args)
+{
+ PyObject* tag = Py_None;
+ if (!PyArg_ParseTuple(args, "|O:iter", &tag))
+ return NULL;
+
+ return element_iter_impl(self, tag);
+}
+
+static PyObject*
+element_getiterator(ElementObject* self, PyObject* args)
+{
+ PyObject* tag = Py_None;
+ if (!PyArg_ParseTuple(args, "|O:getiterator", &tag))
+ return NULL;
+
+ /* Change for a DeprecationWarning in 1.4 */
+ if (Py_Py3kWarningFlag &&
+ PyErr_WarnEx(PyExc_PendingDeprecationWarning,
+ "This method will be removed in future versions. "
+ "Use 'tree.iter()' or 'list(tree.iter())' instead.",
+ 1) < 0) {
+ return NULL;
+ }
+ return element_iter_impl(self, tag);
+}
+
static PyObject*
element_itertext(ElementObject* self, PyObject* args)
if (status == 0) {
PyObject *repr, *tag;
tag = PyObject_Repr(self->tag);
- if (!tag)
+ if (!tag) {
+ Py_ReprLeave((PyObject *)self);
return NULL;
+ }
repr = PyString_FromFormat("<Element %s at %p>",
PyString_AS_STRING(tag), self);
if (!self->extra)
return PyList_New(0);
- if (PySlice_GetIndicesEx((PySliceObject *)item,
- self->extra->length,
- &start, &stop, &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelen = _PySlice_AdjustIndices(self->extra->length, &start, &stop,
+ step);
if (slicelen <= 0)
return PyList_New(0);
if (!self->extra)
element_new_extra(self, NULL);
- if (PySlice_GetIndicesEx((PySliceObject *)item,
- self->extra->length,
- &start, &stop, &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return -1;
}
+ slicelen = _PySlice_AdjustIndices(self->extra->length, &start, &stop,
+ step);
assert(slicelen <= self->extra->length);
if (value == NULL)
{"itertext", (PyCFunction) element_itertext, METH_VARARGS},
{"iterfind", (PyCFunction) element_iterfind, METH_VARARGS},
- {"getiterator", (PyCFunction) element_iter, METH_VARARGS},
+ {"getiterator", (PyCFunction) element_getiterator, METH_VARARGS},
{"getchildren", (PyCFunction) element_getchildren, METH_VARARGS},
{"items", (PyCFunction) element_items, METH_VARARGS},
return res;
} else if (strcmp(name, "text") == 0) {
res = element_get_text(self);
- Py_INCREF(res);
+ Py_XINCREF(res);
return res;
}
PyObject_Del(self);
}
+/* -------------------------------------------------------------------- */
+/* helpers for handling of arbitrary element-like objects */
+
+static void
+treebuilder_set_element_text_or_tail(PyObject **data, PyObject **dest)
+{
+ PyObject *tmp = JOIN_OBJ(*dest);
+ *dest = JOIN_SET(*data, PyList_CheckExact(*data));
+ *data = NULL;
+ Py_DECREF(tmp);
+}
+
+LOCAL(void)
+treebuilder_flush_data(TreeBuilderObject* self)
+{
+ ElementObject *element = self->last;
+
+ if (self->data) {
+ if (self->this == element) {
+ treebuilder_set_element_text_or_tail(
+ &self->data,
+ &element->text);
+ }
+ else {
+ treebuilder_set_element_text_or_tail(
+ &self->data,
+ &element->tail);
+ }
+ }
+}
+
LOCAL(int)
treebuilder_append_event(TreeBuilderObject *self, PyObject *action,
PyObject *node)
PyObject* node;
PyObject* this;
- if (self->data) {
- if (self->this == self->last) {
- Py_DECREF(JOIN_OBJ(self->last->text));
- self->last->text = JOIN_SET(
- self->data, PyList_CheckExact(self->data)
- );
- } else {
- Py_DECREF(JOIN_OBJ(self->last->tail));
- self->last->tail = JOIN_SET(
- self->data, PyList_CheckExact(self->data)
- );
- }
- self->data = NULL;
- }
+ treebuilder_flush_data(self);
node = element_new(tag, attrib);
if (!node)
{
ElementObject *item;
- if (self->data) {
- if (self->this == self->last) {
- Py_DECREF(JOIN_OBJ(self->last->text));
- self->last->text = JOIN_SET(
- self->data, PyList_CheckExact(self->data)
- );
- } else {
- Py_DECREF(JOIN_OBJ(self->last->tail));
- self->last->tail = JOIN_SET(
- self->data, PyList_CheckExact(self->data)
- );
- }
- self->data = NULL;
- }
+ treebuilder_flush_data(self);
if (self->index == 0) {
PyErr_SetString(
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
/*
An implementation of the I/O abstract base classes hierarchy
as defined by PEP 3116 - "New I/O"
-
+
Classes defined here: IOBase, RawIOBase.
-
+
Written by Amaury Forgeot d'Arc and Antoine Pitrou
*/
typedef struct {
PyObject_HEAD
-
+
PyObject *dict;
PyObject *weakreflist;
} iobase;
if (line == NULL)
return NULL;
- if (PyObject_Size(line) == 0) {
+ if (PyObject_Size(line) <= 0) {
+ /* Error or empty */
Py_DECREF(line);
return NULL;
}
iobase_readlines(PyObject *self, PyObject *args)
{
Py_ssize_t hint = -1, length = 0;
- PyObject *result;
+ PyObject *result, *it = NULL;
if (!PyArg_ParseTuple(args, "|O&:readlines", &_PyIO_ConvertSsize_t, &hint)) {
return NULL;
probably be removed here. */
PyObject *ret = PyObject_CallMethod(result, "extend", "O", self);
if (ret == NULL) {
- Py_DECREF(result);
- return NULL;
+ goto error;
}
Py_DECREF(ret);
return result;
}
+ it = PyObject_GetIter(self);
+ if (it == NULL) {
+ goto error;
+ }
+
while (1) {
- PyObject *line = PyIter_Next(self);
+ Py_ssize_t line_length;
+ PyObject *line = PyIter_Next(it);
if (line == NULL) {
if (PyErr_Occurred()) {
- Py_DECREF(result);
- return NULL;
+ goto error;
}
else
break; /* StopIteration raised */
if (PyList_Append(result, line) < 0) {
Py_DECREF(line);
- Py_DECREF(result);
- return NULL;
+ goto error;
}
- length += PyObject_Size(line);
+ line_length = PyObject_Size(line);
Py_DECREF(line);
-
- if (length > hint)
+ if (line_length < 0) {
+ goto error;
+ }
+ if (line_length > hint - length)
break;
+ length += line_length;
}
+
+ Py_DECREF(it);
return result;
+
+ error:
+ Py_XDECREF(it);
+ Py_DECREF(result);
+ return NULL;
}
static PyObject *
int r;
PyObject *chunks = PyList_New(0);
PyObject *result;
-
+
if (chunks == NULL)
return NULL;
errors);
if (self->encoder == NULL)
goto error;
- /* Get the normalized named of the codec */
+ /* Get the normalized name of the codec */
res = PyObject_GetAttrString(codec_info, "name");
if (res == NULL) {
if (PyErr_ExceptionMatches(PyExc_AttributeError))
_build_rval_index_tuple(PyObject *rval, Py_ssize_t idx);
static PyObject *
scanner_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
-static int
-scanner_init(PyObject *self, PyObject *args, PyObject *kwds);
static void
scanner_dealloc(PyObject *self);
static int
scanner_clear(PyObject *self);
static PyObject *
encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
-static int
-encoder_init(PyObject *self, PyObject *args, PyObject *kwds);
static void
encoder_dealloc(PyObject *self);
static int
scanner_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyScannerObject *s;
- s = (PyScannerObject *)type->tp_alloc(type, 0);
- if (s != NULL) {
- s->encoding = NULL;
- s->strict = NULL;
- s->object_hook = NULL;
- s->pairs_hook = NULL;
- s->parse_float = NULL;
- s->parse_int = NULL;
- s->parse_constant = NULL;
- }
- return (PyObject *)s;
-}
-
-static int
-scanner_init(PyObject *self, PyObject *args, PyObject *kwds)
-{
- /* Initialize Scanner object */
PyObject *ctx;
static char *kwlist[] = {"context", NULL};
- PyScannerObject *s;
-
- assert(PyScanner_Check(self));
- s = (PyScannerObject *)self;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:make_scanner", kwlist, &ctx))
- return -1;
+ return NULL;
+
+ s = (PyScannerObject *)type->tp_alloc(type, 0);
+ if (s == NULL)
+ return NULL;
/* PyString_AS_STRING is used on encoding */
s->encoding = PyObject_GetAttrString(ctx, "encoding");
if (s->parse_constant == NULL)
goto bail;
- return 0;
+ return (PyObject *)s;
bail:
- Py_CLEAR(s->encoding);
- Py_CLEAR(s->strict);
- Py_CLEAR(s->object_hook);
- Py_CLEAR(s->pairs_hook);
- Py_CLEAR(s->parse_float);
- Py_CLEAR(s->parse_int);
- Py_CLEAR(s->parse_constant);
- return -1;
+ Py_DECREF(s);
+ return NULL;
}
PyDoc_STRVAR(scanner_doc, "JSON scanner object");
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
- scanner_init, /* tp_init */
+ 0, /* tp_init */
0,/* PyType_GenericAlloc, */ /* tp_alloc */
scanner_new, /* tp_new */
0,/* PyObject_GC_Del, */ /* tp_free */
static PyObject *
encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyEncoderObject *s;
- s = (PyEncoderObject *)type->tp_alloc(type, 0);
- if (s != NULL) {
- s->markers = NULL;
- s->defaultfn = NULL;
- s->encoder = NULL;
- s->indent = NULL;
- s->key_separator = NULL;
- s->item_separator = NULL;
- s->sort_keys = NULL;
- s->skipkeys = NULL;
- }
- return (PyObject *)s;
-}
-
-static int
-encoder_init(PyObject *self, PyObject *args, PyObject *kwds)
-{
- /* initialize Encoder object */
static char *kwlist[] = {"markers", "default", "encoder", "indent", "key_separator", "item_separator", "sort_keys", "skipkeys", "allow_nan", NULL};
PyEncoderObject *s;
PyObject *item_separator, *sort_keys, *skipkeys, *allow_nan_obj;
int allow_nan;
- assert(PyEncoder_Check(self));
- s = (PyEncoderObject *)self;
-
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOOOOOOO:make_encoder", kwlist,
&markers, &defaultfn, &encoder, &indent, &key_separator, &item_separator,
&sort_keys, &skipkeys, &allow_nan_obj))
- return -1;
+ return NULL;
allow_nan = PyObject_IsTrue(allow_nan_obj);
if (allow_nan < 0)
- return -1;
+ return NULL;
if (markers != Py_None && !PyDict_Check(markers)) {
PyErr_Format(PyExc_TypeError,
"make_encoder() argument 1 must be dict or None, "
"not %.200s", Py_TYPE(markers)->tp_name);
- return -1;
+ return NULL;
}
+ s = (PyEncoderObject *)type->tp_alloc(type, 0);
+ if (s == NULL)
+ return NULL;
+
s->markers = markers;
s->defaultfn = defaultfn;
s->encoder = encoder;
Py_INCREF(s->item_separator);
Py_INCREF(s->sort_keys);
Py_INCREF(s->skipkeys);
- return 0;
+ return (PyObject *)s;
}
static PyObject *
return -1;
}
- if (Py_EnterRecursiveCall(" while encoding a JSON object"))
+ if (Py_EnterRecursiveCall(" while encoding a JSON object")) {
+ Py_DECREF(newobj);
+ Py_XDECREF(ident);
return -1;
+ }
rv = encoder_listencode_obj(s, rval, newobj, indent_level);
Py_LeaveRecursiveCall();
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
- encoder_init, /* tp_init */
+ 0, /* tp_init */
0, /* tp_alloc */
encoder_new, /* tp_new */
0, /* tp_free */
init_json(void)
{
PyObject *m;
- PyScannerType.tp_new = PyType_GenericNew;
if (PyType_Ready(&PyScannerType) < 0)
return;
- PyEncoderType.tp_new = PyType_GenericNew;
if (PyType_Ready(&PyEncoderType) < 0)
return;
m = Py_InitModule3("_json", speedups_methods, module_doc);
/* ------------------------------------------------------------------
The code in this module was based on a download from:
- http://www.math.keio.ac.jp/~matumoto/MT2002/emt19937ar.html
+ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html
It was modified in 2002 by Raymond Hettinger as follows:
Any feedback is very welcome.
- http://www.math.keio.ac.jp/matumoto/emt.html
- email: matumoto@math.keio.ac.jp
+ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
*/
/* ---------------------------------------------------------------*/
int i;
unsigned long element;
long index;
+ unsigned long new_state[N];
if (!PyTuple_Check(state)) {
PyErr_SetString(PyExc_TypeError,
element = PyLong_AsUnsignedLong(PyTuple_GET_ITEM(state, i));
if (element == (unsigned long)-1 && PyErr_Occurred())
return NULL;
- self->state[i] = element & 0xffffffffUL; /* Make sure we get sane state */
+ new_state[i] = element & 0xffffffffUL; /* Make sure we get sane state */
}
index = PyLong_AsLong(PyTuple_GET_ITEM(state, i));
return NULL;
}
self->index = (int)index;
+ for (i = 0; i < N; i++)
+ self->state[i] = new_state[i];
Py_INCREF(Py_None);
return Py_None;
if (!string)
return NULL;
+ if (Py_Py3kWarningFlag &&
+ (self->code[0] != SRE_OP_INFO || self->code[3] == 0))
+ {
+ if (self->code[0] == SRE_OP_INFO && self->code[4] == 0) {
+ if (PyErr_WarnPy3k("split() requires a non-empty pattern match.",
+ 1) < 0)
+ return NULL;
+ }
+ else if (PyErr_WarnEx(PyExc_FutureWarning,
+ "split() requires a non-empty pattern match.",
+ 1) < 0)
+ return NULL;
+ }
+
string = state_init(&state, self, string, 0, PY_SSIZE_T_MAX);
if (!string)
return NULL;
int i, j;
PyObject *lst, *res = NULL;
-#if OPENSSL_VERSION_NUMBER >= 0x10001000L
- /* Calls x509v3_cache_extensions and sets up crldp */
- X509_check_ca(certificate);
-#endif
dps = X509_get_ext_d2i(certificate, NID_crl_distribution_points, NULL, NULL);
if (dps == NULL)
done:
Py_XDECREF(lst);
-#if OPENSSL_VERSION_NUMBER < 0x10001000L
- sk_DIST_POINT_free(dps);
-#endif
+ CRL_DIST_POINTS_free(dps);
return res;
}
options |= SSL_OP_NO_SSLv3;
SSL_CTX_set_options(self->ctx, options);
-#ifndef OPENSSL_NO_ECDH
+#if !defined(OPENSSL_NO_ECDH) && !defined(OPENSSL_VERSION_1_1)
/* Allow automatic ECDH curve selection (on OpenSSL 1.0.2+), or use
prime256v1 by default. This is Apache mod_ssl's initialization
policy, so we should be safe. OpenSSL 1.1 has it enabled by default.
*/
-#if defined(SSL_CTX_set_ecdh_auto) && !defined(OPENSSL_VERSION_1_1)
+#if defined(SSL_CTX_set_ecdh_auto)
SSL_CTX_set_ecdh_auto(self->ctx, 1);
#else
{
"ubyte format requires 0 <= number <= 255");
return -1;
}
- *p = (char)x;
+ *(unsigned char *)p = (unsigned char)x;
return 0;
}
{
long x;
Py_ssize_t i;
+ unsigned char *q = (unsigned char *)p;
if (get_long(v, &x) < 0)
return -1;
i = f->size;
#endif
}
do {
- p[--i] = (char)x;
+ q[--i] = (unsigned char)(x & 0xffL);
x >>= 8;
} while (i > 0);
return 0;
{
unsigned long x;
Py_ssize_t i;
+ unsigned char *q = (unsigned char *)p;
if (get_ulong(v, &x) < 0)
return -1;
i = f->size;
return _range_error(f, 1);
}
do {
- p[--i] = (char)x;
+ q[--i] = (unsigned char)(x & 0xffUL);
x >>= 8;
} while (i > 0);
return 0;
{
long x;
Py_ssize_t i;
+ unsigned char *q = (unsigned char *)p;
if (get_long(v, &x) < 0)
return -1;
i = f->size;
#endif
}
do {
- *p++ = (char)x;
+ *q++ = (unsigned char)(x & 0xffL);
x >>= 8;
} while (--i > 0);
return 0;
{
unsigned long x;
Py_ssize_t i;
+ unsigned char *q = (unsigned char *)p;
if (get_ulong(v, &x) < 0)
return -1;
i = f->size;
return _range_error(f, 1);
}
do {
- *p++ = (char)x;
+ *q++ = (unsigned char)(x & 0xffUL);
x >>= 8;
} while (--i > 0);
return 0;
#include "structmember.h"
#include "datetime.h"
#include "marshal.h"
+#include <signal.h>
+#ifdef MS_WINDOWS
+# include <crtdbg.h>
+#endif
+
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h> /* For W_STOPCODE */
+#endif
#ifdef WITH_THREAD
#include "pythread.h"
Py_RETURN_NONE;
}
-#ifdef Py_USING_UNICODE
+#if defined(Py_USING_UNICODE) && !defined(Py_BUILD_CORE)
static int test_run_counter = 0;
static PyObject *
return Py_BuildValue("Nl", obj, pos);
}
+static PyObject*
+test_raise_signal(PyObject* self, PyObject *args)
+{
+ int signum, err;
+
+ if (PyArg_ParseTuple(args, "i:raise_signal", &signum) < 0)
+ return NULL;
+
+ err = raise(signum);
+ if (err)
+ return PyErr_SetFromErrno(PyExc_OSError);
+
+ if (PyErr_CheckSignals() < 0)
+ return NULL;
+
+ Py_RETURN_NONE;
+}
+
+
+#ifdef MS_WINDOWS
+static PyObject*
+msvcrt_CrtSetReportMode(PyObject* self, PyObject *args)
+{
+ int type, mode;
+ int res;
+
+ if (!PyArg_ParseTuple(args, "ii:CrtSetReportMode", &type, &mode)) {
+ return NULL;
+ }
+
+ res = _CrtSetReportMode(type, mode);
+ if (res == -1) {
+ PyErr_SetFromErrno(PyExc_OSError);
+ return NULL;
+ }
+ return PyInt_FromLong(res);
+}
+
+
+static PyObject*
+msvcrt_CrtSetReportFile(PyObject* self, PyObject *args)
+{
+ int type, file;
+ long res;
+
+ if (!PyArg_ParseTuple(args, "ii:CrtSetReportFile", &type, &file)) {
+ return NULL;
+ }
+
+ res = (long)_CrtSetReportFile(type, (_HFILE)file);
+
+ return PyInt_FromLong(res);
+}
+#endif
+
+
+#ifdef W_STOPCODE
+static PyObject*
+py_w_stopcode(PyObject *self, PyObject *args)
+{
+ int sig, status;
+ if (!PyArg_ParseTuple(args, "i", &sig)) {
+ return NULL;
+ }
+ status = W_STOPCODE(sig);
+ return PyLong_FromLong(status);
+}
+#endif
+
static PyMethodDef TestMethods[] = {
{"raise_exception", raise_exception, METH_VARARGS},
{"set_errno", set_errno, METH_VARARGS},
{"test_config", (PyCFunction)test_config, METH_NOARGS},
-#ifdef Py_USING_UNICODE
+#if defined(Py_USING_UNICODE) && !defined(Py_BUILD_CORE)
{"test_datetime_capi", test_datetime_capi, METH_NOARGS},
#endif
{"test_list_api", (PyCFunction)test_list_api, METH_NOARGS},
pymarshal_read_last_object_from_file, METH_VARARGS},
{"pymarshal_read_object_from_file",
pymarshal_read_object_from_file, METH_VARARGS},
+ {"raise_signal", (PyCFunction)test_raise_signal, METH_VARARGS},
+#ifdef MS_WINDOWS
+ {"CrtSetReportMode", (PyCFunction)msvcrt_CrtSetReportMode, METH_VARARGS},
+ {"CrtSetReportFile", (PyCFunction)msvcrt_CrtSetReportFile, METH_VARARGS},
+#endif
+#ifdef W_STOPCODE
+ {"W_STOPCODE", py_w_stopcode, METH_VARARGS},
+#endif
{NULL, NULL} /* sentinel */
};
PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyInt_FromSsize_t(PY_SSIZE_T_MIN));
PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyInt_FromSsize_t(sizeof(PyGC_Head)));
+#ifdef MS_WINDOWS
+ PyModule_AddIntConstant(m, "CRT_WARN", _CRT_WARN);
+ PyModule_AddIntConstant(m, "CRT_ERROR", _CRT_ERROR);
+ PyModule_AddIntConstant(m, "CRT_ASSERT", _CRT_ASSERT);
+ PyModule_AddIntConstant(m, "CRTDBG_MODE_FILE", _CRTDBG_MODE_FILE);
+ PyModule_AddIntConstant(m, "CRTDBG_FILE_STDERR", (int)_CRTDBG_FILE_STDERR);
+#endif
+
TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
Py_INCREF(TestError);
PyModule_AddObject(m, "error", TestError);
result = fromWideIntObj(self, value);
#endif
Tcl_DecrRefCount(value);
- if (result != NULL)
- return PyNumber_Int(result);
+ if (result != NULL) {
+ PyObject *resint = PyNumber_Int(result);
+ Py_DECREF(result);
+ return resint;
+ }
+
if (PyErr_Occurred())
return NULL;
#else
((PyWeakReference **) PyObject_GET_WEAKREFS_LISTPTR(o))
+static int
+is_dead_weakref(PyObject *value)
+{
+ if (!PyWeakref_Check(value)) {
+ PyErr_SetString(PyExc_TypeError, "not a weakref");
+ return -1;
+ }
+ return PyWeakref_GET_OBJECT(value) == Py_None;
+}
+
+PyDoc_STRVAR(remove_dead_weakref__doc__,
+"_remove_dead_weakref(dict, key) -- atomically remove key from dict\n"
+"if it points to a dead weakref.");
+
+static PyObject *
+remove_dead_weakref(PyObject *self, PyObject *args)
+{
+ PyObject *dct, *key;
+
+ if (!PyArg_ParseTuple(args, "O!O:_remove_dead_weakref",
+ &PyDict_Type, &dct, &key)) {
+ return NULL;
+ }
+ if (_PyDict_DelItemIf(dct, key, is_dead_weakref) < 0) {
+ if (PyErr_ExceptionMatches(PyExc_KeyError))
+ /* This function is meant to allow safe weak-value dicts
+ with GC in another thread (see issue #28427), so it's
+ ok if the key doesn't exist anymore.
+ */
+ PyErr_Clear();
+ else
+ return NULL;
+ }
+ Py_RETURN_NONE;
+}
+
+
PyDoc_STRVAR(weakref_getweakrefcount__doc__,
"getweakrefcount(object) -- return the number of weak references\n"
"to 'object'.");
weakref_getweakrefs__doc__},
{"proxy", weakref_proxy, METH_VARARGS,
weakref_proxy__doc__},
+ {"_remove_dead_weakref", remove_dead_weakref, METH_VARARGS,
+ remove_dead_weakref__doc__},
{NULL, NULL, 0, NULL}
};
arrayobject* ar;
int itemsize = self->ob_descr->itemsize;
- if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelength = _PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
+ step);
if (slicelength <= 0) {
return newarrayobject(&Arraytype, 0, self->ob_descr);
return (*self->ob_descr->setitem)(self, i, value);
}
else if (PySlice_Check(item)) {
- if (PySlice_GetIndicesEx((PySliceObject *)item,
- Py_SIZE(self), &start, &stop,
- &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return -1;
}
+ slicelength = _PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
+ step);
}
else {
PyErr_SetString(PyExc_TypeError,
--- /dev/null
+/*
+ * atexit - allow programmer to define multiple exit functions to be executed
+ * upon normal program termination.
+ *
+ * Translated from atexit.py by Collin Winter.
+ + Copyright 2007 Python Software Foundation.
+ */
+
+#include "Python.h"
+
+/* Forward declaration (for atexit_cleanup) */
+static PyObject *atexit_clear(PyObject*, PyObject*);
+/* Forward declaration of module object */
+static struct PyModuleDef atexitmodule;
+
+/* ===================================================================== */
+/* Callback machinery. */
+
+typedef struct {
+ PyObject *func;
+ PyObject *args;
+ PyObject *kwargs;
+} atexit_callback;
+
+typedef struct {
+ atexit_callback **atexit_callbacks;
+ int ncallbacks;
+ int callback_len;
+} atexitmodule_state;
+
+#define GET_ATEXIT_STATE(mod) ((atexitmodule_state*)PyModule_GetState(mod))
+
+
+static void
+atexit_delete_cb(atexitmodule_state *modstate, int i)
+{
+ atexit_callback *cb;
+
+ cb = modstate->atexit_callbacks[i];
+ modstate->atexit_callbacks[i] = NULL;
+ Py_DECREF(cb->func);
+ Py_DECREF(cb->args);
+ Py_XDECREF(cb->kwargs);
+ PyMem_Free(cb);
+}
+
+/* Clear all callbacks without calling them */
+static void
+atexit_cleanup(atexitmodule_state *modstate)
+{
+ atexit_callback *cb;
+ int i;
+ for (i = 0; i < modstate->ncallbacks; i++) {
+ cb = modstate->atexit_callbacks[i];
+ if (cb == NULL)
+ continue;
+
+ atexit_delete_cb(modstate, i);
+ }
+ modstate->ncallbacks = 0;
+}
+
+/* Installed into pylifecycle.c's atexit mechanism */
+
+static void
+atexit_callfuncs(void)
+{
+ PyObject *exc_type = NULL, *exc_value, *exc_tb, *r;
+ atexit_callback *cb;
+ PyObject *module;
+ atexitmodule_state *modstate;
+ int i;
+
+ module = PyState_FindModule(&atexitmodule);
+ if (module == NULL)
+ return;
+ modstate = GET_ATEXIT_STATE(module);
+
+ if (modstate->ncallbacks == 0)
+ return;
+
+
+ for (i = modstate->ncallbacks - 1; i >= 0; i--)
+ {
+ cb = modstate->atexit_callbacks[i];
+ if (cb == NULL)
+ continue;
+
+ r = PyObject_Call(cb->func, cb->args, cb->kwargs);
+ Py_XDECREF(r);
+ if (r == NULL) {
+ /* Maintain the last exception, but don't leak if there are
+ multiple exceptions. */
+ if (exc_type) {
+ Py_DECREF(exc_type);
+ Py_XDECREF(exc_value);
+ Py_XDECREF(exc_tb);
+ }
+ PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
+ if (!PyErr_GivenExceptionMatches(exc_type, PyExc_SystemExit)) {
+ PySys_WriteStderr("Error in atexit._run_exitfuncs:\n");
+ PyErr_NormalizeException(&exc_type, &exc_value, &exc_tb);
+ PyErr_Display(exc_type, exc_value, exc_tb);
+ }
+ }
+ }
+
+ atexit_cleanup(modstate);
+
+ if (exc_type)
+ PyErr_Restore(exc_type, exc_value, exc_tb);
+}
+
+/* ===================================================================== */
+/* Module methods. */
+
+PyDoc_STRVAR(atexit_register__doc__,
+"register(func, *args, **kwargs) -> func\n\
+\n\
+Register a function to be executed upon normal program termination\n\
+\n\
+ func - function to be called at exit\n\
+ args - optional arguments to pass to func\n\
+ kwargs - optional keyword arguments to pass to func\n\
+\n\
+ func is returned to facilitate usage as a decorator.");
+
+static PyObject *
+atexit_register(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ atexitmodule_state *modstate;
+ atexit_callback *new_callback;
+ PyObject *func = NULL;
+
+ modstate = GET_ATEXIT_STATE(self);
+
+ if (modstate->ncallbacks >= modstate->callback_len) {
+ atexit_callback **r;
+ modstate->callback_len += 16;
+ r = (atexit_callback**)PyMem_Realloc(modstate->atexit_callbacks,
+ sizeof(atexit_callback*) * modstate->callback_len);
+ if (r == NULL)
+ return PyErr_NoMemory();
+ modstate->atexit_callbacks = r;
+ }
+
+ if (PyTuple_GET_SIZE(args) == 0) {
+ PyErr_SetString(PyExc_TypeError,
+ "register() takes at least 1 argument (0 given)");
+ return NULL;
+ }
+
+ func = PyTuple_GET_ITEM(args, 0);
+ if (!PyCallable_Check(func)) {
+ PyErr_SetString(PyExc_TypeError,
+ "the first argument must be callable");
+ return NULL;
+ }
+
+ new_callback = PyMem_Malloc(sizeof(atexit_callback));
+ if (new_callback == NULL)
+ return PyErr_NoMemory();
+
+ new_callback->args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
+ if (new_callback->args == NULL) {
+ PyMem_Free(new_callback);
+ return NULL;
+ }
+ new_callback->func = func;
+ new_callback->kwargs = kwargs;
+ Py_INCREF(func);
+ Py_XINCREF(kwargs);
+
+ modstate->atexit_callbacks[modstate->ncallbacks++] = new_callback;
+
+ Py_INCREF(func);
+ return func;
+}
+
+PyDoc_STRVAR(atexit_run_exitfuncs__doc__,
+"_run_exitfuncs() -> None\n\
+\n\
+Run all registered exit functions.");
+
+static PyObject *
+atexit_run_exitfuncs(PyObject *self, PyObject *unused)
+{
+ atexit_callfuncs();
+ if (PyErr_Occurred())
+ return NULL;
+ Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(atexit_clear__doc__,
+"_clear() -> None\n\
+\n\
+Clear the list of previously registered exit functions.");
+
+static PyObject *
+atexit_clear(PyObject *self, PyObject *unused)
+{
+ atexit_cleanup(GET_ATEXIT_STATE(self));
+ Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(atexit_ncallbacks__doc__,
+"_ncallbacks() -> int\n\
+\n\
+Return the number of registered exit functions.");
+
+static PyObject *
+atexit_ncallbacks(PyObject *self, PyObject *unused)
+{
+ atexitmodule_state *modstate;
+
+ modstate = GET_ATEXIT_STATE(self);
+
+ return PyLong_FromSsize_t(modstate->ncallbacks);
+}
+
+static int
+atexit_m_traverse(PyObject *self, visitproc visit, void *arg)
+{
+ int i;
+ atexitmodule_state *modstate;
+
+ modstate = GET_ATEXIT_STATE(self);
+ for (i = 0; i < modstate->ncallbacks; i++) {
+ atexit_callback *cb = modstate->atexit_callbacks[i];
+ if (cb == NULL)
+ continue;
+ Py_VISIT(cb->func);
+ Py_VISIT(cb->args);
+ Py_VISIT(cb->kwargs);
+ }
+ return 0;
+}
+
+static int
+atexit_m_clear(PyObject *self)
+{
+ atexitmodule_state *modstate;
+ modstate = GET_ATEXIT_STATE(self);
+ atexit_cleanup(modstate);
+ return 0;
+}
+
+static void
+atexit_free(PyObject *m)
+{
+ atexitmodule_state *modstate;
+ modstate = GET_ATEXIT_STATE(m);
+ atexit_cleanup(modstate);
+ PyMem_Free(modstate->atexit_callbacks);
+}
+
+PyDoc_STRVAR(atexit_unregister__doc__,
+"unregister(func) -> None\n\
+\n\
+Unregister an exit function which was previously registered using\n\
+atexit.register\n\
+\n\
+ func - function to be unregistered");
+
+static PyObject *
+atexit_unregister(PyObject *self, PyObject *func)
+{
+ atexitmodule_state *modstate;
+ atexit_callback *cb;
+ int i, eq;
+
+ modstate = GET_ATEXIT_STATE(self);
+
+ for (i = 0; i < modstate->ncallbacks; i++)
+ {
+ cb = modstate->atexit_callbacks[i];
+ if (cb == NULL)
+ continue;
+
+ eq = PyObject_RichCompareBool(cb->func, func, Py_EQ);
+ if (eq < 0)
+ return NULL;
+ if (eq)
+ atexit_delete_cb(modstate, i);
+ }
+ Py_RETURN_NONE;
+}
+
+static PyMethodDef atexit_methods[] = {
+ {"register", (PyCFunction) atexit_register, METH_VARARGS|METH_KEYWORDS,
+ atexit_register__doc__},
+ {"_clear", (PyCFunction) atexit_clear, METH_NOARGS,
+ atexit_clear__doc__},
+ {"unregister", (PyCFunction) atexit_unregister, METH_O,
+ atexit_unregister__doc__},
+ {"_run_exitfuncs", (PyCFunction) atexit_run_exitfuncs, METH_NOARGS,
+ atexit_run_exitfuncs__doc__},
+ {"_ncallbacks", (PyCFunction) atexit_ncallbacks, METH_NOARGS,
+ atexit_ncallbacks__doc__},
+ {NULL, NULL} /* sentinel */
+};
+
+/* ===================================================================== */
+/* Initialization function. */
+
+PyDoc_STRVAR(atexit__doc__,
+"allow programmer to define multiple exit functions to be executed\
+upon normal program termination.\n\
+\n\
+Two public functions, register and unregister, are defined.\n\
+");
+
+
+static struct PyModuleDef atexitmodule = {
+ PyModuleDef_HEAD_INIT,
+ "atexit",
+ atexit__doc__,
+ sizeof(atexitmodule_state),
+ atexit_methods,
+ NULL,
+ atexit_m_traverse,
+ atexit_m_clear,
+ (freefunc)atexit_free
+};
+
+PyMODINIT_FUNC
+PyInit_atexit(void)
+{
+ PyObject *m;
+ atexitmodule_state *modstate;
+
+ m = PyModule_Create(&atexitmodule);
+ if (m == NULL)
+ return NULL;
+
+ modstate = GET_ATEXIT_STATE(m);
+ modstate->callback_len = 32;
+ modstate->ncallbacks = 0;
+ modstate->atexit_callbacks = PyMem_New(atexit_callback*,
+ modstate->callback_len);
+ if (modstate->atexit_callbacks == NULL)
+ return NULL;
+
+ _Py_PyAtExit(atexit_callfuncs);
+ return m;
+}
}
PyDoc_STRVAR(doc_crc_hqx,
-"(data, oldcrc) -> newcrc. Compute hqx CRC incrementally");
+"(data, oldcrc) -> newcrc. Compute CRC-CCITT incrementally");
static PyObject *
binascii_crc_hqx(PyObject *self, PyObject *args)
/* ===================================================================== */
/* Slot definitions for BZ2File_Type. */
+static int
+BZ2File_clear(BZ2FileObject *self)
+{
+ int bzerror;
+
+ ACQUIRE_LOCK(self);
+ switch (self->mode) {
+ case MODE_READ:
+ case MODE_READ_EOF:
+ BZ2_bzReadClose(&bzerror, self->fp);
+ break;
+ case MODE_WRITE:
+ BZ2_bzWriteClose(&bzerror, self->fp,
+ 0, NULL, NULL);
+ break;
+ }
+ if (self->fp != NULL && self->file != NULL)
+ PyFile_DecUseCount((PyFileObject *)self->file);
+ self->fp = NULL;
+ Util_DropReadAhead(self);
+ Py_CLEAR(self->file);
+ RELEASE_LOCK(self);
+ return 0;
+}
static int
BZ2File_init(BZ2FileObject *self, PyObject *args, PyObject *kwargs)
mode = (mode_char == 'r') ? "rb" : "wb";
+#ifdef WITH_THREAD
+ if (!self->lock) {
+ self->lock = PyThread_allocate_lock();
+ }
+
+ if (!self->lock) {
+ PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");
+ goto error;
+ }
+#endif
+
+ BZ2File_clear(self);
+
self->file = PyObject_CallFunction((PyObject*)&PyFile_Type, "(Osi)",
name, mode, buffering);
if (self->file == NULL)
/* From now on, we have stuff to dealloc, so jump to error label
* instead of returning */
-#ifdef WITH_THREAD
- self->lock = PyThread_allocate_lock();
- if (!self->lock) {
- PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");
- goto error;
- }
-#endif
-
if (mode_char == 'r')
self->fp = BZ2_bzReadOpen(&bzerror,
PyFile_AsFile(self->file),
static void
BZ2File_dealloc(BZ2FileObject *self)
{
- int bzerror;
+ BZ2File_clear(self);
#ifdef WITH_THREAD
if (self->lock)
PyThread_free_lock(self->lock);
#endif
- switch (self->mode) {
- case MODE_READ:
- case MODE_READ_EOF:
- BZ2_bzReadClose(&bzerror, self->fp);
- break;
- case MODE_WRITE:
- BZ2_bzWriteClose(&bzerror, self->fp,
- 0, NULL, NULL);
- break;
- }
- if (self->fp != NULL && self->file != NULL)
- PyFile_DecUseCount((PyFileObject *)self->file);
- self->fp = NULL;
- Util_DropReadAhead(self);
- Py_XDECREF(self->file);
Py_TYPE(self)->tp_free((PyObject *)self);
}
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /*tp_flags*/
BZ2File__doc__, /*tp_doc*/
0, /*tp_traverse*/
- 0, /*tp_clear*/
+ (inquiry)BZ2File_clear, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
(getiterfunc)BZ2File_getiter, /*tp_iter*/
s[1] = (int)(c_value & 0xff);
len = 2;
}
- else {
+ else if (c_value < 0x7fffffffL) {
s[0] = LONG_BINGET;
s[1] = (int)(c_value & 0xff);
s[2] = (int)((c_value >> 8) & 0xff);
s[4] = (int)((c_value >> 24) & 0xff);
len = 5;
}
+ else { /* unlikely */
+ PyErr_SetString(PicklingError,
+ "memo id too large for LONG_BINGET");
+ return -1;
+ }
}
if (self->write_func(self, s, len) < 0)
goto finally;
}
else {
- if (p >= 256) {
+ if (p < 256) {
+ c_str[0] = BINPUT;
+ c_str[1] = p;
+ len = 2;
+ }
+ else if (p < 0x7fffffffL) {
c_str[0] = LONG_BINPUT;
c_str[1] = (int)(p & 0xff);
c_str[2] = (int)((p >> 8) & 0xff);
c_str[4] = (int)((p >> 24) & 0xff);
len = 5;
}
- else {
- c_str[0] = BINPUT;
- c_str[1] = p;
- len = 2;
+ else { /* unlikely */
+ PyErr_SetString(PicklingError,
+ "memo id too large for LONG_BINPUT");
+ goto finally;
}
}
c_str[1] = size;
len = 2;
}
- else if (size <= INT_MAX) {
+ else if (size <= 0x7fffffffL) {
c_str[0] = BINSTRING;
for (i = 1; i < 5; i++)
c_str[i] = (int)(size >> ((i - 1) * 8));
len = 5;
}
- else
+ else {
+ PyErr_SetString(PyExc_OverflowError,
+ "cannot serialize a string larger than 2 GiB");
return -1; /* string too large */
+ }
if (self->write_func(self, c_str, len) < 0)
return -1;
if ((size = PyString_Size(repr)) < 0)
goto err;
- if (size > INT_MAX)
- return -1; /* string too large */
+ if (size > 0x7fffffffL) {
+ PyErr_SetString(PyExc_OverflowError,
+ "cannot serialize a Unicode string larger than 2 GiB");
+ goto err; /* string too large */
+ }
c_str[0] = BINUNICODE;
for (i = 1; i < 5; i++)
static PyObject *
Instance_New(PyObject *cls, PyObject *args)
{
- PyObject *r = 0;
-
if (PyClass_Check(cls)) {
int l;
- if ((l=PyObject_Size(args)) < 0) goto err;
+ if ((l=PyObject_Size(args)) < 0) return NULL;
if (!( l )) {
- PyObject *__getinitargs__;
-
- __getinitargs__ = PyObject_GetAttr(cls,
- __getinitargs___str);
- if (!__getinitargs__) {
+ if (!PyObject_HasAttr(cls, __getinitargs___str)) {
/* We have a class with no __getinitargs__,
so bypass usual construction */
- PyObject *inst;
-
- PyErr_Clear();
- if (!( inst=PyInstance_NewRaw(cls, NULL)))
- goto err;
- return inst;
+ return PyInstance_NewRaw(cls, NULL);
}
- Py_DECREF(__getinitargs__);
}
- if ((r=PyInstance_New(cls, args, NULL))) return r;
- else goto err;
+ return PyInstance_New(cls, args, NULL);
}
- if ((r=PyObject_CallObject(cls, args))) return r;
-
- err:
- {
- PyObject *tp, *v, *tb, *tmp_value;
-
- PyErr_Fetch(&tp, &v, &tb);
- tmp_value = v;
- /* NULL occurs when there was a KeyboardInterrupt */
- if (tmp_value == NULL)
- tmp_value = Py_None;
- if ((r = PyTuple_Pack(3, tmp_value, cls, args))) {
- Py_XDECREF(v);
- v=r;
- }
- PyErr_Restore(tp,v,tb);
- }
- return NULL;
+ return PyObject_CallObject(cls, args);
}
REQUIRE_INBUF(4)
c3 = IN3;
c4 = IN4;
- if (c < 0x81 || c3 < 0x81 || c4 < 0x30 || c4 > 0x39)
+ if (c < 0x81 || c > 0xFE ||
+ c3 < 0x81 || c3 > 0xFE ||
+ c4 < 0x30 || c4 > 0x39)
return 4;
c -= 0x81; c2 -= 0x30;
c3 -= 0x81; c4 -= 0x30;
DBCHAR code;
if (c < 0x80) {
- if (state->i == 0) {
- WRITE1((unsigned char)c)
- NEXT(1, 1)
- }
- else {
- WRITE3('~', '}', (unsigned char)c)
- NEXT(1, 3)
+ if (state->i) {
+ WRITE2('~', '}')
+ NEXT_OUT(2)
state->i = 0;
}
+ WRITE1((unsigned char)c)
+ NEXT(1, 1)
+ if (c == '~') {
+ WRITE1('~')
+ NEXT_OUT(1)
+ }
continue;
}
unsigned char c2 = IN2;
REQUIRE_INBUF(2)
- if (c2 == '~') {
+ if (c2 == '~' && state->i == 0) {
WRITE1('~')
- NEXT(2, 1)
- continue;
+ NEXT_OUT(1)
}
else if (c2 == '{' && state->i == 0)
state->i = 1; /* set GB */
+ else if (c2 == '\n' && state->i == 0)
+ ; /* line-continuation */
else if (c2 == '}' && state->i == 1)
state->i = 0; /* set ASCII */
- else if (c2 == '\n')
- ; /* line-continuation */
else
return 2;
- NEXT(2, 0);
+ NEXT_IN(2)
continue;
}
if (r == -1)
return NULL;
}
+ /* PySequence_Length() can fail */
+ if (PyErr_Occurred())
+ return NULL;
Py_RETURN_NONE;
}
}
for (i = 1; i < n; i++) {
PyObject *v = PyTuple_GetItem(args, i);
- if (PyInt_Check(v))
+ if (PyInt_Check(v) || PyLong_Check(v)) {
alist[i-1] = PyInt_AsLong(v);
+ if (alist[i-1] == -1 && PyErr_Occurred())
+ return NULL;
+ }
else if (PyString_Check(v))
alist[i-1] = (long)PyString_AsString(v);
else if (v == Py_None)
-Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
- and Clark Cooper
-Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.
+Copyright (c) 1998-2000 Thai Open Source Software Center Ltd and Clark Cooper
+Copyright (c) 2001-2017 Expat maintainers
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
+++ /dev/null
-#ifndef AMIGACONFIG_H
-#define AMIGACONFIG_H
-
-/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
-#define BYTEORDER 4321
-
-/* Define to 1 if you have the `bcopy' function. */
-#define HAVE_BCOPY 1
-
-/* Define to 1 if you have the <check.h> header file. */
-#undef HAVE_CHECK_H
-
-/* Define to 1 if you have the `memmove' function. */
-#define HAVE_MEMMOVE 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* whether byteorder is bigendian */
-#define WORDS_BIGENDIAN
-
-/* Define to specify how much context to retain around the current parse
- point. */
-#define XML_CONTEXT_BYTES 1024
-
-/* Define to make parameter entity parsing functionality available. */
-#define XML_DTD
-
-/* Define to make XML Namespaces functionality available. */
-#define XML_NS
-
-#endif /* AMIGACONFIG_H */
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#define ASCII_A 0x41
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef Expat_INCLUDED
struct XML_ParserStruct;
typedef struct XML_ParserStruct *XML_Parser;
-/* Should this be defined using stdbool.h when C99 is available? */
typedef unsigned char XML_Bool;
#define XML_TRUE ((XML_Bool) 1)
#define XML_FALSE ((XML_Bool) 0)
/* Added in 2.0. */
XML_ERROR_RESERVED_PREFIX_XML,
XML_ERROR_RESERVED_PREFIX_XMLNS,
- XML_ERROR_RESERVED_NAMESPACE_URI
+ XML_ERROR_RESERVED_NAMESPACE_URI,
+ /* Added in 2.2.1. */
+ XML_ERROR_INVALID_ARGUMENT
};
enum XML_Content_Type {
XML_EntityDeclHandler handler);
/* OBSOLETE -- OBSOLETE -- OBSOLETE
- This handler has been superceded by the EntityDeclHandler above.
+ This handler has been superseded by the EntityDeclHandler above.
It is provided here for backward compatibility.
This is called for a declaration of an unparsed (NDATA) entity.
be called, despite an external subset being parsed.
Note: If XML_DTD is not defined when Expat is compiled, returns
XML_ERROR_FEATURE_REQUIRES_XML_DTD.
+ Note: If parser == NULL, returns XML_ERROR_INVALID_ARGUMENT.
*/
XMLPARSEAPI(enum XML_Error)
XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
to the XML_StartElementHandler that were specified in the start-tag
rather than defaulted. Each attribute/value pair counts as 2; thus
this correspondds to an index into the atts array passed to the
- XML_StartElementHandler.
+ XML_StartElementHandler. Returns -1 if parser == NULL.
*/
XMLPARSEAPI(int)
XML_GetSpecifiedAttributeCount(XML_Parser parser);
/* Returns the index of the ID attribute passed in the last call to
- XML_StartElementHandler, or -1 if there is no ID attribute. Each
- attribute/value pair counts as 2; thus this correspondds to an
- index into the atts array passed to the XML_StartElementHandler.
+ XML_StartElementHandler, or -1 if there is no ID attribute or
+ parser == NULL. Each attribute/value pair counts as 2; thus this
+ correspondds to an index into the atts array passed to the
+ XML_StartElementHandler.
*/
XMLPARSEAPI(int)
XML_GetIdAttributeIndex(XML_Parser parser);
entities is requested; otherwise it will return non-zero.
Note: If XML_SetParamEntityParsing is called after XML_Parse or
XML_ParseBuffer, then it has no effect and will always return 0.
+ Note: If parser == NULL, the function will do nothing and return 0.
*/
XMLPARSEAPI(int)
XML_SetParamEntityParsing(XML_Parser parser,
Helps in preventing DoS attacks based on predicting hash
function behavior. This must be called before parsing is started.
Returns 1 if successful, 0 when called after parsing has started.
+ Note: If parser == NULL, the function will do nothing and return 0.
*/
XMLPARSEAPI(int)
XML_SetHashSalt(XML_Parser parser,
unsigned long hash_salt);
-#define XML_HAS_SET_HASH_SALT /* Python Only: Defined for pyexpat.c. */
-
/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
XML_GetErrorCode returns information about the error.
*/
the location is the location of the character at which the error
was detected; otherwise the location is the location of the last
parse event, as described above.
+
+ Note: XML_GetCurrentLineNumber and XML_GetCurrentColumnNumber
+ return 0 to indicate an error.
+ Note: XML_GetCurrentByteIndex returns -1 to indicate an error.
*/
XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
/* Exposing the memory handling functions used in Expat */
XMLPARSEAPI(void *)
+XML_ATTR_MALLOC
+XML_ATTR_ALLOC_SIZE(2)
XML_MemMalloc(XML_Parser parser, size_t size);
XMLPARSEAPI(void *)
+XML_ATTR_ALLOC_SIZE(3)
XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
XMLPARSEAPI(void)
XML_GetFeatureList(void);
-/* Expat follows the GNU/Linux convention of odd number minor version for
- beta/development releases and even number minor version for stable
- releases. Micro is bumped with each release, and set to 0 with each
- change to major or minor version.
+/* Expat follows the semantic versioning convention.
+ See http://semver.org.
*/
#define XML_MAJOR_VERSION 2
-#define XML_MINOR_VERSION 1
-#define XML_MICRO_VERSION 1
+#define XML_MINOR_VERSION 2
+#define XML_MICRO_VERSION 4
#ifdef __cplusplus
}
-/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef Expat_External_INCLUDED
#endif
#endif /* not defined XML_STATIC */
+#if !defined(XMLIMPORT) && defined(__GNUC__) && (__GNUC__ >= 4)
+#define XMLIMPORT __attribute__ ((visibility ("default")))
+#endif
/* If we didn't define it above, define it away: */
#ifndef XMLIMPORT
#define XMLIMPORT
#endif
+#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
+#define XML_ATTR_MALLOC __attribute__((__malloc__))
+#else
+#define XML_ATTR_MALLOC
+#endif
+
+#if defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+#define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
+#else
+#define XML_ATTR_ALLOC_SIZE(x)
+#endif
#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
#endif
#ifdef XML_UNICODE_WCHAR_T
-#define XML_UNICODE
+# define XML_UNICODE
+# if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
+# error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc"
+# endif
#endif
#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
Note: Use of these macros is based on judgement, not hard rules,
and therefore subject to change.
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#if defined(__GNUC__) && defined(__i386__) && !defined(__MINGW32__)
#define inline
#endif
#endif
+
+#ifndef UNUSED_P
+# ifdef __GNUC__
+# define UNUSED_P(p) UNUSED_ ## p __attribute__((__unused__))
+# else
+# define UNUSED_P(p) UNUSED_ ## p
+# endif
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+void
+align_limit_to_full_utf8_characters(const char * from, const char ** fromLimRef);
+
+
+#ifdef __cplusplus
+}
+#endif
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
--- /dev/null
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2016 - 2017, Steve Holme, <steve_holme@hotmail.com>.
+ * Copyright (C) 2017, Expat development team
+ *
+ * All rights reserved.
+ * Licensed under the MIT license:
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+ * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH
+ * THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder shall
+ * not be used in advertising or otherwise to promote the sale, use or other
+ * dealings in this Software without prior written authorization of the
+ * copyright holder.
+ *
+ ***************************************************************************/
+
+#if defined(_WIN32)
+
+#include <windows.h>
+#include <tchar.h>
+
+
+HMODULE _Expat_LoadLibrary(LPCTSTR filename);
+
+
+#if !defined(LOAD_WITH_ALTERED_SEARCH_PATH)
+#define LOAD_WITH_ALTERED_SEARCH_PATH 0x00000008
+#endif
+
+#if !defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
+#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
+#endif
+
+/* We use our own typedef here since some headers might lack these */
+typedef HMODULE (APIENTRY *LOADLIBRARYEX_FN)(LPCTSTR, HANDLE, DWORD);
+
+/* See function definitions in winbase.h */
+#ifdef UNICODE
+# ifdef _WIN32_WCE
+# define LOADLIBARYEX L"LoadLibraryExW"
+# else
+# define LOADLIBARYEX "LoadLibraryExW"
+# endif
+#else
+# define LOADLIBARYEX "LoadLibraryExA"
+#endif
+
+
+/*
+ * _Expat_LoadLibrary()
+ *
+ * This is used to dynamically load DLLs using the most secure method available
+ * for the version of Windows that we are running on.
+ *
+ * Parameters:
+ *
+ * filename [in] - The filename or full path of the DLL to load. If only the
+ * filename is passed then the DLL will be loaded from the
+ * Windows system directory.
+ *
+ * Returns the handle of the module on success; otherwise NULL.
+ */
+HMODULE _Expat_LoadLibrary(LPCTSTR filename)
+{
+ HMODULE hModule = NULL;
+ LOADLIBRARYEX_FN pLoadLibraryEx = NULL;
+
+ /* Get a handle to kernel32 so we can access it's functions at runtime */
+ HMODULE hKernel32 = GetModuleHandle(TEXT("kernel32"));
+ if(!hKernel32)
+ return NULL;
+
+ /* Attempt to find LoadLibraryEx() which is only available on Windows 2000
+ and above */
+ pLoadLibraryEx = (LOADLIBRARYEX_FN) GetProcAddress(hKernel32, LOADLIBARYEX);
+
+ /* Detect if there's already a path in the filename and load the library if
+ there is. Note: Both back slashes and forward slashes have been supported
+ since the earlier days of DOS at an API level although they are not
+ supported by command prompt */
+ if(_tcspbrk(filename, TEXT("\\/"))) {
+ /** !checksrc! disable BANNEDFUNC 1 **/
+ hModule = pLoadLibraryEx ?
+ pLoadLibraryEx(filename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH) :
+ LoadLibrary(filename);
+ }
+ /* Detect if KB2533623 is installed, as LOAD_LIBARY_SEARCH_SYSTEM32 is only
+ supported on Windows Vista, Windows Server 2008, Windows 7 and Windows
+ Server 2008 R2 with this patch or natively on Windows 8 and above */
+ else if(pLoadLibraryEx && GetProcAddress(hKernel32, "AddDllDirectory")) {
+ /* Load the DLL from the Windows system directory */
+ hModule = pLoadLibraryEx(filename, NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
+ }
+ else {
+ /* Attempt to get the Windows system path */
+ UINT systemdirlen = GetSystemDirectory(NULL, 0);
+ if(systemdirlen) {
+ /* Allocate space for the full DLL path (Room for the null terminator
+ is included in systemdirlen) */
+ size_t filenamelen = _tcslen(filename);
+ TCHAR *path = malloc(sizeof(TCHAR) * (systemdirlen + 1 + filenamelen));
+ if(path && GetSystemDirectory(path, systemdirlen)) {
+ /* Calculate the full DLL path */
+ _tcscpy(path + _tcslen(path), TEXT("\\"));
+ _tcscpy(path + _tcslen(path), filename);
+
+ /* Load the DLL from the Windows system directory */
+ /** !checksrc! disable BANNEDFUNC 1 **/
+ hModule = pLoadLibraryEx ?
+ pLoadLibraryEx(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH) :
+ LoadLibrary(path);
+
+ }
+ free(path);
+ }
+ }
+
+ return hModule;
+}
+
+#else /* defined(_WIN32) */
+
+/* ISO C requires a translation unit to contain at least one declaration
+ [-Wempty-translation-unit] */
+typedef int _TRANSLATION_UNIT_LOAD_LIBRARY_C_NOT_EMTPY;
+
+#endif /* defined(_WIN32) */
+++ /dev/null
-/*================================================================
-** Copyright 2000, Clark Cooper
-** All rights reserved.
-**
-** This is free software. You are permitted to copy, distribute, or modify
-** it under the terms of the MIT/X license (contained in the COPYING file
-** with this distribution.)
-**
-*/
-
-#ifndef MACCONFIG_H
-#define MACCONFIG_H
-
-
-/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
-#define BYTEORDER 4321
-
-/* Define to 1 if you have the `bcopy' function. */
-#undef HAVE_BCOPY
-
-/* Define to 1 if you have the `memmove' function. */
-#define HAVE_MEMMOVE
-
-/* Define to 1 if you have a working `mmap' system call. */
-#undef HAVE_MMAP
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* whether byteorder is bigendian */
-#define WORDS_BIGENDIAN
-
-/* Define to specify how much context to retain around the current parse
- point. */
-#undef XML_CONTEXT_BYTES
-
-/* Define to make parameter entity parsing functionality available. */
-#define XML_DTD
-
-/* Define to make XML Namespaces functionality available. */
-#define XML_NS
-
-/* Define to empty if `const' does not conform to ANSI C. */
-#undef const
-
-/* Define to `long' if <sys/types.h> does not define. */
-#define off_t long
-
-/* Define to `unsigned' if <sys/types.h> does not define. */
-#undef size_t
-
-
-#endif /* ifndef MACCONFIG_H */
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
static const unsigned namingBitmap[] = {
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
--- /dev/null
+/* ==========================================================================
+ * siphash.h - SipHash-2-4 in a single header file
+ * --------------------------------------------------------------------------
+ * Derived by William Ahern from the reference implementation[1] published[2]
+ * by Jean-Philippe Aumasson and Daniel J. Berstein.
+ * Minimal changes by Sebastian Pipping and Victor Stinner on top, see below.
+ * Licensed under the CC0 Public Domain Dedication license.
+ *
+ * 1. https://www.131002.net/siphash/siphash24.c
+ * 2. https://www.131002.net/siphash/
+ * --------------------------------------------------------------------------
+ * HISTORY:
+ *
+ * 2017-07-25 (Vadim Zeitlin)
+ * - Fix use of SIPHASH_MAIN macro
+ *
+ * 2017-07-05 (Sebastian Pipping)
+ * - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++
+ * - Add const qualifiers at two places
+ * - Ensure <=80 characters line length (assuming tab width 4)
+ *
+ * 2017-06-23 (Victor Stinner)
+ * - Address Win64 compile warnings
+ *
+ * 2017-06-18 (Sebastian Pipping)
+ * - Clarify license note in the header
+ * - Address C89 issues:
+ * - Stop using inline keyword (and let compiler decide)
+ * - Replace _Bool by int
+ * - Turn macro siphash24 into a function
+ * - Address invalid conversion (void pointer) by explicit cast
+ * - Address lack of stdint.h for Visual Studio 2003 to 2008
+ * - Always expose sip24_valid (for self-tests)
+ *
+ * 2012-11-04 - Born. (William Ahern)
+ * --------------------------------------------------------------------------
+ * USAGE:
+ *
+ * SipHash-2-4 takes as input two 64-bit words as the key, some number of
+ * message bytes, and outputs a 64-bit word as the message digest. This
+ * implementation employs two data structures: a struct sipkey for
+ * representing the key, and a struct siphash for representing the hash
+ * state.
+ *
+ * For converting a 16-byte unsigned char array to a key, use either the
+ * macro sip_keyof or the routine sip_tokey. The former instantiates a
+ * compound literal key, while the latter requires a key object as a
+ * parameter.
+ *
+ * unsigned char secret[16];
+ * arc4random_buf(secret, sizeof secret);
+ * struct sipkey *key = sip_keyof(secret);
+ *
+ * For hashing a message, use either the convenience macro siphash24 or the
+ * routines sip24_init, sip24_update, and sip24_final.
+ *
+ * struct siphash state;
+ * void *msg;
+ * size_t len;
+ * uint64_t hash;
+ *
+ * sip24_init(&state, key);
+ * sip24_update(&state, msg, len);
+ * hash = sip24_final(&state);
+ *
+ * or
+ *
+ * hash = siphash24(msg, len, key);
+ *
+ * To convert the 64-bit hash value to a canonical 8-byte little-endian
+ * binary representation, use either the macro sip_binof or the routine
+ * sip_tobin. The former instantiates and returns a compound literal array,
+ * while the latter requires an array object as a parameter.
+ * --------------------------------------------------------------------------
+ * NOTES:
+ *
+ * o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers
+ * lacking compound literal support. Instead, you must use the lower-level
+ * interfaces which take as parameters the temporary state objects.
+ *
+ * o Uppercase macros may evaluate parameters more than once. Lowercase
+ * macros should not exhibit any such side effects.
+ * ==========================================================================
+ */
+#ifndef SIPHASH_H
+#define SIPHASH_H
+
+#include <stddef.h> /* size_t */
+
+#if defined(_WIN32) && defined(_MSC_VER) && (_MSC_VER < 1600)
+ /* For vs2003/7.1 up to vs2008/9.0; _MSC_VER 1600 is vs2010/10.0 */
+ typedef unsigned __int8 uint8_t;
+ typedef unsigned __int32 uint32_t;
+ typedef unsigned __int64 uint64_t;
+#else
+ #include <stdint.h> /* uint64_t uint32_t uint8_t */
+#endif
+
+
+/*
+ * Workaround to not require a C++11 compiler for using ULL suffix
+ * if this code is included and compiled as C++; related GCC warning is:
+ * warning: use of C++11 long long integer constant [-Wlong-long]
+ */
+#define _SIP_ULL(high, low) (((uint64_t)high << 32) | low)
+
+
+#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ( (x) >> (64 - (b))))
+
+#define SIP_U32TO8_LE(p, v) \
+ (p)[0] = (uint8_t)((v) >> 0); (p)[1] = (uint8_t)((v) >> 8); \
+ (p)[2] = (uint8_t)((v) >> 16); (p)[3] = (uint8_t)((v) >> 24);
+
+#define SIP_U64TO8_LE(p, v) \
+ SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0)); \
+ SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
+
+#define SIP_U8TO64_LE(p) \
+ (((uint64_t)((p)[0]) << 0) | \
+ ((uint64_t)((p)[1]) << 8) | \
+ ((uint64_t)((p)[2]) << 16) | \
+ ((uint64_t)((p)[3]) << 24) | \
+ ((uint64_t)((p)[4]) << 32) | \
+ ((uint64_t)((p)[5]) << 40) | \
+ ((uint64_t)((p)[6]) << 48) | \
+ ((uint64_t)((p)[7]) << 56))
+
+
+#define SIPHASH_INITIALIZER { 0, 0, 0, 0, { 0 }, 0, 0 }
+
+struct siphash {
+ uint64_t v0, v1, v2, v3;
+
+ unsigned char buf[8], *p;
+ uint64_t c;
+}; /* struct siphash */
+
+
+#define SIP_KEYLEN 16
+
+struct sipkey {
+ uint64_t k[2];
+}; /* struct sipkey */
+
+#define sip_keyof(k) sip_tokey(&(struct sipkey){ { 0 } }, (k))
+
+static struct sipkey *sip_tokey(struct sipkey *key, const void *src) {
+ key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
+ key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
+ return key;
+} /* sip_tokey() */
+
+
+#define sip_binof(v) sip_tobin((unsigned char[8]){ 0 }, (v))
+
+static void *sip_tobin(void *dst, uint64_t u64) {
+ SIP_U64TO8_LE((unsigned char *)dst, u64);
+ return dst;
+} /* sip_tobin() */
+
+
+static void sip_round(struct siphash *H, const int rounds) {
+ int i;
+
+ for (i = 0; i < rounds; i++) {
+ H->v0 += H->v1;
+ H->v1 = SIP_ROTL(H->v1, 13);
+ H->v1 ^= H->v0;
+ H->v0 = SIP_ROTL(H->v0, 32);
+
+ H->v2 += H->v3;
+ H->v3 = SIP_ROTL(H->v3, 16);
+ H->v3 ^= H->v2;
+
+ H->v0 += H->v3;
+ H->v3 = SIP_ROTL(H->v3, 21);
+ H->v3 ^= H->v0;
+
+ H->v2 += H->v1;
+ H->v1 = SIP_ROTL(H->v1, 17);
+ H->v1 ^= H->v2;
+ H->v2 = SIP_ROTL(H->v2, 32);
+ }
+} /* sip_round() */
+
+
+static struct siphash *sip24_init(struct siphash *H,
+ const struct sipkey *key) {
+ H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
+ H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
+ H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
+ H->v3 = _SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
+
+ H->p = H->buf;
+ H->c = 0;
+
+ return H;
+} /* sip24_init() */
+
+
+#define sip_endof(a) (&(a)[sizeof (a) / sizeof *(a)])
+
+static struct siphash *sip24_update(struct siphash *H, const void *src,
+ size_t len) {
+ const unsigned char *p = (const unsigned char *)src, *pe = p + len;
+ uint64_t m;
+
+ do {
+ while (p < pe && H->p < sip_endof(H->buf))
+ *H->p++ = *p++;
+
+ if (H->p < sip_endof(H->buf))
+ break;
+
+ m = SIP_U8TO64_LE(H->buf);
+ H->v3 ^= m;
+ sip_round(H, 2);
+ H->v0 ^= m;
+
+ H->p = H->buf;
+ H->c += 8;
+ } while (p < pe);
+
+ return H;
+} /* sip24_update() */
+
+
+static uint64_t sip24_final(struct siphash *H) {
+ const char left = (char)(H->p - H->buf);
+ uint64_t b = (H->c + left) << 56;
+
+ switch (left) {
+ case 7: b |= (uint64_t)H->buf[6] << 48;
+ case 6: b |= (uint64_t)H->buf[5] << 40;
+ case 5: b |= (uint64_t)H->buf[4] << 32;
+ case 4: b |= (uint64_t)H->buf[3] << 24;
+ case 3: b |= (uint64_t)H->buf[2] << 16;
+ case 2: b |= (uint64_t)H->buf[1] << 8;
+ case 1: b |= (uint64_t)H->buf[0] << 0;
+ case 0: break;
+ }
+
+ H->v3 ^= b;
+ sip_round(H, 2);
+ H->v0 ^= b;
+ H->v2 ^= 0xff;
+ sip_round(H, 4);
+
+ return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
+} /* sip24_final() */
+
+
+static uint64_t siphash24(const void *src, size_t len,
+ const struct sipkey *key) {
+ struct siphash state = SIPHASH_INITIALIZER;
+ return sip24_final(sip24_update(sip24_init(&state, key), src, len));
+} /* siphash24() */
+
+
+/*
+ * SipHash-2-4 output with
+ * k = 00 01 02 ...
+ * and
+ * in = (empty string)
+ * in = 00 (1 byte)
+ * in = 00 01 (2 bytes)
+ * in = 00 01 02 (3 bytes)
+ * ...
+ * in = 00 01 02 ... 3e (63 bytes)
+ */
+static int sip24_valid(void) {
+ static const unsigned char vectors[64][8] = {
+ { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
+ { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
+ { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
+ { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
+ { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
+ { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
+ { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
+ { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
+ { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
+ { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
+ { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
+ { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
+ { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
+ { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
+ { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
+ { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
+ { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
+ { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
+ { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
+ { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
+ { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
+ { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
+ { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
+ { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
+ { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
+ { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
+ { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
+ { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
+ { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
+ { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
+ { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
+ { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
+ { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
+ { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
+ { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
+ { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
+ { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
+ { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
+ { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
+ { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
+ { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
+ { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
+ { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
+ { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
+ { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
+ { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
+ { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
+ { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
+ { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
+ { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
+ { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
+ { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
+ { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
+ { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
+ { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
+ { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
+ { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
+ { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
+ { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
+ { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
+ { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
+ { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
+ { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
+ { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
+ };
+ unsigned char in[64];
+ struct sipkey k;
+ size_t i;
+
+ sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
+ "\012\013\014\015\016\017");
+
+ for (i = 0; i < sizeof in; ++i) {
+ in[i] = (unsigned char)i;
+
+ if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
+ return 0;
+ }
+
+ return 1;
+} /* sip24_valid() */
+
+
+#ifdef SIPHASH_MAIN
+
+#include <stdio.h>
+
+int main(void) {
+ const int ok = sip24_valid();
+
+ if (ok)
+ puts("OK");
+ else
+ puts("FAIL");
+
+ return !ok;
+} /* main() */
+
+#endif /* SIPHASH_MAIN */
+
+
+#endif /* SIPHASH_H */
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
-*/
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+++ /dev/null
-/* expat_config.h for use with Open Watcom 1.5 and above. */
-
-#ifndef WATCOMCONFIG_H
-#define WATCOMCONFIG_H
-
-#ifdef __NT__
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-#endif
-
-/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
-#define BYTEORDER 1234
-
-/* Define to 1 if you have the `memmove' function. */
-#define HAVE_MEMMOVE 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "expat-bugs@mail.libexpat.org"
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "expat"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "expat 2.0.0"
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "2.0.0"
-
-/* Define to specify how much context to retain around the current parse
- point. */
-#define XML_CONTEXT_BYTES 1024
-
-/* Define to make parameter entity parsing functionality available. */
-#define XML_DTD 1
-
-/* Define to make XML Namespaces functionality available. */
-#define XML_NS 1
-
-#endif
-
-/*================================================================
-** Copyright 2000, Clark Cooper
-** All rights reserved.
-**
-** This is free software. You are permitted to copy, distribute, or modify
-** it under the terms of the MIT/X license (contained in the COPYING file
-** with this distribution.)
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef WINCONFIG_H
#include <memory.h>
#include <string.h>
+
+#if defined(HAVE_EXPAT_CONFIG_H) /* e.g. MinGW */
+# include <expat_config.h>
+#else /* !defined(HAVE_EXPAT_CONFIG_H) */
+
+
#define XML_NS 1
#define XML_DTD 1
#define XML_CONTEXT_BYTES 1024
/* Windows has memmove() available. */
#define HAVE_MEMMOVE
+
+#endif /* !defined(HAVE_EXPAT_CONFIG_H) */
+
+
#endif /* ndef WINCONFIG_H */
-/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/* 8c6b2be7c6281da65ce05218fc15c339f02a811706340824ab596aa86e1fd51a (2.2.4+)
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-#define XML_BUILDING_EXPAT 1
-
-#ifdef COMPILED_FROM_DSP
-#include "winconfig.h"
-#elif defined(MACOS_CLASSIC)
-#include "macconfig.h"
-#elif defined(__amigaos__)
-#include "amigaconfig.h"
-#elif defined(__WATCOMC__)
-#include "watcomconfig.h"
-#elif defined(HAVE_EXPAT_CONFIG_H)
-#include <expat_config.h>
-#endif /* ndef COMPILED_FROM_DSP */
+#if !defined(_GNU_SOURCE)
+# define _GNU_SOURCE 1 /* syscall prototype */
+#endif
#include <stddef.h>
#include <string.h> /* memset(), memcpy() */
#include <assert.h>
#include <limits.h> /* UINT_MAX */
-#include <time.h> /* time() */
+#include <stdio.h> /* fprintf */
+#include <stdlib.h> /* getenv */
+
+#ifdef _WIN32
+#define getpid GetCurrentProcessId
+#else
+#include <sys/time.h> /* gettimeofday() */
+#include <sys/types.h> /* getpid() */
+#include <unistd.h> /* getpid() */
+#include <fcntl.h> /* O_RDONLY */
+#include <errno.h>
+#endif
+
+#define XML_BUILDING_EXPAT 1
+
+#ifdef _WIN32
+#include "winconfig.h"
+#elif defined(HAVE_EXPAT_CONFIG_H)
+#include <expat_config.h>
+#endif /* ndef _WIN32 */
#include "ascii.h"
#include "expat.h"
+#include "siphash.h"
+
+#if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+# if defined(HAVE_GETRANDOM)
+# include <sys/random.h> /* getrandom */
+# else
+# include <unistd.h> /* syscall */
+# include <sys/syscall.h> /* SYS_getrandom */
+# endif
+# if ! defined(GRND_NONBLOCK)
+# define GRND_NONBLOCK 0x0001
+# endif /* defined(GRND_NONBLOCK) */
+#endif /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
+
+#if defined(HAVE_LIBBSD) \
+ && (defined(HAVE_ARC4RANDOM_BUF) || defined(HAVE_ARC4RANDOM))
+# include <bsd/stdlib.h>
+#endif
+
+#if defined(_WIN32) && !defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
+# define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
+#endif
+
+#if !defined(HAVE_GETRANDOM) && !defined(HAVE_SYSCALL_GETRANDOM) \
+ && !defined(HAVE_ARC4RANDOM_BUF) && !defined(HAVE_ARC4RANDOM) \
+ && !defined(XML_DEV_URANDOM) \
+ && !defined(_WIN32) \
+ && !defined(XML_POOR_ENTROPY)
+# error \
+ You do not have support for any sources of high quality entropy \
+ enabled. For end user security, that is probably not what you want. \
+ \
+ Your options include: \
+ * Linux + glibc >=2.25 (getrandom): HAVE_GETRANDOM, \
+ * Linux + glibc <2.25 (syscall SYS_getrandom): HAVE_SYSCALL_GETRANDOM, \
+ * BSD / macOS >=10.7 (arc4random_buf): HAVE_ARC4RANDOM_BUF, \
+ * BSD / macOS <10.7 (arc4random): HAVE_ARC4RANDOM, \
+ * libbsd (arc4random_buf): HAVE_ARC4RANDOM_BUF + HAVE_LIBBSD, \
+ * libbsd (arc4random): HAVE_ARC4RANDOM + HAVE_LIBBSD, \
+ * Linux / BSD / macOS (/dev/urandom): XML_DEV_URANDOM \
+ * Windows (RtlGenRandom): _WIN32. \
+ \
+ If insist on not using any of these, bypass this error by defining \
+ XML_POOR_ENTROPY; you have been warned. \
+ \
+ If you have reasons to patch this detection code away or need changes \
+ to the build system, please open a bug. Thank you!
+#endif
+
#ifdef XML_UNICODE
#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
const XML_Memory_Handling_Suite *mem;
} HASH_TABLE;
-/* Basic character hash algorithm, taken from Python's string hash:
- h = h * 1000003 ^ character, the constant being a prime number.
+static size_t
+keylen(KEY s);
-*/
-#ifdef XML_UNICODE
-#define CHAR_HASH(h, c) \
- (((h) * 0xF4243) ^ (unsigned short)(c))
-#else
-#define CHAR_HASH(h, c) \
- (((h) * 0xF4243) ^ (unsigned char)(c))
-#endif
+static void
+copy_salt_to_sipkey(XML_Parser parser, struct sipkey * key);
/* For probing (after a collision) we need a step size relative prime
to the hash table size, which is a power of 2. We use double-hashing,
const char *end, const char **nextPtr, XML_Bool haveMore);
#endif /* XML_DTD */
+static void
+freeBindings(XML_Parser parser, BINDING *bindings);
static enum XML_Error
storeAtts(XML_Parser parser, const ENCODING *, const char *s,
TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
getElementType(XML_Parser parser, const ENCODING *enc,
const char *ptr, const char *end);
-static unsigned long generate_hash_secret_salt(void);
+static XML_Char *copyString(const XML_Char *s,
+ const XML_Memory_Handling_Suite *memsuite);
+
+static unsigned long generate_hash_secret_salt(XML_Parser parser);
static XML_Bool startParsing(XML_Parser parser);
static XML_Parser
ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'
};
+
+#if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+
+/* Obtain entropy on Linux 3.17+ */
+static int
+writeRandomBytes_getrandom_nonblock(void * target, size_t count) {
+ int success = 0; /* full count bytes written? */
+ size_t bytesWrittenTotal = 0;
+ const unsigned int getrandomFlags = GRND_NONBLOCK;
+
+ do {
+ void * const currentTarget = (void*)((char*)target + bytesWrittenTotal);
+ const size_t bytesToWrite = count - bytesWrittenTotal;
+
+ const int bytesWrittenMore =
+#if defined(HAVE_GETRANDOM)
+ getrandom(currentTarget, bytesToWrite, getrandomFlags);
+#else
+ syscall(SYS_getrandom, currentTarget, bytesToWrite, getrandomFlags);
+#endif
+
+ if (bytesWrittenMore > 0) {
+ bytesWrittenTotal += bytesWrittenMore;
+ if (bytesWrittenTotal >= count)
+ success = 1;
+ }
+ } while (! success && (errno == EINTR));
+
+ return success;
+}
+
+#endif /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
+
+
+#if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+
+/* Extract entropy from /dev/urandom */
+static int
+writeRandomBytes_dev_urandom(void * target, size_t count) {
+ int success = 0; /* full count bytes written? */
+ size_t bytesWrittenTotal = 0;
+
+ const int fd = open("/dev/urandom", O_RDONLY);
+ if (fd < 0) {
+ return 0;
+ }
+
+ do {
+ void * const currentTarget = (void*)((char*)target + bytesWrittenTotal);
+ const size_t bytesToWrite = count - bytesWrittenTotal;
+
+ const ssize_t bytesWrittenMore = read(fd, currentTarget, bytesToWrite);
+
+ if (bytesWrittenMore > 0) {
+ bytesWrittenTotal += bytesWrittenMore;
+ if (bytesWrittenTotal >= count)
+ success = 1;
+ }
+ } while (! success && (errno == EINTR));
+
+ close(fd);
+ return success;
+}
+
+#endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+
+
+#if defined(HAVE_ARC4RANDOM)
+
+static void
+writeRandomBytes_arc4random(void * target, size_t count) {
+ size_t bytesWrittenTotal = 0;
+
+ while (bytesWrittenTotal < count) {
+ const uint32_t random32 = arc4random();
+ size_t i = 0;
+
+ for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
+ i++, bytesWrittenTotal++) {
+ const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
+ ((uint8_t *)target)[bytesWrittenTotal] = random8;
+ }
+ }
+}
+
+#endif /* defined(HAVE_ARC4RANDOM) */
+
+
+#ifdef _WIN32
+
+typedef BOOLEAN (APIENTRY *RTLGENRANDOM_FUNC)(PVOID, ULONG);
+HMODULE _Expat_LoadLibrary(LPCTSTR filename); /* see loadlibrary.c */
+
+/* Obtain entropy on Windows XP / Windows Server 2003 and later.
+ * Hint on RtlGenRandom and the following article from libsodium.
+ *
+ * Michael Howard: Cryptographically Secure Random number on Windows without using CryptoAPI
+ * https://blogs.msdn.microsoft.com/michael_howard/2005/01/14/cryptographically-secure-random-number-on-windows-without-using-cryptoapi/
+ */
+static int
+writeRandomBytes_RtlGenRandom(void * target, size_t count) {
+ int success = 0; /* full count bytes written? */
+ const HMODULE advapi32 = _Expat_LoadLibrary(TEXT("ADVAPI32.DLL"));
+
+ if (advapi32) {
+ const RTLGENRANDOM_FUNC RtlGenRandom
+ = (RTLGENRANDOM_FUNC)GetProcAddress(advapi32, "SystemFunction036");
+ if (RtlGenRandom) {
+ if (RtlGenRandom((PVOID)target, (ULONG)count) == TRUE) {
+ success = 1;
+ }
+ }
+ FreeLibrary(advapi32);
+ }
+
+ return success;
+}
+
+#endif /* _WIN32 */
+
+
+#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
+
static unsigned long
-generate_hash_secret_salt(void)
+gather_time_entropy(void)
{
- unsigned int seed = time(NULL) % UINT_MAX;
- srand(seed);
- return rand();
+#ifdef _WIN32
+ FILETIME ft;
+ GetSystemTimeAsFileTime(&ft); /* never fails */
+ return ft.dwHighDateTime ^ ft.dwLowDateTime;
+#else
+ struct timeval tv;
+ int gettimeofday_res;
+
+ gettimeofday_res = gettimeofday(&tv, NULL);
+
+#if defined(NDEBUG)
+ (void)gettimeofday_res;
+#else
+ assert (gettimeofday_res == 0);
+#endif /* defined(NDEBUG) */
+
+ /* Microseconds time is <20 bits entropy */
+ return tv.tv_usec;
+#endif
+}
+
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
+
+
+static unsigned long
+ENTROPY_DEBUG(const char * label, unsigned long entropy) {
+ const char * const EXPAT_ENTROPY_DEBUG = getenv("EXPAT_ENTROPY_DEBUG");
+ if (EXPAT_ENTROPY_DEBUG && ! strcmp(EXPAT_ENTROPY_DEBUG, "1")) {
+ fprintf(stderr, "Entropy: %s --> 0x%0*lx (%lu bytes)\n",
+ label,
+ (int)sizeof(entropy) * 2, entropy,
+ (unsigned long)sizeof(entropy));
+ }
+ return entropy;
+}
+
+static unsigned long
+generate_hash_secret_salt(XML_Parser parser)
+{
+ unsigned long entropy;
+ (void)parser;
+#if defined(HAVE_ARC4RANDOM_BUF)
+ arc4random_buf(&entropy, sizeof(entropy));
+ return ENTROPY_DEBUG("arc4random_buf", entropy);
+#elif defined(HAVE_ARC4RANDOM)
+ writeRandomBytes_arc4random((void *)&entropy, sizeof(entropy));
+ return ENTROPY_DEBUG("arc4random", entropy);
+#else
+ /* Try high quality providers first .. */
+#ifdef _WIN32
+ if (writeRandomBytes_RtlGenRandom((void *)&entropy, sizeof(entropy))) {
+ return ENTROPY_DEBUG("RtlGenRandom", entropy);
+ }
+#elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+ if (writeRandomBytes_getrandom_nonblock((void *)&entropy, sizeof(entropy))) {
+ return ENTROPY_DEBUG("getrandom", entropy);
+ }
+#endif
+#if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+ if (writeRandomBytes_dev_urandom((void *)&entropy, sizeof(entropy))) {
+ return ENTROPY_DEBUG("/dev/urandom", entropy);
+ }
+#endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+ /* .. and self-made low quality for backup: */
+
+ /* Process ID is 0 bits entropy if attacker has local access */
+ entropy = gather_time_entropy() ^ getpid();
+
+ /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */
+ if (sizeof(unsigned long) == 4) {
+ return ENTROPY_DEBUG("fallback(4)", entropy * 2147483647);
+ } else {
+ return ENTROPY_DEBUG("fallback(8)",
+ entropy * (unsigned long)2305843009213693951ULL);
+ }
+#endif
+}
+
+static unsigned long
+get_hash_secret_salt(XML_Parser parser) {
+ if (parser->m_parentParser != NULL)
+ return get_hash_secret_salt(parser->m_parentParser);
+ return parser->m_hash_secret_salt;
}
static XML_Bool /* only valid for root parser */
{
/* hash functions must be initialized before setContext() is called */
if (hash_secret_salt == 0)
- hash_secret_salt = generate_hash_secret_salt();
+ hash_secret_salt = generate_hash_secret_salt(parser);
if (ns) {
/* implicit context only set for root parser, since child
parsers (i.e. external entity parsers) will inherit it
nsAttsVersion = 0;
nsAttsPower = 0;
+ protocolEncodingName = NULL;
+
poolInit(&tempPool, &(parser->m_mem));
poolInit(&temp2Pool, &(parser->m_mem));
parserInit(parser, encodingName);
{
processor = prologInitProcessor;
XmlPrologStateInit(&prologState);
- protocolEncodingName = (encodingName != NULL
- ? poolCopyString(&tempPool, encodingName)
- : NULL);
+ if (encodingName != NULL) {
+ protocolEncodingName = copyString(encodingName, &(parser->m_mem));
+ }
curBase = NULL;
XmlInitEncoding(&initEncoding, &encoding, 0);
userData = NULL;
{
TAG *tStk;
OPEN_INTERNAL_ENTITY *openEntityList;
+
+ if (parser == NULL)
+ return XML_FALSE;
+
if (parentParser)
return XML_FALSE;
/* move tagStack to freeTagList */
unknownEncodingRelease(unknownEncodingData);
poolClear(&tempPool);
poolClear(&temp2Pool);
+ FREE((void *)protocolEncodingName);
+ protocolEncodingName = NULL;
parserInit(parser, encodingName);
dtdReset(_dtd, &parser->m_mem);
return XML_TRUE;
enum XML_Status XMLCALL
XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
{
+ if (parser == NULL)
+ return XML_STATUS_ERROR;
/* Block after XML_Parse()/XML_ParseBuffer() has been called.
XXX There's no way for the caller to determine which of the
XXX possible error cases caused the XML_STATUS_ERROR return.
*/
if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return XML_STATUS_ERROR;
+
+ /* Get rid of any previous encoding name */
+ FREE((void *)protocolEncodingName);
+
if (encodingName == NULL)
+ /* No new encoding name */
protocolEncodingName = NULL;
else {
- protocolEncodingName = poolCopyString(&tempPool, encodingName);
+ /* Copy the new encoding name into allocated memory */
+ protocolEncodingName = copyString(encodingName, &(parser->m_mem));
if (!protocolEncodingName)
return XML_STATUS_ERROR;
}
{
XML_Parser parser = oldParser;
DTD *newDtd = NULL;
- DTD *oldDtd = _dtd;
- XML_StartElementHandler oldStartElementHandler = startElementHandler;
- XML_EndElementHandler oldEndElementHandler = endElementHandler;
- XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
- XML_ProcessingInstructionHandler oldProcessingInstructionHandler
- = processingInstructionHandler;
- XML_CommentHandler oldCommentHandler = commentHandler;
- XML_StartCdataSectionHandler oldStartCdataSectionHandler
- = startCdataSectionHandler;
- XML_EndCdataSectionHandler oldEndCdataSectionHandler
- = endCdataSectionHandler;
- XML_DefaultHandler oldDefaultHandler = defaultHandler;
- XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler
- = unparsedEntityDeclHandler;
- XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;
- XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler
- = startNamespaceDeclHandler;
- XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler
- = endNamespaceDeclHandler;
- XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;
- XML_ExternalEntityRefHandler oldExternalEntityRefHandler
- = externalEntityRefHandler;
- XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;
- XML_UnknownEncodingHandler oldUnknownEncodingHandler
- = unknownEncodingHandler;
- XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;
- XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;
- XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;
- XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;
- ELEMENT_TYPE * oldDeclElementType = declElementType;
-
- void *oldUserData = userData;
- void *oldHandlerArg = handlerArg;
- XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
- XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
+ DTD *oldDtd;
+ XML_StartElementHandler oldStartElementHandler;
+ XML_EndElementHandler oldEndElementHandler;
+ XML_CharacterDataHandler oldCharacterDataHandler;
+ XML_ProcessingInstructionHandler oldProcessingInstructionHandler;
+ XML_CommentHandler oldCommentHandler;
+ XML_StartCdataSectionHandler oldStartCdataSectionHandler;
+ XML_EndCdataSectionHandler oldEndCdataSectionHandler;
+ XML_DefaultHandler oldDefaultHandler;
+ XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;
+ XML_NotationDeclHandler oldNotationDeclHandler;
+ XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;
+ XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;
+ XML_NotStandaloneHandler oldNotStandaloneHandler;
+ XML_ExternalEntityRefHandler oldExternalEntityRefHandler;
+ XML_SkippedEntityHandler oldSkippedEntityHandler;
+ XML_UnknownEncodingHandler oldUnknownEncodingHandler;
+ XML_ElementDeclHandler oldElementDeclHandler;
+ XML_AttlistDeclHandler oldAttlistDeclHandler;
+ XML_EntityDeclHandler oldEntityDeclHandler;
+ XML_XmlDeclHandler oldXmlDeclHandler;
+ ELEMENT_TYPE * oldDeclElementType;
+
+ void *oldUserData;
+ void *oldHandlerArg;
+ XML_Bool oldDefaultExpandInternalEntities;
+ XML_Parser oldExternalEntityRefHandlerArg;
#ifdef XML_DTD
- enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;
- int oldInEntityValue = prologState.inEntityValue;
+ enum XML_ParamEntityParsing oldParamEntityParsing;
+ int oldInEntityValue;
+#endif
+ XML_Bool oldns_triplets;
+ /* Note that the new parser shares the same hash secret as the old
+ parser, so that dtdCopy and copyEntityTable can lookup values
+ from hash tables associated with either parser without us having
+ to worry which hash secrets each table has.
+ */
+ unsigned long oldhash_secret_salt;
+
+ /* Validate the oldParser parameter before we pull everything out of it */
+ if (oldParser == NULL)
+ return NULL;
+
+ /* Stash the original parser contents on the stack */
+ oldDtd = _dtd;
+ oldStartElementHandler = startElementHandler;
+ oldEndElementHandler = endElementHandler;
+ oldCharacterDataHandler = characterDataHandler;
+ oldProcessingInstructionHandler = processingInstructionHandler;
+ oldCommentHandler = commentHandler;
+ oldStartCdataSectionHandler = startCdataSectionHandler;
+ oldEndCdataSectionHandler = endCdataSectionHandler;
+ oldDefaultHandler = defaultHandler;
+ oldUnparsedEntityDeclHandler = unparsedEntityDeclHandler;
+ oldNotationDeclHandler = notationDeclHandler;
+ oldStartNamespaceDeclHandler = startNamespaceDeclHandler;
+ oldEndNamespaceDeclHandler = endNamespaceDeclHandler;
+ oldNotStandaloneHandler = notStandaloneHandler;
+ oldExternalEntityRefHandler = externalEntityRefHandler;
+ oldSkippedEntityHandler = skippedEntityHandler;
+ oldUnknownEncodingHandler = unknownEncodingHandler;
+ oldElementDeclHandler = elementDeclHandler;
+ oldAttlistDeclHandler = attlistDeclHandler;
+ oldEntityDeclHandler = entityDeclHandler;
+ oldXmlDeclHandler = xmlDeclHandler;
+ oldDeclElementType = declElementType;
+
+ oldUserData = userData;
+ oldHandlerArg = handlerArg;
+ oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
+ oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
+#ifdef XML_DTD
+ oldParamEntityParsing = paramEntityParsing;
+ oldInEntityValue = prologState.inEntityValue;
#endif
- XML_Bool oldns_triplets = ns_triplets;
+ oldns_triplets = ns_triplets;
/* Note that the new parser shares the same hash secret as the old
parser, so that dtdCopy and copyEntityTable can lookup values
from hash tables associated with either parser without us having
to worry which hash secrets each table has.
*/
- unsigned long oldhash_secret_salt = hash_secret_salt;
+ oldhash_secret_salt = hash_secret_salt;
#ifdef XML_DTD
if (!context)
destroyBindings(inheritedBindings, parser);
poolDestroy(&tempPool);
poolDestroy(&temp2Pool);
+ FREE((void *)protocolEncodingName);
#ifdef XML_DTD
/* external parameter entity parsers share the DTD structure
parser->m_dtd with the root parser, so we must not destroy it
void XMLCALL
XML_UseParserAsHandlerArg(XML_Parser parser)
{
- handlerArg = parser;
+ if (parser != NULL)
+ handlerArg = parser;
}
enum XML_Error XMLCALL
XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
{
+ if (parser == NULL)
+ return XML_ERROR_INVALID_ARGUMENT;
#ifdef XML_DTD
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
void XMLCALL
XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)
{
+ if (parser == NULL)
+ return;
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return;
void XMLCALL
XML_SetUserData(XML_Parser parser, void *p)
{
+ if (parser == NULL)
+ return;
if (handlerArg == userData)
handlerArg = userData = p;
else
enum XML_Status XMLCALL
XML_SetBase(XML_Parser parser, const XML_Char *p)
{
+ if (parser == NULL)
+ return XML_STATUS_ERROR;
if (p) {
p = poolCopyString(&_dtd->pool, p);
if (!p)
const XML_Char * XMLCALL
XML_GetBase(XML_Parser parser)
{
+ if (parser == NULL)
+ return NULL;
return curBase;
}
int XMLCALL
XML_GetSpecifiedAttributeCount(XML_Parser parser)
{
+ if (parser == NULL)
+ return -1;
return nSpecifiedAtts;
}
int XMLCALL
XML_GetIdAttributeIndex(XML_Parser parser)
{
+ if (parser == NULL)
+ return -1;
return idAttIndex;
}
const XML_AttrInfo * XMLCALL
XML_GetAttributeInfo(XML_Parser parser)
{
+ if (parser == NULL)
+ return NULL;
return attInfo;
}
#endif
XML_StartElementHandler start,
XML_EndElementHandler end)
{
+ if (parser == NULL)
+ return;
startElementHandler = start;
endElementHandler = end;
}
void XMLCALL
XML_SetStartElementHandler(XML_Parser parser,
XML_StartElementHandler start) {
- startElementHandler = start;
+ if (parser != NULL)
+ startElementHandler = start;
}
void XMLCALL
XML_SetEndElementHandler(XML_Parser parser,
XML_EndElementHandler end) {
- endElementHandler = end;
+ if (parser != NULL)
+ endElementHandler = end;
}
void XMLCALL
XML_SetCharacterDataHandler(XML_Parser parser,
XML_CharacterDataHandler handler)
{
- characterDataHandler = handler;
+ if (parser != NULL)
+ characterDataHandler = handler;
}
void XMLCALL
XML_SetProcessingInstructionHandler(XML_Parser parser,
XML_ProcessingInstructionHandler handler)
{
- processingInstructionHandler = handler;
+ if (parser != NULL)
+ processingInstructionHandler = handler;
}
void XMLCALL
XML_SetCommentHandler(XML_Parser parser,
XML_CommentHandler handler)
{
- commentHandler = handler;
+ if (parser != NULL)
+ commentHandler = handler;
}
void XMLCALL
XML_StartCdataSectionHandler start,
XML_EndCdataSectionHandler end)
{
+ if (parser == NULL)
+ return;
startCdataSectionHandler = start;
endCdataSectionHandler = end;
}
void XMLCALL
XML_SetStartCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start) {
- startCdataSectionHandler = start;
+ if (parser != NULL)
+ startCdataSectionHandler = start;
}
void XMLCALL
XML_SetEndCdataSectionHandler(XML_Parser parser,
XML_EndCdataSectionHandler end) {
- endCdataSectionHandler = end;
+ if (parser != NULL)
+ endCdataSectionHandler = end;
}
void XMLCALL
XML_SetDefaultHandler(XML_Parser parser,
XML_DefaultHandler handler)
{
+ if (parser == NULL)
+ return;
defaultHandler = handler;
defaultExpandInternalEntities = XML_FALSE;
}
XML_SetDefaultHandlerExpand(XML_Parser parser,
XML_DefaultHandler handler)
{
+ if (parser == NULL)
+ return;
defaultHandler = handler;
defaultExpandInternalEntities = XML_TRUE;
}
XML_StartDoctypeDeclHandler start,
XML_EndDoctypeDeclHandler end)
{
+ if (parser == NULL)
+ return;
startDoctypeDeclHandler = start;
endDoctypeDeclHandler = end;
}
void XMLCALL
XML_SetStartDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start) {
- startDoctypeDeclHandler = start;
+ if (parser != NULL)
+ startDoctypeDeclHandler = start;
}
void XMLCALL
XML_SetEndDoctypeDeclHandler(XML_Parser parser,
XML_EndDoctypeDeclHandler end) {
- endDoctypeDeclHandler = end;
+ if (parser != NULL)
+ endDoctypeDeclHandler = end;
}
void XMLCALL
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
XML_UnparsedEntityDeclHandler handler)
{
- unparsedEntityDeclHandler = handler;
+ if (parser != NULL)
+ unparsedEntityDeclHandler = handler;
}
void XMLCALL
XML_SetNotationDeclHandler(XML_Parser parser,
XML_NotationDeclHandler handler)
{
- notationDeclHandler = handler;
+ if (parser != NULL)
+ notationDeclHandler = handler;
}
void XMLCALL
XML_StartNamespaceDeclHandler start,
XML_EndNamespaceDeclHandler end)
{
+ if (parser == NULL)
+ return;
startNamespaceDeclHandler = start;
endNamespaceDeclHandler = end;
}
void XMLCALL
XML_SetStartNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start) {
- startNamespaceDeclHandler = start;
+ if (parser != NULL)
+ startNamespaceDeclHandler = start;
}
void XMLCALL
XML_SetEndNamespaceDeclHandler(XML_Parser parser,
XML_EndNamespaceDeclHandler end) {
- endNamespaceDeclHandler = end;
+ if (parser != NULL)
+ endNamespaceDeclHandler = end;
}
void XMLCALL
XML_SetNotStandaloneHandler(XML_Parser parser,
XML_NotStandaloneHandler handler)
{
- notStandaloneHandler = handler;
+ if (parser != NULL)
+ notStandaloneHandler = handler;
}
void XMLCALL
XML_SetExternalEntityRefHandler(XML_Parser parser,
XML_ExternalEntityRefHandler handler)
{
- externalEntityRefHandler = handler;
+ if (parser != NULL)
+ externalEntityRefHandler = handler;
}
void XMLCALL
XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
{
+ if (parser == NULL)
+ return;
if (arg)
externalEntityRefHandlerArg = (XML_Parser)arg;
else
XML_SetSkippedEntityHandler(XML_Parser parser,
XML_SkippedEntityHandler handler)
{
- skippedEntityHandler = handler;
+ if (parser != NULL)
+ skippedEntityHandler = handler;
}
void XMLCALL
XML_UnknownEncodingHandler handler,
void *data)
{
+ if (parser == NULL)
+ return;
unknownEncodingHandler = handler;
unknownEncodingHandlerData = data;
}
XML_SetElementDeclHandler(XML_Parser parser,
XML_ElementDeclHandler eldecl)
{
- elementDeclHandler = eldecl;
+ if (parser != NULL)
+ elementDeclHandler = eldecl;
}
void XMLCALL
XML_SetAttlistDeclHandler(XML_Parser parser,
XML_AttlistDeclHandler attdecl)
{
- attlistDeclHandler = attdecl;
+ if (parser != NULL)
+ attlistDeclHandler = attdecl;
}
void XMLCALL
XML_SetEntityDeclHandler(XML_Parser parser,
XML_EntityDeclHandler handler)
{
- entityDeclHandler = handler;
+ if (parser != NULL)
+ entityDeclHandler = handler;
}
void XMLCALL
XML_SetXmlDeclHandler(XML_Parser parser,
XML_XmlDeclHandler handler) {
- xmlDeclHandler = handler;
+ if (parser != NULL)
+ xmlDeclHandler = handler;
}
int XMLCALL
XML_SetParamEntityParsing(XML_Parser parser,
enum XML_ParamEntityParsing peParsing)
{
+ if (parser == NULL)
+ return 0;
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return 0;
XML_SetHashSalt(XML_Parser parser,
unsigned long hash_salt)
{
+ if (parser == NULL)
+ return 0;
+ if (parser->m_parentParser)
+ return XML_SetHashSalt(parser->m_parentParser, hash_salt);
/* block after XML_Parse()/XML_ParseBuffer() has been called */
if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return 0;
enum XML_Status XMLCALL
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
{
+ if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
+ if (parser != NULL)
+ parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
+ return XML_STATUS_ERROR;
+ }
switch (ps_parsing) {
case XML_SUSPENDED:
errorCode = XML_ERROR_SUSPENDED;
if (errorCode == XML_ERROR_NONE) {
switch (ps_parsing) {
case XML_SUSPENDED:
+ /* It is hard to be certain, but it seems that this case
+ * cannot occur. This code is cleaning up a previous parse
+ * with no new data (since len == 0). Changing the parsing
+ * state requires getting to execute a handler function, and
+ * there doesn't seem to be an opportunity for that while in
+ * this circumstance.
+ *
+ * Given the uncertainty, we retain the code but exclude it
+ * from coverage tests.
+ *
+ * LCOV_EXCL_START
+ */
XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
positionPtr = bufferPtr;
return XML_STATUS_SUSPENDED;
+ /* LCOV_EXCL_STOP */
case XML_INITIALIZED:
case XML_PARSING:
ps_parsing = XML_FINISHED;
const char *end;
int nLeftOver;
enum XML_Status result;
+ /* Detect overflow (a+b > MAX <==> b > MAX-a) */
+ if (len > ((XML_Size)-1) / 2 - parseEndByteIndex) {
+ errorCode = XML_ERROR_NO_MEMORY;
+ eventPtr = eventEndPtr = NULL;
+ processor = errorProcessor;
+ return XML_STATUS_ERROR;
+ }
parseEndByteIndex += len;
positionPtr = s;
ps_finalBuffer = (XML_Bool)isFinal;
nLeftOver = s + len - end;
if (nLeftOver) {
if (buffer == NULL || nLeftOver > bufferLim - buffer) {
- /* FIXME avoid integer overflow */
- char *temp;
- temp = (buffer == NULL
- ? (char *)MALLOC(len * 2)
- : (char *)REALLOC(buffer, len * 2));
+ /* avoid _signed_ integer overflow */
+ char *temp = NULL;
+ const int bytesToAllocate = (int)((unsigned)len * 2U);
+ if (bytesToAllocate > 0) {
+ temp = (buffer == NULL
+ ? (char *)MALLOC(bytesToAllocate)
+ : (char *)REALLOC(buffer, bytesToAllocate));
+ }
if (temp == NULL) {
errorCode = XML_ERROR_NO_MEMORY;
eventPtr = eventEndPtr = NULL;
return XML_STATUS_ERROR;
}
buffer = temp;
- bufferLim = buffer + len * 2;
+ bufferLim = buffer + bytesToAllocate;
}
memcpy(buffer, end, nLeftOver);
}
const char *start;
enum XML_Status result = XML_STATUS_OK;
+ if (parser == NULL)
+ return XML_STATUS_ERROR;
switch (ps_parsing) {
case XML_SUSPENDED:
errorCode = XML_ERROR_SUSPENDED;
void * XMLCALL
XML_GetBuffer(XML_Parser parser, int len)
{
+ if (parser == NULL)
+ return NULL;
if (len < 0) {
errorCode = XML_ERROR_NO_MEMORY;
return NULL;
if (len > bufferLim - bufferEnd) {
#ifdef XML_CONTEXT_BYTES
int keep;
-#endif
- int neededSize = len + (int)(bufferEnd - bufferPtr);
+#endif /* defined XML_CONTEXT_BYTES */
+ /* Do not invoke signed arithmetic overflow: */
+ int neededSize = (int) ((unsigned)len + (unsigned)(bufferEnd - bufferPtr));
if (neededSize < 0) {
errorCode = XML_ERROR_NO_MEMORY;
return NULL;
}
#ifdef XML_CONTEXT_BYTES
keep = (int)(bufferPtr - buffer);
-
if (keep > XML_CONTEXT_BYTES)
keep = XML_CONTEXT_BYTES;
neededSize += keep;
if (bufferSize == 0)
bufferSize = INIT_BUFFER_SIZE;
do {
- bufferSize *= 2;
+ /* Do not invoke signed arithmetic overflow: */
+ bufferSize = (int) (2U * (unsigned) bufferSize);
} while (bufferSize < neededSize && bufferSize > 0);
if (bufferSize <= 0) {
errorCode = XML_ERROR_NO_MEMORY;
enum XML_Status XMLCALL
XML_StopParser(XML_Parser parser, XML_Bool resumable)
{
+ if (parser == NULL)
+ return XML_STATUS_ERROR;
switch (ps_parsing) {
case XML_SUSPENDED:
if (resumable) {
{
enum XML_Status result = XML_STATUS_OK;
+ if (parser == NULL)
+ return XML_STATUS_ERROR;
if (ps_parsing != XML_SUSPENDED) {
errorCode = XML_ERROR_NOT_SUSPENDED;
return XML_STATUS_ERROR;
void XMLCALL
XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)
{
+ if (parser == NULL)
+ return;
assert(status != NULL);
*status = parser->m_parsingStatus;
}
enum XML_Error XMLCALL
XML_GetErrorCode(XML_Parser parser)
{
+ if (parser == NULL)
+ return XML_ERROR_INVALID_ARGUMENT;
return errorCode;
}
XML_Index XMLCALL
XML_GetCurrentByteIndex(XML_Parser parser)
{
+ if (parser == NULL)
+ return -1;
if (eventPtr)
- return parseEndByteIndex - (parseEndPtr - eventPtr);
+ return (XML_Index)(parseEndByteIndex - (parseEndPtr - eventPtr));
return -1;
}
int XMLCALL
XML_GetCurrentByteCount(XML_Parser parser)
{
+ if (parser == NULL)
+ return 0;
if (eventEndPtr && eventPtr)
return (int)(eventEndPtr - eventPtr);
return 0;
XML_GetInputContext(XML_Parser parser, int *offset, int *size)
{
#ifdef XML_CONTEXT_BYTES
+ if (parser == NULL)
+ return NULL;
if (eventPtr && buffer) {
- *offset = (int)(eventPtr - buffer);
- *size = (int)(bufferEnd - buffer);
+ if (offset != NULL)
+ *offset = (int)(eventPtr - buffer);
+ if (size != NULL)
+ *size = (int)(bufferEnd - buffer);
return buffer;
}
+#else
+ (void)parser;
+ (void)offset;
+ (void)size;
#endif /* defined XML_CONTEXT_BYTES */
return (char *) 0;
}
XML_Size XMLCALL
XML_GetCurrentLineNumber(XML_Parser parser)
{
+ if (parser == NULL)
+ return 0;
if (eventPtr && eventPtr >= positionPtr) {
XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
positionPtr = eventPtr;
XML_Size XMLCALL
XML_GetCurrentColumnNumber(XML_Parser parser)
{
+ if (parser == NULL)
+ return 0;
if (eventPtr && eventPtr >= positionPtr) {
XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
positionPtr = eventPtr;
void XMLCALL
XML_FreeContentModel(XML_Parser parser, XML_Content *model)
{
- FREE(model);
+ if (parser != NULL)
+ FREE(model);
}
void * XMLCALL
XML_MemMalloc(XML_Parser parser, size_t size)
{
+ if (parser == NULL)
+ return NULL;
return MALLOC(size);
}
void * XMLCALL
XML_MemRealloc(XML_Parser parser, void *ptr, size_t size)
{
+ if (parser == NULL)
+ return NULL;
return REALLOC(ptr, size);
}
void XMLCALL
XML_MemFree(XML_Parser parser, void *ptr)
{
- FREE(ptr);
+ if (parser != NULL)
+ FREE(ptr);
}
void XMLCALL
XML_DefaultCurrent(XML_Parser parser)
{
+ if (parser == NULL)
+ return;
if (defaultHandler) {
if (openInternalEntities)
reportDefault(parser,
for (;;) {
int bufSize;
int convLen;
- XmlConvert(enc,
+ const enum XML_Convert_Result convert_res = XmlConvert(enc,
&fromPtr, rawNameEnd,
(ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
convLen = (int)(toPtr - (XML_Char *)tag->buf);
- if (fromPtr == rawNameEnd) {
+ if ((fromPtr >= rawNameEnd) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
tag->name.strLen = convLen;
break;
}
return XML_ERROR_NO_MEMORY;
poolFinish(&tempPool);
result = storeAtts(parser, enc, s, &name, &bindings);
- if (result)
+ if (result != XML_ERROR_NONE) {
+ freeBindings(parser, bindings);
return result;
+ }
poolFinish(&tempPool);
if (startElementHandler) {
startElementHandler(handlerArg, name.str, (const XML_Char **)atts);
if (noElmHandlers && defaultHandler)
reportDefault(parser, enc, s, next);
poolClear(&tempPool);
- while (bindings) {
- BINDING *b = bindings;
- if (endNamespaceDeclHandler)
- endNamespaceDeclHandler(handlerArg, b->prefix->name);
- bindings = bindings->nextTagBinding;
- b->nextTagBinding = freeBindingList;
- freeBindingList = b;
- b->prefix->binding = b->prevPrefixBinding;
- }
+ freeBindings(parser, bindings);
}
if (tagLevel == 0)
return epilogProcessor(parser, next, end, nextPtr);
if (MUST_CONVERT(enc, s)) {
for (;;) {
ICHAR *dataPtr = (ICHAR *)dataBuf;
- XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
+ const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = s;
charDataHandler(handlerArg, dataBuf,
(int)(dataPtr - (ICHAR *)dataBuf));
- if (s == next)
+ if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break;
*eventPP = s;
}
return XML_ERROR_NO_MEMORY;
break;
default:
+ /* All of the tokens produced by XmlContentTok() have their own
+ * explicit cases, so this default is not strictly necessary.
+ * However it is a useful safety net, so we retain the code and
+ * simply exclude it from the coverage tests.
+ *
+ * LCOV_EXCL_START
+ */
if (defaultHandler)
reportDefault(parser, enc, s, next);
break;
+ /* LCOV_EXCL_STOP */
}
*eventPP = s = next;
switch (ps_parsing) {
/* not reached */
}
+/* This function does not call free() on the allocated memory, merely
+ * moving it to the parser's freeBindingList where it can be freed or
+ * reused as appropriate.
+ */
+static void
+freeBindings(XML_Parser parser, BINDING *bindings)
+{
+ while (bindings) {
+ BINDING *b = bindings;
+
+ /* startNamespaceDeclHandler will have been called for this
+ * binding in addBindings(), so call the end handler now.
+ */
+ if (endNamespaceDeclHandler)
+ endNamespaceDeclHandler(handlerArg, b->prefix->name);
+
+ bindings = bindings->nextTagBinding;
+ b->nextTagBinding = freeBindingList;
+ freeBindingList = b;
+ b->prefix->binding = b->prevPrefixBinding;
+ }
+}
+
/* Precondition: all arguments must be non-NULL;
Purpose:
- normalize attributes
#endif
attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
- if (temp == NULL)
+ if (temp == NULL) {
+ attsSize = oldAttsSize;
return XML_ERROR_NO_MEMORY;
+ }
atts = temp;
#ifdef XML_ATTR_INFO
temp2 = (XML_AttrInfo *)REALLOC((void *)attInfo, attsSize * sizeof(XML_AttrInfo));
- if (temp2 == NULL)
+ if (temp2 == NULL) {
+ attsSize = oldAttsSize;
return XML_ERROR_NO_MEMORY;
+ }
attInfo = temp2;
#endif
if (n > oldAttsSize)
int j; /* hash table index */
unsigned long version = nsAttsVersion;
int nsAttsSize = (int)1 << nsAttsPower;
+ unsigned char oldNsAttsPower = nsAttsPower;
/* size of hash table must be at least 2 * (# of prefixed attributes) */
if ((nPrefixes << 1) >> nsAttsPower) { /* true for nsAttsPower = 0 */
NS_ATT *temp;
nsAttsPower = 3;
nsAttsSize = (int)1 << nsAttsPower;
temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));
- if (!temp)
+ if (!temp) {
+ /* Restore actual size of memory in nsAtts */
+ nsAttsPower = oldNsAttsPower;
return XML_ERROR_NO_MEMORY;
+ }
nsAtts = temp;
version = 0; /* force re-initialization of nsAtts hash table */
}
if (s[-1] == 2) { /* prefixed */
ATTRIBUTE_ID *id;
const BINDING *b;
- unsigned long uriHash = hash_secret_salt;
+ unsigned long uriHash;
+ struct siphash sip_state;
+ struct sipkey sip_key;
+
+ copy_salt_to_sipkey(parser, &sip_key);
+ sip24_init(&sip_state, &sip_key);
+
((XML_Char *)s)[-1] = 0; /* clear flag */
id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
- if (!id || !id->prefix)
- return XML_ERROR_NO_MEMORY;
+ if (!id || !id->prefix) {
+ /* This code is walking through the appAtts array, dealing
+ * with (in this case) a prefixed attribute name. To be in
+ * the array, the attribute must have already been bound, so
+ * has to have passed through the hash table lookup once
+ * already. That implies that an entry for it already
+ * exists, so the lookup above will return a pointer to
+ * already allocated memory. There is no opportunaity for
+ * the allocator to fail, so the condition above cannot be
+ * fulfilled.
+ *
+ * Since it is difficult to be certain that the above
+ * analysis is complete, we retain the test and merely
+ * remove the code from coverage tests.
+ */
+ return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
+ }
b = id->prefix->binding;
if (!b)
return XML_ERROR_UNBOUND_PREFIX;
- /* as we expand the name we also calculate its hash value */
for (j = 0; j < b->uriLen; j++) {
const XML_Char c = b->uri[j];
if (!poolAppendChar(&tempPool, c))
return XML_ERROR_NO_MEMORY;
- uriHash = CHAR_HASH(uriHash, c);
}
+
+ sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));
+
while (*s++ != XML_T(ASCII_COLON))
;
+
+ sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));
+
do { /* copies null terminator */
- const XML_Char c = *s;
if (!poolAppendChar(&tempPool, *s))
return XML_ERROR_NO_MEMORY;
- uriHash = CHAR_HASH(uriHash, c);
} while (*s++);
+ uriHash = (unsigned long)sip24_final(&sip_state);
+
{ /* Check hash table for duplicate of expanded name (uriName).
Derived from code in lookup(parser, HASH_TABLE *table, ...).
*/
if (MUST_CONVERT(enc, s)) {
for (;;) {
ICHAR *dataPtr = (ICHAR *)dataBuf;
- XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
+ const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = next;
charDataHandler(handlerArg, dataBuf,
(int)(dataPtr - (ICHAR *)dataBuf));
- if (s == next)
+ if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break;
*eventPP = s;
}
}
return XML_ERROR_UNCLOSED_CDATA_SECTION;
default:
+ /* Every token returned by XmlCdataSectionTok() has its own
+ * explicit case, so this default case will never be executed.
+ * We retain it as a safety net and exclude it from the coverage
+ * statistics.
+ *
+ * LCOV_EXCL_START
+ */
*eventPP = next;
return XML_ERROR_UNEXPECTED_STATE;
+ /* LCOV_EXCL_STOP */
}
*eventPP = s = next;
eventEndPP = &eventEndPtr;
}
else {
+ /* It's not entirely clear, but it seems the following two lines
+ * of code cannot be executed. The only occasions on which 'enc'
+ * is not 'parser->m_encoding' are when this function is called
+ * from the internal entity processing, and IGNORE sections are an
+ * error in internal entities.
+ *
+ * Since it really isn't clear that this is true, we keep the code
+ * and just remove it from our coverage tests.
+ *
+ * LCOV_EXCL_START
+ */
eventPP = &(openInternalEntities->internalEventPtr);
eventEndPP = &(openInternalEntities->internalEventEndPtr);
+ /* LCOV_EXCL_STOP */
}
*eventPP = s;
*startPtr = NULL;
}
return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
default:
+ /* All of the tokens that XmlIgnoreSectionTok() returns have
+ * explicit cases to handle them, so this default case is never
+ * executed. We keep it as a safety net anyway, and remove it
+ * from our test coverage statistics.
+ *
+ * LCOV_EXCL_START
+ */
*eventPP = next;
return XML_ERROR_UNEXPECTED_STATE;
+ /* LCOV_EXCL_STOP */
}
/* not reached */
}
const char *s;
#ifdef XML_UNICODE
char encodingBuf[128];
+ /* See comments abount `protoclEncodingName` in parserInit() */
if (!protocolEncodingName)
s = NULL;
else {
reportDefault(parser, encoding, s, next);
if (protocolEncodingName == NULL) {
if (newEncoding) {
- if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
+ /* Check that the specified encoding does not conflict with what
+ * the parser has already deduced. Do we have the same number
+ * of bytes in the smallest representation of a character? If
+ * this is UTF-16, is it the same endianness?
+ */
+ if (newEncoding->minBytesPerChar != encoding->minBytesPerChar
+ || (newEncoding->minBytesPerChar == 2 &&
+ newEncoding != encoding)) {
eventPtr = encodingName;
return XML_ERROR_INCORRECT_ENCODING;
}
result = processXmlDecl(parser, 0, start, next);
if (result != XML_ERROR_NONE)
return result;
- switch (ps_parsing) {
- case XML_SUSPENDED:
- *nextPtr = next;
- return XML_ERROR_NONE;
- case XML_FINISHED:
+ /* At this point, ps_parsing cannot be XML_SUSPENDED. For that
+ * to happen, a parameter entity parsing handler must have
+ * attempted to suspend the parser, which fails and raises an
+ * error. The parser can be aborted, but can't be suspended.
+ */
+ if (ps_parsing == XML_FINISHED)
return XML_ERROR_ABORTED;
- default:
- *nextPtr = next;
- }
+ *nextPtr = next;
/* stop scanning for text declaration - we found one */
processor = entityValueProcessor;
return entityValueProcessor(parser, next, end, nextPtr);
*nextPtr = next;
return XML_ERROR_NONE;
}
+ /* If we get this token, we have the start of what might be a
+ normal tag, but not a declaration (i.e. it doesn't begin with
+ "<!"). In a DTD context, that isn't legal.
+ */
+ else if (tok == XML_TOK_INSTANCE_START) {
+ *nextPtr = next;
+ return XML_ERROR_SYNTAX;
+ }
start = next;
eventPtr = start;
}
&dtd->paramEntities,
externalSubsetName,
sizeof(ENTITY));
- if (!entity)
- return XML_ERROR_NO_MEMORY;
+ if (!entity) {
+ /* The external subset name "#" will have already been
+ * inserted into the hash table at the start of the
+ * external entity parsing, so no allocation will happen
+ * and lookup() cannot fail.
+ */
+ return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
+ }
if (useForeignDTD)
entity->base = curBase;
dtd->paramEntityRead = XML_FALSE;
if (prologState.level >= groupSize) {
if (groupSize) {
char *temp = (char *)REALLOC(groupConnector, groupSize *= 2);
- if (temp == NULL)
+ if (temp == NULL) {
+ groupSize /= 2;
return XML_ERROR_NO_MEMORY;
+ }
groupConnector = temp;
if (dtd->scaffIndex) {
int *temp = (int *)REALLOC(dtd->scaffIndex,
}
else {
groupConnector = (char *)MALLOC(groupSize = 32);
- if (!groupConnector)
+ if (!groupConnector) {
+ groupSize = 0;
return XML_ERROR_NO_MEMORY;
+ }
}
}
groupConnector[prologState.level] = 0;
: !dtd->hasParamEntityRefs)) {
if (!entity)
return XML_ERROR_UNDEFINED_ENTITY;
- else if (!entity->is_internal)
- return XML_ERROR_ENTITY_DECLARED_IN_PE;
+ else if (!entity->is_internal) {
+ /* It's hard to exhaustively search the code to be sure,
+ * but there doesn't seem to be a way of executing the
+ * following line. There are two cases:
+ *
+ * If 'standalone' is false, the DTD must have no
+ * parameter entities or we wouldn't have passed the outer
+ * 'if' statement. That measn the only entity in the hash
+ * table is the external subset name "#" which cannot be
+ * given as a parameter entity name in XML syntax, so the
+ * lookup must have returned NULL and we don't even reach
+ * the test for an internal entity.
+ *
+ * If 'standalone' is true, it does not seem to be
+ * possible to create entities taking this code path that
+ * are not internal entities, so fail the test above.
+ *
+ * Because this analysis is very uncertain, the code is
+ * being left in place and merely removed from the
+ * coverage test statistics.
+ */
+ return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */
+ }
}
else if (!entity) {
dtd->keepProcessing = dtd->standalone;
openEntity->internalEventEndPtr = NULL;
textStart = (char *)entity->textPtr;
textEnd = (char *)(entity->textPtr + entity->textLen);
+ /* Set a safe default value in case 'next' does not get set */
+ next = textStart;
#ifdef XML_DTD
if (entity->is_param) {
entity = openEntity->entity;
textStart = ((char *)entity->textPtr) + entity->processed;
textEnd = (char *)(entity->textPtr + entity->textLen);
+ /* Set a safe default value in case 'next' does not get set */
+ next = textStart;
#ifdef XML_DTD
if (entity->is_param) {
static enum XML_Error PTRCALL
errorProcessor(XML_Parser parser,
- const char *s,
- const char *end,
- const char **nextPtr)
+ const char *UNUSED_P(s),
+ const char *UNUSED_P(end),
+ const char **UNUSED_P(nextPtr))
{
return errorCode;
}
&& (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
break;
n = XmlEncode(n, (ICHAR *)buf);
- if (!n) {
- if (enc == encoding)
- eventPtr = ptr;
- return XML_ERROR_BAD_CHAR_REF;
- }
+ /* The XmlEncode() functions can never return 0 here. That
+ * error return happens if the code point passed in is either
+ * negative or greater than or equal to 0x110000. The
+ * XmlCharRefNumber() functions will all return a number
+ * strictly less than 0x110000 or a negative value if an error
+ * occurred. The negative value is intercepted above, so
+ * XmlEncode() is never passed a value it might return an
+ * error for.
+ */
for (i = 0; i < n; i++) {
if (!poolAppendChar(pool, buf[i]))
return XML_ERROR_NO_MEMORY;
break;
}
if (entity->open) {
- if (enc == encoding)
- eventPtr = ptr;
+ if (enc == encoding) {
+ /* It does not appear that this line can be executed.
+ *
+ * The "if (entity->open)" check catches recursive entity
+ * definitions. In order to be called with an open
+ * entity, it must have gone through this code before and
+ * been through the recursive call to
+ * appendAttributeValue() some lines below. That call
+ * sets the local encoding ("enc") to the parser's
+ * internal encoding (internal_utf8 or internal_utf16),
+ * which can never be the same as the principle encoding.
+ * It doesn't appear there is another code path that gets
+ * here with entity->open being TRUE.
+ *
+ * Since it is not certain that this logic is watertight,
+ * we keep the line and merely exclude it from coverage
+ * tests.
+ */
+ eventPtr = ptr; /* LCOV_EXCL_LINE */
+ }
return XML_ERROR_RECURSIVE_ENTITY_REF;
}
if (entity->notation) {
}
break;
default:
+ /* The only token returned by XmlAttributeValueTok() that does
+ * not have an explicit case here is XML_TOK_PARTIAL_CHAR.
+ * Getting that would require an entity name to contain an
+ * incomplete XML character (e.g. \xE2\x82); however previous
+ * tokenisers will have already recognised and rejected such
+ * names before XmlAttributeValueTok() gets a look-in. This
+ * default case should be retained as a safety net, but the code
+ * excluded from coverage tests.
+ *
+ * LCOV_EXCL_START
+ */
if (enc == encoding)
eventPtr = ptr;
return XML_ERROR_UNEXPECTED_STATE;
+ /* LCOV_EXCL_STOP */
}
ptr = next;
}
goto endEntityValue;
}
n = XmlEncode(n, (ICHAR *)buf);
- if (!n) {
- if (enc == encoding)
- eventPtr = entityTextPtr;
- result = XML_ERROR_BAD_CHAR_REF;
- goto endEntityValue;
- }
+ /* The XmlEncode() functions can never return 0 here. That
+ * error return happens if the code point passed in is either
+ * negative or greater than or equal to 0x110000. The
+ * XmlCharRefNumber() functions will all return a number
+ * strictly less than 0x110000 or a negative value if an error
+ * occurred. The negative value is intercepted above, so
+ * XmlEncode() is never passed a value it might return an
+ * error for.
+ */
for (i = 0; i < n; i++) {
if (pool->end == pool->ptr && !poolGrow(pool)) {
result = XML_ERROR_NO_MEMORY;
result = XML_ERROR_INVALID_TOKEN;
goto endEntityValue;
default:
+ /* This default case should be unnecessary -- all the tokens
+ * that XmlEntityValueTok() can return have their own explicit
+ * cases -- but should be retained for safety. We do however
+ * exclude it from the coverage statistics.
+ *
+ * LCOV_EXCL_START
+ */
if (enc == encoding)
eventPtr = entityTextPtr;
result = XML_ERROR_UNEXPECTED_STATE;
goto endEntityValue;
+ /* LCOV_EXCL_STOP */
}
entityTextPtr = next;
}
const char *s, const char *end)
{
if (MUST_CONVERT(enc, s)) {
+ enum XML_Convert_Result convert_res;
const char **eventPP;
const char **eventEndPP;
if (enc == encoding) {
eventEndPP = &eventEndPtr;
}
else {
+ /* To get here, two things must be true; the parser must be
+ * using a character encoding that is not the same as the
+ * encoding passed in, and the encoding passed in must need
+ * conversion to the internal format (UTF-8 unless XML_UNICODE
+ * is defined). The only occasions on which the encoding passed
+ * in is not the same as the parser's encoding are when it is
+ * the internal encoding (e.g. a previously defined parameter
+ * entity, already converted to internal format). This by
+ * definition doesn't need conversion, so the whole branch never
+ * gets executed.
+ *
+ * For safety's sake we don't delete these lines and merely
+ * exclude them from coverage statistics.
+ *
+ * LCOV_EXCL_START
+ */
eventPP = &(openInternalEntities->internalEventPtr);
eventEndPP = &(openInternalEntities->internalEventEndPtr);
+ /* LCOV_EXCL_STOP */
}
do {
ICHAR *dataPtr = (ICHAR *)dataBuf;
- XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
+ convert_res = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = s;
defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
*eventPP = s;
- } while (s != end);
+ } while ((convert_res != XML_CONVERT_COMPLETED) && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
}
else
defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
len = dtd->defaultPrefix.binding->uriLen;
if (namespaceSeparator)
len--;
- for (i = 0; i < len; i++)
- if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))
- return NULL;
+ for (i = 0; i < len; i++) {
+ if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i])) {
+ /* Because of memory caching, I don't believe this line can be
+ * executed.
+ *
+ * This is part of a loop copying the default prefix binding
+ * URI into the parser's temporary string pool. Previously,
+ * that URI was copied into the same string pool, with a
+ * terminating NUL character, as part of setContext(). When
+ * the pool was cleared, that leaves a block definitely big
+ * enough to hold the URI on the free block list of the pool.
+ * The URI copy in getContext() therefore cannot run out of
+ * memory.
+ *
+ * If the pool is used between the setContext() and
+ * getContext() calls, the worst it can do is leave a bigger
+ * block on the front of the free list. Given that this is
+ * all somewhat inobvious and program logic can be changed, we
+ * don't delete the line but we do exclude it from the test
+ * coverage statistics.
+ */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
+ }
needSep = XML_TRUE;
}
PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
if (!prefix)
break;
- if (!prefix->binding)
- continue;
+ if (!prefix->binding) {
+ /* This test appears to be (justifiable) paranoia. There does
+ * not seem to be a way of injecting a prefix without a binding
+ * that doesn't get errored long before this function is called.
+ * The test should remain for safety's sake, so we instead
+ * exclude the following line from the coverage statistics.
+ */
+ continue; /* LCOV_EXCL_LINE */
+ }
if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
return NULL;
for (s = prefix->name; *s; s++)
newE->defaultAtts = (DEFAULT_ATTRIBUTE *)
ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
if (!newE->defaultAtts) {
- ms->free_fcn(newE);
return 0;
}
}
return XML_FALSE;
}
+static size_t
+keylen(KEY s)
+{
+ size_t len = 0;
+ for (; *s; s++, len++);
+ return len;
+}
+
+static void
+copy_salt_to_sipkey(XML_Parser parser, struct sipkey * key)
+{
+ key->k[0] = 0;
+ key->k[1] = get_hash_secret_salt(parser);
+}
+
static unsigned long FASTCALL
hash(XML_Parser parser, KEY s)
{
- unsigned long h = hash_secret_salt;
- while (*s)
- h = CHAR_HASH(h, *s++);
- return h;
+ struct siphash state;
+ struct sipkey key;
+ (void)sip_tobin;
+ (void)sip24_valid;
+ copy_salt_to_sipkey(parser, &key);
+ sip24_init(&state, &key);
+ sip24_update(&state, s, keylen(s) * sizeof(XML_Char));
+ return (unsigned long)sip24_final(&state);
}
static NAMED *
if (!pool->ptr && !poolGrow(pool))
return NULL;
for (;;) {
- XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
- if (ptr == end)
+ const enum XML_Convert_Result convert_res = XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
+ if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break;
if (!poolGrow(pool))
return NULL;
static const XML_Char *
poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
{
- if (!pool->ptr && !poolGrow(pool))
- return NULL;
+ if (!pool->ptr && !poolGrow(pool)) {
+ /* The following line is unreachable given the current usage of
+ * poolCopyStringN(). Currently it is called from exactly one
+ * place to copy the text of a simple general entity. By that
+ * point, the name of the entity is already stored in the pool, so
+ * pool->ptr cannot be NULL.
+ *
+ * If poolCopyStringN() is used elsewhere as it well might be,
+ * this line may well become executable again. Regardless, this
+ * sort of check shouldn't be removed lightly, so we just exclude
+ * it from the coverage statistics.
+ */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
for (; n > 0; --n, s++) {
if (!poolAppendChar(pool, *s))
return NULL;
return pool->start;
}
+static size_t
+poolBytesToAllocateFor(int blockSize)
+{
+ /* Unprotected math would be:
+ ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);
+ **
+ ** Detect overflow, avoiding _signed_ overflow undefined behavior
+ ** For a + b * c we check b * c in isolation first, so that addition of a
+ ** on top has no chance of making us accept a small non-negative number
+ */
+ const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */
+
+ if (blockSize <= 0)
+ return 0;
+
+ if (blockSize > (int)(INT_MAX / stretch))
+ return 0;
+
+ {
+ const int stretchedBlockSize = blockSize * (int)stretch;
+ const int bytesToAllocate = (int)(
+ offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);
+ if (bytesToAllocate < 0)
+ return 0;
+
+ return (size_t)bytesToAllocate;
+ }
+}
+
static XML_Bool FASTCALL
poolGrow(STRING_POOL *pool)
{
}
}
if (pool->blocks && pool->start == pool->blocks->s) {
- int blockSize = (int)(pool->end - pool->start)*2;
- BLOCK *temp = (BLOCK *)
- pool->mem->realloc_fcn(pool->blocks,
- (offsetof(BLOCK, s)
- + blockSize * sizeof(XML_Char)));
+ BLOCK *temp;
+ int blockSize = (int)((unsigned)(pool->end - pool->start)*2U);
+ size_t bytesToAllocate;
+
+ // NOTE: Needs to be calculated prior to calling `realloc`
+ // to avoid dangling pointers:
+ const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;
+
+ if (blockSize < 0) {
+ /* This condition traps a situation where either more than
+ * INT_MAX/2 bytes have already been allocated. This isn't
+ * readily testable, since it is unlikely that an average
+ * machine will have that much memory, so we exclude it from the
+ * coverage statistics.
+ */
+ return XML_FALSE; /* LCOV_EXCL_LINE */
+ }
+
+ bytesToAllocate = poolBytesToAllocateFor(blockSize);
+ if (bytesToAllocate == 0)
+ return XML_FALSE;
+
+ temp = (BLOCK *)
+ pool->mem->realloc_fcn(pool->blocks, (unsigned)bytesToAllocate);
if (temp == NULL)
return XML_FALSE;
pool->blocks = temp;
pool->blocks->size = blockSize;
- pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
+ pool->ptr = pool->blocks->s + offsetInsideBlock;
pool->start = pool->blocks->s;
pool->end = pool->start + blockSize;
}
else {
BLOCK *tem;
int blockSize = (int)(pool->end - pool->start);
+ size_t bytesToAllocate;
+
+ if (blockSize < 0) {
+ /* This condition traps a situation where either more than
+ * INT_MAX bytes have already been allocated (which is prevented
+ * by various pieces of program logic, not least this one, never
+ * mind the unlikelihood of actually having that much memory) or
+ * the pool control fields have been corrupted (which could
+ * conceivably happen in an extremely buggy user handler
+ * function). Either way it isn't readily testable, so we
+ * exclude it from the coverage statistics.
+ */
+ return XML_FALSE; /* LCOV_EXCL_LINE */
+ }
+
if (blockSize < INIT_BLOCK_SIZE)
blockSize = INIT_BLOCK_SIZE;
- else
+ else {
+ /* Detect overflow, avoiding _signed_ overflow undefined behavior */
+ if ((int)((unsigned)blockSize * 2U) < 0) {
+ return XML_FALSE;
+ }
blockSize *= 2;
- tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s)
- + blockSize * sizeof(XML_Char));
+ }
+
+ bytesToAllocate = poolBytesToAllocateFor(blockSize);
+ if (bytesToAllocate == 0)
+ return XML_FALSE;
+
+ tem = (BLOCK *)pool->mem->malloc_fcn(bytesToAllocate);
if (!tem)
return XML_FALSE;
tem->size = blockSize;
}
return ret;
}
+
+static XML_Char *
+copyString(const XML_Char *s,
+ const XML_Memory_Handling_Suite *memsuite)
+{
+ int charsRequired = 0;
+ XML_Char *result;
+
+ /* First determine how long the string is */
+ while (s[charsRequired] != 0) {
+ charsRequired++;
+ }
+ /* Include the terminator */
+ charsRequired++;
+
+ /* Now allocate space for the copy */
+ result = memsuite->malloc_fcn(charsRequired * sizeof(XML_Char));
+ if (result == NULL)
+ return NULL;
+ /* Copy the original into place */
+ memcpy(result, s, charsRequired * sizeof(XML_Char));
+ return result;
+}
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stddef.h>
-#ifdef COMPILED_FROM_DSP
+#ifdef _WIN32
#include "winconfig.h"
-#elif defined(MACOS_CLASSIC)
-#include "macconfig.h"
-#elif defined(__amigaos__)
-#include "amigaconfig.h"
-#elif defined(__WATCOMC__)
-#include "watcomconfig.h"
#else
#ifdef HAVE_EXPAT_CONFIG_H
#include <expat_config.h>
#endif
-#endif /* ndef COMPILED_FROM_DSP */
+#endif /* ndef _WIN32 */
#include "expat_external.h"
#include "internal.h"
case XML_TOK_COMMENT:
return XML_ROLE_COMMENT;
case XML_TOK_BOM:
- return XML_ROLE_NONE;
+ /* This case can never arise. To reach this role function, the
+ * parse must have passed through prolog0 and therefore have had
+ * some form of input, even if only a space. At that point, a
+ * byte order mark is no longer a valid character (though
+ * technically it should be interpreted as a non-breaking space),
+ * so will be rejected by the tokenizing stages.
+ */
+ return XML_ROLE_NONE; /* LCOV_EXCL_LINE */
case XML_TOK_DECL_OPEN:
if (!XmlNameMatchesAscii(enc,
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
static int PTRCALL
prolog2(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
doctype0(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
doctype2(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
doctype3(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
doctype4(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
doctype5(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity0(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity1(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity3(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity4(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity6(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity8(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity9(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
entity10(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
notation0(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
notation2(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
notation3(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
notation4(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist0(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist1(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist3(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist4(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist5(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist6(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist7(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
attlist9(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
element0(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
element3(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
element4(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
element5(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
element6(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
element7(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
condSect1(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
condSect2(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
static int PTRCALL
declClose(PROLOG_STATE *state,
int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
switch (tok) {
case XML_TOK_PROLOG_S:
return common(state, tok);
}
+/* This function will only be invoked if the internal logic of the
+ * parser has broken down. It is used in two cases:
+ *
+ * 1: When the XML prolog has been finished. At this point the
+ * processor (the parser level above these role handlers) should
+ * switch from prologProcessor to contentProcessor and reinitialise
+ * the handler function.
+ *
+ * 2: When an error has been detected (via common() below). At this
+ * point again the processor should be switched to errorProcessor,
+ * which will never call a handler.
+ *
+ * The result of this is that error() can only be called if the
+ * processor switch failed to happen, which is an internal error and
+ * therefore we shouldn't be able to provoke it simply by using the
+ * library. It is a necessary backstop, however, so we merely exclude
+ * it from the coverage statistics.
+ *
+ * LCOV_EXCL_START
+ */
static int PTRCALL
-error(PROLOG_STATE *state,
- int tok,
- const char *ptr,
- const char *end,
- const ENCODING *enc)
+error(PROLOG_STATE *UNUSED_P(state),
+ int UNUSED_P(tok),
+ const char *UNUSED_P(ptr),
+ const char *UNUSED_P(end),
+ const ENCODING *UNUSED_P(enc))
{
return XML_ROLE_NONE;
}
+/* LCOV_EXCL_STOP */
static int FASTCALL
common(PROLOG_STATE *state, int tok)
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef XmlRole_INCLUDED
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stddef.h>
+#include <string.h> // memcpy
-#ifdef COMPILED_FROM_DSP
+#if defined(_MSC_VER) && (_MSC_VER <= 1700)
+ /* for vs2012/11.0/1700 and earlier Visual Studio compilers */
+# define bool int
+# define false 0
+# define true 1
+#else
+# include <stdbool.h>
+#endif
+
+
+#ifdef _WIN32
#include "winconfig.h"
-#elif defined(MACOS_CLASSIC)
-#include "macconfig.h"
-#elif defined(__amigaos__)
-#include "amigaconfig.h"
-#elif defined(__WATCOMC__)
-#include "watcomconfig.h"
#else
#ifdef HAVE_EXPAT_CONFIG_H
#include <expat_config.h>
#endif
-#endif /* ndef COMPILED_FROM_DSP */
+#endif /* ndef _WIN32 */
#include "expat_external.h"
#include "internal.h"
#define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
#define UCS2_GET_NAMING(pages, hi, lo) \
- (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1 << ((lo) & 0x1F)))
+ (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F)))
/* A 2 byte UTF-8 representation splits the characters 11 bits between
the bottom 5 and 6 bits of the bytes. We need 8 bits to index into
(namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \
+ ((((byte)[0]) & 3) << 1) \
+ ((((byte)[1]) >> 5) & 1)] \
- & (1 << (((byte)[1]) & 0x1F)))
+ & (1u << (((byte)[1]) & 0x1F)))
/* A 3 byte UTF-8 representation splits the characters 16 bits between
the bottom 4, 6 and 6 bits of the bytes. We need 8 bits to index
<< 3) \
+ ((((byte)[1]) & 3) << 1) \
+ ((((byte)[2]) >> 5) & 1)] \
- & (1 << (((byte)[2]) & 0x1F)))
+ & (1u << (((byte)[2]) & 0x1F)))
#define UTF8_GET_NAMING(pages, p, n) \
((n) == 2 \
((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
static int PTRFASTCALL
-isNever(const ENCODING *enc, const char *p)
+isNever(const ENCODING *UNUSED_P(enc), const char *UNUSED_P(p))
{
return 0;
}
static int PTRFASTCALL
-utf8_isName2(const ENCODING *enc, const char *p)
+utf8_isName2(const ENCODING *UNUSED_P(enc), const char *p)
{
return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
}
static int PTRFASTCALL
-utf8_isName3(const ENCODING *enc, const char *p)
+utf8_isName3(const ENCODING *UNUSED_P(enc), const char *p)
{
return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
}
#define utf8_isName4 isNever
static int PTRFASTCALL
-utf8_isNmstrt2(const ENCODING *enc, const char *p)
+utf8_isNmstrt2(const ENCODING *UNUSED_P(enc), const char *p)
{
return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
}
static int PTRFASTCALL
-utf8_isNmstrt3(const ENCODING *enc, const char *p)
+utf8_isNmstrt3(const ENCODING *UNUSED_P(enc), const char *p)
{
return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
}
#define utf8_isNmstrt4 isNever
static int PTRFASTCALL
-utf8_isInvalid2(const ENCODING *enc, const char *p)
+utf8_isInvalid2(const ENCODING *UNUSED_P(enc), const char *p)
{
return UTF8_INVALID2((const unsigned char *)p);
}
static int PTRFASTCALL
-utf8_isInvalid3(const ENCODING *enc, const char *p)
+utf8_isInvalid3(const ENCODING *UNUSED_P(enc), const char *p)
{
return UTF8_INVALID3((const unsigned char *)p);
}
static int PTRFASTCALL
-utf8_isInvalid4(const ENCODING *enc, const char *p)
+utf8_isInvalid4(const ENCODING *UNUSED_P(enc), const char *p)
{
return UTF8_INVALID4((const unsigned char *)p);
}
E ## isInvalid3, \
E ## isInvalid4
+#define NULL_VTABLE \
+ /* isName2 */ NULL, \
+ /* isName3 */ NULL, \
+ /* isName4 */ NULL, \
+ /* isNmstrt2 */ NULL, \
+ /* isNmstrt3 */ NULL, \
+ /* isNmstrt4 */ NULL, \
+ /* isInvalid2 */ NULL, \
+ /* isInvalid3 */ NULL, \
+ /* isInvalid4 */ NULL
+
static int FASTCALL checkCharRefNumber(int);
#include "xmltok_impl.h"
UTF8_cval4 = 0xf0
};
-static void PTRCALL
-utf8_toUtf8(const ENCODING *enc,
+void
+align_limit_to_full_utf8_characters(const char * from, const char ** fromLimRef)
+{
+ const char * fromLim = *fromLimRef;
+ size_t walked = 0;
+ for (; fromLim > from; fromLim--, walked++) {
+ const unsigned char prev = (unsigned char)fromLim[-1];
+ if ((prev & 0xf8u) == 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */
+ if (walked + 1 >= 4) {
+ fromLim += 4 - 1;
+ break;
+ } else {
+ walked = 0;
+ }
+ } else if ((prev & 0xf0u) == 0xe0u) { /* 3-byte character, lead by 0b1110xxxx byte */
+ if (walked + 1 >= 3) {
+ fromLim += 3 - 1;
+ break;
+ } else {
+ walked = 0;
+ }
+ } else if ((prev & 0xe0u) == 0xc0u) { /* 2-byte character, lead by 0b110xxxxx byte */
+ if (walked + 1 >= 2) {
+ fromLim += 2 - 1;
+ break;
+ } else {
+ walked = 0;
+ }
+ } else if ((prev & 0x80u) == 0x00u) { /* 1-byte character, matching 0b0xxxxxxx */
+ break;
+ }
+ }
+ *fromLimRef = fromLim;
+}
+
+static enum XML_Convert_Result PTRCALL
+utf8_toUtf8(const ENCODING *UNUSED_P(enc),
const char **fromP, const char *fromLim,
char **toP, const char *toLim)
{
- char *to;
- const char *from;
- if (fromLim - *fromP > toLim - *toP) {
- /* Avoid copying partial characters. */
- for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
- if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
- break;
+ bool input_incomplete = false;
+ bool output_exhausted = false;
+
+ /* Avoid copying partial characters (due to limited space). */
+ const ptrdiff_t bytesAvailable = fromLim - *fromP;
+ const ptrdiff_t bytesStorable = toLim - *toP;
+ if (bytesAvailable > bytesStorable) {
+ fromLim = *fromP + bytesStorable;
+ output_exhausted = true;
}
- for (to = *toP, from = *fromP; from != fromLim; from++, to++)
- *to = *from;
- *fromP = from;
- *toP = to;
+
+ /* Avoid copying partial characters (from incomplete input). */
+ {
+ const char * const fromLimBefore = fromLim;
+ align_limit_to_full_utf8_characters(*fromP, &fromLim);
+ if (fromLim < fromLimBefore) {
+ input_incomplete = true;
+ }
+ }
+
+ {
+ const ptrdiff_t bytesToCopy = fromLim - *fromP;
+ memcpy((void *)*toP, (const void *)*fromP, (size_t)bytesToCopy);
+ *fromP += bytesToCopy;
+ *toP += bytesToCopy;
+ }
+
+ if (output_exhausted) // needs to go first
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
+ else if (input_incomplete)
+ return XML_CONVERT_INPUT_INCOMPLETE;
+ else
+ return XML_CONVERT_COMPLETED;
}
-static void PTRCALL
+static enum XML_Convert_Result PTRCALL
utf8_toUtf16(const ENCODING *enc,
const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim)
{
+ enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
unsigned short *to = *toP;
const char *from = *fromP;
- while (from != fromLim && to != toLim) {
+ while (from < fromLim && to < toLim) {
switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
case BT_LEAD2:
+ if (fromLim - from < 2) {
+ res = XML_CONVERT_INPUT_INCOMPLETE;
+ goto after;
+ }
*to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
from += 2;
break;
case BT_LEAD3:
+ if (fromLim - from < 3) {
+ res = XML_CONVERT_INPUT_INCOMPLETE;
+ goto after;
+ }
*to++ = (unsigned short)(((from[0] & 0xf) << 12)
| ((from[1] & 0x3f) << 6) | (from[2] & 0x3f));
from += 3;
case BT_LEAD4:
{
unsigned long n;
- if (to + 1 == toLim)
+ if (toLim - to < 2) {
+ res = XML_CONVERT_OUTPUT_EXHAUSTED;
goto after;
+ }
+ if (fromLim - from < 4) {
+ res = XML_CONVERT_INPUT_INCOMPLETE;
+ goto after;
+ }
n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
| ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
n -= 0x10000;
break;
}
}
+ if (from < fromLim)
+ res = XML_CONVERT_OUTPUT_EXHAUSTED;
after:
*fromP = from;
*toP = to;
+ return res;
}
#ifdef XML_NS
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
};
-static void PTRCALL
-latin1_toUtf8(const ENCODING *enc,
+static enum XML_Convert_Result PTRCALL
+latin1_toUtf8(const ENCODING *UNUSED_P(enc),
const char **fromP, const char *fromLim,
char **toP, const char *toLim)
{
for (;;) {
unsigned char c;
if (*fromP == fromLim)
- break;
+ return XML_CONVERT_COMPLETED;
c = (unsigned char)**fromP;
if (c & 0x80) {
if (toLim - *toP < 2)
- break;
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
*(*toP)++ = (char)((c >> 6) | UTF8_cval2);
*(*toP)++ = (char)((c & 0x3f) | 0x80);
(*fromP)++;
}
else {
if (*toP == toLim)
- break;
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
*(*toP)++ = *(*fromP)++;
}
}
}
-static void PTRCALL
-latin1_toUtf16(const ENCODING *enc,
+static enum XML_Convert_Result PTRCALL
+latin1_toUtf16(const ENCODING *UNUSED_P(enc),
const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim)
{
- while (*fromP != fromLim && *toP != toLim)
+ while (*fromP < fromLim && *toP < toLim)
*(*toP)++ = (unsigned char)*(*fromP)++;
+
+ if ((*toP == toLim) && (*fromP < fromLim))
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
+ else
+ return XML_CONVERT_COMPLETED;
}
#ifdef XML_NS
#include "asciitab.h"
#include "latin1tab.h"
},
- STANDARD_VTABLE(sb_)
+ STANDARD_VTABLE(sb_) NULL_VTABLE
};
#endif
#undef BT_COLON
#include "latin1tab.h"
},
- STANDARD_VTABLE(sb_)
+ STANDARD_VTABLE(sb_) NULL_VTABLE
};
-static void PTRCALL
-ascii_toUtf8(const ENCODING *enc,
+static enum XML_Convert_Result PTRCALL
+ascii_toUtf8(const ENCODING *UNUSED_P(enc),
const char **fromP, const char *fromLim,
char **toP, const char *toLim)
{
- while (*fromP != fromLim && *toP != toLim)
+ while (*fromP < fromLim && *toP < toLim)
*(*toP)++ = *(*fromP)++;
+
+ if ((*toP == toLim) && (*fromP < fromLim))
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
+ else
+ return XML_CONVERT_COMPLETED;
}
#ifdef XML_NS
#include "asciitab.h"
/* BT_NONXML == 0 */
},
- STANDARD_VTABLE(sb_)
+ STANDARD_VTABLE(sb_) NULL_VTABLE
};
#endif
#undef BT_COLON
/* BT_NONXML == 0 */
},
- STANDARD_VTABLE(sb_)
+ STANDARD_VTABLE(sb_) NULL_VTABLE
};
static int PTRFASTCALL
}
#define DEFINE_UTF16_TO_UTF8(E) \
-static void PTRCALL \
-E ## toUtf8(const ENCODING *enc, \
+static enum XML_Convert_Result PTRCALL \
+E ## toUtf8(const ENCODING *UNUSED_P(enc), \
const char **fromP, const char *fromLim, \
char **toP, const char *toLim) \
{ \
- const char *from; \
- for (from = *fromP; from != fromLim; from += 2) { \
+ const char *from = *fromP; \
+ fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */ \
+ for (; from < fromLim; from += 2) { \
int plane; \
unsigned char lo2; \
unsigned char lo = GET_LO(from); \
if (lo < 0x80) { \
if (*toP == toLim) { \
*fromP = from; \
- return; \
+ return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
*(*toP)++ = lo; \
break; \
case 0x4: case 0x5: case 0x6: case 0x7: \
if (toLim - *toP < 2) { \
*fromP = from; \
- return; \
+ return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
*(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2); \
*(*toP)++ = ((lo & 0x3f) | 0x80); \
default: \
if (toLim - *toP < 3) { \
*fromP = from; \
- return; \
+ return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
/* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
*(*toP)++ = ((hi >> 4) | UTF8_cval3); \
case 0xD8: case 0xD9: case 0xDA: case 0xDB: \
if (toLim - *toP < 4) { \
*fromP = from; \
- return; \
+ return XML_CONVERT_OUTPUT_EXHAUSTED; \
+ } \
+ if (fromLim - from < 4) { \
+ *fromP = from; \
+ return XML_CONVERT_INPUT_INCOMPLETE; \
} \
plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
*(*toP)++ = ((plane >> 2) | UTF8_cval4); \
} \
} \
*fromP = from; \
+ if (from < fromLim) \
+ return XML_CONVERT_INPUT_INCOMPLETE; \
+ else \
+ return XML_CONVERT_COMPLETED; \
}
#define DEFINE_UTF16_TO_UTF16(E) \
-static void PTRCALL \
-E ## toUtf16(const ENCODING *enc, \
+static enum XML_Convert_Result PTRCALL \
+E ## toUtf16(const ENCODING *UNUSED_P(enc), \
const char **fromP, const char *fromLim, \
unsigned short **toP, const unsigned short *toLim) \
{ \
+ enum XML_Convert_Result res = XML_CONVERT_COMPLETED; \
+ fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */ \
/* Avoid copying first half only of surrogate */ \
if (fromLim - *fromP > ((toLim - *toP) << 1) \
- && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \
+ && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) { \
fromLim -= 2; \
- for (; *fromP != fromLim && *toP != toLim; *fromP += 2) \
+ res = XML_CONVERT_INPUT_INCOMPLETE; \
+ } \
+ for (; *fromP < fromLim && *toP < toLim; *fromP += 2) \
*(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
+ if ((*toP == toLim) && (*fromP < fromLim)) \
+ return XML_CONVERT_OUTPUT_EXHAUSTED; \
+ else \
+ return res; \
}
#define SET2(ptr, ch) \
#include "asciitab.h"
#include "latin1tab.h"
},
- STANDARD_VTABLE(little2_)
+ STANDARD_VTABLE(little2_) NULL_VTABLE
};
#endif
#undef BT_COLON
#include "latin1tab.h"
},
- STANDARD_VTABLE(little2_)
+ STANDARD_VTABLE(little2_) NULL_VTABLE
};
#if BYTEORDER != 4321
#include "iasciitab.h"
#include "latin1tab.h"
},
- STANDARD_VTABLE(little2_)
+ STANDARD_VTABLE(little2_) NULL_VTABLE
};
#endif
#undef BT_COLON
#include "latin1tab.h"
},
- STANDARD_VTABLE(little2_)
+ STANDARD_VTABLE(little2_) NULL_VTABLE
};
#endif
#include "asciitab.h"
#include "latin1tab.h"
},
- STANDARD_VTABLE(big2_)
+ STANDARD_VTABLE(big2_) NULL_VTABLE
};
#endif
#undef BT_COLON
#include "latin1tab.h"
},
- STANDARD_VTABLE(big2_)
+ STANDARD_VTABLE(big2_) NULL_VTABLE
};
#if BYTEORDER != 1234
#include "iasciitab.h"
#include "latin1tab.h"
},
- STANDARD_VTABLE(big2_)
+ STANDARD_VTABLE(big2_) NULL_VTABLE
};
#endif
#undef BT_COLON
#include "latin1tab.h"
},
- STANDARD_VTABLE(big2_)
+ STANDARD_VTABLE(big2_) NULL_VTABLE
};
#endif
if (ASCII_a <= c1 && c1 <= ASCII_z)
c1 += ASCII_A - ASCII_a;
if (ASCII_a <= c2 && c2 <= ASCII_z)
- c2 += ASCII_A - ASCII_a;
+ /* The following line will never get executed. streqci() is
+ * only called from two places, both of which guarantee to put
+ * upper-case strings into s2.
+ */
+ c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */
if (c1 != c2)
return 0;
if (!c1)
}
static void PTRCALL
-initUpdatePosition(const ENCODING *enc, const char *ptr,
+initUpdatePosition(const ENCODING *UNUSED_P(enc), const char *ptr,
const char *end, POSITION *pos)
{
normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
};
if (c < 0)
- return 0;
+ return 0; /* LCOV_EXCL_LINE: this case is always eliminated beforehand */
if (c < min2) {
buf[0] = (char)(c | UTF8_cval1);
return 1;
buf[3] = (char)((c & 0x3f) | 0x80);
return 4;
}
- return 0;
+ return 0; /* LCOV_EXCL_LINE: this case too is eliminated before calling */
}
int FASTCALL
return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
}
-static void PTRCALL
+static enum XML_Convert_Result PTRCALL
unknown_toUtf8(const ENCODING *enc,
const char **fromP, const char *fromLim,
char **toP, const char *toLim)
const char *utf8;
int n;
if (*fromP == fromLim)
- break;
+ return XML_CONVERT_COMPLETED;
utf8 = uenc->utf8[(unsigned char)**fromP];
n = *utf8++;
if (n == 0) {
int c = uenc->convert(uenc->userData, *fromP);
n = XmlUtf8Encode(c, buf);
if (n > toLim - *toP)
- break;
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
utf8 = buf;
*fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
- (BT_LEAD2 - 2));
}
else {
if (n > toLim - *toP)
- break;
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
(*fromP)++;
}
do {
}
}
-static void PTRCALL
+static enum XML_Convert_Result PTRCALL
unknown_toUtf16(const ENCODING *enc,
const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim)
{
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
- while (*fromP != fromLim && *toP != toLim) {
+ while (*fromP < fromLim && *toP < toLim) {
unsigned short c = uenc->utf16[(unsigned char)**fromP];
if (c == 0) {
c = (unsigned short)
(*fromP)++;
*(*toP)++ = c;
}
+
+ if ((*toP == toLim) && (*fromP < fromLim))
+ return XML_CONVERT_OUTPUT_EXHAUSTED;
+ else
+ return XML_CONVERT_COMPLETED;
}
ENCODING *
else if (c < 0) {
if (c < -4)
return 0;
+ /* Multi-byte sequences need a converter function */
+ if (!convert)
+ return 0;
e->normal.type[i] = (unsigned char)(BT_LEAD2 - (c + 2));
e->utf8[i][0] = 0;
e->utf16[i] = 0;
{
const ENCODING **encPtr;
- if (ptr == end)
+ if (ptr >= end)
return XML_TOK_NONE;
encPtr = enc->encPtr;
if (ptr + 1 == end) {
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/*
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef XmlTok_INCLUDED
const char *,
const char **);
+enum XML_Convert_Result {
+ XML_CONVERT_COMPLETED = 0,
+ XML_CONVERT_INPUT_INCOMPLETE = 1,
+ XML_CONVERT_OUTPUT_EXHAUSTED = 2 /* and therefore potentially input remaining as well */
+};
+
struct encoding {
SCANNER scanners[XML_N_STATES];
SCANNER literalScanners[XML_N_LITERAL_TYPES];
const char *ptr,
const char *end,
const char **badPtr);
- void (PTRCALL *utf8Convert)(const ENCODING *enc,
+ enum XML_Convert_Result (PTRCALL *utf8Convert)(const ENCODING *enc,
const char **fromP,
const char *fromLim,
char **toP,
const char *toLim);
- void (PTRCALL *utf16Convert)(const ENCODING *enc,
+ enum XML_Convert_Result (PTRCALL *utf16Convert)(const ENCODING *enc,
const char **fromP,
const char *fromLim,
unsigned short **toP,
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/* This file is included!
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-/* This file is included! */
#ifdef XML_TOK_IMPL_C
#ifndef IS_INVALID_CHAR
#define PREFIX(ident) ident
#endif
+
+#define HAS_CHARS(enc, ptr, end, count) \
+ (end - ptr >= count * MINBPC(enc))
+
+#define HAS_CHAR(enc, ptr, end) \
+ HAS_CHARS(enc, ptr, end, 1)
+
+#define REQUIRE_CHARS(enc, ptr, end, count) \
+ { \
+ if (! HAS_CHARS(enc, ptr, end, count)) { \
+ return XML_TOK_PARTIAL; \
+ } \
+ }
+
+#define REQUIRE_CHAR(enc, ptr, end) \
+ REQUIRE_CHARS(enc, ptr, end, 1)
+
+
/* ptr points to character following "<!-" */
static int PTRCALL
PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr)
{
- if (ptr != end) {
+ if (HAS_CHAR(enc, ptr, end)) {
if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
ptr += MINBPC(enc);
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr)
case BT_MINUS:
- if ((ptr += MINBPC(enc)) == end)
- return XML_TOK_PARTIAL;
+ ptr += MINBPC(enc);
+ REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
- if ((ptr += MINBPC(enc)) == end)
- return XML_TOK_PARTIAL;
+ ptr += MINBPC(enc);
+ REQUIRE_CHAR(enc, ptr, end);
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr)
{
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_MINUS:
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_PERCNT:
- if (ptr + MINBPC(enc) == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHARS(enc, ptr, end, 2);
/* don't allow <!ENTITY% foo "whatever"> */
switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
}
static int PTRCALL
-PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
+PREFIX(checkPiTarget)(const ENCODING *UNUSED_P(enc), const char *ptr,
const char *end, int *tokPtr)
{
int upper = 0;
{
int tok;
const char *target = ptr;
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF:
return XML_TOK_INVALID;
}
ptr += MINBPC(enc);
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr)
case BT_QUEST:
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr + MINBPC(enc);
return tok;
return XML_TOK_INVALID;
}
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr + MINBPC(enc);
return tok;
}
static int PTRCALL
-PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
+PREFIX(scanCdataSection)(const ENCODING *UNUSED_P(enc), const char *ptr,
const char *end, const char **nextTokPtr)
{
static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
ASCII_T, ASCII_A, ASCII_LSQB };
int i;
/* CDATA[ */
- if (end - ptr < 6 * MINBPC(enc))
- return XML_TOK_PARTIAL;
+ REQUIRE_CHARS(enc, ptr, end, 6);
for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
*nextTokPtr = ptr;
PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr)
{
- if (ptr == end)
+ if (ptr >= end)
return XML_TOK_NONE;
if (MINBPC(enc) > 1) {
size_t n = end - ptr;
switch (BYTE_TYPE(enc, ptr)) {
case BT_RSQB:
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
break;
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
ptr -= MINBPC(enc);
break;
return XML_TOK_CDATA_SECT_CLOSE;
case BT_CR:
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
*nextTokPtr = ptr;
ptr += MINBPC(enc);
break;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
case BT_LEAD ## n: \
PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr)
{
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF:
- for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
+ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_S: case BT_CR: case BT_LF:
break;
PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr)
{
- if (ptr != end) {
+ if (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
case BT_HEX:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
+ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
case BT_HEX:
PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr)
{
- if (ptr != end) {
+ if (HAS_CHAR(enc, ptr, end)) {
if (CHAR_MATCHES(enc, ptr, ASCII_x))
return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
switch (BYTE_TYPE(enc, ptr)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
+ for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
break;
PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr)
{
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_NUM:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_SEMI:
#ifdef XML_NS
int hadColon = 0;
#endif
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
#ifdef XML_NS
}
hadColon = 1;
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
int t;
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
t = BYTE_TYPE(enc, ptr);
if (t == BT_EQUALS)
break;
#endif
for (;;) {
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
open = BYTE_TYPE(enc, ptr);
if (open == BT_QUOT || open == BT_APOS)
break;
/* in attribute value */
for (;;) {
int t;
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
t = BYTE_TYPE(enc, ptr);
if (t == open)
break;
}
}
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_S:
case BT_CR:
/* ptr points to closing quote */
for (;;) {
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF:
case BT_SOL:
sol:
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
#ifdef XML_NS
int hadColon;
#endif
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_EXCL:
- if ((ptr += MINBPC(enc)) == end)
- return XML_TOK_PARTIAL;
+ ptr += MINBPC(enc);
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_MINUS:
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
hadColon = 0;
#endif
/* we have a start-tag */
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
#ifdef XML_NS
}
hadColon = 1;
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
case BT_S: case BT_CR: case BT_LF:
{
ptr += MINBPC(enc);
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_GT:
case BT_SOL:
sol:
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
*nextTokPtr = ptr;
return XML_TOK_INVALID;
PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr)
{
- if (ptr == end)
+ if (ptr >= end)
return XML_TOK_NONE;
if (MINBPC(enc) > 1) {
size_t n = end - ptr;
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_CR:
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_CR;
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
return XML_TOK_DATA_NEWLINE;
case BT_RSQB:
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_RSQB;
if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
break;
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_RSQB;
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
ptr -= MINBPC(enc);
ptr += MINBPC(enc);
break;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
case BT_LEAD ## n: \
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
#undef LEAD_CASE
case BT_RSQB:
- if (ptr + MINBPC(enc) != end) {
+ if (HAS_CHARS(enc, ptr, end, 2)) {
if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
ptr += MINBPC(enc);
break;
}
- if (ptr + 2*MINBPC(enc) != end) {
+ if (HAS_CHARS(enc, ptr, end, 3)) {
if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
ptr += MINBPC(enc);
break;
PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr)
{
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_SEMI:
PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr)
{
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
default:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_CR: case BT_LF: case BT_S:
const char *ptr, const char *end,
const char **nextTokPtr)
{
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
int t = BYTE_TYPE(enc, ptr);
switch (t) {
INVALID_CASES(ptr, nextTokPtr)
ptr += MINBPC(enc);
if (t != open)
break;
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return -XML_TOK_LITERAL;
*nextTokPtr = ptr;
switch (BYTE_TYPE(enc, ptr)) {
const char **nextTokPtr)
{
int tok;
- if (ptr == end)
+ if (ptr >= end)
return XML_TOK_NONE;
if (MINBPC(enc) > 1) {
size_t n = end - ptr;
case BT_LT:
{
ptr += MINBPC(enc);
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) {
case BT_EXCL:
return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_S: case BT_LF:
for (;;) {
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
break;
switch (BYTE_TYPE(enc, ptr)) {
case BT_S: case BT_LF:
return XML_TOK_OPEN_BRACKET;
case BT_RSQB:
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return -XML_TOK_CLOSE_BRACKET;
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
- if (ptr + MINBPC(enc) == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHARS(enc, ptr, end, 2);
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
*nextTokPtr = ptr + 2*MINBPC(enc);
return XML_TOK_COND_SECT_CLOSE;
return XML_TOK_OPEN_PAREN;
case BT_RPAR:
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return -XML_TOK_CLOSE_PAREN;
switch (BYTE_TYPE(enc, ptr)) {
case BT_AST:
*nextTokPtr = ptr;
return XML_TOK_INVALID;
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_GT: case BT_RPAR: case BT_COMMA:
ptr += MINBPC(enc);
switch (tok) {
case XML_TOK_NAME:
- if (ptr == end)
- return XML_TOK_PARTIAL;
+ REQUIRE_CHAR(enc, ptr, end);
tok = XML_TOK_PREFIXED_NAME;
switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
const char *end, const char **nextTokPtr)
{
const char *start;
- if (ptr == end)
+ if (ptr >= end)
return XML_TOK_NONE;
+ else if (! HAS_CHAR(enc, ptr, end)) {
+ /* This line cannot be executed. The incoming data has already
+ * been tokenized once, so incomplete characters like this have
+ * already been eliminated from the input. Retaining the paranoia
+ * check is still valuable, however.
+ */
+ return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
+ }
start = ptr;
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
case BT_LEAD ## n: ptr += n; break;
case BT_CR:
if (ptr == start) {
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_CR;
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
const char *end, const char **nextTokPtr)
{
const char *start;
- if (ptr == end)
+ if (ptr >= end)
return XML_TOK_NONE;
+ else if (! HAS_CHAR(enc, ptr, end)) {
+ /* This line cannot be executed. The incoming data has already
+ * been tokenized once, so incomplete characters like this have
+ * already been eliminated from the input. Retaining the paranoia
+ * check is still valuable, however.
+ */
+ return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
+ }
start = ptr;
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
case BT_LEAD ## n: ptr += n; break;
case BT_CR:
if (ptr == start) {
ptr += MINBPC(enc);
- if (ptr == end)
+ if (! HAS_CHAR(enc, ptr, end))
return XML_TOK_TRAILING_CR;
if (BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
end = ptr + n;
}
}
- while (ptr != end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr)
case BT_LT:
- if ((ptr += MINBPC(enc)) == end)
- return XML_TOK_PARTIAL;
+ ptr += MINBPC(enc);
+ REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
- if ((ptr += MINBPC(enc)) == end)
- return XML_TOK_PARTIAL;
+ ptr += MINBPC(enc);
+ REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
++level;
ptr += MINBPC(enc);
}
break;
case BT_RSQB:
- if ((ptr += MINBPC(enc)) == end)
- return XML_TOK_PARTIAL;
+ ptr += MINBPC(enc);
+ REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
- if ((ptr += MINBPC(enc)) == end)
- return XML_TOK_PARTIAL;
+ ptr += MINBPC(enc);
+ REQUIRE_CHAR(enc, ptr, end);
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
ptr += MINBPC(enc);
if (level == 0) {
{
ptr += MINBPC(enc);
end -= MINBPC(enc);
- for (; ptr != end; ptr += MINBPC(enc)) {
+ for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT:
case BT_HEX:
}
static int PTRFASTCALL
-PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
+PREFIX(charRefNumber)(const ENCODING *UNUSED_P(enc), const char *ptr)
{
int result = 0;
/* skip &# */
}
static int PTRCALL
-PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
+PREFIX(predefinedEntityName)(const ENCODING *UNUSED_P(enc), const char *ptr,
const char *end)
{
switch ((end - ptr)/MINBPC(enc)) {
return 0;
}
+/* This function does not appear to be called from anywhere within the
+ * library code. It is used via the macro XmlSameName(), which is
+ * defined but never used. Since it appears in the encoding function
+ * table, removing it is not a thing to be undertaken lightly. For
+ * the moment, we simply exclude it from coverage tests.
+ *
+ * LCOV_EXCL_START
+ */
static int PTRCALL
PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
{
}
/* not reached */
}
+/* LCOV_EXCL_STOP */
static int PTRCALL
-PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
+PREFIX(nameMatchesAscii)(const ENCODING *UNUSED_P(enc), const char *ptr1,
const char *end1, const char *ptr2)
{
for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
- if (ptr1 == end1)
- return 0;
+ if (end1 - ptr1 < MINBPC(enc)) {
+ /* This line cannot be executed. THe incoming data has already
+ * been tokenized once, so imcomplete characters like this have
+ * already been eliminated from the input. Retaining the
+ * paranoia check is still valuable, however.
+ */
+ return 0; /* LCOV_EXCL_LINE */
+ }
if (!CHAR_MATCHES(enc, ptr1, *ptr2))
return 0;
}
const char *end,
POSITION *pos)
{
- while (ptr < end) {
+ while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
case BT_LEAD ## n: \
case BT_CR:
pos->lineNumber++;
ptr += MINBPC(enc);
- if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
+ if (HAS_CHAR(enc, ptr, end) && BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc);
pos->columnNumber = (XML_Size)-1;
break;
/*
-Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
-See the file COPYING for copying permission.
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
enum {
-/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
- See the file COPYING for copying permission.
+/* This file is included!
+ __ __ _
+ ___\ \/ /_ __ __ _| |_
+ / _ \\ /| '_ \ / _` | __|
+ | __// \| |_) | (_| | |_
+ \___/_/\_\ .__/ \__,_|\__|
+ |_| XML parser
+
+ Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+ Copyright (c) 2000-2017 Expat development team
+ Licensed under the MIT license:
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-/* This file is included! */
#ifdef XML_TOK_NS_C
const ENCODING *
#endif
#endif
-/* on unix, SVNVERSION is passed on the command line.
- * on Windows, the string is interpolated using
- * subwcrev.exe
- */
-#ifndef SVNVERSION
-#define SVNVERSION "$WCRANGE$$WCMODS?M:$"
-#endif
-
/* XXX Only unix build process has been tested */
-#ifndef HGVERSION
-#define HGVERSION ""
+#ifndef GITVERSION
+#define GITVERSION ""
#endif
-#ifndef HGTAG
-#define HGTAG ""
+#ifndef GITTAG
+#define GITTAG ""
#endif
-#ifndef HGBRANCH
-#define HGBRANCH ""
+#ifndef GITBRANCH
+#define GITBRANCH ""
#endif
const char *
Py_GetBuildInfo(void)
{
- static char buildinfo[50 + sizeof(HGVERSION) +
- ((sizeof(HGTAG) > sizeof(HGBRANCH)) ?
- sizeof(HGTAG) : sizeof(HGBRANCH))];
- const char *revision = _Py_hgversion();
+ static char buildinfo[50 + sizeof(GITVERSION) +
+ ((sizeof(GITTAG) > sizeof(GITBRANCH)) ?
+ sizeof(GITTAG) : sizeof(GITBRANCH))];
+ const char *revision = _Py_gitversion();
const char *sep = *revision ? ":" : "";
- const char *hgid = _Py_hgidentifier();
- if (!(*hgid))
- hgid = "default";
+ const char *gitid = _Py_gitidentifier();
+ if (!(*gitid))
+ gitid = "default";
PyOS_snprintf(buildinfo, sizeof(buildinfo),
- "%s%s%s, %.20s, %.9s", hgid, sep, revision,
+ "%s%s%s, %.20s, %.9s", gitid, sep, revision,
DATE, TIME);
return buildinfo;
}
const char *
-_Py_svnversion(void)
-{
- /* the following string can be modified by subwcrev.exe */
- static const char svnversion[] = SVNVERSION;
- if (svnversion[0] != '$')
- return svnversion; /* it was interpolated, or passed on command line */
- return "Unversioned directory";
-}
-
-const char *
-_Py_hgversion(void)
+_Py_gitversion(void)
{
- return HGVERSION;
+ return GITVERSION;
}
const char *
-_Py_hgidentifier(void)
+_Py_gitidentifier(void)
{
- const char *hgtag, *hgid;
- hgtag = HGTAG;
- if ((*hgtag) && strcmp(hgtag, "tip") != 0)
- hgid = hgtag;
+ const char *gittag, *gitid;
+ gittag = GITTAG;
+ if ((*gittag) && strcmp(gittag, "undefined") != 0)
+ gitid = gittag;
else
- hgid = HGBRANCH;
- return hgid;
+ gitid = GITBRANCH;
+ return gitid;
}
{
PyObject *item;
- if (lz->source == NULL)
- return NULL; /* already stopped */
-
- if (lz->active == NULL) {
- PyObject *iterable = PyIter_Next(lz->source);
- if (iterable == NULL) {
- Py_CLEAR(lz->source);
- return NULL; /* no more input sources */
- }
- lz->active = PyObject_GetIter(iterable);
- Py_DECREF(iterable);
+ /* lz->source is the iterator of iterables. If it's NULL, we've already
+ * consumed them all. lz->active is the current iterator. If it's NULL,
+ * we should grab a new one from lz->source. */
+ while (lz->source != NULL) {
if (lz->active == NULL) {
- Py_CLEAR(lz->source);
- return NULL; /* input not iterable */
+ PyObject *iterable = PyIter_Next(lz->source);
+ if (iterable == NULL) {
+ Py_CLEAR(lz->source);
+ return NULL; /* no more input sources */
+ }
+ lz->active = PyObject_GetIter(iterable);
+ Py_DECREF(iterable);
+ if (lz->active == NULL) {
+ Py_CLEAR(lz->source);
+ return NULL; /* input not iterable */
+ }
}
+ item = PyIter_Next(lz->active);
+ if (item != NULL)
+ return item;
+ if (PyErr_Occurred()) {
+ if (PyErr_ExceptionMatches(PyExc_StopIteration))
+ PyErr_Clear();
+ else
+ return NULL; /* input raised an exception */
+ }
+ /* lz->active is consumed, try with the next iterable. */
+ Py_CLEAR(lz->active);
}
- item = PyIter_Next(lz->active);
- if (item != NULL)
- return item;
- if (PyErr_Occurred()) {
- if (PyErr_ExceptionMatches(PyExc_StopIteration))
- PyErr_Clear();
- else
- return NULL; /* input raised an exception */
- }
- Py_CLEAR(lz->active);
- return chain_next(lz); /* recurse and use next active */
+ /* Everything had been consumed already. */
+ return NULL;
}
PyDoc_STRVAR(chain_doc,
#endif
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
/* Long usage message, split into parts < 512 bytes */
static char *usage_1 = "\
Options and arguments (and corresponding environment variables):\n\
+-b : issue warnings about comparing bytearray with unicode\n\
+ (-bb: issue errors)\n\
-B : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\
-c cmd : program passed in as string (terminates option list)\n\
-d : debug output from parser; also PYTHONDEBUG=x\n\
for mod in $MODS
do
EXTDECLS="${EXTDECLS}extern void init$mod(void);$NL"
- INITBITS="${INITBITS} {\"$mod\", init$mod},$NL"
+ INITBITS="${INITBITS} {\"$mod\", init$mod},$NL"
done
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
- if (PySlice_GetIndicesEx((PySliceObject *)item, self->size,
- &start, &stop, &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelen = _PySlice_AdjustIndices(self->size, &start, &stop, step);
if (slicelen <= 0)
return PyString_FromStringAndSize("", 0);
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
- if (PySlice_GetIndicesEx((PySliceObject *)item,
- self->size, &start, &stop,
- &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return -1;
}
+ slicelen = _PySlice_AdjustIndices(self->size, &start, &stop, step);
if (value == NULL) {
PyErr_SetString(PyExc_TypeError,
"mmap object doesn't support slice deletion");
Py_ssize_t i;
int err;
+ if (len < 0) {
+ return NULL;
+ }
for (i = 1; i < len; ++i) {
/* elem must always be a sequence, however simple */
PyObject* elem = PySequence_GetItem(tuple, i);
PyErr_SetObject(parser_error, err);
Py_XDECREF(err);
Py_XDECREF(elem);
- return (0);
+ return NULL;
}
if (ISTERMINAL(type)) {
Py_ssize_t len = PyObject_Size(elem);
if ((len != 2) && (len != 3)) {
err_string("terminal nodes must have 2 or 3 entries");
- return 0;
+ Py_DECREF(elem);
+ return NULL;
}
temp = PySequence_GetItem(elem, 1);
- if (temp == NULL)
- return 0;
+ if (temp == NULL) {
+ Py_DECREF(elem);
+ return NULL;
+ }
if (!PyString_Check(temp)) {
PyErr_Format(parser_error,
"second item in terminal node must be a string,"
" found %s",
Py_TYPE(temp)->tp_name);
Py_DECREF(temp);
- return 0;
+ Py_DECREF(elem);
+ return NULL;
}
if (len == 3) {
PyObject *o = PySequence_GetItem(elem, 2);
- if (o != NULL) {
- if (PyInt_Check(o))
- *line_num = PyInt_AS_LONG(o);
- else {
- PyErr_Format(parser_error,
- "third item in terminal node must be an"
- " integer, found %s",
- Py_TYPE(temp)->tp_name);
- Py_DECREF(o);
- Py_DECREF(temp);
- return 0;
- }
+ if (o == NULL) {
+ Py_DECREF(temp);
+ Py_DECREF(elem);
+ return NULL;
+ }
+ if (PyInt_Check(o))
+ *line_num = PyInt_AS_LONG(o);
+ else {
+ PyErr_Format(parser_error,
+ "third item in terminal node must be an"
+ " integer, found %s",
+ Py_TYPE(temp)->tp_name);
Py_DECREF(o);
+ Py_DECREF(temp);
+ Py_DECREF(elem);
+ return NULL;
}
+ Py_DECREF(o);
}
len = PyString_GET_SIZE(temp) + 1;
strn = (char *)PyObject_MALLOC(len);
- if (strn != NULL)
- (void) memcpy(strn, PyString_AS_STRING(temp), len);
+ if (strn == NULL) {
+ Py_DECREF(temp);
+ Py_DECREF(elem);
+ PyErr_NoMemory();
+ return NULL;
+ }
+ (void) memcpy(strn, PyString_AS_STRING(temp), len);
Py_DECREF(temp);
}
else if (!ISNONTERMINAL(type)) {
* It has to be one or the other; this is an error.
* Raise an exception.
*/
- PyObject *err = Py_BuildValue("os", elem, "unknown node type.");
+ PyObject *err = Py_BuildValue("Os", elem, "unknown node type.");
PyErr_SetObject(parser_error, err);
Py_XDECREF(err);
- Py_XDECREF(elem);
- return (0);
+ Py_DECREF(elem);
+ return NULL;
}
err = PyNode_AddChild(root, type, strn, *line_num, 0);
if (err == E_NOMEM) {
+ Py_DECREF(elem);
PyObject_FREE(strn);
- return (node *) PyErr_NoMemory();
+ PyErr_NoMemory();
+ return NULL;
}
if (err == E_OVERFLOW) {
+ Py_DECREF(elem);
PyObject_FREE(strn);
PyErr_SetString(PyExc_ValueError,
"unsupported number of child nodes");
node* new_child = CHILD(root, i - 1);
if (new_child != build_node_children(elem, new_child, line_num)) {
- Py_XDECREF(elem);
- return (0);
+ Py_DECREF(elem);
+ return NULL;
}
}
else if (type == NEWLINE) { /* It's true: we increment the */
++(*line_num); /* line number *after* the newline! */
}
- Py_XDECREF(elem);
+ Py_DECREF(elem);
}
return root;
}
if (num == encoding_decl) {
encoding = PySequence_GetItem(tuple, 2);
+ if (encoding == NULL) {
+ PyErr_SetString(parser_error, "missed encoding");
+ return NULL;
+ }
+ if (!PyString_Check(encoding)) {
+ PyErr_Format(parser_error,
+ "encoding must be a string, found %.200s",
+ Py_TYPE(encoding)->tp_name);
+ Py_DECREF(encoding);
+ return NULL;
+ }
/* tuple isn't borrowed anymore here, need to DECREF */
tuple = PySequence_GetSlice(tuple, 0, 2);
+ if (tuple == NULL) {
+ Py_DECREF(encoding);
+ return NULL;
+ }
}
res = PyNode_New(num);
if (res != NULL) {
Py_ssize_t len;
len = PyString_GET_SIZE(encoding) + 1;
res->n_str = (char *)PyObject_MALLOC(len);
- if (res->n_str != NULL)
- (void) memcpy(res->n_str, PyString_AS_STRING(encoding), len);
- Py_DECREF(encoding);
- Py_DECREF(tuple);
+ if (res->n_str == NULL) {
+ PyNode_Free(res);
+ Py_DECREF(encoding);
+ Py_DECREF(tuple);
+ PyErr_NoMemory();
+ return NULL;
+ }
+ (void) memcpy(res->n_str, PyString_AS_STRING(encoding), len);
}
}
+ if (encoding != NULL) {
+ Py_DECREF(encoding);
+ Py_DECREF(tuple);
+ }
}
else {
/* The tuple is illegal -- if the number is neither TERMINAL nor
* NONTERMINAL, we can't use it. Not sure the implementation
* allows this condition, but the API doesn't preclude it.
*/
- PyObject *err = Py_BuildValue("os", tuple,
+ PyObject *err = Py_BuildValue("Os", tuple,
"Illegal component tuple.");
PyErr_SetObject(parser_error, err);
Py_XDECREF(err);
result = Py_BuildValue("O(O)", pickle_constructor, tuple);
Py_DECREF(tuple);
}
- Py_DECREF(empty_dict);
Py_DECREF(newargs);
}
finally:
{
goto fail_2;
}
+ /* Search from index 1 because on Windows starting '=' is allowed for
+ defining hidden environment variables. */
+ if (*k == '\0' || strchr(k + 1, '=') != NULL) {
+ PyErr_SetString(PyExc_ValueError, "illegal environment variable name");
+ goto fail_2;
+ }
#if defined(PYOS_OS2)
/* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
{
goto fail_2;
}
+ /* Search from index 1 because on Windows starting '=' is allowed for
+ defining hidden environment variables. */
+ if (*k == '\0' || strchr(k + 1, '=') != NULL) {
+ PyErr_SetString(PyExc_ValueError, "illegal environment variable name");
+ goto fail_2;
+ }
len = PyString_Size(key) + PyString_Size(val) + 2;
p = PyMem_NEW(char, len);
if (p == NULL) {
{
goto fail_2;
}
+ /* Search from index 1 because on Windows starting '=' is allowed for
+ defining hidden environment variables. */
+ if (*k == '\0' || strchr(k + 1, '=') != NULL) {
+ PyErr_SetString(PyExc_ValueError, "illegal environment variable name");
+ goto fail_2;
+ }
len = PyString_Size(key) + PyString_Size(val) + 2;
p = PyMem_NEW(char, len);
if (p == NULL) {
static PyObject *
posix_setgroups(PyObject *self, PyObject *groups)
{
- int i, len;
+ Py_ssize_t i, len;
gid_t grouplist[MAX_GROUPS];
if (!PySequence_Check(groups)) {
return NULL;
}
len = PySequence_Size(groups);
+ if (len < 0) {
+ return NULL;
+ }
if (len > MAX_GROUPS) {
PyErr_SetString(PyExc_ValueError, "too many groups");
return NULL;
} else {
#endif
+ /* Search from index 1 because on Windows starting '=' is allowed for
+ defining hidden environment variables. */
+ if (*s1 == '\0' || strchr(s1 + 1, '=') != NULL) {
+ PyErr_SetString(PyExc_ValueError, "illegal environment variable name");
+ return NULL;
+ }
+
/* XXX This can leak memory -- not easy to fix :-( */
len = strlen(s1) + strlen(s2) + 2;
#ifdef MS_WINDOWS
else {
self->itself = XML_ParserCreate(encoding);
}
-#if ((XML_MAJOR_VERSION >= 2) && (XML_MINOR_VERSION >= 1)) || defined(XML_HAS_SET_HASH_SALT)
- /* This feature was added upstream in libexpat 2.1.0. Our expat copy
- * has a backport of this feature where we also define XML_HAS_SET_HASH_SALT
- * to indicate that we can still use it. */
+ if (self->itself == NULL) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "XML_ParserCreate failed");
+ Py_DECREF(self);
+ return NULL;
+ }
+#if XML_COMBINED_VERSION >= 20100
+ /* This feature was added upstream in libexpat 2.1.0. */
XML_SetHashSalt(self->itself,
(unsigned long)_Py_HashSecret.prefix);
#endif
#else
PyObject_GC_Init(self);
#endif
- if (self->itself == NULL) {
- PyErr_SetString(PyExc_RuntimeError,
- "XML_ParserCreate failed");
- Py_DECREF(self);
- return NULL;
- }
XML_SetUserData(self->itself, (void *)self);
#ifdef Py_USING_UNICODE
XML_SetUnknownEncodingHandler(self->itself,
if (n > 0) {
const char *line;
int length = _py_get_history_length();
- if (length > 0)
+ if (length > 0) {
+ HIST_ENTRY *hist_ent;
#ifdef __APPLE__
if (using_libedit_emulation) {
/* handle older 0-based or newer 1-based indexing */
- line = history_get(length + libedit_history_start - 1)->line;
+ hist_ent = history_get(length + libedit_history_start - 1);
} else
#endif /* __APPLE__ */
- line = history_get(length)->line;
- else
+ hist_ent = history_get(length);
+ line = hist_ent ? hist_ent->line : "";
+ } else
line = "";
if (strcmp(p, line))
add_history(p);
else
ret = PyTuple_Pack(3, ifdlist, ofdlist, efdlist);
- Py_DECREF(ifdlist);
- Py_DECREF(ofdlist);
- Py_DECREF(efdlist);
+ Py_XDECREF(ifdlist);
+ Py_XDECREF(ofdlist);
+ Py_XDECREF(efdlist);
}
finally:
if (PyLong_Check(pfd)
#if IDENT_TYPE == T_UINT
- && PyLong_AsUnsignedLong(pfd) <= UINT_MAX
+ && PyLong_AsUnsignedLong(pfd) <= UINT_MAX
#endif
) {
self->e.ident = IDENT_AsType(pfd);
{
tv->tv_sec = floor(d);
tv->tv_usec = fmod(d, 1.0) * 1000000.0;
+ /* Don't disable the timer if the computation above rounds down to zero. */
+ if (d > 0.0 && tv->tv_sec == 0 && tv->tv_usec == 0) {
+ tv->tv_usec = 1;
+ }
}
Py_LOCAL_INLINE(double)
if (!cell)
goto finally;
- if (!PyInt_Check(cell)) {
+ if (!PyInt_Check(cell) && !PyLong_Check(cell)) {
PyErr_BadArgument();
goto finally;
}
if (!v)
goto finally;
- if (!PyInt_Check(v)) {
+ if (!PyInt_Check(v) && !PyLong_Check(v)) {
PyErr_BadArgument();
goto finally;
}
if (PyString_Check(v) && PyString_Size(v) == 1)
mode.c_cc[i] = (cc_t) * PyString_AsString(v);
- else if (PyInt_Check(v))
+ else if (PyInt_Check(v) || PyLong_Check(v)) {
mode.c_cc[i] = (cc_t) PyInt_AsLong(v);
+ if (mode.c_cc[i] == (cc_t) -1 && PyErr_Occurred())
+ return NULL;
+ }
else {
PyErr_SetString(PyExc_TypeError,
"tcsetattr: elements of attributes must be characters or integers");
ChangeLog file for zlib
+Changes in 1.2.11 (15 Jan 2017)
+- Fix deflate stored bug when pulling last block from window
+- Permit immediate deflateParams changes before any deflate input
+
+Changes in 1.2.10 (2 Jan 2017)
+- Avoid warnings on snprintf() return value
+- Fix bug in deflate_stored() for zero-length input
+- Fix bug in gzwrite.c that produced corrupt gzip files
+- Remove files to be installed before copying them in Makefile.in
+- Add warnings when compiling with assembler code
+
+Changes in 1.2.9 (31 Dec 2016)
+- Fix contrib/minizip to permit unzipping with desktop API [Zouzou]
+- Improve contrib/blast to return unused bytes
+- Assure that gzoffset() is correct when appending
+- Improve compress() and uncompress() to support large lengths
+- Fix bug in test/example.c where error code not saved
+- Remedy Coverity warning [Randers-Pehrson]
+- Improve speed of gzprintf() in transparent mode
+- Fix inflateInit2() bug when windowBits is 16 or 32
+- Change DEBUG macro to ZLIB_DEBUG
+- Avoid uninitialized access by gzclose_w()
+- Allow building zlib outside of the source directory
+- Fix bug that accepted invalid zlib header when windowBits is zero
+- Fix gzseek() problem on MinGW due to buggy _lseeki64 there
+- Loop on write() calls in gzwrite.c in case of non-blocking I/O
+- Add --warn (-w) option to ./configure for more compiler warnings
+- Reject a window size of 256 bytes if not using the zlib wrapper
+- Fix bug when level 0 used with Z_HUFFMAN or Z_RLE
+- Add --debug (-d) option to ./configure to define ZLIB_DEBUG
+- Fix bugs in creating a very large gzip header
+- Add uncompress2() function, which returns the input size used
+- Assure that deflateParams() will not switch functions mid-block
+- Dramatically speed up deflation for level 0 (storing)
+- Add gzfread(), duplicating the interface of fread()
+- Add gzfwrite(), duplicating the interface of fwrite()
+- Add deflateGetDictionary() function
+- Use snprintf() for later versions of Microsoft C
+- Fix *Init macros to use z_ prefix when requested
+- Replace as400 with os400 for OS/400 support [Monnerat]
+- Add crc32_z() and adler32_z() functions with size_t lengths
+- Update Visual Studio project files [AraHaan]
+
Changes in 1.2.8 (28 Apr 2013)
- Update contrib/minizip/iowin32.c for Windows RT [Vollant]
- Do not force Z_CONST for C++
-- Clean up contrib/vstudio [Ro§]
+- Clean up contrib/vstudio [Roß]
- Correct spelling error in zlib.h
- Fix mixed line endings in contrib/vstudio
- Clean up the usage of z_const and respect const usage within zlib
- Clean up examples/gzlog.[ch] comparisons of different types
- Avoid shift equal to bits in type (caused endless loop)
-- Fix unintialized value bug in gzputc() introduced by const patches
+- Fix uninitialized value bug in gzputc() introduced by const patches
- Fix memory allocation error in examples/zran.c [Nor]
- Fix bug where gzopen(), gzclose() would write an empty file
- Fix bug in gzclose() when gzwrite() runs out of memory
- Add a transparent write mode to gzopen() when 'T' is in the mode
- Update python link in zlib man page
- Get inffixed.h and MAKEFIXED result to match
-- Add a ./config --solo option to make zlib subset with no libary use
+- Add a ./config --solo option to make zlib subset with no library use
- Add undocumented inflateResetKeep() function for CAB file decoding
- Add --cover option to ./configure for gcc coverage testing
- Add #define ZLIB_CONST option to use const in the z_stream interface
- Update make_vms.com [Zinser]
- Use -fPIC for shared build in configure [Teredesai, Nicholson]
- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen]
-- Use fdopen() (not _fdopen()) for Interix in zutil.h [B\8ack]
+- Use fdopen() (not _fdopen()) for Interix in zutil.h [Bäck]
- Add some FAQ entries about the contrib directory
- Update the MVS question in the FAQ
- Avoid extraneous reads after EOF in gzio.c [Brown]
386 asm code replacing longest_match().
contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
A C++ I/O streams interface to the zlib gz* functions
- contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
+ contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
Another C++ I/O streams interface
contrib/untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
A very simple tar.gz file extractor using zlib
- fix array overlay in deflate.c which sometimes caused bad compressed data
- fix inflate bug with empty stored block
- fix MSDOS medium model which was broken in 0.99
-- fix deflateParams() which could generated bad compressed data.
+- fix deflateParams() which could generate bad compressed data.
- Bytef is define'd instead of typedef'ed (work around Borland bug)
- added an INDEX file
- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
# Makefile for zlib
-# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler
+# Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
# For conditions of distribution and use, see copyright notice in zlib.h
# To compile and test, type:
CFLAGS=-O
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
-#CFLAGS=-g -DDEBUG
+#CFLAGS=-g -DZLIB_DEBUG
#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
# -Wstrict-prototypes -Wmissing-prototypes
STATICLIB=libz.a
SHAREDLIB=libz.so
-SHAREDLIBV=libz.so.1.2.8
+SHAREDLIBV=libz.so.1.2.10
SHAREDLIBM=libz.so.1
LIBS=$(STATICLIB) $(SHAREDLIBV)
mandir = ${prefix}/share/man
man3dir = ${mandir}/man3
pkgconfigdir = ${libdir}/pkgconfig
+SRCDIR=
+ZINC=
+ZINCOUT=-I.
OBJZ = adler32.o crc32.o deflate.o infback.o inffast.o inflate.o inftrees.o trees.o zutil.o
OBJG = compress.o uncompr.o gzclose.o gzlib.o gzread.o gzwrite.o
fi; \
rm -f $$TMP64
-infcover.o: test/infcover.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -c -o $@ test/infcover.c
+infcover.o: $(SRCDIR)test/infcover.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/infcover.c
infcover: infcover.o libz.a
$(CC) $(CFLAGS) -o $@ infcover.o libz.a
mv _match.o match.lo
rm -f _match.s
-example.o: test/example.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -c -o $@ test/example.c
+example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/example.c
-minigzip.o: test/minigzip.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -c -o $@ test/minigzip.c
+minigzip.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/minigzip.c
-example64.o: test/example.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -D_FILE_OFFSET_BITS=64 -c -o $@ test/example.c
+example64.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/example.c
-minigzip64.o: test/minigzip.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -D_FILE_OFFSET_BITS=64 -c -o $@ test/minigzip.c
+minigzip64.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/minigzip.c
-.SUFFIXES: .lo
-.c.lo:
+adler32.o: $(SRCDIR)adler32.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)adler32.c
+
+crc32.o: $(SRCDIR)crc32.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)crc32.c
+
+deflate.o: $(SRCDIR)deflate.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)deflate.c
+
+infback.o: $(SRCDIR)infback.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)infback.c
+
+inffast.o: $(SRCDIR)inffast.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inffast.c
+
+inflate.o: $(SRCDIR)inflate.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inflate.c
+
+inftrees.o: $(SRCDIR)inftrees.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inftrees.c
+
+trees.o: $(SRCDIR)trees.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)trees.c
+
+zutil.o: $(SRCDIR)zutil.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)zutil.c
+
+compress.o: $(SRCDIR)compress.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)compress.c
+
+uncompr.o: $(SRCDIR)uncompr.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)uncompr.c
+
+gzclose.o: $(SRCDIR)gzclose.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzclose.c
+
+gzlib.o: $(SRCDIR)gzlib.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzlib.c
+
+gzread.o: $(SRCDIR)gzread.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzread.c
+
+gzwrite.o: $(SRCDIR)gzwrite.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzwrite.c
+
+
+adler32.lo: $(SRCDIR)adler32.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/adler32.o $(SRCDIR)adler32.c
+ -@mv objs/adler32.o $@
+
+crc32.lo: $(SRCDIR)crc32.c
-@mkdir objs 2>/dev/null || test -d objs
- $(CC) $(SFLAGS) -DPIC -c -o objs/$*.o $<
- -@mv objs/$*.o $@
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/crc32.o $(SRCDIR)crc32.c
+ -@mv objs/crc32.o $@
+
+deflate.lo: $(SRCDIR)deflate.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/deflate.o $(SRCDIR)deflate.c
+ -@mv objs/deflate.o $@
+
+infback.lo: $(SRCDIR)infback.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/infback.o $(SRCDIR)infback.c
+ -@mv objs/infback.o $@
+
+inffast.lo: $(SRCDIR)inffast.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inffast.o $(SRCDIR)inffast.c
+ -@mv objs/inffast.o $@
+
+inflate.lo: $(SRCDIR)inflate.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inflate.o $(SRCDIR)inflate.c
+ -@mv objs/inflate.o $@
+
+inftrees.lo: $(SRCDIR)inftrees.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inftrees.o $(SRCDIR)inftrees.c
+ -@mv objs/inftrees.o $@
+
+trees.lo: $(SRCDIR)trees.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/trees.o $(SRCDIR)trees.c
+ -@mv objs/trees.o $@
+
+zutil.lo: $(SRCDIR)zutil.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/zutil.o $(SRCDIR)zutil.c
+ -@mv objs/zutil.o $@
+
+compress.lo: $(SRCDIR)compress.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/compress.o $(SRCDIR)compress.c
+ -@mv objs/compress.o $@
+
+uncompr.lo: $(SRCDIR)uncompr.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/uncompr.o $(SRCDIR)uncompr.c
+ -@mv objs/uncompr.o $@
+
+gzclose.lo: $(SRCDIR)gzclose.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzclose.o $(SRCDIR)gzclose.c
+ -@mv objs/gzclose.o $@
+
+gzlib.lo: $(SRCDIR)gzlib.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzlib.o $(SRCDIR)gzlib.c
+ -@mv objs/gzlib.o $@
+
+gzread.lo: $(SRCDIR)gzread.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzread.o $(SRCDIR)gzread.c
+ -@mv objs/gzread.o $@
+
+gzwrite.lo: $(SRCDIR)gzwrite.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzwrite.o $(SRCDIR)gzwrite.c
+ -@mv objs/gzwrite.o $@
+
placebo $(SHAREDLIBV): $(PIC_OBJS) libz.a
$(LDSHARED) $(SFLAGS) -o $@ $(PIC_OBJS) $(LDSHAREDLIBC) $(LDFLAGS)
-@if [ ! -d $(DESTDIR)$(sharedlibdir) ]; then mkdir -p $(DESTDIR)$(sharedlibdir); fi
-@if [ ! -d $(DESTDIR)$(man3dir) ]; then mkdir -p $(DESTDIR)$(man3dir); fi
-@if [ ! -d $(DESTDIR)$(pkgconfigdir) ]; then mkdir -p $(DESTDIR)$(pkgconfigdir); fi
+ rm -f $(DESTDIR)$(libdir)/$(STATICLIB)
cp $(STATICLIB) $(DESTDIR)$(libdir)
chmod 644 $(DESTDIR)$(libdir)/$(STATICLIB)
-@($(RANLIB) $(DESTDIR)$(libdir)/libz.a || true) >/dev/null 2>&1
-@if test -n "$(SHAREDLIBV)"; then \
+ rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir); \
echo "cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)"; \
chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
($(LDCONFIG) || true) >/dev/null 2>&1; \
fi
- cp zlib.3 $(DESTDIR)$(man3dir)
+ rm -f $(DESTDIR)$(man3dir)/zlib.3
+ cp $(SRCDIR)zlib.3 $(DESTDIR)$(man3dir)
chmod 644 $(DESTDIR)$(man3dir)/zlib.3
+ rm -f $(DESTDIR)$(pkgconfigdir)/zlib.pc
cp zlib.pc $(DESTDIR)$(pkgconfigdir)
chmod 644 $(DESTDIR)$(pkgconfigdir)/zlib.pc
# The ranlib in install is needed on NeXTSTEP which checks file times
install: install-libs
-@if [ ! -d $(DESTDIR)$(includedir) ]; then mkdir -p $(DESTDIR)$(includedir); fi
- cp zlib.h zconf.h $(DESTDIR)$(includedir)
+ rm -f $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
+ cp $(SRCDIR)zlib.h zconf.h $(DESTDIR)$(includedir)
chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
uninstall:
docs: zlib.3.pdf
-zlib.3.pdf: zlib.3
- groff -mandoc -f H -T ps zlib.3 | ps2pdf - zlib.3.pdf
+zlib.3.pdf: $(SRCDIR)zlib.3
+ groff -mandoc -f H -T ps $(SRCDIR)zlib.3 | ps2pdf - $@
-zconf.h.cmakein: zconf.h.in
+zconf.h.cmakein: $(SRCDIR)zconf.h.in
-@ TEMPFILE=zconfh_$$; \
echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_PREFIX\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\
- sed -f $$TEMPFILE zconf.h.in > zconf.h.cmakein &&\
- touch -r zconf.h.in zconf.h.cmakein &&\
+ sed -f $$TEMPFILE $(SRCDIR)zconf.h.in > $@ &&\
+ touch -r $(SRCDIR)zconf.h.in $@ &&\
rm $$TEMPFILE
-zconf: zconf.h.in
- cp -p zconf.h.in zconf.h
+zconf: $(SRCDIR)zconf.h.in
+ cp -p $(SRCDIR)zconf.h.in zconf.h
mostlyclean: clean
clean:
distclean: clean zconf zconf.h.cmakein docs
rm -f Makefile zlib.pc configure.log
-@rm -f .DS_Store
- -@printf 'all:\n\t-@echo "Please use ./configure first. Thank you."\n' > Makefile
- -@printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile
- -@touch -r Makefile.in Makefile
+ @if [ -f Makefile.in ]; then \
+ printf 'all:\n\t-@echo "Please use ./configure first. Thank you."\n' > Makefile ; \
+ printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile ; \
+ touch -r $(SRCDIR)Makefile.in Makefile ; fi
+ @if [ ! -f zconf.h.in ]; then rm -f zconf.h zconf.h.cmakein ; fi
+ @if [ ! -f zlib.3 ]; then rm -f zlib.3.pdf ; fi
tags:
- etags *.[ch]
-
-depend:
- makedepend -- $(CFLAGS) -- *.[ch]
-
-# DO NOT DELETE THIS LINE -- make depend depends on it.
-
-adler32.o zutil.o: zutil.h zlib.h zconf.h
-gzclose.o gzlib.o gzread.o gzwrite.o: zlib.h zconf.h gzguts.h
-compress.o example.o minigzip.o uncompr.o: zlib.h zconf.h
-crc32.o: zutil.h zlib.h zconf.h crc32.h
-deflate.o: deflate.h zutil.h zlib.h zconf.h
-infback.o inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h inffixed.h
-inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
-inftrees.o: zutil.h zlib.h zconf.h inftrees.h
-trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
-
-adler32.lo zutil.lo: zutil.h zlib.h zconf.h
-gzclose.lo gzlib.lo gzread.lo gzwrite.lo: zlib.h zconf.h gzguts.h
-compress.lo example.lo minigzip.lo uncompr.lo: zlib.h zconf.h
-crc32.lo: zutil.h zlib.h zconf.h crc32.h
-deflate.lo: deflate.h zutil.h zlib.h zconf.h
-infback.lo inflate.lo: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h inffixed.h
-inffast.lo: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
-inftrees.lo: zutil.h zlib.h zconf.h inftrees.h
-trees.lo: deflate.h zutil.h zlib.h zconf.h trees.h
+ etags $(SRCDIR)*.[ch]
+
+adler32.o zutil.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+gzclose.o gzlib.o gzread.o gzwrite.o: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+compress.o example.o minigzip.o uncompr.o: $(SRCDIR)zlib.h zconf.h
+crc32.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+deflate.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+infback.o inflate.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+inffast.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
+inftrees.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
+trees.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
+
+adler32.lo zutil.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+gzclose.lo gzlib.lo gzread.lo gzwrite.lo: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+compress.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)zlib.h zconf.h
+crc32.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+deflate.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+infback.lo inflate.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+inffast.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
+inftrees.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
+trees.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
ZLIB DATA COMPRESSION LIBRARY
-zlib 1.2.8 is a general purpose data compression library. All the code is
+zlib 1.2.11 is a general purpose data compression library. All the code is
thread safe. The data format used by the zlib library is described by RFCs
(Request for Comments) 1950 to 1952 in the files
http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
issue of Dr. Dobb's Journal; a copy of the article is available at
http://marknelson.us/1997/01/01/zlib-engine/ .
-The changes made in version 1.2.8 are documented in the file ChangeLog.
+The changes made in version 1.2.11 are documented in the file ChangeLog.
Unsupported third party contributions are provided in directory contrib/ .
Copyright notice:
- (C) 1995-2013 Jean-loup Gailly and Mark Adler
+ (C) 1995-2017 Jean-loup Gailly and Mark Adler
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
/* adler32.c -- compute the Adler-32 checksum of a data stream
- * Copyright (C) 1995-2011 Mark Adler
+ * Copyright (C) 1995-2011, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "zutil.h"
-#define local static
-
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
-#define BASE 65521 /* largest prime smaller than 65536 */
+#define BASE 65521U /* largest prime smaller than 65536 */
#define NMAX 5552
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
#endif
/* ========================================================================= */
-uLong ZEXPORT adler32(adler, buf, len)
+uLong ZEXPORT adler32_z(adler, buf, len)
uLong adler;
const Bytef *buf;
- uInt len;
+ z_size_t len;
{
unsigned long sum2;
unsigned n;
}
/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+ uLong adler;
+ const Bytef *buf;
+ uInt len;
+{
+ return adler32_z(adler, buf, len);
+}
+
+/* ========================================================================= */
local uLong adler32_combine_(adler1, adler2, len2)
uLong adler1;
uLong adler2;
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
if (sum1 >= BASE) sum1 -= BASE;
if (sum1 >= BASE) sum1 -= BASE;
- if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
+ if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
if (sum2 >= BASE) sum2 -= BASE;
return sum1 | (sum2 << 16);
}
/* compress.c -- compress a memory buffer
- * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
{
z_stream stream;
int err;
+ const uInt max = (uInt)-1;
+ uLong left;
- stream.next_in = (z_const Bytef *)source;
- stream.avail_in = (uInt)sourceLen;
-#ifdef MAXSEG_64K
- /* Check for source > 64K on 16-bit machine: */
- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-#endif
- stream.next_out = dest;
- stream.avail_out = (uInt)*destLen;
- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+ left = *destLen;
+ *destLen = 0;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
err = deflateInit(&stream, level);
if (err != Z_OK) return err;
- err = deflate(&stream, Z_FINISH);
- if (err != Z_STREAM_END) {
- deflateEnd(&stream);
- return err == Z_OK ? Z_BUF_ERROR : err;
- }
- *destLen = stream.total_out;
+ stream.next_out = dest;
+ stream.avail_out = 0;
+ stream.next_in = (z_const Bytef *)source;
+ stream.avail_in = 0;
+
+ do {
+ if (stream.avail_out == 0) {
+ stream.avail_out = left > (uLong)max ? max : (uInt)left;
+ left -= stream.avail_out;
+ }
+ if (stream.avail_in == 0) {
+ stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
+ sourceLen -= stream.avail_in;
+ }
+ err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
+ } while (err == Z_OK);
- err = deflateEnd(&stream);
- return err;
+ *destLen = stream.total_out;
+ deflateEnd(&stream);
+ return err == Z_STREAM_END ? Z_OK : err;
}
/* ===========================================================================
echo $0 $* >> configure.log
date >> configure.log
+# get source directory
+SRCDIR=`dirname $0`
+if test $SRCDIR = "."; then
+ ZINC=""
+ ZINCOUT="-I."
+ SRCDIR=""
+else
+ ZINC='-include zconf.h'
+ ZINCOUT='-I. -I$(SRCDIR)'
+ SRCDIR="$SRCDIR/"
+fi
+
# set command prefix for cross-compilation
if [ -n "${CHOST}" ]; then
uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`"
STATICLIB=libz.a
# extract zlib version numbers from zlib.h
-VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`
-VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < zlib.h`
-VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < zlib.h`
-VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < zlib.h`
+VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}zlib.h`
+VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < ${SRCDIR}zlib.h`
+VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
+VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
# establish commands for library building
if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then
zconst=0
build64=0
gcc=0
+warn=0
+debug=0
old_cc="$CC"
old_cflags="$CFLAGS"
OBJC='$(OBJZ) $(OBJG)'
--sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
--localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
-c* | --const) zconst=1; shift ;;
+ -w* | --warn) warn=1; shift ;;
+ -d* | --debug) debug=1; shift ;;
*)
echo "unknown option: $1" | tee -a configure.log
echo "$0 --help for help" | tee -a configure.log
esac
case `$cc -v 2>&1` in
*gcc*) gcc=1 ;;
+ *clang*) gcc=1 ;;
esac
show $cc -c $test.c
if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then
echo ... using gcc >> configure.log
CC="$cc"
- CFLAGS="${CFLAGS--O3} ${ARCHS}"
+ CFLAGS="${CFLAGS--O3}"
SFLAGS="${CFLAGS--O3} -fPIC"
- LDFLAGS="${LDFLAGS} ${ARCHS}"
+ if test "$ARCHS"; then
+ CFLAGS="${CFLAGS} ${ARCHS}"
+ LDFLAGS="${LDFLAGS} ${ARCHS}"
+ fi
if test $build64 -eq 1; then
CFLAGS="${CFLAGS} -m64"
SFLAGS="${SFLAGS} -m64"
fi
- if test "${ZLIBGCCWARN}" = "YES"; then
+ if test "$warn" -eq 1; then
if test "$zconst" -eq 1; then
CFLAGS="${CFLAGS} -Wall -Wextra -Wcast-qual -pedantic -DZLIB_CONST"
else
CFLAGS="${CFLAGS} -Wall -Wextra -pedantic"
fi
fi
+ if test $debug -eq 1; then
+ CFLAGS="${CFLAGS} -DZLIB_DEBUG"
+ SFLAGS="${SFLAGS} -DZLIB_DEBUG"
+ fi
if test -z "$uname"; then
uname=`(uname -s || echo unknown) 2>/dev/null`
fi
case "$uname" in
Linux* | linux* | GNU | GNU/* | solaris*)
- LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,zlib.map"} ;;
+ LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"} ;;
*BSD | *bsd* | DragonFly)
- LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,zlib.map"}
+ LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"}
LDCONFIG="ldconfig -m" ;;
CYGWIN* | Cygwin* | cygwin* | OS/2*)
EXE='.exe' ;;
esac
fi
fi
+ if test -n "$ZINC"; then
+ ZINC='-I- -I. -I$(SRCDIR)'
+ fi
;;
SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"}
CFLAGS=${CFLAGS-"-O2"}
}
echo - using any output from compiler to indicate an error >> configure.log
else
-try()
-{
- show $*
- ( $* ) >> configure.log 2>&1
- ret=$?
- if test $ret -ne 0; then
- echo "(exit code "$ret")" >> configure.log
- fi
- return $ret
-}
+ try()
+ {
+ show $*
+ ( $* ) >> configure.log 2>&1
+ ret=$?
+ if test $ret -ne 0; then
+ echo "(exit code "$ret")" >> configure.log
+ fi
+ return $ret
+ }
fi
tryboth()
echo >> configure.log
+# check for size_t
+cat > $test.c <<EOF
+#include <stdio.h>
+#include <stdlib.h>
+size_t dummy = 0;
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for size_t... Yes." | tee -a configure.log
+ need_sizet=0
+else
+ echo "Checking for size_t... No." | tee -a configure.log
+ need_sizet=1
+fi
+
+echo >> configure.log
+
+# find the size_t integer type, if needed
+if test $need_sizet -eq 1; then
+ cat > $test.c <<EOF
+long long dummy = 0;
+EOF
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for long long... Yes." | tee -a configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ if (sizeof(void *) <= sizeof(int)) puts("int");
+ else if (sizeof(void *) <= sizeof(long)) puts("long");
+ else puts("z_longlong");
+ return 0;
+}
+EOF
+ else
+ echo "Checking for long long... No." | tee -a configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ if (sizeof(void *) <= sizeof(int)) puts("int");
+ else puts("long");
+ return 0;
+}
+EOF
+ fi
+ if try $CC $CFLAGS -o $test $test.c; then
+ sizet=`./$test`
+ echo "Checking for a pointer-size integer type..." $sizet"." | tee -a configure.log
+ else
+ echo "Failed to find a pointer-size integer type." | tee -a configure.log
+ leave 1
+ fi
+fi
+
+if test $need_sizet -eq 1; then
+ CFLAGS="${CFLAGS} -DNO_SIZE_T=${sizet}"
+ SFLAGS="${SFLAGS} -DNO_SIZE_T=${sizet}"
+fi
+
+echo >> configure.log
+
# check for large file support, and if none, check for fseeko()
cat > $test.c <<EOF
#include <sys/types.h>
fi
# copy clean zconf.h for subsequent edits
-cp -p zconf.h.in zconf.h
+cp -p ${SRCDIR}zconf.h.in zconf.h
echo >> configure.log
echo TEST = $TEST >> configure.log
echo VER = $VER >> configure.log
echo Z_U4 = $Z_U4 >> configure.log
+echo SRCDIR = $SRCDIR >> configure.log
echo exec_prefix = $exec_prefix >> configure.log
echo includedir = $includedir >> configure.log
echo libdir = $libdir >> configure.log
echo uname = $uname >> configure.log
# udpate Makefile with the configure results
-sed < Makefile.in "
+sed < ${SRCDIR}Makefile.in "
/^CC *=/s#=.*#=$CC#
/^CFLAGS *=/s#=.*#=$CFLAGS#
/^SFLAGS *=/s#=.*#=$SFLAGS#
/^LDCONFIG *=/s#=.*#=$LDCONFIG#
/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC#
/^EXE *=/s#=.*#=$EXE#
+/^SRCDIR *=/s#=.*#=$SRCDIR#
+/^ZINC *=/s#=.*#=$ZINC#
+/^ZINCOUT *=/s#=.*#=$ZINCOUT#
/^prefix *=/s#=.*#=$prefix#
/^exec_prefix *=/s#=.*#=$exec_prefix#
/^libdir *=/s#=.*#=$libdir#
" > Makefile
# create zlib.pc with the configure results
-sed < zlib.pc.in "
+sed < ${SRCDIR}zlib.pc.in "
/^CC *=/s#=.*#=$CC#
/^CFLAGS *=/s#=.*#=$CFLAGS#
/^CPP *=/s#=.*#=$CPP#
/* crc32.c -- compute the CRC-32 of a data stream
- * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
+ * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*
* Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
#include "zutil.h" /* for STDC and FAR definitions */
-#define local static
-
/* Definitions for doing the crc four data bytes at a time. */
#if !defined(NOBYFOUR) && defined(Z_U4)
# define BYFOUR
#endif
#ifdef BYFOUR
local unsigned long crc32_little OF((unsigned long,
- const unsigned char FAR *, unsigned));
+ const unsigned char FAR *, z_size_t));
local unsigned long crc32_big OF((unsigned long,
- const unsigned char FAR *, unsigned));
+ const unsigned char FAR *, z_size_t));
# define TBLS 8
#else
# define TBLS 1
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
/* ========================================================================= */
-unsigned long ZEXPORT crc32(crc, buf, len)
+unsigned long ZEXPORT crc32_z(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
- uInt len;
+ z_size_t len;
{
if (buf == Z_NULL) return 0UL;
return crc ^ 0xffffffffUL;
}
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ uInt len;
+{
+ return crc32_z(crc, buf, len);
+}
+
#ifdef BYFOUR
+/*
+ This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
+ integer pointer type. This violates the strict aliasing rule, where a
+ compiler can assume, for optimization purposes, that two pointers to
+ fundamentally different types won't ever point to the same memory. This can
+ manifest as a problem only if one of the pointers is written to. This code
+ only reads from those pointers. So long as this code remains isolated in
+ this compilation unit, there won't be a problem. For this reason, this code
+ should not be copied and pasted into a compilation unit in which other code
+ writes to the buffer that is passed to these routines.
+ */
+
/* ========================================================================= */
#define DOLIT4 c ^= *buf4++; \
c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
local unsigned long crc32_little(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
- unsigned len;
+ z_size_t len;
{
register z_crc_t c;
register const z_crc_t FAR *buf4;
}
/* ========================================================================= */
-#define DOBIG4 c ^= *++buf4; \
+#define DOBIG4 c ^= *buf4++; \
c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
local unsigned long crc32_big(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
- unsigned len;
+ z_size_t len;
{
register z_crc_t c;
register const z_crc_t FAR *buf4;
}
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
- buf4--;
while (len >= 32) {
DOBIG32;
len -= 32;
DOBIG4;
len -= 4;
}
- buf4++;
buf = (const unsigned char FAR *)buf4;
if (len) do {
/* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
+ * Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "deflate.h"
const char deflate_copyright[] =
- " deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ";
+ " deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and Mark Adler ";
/*
If you use the zlib library in a product, an acknowledgment is welcome
in the documentation of your product. If for some reason you cannot
typedef block_state (*compress_func) OF((deflate_state *s, int flush));
/* Compression function. Returns the block state after the call. */
+local int deflateStateCheck OF((z_streamp strm));
+local void slide_hash OF((deflate_state *s));
local void fill_window OF((deflate_state *s));
local block_state deflate_stored OF((deflate_state *s, int flush));
local block_state deflate_fast OF((deflate_state *s, int flush));
local void lm_init OF((deflate_state *s));
local void putShortMSB OF((deflate_state *s, uInt b));
local void flush_pending OF((z_streamp strm));
-local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
+local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
#ifdef ASMV
+# pragma message("Assembler code may have bugs -- use at your own risk")
void match_init OF((void)); /* asm code initialization */
uInt longest_match OF((deflate_state *s, IPos cur_match));
#else
local uInt longest_match OF((deflate_state *s, IPos cur_match));
#endif
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
local void check_match OF((deflate_state *s, IPos start, IPos match,
int length));
#endif
* meaning.
*/
-#define EQUAL 0
-/* result of memcmp for equal strings */
-
-#ifndef NO_DUMMY_DECL
-struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
-#endif
-
/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
-#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0))
+#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
/* ===========================================================================
* Update a hash value with the given input byte
- * IN assertion: all calls to to UPDATE_HASH are made with consecutive
- * input characters, so that a running hash key can be computed from the
- * previous key instead of complete recalculation each time.
+ * IN assertion: all calls to UPDATE_HASH are made with consecutive input
+ * characters, so that a running hash key can be computed from the previous
+ * key instead of complete recalculation each time.
*/
#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
* the previous length of the hash chain.
* If this file is compiled with -DFASTEST, the compression level is forced
* to 1, and no hash chains are maintained.
- * IN assertion: all calls to to INSERT_STRING are made with consecutive
- * input characters and the first MIN_MATCH bytes of str are valid
- * (except for the last MIN_MATCH-1 bytes of the input file).
+ * IN assertion: all calls to INSERT_STRING are made with consecutive input
+ * characters and the first MIN_MATCH bytes of str are valid (except for
+ * the last MIN_MATCH-1 bytes of the input file).
*/
#ifdef FASTEST
#define INSERT_STRING(s, str, match_head) \
s->head[s->hash_size-1] = NIL; \
zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+/* ===========================================================================
+ * Slide the hash table when sliding the window down (could be avoided with 32
+ * bit values at the expense of memory usage). We slide even when level == 0 to
+ * keep the hash table consistent if we switch back to level > 0 later.
+ */
+local void slide_hash(s)
+ deflate_state *s;
+{
+ unsigned n, m;
+ Posf *p;
+ uInt wsize = s->w_size;
+
+ n = s->hash_size;
+ p = &s->head[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m - wsize : NIL);
+ } while (--n);
+ n = wsize;
+#ifndef FASTEST
+ p = &s->prev[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m - wsize : NIL);
+ /* If n is not on any hash chain, prev[n] is garbage but
+ * its value will never be used.
+ */
+ } while (--n);
+#endif
+}
+
/* ========================================================================= */
int ZEXPORT deflateInit_(strm, level, version, stream_size)
z_streamp strm;
#endif
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
- strategy < 0 || strategy > Z_FIXED) {
+ strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) {
return Z_STREAM_ERROR;
}
if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
if (s == Z_NULL) return Z_MEM_ERROR;
strm->state = (struct internal_state FAR *)s;
s->strm = strm;
+ s->status = INIT_STATE; /* to pass state test in deflateReset() */
s->wrap = wrap;
s->gzhead = Z_NULL;
- s->w_bits = windowBits;
+ s->w_bits = (uInt)windowBits;
s->w_size = 1 << s->w_bits;
s->w_mask = s->w_size - 1;
- s->hash_bits = memLevel + 7;
+ s->hash_bits = (uInt)memLevel + 7;
s->hash_size = 1 << s->hash_bits;
s->hash_mask = s->hash_size - 1;
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
return deflateReset(strm);
}
+/* =========================================================================
+ * Check for a valid deflate stream state. Return 0 if ok, 1 if not.
+ */
+local int deflateStateCheck (strm)
+ z_streamp strm;
+{
+ deflate_state *s;
+ if (strm == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+ return 1;
+ s = strm->state;
+ if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
+#ifdef GZIP
+ s->status != GZIP_STATE &&
+#endif
+ s->status != EXTRA_STATE &&
+ s->status != NAME_STATE &&
+ s->status != COMMENT_STATE &&
+ s->status != HCRC_STATE &&
+ s->status != BUSY_STATE &&
+ s->status != FINISH_STATE))
+ return 1;
+ return 0;
+}
+
/* ========================================================================= */
int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
z_streamp strm;
unsigned avail;
z_const unsigned char *next;
- if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
+ if (deflateStateCheck(strm) || dictionary == Z_NULL)
return Z_STREAM_ERROR;
s = strm->state;
wrap = s->wrap;
}
/* ========================================================================= */
+int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)
+ z_streamp strm;
+ Bytef *dictionary;
+ uInt *dictLength;
+{
+ deflate_state *s;
+ uInt len;
+
+ if (deflateStateCheck(strm))
+ return Z_STREAM_ERROR;
+ s = strm->state;
+ len = s->strstart + s->lookahead;
+ if (len > s->w_size)
+ len = s->w_size;
+ if (dictionary != Z_NULL && len)
+ zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
+ if (dictLength != Z_NULL)
+ *dictLength = len;
+ return Z_OK;
+}
+
+/* ========================================================================= */
int ZEXPORT deflateResetKeep (strm)
z_streamp strm;
{
deflate_state *s;
- if (strm == Z_NULL || strm->state == Z_NULL ||
- strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
+ if (deflateStateCheck(strm)) {
return Z_STREAM_ERROR;
}
if (s->wrap < 0) {
s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
}
- s->status = s->wrap ? INIT_STATE : BUSY_STATE;
+ s->status =
+#ifdef GZIP
+ s->wrap == 2 ? GZIP_STATE :
+#endif
+ s->wrap ? INIT_STATE : BUSY_STATE;
strm->adler =
#ifdef GZIP
s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
z_streamp strm;
gz_headerp head;
{
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
- if (strm->state->wrap != 2) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm) || strm->state->wrap != 2)
+ return Z_STREAM_ERROR;
strm->state->gzhead = head;
return Z_OK;
}
int *bits;
z_streamp strm;
{
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
if (pending != Z_NULL)
*pending = strm->state->pending;
if (bits != Z_NULL)
deflate_state *s;
int put;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
return Z_BUF_ERROR;
{
deflate_state *s;
compress_func func;
- int err = Z_OK;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
#ifdef FASTEST
func = configuration_table[s->level].func;
if ((strategy != s->strategy || func != configuration_table[level].func) &&
- strm->total_in != 0) {
+ s->high_water) {
/* Flush the last buffer: */
- err = deflate(strm, Z_BLOCK);
- if (err == Z_BUF_ERROR && s->pending == 0)
- err = Z_OK;
+ int err = deflate(strm, Z_BLOCK);
+ if (err == Z_STREAM_ERROR)
+ return err;
+ if (strm->avail_out == 0)
+ return Z_BUF_ERROR;
}
if (s->level != level) {
+ if (s->level == 0 && s->matches != 0) {
+ if (s->matches == 1)
+ slide_hash(s);
+ else
+ CLEAR_HASH(s);
+ s->matches = 0;
+ }
s->level = level;
s->max_lazy_match = configuration_table[level].max_lazy;
s->good_match = configuration_table[level].good_length;
s->max_chain_length = configuration_table[level].max_chain;
}
s->strategy = strategy;
- return err;
+ return Z_OK;
}
/* ========================================================================= */
{
deflate_state *s;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
- s->good_match = good_length;
- s->max_lazy_match = max_lazy;
+ s->good_match = (uInt)good_length;
+ s->max_lazy_match = (uInt)max_lazy;
s->nice_match = nice_length;
- s->max_chain_length = max_chain;
+ s->max_chain_length = (uInt)max_chain;
return Z_OK;
}
{
deflate_state *s;
uLong complen, wraplen;
- Bytef *str;
/* conservative upper bound for compressed data */
complen = sourceLen +
((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
/* if can't get parameters, return conservative bound plus zlib wrapper */
- if (strm == Z_NULL || strm->state == Z_NULL)
+ if (deflateStateCheck(strm))
return complen + 6;
/* compute wrapper length */
case 1: /* zlib wrapper */
wraplen = 6 + (s->strstart ? 4 : 0);
break;
+#ifdef GZIP
case 2: /* gzip wrapper */
wraplen = 18;
if (s->gzhead != Z_NULL) { /* user-supplied gzip header */
+ Bytef *str;
if (s->gzhead->extra != Z_NULL)
wraplen += 2 + s->gzhead->extra_len;
str = s->gzhead->name;
wraplen += 2;
}
break;
+#endif
default: /* for compiler happiness */
wraplen = 6;
}
}
/* =========================================================================
- * Flush as much pending output as possible. All deflate() output goes
- * through this function so some applications may wish to modify it
- * to avoid allocating a large strm->next_out buffer and copying into it.
- * (See also read_buf()).
+ * Flush as much pending output as possible. All deflate() output, except for
+ * some deflate_stored() output, goes through this function so some
+ * applications may wish to modify it to avoid allocating a large
+ * strm->next_out buffer and copying into it. (See also read_buf()).
*/
local void flush_pending(strm)
z_streamp strm;
strm->next_out += len;
s->pending_out += len;
strm->total_out += len;
- strm->avail_out -= len;
- s->pending -= len;
+ strm->avail_out -= len;
+ s->pending -= len;
if (s->pending == 0) {
s->pending_out = s->pending_buf;
}
}
+/* ===========================================================================
+ * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
+ */
+#define HCRC_UPDATE(beg) \
+ do { \
+ if (s->gzhead->hcrc && s->pending > (beg)) \
+ strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
+ s->pending - (beg)); \
+ } while (0)
+
/* ========================================================================= */
int ZEXPORT deflate (strm, flush)
z_streamp strm;
int old_flush; /* value of flush param for previous deflate call */
deflate_state *s;
- if (strm == Z_NULL || strm->state == Z_NULL ||
- flush > Z_BLOCK || flush < 0) {
+ if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
return Z_STREAM_ERROR;
}
s = strm->state;
if (strm->next_out == Z_NULL ||
- (strm->next_in == Z_NULL && strm->avail_in != 0) ||
+ (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
(s->status == FINISH_STATE && flush != Z_FINISH)) {
ERR_RETURN(strm, Z_STREAM_ERROR);
}
if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
- s->strm = strm; /* just in case */
old_flush = s->last_flush;
s->last_flush = flush;
+ /* Flush as much pending output as possible */
+ if (s->pending != 0) {
+ flush_pending(strm);
+ if (strm->avail_out == 0) {
+ /* Since avail_out is 0, deflate will be called again with
+ * more output space, but possibly with both pending and
+ * avail_in equal to zero. There won't be anything to do,
+ * but this is not an error situation so make sure we
+ * return OK instead of BUF_ERROR at next call of deflate:
+ */
+ s->last_flush = -1;
+ return Z_OK;
+ }
+
+ /* Make sure there is something to do and avoid duplicate consecutive
+ * flushes. For repeated and useless calls with Z_FINISH, we keep
+ * returning Z_STREAM_END instead of Z_BUF_ERROR.
+ */
+ } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
+ flush != Z_FINISH) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
+ /* User must not provide more input after the first FINISH: */
+ if (s->status == FINISH_STATE && strm->avail_in != 0) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
/* Write the header */
if (s->status == INIT_STATE) {
-#ifdef GZIP
- if (s->wrap == 2) {
- strm->adler = crc32(0L, Z_NULL, 0);
- put_byte(s, 31);
- put_byte(s, 139);
- put_byte(s, 8);
- if (s->gzhead == Z_NULL) {
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, s->level == 9 ? 2 :
- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
- 4 : 0));
- put_byte(s, OS_CODE);
- s->status = BUSY_STATE;
- }
- else {
- put_byte(s, (s->gzhead->text ? 1 : 0) +
- (s->gzhead->hcrc ? 2 : 0) +
- (s->gzhead->extra == Z_NULL ? 0 : 4) +
- (s->gzhead->name == Z_NULL ? 0 : 8) +
- (s->gzhead->comment == Z_NULL ? 0 : 16)
- );
- put_byte(s, (Byte)(s->gzhead->time & 0xff));
- put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
- put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
- put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
- put_byte(s, s->level == 9 ? 2 :
- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
- 4 : 0));
- put_byte(s, s->gzhead->os & 0xff);
- if (s->gzhead->extra != Z_NULL) {
- put_byte(s, s->gzhead->extra_len & 0xff);
- put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
- }
- if (s->gzhead->hcrc)
- strm->adler = crc32(strm->adler, s->pending_buf,
- s->pending);
- s->gzindex = 0;
- s->status = EXTRA_STATE;
- }
- }
+ /* zlib header */
+ uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+ uInt level_flags;
+
+ if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
+ level_flags = 0;
+ else if (s->level < 6)
+ level_flags = 1;
+ else if (s->level == 6)
+ level_flags = 2;
else
-#endif
- {
- uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
- uInt level_flags;
-
- if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
- level_flags = 0;
- else if (s->level < 6)
- level_flags = 1;
- else if (s->level == 6)
- level_flags = 2;
- else
- level_flags = 3;
- header |= (level_flags << 6);
- if (s->strstart != 0) header |= PRESET_DICT;
- header += 31 - (header % 31);
+ level_flags = 3;
+ header |= (level_flags << 6);
+ if (s->strstart != 0) header |= PRESET_DICT;
+ header += 31 - (header % 31);
+
+ putShortMSB(s, header);
+ /* Save the adler32 of the preset dictionary: */
+ if (s->strstart != 0) {
+ putShortMSB(s, (uInt)(strm->adler >> 16));
+ putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ }
+ strm->adler = adler32(0L, Z_NULL, 0);
+ s->status = BUSY_STATE;
+
+ /* Compression must start with an empty pending buffer */
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+#ifdef GZIP
+ if (s->status == GZIP_STATE) {
+ /* gzip header */
+ strm->adler = crc32(0L, Z_NULL, 0);
+ put_byte(s, 31);
+ put_byte(s, 139);
+ put_byte(s, 8);
+ if (s->gzhead == Z_NULL) {
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, OS_CODE);
s->status = BUSY_STATE;
- putShortMSB(s, header);
- /* Save the adler32 of the preset dictionary: */
- if (s->strstart != 0) {
- putShortMSB(s, (uInt)(strm->adler >> 16));
- putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ /* Compression must start with an empty pending buffer */
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+ else {
+ put_byte(s, (s->gzhead->text ? 1 : 0) +
+ (s->gzhead->hcrc ? 2 : 0) +
+ (s->gzhead->extra == Z_NULL ? 0 : 4) +
+ (s->gzhead->name == Z_NULL ? 0 : 8) +
+ (s->gzhead->comment == Z_NULL ? 0 : 16)
+ );
+ put_byte(s, (Byte)(s->gzhead->time & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, s->gzhead->os & 0xff);
+ if (s->gzhead->extra != Z_NULL) {
+ put_byte(s, s->gzhead->extra_len & 0xff);
+ put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
}
- strm->adler = adler32(0L, Z_NULL, 0);
+ if (s->gzhead->hcrc)
+ strm->adler = crc32(strm->adler, s->pending_buf,
+ s->pending);
+ s->gzindex = 0;
+ s->status = EXTRA_STATE;
}
}
-#ifdef GZIP
if (s->status == EXTRA_STATE) {
if (s->gzhead->extra != Z_NULL) {
- uInt beg = s->pending; /* start of bytes to update crc */
-
- while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
- if (s->pending == s->pending_buf_size) {
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- flush_pending(strm);
- beg = s->pending;
- if (s->pending == s->pending_buf_size)
- break;
+ ulg beg = s->pending; /* start of bytes to update crc */
+ uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
+ while (s->pending + left > s->pending_buf_size) {
+ uInt copy = s->pending_buf_size - s->pending;
+ zmemcpy(s->pending_buf + s->pending,
+ s->gzhead->extra + s->gzindex, copy);
+ s->pending = s->pending_buf_size;
+ HCRC_UPDATE(beg);
+ s->gzindex += copy;
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
}
- put_byte(s, s->gzhead->extra[s->gzindex]);
- s->gzindex++;
- }
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- if (s->gzindex == s->gzhead->extra_len) {
- s->gzindex = 0;
- s->status = NAME_STATE;
+ beg = 0;
+ left -= copy;
}
+ zmemcpy(s->pending_buf + s->pending,
+ s->gzhead->extra + s->gzindex, left);
+ s->pending += left;
+ HCRC_UPDATE(beg);
+ s->gzindex = 0;
}
- else
- s->status = NAME_STATE;
+ s->status = NAME_STATE;
}
if (s->status == NAME_STATE) {
if (s->gzhead->name != Z_NULL) {
- uInt beg = s->pending; /* start of bytes to update crc */
+ ulg beg = s->pending; /* start of bytes to update crc */
int val;
-
do {
if (s->pending == s->pending_buf_size) {
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
+ HCRC_UPDATE(beg);
flush_pending(strm);
- beg = s->pending;
- if (s->pending == s->pending_buf_size) {
- val = 1;
- break;
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
}
+ beg = 0;
}
val = s->gzhead->name[s->gzindex++];
put_byte(s, val);
} while (val != 0);
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- if (val == 0) {
- s->gzindex = 0;
- s->status = COMMENT_STATE;
- }
+ HCRC_UPDATE(beg);
+ s->gzindex = 0;
}
- else
- s->status = COMMENT_STATE;
+ s->status = COMMENT_STATE;
}
if (s->status == COMMENT_STATE) {
if (s->gzhead->comment != Z_NULL) {
- uInt beg = s->pending; /* start of bytes to update crc */
+ ulg beg = s->pending; /* start of bytes to update crc */
int val;
-
do {
if (s->pending == s->pending_buf_size) {
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
+ HCRC_UPDATE(beg);
flush_pending(strm);
- beg = s->pending;
- if (s->pending == s->pending_buf_size) {
- val = 1;
- break;
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
}
+ beg = 0;
}
val = s->gzhead->comment[s->gzindex++];
put_byte(s, val);
} while (val != 0);
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- if (val == 0)
- s->status = HCRC_STATE;
+ HCRC_UPDATE(beg);
}
- else
- s->status = HCRC_STATE;
+ s->status = HCRC_STATE;
}
if (s->status == HCRC_STATE) {
if (s->gzhead->hcrc) {
- if (s->pending + 2 > s->pending_buf_size)
+ if (s->pending + 2 > s->pending_buf_size) {
flush_pending(strm);
- if (s->pending + 2 <= s->pending_buf_size) {
- put_byte(s, (Byte)(strm->adler & 0xff));
- put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
- strm->adler = crc32(0L, Z_NULL, 0);
- s->status = BUSY_STATE;
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
}
+ put_byte(s, (Byte)(strm->adler & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+ strm->adler = crc32(0L, Z_NULL, 0);
}
- else
- s->status = BUSY_STATE;
- }
-#endif
+ s->status = BUSY_STATE;
- /* Flush as much pending output as possible */
- if (s->pending != 0) {
+ /* Compression must start with an empty pending buffer */
flush_pending(strm);
- if (strm->avail_out == 0) {
- /* Since avail_out is 0, deflate will be called again with
- * more output space, but possibly with both pending and
- * avail_in equal to zero. There won't be anything to do,
- * but this is not an error situation so make sure we
- * return OK instead of BUF_ERROR at next call of deflate:
- */
+ if (s->pending != 0) {
s->last_flush = -1;
return Z_OK;
}
-
- /* Make sure there is something to do and avoid duplicate consecutive
- * flushes. For repeated and useless calls with Z_FINISH, we keep
- * returning Z_STREAM_END instead of Z_BUF_ERROR.
- */
- } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
- flush != Z_FINISH) {
- ERR_RETURN(strm, Z_BUF_ERROR);
- }
-
- /* User must not provide more input after the first FINISH: */
- if (s->status == FINISH_STATE && strm->avail_in != 0) {
- ERR_RETURN(strm, Z_BUF_ERROR);
}
+#endif
/* Start a new block or continue the current one.
*/
(flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
block_state bstate;
- bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
- (s->strategy == Z_RLE ? deflate_rle(s, flush) :
- (*(configuration_table[s->level].func))(s, flush));
+ bstate = s->level == 0 ? deflate_stored(s, flush) :
+ s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
+ s->strategy == Z_RLE ? deflate_rle(s, flush) :
+ (*(configuration_table[s->level].func))(s, flush);
if (bstate == finish_started || bstate == finish_done) {
s->status = FINISH_STATE;
}
}
}
- Assert(strm->avail_out > 0, "bug2");
if (flush != Z_FINISH) return Z_OK;
if (s->wrap <= 0) return Z_STREAM_END;
{
int status;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
status = strm->state->status;
- if (status != INIT_STATE &&
- status != EXTRA_STATE &&
- status != NAME_STATE &&
- status != COMMENT_STATE &&
- status != HCRC_STATE &&
- status != BUSY_STATE &&
- status != FINISH_STATE) {
- return Z_STREAM_ERROR;
- }
/* Deallocate in reverse order of allocations: */
TRY_FREE(strm, strm->state->pending_buf);
ushf *overlay;
- if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
+ if (deflateStateCheck(source) || dest == Z_NULL) {
return Z_STREAM_ERROR;
}
* allocating a large strm->next_in buffer and copying from it.
* (See also flush_pending()).
*/
-local int read_buf(strm, buf, size)
+local unsigned read_buf(strm, buf, size)
z_streamp strm;
Bytef *buf;
unsigned size;
strm->next_in += len;
strm->total_in += len;
- return (int)len;
+ return len;
}
/* ===========================================================================
{
unsigned chain_length = s->max_chain_length;/* max hash chain length */
register Bytef *scan = s->window + s->strstart; /* current string */
- register Bytef *match; /* matched string */
+ register Bytef *match; /* matched string */
register int len; /* length of current match */
- int best_len = s->prev_length; /* best match length so far */
+ int best_len = (int)s->prev_length; /* best match length so far */
int nice_match = s->nice_match; /* stop if match long enough */
IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
s->strstart - (IPos)MAX_DIST(s) : NIL;
/* Do not look for matches beyond the end of the input. This is necessary
* to make deflate deterministic.
*/
- if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+ if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
#endif /* FASTEST */
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
/* ===========================================================================
* Check that the match at match_start is indeed a match.
*/
}
#else
# define check_match(s, start, match, length)
-#endif /* DEBUG */
+#endif /* ZLIB_DEBUG */
/* ===========================================================================
* Fill the window when the lookahead becomes insufficient.
local void fill_window(s)
deflate_state *s;
{
- register unsigned n, m;
- register Posf *p;
+ unsigned n;
unsigned more; /* Amount of free space at the end of the window. */
uInt wsize = s->w_size;
*/
if (s->strstart >= wsize+MAX_DIST(s)) {
- zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
+ zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more);
s->match_start -= wsize;
s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
s->block_start -= (long) wsize;
-
- /* Slide the hash table (could be avoided with 32 bit values
- at the expense of memory usage). We slide even when level == 0
- to keep the hash table consistent if we switch back to level > 0
- later. (Using level 0 permanently is not an optimal usage of
- zlib, so we don't care about this pathological case.)
- */
- n = s->hash_size;
- p = &s->head[n];
- do {
- m = *--p;
- *p = (Pos)(m >= wsize ? m-wsize : NIL);
- } while (--n);
-
- n = wsize;
-#ifndef FASTEST
- p = &s->prev[n];
- do {
- m = *--p;
- *p = (Pos)(m >= wsize ? m-wsize : NIL);
- /* If n is not on any hash chain, prev[n] is garbage but
- * its value will never be used.
- */
- } while (--n);
-#endif
+ slide_hash(s);
more += wsize;
}
if (s->strm->avail_in == 0) break;
if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
}
+/* Maximum stored block length in deflate format (not including header). */
+#define MAX_STORED 65535
+
+/* Minimum of a and b. */
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
+
/* ===========================================================================
* Copy without compression as much as possible from the input stream, return
* the current block state.
- * This function does not insert new strings in the dictionary since
- * uncompressible data is probably not useful. This function is used
- * only for the level=0 compression option.
- * NOTE: this function should be optimized to avoid extra copying from
- * window to pending_buf.
+ *
+ * In case deflateParams() is used to later switch to a non-zero compression
+ * level, s->matches (otherwise unused when storing) keeps track of the number
+ * of hash table slides to perform. If s->matches is 1, then one hash table
+ * slide will be done when switching. If s->matches is 2, the maximum value
+ * allowed here, then the hash table will be cleared, since two or more slides
+ * is the same as a clear.
+ *
+ * deflate_stored() is written to minimize the number of times an input byte is
+ * copied. It is most efficient with large input and output buffers, which
+ * maximizes the opportunites to have a single copy from next_in to next_out.
*/
local block_state deflate_stored(s, flush)
deflate_state *s;
int flush;
{
- /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
- * to pending_buf_size, and each stored block has a 5 byte header:
+ /* Smallest worthy block size when not flushing or finishing. By default
+ * this is 32K. This can be as small as 507 bytes for memLevel == 1. For
+ * large input and output buffers, the stored block size will be larger.
*/
- ulg max_block_size = 0xffff;
- ulg max_start;
-
- if (max_block_size > s->pending_buf_size - 5) {
- max_block_size = s->pending_buf_size - 5;
- }
+ unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);
- /* Copy as much as possible from input to output: */
- for (;;) {
- /* Fill the window as much as possible: */
- if (s->lookahead <= 1) {
-
- Assert(s->strstart < s->w_size+MAX_DIST(s) ||
- s->block_start >= (long)s->w_size, "slide too late");
+ /* Copy as many min_block or larger stored blocks directly to next_out as
+ * possible. If flushing, copy the remaining available input to next_out as
+ * stored blocks, if there is enough space.
+ */
+ unsigned len, left, have, last = 0;
+ unsigned used = s->strm->avail_in;
+ do {
+ /* Set len to the maximum size block that we can copy directly with the
+ * available input data and output space. Set left to how much of that
+ * would be copied from what's left in the window.
+ */
+ len = MAX_STORED; /* maximum deflate stored block length */
+ have = (s->bi_valid + 42) >> 3; /* number of header bytes */
+ if (s->strm->avail_out < have) /* need room for header */
+ break;
+ /* maximum stored block length that will fit in avail_out: */
+ have = s->strm->avail_out - have;
+ left = s->strstart - s->block_start; /* bytes left in window */
+ if (len > (ulg)left + s->strm->avail_in)
+ len = left + s->strm->avail_in; /* limit len to the input */
+ if (len > have)
+ len = have; /* limit len to the output */
+
+ /* If the stored block would be less than min_block in length, or if
+ * unable to copy all of the available input when flushing, then try
+ * copying to the window and the pending buffer instead. Also don't
+ * write an empty block when flushing -- deflate() does that.
+ */
+ if (len < min_block && ((len == 0 && flush != Z_FINISH) ||
+ flush == Z_NO_FLUSH ||
+ len != left + s->strm->avail_in))
+ break;
- fill_window(s);
- if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
+ /* Make a dummy stored block in pending to get the header bytes,
+ * including any pending bits. This also updates the debugging counts.
+ */
+ last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
+ _tr_stored_block(s, (char *)0, 0L, last);
+
+ /* Replace the lengths in the dummy stored block with len. */
+ s->pending_buf[s->pending - 4] = len;
+ s->pending_buf[s->pending - 3] = len >> 8;
+ s->pending_buf[s->pending - 2] = ~len;
+ s->pending_buf[s->pending - 1] = ~len >> 8;
+
+ /* Write the stored block header bytes. */
+ flush_pending(s->strm);
+
+#ifdef ZLIB_DEBUG
+ /* Update debugging counts for the data about to be copied. */
+ s->compressed_len += len << 3;
+ s->bits_sent += len << 3;
+#endif
- if (s->lookahead == 0) break; /* flush the current block */
+ /* Copy uncompressed bytes from the window to next_out. */
+ if (left) {
+ if (left > len)
+ left = len;
+ zmemcpy(s->strm->next_out, s->window + s->block_start, left);
+ s->strm->next_out += left;
+ s->strm->avail_out -= left;
+ s->strm->total_out += left;
+ s->block_start += left;
+ len -= left;
}
- Assert(s->block_start >= 0L, "block gone");
-
- s->strstart += s->lookahead;
- s->lookahead = 0;
-
- /* Emit a stored block if pending_buf will be full: */
- max_start = s->block_start + max_block_size;
- if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
- /* strstart == 0 is possible when wraparound on 16-bit machine */
- s->lookahead = (uInt)(s->strstart - max_start);
- s->strstart = (uInt)max_start;
- FLUSH_BLOCK(s, 0);
+
+ /* Copy uncompressed bytes directly from next_in to next_out, updating
+ * the check value.
+ */
+ if (len) {
+ read_buf(s->strm, s->strm->next_out, len);
+ s->strm->next_out += len;
+ s->strm->avail_out -= len;
+ s->strm->total_out += len;
}
- /* Flush if we may have to slide, otherwise block_start may become
- * negative and the data will be gone:
+ } while (last == 0);
+
+ /* Update the sliding window with the last s->w_size bytes of the copied
+ * data, or append all of the copied data to the existing window if less
+ * than s->w_size bytes were copied. Also update the number of bytes to
+ * insert in the hash tables, in the event that deflateParams() switches to
+ * a non-zero compression level.
+ */
+ used -= s->strm->avail_in; /* number of input bytes directly copied */
+ if (used) {
+ /* If any input was used, then no unused input remains in the window,
+ * therefore s->block_start == s->strstart.
*/
- if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
- FLUSH_BLOCK(s, 0);
+ if (used >= s->w_size) { /* supplant the previous history */
+ s->matches = 2; /* clear hash */
+ zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
+ s->strstart = s->w_size;
}
+ else {
+ if (s->window_size - s->strstart <= used) {
+ /* Slide the window down. */
+ s->strstart -= s->w_size;
+ zmemcpy(s->window, s->window + s->w_size, s->strstart);
+ if (s->matches < 2)
+ s->matches++; /* add a pending slide_hash() */
+ }
+ zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
+ s->strstart += used;
+ }
+ s->block_start = s->strstart;
+ s->insert += MIN(used, s->w_size - s->insert);
}
- s->insert = 0;
- if (flush == Z_FINISH) {
- FLUSH_BLOCK(s, 1);
+ if (s->high_water < s->strstart)
+ s->high_water = s->strstart;
+
+ /* If the last block was written to next_out, then done. */
+ if (last)
return finish_done;
+
+ /* If flushing and all input has been consumed, then done. */
+ if (flush != Z_NO_FLUSH && flush != Z_FINISH &&
+ s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
+ return block_done;
+
+ /* Fill the window with any remaining input. */
+ have = s->window_size - s->strstart - 1;
+ if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
+ /* Slide the window down. */
+ s->block_start -= s->w_size;
+ s->strstart -= s->w_size;
+ zmemcpy(s->window, s->window + s->w_size, s->strstart);
+ if (s->matches < 2)
+ s->matches++; /* add a pending slide_hash() */
+ have += s->w_size; /* more space now */
}
- if ((long)s->strstart > s->block_start)
- FLUSH_BLOCK(s, 0);
- return block_done;
+ if (have > s->strm->avail_in)
+ have = s->strm->avail_in;
+ if (have) {
+ read_buf(s->strm, s->window + s->strstart, have);
+ s->strstart += have;
+ }
+ if (s->high_water < s->strstart)
+ s->high_water = s->strstart;
+
+ /* There was not enough avail_out to write a complete worthy or flushed
+ * stored block to next_out. Write a stored block to pending instead, if we
+ * have enough input for a worthy block, or if flushing and there is enough
+ * room for the remaining input as a stored block in the pending buffer.
+ */
+ have = (s->bi_valid + 42) >> 3; /* number of header bytes */
+ /* maximum stored block length that will fit in pending: */
+ have = MIN(s->pending_buf_size - have, MAX_STORED);
+ min_block = MIN(have, s->w_size);
+ left = s->strstart - s->block_start;
+ if (left >= min_block ||
+ ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH &&
+ s->strm->avail_in == 0 && left <= have)) {
+ len = MIN(left, have);
+ last = flush == Z_FINISH && s->strm->avail_in == 0 &&
+ len == left ? 1 : 0;
+ _tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
+ s->block_start += len;
+ flush_pending(s->strm);
+ }
+
+ /* We've done all we can with the available input and output. */
+ return last ? finish_started : need_more;
}
/* ===========================================================================
prev == *++scan && prev == *++scan &&
prev == *++scan && prev == *++scan &&
scan < strend);
- s->match_length = MAX_MATCH - (int)(strend - scan);
+ s->match_length = MAX_MATCH - (uInt)(strend - scan);
if (s->match_length > s->lookahead)
s->match_length = s->lookahead;
}
/* deflate.h -- internal compression state
- * Copyright (C) 1995-2012 Jean-loup Gailly
+ * Copyright (C) 1995-2016 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#define Buf_size 16
/* size of bit buffer in bi_buf */
-#define INIT_STATE 42
-#define EXTRA_STATE 69
-#define NAME_STATE 73
-#define COMMENT_STATE 91
-#define HCRC_STATE 103
-#define BUSY_STATE 113
-#define FINISH_STATE 666
+#define INIT_STATE 42 /* zlib header -> BUSY_STATE */
+#ifdef GZIP
+# define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */
+#endif
+#define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */
+#define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */
+#define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */
+#define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */
+#define BUSY_STATE 113 /* deflate -> FINISH_STATE */
+#define FINISH_STATE 666 /* stream complete */
/* Stream status */
typedef struct tree_desc_s {
ct_data *dyn_tree; /* the dynamic tree */
int max_code; /* largest code with non zero frequency */
- static_tree_desc *stat_desc; /* the corresponding static tree */
+ const static_tree_desc *stat_desc; /* the corresponding static tree */
} FAR tree_desc;
typedef ush Pos;
Bytef *pending_buf; /* output still pending */
ulg pending_buf_size; /* size of pending_buf */
Bytef *pending_out; /* next pending byte to output to the stream */
- uInt pending; /* nb of bytes in the pending buffer */
+ ulg pending; /* nb of bytes in the pending buffer */
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
gz_headerp gzhead; /* gzip header information to write */
- uInt gzindex; /* where in extra, name, or comment */
+ ulg gzindex; /* where in extra, name, or comment */
Byte method; /* can only be DEFLATED */
int last_flush; /* value of flush param for previous deflate call */
uInt matches; /* number of string matches in current block */
uInt insert; /* bytes at end of window left to insert */
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
ulg compressed_len; /* total bit length of compressed file mod 2^32 */
ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
#endif
/* Output a byte on the stream.
* IN assertion: there is enough room in pending_buf.
*/
-#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
* used.
*/
-#ifndef DEBUG
+#ifndef ZLIB_DEBUG
/* Inline versions of _tr_tally for speed: */
#if defined(GEN_TREES_H) || !defined(STDC)
flush = (s->last_lit == s->lit_bufsize-1); \
}
# define _tr_tally_dist(s, distance, length, flush) \
- { uch len = (length); \
- ush dist = (distance); \
+ { uch len = (uch)(length); \
+ ush dist = (ush)(distance); \
s->d_buf[s->last_lit] = dist; \
s->l_buf[s->last_lit++] = len; \
dist--; \
/* gzguts.h -- zlib internal header definitions for gz* operations
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
# include <stdlib.h>
# include <limits.h>
#endif
+
+#ifndef _POSIX_SOURCE
+# define _POSIX_SOURCE
+#endif
#include <fcntl.h>
#ifdef _WIN32
# include <io.h>
#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+# define WIDECHAR
+#endif
+
#ifdef WINAPI_FAMILY
# define open _open
# define read _read
# endif
#endif
-/* unlike snprintf (which is required in C99, yet still not supported by
- Microsoft more than a decade later!), _snprintf does not guarantee null
- termination of the result -- however this is only used in gzlib.c where
+/* unlike snprintf (which is required in C99), _snprintf does not guarantee
+ null termination of the result -- however this is only used in gzlib.c where
the result is assured to fit in the space provided */
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && _MSC_VER < 1900
# define snprintf _snprintf
#endif
#ifndef local
# define local static
#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
+/* since "static" is used to mean two completely different things in C, we
+ define "local" for the non-static meaning of "static", for readability
+ (compile with -Dlocal if your debugger can't find static symbols) */
/* gz* functions always use library allocation functions */
#ifndef STDC
char *path; /* path or fd for error messages */
unsigned size; /* buffer size, zero if not allocated yet */
unsigned want; /* requested buffer size, default is GZBUFSIZE */
- unsigned char *in; /* input buffer */
+ unsigned char *in; /* input buffer (double-sized when writing) */
unsigned char *out; /* output buffer (double-sized when reading) */
int direct; /* 0 if processing gzip, 1 if transparent */
/* just for reading */
/* gzlib.c -- zlib functions common to reading and writing gzip files
- * Copyright (C) 2004, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "gzguts.h"
-#if defined(_WIN32) && !defined(__BORLANDC__)
+#if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
# define LSEEK _lseeki64
#else
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
const char *mode;
{
gz_statep state;
- size_t len;
+ z_size_t len;
int oflag;
#ifdef O_CLOEXEC
int cloexec = 0;
}
/* save the path name for error messages */
-#ifdef _WIN32
+#ifdef WIDECHAR
if (fd == -2) {
len = wcstombs(NULL, path, 0);
- if (len == (size_t)-1)
+ if (len == (z_size_t)-1)
len = 0;
}
else
free(state);
return NULL;
}
-#ifdef _WIN32
+#ifdef WIDECHAR
if (fd == -2)
if (len)
wcstombs(state->path, path, len + 1);
else
#endif
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
- snprintf(state->path, len + 1, "%s", (const char *)path);
+ (void)snprintf(state->path, len + 1, "%s", (const char *)path);
#else
strcpy(state->path, path);
#endif
/* open the file with the appropriate flags (or just use fd) */
state->fd = fd > -1 ? fd : (
-#ifdef _WIN32
+#ifdef WIDECHAR
fd == -2 ? _wopen(path, oflag, 0666) :
#endif
open((const char *)path, oflag, 0666));
free(state);
return NULL;
}
- if (state->mode == GZ_APPEND)
+ if (state->mode == GZ_APPEND) {
+ LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */
state->mode = GZ_WRITE; /* simplify later checks */
+ }
/* save the current position for rewinding (only if reading) */
if (state->mode == GZ_READ) {
if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
return NULL;
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
- snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */
+ (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
#else
sprintf(path, "<fd:%d>", fd); /* for debugging */
#endif
}
/* -- see zlib.h -- */
-#ifdef _WIN32
+#ifdef WIDECHAR
gzFile ZEXPORT gzopen_w(path, mode)
const wchar_t *path;
const char *mode;
return -1;
/* check and set requested size */
+ if ((size << 1) < size)
+ return -1; /* need to be able to double it */
if (size < 2)
size = 2; /* need two bytes to check magic header */
state->want = size;
return;
}
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
- snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
- "%s%s%s", state->path, ": ", msg);
+ (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
+ "%s%s%s", state->path, ": ", msg);
#else
strcpy(state->msg, state->path);
strcat(state->msg, ": ");
strcat(state->msg, msg);
#endif
- return;
}
#ifndef INT_MAX
/* gzread.c -- zlib functions for reading gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
local int gz_decomp OF((gz_statep));
local int gz_fetch OF((gz_statep));
local int gz_skip OF((gz_statep, z_off64_t));
+local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
state->fd, and update state->eof, state->err, and state->msg as appropriate.
unsigned *have;
{
int ret;
+ unsigned get, max = ((unsigned)-1 >> 2) + 1;
*have = 0;
do {
- ret = read(state->fd, buf + *have, len - *have);
+ get = len - *have;
+ if (get > max)
+ get = max;
+ ret = read(state->fd, buf + *have, get);
if (ret <= 0)
break;
- *have += ret;
+ *have += (unsigned)ret;
} while (*have < len);
if (ret < 0) {
gz_error(state, Z_ERRNO, zstrerror());
state->in = (unsigned char *)malloc(state->want);
state->out = (unsigned char *)malloc(state->want << 1);
if (state->in == NULL || state->out == NULL) {
- if (state->out != NULL)
- free(state->out);
- if (state->in != NULL)
- free(state->in);
+ free(state->out);
+ free(state->in);
gz_error(state, Z_MEM_ERROR, "out of memory");
return -1;
}
return 0;
}
-/* -- see zlib.h -- */
-int ZEXPORT gzread(file, buf, len)
- gzFile file;
+/* Read len bytes into buf from file, or less than len up to the end of the
+ input. Return the number of bytes read. If zero is returned, either the
+ end of file was reached, or there was an error. state->err must be
+ consulted in that case to determine which. */
+local z_size_t gz_read(state, buf, len)
+ gz_statep state;
voidp buf;
- unsigned len;
+ z_size_t len;
{
- unsigned got, n;
- gz_statep state;
- z_streamp strm;
-
- /* get internal structure */
- if (file == NULL)
- return -1;
- state = (gz_statep)file;
- strm = &(state->strm);
-
- /* check that we're reading and that there's no (serious) error */
- if (state->mode != GZ_READ ||
- (state->err != Z_OK && state->err != Z_BUF_ERROR))
- return -1;
-
- /* since an int is returned, make sure len fits in one, otherwise return
- with an error (this avoids the flaw in the interface) */
- if ((int)len < 0) {
- gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
- return -1;
- }
+ z_size_t got;
+ unsigned n;
/* if len is zero, avoid unnecessary operations */
if (len == 0)
if (state->seek) {
state->seek = 0;
if (gz_skip(state, state->skip) == -1)
- return -1;
+ return 0;
}
/* get len bytes to buf, or less than len if at the end */
got = 0;
do {
+ /* set n to the maximum amount of len that fits in an unsigned int */
+ n = -1;
+ if (n > len)
+ n = len;
+
/* first just try copying data from the output buffer */
if (state->x.have) {
- n = state->x.have > len ? len : state->x.have;
+ if (state->x.have < n)
+ n = state->x.have;
memcpy(buf, state->x.next, n);
state->x.next += n;
state->x.have -= n;
}
/* output buffer empty -- return if we're at the end of the input */
- else if (state->eof && strm->avail_in == 0) {
+ else if (state->eof && state->strm.avail_in == 0) {
state->past = 1; /* tried to read past end */
break;
}
/* need output data -- for small len or new stream load up our output
buffer */
- else if (state->how == LOOK || len < (state->size << 1)) {
+ else if (state->how == LOOK || n < (state->size << 1)) {
/* get more output, looking for header if required */
if (gz_fetch(state) == -1)
- return -1;
+ return 0;
continue; /* no progress yet -- go back to copy above */
/* the copy above assures that we will leave with space in the
output buffer, allowing at least one gzungetc() to succeed */
/* large len -- read directly into user buffer */
else if (state->how == COPY) { /* read directly */
- if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
- return -1;
+ if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
+ return 0;
}
/* large len -- decompress directly into user buffer */
else { /* state->how == GZIP */
- strm->avail_out = len;
- strm->next_out = (unsigned char *)buf;
+ state->strm.avail_out = n;
+ state->strm.next_out = (unsigned char *)buf;
if (gz_decomp(state) == -1)
- return -1;
+ return 0;
n = state->x.have;
state->x.have = 0;
}
state->x.pos += n;
} while (len);
- /* return number of bytes read into user buffer (will fit in int) */
- return (int)got;
+ /* return number of bytes read into user buffer */
+ return got;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzread(file, buf, len)
+ gzFile file;
+ voidp buf;
+ unsigned len;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return -1;
+
+ /* since an int is returned, make sure len fits in one, otherwise return
+ with an error (this avoids a flaw in the interface) */
+ if ((int)len < 0) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
+ return -1;
+ }
+
+ /* read len or fewer bytes to buf */
+ len = gz_read(state, buf, len);
+
+ /* check for an error */
+ if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
+ return -1;
+
+ /* return the number of bytes read (this is assured to fit in an int) */
+ return (int)len;
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfread(buf, size, nitems, file)
+ voidp buf;
+ z_size_t size;
+ z_size_t nitems;
+ gzFile file;
+{
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return 0;
+
+ /* compute bytes to read -- error on overflow */
+ len = nitems * size;
+ if (size && len / size != nitems) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+ return 0;
+ }
+
+ /* read len or fewer bytes to buf, return the number of full items read */
+ return len ? gz_read(state, buf, len) / size : 0;
}
/* -- see zlib.h -- */
return *(state->x.next)++;
}
- /* nothing there -- try gzread() */
- ret = gzread(file, buf, 1);
+ /* nothing there -- try gz_read() */
+ ret = gz_read(state, buf, 1);
return ret < 1 ? -1 : buf[0];
}
if (state->x.have == 0) {
state->x.have = 1;
state->x.next = state->out + (state->size << 1) - 1;
- state->x.next[0] = c;
+ state->x.next[0] = (unsigned char)c;
state->x.pos--;
state->past = 0;
return c;
}
state->x.have++;
state->x.next--;
- state->x.next[0] = c;
+ state->x.next[0] = (unsigned char)c;
state->x.pos--;
state->past = 0;
return c;
/* gzwrite.c -- zlib functions for writing gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
local int gz_init OF((gz_statep));
local int gz_comp OF((gz_statep, int));
local int gz_zero OF((gz_statep, z_off64_t));
+local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
/* Initialize state for writing a gzip file. Mark initialization by setting
- state->size to non-zero. Return -1 on failure or 0 on success. */
+ state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
+ success. */
local int gz_init(state)
gz_statep state;
{
int ret;
z_streamp strm = &(state->strm);
- /* allocate input buffer */
- state->in = (unsigned char *)malloc(state->want);
+ /* allocate input buffer (double size for gzprintf) */
+ state->in = (unsigned char *)malloc(state->want << 1);
if (state->in == NULL) {
gz_error(state, Z_MEM_ERROR, "out of memory");
return -1;
gz_error(state, Z_MEM_ERROR, "out of memory");
return -1;
}
+ strm->next_in = NULL;
}
/* mark state as initialized */
}
/* Compress whatever is at avail_in and next_in and write to the output file.
- Return -1 if there is an error writing to the output file, otherwise 0.
- flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH,
- then the deflate() state is reset to start a new gzip stream. If gz->direct
- is true, then simply write to the output file without compressing, and
- ignore flush. */
+ Return -1 if there is an error writing to the output file or if gz_init()
+ fails to allocate memory, otherwise 0. flush is assumed to be a valid
+ deflate() flush value. If flush is Z_FINISH, then the deflate() state is
+ reset to start a new gzip stream. If gz->direct is true, then simply write
+ to the output file without compressing, and ignore flush. */
local int gz_comp(state, flush)
gz_statep state;
int flush;
{
- int ret, got;
- unsigned have;
+ int ret, writ;
+ unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
z_streamp strm = &(state->strm);
/* allocate memory if this is the first time through */
/* write directly if requested */
if (state->direct) {
- got = write(state->fd, strm->next_in, strm->avail_in);
- if (got < 0 || (unsigned)got != strm->avail_in) {
- gz_error(state, Z_ERRNO, zstrerror());
- return -1;
+ while (strm->avail_in) {
+ put = strm->avail_in > max ? max : strm->avail_in;
+ writ = write(state->fd, strm->next_in, put);
+ if (writ < 0) {
+ gz_error(state, Z_ERRNO, zstrerror());
+ return -1;
+ }
+ strm->avail_in -= (unsigned)writ;
+ strm->next_in += writ;
}
- strm->avail_in = 0;
return 0;
}
doing Z_FINISH then don't write until we get to Z_STREAM_END */
if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
(flush != Z_FINISH || ret == Z_STREAM_END))) {
- have = (unsigned)(strm->next_out - state->x.next);
- if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||
- (unsigned)got != have)) {
- gz_error(state, Z_ERRNO, zstrerror());
- return -1;
+ while (strm->next_out > state->x.next) {
+ put = strm->next_out - state->x.next > (int)max ? max :
+ (unsigned)(strm->next_out - state->x.next);
+ writ = write(state->fd, state->x.next, put);
+ if (writ < 0) {
+ gz_error(state, Z_ERRNO, zstrerror());
+ return -1;
+ }
+ state->x.next += writ;
}
if (strm->avail_out == 0) {
strm->avail_out = state->size;
strm->next_out = state->out;
+ state->x.next = state->out;
}
- state->x.next = strm->next_out;
}
/* compress */
return 0;
}
-/* Compress len zeros to output. Return -1 on error, 0 on success. */
+/* Compress len zeros to output. Return -1 on a write error or memory
+ allocation failure by gz_comp(), or 0 on success. */
local int gz_zero(state, len)
gz_statep state;
z_off64_t len;
return 0;
}
-/* -- see zlib.h -- */
-int ZEXPORT gzwrite(file, buf, len)
- gzFile file;
+/* Write len bytes from buf to file. Return the number of bytes written. If
+ the returned value is less than len, then there was an error. */
+local z_size_t gz_write(state, buf, len)
+ gz_statep state;
voidpc buf;
- unsigned len;
+ z_size_t len;
{
- unsigned put = len;
- gz_statep state;
- z_streamp strm;
-
- /* get internal structure */
- if (file == NULL)
- return 0;
- state = (gz_statep)file;
- strm = &(state->strm);
-
- /* check that we're writing and that there's no error */
- if (state->mode != GZ_WRITE || state->err != Z_OK)
- return 0;
-
- /* since an int is returned, make sure len fits in one, otherwise return
- with an error (this avoids the flaw in the interface) */
- if ((int)len < 0) {
- gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
- return 0;
- }
+ z_size_t put = len;
/* if len is zero, avoid unnecessary operations */
if (len == 0)
do {
unsigned have, copy;
- if (strm->avail_in == 0)
- strm->next_in = state->in;
- have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
+ if (state->strm.avail_in == 0)
+ state->strm.next_in = state->in;
+ have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
+ state->in);
copy = state->size - have;
if (copy > len)
copy = len;
memcpy(state->in + have, buf, copy);
- strm->avail_in += copy;
+ state->strm.avail_in += copy;
state->x.pos += copy;
buf = (const char *)buf + copy;
len -= copy;
}
else {
/* consume whatever's left in the input buffer */
- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
+ if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
return 0;
/* directly compress user buffer to file */
- strm->avail_in = len;
- strm->next_in = (z_const Bytef *)buf;
- state->x.pos += len;
- if (gz_comp(state, Z_NO_FLUSH) == -1)
- return 0;
+ state->strm.next_in = (z_const Bytef *)buf;
+ do {
+ unsigned n = (unsigned)-1;
+ if (n > len)
+ n = len;
+ state->strm.avail_in = n;
+ state->x.pos += n;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return 0;
+ len -= n;
+ } while (len);
+ }
+
+ /* input was all buffered or compressed */
+ return put;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzwrite(file, buf, len)
+ gzFile file;
+ voidpc buf;
+ unsigned len;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return 0;
+
+ /* since an int is returned, make sure len fits in one, otherwise return
+ with an error (this avoids a flaw in the interface) */
+ if ((int)len < 0) {
+ gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
+ return 0;
+ }
+
+ /* write len bytes from buf (the return value will fit in an int) */
+ return (int)gz_write(state, buf, len);
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfwrite(buf, size, nitems, file)
+ voidpc buf;
+ z_size_t size;
+ z_size_t nitems;
+ gzFile file;
+{
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return 0;
+
+ /* compute bytes to read -- error on overflow */
+ len = nitems * size;
+ if (size && len / size != nitems) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+ return 0;
}
- /* input was all buffered or compressed (put will fit in int) */
- return (int)put;
+ /* write len bytes to buf, return the number of full items written */
+ return len ? gz_write(state, buf, len) / size : 0;
}
/* -- see zlib.h -- */
strm->next_in = state->in;
have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
if (have < state->size) {
- state->in[have] = c;
+ state->in[have] = (unsigned char)c;
strm->avail_in++;
state->x.pos++;
return c & 0xff;
}
/* no room in buffer or not initialized, use gz_write() */
- buf[0] = c;
- if (gzwrite(file, buf, 1) != 1)
+ buf[0] = (unsigned char)c;
+ if (gz_write(state, buf, 1) != 1)
return -1;
return c & 0xff;
}
const char *str;
{
int ret;
- unsigned len;
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return -1;
/* write string */
- len = (unsigned)strlen(str);
- ret = gzwrite(file, str, len);
+ len = strlen(str);
+ ret = gz_write(state, str, len);
return ret == 0 && len != 0 ? -1 : ret;
}
/* -- see zlib.h -- */
int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
{
- int size, len;
+ int len;
+ unsigned left;
+ char *next;
gz_statep state;
z_streamp strm;
/* get internal structure */
if (file == NULL)
- return -1;
+ return Z_STREAM_ERROR;
state = (gz_statep)file;
strm = &(state->strm);
/* check that we're writing and that there's no error */
if (state->mode != GZ_WRITE || state->err != Z_OK)
- return 0;
+ return Z_STREAM_ERROR;
/* make sure we have some buffer space */
if (state->size == 0 && gz_init(state) == -1)
- return 0;
+ return state->err;
/* check for seek request */
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return 0;
+ return state->err;
}
- /* consume whatever's left in the input buffer */
- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
- return 0;
-
- /* do the printf() into the input buffer, put length in len */
- size = (int)(state->size);
- state->in[size - 1] = 0;
+ /* do the printf() into the input buffer, put length in len -- the input
+ buffer is double-sized just for this function, so there is guaranteed to
+ be state->size bytes available after the current contents */
+ if (strm->avail_in == 0)
+ strm->next_in = state->in;
+ next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
+ next[state->size - 1] = 0;
#ifdef NO_vsnprintf
# ifdef HAS_vsprintf_void
- (void)vsprintf((char *)(state->in), format, va);
- for (len = 0; len < size; len++)
- if (state->in[len] == 0) break;
+ (void)vsprintf(next, format, va);
+ for (len = 0; len < state->size; len++)
+ if (next[len] == 0) break;
# else
- len = vsprintf((char *)(state->in), format, va);
+ len = vsprintf(next, format, va);
# endif
#else
# ifdef HAS_vsnprintf_void
- (void)vsnprintf((char *)(state->in), size, format, va);
- len = strlen((char *)(state->in));
+ (void)vsnprintf(next, state->size, format, va);
+ len = strlen(next);
# else
- len = vsnprintf((char *)(state->in), size, format, va);
+ len = vsnprintf(next, state->size, format, va);
# endif
#endif
/* check that printf() results fit in buffer */
- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
+ if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
return 0;
- /* update buffer and position, defer compression until needed */
- strm->avail_in = (unsigned)len;
- strm->next_in = state->in;
+ /* update buffer and position, compress first half if past that */
+ strm->avail_in += (unsigned)len;
state->x.pos += len;
+ if (strm->avail_in >= state->size) {
+ left = strm->avail_in - state->size;
+ strm->avail_in = state->size;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return state->err;
+ memcpy(state->in, state->in + state->size, left);
+ strm->next_in = state->in;
+ strm->avail_in = left;
+ }
return len;
}
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
{
- int size, len;
+ unsigned len, left;
+ char *next;
gz_statep state;
z_streamp strm;
/* get internal structure */
if (file == NULL)
- return -1;
+ return Z_STREAM_ERROR;
state = (gz_statep)file;
strm = &(state->strm);
/* check that can really pass pointer in ints */
if (sizeof(int) != sizeof(void *))
- return 0;
+ return Z_STREAM_ERROR;
/* check that we're writing and that there's no error */
if (state->mode != GZ_WRITE || state->err != Z_OK)
- return 0;
+ return Z_STREAM_ERROR;
/* make sure we have some buffer space */
if (state->size == 0 && gz_init(state) == -1)
- return 0;
+ return state->error;
/* check for seek request */
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return 0;
+ return state->error;
}
- /* consume whatever's left in the input buffer */
- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
- return 0;
-
- /* do the printf() into the input buffer, put length in len */
- size = (int)(state->size);
- state->in[size - 1] = 0;
+ /* do the printf() into the input buffer, put length in len -- the input
+ buffer is double-sized just for this function, so there is guaranteed to
+ be state->size bytes available after the current contents */
+ if (strm->avail_in == 0)
+ strm->next_in = state->in;
+ next = (char *)(strm->next_in + strm->avail_in);
+ next[state->size - 1] = 0;
#ifdef NO_snprintf
# ifdef HAS_sprintf_void
- sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
+ a13, a14, a15, a16, a17, a18, a19, a20);
for (len = 0; len < size; len++)
- if (state->in[len] == 0) break;
+ if (next[len] == 0)
+ break;
# else
- len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
+ a12, a13, a14, a15, a16, a17, a18, a19, a20);
# endif
#else
# ifdef HAS_snprintf_void
- snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8,
- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
- len = strlen((char *)(state->in));
+ snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ len = strlen(next);
# else
- len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6,
- a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
- a19, a20);
+ len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
# endif
#endif
/* check that printf() results fit in buffer */
- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
+ if (len == 0 || len >= state->size || next[state->size - 1] != 0)
return 0;
- /* update buffer and position, defer compression until needed */
- strm->avail_in = (unsigned)len;
- strm->next_in = state->in;
+ /* update buffer and position, compress first half if past that */
+ strm->avail_in += len;
state->x.pos += len;
- return len;
+ if (strm->avail_in >= state->size) {
+ left = strm->avail_in - state->size;
+ strm->avail_in = state->size;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return state->err;
+ memcpy(state->in, state->in + state->size, left);
+ strm->next_in = state->in;
+ strm->avail_in = left;
+ }
+ return (int)len;
}
#endif
/* get internal structure */
if (file == NULL)
- return -1;
+ return Z_STREAM_ERROR;
state = (gz_statep)file;
/* check that we're writing and that there's no error */
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return -1;
+ return state->err;
}
/* compress remaining data with requested flush */
- gz_comp(state, flush);
+ (void)gz_comp(state, flush);
return state->err;
}
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return -1;
+ return state->err;
}
/* change compression parameters for subsequent input */
if (state->size) {
/* flush previous input with previous parameters before changing */
- if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
+ if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
return state->err;
deflateParams(strm, level, strategy);
}
/* infback.c -- inflate using a call-back interface
- * Copyright (C) 1995-2011 Mark Adler
+ * Copyright (C) 1995-2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state;
state->dmax = 32768U;
- state->wbits = windowBits;
+ state->wbits = (uInt)windowBits;
state->wsize = 1U << windowBits;
state->window = window;
state->wnext = 0;
/* inffast.c -- fast decoding
- * Copyright (C) 1995-2008, 2010, 2013 Mark Adler
+ * Copyright (C) 1995-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "inflate.h"
#include "inffast.h"
-#ifndef ASMINF
-
-/* Allow machine dependent optimization for post-increment or pre-increment.
- Based on testing to date,
- Pre-increment preferred for:
- - PowerPC G3 (Adler)
- - MIPS R5000 (Randers-Pehrson)
- Post-increment preferred for:
- - none
- No measurable difference:
- - Pentium III (Anderson)
- - M68060 (Nikl)
- */
-#ifdef POSTINC
-# define OFF 0
-# define PUP(a) *(a)++
+#ifdef ASMINF
+# pragma message("Assembler code may have bugs -- use at your own risk")
#else
-# define OFF 1
-# define PUP(a) *++(a)
-#endif
/*
Decode literal, length, and distance codes and write out the resulting
/* copy state to local variables */
state = (struct inflate_state FAR *)strm->state;
- in = strm->next_in - OFF;
+ in = strm->next_in;
last = in + (strm->avail_in - 5);
- out = strm->next_out - OFF;
+ out = strm->next_out;
beg = out - (start - strm->avail_out);
end = out + (strm->avail_out - 257);
#ifdef INFLATE_STRICT
input data or output space */
do {
if (bits < 15) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
here = lcode[hold & lmask];
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
"inflate: literal '%c'\n" :
"inflate: literal 0x%02x\n", here.val));
- PUP(out) = (unsigned char)(here.val);
+ *out++ = (unsigned char)(here.val);
}
else if (op & 16) { /* length base */
len = (unsigned)(here.val);
op &= 15; /* number of extra bits */
if (op) {
if (bits < op) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
len += (unsigned)hold & ((1U << op) - 1);
}
Tracevv((stderr, "inflate: length %u\n", len));
if (bits < 15) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
here = dcode[hold & dmask];
dist = (unsigned)(here.val);
op &= 15; /* number of extra bits */
if (bits < op) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
if (bits < op) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
}
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
if (len <= op - whave) {
do {
- PUP(out) = 0;
+ *out++ = 0;
} while (--len);
continue;
}
len -= op - whave;
do {
- PUP(out) = 0;
+ *out++ = 0;
} while (--op > whave);
if (op == 0) {
from = out - dist;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--len);
continue;
}
#endif
}
- from = window - OFF;
+ from = window;
if (wnext == 0) { /* very common case */
from += wsize - op;
if (op < len) { /* some from window */
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
from = out - dist; /* rest from output */
}
if (op < len) { /* some from end of window */
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
- from = window - OFF;
+ from = window;
if (wnext < len) { /* some from start of window */
op = wnext;
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
from = out - dist; /* rest from output */
}
if (op < len) { /* some from window */
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
from = out - dist; /* rest from output */
}
}
while (len > 2) {
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
+ *out++ = *from++;
+ *out++ = *from++;
+ *out++ = *from++;
len -= 3;
}
if (len) {
- PUP(out) = PUP(from);
+ *out++ = *from++;
if (len > 1)
- PUP(out) = PUP(from);
+ *out++ = *from++;
}
}
else {
from = out - dist; /* copy direct from output */
do { /* minimum length is three */
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
+ *out++ = *from++;
+ *out++ = *from++;
+ *out++ = *from++;
len -= 3;
} while (len > 2);
if (len) {
- PUP(out) = PUP(from);
+ *out++ = *from++;
if (len > 1)
- PUP(out) = PUP(from);
+ *out++ = *from++;
}
}
}
hold &= (1U << bits) - 1;
/* update state and return */
- strm->next_in = in + OFF;
- strm->next_out = out + OFF;
+ strm->next_in = in;
+ strm->next_out = out;
strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
strm->avail_out = (unsigned)(out < end ?
257 + (end - out) : 257 - (out - end));
/* inflate.c -- zlib decompression
- * Copyright (C) 1995-2012 Mark Adler
+ * Copyright (C) 1995-2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#endif
/* function prototypes */
+local int inflateStateCheck OF((z_streamp strm));
local void fixedtables OF((struct inflate_state FAR *state));
local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
unsigned copy));
local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
unsigned len));
+local int inflateStateCheck(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (strm == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+ return 1;
+ state = (struct inflate_state FAR *)strm->state;
+ if (state == Z_NULL || state->strm != strm ||
+ state->mode < HEAD || state->mode > SYNC)
+ return 1;
+ return 0;
+}
+
int ZEXPORT inflateResetKeep(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
strm->total_in = strm->total_out = state->total = 0;
strm->msg = Z_NULL;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
state->wsize = 0;
state->whave = 0;
struct inflate_state FAR *state;
/* get the state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* extract wrap request from windowBits parameter */
windowBits = -windowBits;
}
else {
- wrap = (windowBits >> 4) + 1;
+ wrap = (windowBits >> 4) + 5;
#ifdef GUNZIP
if (windowBits < 48)
windowBits &= 15;
if (state == Z_NULL) return Z_MEM_ERROR;
Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state;
+ state->strm = strm;
state->window = Z_NULL;
+ state->mode = HEAD; /* to pass state test in inflateReset2() */
ret = inflateReset2(strm, windowBits);
if (ret != Z_OK) {
ZFREE(strm, state);
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (bits < 0) {
state->hold = 0;
state->bits = 0;
return Z_OK;
}
- if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
+ if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
value &= (1L << bits) - 1;
- state->hold += value << state->bits;
- state->bits += bits;
+ state->hold += (unsigned)value << state->bits;
+ state->bits += (uInt)bits;
return Z_OK;
}
static const unsigned short order[19] = /* permutation of code lengths */
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
- if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
+ if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
(strm->next_in == Z_NULL && strm->avail_in != 0))
return Z_STREAM_ERROR;
NEEDBITS(16);
#ifdef GUNZIP
if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
+ if (state->wbits == 0)
+ state->wbits = 15;
state->check = crc32(0L, Z_NULL, 0);
CRC2(state->check, hold);
INITBITS();
len = BITS(4) + 8;
if (state->wbits == 0)
state->wbits = len;
- else if (len > state->wbits) {
+ if (len > 15 || len > state->wbits) {
strm->msg = (char *)"invalid window size";
state->mode = BAD;
break;
}
if (state->head != Z_NULL)
state->head->text = (int)((hold >> 8) & 1);
- if (state->flags & 0x0200) CRC2(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC2(state->check, hold);
INITBITS();
state->mode = TIME;
case TIME:
NEEDBITS(32);
if (state->head != Z_NULL)
state->head->time = hold;
- if (state->flags & 0x0200) CRC4(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC4(state->check, hold);
INITBITS();
state->mode = OS;
case OS:
state->head->xflags = (int)(hold & 0xff);
state->head->os = (int)(hold >> 8);
}
- if (state->flags & 0x0200) CRC2(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC2(state->check, hold);
INITBITS();
state->mode = EXLEN;
case EXLEN:
state->length = (unsigned)(hold);
if (state->head != Z_NULL)
state->head->extra_len = (unsigned)hold;
- if (state->flags & 0x0200) CRC2(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC2(state->check, hold);
INITBITS();
}
else if (state->head != Z_NULL)
len + copy > state->head->extra_max ?
state->head->extra_max - len : copy);
}
- if (state->flags & 0x0200)
+ if ((state->flags & 0x0200) && (state->wrap & 4))
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
if (state->head != Z_NULL &&
state->head->name != Z_NULL &&
state->length < state->head->name_max)
- state->head->name[state->length++] = len;
+ state->head->name[state->length++] = (Bytef)len;
} while (len && copy < have);
- if (state->flags & 0x0200)
+ if ((state->flags & 0x0200) && (state->wrap & 4))
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
if (state->head != Z_NULL &&
state->head->comment != Z_NULL &&
state->length < state->head->comm_max)
- state->head->comment[state->length++] = len;
+ state->head->comment[state->length++] = (Bytef)len;
} while (len && copy < have);
- if (state->flags & 0x0200)
+ if ((state->flags & 0x0200) && (state->wrap & 4))
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
case HCRC:
if (state->flags & 0x0200) {
NEEDBITS(16);
- if (hold != (state->check & 0xffff)) {
+ if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
strm->msg = (char *)"header crc mismatch";
state->mode = BAD;
break;
out -= left;
strm->total_out += out;
state->total += out;
- if (out)
+ if ((state->wrap & 4) && out)
strm->adler = state->check =
UPDATE(state->check, put - out, out);
out = left;
- if ((
+ if ((state->wrap & 4) && (
#ifdef GUNZIP
state->flags ? hold :
#endif
strm->total_in += in;
strm->total_out += out;
state->total += out;
- if (state->wrap && out)
+ if ((state->wrap & 4) && out)
strm->adler = state->check =
UPDATE(state->check, strm->next_out - out, out);
- strm->data_type = state->bits + (state->last ? 64 : 0) +
+ strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
(state->mode == TYPE ? 128 : 0) +
(state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
z_streamp strm;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ if (inflateStateCheck(strm))
return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (state->window != Z_NULL) ZFREE(strm, state->window);
struct inflate_state FAR *state;
/* check state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* copy dictionary */
int ret;
/* check state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (state->wrap != 0 && state->mode != DICT)
return Z_STREAM_ERROR;
struct inflate_state FAR *state;
/* check state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
struct inflate_state FAR *state;
/* check parameters */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
return state->mode == STORED && state->bits == 0;
}
unsigned wsize;
/* check input */
- if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
- source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
+ if (inflateStateCheck(source) || dest == Z_NULL)
return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)source->state;
/* copy state */
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
+ copy->strm = dest;
if (state->lencode >= state->codes &&
state->lencode <= state->codes + ENOUGH - 1) {
copy->lencode = copy->codes + (state->lencode - state->codes);
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
- state->sane = !subvert;
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+ state->sane = !subvert;
return Z_OK;
#else
+ (void)subvert;
state->sane = 1;
return Z_DATA_ERROR;
#endif
}
+int ZEXPORT inflateValidate(strm, check)
+z_streamp strm;
+int check;
+{
+ struct inflate_state FAR *state;
+
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (check)
+ state->wrap |= 4;
+ else
+ state->wrap &= ~4;
+ return Z_OK;
+}
+
long ZEXPORT inflateMark(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
+ if (inflateStateCheck(strm))
+ return -(1L << 16);
state = (struct inflate_state FAR *)strm->state;
- return ((long)(state->back) << 16) +
+ return (long)(((unsigned long)((long)state->back)) << 16) +
(state->mode == COPY ? state->length :
(state->mode == MATCH ? state->was - state->length : 0));
}
+
+unsigned long ZEXPORT inflateCodesUsed(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (inflateStateCheck(strm)) return (unsigned long)-1;
+ state = (struct inflate_state FAR *)strm->state;
+ return (unsigned long)(state->next - state->codes);
+}
/* inflate.h -- internal inflate state definition
- * Copyright (C) 1995-2009 Mark Adler
+ * Copyright (C) 1995-2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* Possible inflate modes between inflate() calls */
typedef enum {
- HEAD, /* i: waiting for magic header */
+ HEAD = 16180, /* i: waiting for magic header */
FLAGS, /* i: waiting for method and flags (gzip) */
TIME, /* i: waiting for modification time (gzip) */
OS, /* i: waiting for extra flags and operating system (gzip) */
CHECK -> LENGTH -> DONE
*/
-/* state maintained between inflate() calls. Approximately 10K bytes. */
+/* State maintained between inflate() calls -- approximately 7K bytes, not
+ including the allocated sliding window, which is up to 32K bytes. */
struct inflate_state {
+ z_streamp strm; /* pointer back to this zlib stream */
inflate_mode mode; /* current inflate mode */
int last; /* true if processing last block */
- int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip,
+ bit 2 true to validate check value */
int havedict; /* true if dictionary provided */
int flags; /* gzip header method and flags (0 if zlib) */
unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
/* inftrees.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-2013 Mark Adler
+ * Copyright (C) 1995-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#define MAXBITS 15
const char inflate_copyright[] =
- " inflate 1.2.8 Copyright 1995-2013 Mark Adler ";
+ " inflate 1.2.11 Copyright 1995-2017 Mark Adler ";
/*
If you use the zlib library in a product, an acknowledgment is welcome
in the documentation of your product. If for some reason you cannot
code FAR *next; /* next available space in table */
const unsigned short FAR *base; /* base value table to use */
const unsigned short FAR *extra; /* extra bits table to use */
- int end; /* use base and extra for symbol > end */
+ unsigned match; /* use base and extra for symbol >= match */
unsigned short count[MAXBITS+1]; /* number of codes of each length */
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
- 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
switch (type) {
case CODES:
base = extra = work; /* dummy value--not used */
- end = 19;
+ match = 20;
break;
case LENS:
base = lbase;
- base -= 257;
extra = lext;
- extra -= 257;
- end = 256;
+ match = 257;
break;
- default: /* DISTS */
+ default: /* DISTS */
base = dbase;
extra = dext;
- end = -1;
+ match = 0;
}
/* initialize state for loop */
for (;;) {
/* create table entry */
here.bits = (unsigned char)(len - drop);
- if ((int)(work[sym]) < end) {
+ if (work[sym] + 1U < match) {
here.op = (unsigned char)0;
here.val = work[sym];
}
- else if ((int)(work[sym]) > end) {
- here.op = (unsigned char)(extra[work[sym]]);
- here.val = base[work[sym]];
+ else if (work[sym] >= match) {
+ here.op = (unsigned char)(extra[work[sym] - match]);
+ here.val = base[work[sym] - match];
}
else {
here.op = (unsigned char)(32 + 64); /* end of block */
/* trees.c -- output deflated data using Huffman coding
- * Copyright (C) 1995-2012 Jean-loup Gailly
+ * Copyright (C) 1995-2017 Jean-loup Gailly
* detect_data_type() function provided freely by Cosmin Truta, 2006
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "deflate.h"
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
# include <ctype.h>
#endif
int max_length; /* max bit length for the codes */
};
-local static_tree_desc static_l_desc =
+local const static_tree_desc static_l_desc =
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
-local static_tree_desc static_d_desc =
+local const static_tree_desc static_d_desc =
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
-local static_tree_desc static_bl_desc =
+local const static_tree_desc static_bl_desc =
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
/* ===========================================================================
local unsigned bi_reverse OF((unsigned value, int length));
local void bi_windup OF((deflate_state *s));
local void bi_flush OF((deflate_state *s));
-local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
- int header));
#ifdef GEN_TREES_H
local void gen_trees_header OF((void));
#endif
-#ifndef DEBUG
+#ifndef ZLIB_DEBUG
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
/* Send a code of the given tree. c and tree must not have side effects */
-#else /* DEBUG */
+#else /* !ZLIB_DEBUG */
# define send_code(s, c, tree) \
{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
send_bits(s, tree[c].Code, tree[c].Len); }
* Send a value on a given number of bits.
* IN assertion: length <= 16 and value fits in length bits.
*/
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
local void send_bits OF((deflate_state *s, int value, int length));
local void send_bits(s, value, length)
s->bi_valid += length;
}
}
-#else /* !DEBUG */
+#else /* !ZLIB_DEBUG */
#define send_bits(s, value, length) \
{ int len = length;\
if (s->bi_valid > (int)Buf_size - len) {\
- int val = value;\
+ int val = (int)value;\
s->bi_buf |= (ush)val << s->bi_valid;\
put_short(s, s->bi_buf);\
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
s->bi_valid += len;\
}\
}
-#endif /* DEBUG */
+#endif /* ZLIB_DEBUG */
/* the arguments must not have side effects */
* Genererate the file trees.h describing the static trees.
*/
#ifdef GEN_TREES_H
-# ifndef DEBUG
+# ifndef ZLIB_DEBUG
# include <stdio.h>
# endif
s->bi_buf = 0;
s->bi_valid = 0;
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len = 0L;
s->bits_sent = 0L;
#endif
xbits = 0;
if (n >= base) xbits = extra[n-base];
f = tree[n].Freq;
- s->opt_len += (ulg)f * (bits + xbits);
- if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
+ s->opt_len += (ulg)f * (unsigned)(bits + xbits);
+ if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
}
if (overflow == 0) return;
- Trace((stderr,"\nbit length overflow\n"));
+ Tracev((stderr,"\nbit length overflow\n"));
/* This happens for example on obj2 and pic of the Calgary corpus */
/* Find the first bit length which could increase: */
m = s->heap[--h];
if (m > max_code) continue;
if ((unsigned) tree[m].Len != (unsigned) bits) {
- Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
- s->opt_len += ((long)bits - (long)tree[m].Len)
- *(long)tree[m].Freq;
+ Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+ s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
tree[m].Len = (ush)bits;
}
n--;
ushf *bl_count; /* number of codes at each bit length */
{
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
- ush code = 0; /* running code value */
+ unsigned code = 0; /* running code value */
int bits; /* bit index */
int n; /* code index */
* without bit reversal.
*/
for (bits = 1; bits <= MAX_BITS; bits++) {
- next_code[bits] = code = (code + bl_count[bits-1]) << 1;
+ code = (code + bl_count[bits-1]) << 1;
+ next_code[bits] = (ush)code;
}
/* Check that the bit counts in bl_count are consistent. The last code
* must be all ones.
int len = tree[n].Len;
if (len == 0) continue;
/* Now reverse the bits */
- tree[n].Code = bi_reverse(next_code[len]++, len);
+ tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
}
/* Update opt_len to include the bit length tree and counts */
- s->opt_len += 3*(max_blindex+1) + 5+5+4;
+ s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
s->opt_len, s->static_len));
int last; /* one if this is the last block for a file */
{
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
-#ifdef DEBUG
+ bi_windup(s); /* align on byte boundary */
+ put_short(s, (ush)stored_len);
+ put_short(s, (ush)~stored_len);
+ zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
+ s->pending += stored_len;
+#ifdef ZLIB_DEBUG
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
s->compressed_len += (stored_len + 4) << 3;
+ s->bits_sent += 2*16;
+ s->bits_sent += stored_len<<3;
#endif
- copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
}
/* ===========================================================================
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
bi_flush(s);
/* ===========================================================================
* Determine the best encoding for the current block: dynamic trees, static
- * trees or store, and output the encoded block to the zip file.
+ * trees or store, and write out the encoded block.
*/
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
deflate_state *s;
send_bits(s, (STATIC_TREES<<1)+last, 3);
compress_block(s, (const ct_data *)static_ltree,
(const ct_data *)static_dtree);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->static_len;
#endif
} else {
max_blindex+1);
compress_block(s, (const ct_data *)s->dyn_ltree,
(const ct_data *)s->dyn_dtree);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->opt_len;
#endif
}
if (last) {
bi_windup(s);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 7; /* align on byte boundary */
#endif
}
send_code(s, code, dtree); /* send the distance code */
extra = extra_dbits[code];
if (extra != 0) {
- dist -= base_dist[code];
+ dist -= (unsigned)base_dist[code];
send_bits(s, dist, extra); /* send the extra distance bits */
}
} /* literal or match pair ? */
}
s->bi_buf = 0;
s->bi_valid = 0;
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}
-
-/* ===========================================================================
- * Copy a stored block, storing first the length and its
- * one's complement if requested.
- */
-local void copy_block(s, buf, len, header)
- deflate_state *s;
- charf *buf; /* the input data */
- unsigned len; /* its length */
- int header; /* true if block header must be written */
-{
- bi_windup(s); /* align on byte boundary */
-
- if (header) {
- put_short(s, (ush)len);
- put_short(s, (ush)~len);
-#ifdef DEBUG
- s->bits_sent += 2*16;
-#endif
- }
-#ifdef DEBUG
- s->bits_sent += (ulg)len<<3;
-#endif
- while (len--) {
- put_byte(s, *buf++);
- }
-}
/* uncompr.c -- decompress a memory buffer
- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
+ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "zlib.h"
/* ===========================================================================
- Decompresses the source buffer into the destination buffer. sourceLen is
- the byte length of the source buffer. Upon entry, destLen is the total
- size of the destination buffer, which must be large enough to hold the
- entire uncompressed data. (The size of the uncompressed data must have
- been saved previously by the compressor and transmitted to the decompressor
- by some mechanism outside the scope of this compression library.)
- Upon exit, destLen is the actual size of the compressed buffer.
-
- uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
- enough memory, Z_BUF_ERROR if there was not enough room in the output
- buffer, or Z_DATA_ERROR if the input data was corrupted.
+ Decompresses the source buffer into the destination buffer. *sourceLen is
+ the byte length of the source buffer. Upon entry, *destLen is the total size
+ of the destination buffer, which must be large enough to hold the entire
+ uncompressed data. (The size of the uncompressed data must have been saved
+ previously by the compressor and transmitted to the decompressor by some
+ mechanism outside the scope of this compression library.) Upon exit,
+ *destLen is the size of the decompressed data and *sourceLen is the number
+ of source bytes consumed. Upon return, source + *sourceLen points to the
+ first unused input byte.
+
+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
+ Z_DATA_ERROR if the input data was corrupted, including if the input data is
+ an incomplete zlib stream.
*/
-int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
Bytef *dest;
uLongf *destLen;
const Bytef *source;
- uLong sourceLen;
+ uLong *sourceLen;
{
z_stream stream;
int err;
+ const uInt max = (uInt)-1;
+ uLong len, left;
+ Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */
- stream.next_in = (z_const Bytef *)source;
- stream.avail_in = (uInt)sourceLen;
- /* Check for source > 64K on 16-bit machine: */
- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-
- stream.next_out = dest;
- stream.avail_out = (uInt)*destLen;
- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+ len = *sourceLen;
+ if (*destLen) {
+ left = *destLen;
+ *destLen = 0;
+ }
+ else {
+ left = 1;
+ dest = buf;
+ }
+ stream.next_in = (z_const Bytef *)source;
+ stream.avail_in = 0;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
+ stream.opaque = (voidpf)0;
err = inflateInit(&stream);
if (err != Z_OK) return err;
- err = inflate(&stream, Z_FINISH);
- if (err != Z_STREAM_END) {
- inflateEnd(&stream);
- if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
- return Z_DATA_ERROR;
- return err;
- }
- *destLen = stream.total_out;
+ stream.next_out = dest;
+ stream.avail_out = 0;
- err = inflateEnd(&stream);
- return err;
+ do {
+ if (stream.avail_out == 0) {
+ stream.avail_out = left > (uLong)max ? max : (uInt)left;
+ left -= stream.avail_out;
+ }
+ if (stream.avail_in == 0) {
+ stream.avail_in = len > (uLong)max ? max : (uInt)len;
+ len -= stream.avail_in;
+ }
+ err = inflate(&stream, Z_NO_FLUSH);
+ } while (err == Z_OK);
+
+ *sourceLen -= len + stream.avail_in;
+ if (dest != buf)
+ *destLen = stream.total_out;
+ else if (stream.total_out && err == Z_BUF_ERROR)
+ left = 1;
+
+ inflateEnd(&stream);
+ return err == Z_STREAM_END ? Z_OK :
+ err == Z_NEED_DICT ? Z_DATA_ERROR :
+ err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
+ err;
+}
+
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+{
+ return uncompress2(dest, destLen, source, &sourceLen);
}
/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
# define Z_PREFIX_SET
-/* all linked symbols */
+/* all linked symbols and init macros */
# define _dist_code z__dist_code
# define _length_code z__length_code
# define _tr_align z__tr_align
# define adler32 z_adler32
# define adler32_combine z_adler32_combine
# define adler32_combine64 z_adler32_combine64
+# define adler32_z z_adler32_z
# ifndef Z_SOLO
# define compress z_compress
# define compress2 z_compress2
# define crc32 z_crc32
# define crc32_combine z_crc32_combine
# define crc32_combine64 z_crc32_combine64
+# define crc32_z z_crc32_z
# define deflate z_deflate
# define deflateBound z_deflateBound
# define deflateCopy z_deflateCopy
# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
# define deflateInit2_ z_deflateInit2_
# define deflateInit_ z_deflateInit_
# define deflateParams z_deflateParams
# define gzeof z_gzeof
# define gzerror z_gzerror
# define gzflush z_gzflush
+# define gzfread z_gzfread
+# define gzfwrite z_gzfwrite
# define gzgetc z_gzgetc
# define gzgetc_ z_gzgetc_
# define gzgets z_gzgets
# define gzopen_w z_gzopen_w
# endif
# define gzprintf z_gzprintf
-# define gzvprintf z_gzvprintf
# define gzputc z_gzputc
# define gzputs z_gzputs
# define gzread z_gzread
# define gztell z_gztell
# define gztell64 z_gztell64
# define gzungetc z_gzungetc
+# define gzvprintf z_gzvprintf
# define gzwrite z_gzwrite
# endif
# define inflate z_inflate
# define inflateBack z_inflateBack
# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
# define inflateCopy z_inflateCopy
# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
# define inflateInit2_ z_inflateInit2_
# define inflateInit_ z_inflateInit_
# define inflateMark z_inflateMark
# define inflatePrime z_inflatePrime
# define inflateReset z_inflateReset
# define inflateReset2 z_inflateReset2
+# define inflateResetKeep z_inflateResetKeep
# define inflateSetDictionary z_inflateSetDictionary
-# define inflateGetDictionary z_inflateGetDictionary
# define inflateSync z_inflateSync
# define inflateSyncPoint z_inflateSyncPoint
# define inflateUndermine z_inflateUndermine
-# define inflateResetKeep z_inflateResetKeep
+# define inflateValidate z_inflateValidate
# define inflate_copyright z_inflate_copyright
# define inflate_fast z_inflate_fast
# define inflate_table z_inflate_table
# ifndef Z_SOLO
# define uncompress z_uncompress
+# define uncompress2 z_uncompress2
# endif
# define zError z_zError
# ifndef Z_SOLO
# define z_const
#endif
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-# define NO_DUMMY_DECL
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
#endif
/* Maximum value for memLevel in deflateInit2 */
Of course this will generally degrade compression (there's no free lunch).
The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
for small objects.
*/
/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
# define Z_PREFIX_SET
-/* all linked symbols */
+/* all linked symbols and init macros */
# define _dist_code z__dist_code
# define _length_code z__length_code
# define _tr_align z__tr_align
# define adler32 z_adler32
# define adler32_combine z_adler32_combine
# define adler32_combine64 z_adler32_combine64
+# define adler32_z z_adler32_z
# ifndef Z_SOLO
# define compress z_compress
# define compress2 z_compress2
# define crc32 z_crc32
# define crc32_combine z_crc32_combine
# define crc32_combine64 z_crc32_combine64
+# define crc32_z z_crc32_z
# define deflate z_deflate
# define deflateBound z_deflateBound
# define deflateCopy z_deflateCopy
# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
# define deflateInit2_ z_deflateInit2_
# define deflateInit_ z_deflateInit_
# define deflateParams z_deflateParams
# define gzeof z_gzeof
# define gzerror z_gzerror
# define gzflush z_gzflush
+# define gzfread z_gzfread
+# define gzfwrite z_gzfwrite
# define gzgetc z_gzgetc
# define gzgetc_ z_gzgetc_
# define gzgets z_gzgets
# define gzopen_w z_gzopen_w
# endif
# define gzprintf z_gzprintf
-# define gzvprintf z_gzvprintf
# define gzputc z_gzputc
# define gzputs z_gzputs
# define gzread z_gzread
# define gztell z_gztell
# define gztell64 z_gztell64
# define gzungetc z_gzungetc
+# define gzvprintf z_gzvprintf
# define gzwrite z_gzwrite
# endif
# define inflate z_inflate
# define inflateBack z_inflateBack
# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
# define inflateCopy z_inflateCopy
# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
# define inflateInit2_ z_inflateInit2_
# define inflateInit_ z_inflateInit_
# define inflateMark z_inflateMark
# define inflatePrime z_inflatePrime
# define inflateReset z_inflateReset
# define inflateReset2 z_inflateReset2
+# define inflateResetKeep z_inflateResetKeep
# define inflateSetDictionary z_inflateSetDictionary
-# define inflateGetDictionary z_inflateGetDictionary
# define inflateSync z_inflateSync
# define inflateSyncPoint z_inflateSyncPoint
# define inflateUndermine z_inflateUndermine
-# define inflateResetKeep z_inflateResetKeep
+# define inflateValidate z_inflateValidate
# define inflate_copyright z_inflate_copyright
# define inflate_fast z_inflate_fast
# define inflate_table z_inflate_table
# ifndef Z_SOLO
# define uncompress z_uncompress
+# define uncompress2 z_uncompress2
# endif
# define zError z_zError
# ifndef Z_SOLO
# define z_const
#endif
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-# define NO_DUMMY_DECL
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
#endif
/* Maximum value for memLevel in deflateInit2 */
Of course this will generally degrade compression (there's no free lunch).
The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
for small objects.
*/
/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
# define Z_PREFIX_SET
-/* all linked symbols */
+/* all linked symbols and init macros */
# define _dist_code z__dist_code
# define _length_code z__length_code
# define _tr_align z__tr_align
# define adler32 z_adler32
# define adler32_combine z_adler32_combine
# define adler32_combine64 z_adler32_combine64
+# define adler32_z z_adler32_z
# ifndef Z_SOLO
# define compress z_compress
# define compress2 z_compress2
# define crc32 z_crc32
# define crc32_combine z_crc32_combine
# define crc32_combine64 z_crc32_combine64
+# define crc32_z z_crc32_z
# define deflate z_deflate
# define deflateBound z_deflateBound
# define deflateCopy z_deflateCopy
# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
# define deflateInit2_ z_deflateInit2_
# define deflateInit_ z_deflateInit_
# define deflateParams z_deflateParams
# define gzeof z_gzeof
# define gzerror z_gzerror
# define gzflush z_gzflush
+# define gzfread z_gzfread
+# define gzfwrite z_gzfwrite
# define gzgetc z_gzgetc
# define gzgetc_ z_gzgetc_
# define gzgets z_gzgets
# define gzopen_w z_gzopen_w
# endif
# define gzprintf z_gzprintf
-# define gzvprintf z_gzvprintf
# define gzputc z_gzputc
# define gzputs z_gzputs
# define gzread z_gzread
# define gztell z_gztell
# define gztell64 z_gztell64
# define gzungetc z_gzungetc
+# define gzvprintf z_gzvprintf
# define gzwrite z_gzwrite
# endif
# define inflate z_inflate
# define inflateBack z_inflateBack
# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
# define inflateCopy z_inflateCopy
# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
# define inflateInit2_ z_inflateInit2_
# define inflateInit_ z_inflateInit_
# define inflateMark z_inflateMark
# define inflatePrime z_inflatePrime
# define inflateReset z_inflateReset
# define inflateReset2 z_inflateReset2
+# define inflateResetKeep z_inflateResetKeep
# define inflateSetDictionary z_inflateSetDictionary
-# define inflateGetDictionary z_inflateGetDictionary
# define inflateSync z_inflateSync
# define inflateSyncPoint z_inflateSyncPoint
# define inflateUndermine z_inflateUndermine
-# define inflateResetKeep z_inflateResetKeep
+# define inflateValidate z_inflateValidate
# define inflate_copyright z_inflate_copyright
# define inflate_fast z_inflate_fast
# define inflate_table z_inflate_table
# ifndef Z_SOLO
# define uncompress z_uncompress
+# define uncompress2 z_uncompress2
# endif
# define zError z_zError
# ifndef Z_SOLO
# define z_const
#endif
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-# define NO_DUMMY_DECL
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
#endif
/* Maximum value for memLevel in deflateInit2 */
Of course this will generally degrade compression (there's no free lunch).
The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
for small objects.
*/
-.TH ZLIB 3 "28 Apr 2013"
+.TH ZLIB 3 "15 Jan 2017"
.SH NAME
zlib \- compression/decompression library
.SH SYNOPSIS
that accompanies the source.
.LP
.I zlib
-is available in Java using the java.util.zip package:
-.IP
-http://java.sun.com/developer/technicalArticles/Programming/compression/
-.LP
-A Perl interface to
-.IR zlib ,
-written by Paul Marquess (pmqs@cpan.org),
-is available at CPAN (Comprehensive Perl Archive Network) sites,
-including:
-.IP
-http://search.cpan.org/~pmqs/IO-Compress-Zlib/
-.LP
-A Python interface to
-.IR zlib ,
-written by A.M. Kuchling (amk@magnet.com),
-is available in Python 1.5 and later versions:
-.IP
-http://docs.python.org/library/zlib.html
-.LP
-.I zlib
-is built into
-.IR tcl:
-.IP
-http://wiki.tcl.tk/4610
+is built in to many languages and operating systems, including but not limited to
+Java, Python, .NET, PHP, Perl, Ruby, Swift, and Go.
.LP
-An experimental package to read and write files in .zip format,
+An experimental package to read and write files in the .zip format,
written on top of
.I zlib
by Gilles Vollant (info@winimage.com),
.IP
http://zlib.net/
.LP
-The data format used by the zlib library is described by RFC
+The data format used by the
+.I zlib
+library is described by RFC
(Request for Comments) 1950 to 1952 in the files:
.IP
http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format)
before asking for help.
Send questions and/or comments to zlib@gzip.org,
or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
-.SH AUTHORS
-Version 1.2.8
-Copyright (C) 1995-2013 Jean-loup Gailly (jloup@gzip.org)
-and Mark Adler (madler@alumni.caltech.edu).
-.LP
-This software is provided "as-is,"
-without any express or implied warranty.
-In no event will the authors be held liable for any damages
+.SH AUTHORS AND LICENSE
+Version 1.2.11
+.LP
+Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+.LP
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
-See the distribution directory with respect to requirements
-governing redistribution.
+.LP
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+.LP
+.nr step 1 1
+.IP \n[step]. 3
+The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+.IP \n+[step].
+Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+.IP \n+[step].
+This notice may not be removed or altered from any source distribution.
+.LP
+Jean-loup Gailly Mark Adler
+.br
+jloup@gzip.org madler@alumni.caltech.edu
+.LP
The deflate format used by
.I zlib
was defined by Phil Katz.
/* zlib.h -- interface of the 'zlib' general purpose compression library
- version 1.2.8, April 28th, 2013
+ version 1.2.11, January 15th, 2017
- Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
+ Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
extern "C" {
#endif
-#define ZLIB_VERSION "1.2.8"
-#define ZLIB_VERNUM 0x1280
+#define ZLIB_VERSION "1.2.11"
+#define ZLIB_VERNUM 0x12b0
#define ZLIB_VER_MAJOR 1
#define ZLIB_VER_MINOR 2
-#define ZLIB_VER_REVISION 8
+#define ZLIB_VER_REVISION 11
#define ZLIB_VER_SUBREVISION 0
/*
with "gz". The gzip format is different from the zlib format. gzip is a
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
- This library can optionally read and write gzip streams in memory as well.
+ This library can optionally read and write gzip and raw deflate streams in
+ memory as well.
The zlib format was designed to be compact and fast for use in memory
and on communications channels. The gzip format was designed for single-
The library does not install any signal handler. The decoder checks
the consistency of the compressed data, so the library should never crash
- even in case of corrupted input.
+ even in the case of corrupted input.
*/
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
uInt avail_in; /* number of bytes available at next_in */
uLong total_in; /* total number of input bytes read so far */
- Bytef *next_out; /* next output byte should be put there */
+ Bytef *next_out; /* next output byte will go here */
uInt avail_out; /* remaining free space at next_out */
uLong total_out; /* total number of bytes output so far */
free_func zfree; /* used to free the internal state */
voidpf opaque; /* private data object passed to zalloc and zfree */
- int data_type; /* best guess about the data type: binary or text */
- uLong adler; /* adler32 value of the uncompressed data */
+ int data_type; /* best guess about the data type: binary or text
+ for deflate, or the decoding state for inflate */
+ uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */
uLong reserved; /* reserved for future use */
} z_stream;
zalloc must return Z_NULL if there is not enough memory for the object.
If zlib is used in a multi-threaded application, zalloc and zfree must be
- thread safe.
+ thread safe. In that case, zlib is thread-safe. When zalloc and zfree are
+ Z_NULL on entry to the initialization function, they are set to internal
+ routines that use the standard library functions malloc() and free().
On 16-bit systems, the functions zalloc and zfree must be able to allocate
exactly 65536 bytes, but will not be required to allocate more than this if
The fields total_in and total_out can be used for statistics or progress
reports. After compression, total_in holds the total size of the
- uncompressed data and may be saved for use in the decompressor (particularly
+ uncompressed data and may be saved for use by the decompressor (particularly
if the decompressor wants to decompress everything in a single step).
*/
#define Z_TEXT 1
#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
#define Z_UNKNOWN 2
-/* Possible values of the data_type field (though see inflate()) */
+/* Possible values of the data_type field for deflate() */
#define Z_DEFLATED 8
/* The deflate compression method (the only one supported in this version) */
enough room in the output buffer), next_in and avail_in are updated and
processing will resume at this point for the next call of deflate().
- - Provide more output starting at next_out and update next_out and avail_out
+ - Generate more output starting at next_out and update next_out and avail_out
accordingly. This action is forced if the parameter flush is non zero.
Forcing flush frequently degrades the compression ratio, so this parameter
- should be set only when necessary (in interactive applications). Some
- output may be provided even if flush is not set.
+ should be set only when necessary. Some output may be provided even if
+ flush is zero.
Before the call of deflate(), the application should ensure that at least
one of the actions is possible, by providing more input and/or consuming more
output when it wants, for example when the output buffer is full (avail_out
== 0), or after each call of deflate(). If deflate returns Z_OK and with
zero avail_out, it must be called again after making room in the output
- buffer because there might be more output pending.
+ buffer because there might be more output pending. See deflatePending(),
+ which can be used if desired to determine whether or not there is more ouput
+ in that case.
Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
decide how much data to accumulate before producing output, in order to
input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
This completes the current deflate block and follows it with an empty fixed
codes block that is 10 bits long. This assures that enough bytes are output
- in order for the decompressor to finish the block before the empty fixed code
- block.
+ in order for the decompressor to finish the block before the empty fixed
+ codes block.
If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
If the parameter flush is set to Z_FINISH, pending input is processed,
pending output is flushed and deflate returns with Z_STREAM_END if there was
- enough output space; if deflate returns with Z_OK, this function must be
- called again with Z_FINISH and more output space (updated avail_out) but no
- more input data, until it returns with Z_STREAM_END or an error. After
- deflate has returned Z_STREAM_END, the only possible operations on the stream
- are deflateReset or deflateEnd.
-
- Z_FINISH can be used immediately after deflateInit if all the compression
- is to be done in a single step. In this case, avail_out must be at least the
- value returned by deflateBound (see below). Then deflate is guaranteed to
- return Z_STREAM_END. If not enough output space is provided, deflate will
- not return Z_STREAM_END, and it must be called again as described above.
-
- deflate() sets strm->adler to the adler32 checksum of all input read
- so far (that is, total_in bytes).
+ enough output space. If deflate returns with Z_OK or Z_BUF_ERROR, this
+ function must be called again with Z_FINISH and more output space (updated
+ avail_out) but no more input data, until it returns with Z_STREAM_END or an
+ error. After deflate has returned Z_STREAM_END, the only possible operations
+ on the stream are deflateReset or deflateEnd.
+
+ Z_FINISH can be used in the first deflate call after deflateInit if all the
+ compression is to be done in a single step. In order to complete in one
+ call, avail_out must be at least the value returned by deflateBound (see
+ below). Then deflate is guaranteed to return Z_STREAM_END. If not enough
+ output space is provided, deflate will not return Z_STREAM_END, and it must
+ be called again as described above.
+
+ deflate() sets strm->adler to the Adler-32 checksum of all input read
+ so far (that is, total_in bytes). If a gzip stream is being generated, then
+ strm->adler will be the CRC-32 checksum of the input read so far. (See
+ deflateInit2 below.)
deflate() may update strm->data_type if it can make a good guess about
- the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
- binary. This field is only for information purposes and does not affect the
- compression algorithm in any manner.
+ the input data type (Z_BINARY or Z_TEXT). If in doubt, the data is
+ considered binary. This field is only for information purposes and does not
+ affect the compression algorithm in any manner.
deflate() returns Z_OK if some progress has been made (more input
processed or more output produced), Z_STREAM_END if all input has been
consumed and all output has been produced (only when flush is set to
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
- if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
- (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
- fatal, and deflate() can be called again with more input and more output
- space to continue compressing.
+ if next_in or next_out was Z_NULL or the state was inadvertently written over
+ by the application), or Z_BUF_ERROR if no progress is possible (for example
+ avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and
+ deflate() can be called again with more input and more output space to
+ continue compressing.
*/
Initializes the internal stream state for decompression. The fields
next_in, avail_in, zalloc, zfree and opaque must be initialized before by
- the caller. If next_in is not Z_NULL and avail_in is large enough (the
- exact value depends on the compression method), inflateInit determines the
- compression method from the zlib header and allocates all data structures
- accordingly; otherwise the allocation will be deferred to the first call of
- inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
- use default allocation functions.
+ the caller. In the current version of inflate, the provided input is not
+ read or consumed. The allocation of a sliding window will be deferred to
+ the first call of inflate (if the decompression does not complete on the
+ first call). If zalloc and zfree are set to Z_NULL, inflateInit updates
+ them to use default allocation functions.
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
version assumed by the caller, or Z_STREAM_ERROR if the parameters are
invalid, such as a null pointer to the structure. msg is set to null if
- there is no error message. inflateInit does not perform any decompression
- apart from possibly reading the zlib header if present: actual decompression
- will be done by inflate(). (So next_in and avail_in may be modified, but
- next_out and avail_out are unused and unchanged.) The current implementation
- of inflateInit() does not process any header information -- that is deferred
- until inflate() is called.
+ there is no error message. inflateInit does not perform any decompression.
+ Actual decompression will be done by inflate(). So next_in, and avail_in,
+ next_out, and avail_out are unused and unchanged. The current
+ implementation of inflateInit() does not process any header information --
+ that is deferred until inflate() is called.
*/
- Decompress more input starting at next_in and update next_in and avail_in
accordingly. If not all input can be processed (because there is not
- enough room in the output buffer), next_in is updated and processing will
- resume at this point for the next call of inflate().
+ enough room in the output buffer), then next_in and avail_in are updated
+ accordingly, and processing will resume at this point for the next call of
+ inflate().
- - Provide more output starting at next_out and update next_out and avail_out
+ - Generate more output starting at next_out and update next_out and avail_out
accordingly. inflate() provides as much output as possible, until there is
no more input data or no more space in the output buffer (see below about
the flush parameter).
Before the call of inflate(), the application should ensure that at least
one of the actions is possible, by providing more input and/or consuming more
- output, and updating the next_* and avail_* values accordingly. The
+ output, and updating the next_* and avail_* values accordingly. If the
+ caller of inflate() does not provide both available input and available
+ output space, it is possible that there will be no progress made. The
application can consume the uncompressed output when it wants, for example
when the output buffer is full (avail_out == 0), or after each call of
inflate(). If inflate returns Z_OK and with zero avail_out, it must be
gets to the end of that block, or when it runs out of data.
The Z_BLOCK option assists in appending to or combining deflate streams.
- Also to assist in this, on return inflate() will set strm->data_type to the
+ To assist in this, on return inflate() always sets strm->data_type to the
number of unused bits in the last byte taken from strm->next_in, plus 64 if
inflate() is currently decoding the last block in the deflate stream, plus
128 if inflate() returned immediately after decoding an end-of-block code or
this case all pending input is processed and all pending output is flushed;
avail_out must be large enough to hold all of the uncompressed data for the
operation to complete. (The size of the uncompressed data may have been
- saved by the compressor for this purpose.) The use of Z_FINISH is not
+ saved by the compressor for this purpose.) The use of Z_FINISH is not
required to perform an inflation in one step. However it may be used to
inform inflate that a faster approach can be used for the single inflate()
call. Z_FINISH also informs inflate to not maintain a sliding window if the
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
strm->adler to the Adler-32 checksum of all output produced so far (that is,
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
- below. At the end of the stream, inflate() checks that its computed adler32
+ below. At the end of the stream, inflate() checks that its computed Adler-32
checksum is equal to that saved by the compressor and returns Z_STREAM_END
only if the checksum is correct.
inflate() can decompress and check either zlib-wrapped or gzip-wrapped
deflate data. The header type is detected automatically, if requested when
initializing with inflateInit2(). Any information contained in the gzip
- header is not retained, so applications that need that information should
- instead use raw inflate, see inflateInit2() below, or inflateBack() and
- perform their own processing of the gzip header and trailer. When processing
+ header is not retained unless inflateGetHeader() is used. When processing
gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
- producted so far. The CRC-32 is checked against the gzip trailer.
+ produced so far. The CRC-32 is checked against the gzip trailer, as is the
+ uncompressed length, modulo 2^32.
inflate() returns Z_OK if some progress has been made (more input processed
or more output produced), Z_STREAM_END if the end of the compressed data has
been reached and all uncompressed output has been produced, Z_NEED_DICT if a
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
corrupted (input stream not conforming to the zlib format or incorrect check
- value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
- next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
- Z_BUF_ERROR if no progress is possible or if there was not enough room in the
- output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
+ value, in which case strm->msg points to a string with a more specific
+ error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+ next_in or next_out was Z_NULL, or the state was inadvertently written over
+ by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
+ if no progress was possible or if there was not enough room in the output
+ buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
inflate() can be called again with more input and more output space to
continue decompressing. If Z_DATA_ERROR is returned, the application may
then call inflateSync() to look for a good compression block if a partial
- recovery of the data is desired.
+ recovery of the data is to be attempted.
*/
This function discards any unprocessed input and does not flush any pending
output.
- inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
- was inconsistent. In the error case, msg may be set but then points to a
- static string (which must not be deallocated).
+ inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
+ was inconsistent.
*/
compression at the expense of memory usage. The default value is 15 if
deflateInit is used instead.
+ For the current implementation of deflate(), a windowBits value of 8 (a
+ window size of 256 bytes) is not supported. As a result, a request for 8
+ will result in 9 (a 512-byte window). In that case, providing 8 to
+ inflateInit2() will result in an error when the zlib header with 9 is
+ checked against the initialization of inflate(). The remedy is to not use 8
+ with deflateInit2() with this initialization, or at least in that case use 9
+ with inflateInit2().
+
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
determines the window size. deflate() will then generate raw deflate data
- with no zlib header or trailer, and will not compute an adler32 check value.
+ with no zlib header or trailer, and will not compute a check value.
windowBits can also be greater than 15 for optional gzip encoding. Add
16 to windowBits to write a simple gzip header and trailer around the
compressed data instead of a zlib wrapper. The gzip header will have no
file name, no extra data, no comment, no modification time (set to zero), no
- header crc, and the operating system will be set to 255 (unknown). If a
- gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+ header crc, and the operating system will be set to the appropriate value,
+ if the operating system was determined at compile time. If a gzip stream is
+ being written, strm->adler is a CRC-32 instead of an Adler-32.
+
+ For raw deflate or gzip encoding, a request for a 256-byte window is
+ rejected as invalid, since only the zlib header provides a means of
+ transmitting the window size to the decompressor.
The memLevel parameter specifies how much memory should be allocated
for the internal compression state. memLevel=1 uses minimum memory but is
addition, the current implementation of deflate will use at most the window
size minus 262 bytes of the provided dictionary.
- Upon return of this function, strm->adler is set to the adler32 value
+ Upon return of this function, strm->adler is set to the Adler-32 value
of the dictionary; the decompressor may later use this value to determine
- which dictionary has been used by the compressor. (The adler32 value
+ which dictionary has been used by the compressor. (The Adler-32 value
applies to the whole dictionary even if only a subset of the dictionary is
actually used by the compressor.) If a raw deflate was requested, then the
- adler32 value is not computed and strm->adler is not set.
+ Adler-32 value is not computed and strm->adler is not set.
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
not perform any compression: this will be done by deflate().
*/
+ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
+ Bytef *dictionary,
+ uInt *dictLength));
+/*
+ Returns the sliding dictionary being maintained by deflate. dictLength is
+ set to the number of bytes in the dictionary, and that many bytes are copied
+ to dictionary. dictionary must have enough space, where 32768 bytes is
+ always enough. If deflateGetDictionary() is called with dictionary equal to
+ Z_NULL, then only the dictionary length is returned, and nothing is copied.
+ Similary, if dictLength is Z_NULL, then it is not set.
+
+ deflateGetDictionary() may return a length less than the window size, even
+ when more than the window size in input has been provided. It may return up
+ to 258 bytes less in that case, due to how zlib's implementation of deflate
+ manages the sliding window and lookahead for matches, where matches can be
+ up to 258 bytes long. If the application needs the last window-size bytes of
+ input, then that would need to be saved by the application outside of zlib.
+
+ deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+ stream state is inconsistent.
+*/
+
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
z_streamp source));
/*
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
/*
- This function is equivalent to deflateEnd followed by deflateInit,
- but does not free and reallocate all the internal compression state. The
- stream will keep the same compression level and any other attributes that
- may have been set by deflateInit2.
+ This function is equivalent to deflateEnd followed by deflateInit, but
+ does not free and reallocate the internal compression state. The stream
+ will leave the compression level and any other attributes that may have been
+ set unchanged.
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
stream state was inconsistent (such as zalloc or state being Z_NULL).
int strategy));
/*
Dynamically update the compression level and compression strategy. The
- interpretation of level and strategy is as in deflateInit2. This can be
+ interpretation of level and strategy is as in deflateInit2(). This can be
used to switch between compression and straight copy of the input data, or
to switch to a different kind of input data requiring a different strategy.
- If the compression level is changed, the input available so far is
- compressed with the old level (and may be flushed); the new level will take
- effect only at the next call of deflate().
-
- Before the call of deflateParams, the stream state must be set as for
- a call of deflate(), since the currently available input may have to be
- compressed and flushed. In particular, strm->avail_out must be non-zero.
-
- deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
- stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
- strm->avail_out was zero.
+ If the compression approach (which is a function of the level) or the
+ strategy is changed, and if any input has been consumed in a previous
+ deflate() call, then the input available so far is compressed with the old
+ level and strategy using deflate(strm, Z_BLOCK). There are three approaches
+ for the compression levels 0, 1..3, and 4..9 respectively. The new level
+ and strategy will take effect at the next call of deflate().
+
+ If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+ not have enough output space to complete, then the parameter change will not
+ take effect. In this case, deflateParams() can be called again with the
+ same parameters and more output space to try again.
+
+ In order to assure a change in the parameters on the first try, the
+ deflate stream should be flushed using deflate() with Z_BLOCK or other flush
+ request until strm.avail_out is not zero, before calling deflateParams().
+ Then no more input data should be provided before the deflateParams() call.
+ If this is done, the old level and strategy will be applied to the data
+ compressed before deflateParams(), and the new level and strategy will be
+ applied to the the data compressed after deflateParams().
+
+ deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
+ state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
+ there was not enough output space to complete the compression of the
+ available input data before a change in the strategy or approach. Note that
+ in the case of a Z_BUF_ERROR, the parameters are not changed. A return
+ value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
+ retried with more output space.
*/
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
is for use with other formats that use the deflate compressed data format
such as zip. Those formats provide their own check values. If a custom
format is developed using the raw deflate format for compressed data, it is
- recommended that a check value such as an adler32 or a crc32 be applied to
+ recommended that a check value such as an Adler-32 or a CRC-32 be applied to
the uncompressed data as is done in the zlib, gzip, and zip formats. For
most applications, the zlib format should be used as is. Note that comments
above on the use in deflateInit2() applies to the magnitude of windowBits.
32 to windowBits to enable zlib and gzip decoding with automatic header
detection, or add 16 to decode only the gzip format (the zlib format will
return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a
- crc32 instead of an adler32.
+ CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see
+ below), inflate() will not automatically decode concatenated gzip streams.
+ inflate() will return Z_STREAM_END at the end of the gzip stream. The state
+ would need to be reset to continue decoding a subsequent gzip stream.
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
Initializes the decompression dictionary from the given uncompressed byte
sequence. This function must be called immediately after a call of inflate,
if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
- can be determined from the adler32 value returned by that call of inflate.
+ can be determined from the Adler-32 value returned by that call of inflate.
The compressor and decompressor must use exactly the same dictionary (see
deflateSetDictionary). For raw inflate, this function can be called at any
time to set the dictionary. If the provided dictionary is smaller than the
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
- expected one (incorrect adler32 value). inflateSetDictionary does not
+ expected one (incorrect Adler-32 value). inflateSetDictionary does not
perform any decompression: this will be done by subsequent calls of
inflate().
*/
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
/*
This function is equivalent to inflateEnd followed by inflateInit,
- but does not free and reallocate all the internal decompression state. The
+ but does not free and reallocate the internal decompression state. The
stream will keep attributes that may have been set by inflateInit2.
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
/*
This function is the same as inflateReset, but it also permits changing
the wrap and window size requests. The windowBits parameter is interpreted
- the same as it is for inflateInit2.
+ the same as it is for inflateInit2. If the window size is changed, then the
+ memory allocated for the window is freed, and the window will be reallocated
+ by inflate() if needed.
inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
stream state was inconsistent (such as zalloc or state being Z_NULL), or if
location in the input stream can be determined from avail_in and data_type
as noted in the description for the Z_BLOCK flush parameter for inflate.
- inflateMark returns the value noted above or -1 << 16 if the provided
+ inflateMark returns the value noted above, or -65536 if the provided
source stream state was inconsistent.
*/
This routine would normally be used in a utility that reads zip or gzip
files and writes out uncompressed files. The utility would decode the
header and process the trailer on its own, hence this routine expects only
- the raw deflate stream to decompress. This is different from the normal
- behavior of inflate(), which expects either a zlib or gzip header and
- trailer around the deflate stream.
+ the raw deflate stream to decompress. This is different from the default
+ behavior of inflate(), which expects a zlib header and trailer around the
+ deflate stream.
inflateBack() uses two subroutines supplied by the caller that are then
called by inflateBack() for input and output. inflateBack() calls those
parameters and return types are defined above in the in_func and out_func
typedefs. inflateBack() will call in(in_desc, &buf) which should return the
number of bytes of provided input, and a pointer to that input in buf. If
- there is no input available, in() must return zero--buf is ignored in that
- case--and inflateBack() will return a buffer error. inflateBack() will call
- out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
- should return zero on success, or non-zero on failure. If out() returns
- non-zero, inflateBack() will return with an error. Neither in() nor out()
- are permitted to change the contents of the window provided to
+ there is no input available, in() must return zero -- buf is ignored in that
+ case -- and inflateBack() will return a buffer error. inflateBack() will
+ call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
+ out() should return zero on success, or non-zero on failure. If out()
+ returns non-zero, inflateBack() will return with an error. Neither in() nor
+ out() are permitted to change the contents of the window provided to
inflateBackInit(), which is also the buffer that out() uses to write from.
The length written by out() will be at most the window size. Any non-zero
amount of input may be provided by in().
using strm->next_in which will be Z_NULL only if in() returned an error. If
strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
non-zero. (in() will always be called before out(), so strm->next_in is
- assured to be defined if out() returns non-zero.) Note that inflateBack()
+ assured to be defined if out() returns non-zero.) Note that inflateBack()
cannot return Z_OK.
*/
7.6: size of z_off_t
Compiler, assembler, and debug options:
- 8: DEBUG
+ 8: ZLIB_DEBUG
9: ASMV or ASMINF -- use ASM code
10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
11: 0 (reserved)
the byte length of the source buffer. Upon entry, destLen is the total size
of the destination buffer, which must be at least the value returned by
compressBound(sourceLen). Upon exit, destLen is the actual size of the
- compressed buffer.
+ compressed data. compress() is equivalent to compress2() with a level
+ parameter of Z_DEFAULT_COMPRESSION.
compress returns Z_OK if success, Z_MEM_ERROR if there was not
enough memory, Z_BUF_ERROR if there was not enough room in the output
length of the source buffer. Upon entry, destLen is the total size of the
destination buffer, which must be at least the value returned by
compressBound(sourceLen). Upon exit, destLen is the actual size of the
- compressed buffer.
+ compressed data.
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
uncompressed data. (The size of the uncompressed data must have been saved
previously by the compressor and transmitted to the decompressor by some
mechanism outside the scope of this compression library.) Upon exit, destLen
- is the actual size of the uncompressed buffer.
+ is the actual size of the uncompressed data.
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
enough memory, Z_BUF_ERROR if there was not enough room in the output
buffer with the uncompressed data up to that point.
*/
+ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong *sourceLen));
+/*
+ Same as uncompress, except that sourceLen is a pointer, where the
+ length of the source is *sourceLen. On return, *sourceLen is the number of
+ source bytes consumed.
+*/
+
/* gzip file access functions */
/*
default buffer size is 8192 bytes. This function must be called after
gzopen() or gzdopen(), and before any other calls that read or write the
file. The buffer memory allocation is always deferred to the first read or
- write. Two buffers are allocated, either both of the specified size when
- writing, or one of the specified size and the other twice that size when
- reading. A larger buffer size of, for example, 64K or 128K bytes will
- noticeably increase the speed of decompression (reading).
+ write. Three times that size in buffer space is allocated. A larger buffer
+ size of, for example, 64K or 128K bytes will noticeably increase the speed
+ of decompression (reading).
The new buffer size also affects the maximum length for gzprintf().
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
/*
Dynamically update the compression level or strategy. See the description
- of deflateInit2 for the meaning of these parameters.
+ of deflateInit2 for the meaning of these parameters. Previously provided
+ data is flushed before the parameter change.
- gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
- opened for writing.
+ gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
+ opened for writing, Z_ERRNO if there is an error writing the flushed data,
+ or Z_MEM_ERROR if there is a memory allocation error.
*/
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
case.
gzread returns the number of uncompressed bytes actually read, less than
- len for end of file, or -1 for error.
+ len for end of file, or -1 for error. If len is too large to fit in an int,
+ then nothing is read, -1 is returned, and the error state is set to
+ Z_STREAM_ERROR.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
+ gzFile file));
+/*
+ Read up to nitems items of size size from file to buf, otherwise operating
+ as gzread() does. This duplicates the interface of stdio's fread(), with
+ size_t request and return types. If the library defines size_t, then
+ z_size_t is identical to size_t. If not, then z_size_t is an unsigned
+ integer type that can contain a pointer.
+
+ gzfread() returns the number of full items read of size size, or zero if
+ the end of the file was reached and a full item could not be read, or if
+ there was an error. gzerror() must be consulted if zero is returned in
+ order to determine if there was an error. If the multiplication of size and
+ nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
+ is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
+
+ In the event that the end of file is reached and only a partial item is
+ available at the end, i.e. the remaining uncompressed data length is not a
+ multiple of size, then the final partial item is nevetheless read into buf
+ and the end-of-file flag is set. The length of the partial item read is not
+ provided, but could be inferred from the result of gztell(). This behavior
+ is the same as the behavior of fread() implementations in common libraries,
+ but it prevents the direct use of gzfread() to read a concurrently written
+ file, reseting and retrying on end-of-file, when size is not 1.
*/
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
error.
*/
+ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
+ z_size_t nitems, gzFile file));
+/*
+ gzfwrite() writes nitems items of size size from buf to file, duplicating
+ the interface of stdio's fwrite(), with size_t request and return types. If
+ the library defines size_t, then z_size_t is identical to size_t. If not,
+ then z_size_t is an unsigned integer type that can contain a pointer.
+
+ gzfwrite() returns the number of full items written of size size, or zero
+ if there was an error. If the multiplication of size and nitems overflows,
+ i.e. the product does not fit in a z_size_t, then nothing is written, zero
+ is returned, and the error state is set to Z_STREAM_ERROR.
+*/
+
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
/*
Converts, formats, and writes the arguments to the compressed file under
control of the format string, as in fprintf. gzprintf returns the number of
- uncompressed bytes actually written, or 0 in case of error. The number of
- uncompressed bytes written is limited to 8191, or one less than the buffer
- size given to gzbuffer(). The caller should assure that this limit is not
- exceeded. If it is exceeded, then gzprintf() will return an error (0) with
- nothing written. In this case, there may also be a buffer overflow with
- unpredictable consequences, which is possible only if zlib was compiled with
- the insecure functions sprintf() or vsprintf() because the secure snprintf()
- or vsnprintf() functions were not available. This can be determined using
- zlibCompileFlags().
+ uncompressed bytes actually written, or a negative zlib error code in case
+ of error. The number of uncompressed bytes written is limited to 8191, or
+ one less than the buffer size given to gzbuffer(). The caller should assure
+ that this limit is not exceeded. If it is exceeded, then gzprintf() will
+ return an error (0) with nothing written. In this case, there may also be a
+ buffer overflow with unpredictable consequences, which is possible only if
+ zlib was compiled with the insecure functions sprintf() or vsprintf()
+ because the secure snprintf() or vsnprintf() functions were not available.
+ This can be determined using zlibCompileFlags().
*/
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
If the flush parameter is Z_FINISH, the remaining data is written and the
gzip stream is completed in the output. If gzwrite() is called again, a new
gzip stream will be started in the output. gzread() is able to read such
- concatented gzip streams.
+ concatenated gzip streams.
gzflush should be called only when strictly necessary because it will
degrade compression if called too often.
return the updated checksum. If buf is Z_NULL, this function returns the
required initial value for the checksum.
- An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+ An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
much faster.
Usage example:
if (adler != original_adler) error();
*/
+ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
+ z_size_t len));
+/*
+ Same as adler32(), but with a size_t length.
+*/
+
/*
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
z_off_t len2));
if (crc != original_crc) error();
*/
+ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf,
+ z_size_t len));
+/*
+ Same as crc32(), but with a size_t length.
+*/
+
/*
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
unsigned char FAR *window,
const char *version,
int stream_size));
-#define deflateInit(strm, level) \
- deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
-#define inflateInit(strm) \
- inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
-#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
- deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
- (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
-#define inflateInit2(strm, windowBits) \
- inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
- (int)sizeof(z_stream))
-#define inflateBackInit(strm, windowBits, window) \
- inflateBackInit_((strm), (windowBits), (window), \
- ZLIB_VERSION, (int)sizeof(z_stream))
+#ifdef Z_PREFIX_SET
+# define z_deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+ (int)sizeof(z_stream))
+# define z_inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, (int)sizeof(z_stream))
+#else
+# define deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+# define inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+# define inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+ (int)sizeof(z_stream))
+# define inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, (int)sizeof(z_stream))
+#endif
#ifndef Z_SOLO
#ifdef Z_PREFIX_SET
# undef z_gzgetc
# define z_gzgetc(g) \
- ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
#else
# define gzgetc(g) \
- ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
#endif
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
#endif /* !Z_SOLO */
-/* hack for buggy compilers */
-#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
- struct internal_state {int dummy;};
-#endif
-
/* undocumented functions */
ZEXTERN const char * ZEXPORT zError OF((int));
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
+ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int));
+ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp));
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
-#if defined(_WIN32) && !defined(Z_SOLO)
+#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO)
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
const char *mode));
#endif
-ZLIB_1.2.0 {
- global:
- compressBound;
- deflateBound;
- inflateBack;
- inflateBackEnd;
- inflateBackInit_;
- inflateCopy;
- local:
- deflate_copyright;
- inflate_copyright;
- inflate_fast;
- inflate_table;
- zcalloc;
- zcfree;
- z_errmsg;
- gz_error;
- gz_intmax;
- _*;
-};
-
-ZLIB_1.2.0.2 {
- gzclearerr;
- gzungetc;
- zlibCompileFlags;
-} ZLIB_1.2.0;
-
-ZLIB_1.2.0.8 {
- deflatePrime;
-} ZLIB_1.2.0.2;
-
-ZLIB_1.2.2 {
- adler32_combine;
- crc32_combine;
- deflateSetHeader;
- inflateGetHeader;
-} ZLIB_1.2.0.8;
-
-ZLIB_1.2.2.3 {
- deflateTune;
- gzdirect;
-} ZLIB_1.2.2;
-
-ZLIB_1.2.2.4 {
- inflatePrime;
-} ZLIB_1.2.2.3;
-
-ZLIB_1.2.3.3 {
- adler32_combine64;
- crc32_combine64;
- gzopen64;
- gzseek64;
- gztell64;
- inflateUndermine;
-} ZLIB_1.2.2.4;
-
-ZLIB_1.2.3.4 {
- inflateReset2;
- inflateMark;
-} ZLIB_1.2.3.3;
-
-ZLIB_1.2.3.5 {
- gzbuffer;
- gzoffset;
- gzoffset64;
- gzclose_r;
- gzclose_w;
-} ZLIB_1.2.3.4;
-
-ZLIB_1.2.5.1 {
- deflatePending;
-} ZLIB_1.2.3.5;
-
-ZLIB_1.2.5.2 {
- deflateResetKeep;
- gzgetc_;
- inflateResetKeep;
-} ZLIB_1.2.5.1;
-
-ZLIB_1.2.7.1 {
- inflateGetDictionary;
- gzvprintf;
-} ZLIB_1.2.5.2;
+ZLIB_1.2.0 {\r
+ global:\r
+ compressBound;\r
+ deflateBound;\r
+ inflateBack;\r
+ inflateBackEnd;\r
+ inflateBackInit_;\r
+ inflateCopy;\r
+ local:\r
+ deflate_copyright;\r
+ inflate_copyright;\r
+ inflate_fast;\r
+ inflate_table;\r
+ zcalloc;\r
+ zcfree;\r
+ z_errmsg;\r
+ gz_error;\r
+ gz_intmax;\r
+ _*;\r
+};\r
+\r
+ZLIB_1.2.0.2 {\r
+ gzclearerr;\r
+ gzungetc;\r
+ zlibCompileFlags;\r
+} ZLIB_1.2.0;\r
+\r
+ZLIB_1.2.0.8 {\r
+ deflatePrime;\r
+} ZLIB_1.2.0.2;\r
+\r
+ZLIB_1.2.2 {\r
+ adler32_combine;\r
+ crc32_combine;\r
+ deflateSetHeader;\r
+ inflateGetHeader;\r
+} ZLIB_1.2.0.8;\r
+\r
+ZLIB_1.2.2.3 {\r
+ deflateTune;\r
+ gzdirect;\r
+} ZLIB_1.2.2;\r
+\r
+ZLIB_1.2.2.4 {\r
+ inflatePrime;\r
+} ZLIB_1.2.2.3;\r
+\r
+ZLIB_1.2.3.3 {\r
+ adler32_combine64;\r
+ crc32_combine64;\r
+ gzopen64;\r
+ gzseek64;\r
+ gztell64;\r
+ inflateUndermine;\r
+} ZLIB_1.2.2.4;\r
+\r
+ZLIB_1.2.3.4 {\r
+ inflateReset2;\r
+ inflateMark;\r
+} ZLIB_1.2.3.3;\r
+\r
+ZLIB_1.2.3.5 {\r
+ gzbuffer;\r
+ gzoffset;\r
+ gzoffset64;\r
+ gzclose_r;\r
+ gzclose_w;\r
+} ZLIB_1.2.3.4;\r
+\r
+ZLIB_1.2.5.1 {\r
+ deflatePending;\r
+} ZLIB_1.2.3.5;\r
+\r
+ZLIB_1.2.5.2 {\r
+ deflateResetKeep;\r
+ gzgetc_;\r
+ inflateResetKeep;\r
+} ZLIB_1.2.5.1;\r
+\r
+ZLIB_1.2.7.1 {\r
+ inflateGetDictionary;\r
+ gzvprintf;\r
+} ZLIB_1.2.5.2;\r
+\r
+ZLIB_1.2.9 {\r
+ inflateCodesUsed;\r
+ inflateValidate;\r
+ uncompress2;\r
+ gzfread;\r
+ gzfwrite;\r
+ deflateGetDictionary;\r
+ adler32_z;\r
+ crc32_z;\r
+} ZLIB_1.2.7.1;\r
/* zutil.c -- target dependent utility functions for the compression library
- * Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
+ * Copyright (C) 1995-2017 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/
# include "gzguts.h"
#endif
-#ifndef NO_DUMMY_DECL
-struct internal_state {int dummy;}; /* for buggy compilers */
-#endif
-
z_const char * const z_errmsg[10] = {
-"need dictionary", /* Z_NEED_DICT 2 */
-"stream end", /* Z_STREAM_END 1 */
-"", /* Z_OK 0 */
-"file error", /* Z_ERRNO (-1) */
-"stream error", /* Z_STREAM_ERROR (-2) */
-"data error", /* Z_DATA_ERROR (-3) */
-"insufficient memory", /* Z_MEM_ERROR (-4) */
-"buffer error", /* Z_BUF_ERROR (-5) */
-"incompatible version",/* Z_VERSION_ERROR (-6) */
-""};
+ (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
+ (z_const char *)"stream end", /* Z_STREAM_END 1 */
+ (z_const char *)"", /* Z_OK 0 */
+ (z_const char *)"file error", /* Z_ERRNO (-1) */
+ (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
+ (z_const char *)"data error", /* Z_DATA_ERROR (-3) */
+ (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
+ (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
+ (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
+ (z_const char *)""
+};
const char * ZEXPORT zlibVersion()
case 8: flags += 2 << 6; break;
default: flags += 3 << 6;
}
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
flags += 1 << 8;
#endif
#if defined(ASMV) || defined(ASMINF)
return flags;
}
-#ifdef DEBUG
-
+#ifdef ZLIB_DEBUG
+#include <stdlib.h>
# ifndef verbose
# define verbose 0
# endif
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
{
- voidpf buf = opaque; /* just to make some compilers happy */
+ voidpf buf;
ulg bsize = (ulg)items*size;
+ (void)opaque;
+
/* If we allocate less than 65520 bytes, we assume that farmalloc
* will return a usable pointer which doesn't have to be normalized.
*/
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
{
int n;
+
+ (void)opaque;
+
if (*(ush*)&ptr != 0) { /* object < 64K */
farfree(ptr);
return;
next_ptr--;
return;
}
- ptr = opaque; /* just to make some compilers happy */
Assert(0, "zcfree: ptr not found");
}
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
{
- if (opaque) opaque = 0; /* to make compiler happy */
+ (void)opaque;
return _halloc((long)items, size);
}
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
{
- if (opaque) opaque = 0; /* to make compiler happy */
+ (void)opaque;
_hfree(ptr);
}
unsigned items;
unsigned size;
{
- if (opaque) items += size - size; /* make compiler happy */
+ (void)opaque;
return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
(voidpf)calloc(items, size);
}
voidpf opaque;
voidpf ptr;
{
+ (void)opaque;
free(ptr);
- if (opaque) return; /* make compiler happy */
}
#endif /* MY_ZCALLOC */
/* zutil.h -- internal interface and configuration of the compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifndef local
# define local static
#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
+/* since "static" is used to mean two completely different things in C, we
+ define "local" for the non-static meaning of "static", for readability
+ (compile with -Dlocal if your debugger can't find static symbols) */
typedef unsigned char uch;
typedef uch FAR uchf;
#endif
#ifdef AMIGA
-# define OS_CODE 0x01
+# define OS_CODE 1
#endif
#if defined(VAXC) || defined(VMS)
-# define OS_CODE 0x02
+# define OS_CODE 2
# define F_OPEN(name, mode) \
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
#endif
+#ifdef __370__
+# if __TARGET_LIB__ < 0x20000000
+# define OS_CODE 4
+# elif __TARGET_LIB__ < 0x40000000
+# define OS_CODE 11
+# else
+# define OS_CODE 8
+# endif
+#endif
+
#if defined(ATARI) || defined(atarist)
-# define OS_CODE 0x05
+# define OS_CODE 5
#endif
#ifdef OS2
-# define OS_CODE 0x06
+# define OS_CODE 6
# if defined(M_I86) && !defined(Z_SOLO)
# include <malloc.h>
# endif
#endif
#if defined(MACOS) || defined(TARGET_OS_MAC)
-# define OS_CODE 0x07
+# define OS_CODE 7
# ifndef Z_SOLO
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
# include <unix.h> /* for fdopen */
# endif
#endif
-#ifdef TOPS20
-# define OS_CODE 0x0a
+#ifdef __acorn
+# define OS_CODE 13
#endif
-#ifdef WIN32
-# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
-# define OS_CODE 0x0b
-# endif
+#if defined(WIN32) && !defined(__CYGWIN__)
+# define OS_CODE 10
+#endif
+
+#ifdef _BEOS_
+# define OS_CODE 16
+#endif
+
+#ifdef __TOS_OS400__
+# define OS_CODE 18
#endif
-#ifdef __50SERIES /* Prime/PRIMOS */
-# define OS_CODE 0x0f
+#ifdef __APPLE__
+# define OS_CODE 19
#endif
#if defined(_BEOS_) || defined(RISCOS)
/* common defaults */
#ifndef OS_CODE
-# define OS_CODE 0x03 /* assume Unix */
+# define OS_CODE 3 /* assume Unix */
#endif
#ifndef F_OPEN
#endif
/* Diagnostic functions */
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
# include <stdio.h>
extern int ZLIB_INTERNAL z_verbose;
extern void ZLIB_INTERNAL z_error OF((char *m));
}
static PyObject *
-buffer_item(PyBufferObject *self, Py_ssize_t idx)
+buffer_item_impl(void *ptr, Py_ssize_t size, Py_ssize_t idx)
{
- void *ptr;
- Py_ssize_t size;
- if (!get_buf(self, &ptr, &size, ANY_BUFFER))
- return NULL;
if ( idx < 0 || idx >= size ) {
PyErr_SetString(PyExc_IndexError, "buffer index out of range");
return NULL;
}
static PyObject *
+buffer_item(PyBufferObject *self, Py_ssize_t idx)
+{
+ void *ptr;
+ Py_ssize_t size;
+ if (!get_buf(self, &ptr, &size, ANY_BUFFER))
+ return NULL;
+ return buffer_item_impl(ptr, size, idx);
+}
+
+static PyObject *
buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right)
{
void *ptr;
void *p;
Py_ssize_t size;
- if (!get_buf(self, &p, &size, ANY_BUFFER))
- return NULL;
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
- if (i < 0)
+ if (!get_buf(self, &p, &size, ANY_BUFFER))
+ return NULL;
+
+ if (i < 0) {
i += size;
- return buffer_item(self, i);
+ }
+ return buffer_item_impl(p, size, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
- if (PySlice_GetIndicesEx((PySliceObject*)item, size,
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0)
+ return NULL;
+ if (!get_buf(self, &p, &size, ANY_BUFFER))
return NULL;
- }
+ slicelength = _PySlice_AdjustIndices(size, &start, &stop, step);
if (slicelength <= 0)
return PyString_FromStringAndSize("", 0);
else if (step == 1)
}
static int
-buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other)
+buffer_ass_item_impl(void *ptr1, Py_ssize_t size, Py_ssize_t idx, PyObject *other)
{
PyBufferProcs *pb;
- void *ptr1, *ptr2;
- Py_ssize_t size;
+ void *ptr2;
Py_ssize_t count;
- if ( self->b_readonly ) {
- PyErr_SetString(PyExc_TypeError,
- "buffer is read-only");
- return -1;
- }
-
- if (!get_buf(self, &ptr1, &size, ANY_BUFFER))
- return -1;
-
if (idx < 0 || idx >= size) {
PyErr_SetString(PyExc_IndexError,
"buffer assignment index out of range");
}
static int
+buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other)
+{
+ void *ptr1;
+ Py_ssize_t size;
+
+ if ( self->b_readonly ) {
+ PyErr_SetString(PyExc_TypeError,
+ "buffer is read-only");
+ return -1;
+ }
+
+ if (!get_buf(self, &ptr1, &size, ANY_BUFFER))
+ return -1;
+ return buffer_ass_item_impl(ptr1, size, idx, other);
+}
+
+static int
buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, PyObject *other)
{
PyBufferProcs *pb;
"single-segment buffer object expected");
return -1;
}
- if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))
- return -1;
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return -1;
+ if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))
+ return -1;
+
if (i < 0)
i += selfsize;
- return buffer_ass_item(self, i, value);
+ return buffer_ass_item_impl(ptr1, selfsize, i, value);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
- if (PySlice_GetIndicesEx((PySliceObject *)item, selfsize,
- &start, &stop, &step, &slicelength) < 0)
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0)
+ return -1;
+ if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))
return -1;
+ slicelength = _PySlice_AdjustIndices(selfsize, &start, &stop, step);
if ((othersize = (*pb->bf_getreadbuffer)(value, 0, &ptr2)) < 0)
return -1;
}
else if (PySlice_Check(index)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
- if (PySlice_GetIndicesEx((PySliceObject *)index,
- PyByteArray_GET_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(index, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelength = _PySlice_AdjustIndices(PyByteArray_GET_SIZE(self),
+ &start, &stop, step);
if (slicelength <= 0)
return PyByteArray_FromStringAndSize("", 0);
}
}
else if (PySlice_Check(index)) {
- if (PySlice_GetIndicesEx((PySliceObject *)index,
- PyByteArray_GET_SIZE(self),
- &start, &stop, &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(index, &start, &stop, &step) < 0) {
return -1;
}
+ slicelen = _PySlice_AdjustIndices(PyByteArray_GET_SIZE(self), &start,
+ &stop, step);
}
else {
PyErr_SetString(PyExc_TypeError, "bytearray indices must be integer");
{
char *self_s, *result_s;
Py_ssize_t self_len, result_len;
- Py_ssize_t count, i, product;
+ Py_ssize_t count, i;
PyByteArrayObject *result;
self_len = PyByteArray_GET_SIZE(self);
- /* 1 at the end plus 1 after every character */
- count = self_len+1;
- if (maxcount < count)
+ /* 1 at the end plus 1 after every character;
+ count = min(maxcount, self_len + 1) */
+ if (maxcount <= self_len) {
count = maxcount;
+ }
+ else {
+ /* Can't overflow: self_len + 1 <= maxcount <= PY_SSIZE_T_MAX. */
+ count = self_len + 1;
+ }
/* Check for overflow */
/* result_len = count * to_len + self_len; */
- product = count * to_len;
- if (product / to_len != count) {
+ assert(count > 0);
+ if (to_len > (PY_SSIZE_T_MAX - self_len) / count) {
PyErr_SetString(PyExc_OverflowError,
- "replace string is too long");
+ "replace bytes is too long");
return NULL;
}
- result_len = product + self_len;
- if (result_len < 0) {
- PyErr_SetString(PyExc_OverflowError,
- "replace string is too long");
- return NULL;
- }
-
+ result_len = count * to_len + self_len;
if (! (result = (PyByteArrayObject *)
PyByteArray_FromStringAndSize(NULL, result_len)) )
return NULL;
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
- Py_ssize_t count, product;
+ Py_ssize_t count;
PyByteArrayObject *result;
self_s = PyByteArray_AS_STRING(self);
/* use the difference between current and new, hence the "-1" */
/* result_len = self_len + count * (to_len-1) */
- product = count * (to_len-1);
- if (product / (to_len-1) != count) {
+ assert(count > 0);
+ if (to_len - 1 > (PY_SSIZE_T_MAX - self_len) / count) {
PyErr_SetString(PyExc_OverflowError, "replace bytes is too long");
return NULL;
}
- result_len = self_len + product;
- if (result_len < 0) {
- PyErr_SetString(PyExc_OverflowError, "replace bytes is too long");
- return NULL;
- }
+ result_len = self_len + count * (to_len - 1);
if ( (result = (PyByteArrayObject *)
PyByteArray_FromStringAndSize(NULL, result_len)) == NULL)
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
- Py_ssize_t count, offset, product;
+ Py_ssize_t count, offset;
PyByteArrayObject *result;
self_s = PyByteArray_AS_STRING(self);
/* Check for overflow */
/* result_len = self_len + count * (to_len-from_len) */
- product = count * (to_len-from_len);
- if (product / (to_len-from_len) != count) {
- PyErr_SetString(PyExc_OverflowError, "replace bytes is too long");
- return NULL;
- }
- result_len = self_len + product;
- if (result_len < 0) {
+ assert(count > 0);
+ if (to_len - from_len > (PY_SSIZE_T_MAX - self_len) / count) {
PyErr_SetString(PyExc_OverflowError, "replace bytes is too long");
return NULL;
}
+ result_len = self_len + count * (to_len - from_len);
if ( (result = (PyByteArrayObject *)
PyByteArray_FromStringAndSize(NULL, result_len)) == NULL)
return NULL;
}
cr.real = PyFloat_AsDouble(tmp);
- cr.imag = 0.0; /* Shut up compiler warning */
+ cr.imag = 0.0;
Py_DECREF(tmp);
}
if (i == NULL) {
- ci.real = 0.0;
+ ci.real = cr.imag;
}
else if (PyComplex_Check(i)) {
ci = ((PyComplexObject*)i)->cval;
if (ci_is_complex) {
cr.real -= ci.imag;
}
- if (cr_is_complex) {
+ if (cr_is_complex && i != NULL) {
ci.real += cr.imag;
}
return complex_subtype_from_doubles(type, cr.real, ci.real);
return dict_set_item_by_hash_or_entry(op, key, hash, NULL, value);
}
+static int
+delitem_common(PyDictObject *mp, PyDictEntry *ep)
+{
+ PyObject *old_value, *old_key;
+
+ old_key = ep->me_key;
+ Py_INCREF(dummy);
+ ep->me_key = dummy;
+ old_value = ep->me_value;
+ ep->me_value = NULL;
+ mp->ma_used--;
+ Py_DECREF(old_value);
+ Py_DECREF(old_key);
+ return 0;
+}
+
int
PyDict_DelItem(PyObject *op, PyObject *key)
{
register PyDictObject *mp;
register long hash;
register PyDictEntry *ep;
- PyObject *old_value, *old_key;
if (!PyDict_Check(op)) {
PyErr_BadInternalCall();
set_key_error(key);
return -1;
}
- old_key = ep->me_key;
- Py_INCREF(dummy);
- ep->me_key = dummy;
- old_value = ep->me_value;
- ep->me_value = NULL;
- mp->ma_used--;
- Py_DECREF(old_value);
- Py_DECREF(old_key);
- return 0;
+
+ return delitem_common(mp, ep);
+}
+
+int
+_PyDict_DelItemIf(PyObject *op, PyObject *key,
+ int (*predicate)(PyObject *value))
+{
+ register PyDictObject *mp;
+ register long hash;
+ register PyDictEntry *ep;
+ int res;
+
+ if (!PyDict_Check(op)) {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ assert(key);
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ hash = PyObject_Hash(key);
+ if (hash == -1)
+ return -1;
+ }
+ mp = (PyDictObject *)op;
+ ep = (mp->ma_lookup)(mp, key, hash);
+ if (ep == NULL)
+ return -1;
+ if (ep->me_value == NULL) {
+ set_key_error(key);
+ return -1;
+ }
+ res = predicate(ep->me_value);
+ if (res == -1)
+ return -1;
+ if (res > 0)
+ return delitem_common(mp, ep);
+ else
+ return 0;
}
void
PyObject *key;
long hash;
- if (dictresize(mp, Py_SIZE(seq) / 2 * 3)) {
+ if (dictresize(mp, ((PyDictObject *)seq)->ma_used / 2 * 3)) {
Py_DECREF(d);
return NULL;
}
/* Update/merge with this (key, value) pair. */
key = PySequence_Fast_GET_ITEM(fast, 0);
value = PySequence_Fast_GET_ITEM(fast, 1);
+ Py_INCREF(key);
+ Py_INCREF(value);
if (override || PyDict_GetItem(d, key) == NULL) {
int status = PyDict_SetItem(d, key, value);
- if (status < 0)
+ if (status < 0) {
+ Py_DECREF(key);
+ Py_DECREF(value);
goto Fail;
+ }
}
+ Py_DECREF(key);
+ Py_DECREF(value);
Py_DECREF(fast);
Py_DECREF(item);
}
/* ditto for key */
Py_INCREF(key);
bval = PyDict_GetItem((PyObject *)b, key);
- Py_DECREF(key);
if (bval == NULL) {
+ Py_DECREF(key);
Py_DECREF(aval);
return 0;
}
cmp = PyObject_RichCompareBool(aval, bval, Py_EQ);
+ Py_DECREF(key);
Py_DECREF(aval);
if (cmp <= 0) /* error or not equal */
return cmp;
static PyObject *dictiter_iternextitem(dictiterobject *di)
{
- PyObject *key, *value, *result = di->di_result;
+ PyObject *key, *value, *result;
register Py_ssize_t i, mask;
register PyDictEntry *ep;
PyDictObject *d = di->di_dict;
if (i > mask)
goto fail;
- if (result->ob_refcnt == 1) {
+ di->len--;
+ key = ep[i].me_key;
+ value = ep[i].me_value;
+ Py_INCREF(key);
+ Py_INCREF(value);
+ result = di->di_result;
+ if (Py_REFCNT(result) == 1) {
+ PyObject *oldkey = PyTuple_GET_ITEM(result, 0);
+ PyObject *oldvalue = PyTuple_GET_ITEM(result, 1);
+ PyTuple_SET_ITEM(result, 0, key); /* steals reference */
+ PyTuple_SET_ITEM(result, 1, value); /* steals reference */
Py_INCREF(result);
- Py_DECREF(PyTuple_GET_ITEM(result, 0));
- Py_DECREF(PyTuple_GET_ITEM(result, 1));
+ Py_DECREF(oldkey);
+ Py_DECREF(oldvalue);
} else {
result = PyTuple_New(2);
if (result == NULL)
return NULL;
+ PyTuple_SET_ITEM(result, 0, key); /* steals reference */
+ PyTuple_SET_ITEM(result, 1, value); /* steals reference */
}
- di->len--;
- key = ep[i].me_key;
- value = ep[i].me_value;
- Py_INCREF(key);
- Py_INCREF(value);
- PyTuple_SET_ITEM(result, 0, key);
- PyTuple_SET_ITEM(result, 1, value);
return result;
fail:
static int
dictitems_contains(dictviewobject *dv, PyObject *obj)
{
+ int result;
PyObject *key, *value, *found;
if (dv->dv_dict == NULL)
return 0;
return -1;
return 0;
}
- return PyObject_RichCompareBool(value, found, Py_EQ);
+ Py_INCREF(found);
+ result = PyObject_RichCompareBool(value, found, Py_EQ);
+ Py_DECREF(found);
+ return result;
}
static PySequenceMethods dictitems_as_sequence = {
return -1;
}
+ if (PyLong_CheckExact(op)) {
+ /* avoid creating temporary int object */
+ return PyLong_AsLong(op);
+ }
+
io = (PyIntObject*) (*nb->nb_int) (op);
if (io == NULL)
return -1;
/* got a long? => retry int conversion */
val = PyLong_AsLong((PyObject *)io);
Py_DECREF(io);
- if ((val == -1) && PyErr_Occurred())
- return -1;
return val;
}
else
static PyObject *err_format = NULL;
if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
- _PyEval_SliceIndex, &start,
- _PyEval_SliceIndex, &stop))
+ _PyEval_SliceIndexNotNone, &start,
+ _PyEval_SliceIndexNotNone, &stop))
return NULL;
if (start < 0) {
start += Py_SIZE(self);
PyObject* it;
PyObject **src, **dest;
- if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelength = _PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
+ step);
if (slicelength <= 0) {
return PyList_New(0);
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
- if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return -1;
}
+ slicelength = _PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
+ step);
if (step == 1)
return list_ass_slice(self, start, stop, value);
else if (PySlice_Check(key)) {
Py_ssize_t start, stop, step, slicelength;
- if (PySlice_GetIndicesEx((PySliceObject*)key, get_shape0(view),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(key, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelength = _PySlice_AdjustIndices(get_shape0(view), &start, &stop,
+ step);
if (step == 1 && view->ndim == 1) {
Py_buffer newview;
else if (PySlice_Check(key)) {
Py_ssize_t stop, step;
- if (PySlice_GetIndicesEx((PySliceObject*)key, get_shape0(view),
- &start, &stop, &step, &len) < 0) {
+ if (_PySlice_Unpack(key, &start, &stop, &step) < 0) {
return -1;
}
+ len = _PySlice_AdjustIndices(get_shape0(view), &start, &stop, step);
if (step != 1) {
PyErr_SetNone(PyExc_NotImplementedError);
return -1;
}
int
-PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
- Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength)
+_PySlice_Unpack(PyObject *_r,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
{
+ PySliceObject *r = (PySliceObject *)_r;
/* this is harder to get right than you might think */
- Py_ssize_t defstart, defstop;
+ assert(PY_SSIZE_T_MIN + 1 <= -PY_SSIZE_T_MAX);
if (r->step == Py_None) {
*step = 1;
"slice step cannot be zero");
return -1;
}
+ /* Here *step might be -PY_SSIZE_T_MAX-1; in this case we replace it
+ * with -PY_SSIZE_T_MAX. This doesn't affect the semantics, and it
+ * guards against later undefined behaviour resulting from code that
+ * does "step = -step" as part of a slice reversal.
+ */
+ if (*step < -PY_SSIZE_T_MAX)
+ *step = -PY_SSIZE_T_MAX;
}
- defstart = *step < 0 ? length-1 : 0;
- defstop = *step < 0 ? -1 : length;
-
if (r->start == Py_None) {
- *start = defstart;
+ *start = *step < 0 ? PY_SSIZE_T_MAX : 0;
}
else {
if (!_PyEval_SliceIndex(r->start, start)) return -1;
- if (*start < 0) *start += length;
- if (*start < 0) *start = (*step < 0) ? -1 : 0;
- if (*start >= length)
- *start = (*step < 0) ? length - 1 : length;
}
if (r->stop == Py_None) {
- *stop = defstop;
+ *stop = *step < 0 ? PY_SSIZE_T_MIN : PY_SSIZE_T_MAX;
}
else {
if (!_PyEval_SliceIndex(r->stop, stop)) return -1;
- if (*stop < 0) *stop += length;
- if (*stop < 0) *stop = (*step < 0) ? -1 : 0;
- if (*stop >= length)
- *stop = (*step < 0) ? length - 1 : length;
}
- if ((*step < 0 && *stop >= *start)
- || (*step > 0 && *start >= *stop)) {
- *slicelength = 0;
+ return 0;
+}
+
+Py_ssize_t
+_PySlice_AdjustIndices(Py_ssize_t length,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t step)
+{
+ /* this is harder to get right than you might think */
+
+ assert(step != 0);
+ assert(step >= -PY_SSIZE_T_MAX);
+
+ if (*start < 0) {
+ *start += length;
+ if (*start < 0) {
+ *start = (step < 0) ? -1 : 0;
+ }
+ }
+ else if (*start >= length) {
+ *start = (step < 0) ? length - 1 : length;
+ }
+
+ if (*stop < 0) {
+ *stop += length;
+ if (*stop < 0) {
+ *stop = (step < 0) ? -1 : 0;
+ }
}
- else if (*step < 0) {
- *slicelength = (*stop-*start+1)/(*step)+1;
+ else if (*stop >= length) {
+ *stop = (step < 0) ? length - 1 : length;
+ }
+
+ if (step < 0) {
+ if (*stop < *start) {
+ return (*start - *stop - 1) / (-step) + 1;
+ }
}
else {
- *slicelength = (*stop-*start-1)/(*step)+1;
+ if (*start < *stop) {
+ return (*stop - *start - 1) / step + 1;
+ }
}
+ return 0;
+}
+
+#undef PySlice_GetIndicesEx
+int
+PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step,
+ Py_ssize_t *slicelength)
+{
+ if (_PySlice_Unpack((PyObject *)r, start, stop, step) < 0)
+ return -1;
+ *slicelength = _PySlice_AdjustIndices(length, start, stop, *step);
return 0;
}
static PyObject*
slice_indices(PySliceObject* self, PyObject* len)
{
- Py_ssize_t ilen, start, stop, step, slicelength;
+ Py_ssize_t ilen, start, stop, step;
ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError);
return NULL;
}
- if (PySlice_GetIndicesEx(self, ilen, &start, &stop,
- &step, &slicelength) < 0) {
+ if (_PySlice_Unpack((PyObject *)self, &start, &stop, &step) < 0) {
return NULL;
}
+ _PySlice_AdjustIndices(ilen, &start, &stop, step);
return Py_BuildValue("(nnn)", start, stop, step);
}
char *p, *buf;
const char *end;
PyObject *v;
- Py_ssize_t newlen = recode_encoding ? 4*len:len;
+ Py_ssize_t newlen;
+ /* Check for integer overflow */
+ if (recode_encoding && (len > PY_SSIZE_T_MAX / 4)) {
+ PyErr_SetString(PyExc_OverflowError, "string is too large");
+ return NULL;
+ }
+ newlen = recode_encoding ? 4*len:len;
v = PyString_FromStringAndSize((char *)NULL, newlen);
if (v == NULL)
return NULL;
char* result_buf;
PyObject* result;
- if (PySlice_GetIndicesEx((PySliceObject*)item,
- PyString_GET_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelength = _PySlice_AdjustIndices(PyString_GET_SIZE(self), &start,
+ &stop, step);
if (slicelength <= 0) {
return PyString_FromStringAndSize("", 0);
{
char *self_s, *result_s;
Py_ssize_t self_len, result_len;
- Py_ssize_t count, i, product;
+ Py_ssize_t count, i;
PyStringObject *result;
self_len = PyString_GET_SIZE(self);
- /* 1 at the end plus 1 after every character */
- count = self_len+1;
- if (maxcount < count)
+ /* 1 at the end plus 1 after every character;
+ count = min(maxcount, self_len + 1) */
+ if (maxcount <= self_len) {
count = maxcount;
+ }
+ else {
+ /* Can't overflow: self_len + 1 <= maxcount <= PY_SSIZE_T_MAX. */
+ count = self_len + 1;
+ }
/* Check for overflow */
/* result_len = count * to_len + self_len; */
- product = count * to_len;
- if (product / to_len != count) {
- PyErr_SetString(PyExc_OverflowError,
- "replace string is too long");
- return NULL;
- }
- result_len = product + self_len;
- if (result_len < 0) {
+ assert(count > 0);
+ if (to_len > (PY_SSIZE_T_MAX - self_len) / count) {
PyErr_SetString(PyExc_OverflowError,
"replace string is too long");
return NULL;
}
-
+ result_len = count * to_len + self_len;
if (! (result = (PyStringObject *)
PyString_FromStringAndSize(NULL, result_len)) )
return NULL;
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
- Py_ssize_t count, product;
+ Py_ssize_t count;
PyStringObject *result;
self_s = PyString_AS_STRING(self);
/* use the difference between current and new, hence the "-1" */
/* result_len = self_len + count * (to_len-1) */
- product = count * (to_len-1);
- if (product / (to_len-1) != count) {
- PyErr_SetString(PyExc_OverflowError, "replace string is too long");
- return NULL;
- }
- result_len = self_len + product;
- if (result_len < 0) {
+ assert(count > 0);
+ if (to_len - 1 > (PY_SSIZE_T_MAX - self_len) / count) {
PyErr_SetString(PyExc_OverflowError, "replace string is too long");
return NULL;
}
+ result_len = self_len + count * (to_len - 1);
if ( (result = (PyStringObject *)
PyString_FromStringAndSize(NULL, result_len)) == NULL)
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
- Py_ssize_t count, offset, product;
+ Py_ssize_t count, offset;
PyStringObject *result;
self_s = PyString_AS_STRING(self);
/* Check for overflow */
/* result_len = self_len + count * (to_len-from_len) */
- product = count * (to_len-from_len);
- if (product / (to_len-from_len) != count) {
- PyErr_SetString(PyExc_OverflowError, "replace string is too long");
- return NULL;
- }
- result_len = self_len + product;
- if (result_len < 0) {
+ assert(count > 0);
+ if (to_len - from_len > (PY_SSIZE_T_MAX - self_len) / count) {
PyErr_SetString(PyExc_OverflowError, "replace string is too long");
return NULL;
}
+ result_len = self_len + count * (to_len - from_len);
if ( (result = (PyStringObject *)
PyString_FromStringAndSize(NULL, result_len)) == NULL)
Py_ssize_t start, stop, step, slicelen, cur, i;
PyObject *result;
- if (PySlice_GetIndicesEx((PySliceObject *)item,
- VISIBLE_SIZE(self), &start, &stop,
- &step, &slicelen) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelen = _PySlice_AdjustIndices(VISIBLE_SIZE(self), &start, &stop,
+ step);
if (slicelen <= 0)
return PyTuple_New(0);
result = PyTuple_New(slicelen);
PyObject *v;
if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
- _PyEval_SliceIndex, &start,
- _PyEval_SliceIndex, &stop))
+ _PyEval_SliceIndexNotNone, &start,
+ _PyEval_SliceIndexNotNone, &stop))
return NULL;
if (start < 0) {
start += Py_SIZE(self);
PyObject* it;
PyObject **src, **dest;
- if (PySlice_GetIndicesEx((PySliceObject*)item,
- PyTuple_GET_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelength = _PySlice_AdjustIndices(PyTuple_GET_SIZE(self), &start,
+ &stop, step);
if (slicelength <= 0) {
return PyTuple_New(0);
static int
type_setattro(PyTypeObject *type, PyObject *name, PyObject *value)
{
+ int res;
if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
PyErr_Format(
PyExc_TypeError,
type->tp_name);
return -1;
}
- if (PyObject_GenericSetAttr((PyObject *)type, name, value) < 0)
- return -1;
- return update_slot(type, name);
+#ifdef Py_USING_UNICODE
+ if (PyUnicode_Check(name)) {
+ name = PyUnicode_AsEncodedString(name, NULL, NULL);
+ if (name == NULL)
+ return -1;
+ }
+ else
+#endif
+ Py_INCREF(name);
+
+ if (PyString_Check(name)) {
+ if (!PyString_CheckExact(name)) {
+ Py_SETREF(name,
+ PyString_FromStringAndSize(PyString_AS_STRING(name),
+ PyString_GET_SIZE(name))
+ );
+ if (name == NULL)
+ return -1;
+ }
+ PyString_InternInPlace(&name);
+ if (!PyString_CHECK_INTERNED(name)) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Out of memory interning an attribute name");
+ Py_DECREF(name);
+ return -1;
+ }
+ }
+ res = PyObject_GenericSetAttr((PyObject *)type, name, value);
+ if (res == 0) {
+ res = update_slot(type, name);
+ }
+ Py_DECREF(name);
+ return res;
}
static void
goto end;
assert(names == Py_None || PyList_Check(names));
+ if (required_state && Py_Py3kWarningFlag) {
+ Py_ssize_t basicsize = PyBaseObject_Type.tp_basicsize;
+ if (obj->ob_type->tp_dictoffset)
+ basicsize += sizeof(PyObject *);
+ if (obj->ob_type->tp_weaklistoffset)
+ basicsize += sizeof(PyObject *);
+ if (names != Py_None)
+ basicsize += sizeof(PyObject *) * PyList_GET_SIZE(names);
+ if (obj->ob_type->tp_basicsize > basicsize) {
+ PyObject *msg = PyString_FromFormat(
+ "can't pickle %.200s objects",
+ Py_TYPE(obj)->tp_name);
+ if (msg == NULL) {
+ goto end;
+ }
+ if (PyErr_WarnPy3k(PyString_AS_STRING(msg), 1) < 0) {
+ Py_DECREF(msg);
+ goto end;
+ }
+ Py_DECREF(msg);
+ }
+ }
+
if (names != Py_None) {
slots = PyDict_New();
if (slots == NULL)
/* Slots must be ordered by their offset in the PyHeapTypeObject. */
assert(!p[1].name || p->offset <= p[1].offset);
p->name_strobj = PyString_InternFromString(p->name);
- if (!p->name_strobj)
+ if (!p->name_strobj || !PyString_CHECK_INTERNED(p->name_strobj))
Py_FatalError("Out of memory interning slotdef names");
}
initialized = 1;
slotdef **pp;
int offset;
+ assert(PyString_CheckExact(name));
+ assert(PyString_CHECK_INTERNED(name));
+
/* Clear the VALID_VERSION flag of 'type' and all its
subclasses. This could possibly be unified with the
update_subclasses() recursion below, but carefully:
init_slotdefs();
pp = ptrs;
for (p = slotdefs; p->name; p++) {
- /* XXX assume name is interned! */
if (p->name_strobj == name)
*pp++ = p;
}
/* Make sure we have enough space for the separator and the item. */
itemlen = PyUnicode_GET_SIZE(item);
- new_res_used = res_used + itemlen;
- if (new_res_used < 0)
+ if (res_used > PY_SSIZE_T_MAX - itemlen)
goto Overflow;
+ new_res_used = res_used + itemlen;
if (i < seqlen - 1) {
- new_res_used += seplen;
- if (new_res_used < 0)
+ if (new_res_used > PY_SSIZE_T_MAX - seplen)
goto Overflow;
+ new_res_used += seplen;
}
if (new_res_used > res_alloc) {
/* double allocated size until it's big enough */
do {
- res_alloc += res_alloc;
- if (res_alloc <= 0)
+ if (res_alloc > PY_SSIZE_T_MAX / 2)
goto Overflow;
+ res_alloc += res_alloc;
} while (new_res_used > res_alloc);
if (_PyUnicode_Resize(&res, res_alloc) < 0) {
Py_DECREF(item);
} else {
Py_ssize_t n, i, j;
- Py_ssize_t product, new_size, delta;
+ Py_ssize_t new_size, delta;
Py_UNICODE *p;
/* replace strings */
if (delta == 0) {
new_size = self->length;
} else {
- product = n * (str2->length - str1->length);
- if ((product / (str2->length - str1->length)) != n) {
- PyErr_SetString(PyExc_OverflowError,
- "replace string is too long");
- return NULL;
- }
- new_size = self->length + product;
- if (new_size < 0) {
+ assert(n > 0);
+ if (delta > (PY_SSIZE_T_MAX - self->length) / n) {
PyErr_SetString(PyExc_OverflowError,
"replace string is too long");
return NULL;
}
+ new_size = self->length + delta * n;
}
u = _PyUnicode_New(new_size);
if (!u)
Py_UNICODE* result_buf;
PyObject* result;
- if (PySlice_GetIndicesEx((PySliceObject*)item, PyUnicode_GET_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
+ if (_PySlice_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
+ slicelength = _PySlice_AdjustIndices(PyUnicode_GET_SIZE(self), &start,
+ &stop, step);
if (slicelength <= 0) {
return PyUnicode_FromUnicode(NULL, 0);
{
self->hash = -1;
self->wr_object = ob;
+ self->wr_prev = NULL;
+ self->wr_next = NULL;
Py_XINCREF(callback);
self->wr_callback = callback;
}
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS;USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories="..\..\Modules\expat"\r
- PreprocessorDefinitions="XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="USE_PYEXPAT_CAPI;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
>\r
</File>\r
<File\r
+ RelativePath="..\..\Modules\expat\loadlibrary.c"\r
+ >\r
+ </File>\r
+ <File\r
RelativePath="..\..\Modules\expat\xmlparse.c"\r
>\r
</File>\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc32"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include32"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
/>\r
<Tool\r
Name="VCCLCompilerTool"\r
- AdditionalIncludeDirectories="$(opensslDir)\inc64"\r
+ AdditionalIncludeDirectories="$(opensslDir)\include64"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
-from __future__ import with_statement, print_function
# Script for building the _ssl and _hashlib modules for Windows.
# Uses Perl to setup the OpenSSL environment correctly
# and build OpenSSL, then invokes a simple nmake session
# python.exe build_ssl.py Release x64
# python.exe build_ssl.py Release Win32
-from __future__ import with_statement
-import os, sys, re, shutil
+from __future__ import with_statement, print_function
+import os
+import re
+import sys
+import time
import subprocess
-
-# Find all "foo.exe" files on the PATH.
-def find_all_on_path(filename, extras = None):
- entries = os.environ["PATH"].split(os.pathsep)
- ret = []
- for p in entries:
- fname = os.path.abspath(os.path.join(p, filename))
- if os.path.isfile(fname) and fname not in ret:
- ret.append(fname)
- if extras:
- for p in extras:
- fname = os.path.abspath(os.path.join(p, filename))
- if os.path.isfile(fname) and fname not in ret:
- ret.append(fname)
- return ret
-
-# Find a suitable Perl installation for OpenSSL.
-# cygwin perl does *not* work. ActivePerl does.
-# Being a Perl dummy, the simplest way I can check is if the "Win32" package
-# is available.
-def find_working_perl(perls):
- for perl in perls:
+from shutil import copy
+from distutils import log
+from distutils.spawn import find_executable
+from distutils.file_util import copy_file
+from distutils.sysconfig import parse_makefile, expand_makefile_vars
+
+# The mk1mf.pl output filename template
+# !!! This must match what is used in prepare_ssl.py
+MK1MF_FMT = 'ms\\nt{}.mak'
+
+# The header files output directory name template
+# !!! This must match what is used in prepare_ssl.py
+INCLUDE_FMT = 'include{}'
+
+# Fetch all the directory definitions from VC properties
+def get_project_properties(propfile):
+ macro_pattern = r'<UserMacro\s+Name="([^"]+?)"\s+Value="([^"]*?)"\s*/>'
+ with open(propfile) as fin:
+ items = re.findall(macro_pattern, fin.read(), re.MULTILINE)
+ props = dict(items)
+ for name, value in items:
try:
- subprocess.check_output([perl, "-e", "use win32;"])
- except Subprocess.CalledProcessError:
- continue
- else:
- return perl
- print("Can not find a suitable PERL:")
- if perls:
- print(" the following perl interpreters were found:")
- for p in perls:
- print(" ", p)
- print(" None of these versions appear suitable for building OpenSSL")
- else:
- print(" NO perl interpreters were found on this machine at all!")
- print(" Please install ActivePerl and ensure it appears on your path")
- return None
+ props[name] = expand_makefile_vars(value, props)
+ except TypeError:
+ # value contains undefined variable reference, drop it
+ del props[name]
+ return props
-# Fetch SSL directory from VC properties
-def get_ssl_dir():
- propfile = (os.path.join(os.path.dirname(__file__), 'pyproject.vsprops'))
- with open(propfile) as f:
- m = re.search('openssl-([^"]+)"', f.read())
- return "..\..\externals\openssl-"+m.group(1)
-
-def create_makefile64(makefile, m32):
- """Create and fix makefile for 64bit
-
- Replace 32 with 64bit directories
- """
- if not os.path.isfile(m32):
- return
- with open(m32) as fin:
- with open(makefile, 'w') as fout:
- for line in fin:
- line = line.replace("=tmp32", "=tmp64")
- line = line.replace("=out32", "=out64")
- line = line.replace("=inc32", "=inc64")
- # force 64 bit machine
- line = line.replace("MKLIB=lib", "MKLIB=lib /MACHINE:X64")
- line = line.replace("LFLAGS=", "LFLAGS=/MACHINE:X64 ")
- # don't link against the lib on 64bit systems
- line = line.replace("bufferoverflowu.lib", "")
- fout.write(line)
- os.unlink(m32)
-
-def fix_makefile(makefile):
+_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
+def fix_makefile(makefile, platform_makefile, suffix):
"""Fix some stuff in all makefiles
"""
- if not os.path.isfile(makefile):
- return
- fin = open(makefile)
- with open(makefile) as fin:
- lines = fin.readlines()
- with open(makefile, 'w') as fout:
- for line in lines:
- if line.startswith("PERL="):
- continue
- if line.startswith("CP="):
- line = "CP=copy\n"
- if line.startswith("MKDIR="):
- line = "MKDIR=mkdir\n"
- if line.startswith("CFLAG="):
- line = line.strip()
- for algo in ("RC5", "MDC2", "IDEA"):
- noalgo = " -DOPENSSL_NO_%s" % algo
- if noalgo not in line:
- line = line + noalgo
- line = line + '\n'
+ subs = {
+ 'PERL': 'rem', # just in case
+ 'CP': 'copy',
+ 'MKDIR': 'mkdir',
+ 'OUT_D': 'out' + suffix,
+ 'TMP_D': 'tmp' + suffix,
+ 'INC_D': INCLUDE_FMT.format(suffix),
+ 'INCO_D': '$(INC_D)\\openssl',
+ }
+ with open(platform_makefile) as fin, open(makefile, 'w') as fout:
+ for line in fin:
+ m = _variable_rx.match(line)
+ if m:
+ name = m.group(1)
+ if name in subs:
+ line = '%s=%s\n' % (name, subs[name])
fout.write(line)
-def run_configure(configure, do_script):
- print("perl Configure "+configure+" no-idea no-mdc2")
- os.system("perl Configure "+configure+" no-idea no-mdc2")
- print(do_script)
- os.system(do_script)
+
+_copy_rx = re.compile(r'\t\$\(PERL\) '
+ r'\$\(SRC_D\)\\util\\copy-if-different.pl '
+ r'"([^"]+)"\s+"([^"]+)"')
+def copy_files(makefile, makevars):
+ # Create the destination directories (see 'init' rule in nt.dll)
+ for varname in ('TMP_D', 'LIB_D', 'INC_D', 'INCO_D'):
+ dirname = makevars[varname]
+ if not os.path.isdir(dirname):
+ os.mkdir(dirname)
+ # Process the just local library headers (HEADER) as installed headers
+ # (EXHEADER) are handled by prepare_ssl.py (see 'headers' rule in nt.dll)
+ headers = set(makevars['HEADER'].split())
+ with open(makefile) as fin:
+ for line in fin:
+ m = _copy_rx.match(line)
+ if m:
+ src, dst = m.groups()
+ src = expand_makefile_vars(src, makevars)
+ dst = expand_makefile_vars(dst, makevars)
+ if dst in headers:
+ copy_file(src, dst, preserve_times=False, update=True)
+
+
+# Update buildinf.h for the build platform.
+def fix_buildinf(makevars):
+ platform_cpp_symbol = 'MK1MF_PLATFORM_'
+ platform_cpp_symbol += makevars['PLATFORM'].replace('-', '_')
+ fn = expand_makefile_vars('$(INCL_D)\\buildinf.h', makevars)
+ with open(fn, 'w') as f:
+ # sanity check
+ f.write(('#ifndef {}\n'
+ ' #error "Windows build (PLATFORM={PLATFORM}) only"\n'
+ '#endif\n').format(platform_cpp_symbol, **makevars))
+ buildinf = (
+ '#define CFLAGS "compiler: cl {CFLAG}"\n'
+ '#define PLATFORM "{PLATFORM}"\n'
+ '#define DATE "{}"\n'
+ ).format(time.asctime(time.gmtime()),
+ **makevars)
+ f.write(buildinf)
+ print('Updating buildinf:')
+ print(buildinf)
+ sys.stdout.flush()
+
def main():
- build_all = "-a" in sys.argv
- if sys.argv[1] == "Release":
- debug = False
- elif sys.argv[1] == "Debug":
- debug = True
- else:
- raise ValueError(str(sys.argv))
+ if sys.argv[1] == "Debug":
+ print("OpenSSL debug builds aren't supported.")
+ elif sys.argv[1] != "Release":
+ raise ValueError('Unrecognized configuration: %s' % sys.argv[1])
if sys.argv[2] == "Win32":
- arch = "x86"
- configure = "VC-WIN32"
- do_script = "ms\\do_nasm"
- makefile="ms\\nt.mak"
- m32 = makefile
+ platform = "VC-WIN32"
+ suffix = '32'
elif sys.argv[2] == "x64":
- arch="amd64"
- configure = "VC-WIN64A"
- do_script = "ms\\do_win64a"
- makefile = "ms\\nt64.mak"
- m32 = makefile.replace('64', '')
- #os.environ["VSEXTCOMP_USECL"] = "MS_OPTERON"
- else:
- raise ValueError(str(sys.argv))
-
- make_flags = ""
- if build_all:
- make_flags = "-a"
- # perl should be on the path, but we also look in "\perl" and "c:\\perl"
- # as "well known" locations
- perls = find_all_on_path("perl.exe", [r"\perl\bin",
- r"C:\perl\bin",
- r"\perl64\bin",
- r"C:\perl64\bin",
- ])
- perl = find_working_perl(perls)
- if perl:
- print("Found a working perl at '%s'" % (perl,))
- # Set PERL for the makefile to find it
- os.environ["PERL"] = perl
+ platform = "VC-WIN64A"
+ suffix = '64'
else:
- print("No Perl installation was found. Existing Makefiles are used.")
- sys.stdout.flush()
- # Look for SSL 2 levels up from pcbuild - ie, same place zlib etc all live.
- ssl_dir = get_ssl_dir()
- if ssl_dir is None:
+ raise ValueError('Unrecognized platform: %s' % sys.argv[2])
+
+ # Have the distutils functions display information output
+ log.set_verbosity(1)
+
+ # Use the same properties that are used in the VS projects
+ solution_dir = os.path.dirname(__file__)
+ propfile = os.path.join(solution_dir, 'pyproject.vsprops')
+ props = get_project_properties(propfile)
+
+ # Ensure we have the necessary external depenedencies
+ ssl_dir = os.path.join(solution_dir, props['opensslDir'])
+ if not os.path.isdir(ssl_dir):
+ print("Could not find the OpenSSL sources, try running "
+ "'build.bat -e'")
+ sys.exit(1)
+
+ # Ensure the executables used herein are available.
+ if not find_executable('nmake.exe'):
+ print('Could not find nmake.exe, try running env.bat')
sys.exit(1)
# add our copy of NASM to PATH. It will be on the same level as openssl
- for dir in os.listdir(os.path.join(ssl_dir, os.pardir)):
+ externals_dir = os.path.join(solution_dir, props['externalsDir'])
+ for dir in os.listdir(externals_dir):
if dir.startswith('nasm'):
- nasm_dir = os.path.join(ssl_dir, os.pardir, dir)
+ nasm_dir = os.path.join(externals_dir, dir)
nasm_dir = os.path.abspath(nasm_dir)
old_path = os.environ['PATH']
os.environ['PATH'] = os.pathsep.join([nasm_dir, old_path])
break
else:
- print('NASM was not found, make sure it is on PATH')
-
+ if not find_executable('nasm.exe'):
+ print('Could not find nasm.exe, please add to PATH')
+ sys.exit(1)
+
+ # If the ssl makefiles do not exist, we invoke PCbuild/prepare_ssl.py
+ # to generate them.
+ platform_makefile = MK1MF_FMT.format(suffix)
+ if not os.path.isfile(os.path.join(ssl_dir, platform_makefile)):
+ pcbuild_dir = os.path.join(os.path.dirname(externals_dir), 'PCbuild')
+ prepare_ssl = os.path.join(pcbuild_dir, 'prepare_ssl.py')
+ rc = subprocess.call([sys.executable, prepare_ssl, ssl_dir])
+ if rc:
+ print('Executing', prepare_ssl, 'failed (error %d)' % rc)
+ sys.exit(rc)
old_cd = os.getcwd()
try:
os.chdir(ssl_dir)
- # rebuild makefile when we do the role over from 32 to 64 build
- if arch == "amd64" and os.path.isfile(m32) and not os.path.isfile(makefile):
- os.unlink(m32)
-
- # If the ssl makefiles do not exist, we invoke Perl to generate them.
- # Due to a bug in this script, the makefile sometimes ended up empty
- # Force a regeneration if it is.
- if not os.path.isfile(makefile) or os.path.getsize(makefile)==0:
- if perl is None:
- print("Perl is required to build the makefiles!")
- sys.exit(1)
-
- print("Creating the makefiles...")
+
+ # Get the variables defined in the current makefile, if it exists.
+ makefile = MK1MF_FMT.format('')
+ try:
+ makevars = parse_makefile(makefile)
+ except EnvironmentError:
+ makevars = {'PLATFORM': None}
+
+ # Rebuild the makefile when building for different a platform than
+ # the last run.
+ if makevars['PLATFORM'] != platform:
+ print("Updating the makefile...")
sys.stdout.flush()
- # Put our working Perl at the front of our path
- os.environ["PATH"] = os.path.dirname(perl) + \
- os.pathsep + \
- os.environ["PATH"]
- run_configure(configure, do_script)
- if debug:
- print("OpenSSL debug builds aren't supported.")
- #if arch=="x86" and debug:
- # # the do_masm script in openssl doesn't generate a debug
- # # build makefile so we generate it here:
- # os.system("perl util\mk1mf.pl debug "+configure+" >"+makefile)
-
- if arch == "amd64":
- create_makefile64(makefile, m32)
- fix_makefile(makefile)
- shutil.copy(r"crypto\buildinf.h", r"crypto\buildinf_%s.h" % arch)
- shutil.copy(r"crypto\opensslconf.h", r"crypto\opensslconf_%s.h" % arch)
+ # Firstly, apply the changes for the platform makefile into
+ # a temporary file to prevent any errors from this script
+ # causing false positives on subsequent runs.
+ new_makefile = makefile + '.new'
+ fix_makefile(new_makefile, platform_makefile, suffix)
+ makevars = parse_makefile(new_makefile)
+
+ # Secondly, perform the make recipes that use Perl
+ copy_files(new_makefile, makevars)
+
+ # Set our build information in buildinf.h.
+ # XXX: This isn't needed for a properly "prepared" SSL, but
+ # it fixes the current checked-in external (as of 2017-05).
+ fix_buildinf(makevars)
+
+ # Finally, move the temporary file to its real destination.
+ if os.path.exists(makefile):
+ os.remove(makefile)
+ os.rename(new_makefile, makefile)
# Now run make.
- if arch == "amd64":
- rc = os.system("nasm -f win64 -DNEAR -Ox -g ms\\uptable.asm")
- if rc:
- print("nasm assembler has failed.")
- sys.exit(rc)
-
- shutil.copy(r"crypto\buildinf_%s.h" % arch, r"crypto\buildinf.h")
- shutil.copy(r"crypto\opensslconf_%s.h" % arch, r"crypto\opensslconf.h")
-
- #makeCommand = "nmake /nologo PERL=\"%s\" -f \"%s\"" %(perl, makefile)
- makeCommand = "nmake /nologo -f \"%s\"" % makefile
+ makeCommand = "nmake /nologo /f \"%s\" lib" % makefile
print("Executing ssl makefiles:", makeCommand)
sys.stdout.flush()
rc = os.system(makeCommand)
if rc:
- print("Executing "+makefile+" failed")
- print(rc)
+ print("Executing", makefile, "failed (error %d)" % rc)
sys.exit(rc)
finally:
os.chdir(old_cd)
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS;PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
<Tool\r
Name="VCCLCompilerTool"\r
AdditionalIncludeDirectories=".\..\..\Modules\expat"\r
- PreprocessorDefinitions="PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE"\r
+ PreprocessorDefinitions="PYEXPAT_EXPORTS;XML_STATIC"\r
/>\r
<Tool\r
Name="VCManagedResourceCompilerTool"\r
>\r
</File>\r
<File\r
+ RelativePath="..\..\Modules\expat\loadlibrary.c"\r
+ >\r
+ </File>\r
+ <File\r
RelativePath="..\..\Modules\expat\xmlparse.c"\r
>\r
</File>\r
InlineFunctionExpansion="1"\r
EnableIntrinsicFunctions="true"\r
AdditionalIncludeDirectories="..\..\Include; ..\..\PC"\r
- PreprocessorDefinitions="_WIN32"\r
+ PreprocessorDefinitions="_WIN32;WIN32"\r
StringPooling="true"\r
ExceptionHandling="0"\r
RuntimeLibrary="0"\r
/>\r
<UserMacro\r
Name="opensslDir"\r
- Value="$(externalsDir)\openssl-1.0.2j"\r
+ Value="$(externalsDir)\openssl-1.0.2k"\r
/>\r
<UserMacro\r
Name="tcltkDir"\r
</Files>\r
<Globals>\r
</Globals>\r
-</VisualStudioProject>\r\r
+</VisualStudioProject>\r
\r
Get the source code through\r
\r
- svn export http://svn.python.org/projects/external/openssl-1.0.2j\r
+ svn export http://svn.python.org/projects/external/openssl-1.0.2k\r
\r
** NOTE: if you use the PCbuild\get_externals.bat approach for\r
obtaining external sources then you don't need to manually get the source\r
p = PyString_AS_STRING(out);
for (i = 0; i < envsize; i++) {
- int ksize, vsize, totalsize;
+ size_t ksize, vsize, totalsize;
PyObject* key = PyList_GET_ITEM(keys, i);
PyObject* value = PyList_GET_ITEM(values, i);
}
ksize = PyString_GET_SIZE(key);
vsize = PyString_GET_SIZE(value);
+ if (strlen(PyString_AS_STRING(key)) != ksize ||
+ strlen(PyString_AS_STRING(value)) != vsize)
+ {
+ PyErr_SetString(PyExc_TypeError, "embedded null character");
+ goto error;
+ }
+ /* Search from index 1 because on Windows starting '=' is allowed for
+ defining hidden environment variables. */
+ if (ksize == 0 || strchr(PyString_AS_STRING(key) + 1, '=') != NULL) {
+ PyErr_SetString(PyExc_ValueError, "illegal environment variable name");
+ goto error;
+ }
totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 +
vsize + 1 + 1;
if (totalsize > PyString_GET_SIZE(out)) {
- int offset = p - PyString_AS_STRING(out);
+ size_t offset = p - PyString_AS_STRING(out);
if (_PyString_Resize(&out, totalsize + 1024))
goto exit;
p = PyString_AS_STRING(out) + offset;
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{EB1C19C1-1F18-421E-9735-CAEE69DC6A3C}</ProjectGuid>
- <RootNamespace>wininst</RootNamespace>
- <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>
- <SupportPGO>false</SupportPGO>
- </PropertyGroup>
- <Import Project="..\..\PCBuild\python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>Application</ConfigurationType>
- <UseOfMfc>false</UseOfMfc>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="..\..\PCBuild\pyproject.props" />
- </ImportGroup>
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- <OutDir>$(PySourcePath)lib\distutils\command\</OutDir>
- <LinkIncremental>false</LinkIncremental>
- <TargetName>wininst-$(VisualStudioVersion)</TargetName>
- <TargetName Condition="$(Platform) == 'x64'">$(TargetName)-amd64</TargetName>
- <TargetExt>.exe</TargetExt>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Midl>
- <TypeLibraryName>$(OutDir)wininst.tlb</TypeLibraryName>
- </Midl>
- <ClCompile>
- <Optimization>MinSpace</Optimization>
- <AdditionalIncludeDirectories>$(PySourcePath)Modules\zlib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <ResourceCompile>
- <AdditionalIncludeDirectories>$(PySourcePath)PC\bdist_wininst;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- </ResourceCompile>
- <Link>
- <AdditionalDependencies>comctl32.lib;imagehlp.lib;%(AdditionalDependencies)</AdditionalDependencies>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="extract.c" />
- <ClCompile Include="install.c" />
- <ClCompile Include="..\..\Modules\zlib\adler32.c" />
- <ClCompile Include="..\..\Modules\zlib\crc32.c" />
- <ClCompile Include="..\..\Modules\zlib\inffast.c" />
- <ClCompile Include="..\..\Modules\zlib\inflate.c" />
- <ClCompile Include="..\..\Modules\zlib\inftrees.c" />
- <ClCompile Include="..\..\Modules\zlib\zutil.c" />
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="archive.h" />
- </ItemGroup>
- <ItemGroup>
- <ResourceCompile Include="install.rc" />
- </ItemGroup>
- <ItemGroup>
- <None Include="PythonPowered.bmp" />
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{EB1C19C1-1F18-421E-9735-CAEE69DC6A3C}</ProjectGuid>\r
+ <RootNamespace>wininst</RootNamespace>\r
+ <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>\r
+ <SupportPGO>false</SupportPGO>\r
+ </PropertyGroup>\r
+ <Import Project="..\..\PCBuild\python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>Application</ConfigurationType>\r
+ <UseOfMfc>false</UseOfMfc>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="..\..\PCBuild\pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ <OutDir>$(PySourcePath)lib\distutils\command\</OutDir>\r
+ <LinkIncremental>false</LinkIncremental>\r
+ <TargetName>wininst-$(VisualStudioVersion)</TargetName>\r
+ <TargetName Condition="$(Platform) == 'x64'">$(TargetName)-amd64</TargetName>\r
+ <TargetExt>.exe</TargetExt>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Midl>\r
+ <TypeLibraryName>$(OutDir)wininst.tlb</TypeLibraryName>\r
+ </Midl>\r
+ <ClCompile>\r
+ <Optimization>MinSpace</Optimization>\r
+ <AdditionalIncludeDirectories>$(PySourcePath)Modules\zlib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <ResourceCompile>\r
+ <AdditionalIncludeDirectories>$(PySourcePath)PC\bdist_wininst;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ </ResourceCompile>\r
+ <Link>\r
+ <AdditionalDependencies>comctl32.lib;imagehlp.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="extract.c" />\r
+ <ClCompile Include="install.c" />\r
+ <ClCompile Include="..\..\Modules\zlib\adler32.c" />\r
+ <ClCompile Include="..\..\Modules\zlib\crc32.c" />\r
+ <ClCompile Include="..\..\Modules\zlib\inffast.c" />\r
+ <ClCompile Include="..\..\Modules\zlib\inflate.c" />\r
+ <ClCompile Include="..\..\Modules\zlib\inftrees.c" />\r
+ <ClCompile Include="..\..\Modules\zlib\zutil.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="archive.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="install.rc" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <None Include="PythonPowered.bmp" />\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
</Project>
\ No newline at end of file
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{293b1092-03ad-4b7c-acb9-c4ab62e52f55}</UniqueIdentifier>
- <Extensions>cpp;c;cxx;rc;def;r;odl;idl;hpj;bat</Extensions>
- </Filter>
- <Filter Include="Source Files\zlib">
- <UniqueIdentifier>{0edc0406-282f-4dbc-b60e-a867c34a2a31}</UniqueIdentifier>
- </Filter>
- <Filter Include="Header Files">
- <UniqueIdentifier>{ea0c0f0e-3b73-474e-a999-e9689d032ccc}</UniqueIdentifier>
- <Extensions>h;hpp;hxx;hm;inl</Extensions>
- </Filter>
- <Filter Include="Resource Files">
- <UniqueIdentifier>{0c77c1cf-3f87-4f87-bd86-b425211c2181}</UniqueIdentifier>
- <Extensions>ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\bdist_wininst\extract.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\bdist_wininst\install.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\adler32.c">
- <Filter>Source Files\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\crc32.c">
- <Filter>Source Files\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\inffast.c">
- <Filter>Source Files\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\inflate.c">
- <Filter>Source Files\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\inftrees.c">
- <Filter>Source Files\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\zutil.c">
- <Filter>Source Files\zlib</Filter>
- </ClCompile>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\PC\bdist_wininst\archive.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ResourceCompile Include="..\PC\bdist_wininst\install.rc">
- <Filter>Resource Files</Filter>
- </ResourceCompile>
- </ItemGroup>
- <ItemGroup>
- <None Include="..\PC\bdist_wininst\PythonPowered.bmp">
- <Filter>Resource Files</Filter>
- </None>
- </ItemGroup>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{293b1092-03ad-4b7c-acb9-c4ab62e52f55}</UniqueIdentifier>\r
+ <Extensions>cpp;c;cxx;rc;def;r;odl;idl;hpj;bat</Extensions>\r
+ </Filter>\r
+ <Filter Include="Source Files\zlib">\r
+ <UniqueIdentifier>{0edc0406-282f-4dbc-b60e-a867c34a2a31}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{ea0c0f0e-3b73-474e-a999-e9689d032ccc}</UniqueIdentifier>\r
+ <Extensions>h;hpp;hxx;hm;inl</Extensions>\r
+ </Filter>\r
+ <Filter Include="Resource Files">\r
+ <UniqueIdentifier>{0c77c1cf-3f87-4f87-bd86-b425211c2181}</UniqueIdentifier>\r
+ <Extensions>ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe</Extensions>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\bdist_wininst\extract.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\bdist_wininst\install.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\adler32.c">\r
+ <Filter>Source Files\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\crc32.c">\r
+ <Filter>Source Files\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\inffast.c">\r
+ <Filter>Source Files\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\inflate.c">\r
+ <Filter>Source Files\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\inftrees.c">\r
+ <Filter>Source Files\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\zutil.c">\r
+ <Filter>Source Files\zlib</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\PC\bdist_wininst\archive.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="..\PC\bdist_wininst\install.rc">\r
+ <Filter>Resource Files</Filter>\r
+ </ResourceCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <None Include="..\PC\bdist_wininst\PythonPowered.bmp">\r
+ <Filter>Resource Files</Filter>\r
+ </None>\r
+ </ItemGroup>\r
</Project>
\ No newline at end of file
VALUE "FileDescription", "Python Core\0"
VALUE "FileVersion", PYTHON_VERSION
VALUE "InternalName", "Python DLL\0"
- VALUE "LegalCopyright", "Copyright © 2001-2016 Python Software Foundation. Copyright © 2000 BeOpen.com. Copyright © 1995-2001 CNRI. Copyright © 1991-1995 SMC.\0"
+ VALUE "LegalCopyright", "Copyright © 2001-2017 Python Software Foundation. Copyright © 2000 BeOpen.com. Copyright © 1995-2001 CNRI. Copyright © 1991-1995 SMC.\0"
VALUE "OriginalFilename", PYTHON_DLL_NAME "\0"
VALUE "ProductName", "Python\0"
VALUE "ProductVersion", PYTHON_VERSION
-Welcome to the "PC" subdirectory of the Python distribution
-***********************************************************
-
-This "PC" subdirectory contains complete project files to make
-several older PC ports of Python, as well as all the PC-specific
-Python source files. It should be located in the root of the
-Python distribution, and there should be directories "Modules",
-"Objects", "Python", etc. in the parent directory of this "PC"
-subdirectory. Be sure to read the documentation in the Python
-distribution.
-
-Python requires library files such as string.py to be available in
-one or more library directories. The search path of libraries is
-set up when Python starts. To see the current Python library search
-path, start Python and enter "import sys" and "print sys.path".
-
-All PC ports use this scheme to try to set up a module search path:
-
- 1) The script location; the current directory without script.
- 2) The PYTHONPATH variable, if set.
- 3) For Win32 platforms (NT/95), paths specified in the Registry.
- 4) Default directories lib, lib/win, lib/test, lib/tkinter;
- these are searched relative to the environment variable
- PYTHONHOME, if set, or relative to the executable and its
- ancestors, if a landmark file (Lib/string.py) is found ,
- or the current directory (not useful).
- 5) The directory containing the executable.
-
-The best installation strategy is to put the Python executable (and
-DLL, for Win32 platforms) in some convenient directory such as
-C:/python, and copy all library files and subdirectories (using XCOPY)
-to C:/python/lib. Then you don't need to set PYTHONPATH. Otherwise,
-set the environment variable PYTHONPATH to your Python search path.
-For example,
- set PYTHONPATH=.;d:\python\lib;d:\python\lib\win;d:\python\lib\dos-8x3
-
-There are several add-in modules to build Python programs which use
-the native Windows operating environment. The ports here just make
-"QuickWin" and DOS Python versions which support a character-mode
-(console) environment. Look in www.python.org for Tkinter, PythonWin,
-WPY and wxPython.
-
-To make a Python port, start the Integrated Development Environment
-(IDE) of your compiler, and read in the native "project file"
-(or makefile) provided. This will enable you to change any source
-files or build settings so you can make custom builds.
-
-pyconfig.h An important configuration file specific to PC's.
-
-config.c The list of C modules to include in the Python PC
- version. Manually edit this file to add or
- remove Python modules.
-
-testpy.py A Python test program. Run this to test your
- Python port. It should produce copious output,
- ending in a report on how many tests were OK, how many
- failed, and how many were skipped. Don't worry about
- skipped tests (these test unavailable optional features).
-
-
-Additional files and subdirectories for 32-bit Windows
-======================================================
-
-python_nt.rc Resource compiler input for python15.dll.
-
-dl_nt.c, import_nt.c
- Additional sources used for 32-bit Windows features.
-
-getpathp.c Default sys.path calculations (for all PC platforms).
-
-dllbase_nt.txt A (manually maintained) list of base addresses for
- various DLLs, to avoid run-time relocation.
-
-
-Legacy support for older versions of Visual Studio
-==================================================
-The subdirectories VC6, VS7.1 and VS8.0 contain legacy support older
-versions of Microsoft Visual Studio. See PCbuild/readme.txt.
-
-EMX development tools for OS/2
-==============================
-
-See os2emx/readme.txt. This platform is maintained by Andrew MacIntyre.
-
-IBM VisualAge C/C++ for OS/2
-============================
-
-See os2vacpp/readme.txt. This platform is supported by Jeff Rush.
-
-NOTE: Support for os2vacpp may be dropped in the near future. Please move
- to EMX.
-
-Note for Windows 3.x and DOS users
-==================================
-
-Neither Windows 3.x nor DOS is supported any more. The last Python
-version that supported these was Python 1.5.2; the support files were
-present in Python 2.0 but weren't updated, and it is not our intention
-to support these platforms for Python 2.x.
+Welcome to the "PC" subdirectory of the Python distribution\r
+***********************************************************\r
+\r
+This "PC" subdirectory contains complete project files to make\r
+several older PC ports of Python, as well as all the PC-specific\r
+Python source files. It should be located in the root of the\r
+Python distribution, and there should be directories "Modules",\r
+"Objects", "Python", etc. in the parent directory of this "PC"\r
+subdirectory. Be sure to read the documentation in the Python\r
+distribution.\r
+\r
+Python requires library files such as string.py to be available in\r
+one or more library directories. The search path of libraries is\r
+set up when Python starts. To see the current Python library search\r
+path, start Python and enter "import sys" and "print sys.path".\r
+\r
+All PC ports use this scheme to try to set up a module search path:\r
+\r
+ 1) The script location; the current directory without script.\r
+ 2) The PYTHONPATH variable, if set.\r
+ 3) For Win32 platforms (NT/95), paths specified in the Registry.\r
+ 4) Default directories lib, lib/win, lib/test, lib/tkinter;\r
+ these are searched relative to the environment variable\r
+ PYTHONHOME, if set, or relative to the executable and its\r
+ ancestors, if a landmark file (Lib/string.py) is found ,\r
+ or the current directory (not useful).\r
+ 5) The directory containing the executable.\r
+\r
+The best installation strategy is to put the Python executable (and\r
+DLL, for Win32 platforms) in some convenient directory such as\r
+C:/python, and copy all library files and subdirectories (using XCOPY)\r
+to C:/python/lib. Then you don't need to set PYTHONPATH. Otherwise,\r
+set the environment variable PYTHONPATH to your Python search path.\r
+For example,\r
+ set PYTHONPATH=.;d:\python\lib;d:\python\lib\win;d:\python\lib\dos-8x3\r
+\r
+There are several add-in modules to build Python programs which use\r
+the native Windows operating environment. The ports here just make\r
+"QuickWin" and DOS Python versions which support a character-mode\r
+(console) environment. Look in www.python.org for Tkinter, PythonWin,\r
+WPY and wxPython.\r
+\r
+To make a Python port, start the Integrated Development Environment\r
+(IDE) of your compiler, and read in the native "project file"\r
+(or makefile) provided. This will enable you to change any source\r
+files or build settings so you can make custom builds.\r
+\r
+pyconfig.h An important configuration file specific to PC's.\r
+\r
+config.c The list of C modules to include in the Python PC\r
+ version. Manually edit this file to add or\r
+ remove Python modules.\r
+\r
+testpy.py A Python test program. Run this to test your\r
+ Python port. It should produce copious output,\r
+ ending in a report on how many tests were OK, how many\r
+ failed, and how many were skipped. Don't worry about\r
+ skipped tests (these test unavailable optional features).\r
+\r
+\r
+Additional files and subdirectories for 32-bit Windows\r
+======================================================\r
+\r
+python_nt.rc Resource compiler input for python15.dll.\r
+\r
+dl_nt.c, import_nt.c\r
+ Additional sources used for 32-bit Windows features.\r
+\r
+getpathp.c Default sys.path calculations (for all PC platforms).\r
+\r
+dllbase_nt.txt A (manually maintained) list of base addresses for\r
+ various DLLs, to avoid run-time relocation.\r
+\r
+\r
+Legacy support for older versions of Visual Studio\r
+==================================================\r
+The subdirectories VC6, VS7.1 and VS8.0 contain legacy support older\r
+versions of Microsoft Visual Studio. See PCbuild/readme.txt.\r
+\r
+EMX development tools for OS/2\r
+==============================\r
+\r
+See os2emx/readme.txt. This platform is maintained by Andrew MacIntyre.\r
+\r
+IBM VisualAge C/C++ for OS/2\r
+============================\r
+\r
+See os2vacpp/readme.txt. This platform is supported by Jeff Rush.\r
+\r
+NOTE: Support for os2vacpp may be dropped in the near future. Please move\r
+ to EMX.\r
+\r
+Note for Windows 3.x and DOS users\r
+==================================\r
+\r
+Neither Windows 3.x nor DOS is supported any more. The last Python\r
+version that supported these was Python 1.5.2; the support files were\r
+present in Python 2.0 but weren't updated, and it is not our intention\r
+to support these platforms for Python 2.x.\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{B4D38F3F-68FB-42EC-A45D-E00657BB3627}</ProjectGuid>
- <RootNamespace>_bsddb</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <PropertyGroup Label="Configuration" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(bsddbDir)\build_windows;$(bsddbDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <BaseAddress>0x1e180000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\bsddb.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_bsddb.c" />
- <ClCompile Include="$(bsddbDir)\crypto\aes_method.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_compact.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_compare.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_conv.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_curadj.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_cursor.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_delete.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_method.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_open.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_put.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_rec.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_reclaim.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_recno.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_rsearch.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_search.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_split.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_stat.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_upgrade.c" />
- <ClCompile Include="$(bsddbDir)\btree\bt_verify.c" />
- <ClCompile Include="$(bsddbDir)\btree\btree_auto.c" />
- <ClCompile Include="$(bsddbDir)\db\crdel_auto.c" />
- <ClCompile Include="$(bsddbDir)\db\crdel_rec.c" />
- <ClCompile Include="$(bsddbDir)\crypto\crypto.c" />
- <ClCompile Include="$(bsddbDir)\db\db.c" />
- <ClCompile Include="$(bsddbDir)\db\db_am.c" />
- <ClCompile Include="$(bsddbDir)\db\db_auto.c" />
- <ClCompile Include="$(bsddbDir)\common\db_byteorder.c" />
- <ClCompile Include="$(bsddbDir)\db\db_cam.c" />
- <ClCompile Include="$(bsddbDir)\db\db_cds.c" />
- <ClCompile Include="$(bsddbDir)\db\db_conv.c" />
- <ClCompile Include="$(bsddbDir)\db\db_dispatch.c" />
- <ClCompile Include="$(bsddbDir)\db\db_dup.c" />
- <ClCompile Include="$(bsddbDir)\common\db_err.c" />
- <ClCompile Include="$(bsddbDir)\common\db_getlong.c" />
- <ClCompile Include="$(bsddbDir)\common\db_idspace.c" />
- <ClCompile Include="$(bsddbDir)\db\db_iface.c" />
- <ClCompile Include="$(bsddbDir)\db\db_join.c" />
- <ClCompile Include="$(bsddbDir)\common\db_log2.c" />
- <ClCompile Include="$(bsddbDir)\db\db_meta.c" />
- <ClCompile Include="$(bsddbDir)\db\db_method.c" />
- <ClCompile Include="$(bsddbDir)\db\db_open.c" />
- <ClCompile Include="$(bsddbDir)\db\db_overflow.c" />
- <ClCompile Include="$(bsddbDir)\db\db_ovfl_vrfy.c" />
- <ClCompile Include="$(bsddbDir)\db\db_pr.c" />
- <ClCompile Include="$(bsddbDir)\db\db_rec.c" />
- <ClCompile Include="$(bsddbDir)\db\db_reclaim.c" />
- <ClCompile Include="$(bsddbDir)\db\db_remove.c" />
- <ClCompile Include="$(bsddbDir)\db\db_rename.c" />
- <ClCompile Include="$(bsddbDir)\db\db_ret.c" />
- <ClCompile Include="$(bsddbDir)\db\db_setid.c" />
- <ClCompile Include="$(bsddbDir)\db\db_setlsn.c" />
- <ClCompile Include="$(bsddbDir)\common\db_shash.c" />
- <ClCompile Include="$(bsddbDir)\db\db_stati.c" />
- <ClCompile Include="$(bsddbDir)\db\db_truncate.c" />
- <ClCompile Include="$(bsddbDir)\db\db_upg.c" />
- <ClCompile Include="$(bsddbDir)\db\db_upg_opd.c" />
- <ClCompile Include="$(bsddbDir)\db\db_vrfy.c" />
- <ClCompile Include="$(bsddbDir)\db\db_vrfyutil.c" />
- <ClCompile Include="$(bsddbDir)\dbm\dbm.c" />
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg.c" />
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_auto.c" />
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_rec.c" />
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_stat.c" />
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_util.c" />
- <ClCompile Include="$(bsddbDir)\common\dbt.c" />
- <ClCompile Include="$(bsddbDir)\env\env_alloc.c" />
- <ClCompile Include="$(bsddbDir)\env\env_config.c" />
- <ClCompile Include="$(bsddbDir)\env\env_failchk.c" />
- <ClCompile Include="$(bsddbDir)\env\env_file.c" />
- <ClCompile Include="$(bsddbDir)\env\env_globals.c" />
- <ClCompile Include="$(bsddbDir)\env\env_method.c" />
- <ClCompile Include="$(bsddbDir)\env\env_name.c" />
- <ClCompile Include="$(bsddbDir)\env\env_open.c" />
- <ClCompile Include="$(bsddbDir)\env\env_recover.c" />
- <ClCompile Include="$(bsddbDir)\env\env_region.c" />
- <ClCompile Include="$(bsddbDir)\env\env_register.c" />
- <ClCompile Include="$(bsddbDir)\env\env_sig.c" />
- <ClCompile Include="$(bsddbDir)\env\env_stat.c" />
- <ClCompile Include="$(bsddbDir)\fileops\fileops_auto.c" />
- <ClCompile Include="$(bsddbDir)\fileops\fop_basic.c" />
- <ClCompile Include="$(bsddbDir)\fileops\fop_rec.c" />
- <ClCompile Include="$(bsddbDir)\fileops\fop_util.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_auto.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_conv.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_dup.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_func.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_meta.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_method.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_open.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_page.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_rec.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_reclaim.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_stat.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_upgrade.c" />
- <ClCompile Include="$(bsddbDir)\hash\hash_verify.c" />
- <ClCompile Include="$(bsddbDir)\hmac\hmac.c" />
- <ClCompile Include="$(bsddbDir)\hsearch\hsearch.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_deadlock.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_failchk.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_id.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_list.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_method.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_region.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_stat.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_timer.c" />
- <ClCompile Include="$(bsddbDir)\lock\lock_util.c" />
- <ClCompile Include="$(bsddbDir)\log\log.c" />
- <ClCompile Include="$(bsddbDir)\log\log_archive.c" />
- <ClCompile Include="$(bsddbDir)\log\log_compare.c" />
- <ClCompile Include="$(bsddbDir)\log\log_debug.c" />
- <ClCompile Include="$(bsddbDir)\log\log_get.c" />
- <ClCompile Include="$(bsddbDir)\log\log_method.c" />
- <ClCompile Include="$(bsddbDir)\log\log_put.c" />
- <ClCompile Include="$(bsddbDir)\log\log_stat.c" />
- <ClCompile Include="$(bsddbDir)\common\mkpath.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_alloc.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_bh.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_fget.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_fmethod.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_fopen.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_fput.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_fset.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_method.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_mvcc.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_region.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_register.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_resize.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_stat.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_sync.c" />
- <ClCompile Include="$(bsddbDir)\mp\mp_trickle.c" />
- <ClCompile Include="$(bsddbDir)\crypto\mersenne\mt19937db.c" />
- <ClCompile Include="$(bsddbDir)\mutex\mut_alloc.c" />
- <ClCompile Include="$(bsddbDir)\mutex\mut_failchk.c" />
- <ClCompile Include="$(bsddbDir)\mutex\mut_method.c" />
- <ClCompile Include="$(bsddbDir)\mutex\mut_region.c" />
- <ClCompile Include="$(bsddbDir)\mutex\mut_stat.c" />
- <ClCompile Include="$(bsddbDir)\mutex\mut_win32.c" />
- <ClCompile Include="$(bsddbDir)\common\openflags.c" />
- <ClCompile Include="$(bsddbDir)\os\os_abort.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_abs.c" />
- <ClCompile Include="$(bsddbDir)\os\os_addrinfo.c" />
- <ClCompile Include="$(bsddbDir)\os\os_alloc.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_clock.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_config.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_cpu.c" />
- <ClCompile Include="$(bsddbDir)\os\os_ctime.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_dir.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_errno.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_fid.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_flock.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_fsync.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_getenv.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_handle.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_map.c" />
- <ClCompile Include="$(bsddbDir)\common\os_method.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_mkdir.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_open.c" />
- <ClCompile Include="$(bsddbDir)\os\os_pid.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_rename.c" />
- <ClCompile Include="$(bsddbDir)\os\os_root.c" />
- <ClCompile Include="$(bsddbDir)\os\os_rpath.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_rw.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_seek.c" />
- <ClCompile Include="$(bsddbDir)\os\os_stack.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_stat.c" />
- <ClCompile Include="$(bsddbDir)\os\os_tmpdir.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_truncate.c" />
- <ClCompile Include="$(bsddbDir)\os\os_uid.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_unlink.c" />
- <ClCompile Include="$(bsddbDir)\os_windows\os_yield.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_auto.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_conv.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_files.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_method.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_open.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_rec.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_stat.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_upgrade.c" />
- <ClCompile Include="$(bsddbDir)\qam\qam_verify.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_auto.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_backup.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_elect.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_lease.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_log.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_method.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_record.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_region.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_stat.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_util.c" />
- <ClCompile Include="$(bsddbDir)\rep\rep_verify.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_auto.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_elect.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_method.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_msg.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_net.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_queue.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_sel.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_stat.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_util.c" />
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_windows.c" />
- <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-alg-fst.c" />
- <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-api-fst.c" />
- <ClCompile Include="$(bsddbDir)\sequence\seq_stat.c" />
- <ClCompile Include="$(bsddbDir)\sequence\sequence.c" />
- <ClCompile Include="$(bsddbDir)\hmac\sha1.c" />
- <ClCompile Include="$(bsddbDir)\clib\strsep.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_auto.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_chkpt.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_failchk.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_method.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_rec.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_recover.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_region.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_stat.c" />
- <ClCompile Include="$(bsddbDir)\txn\txn_util.c" />
- <ClCompile Include="$(bsddbDir)\common\util_cache.c" />
- <ClCompile Include="$(bsddbDir)\common\util_log.c" />
- <ClCompile Include="$(bsddbDir)\common\util_sig.c" />
- <ClCompile Include="$(bsddbDir)\xa\xa.c" />
- <ClCompile Include="$(bsddbDir)\xa\xa_db.c" />
- <ClCompile Include="$(bsddbDir)\xa\xa_map.c" />
- <ClCompile Include="$(bsddbDir)\common\zerofill.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{B4D38F3F-68FB-42EC-A45D-E00657BB3627}</ProjectGuid>\r
+ <RootNamespace>_bsddb</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <PropertyGroup Label="Configuration" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(bsddbDir)\build_windows;$(bsddbDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <Link>\r
+ <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ <BaseAddress>0x1e180000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\bsddb.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_bsddb.c" />\r
+ <ClCompile Include="$(bsddbDir)\crypto\aes_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_compact.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_compare.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_conv.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_curadj.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_cursor.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_delete.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_open.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_put.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_reclaim.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_recno.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_rsearch.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_search.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_split.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_upgrade.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_verify.c" />\r
+ <ClCompile Include="$(bsddbDir)\btree\btree_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\crdel_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\crdel_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\crypto\crypto.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_am.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\db_byteorder.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_cam.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_cds.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_conv.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_dispatch.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_dup.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\db_err.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\db_getlong.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\db_idspace.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_iface.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_join.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\db_log2.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_meta.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_open.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_overflow.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_ovfl_vrfy.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_pr.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_reclaim.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_remove.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_rename.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_ret.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_setid.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_setlsn.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\db_shash.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_stati.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_truncate.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_upg.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_upg_opd.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_vrfy.c" />\r
+ <ClCompile Include="$(bsddbDir)\db\db_vrfyutil.c" />\r
+ <ClCompile Include="$(bsddbDir)\dbm\dbm.c" />\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg.c" />\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_util.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\dbt.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_alloc.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_config.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_failchk.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_file.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_globals.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_name.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_open.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_recover.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_region.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_register.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_sig.c" />\r
+ <ClCompile Include="$(bsddbDir)\env\env_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\fileops\fileops_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\fileops\fop_basic.c" />\r
+ <ClCompile Include="$(bsddbDir)\fileops\fop_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\fileops\fop_util.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_conv.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_dup.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_func.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_meta.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_open.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_page.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_reclaim.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_upgrade.c" />\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_verify.c" />\r
+ <ClCompile Include="$(bsddbDir)\hmac\hmac.c" />\r
+ <ClCompile Include="$(bsddbDir)\hsearch\hsearch.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_deadlock.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_failchk.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_id.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_list.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_region.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_timer.c" />\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_util.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log_archive.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log_compare.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log_debug.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log_get.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log_put.c" />\r
+ <ClCompile Include="$(bsddbDir)\log\log_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\mkpath.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_alloc.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_bh.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fget.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fmethod.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fopen.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fput.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fset.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_mvcc.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_region.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_register.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_resize.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_sync.c" />\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_trickle.c" />\r
+ <ClCompile Include="$(bsddbDir)\crypto\mersenne\mt19937db.c" />\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_alloc.c" />\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_failchk.c" />\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_region.c" />\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_win32.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\openflags.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_abort.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_abs.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_addrinfo.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_alloc.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_clock.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_config.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_cpu.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_ctime.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_dir.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_errno.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_fid.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_flock.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_fsync.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_getenv.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_handle.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_map.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\os_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_mkdir.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_open.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_pid.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_rename.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_root.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_rpath.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_rw.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_seek.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_stack.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_tmpdir.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_truncate.c" />\r
+ <ClCompile Include="$(bsddbDir)\os\os_uid.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_unlink.c" />\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_yield.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_conv.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_files.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_open.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_upgrade.c" />\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_verify.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_backup.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_elect.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_lease.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_log.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_record.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_region.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_util.c" />\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_verify.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_elect.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_msg.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_net.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_queue.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_sel.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_util.c" />\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_windows.c" />\r
+ <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-alg-fst.c" />\r
+ <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-api-fst.c" />\r
+ <ClCompile Include="$(bsddbDir)\sequence\seq_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\sequence\sequence.c" />\r
+ <ClCompile Include="$(bsddbDir)\hmac\sha1.c" />\r
+ <ClCompile Include="$(bsddbDir)\clib\strsep.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_auto.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_chkpt.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_failchk.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_method.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_rec.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_recover.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_region.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_stat.c" />\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_util.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\util_cache.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\util_log.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\util_sig.c" />\r
+ <ClCompile Include="$(bsddbDir)\xa\xa.c" />\r
+ <ClCompile Include="$(bsddbDir)\xa\xa_db.c" />\r
+ <ClCompile Include="$(bsddbDir)\xa\xa_map.c" />\r
+ <ClCompile Include="$(bsddbDir)\common\zerofill.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{82655853-5a03-4804-a421-44510138071e}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{c52be92f-9033-4a0f-bf55-1b65c7e7b015}</UniqueIdentifier>
- </Filter>
- <Filter Include="Berkeley DB 4.7.25 Source Files">
- <UniqueIdentifier>{49074366-917a-4969-88c7-0f6ec09c7021}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\bsddb.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_bsddb.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\crypto\aes_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_compact.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_compare.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_conv.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_curadj.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_cursor.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_delete.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_open.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_put.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_reclaim.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_recno.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_rsearch.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_search.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_split.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_upgrade.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\bt_verify.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\btree\btree_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\crdel_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\crdel_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\crypto\crypto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_am.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\db_byteorder.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_cam.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_cds.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_conv.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_dispatch.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_dup.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\db_err.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\db_getlong.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\db_idspace.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_iface.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_join.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\db_log2.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_meta.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_open.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_overflow.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_ovfl_vrfy.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_pr.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_reclaim.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_remove.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_rename.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_ret.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_setid.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_setlsn.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\db_shash.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_stati.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_truncate.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_upg.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_upg_opd.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_vrfy.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\db\db_vrfyutil.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\dbm\dbm.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\dbreg\dbreg_util.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\dbt.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_alloc.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_config.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_failchk.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_file.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_globals.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_name.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_open.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_recover.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_region.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_register.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_sig.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\env\env_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\fileops\fileops_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\fileops\fop_basic.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\fileops\fop_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\fileops\fop_util.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_conv.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_dup.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_func.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_meta.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_open.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_page.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_reclaim.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_upgrade.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hash\hash_verify.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hmac\hmac.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hsearch\hsearch.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_deadlock.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_failchk.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_id.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_list.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_region.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_timer.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\lock\lock_util.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log_archive.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log_compare.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log_debug.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log_get.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log_put.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\log\log_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\mkpath.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_alloc.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_bh.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_fget.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_fmethod.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_fopen.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_fput.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_fset.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_mvcc.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_region.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_register.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_resize.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_sync.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mp\mp_trickle.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\crypto\mersenne\mt19937db.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mutex\mut_alloc.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mutex\mut_failchk.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mutex\mut_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mutex\mut_region.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mutex\mut_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\mutex\mut_win32.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\openflags.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_abort.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_abs.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_addrinfo.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_alloc.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_clock.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_config.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_cpu.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_ctime.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_dir.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_errno.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_fid.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_flock.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_fsync.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_getenv.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_handle.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_map.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\os_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_mkdir.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_open.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_pid.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_rename.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_root.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_rpath.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_rw.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_seek.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_stack.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_tmpdir.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_truncate.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os\os_uid.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_unlink.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\os_windows\os_yield.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_conv.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_files.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_open.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_upgrade.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\qam\qam_verify.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_backup.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_elect.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_lease.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_log.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_record.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_region.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_util.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\rep\rep_verify.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_elect.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_msg.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_net.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_queue.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_sel.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_util.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\repmgr\repmgr_windows.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-alg-fst.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-api-fst.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\sequence\seq_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\sequence\sequence.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\hmac\sha1.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\clib\strsep.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_auto.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_chkpt.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_failchk.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_method.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_rec.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_recover.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_region.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_stat.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\txn\txn_util.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\util_cache.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\util_log.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\util_sig.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\xa\xa.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\xa\xa_db.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\xa\xa_map.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bsddbDir)\common\zerofill.c">
- <Filter>Berkeley DB 4.7.25 Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{82655853-5a03-4804-a421-44510138071e}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{c52be92f-9033-4a0f-bf55-1b65c7e7b015}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Berkeley DB 4.7.25 Source Files">\r
+ <UniqueIdentifier>{49074366-917a-4969-88c7-0f6ec09c7021}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\bsddb.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_bsddb.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\crypto\aes_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_compact.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_compare.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_conv.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_curadj.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_cursor.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_delete.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_open.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_put.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_reclaim.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_recno.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_rsearch.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_search.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_split.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_upgrade.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\bt_verify.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\btree\btree_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\crdel_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\crdel_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\crypto\crypto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_am.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\db_byteorder.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_cam.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_cds.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_conv.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_dispatch.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_dup.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\db_err.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\db_getlong.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\db_idspace.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_iface.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_join.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\db_log2.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_meta.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_open.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_overflow.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_ovfl_vrfy.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_pr.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_reclaim.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_remove.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_rename.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_ret.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_setid.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_setlsn.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\db_shash.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_stati.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_truncate.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_upg.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_upg_opd.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_vrfy.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\db\db_vrfyutil.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\dbm\dbm.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\dbreg\dbreg_util.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\dbt.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_alloc.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_config.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_failchk.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_file.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_globals.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_name.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_open.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_recover.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_region.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_register.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_sig.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\env\env_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\fileops\fileops_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\fileops\fop_basic.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\fileops\fop_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\fileops\fop_util.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_conv.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_dup.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_func.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_meta.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_open.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_page.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_reclaim.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_upgrade.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hash\hash_verify.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hmac\hmac.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hsearch\hsearch.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_deadlock.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_failchk.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_id.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_list.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_region.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_timer.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\lock\lock_util.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log_archive.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log_compare.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log_debug.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log_get.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log_put.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\log\log_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\mkpath.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_alloc.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_bh.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fget.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fmethod.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fopen.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fput.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_fset.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_mvcc.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_region.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_register.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_resize.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_sync.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mp\mp_trickle.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\crypto\mersenne\mt19937db.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_alloc.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_failchk.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_region.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\mutex\mut_win32.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\openflags.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_abort.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_abs.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_addrinfo.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_alloc.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_clock.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_config.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_cpu.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_ctime.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_dir.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_errno.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_fid.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_flock.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_fsync.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_getenv.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_handle.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_map.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\os_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_mkdir.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_open.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_pid.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_rename.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_root.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_rpath.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_rw.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_seek.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_stack.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_tmpdir.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_truncate.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os\os_uid.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_unlink.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\os_windows\os_yield.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_conv.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_files.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_open.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_upgrade.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\qam\qam_verify.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_backup.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_elect.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_lease.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_log.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_record.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_region.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_util.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\rep\rep_verify.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_elect.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_msg.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_net.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_queue.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_sel.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_util.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\repmgr\repmgr_windows.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-alg-fst.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\crypto\rijndael\rijndael-api-fst.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\sequence\seq_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\sequence\sequence.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\hmac\sha1.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\clib\strsep.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_auto.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_chkpt.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_failchk.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_method.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_rec.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_recover.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_region.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_stat.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\txn\txn_util.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\util_cache.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\util_log.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\util_sig.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\xa\xa.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\xa\xa_db.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\xa\xa_map.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bsddbDir)\common\zerofill.c">\r
+ <Filter>Berkeley DB 4.7.25 Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{0E9791DB-593A-465F-98BC-681011311618}</ProjectGuid>
- <RootNamespace>_ctypes</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>..\Modules\_ctypes\libffi_msvc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- </ClCompile>
- <Link>
- <BaseAddress>0x1D1A0000</BaseAddress>
- <AdditionalOptions>/EXPORT:DllGetClassObject,PRIVATE /EXPORT:DllCanUnloadNow,PRIVATE %(AdditionalOptions)</AdditionalOptions>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_ctypes\ctypes.h" />
- <ClInclude Include="..\Modules\_ctypes\ctypes_dlfcn.h" />
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi.h" />
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi_common.h" />
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\fficonfig.h" />
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffitarget.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_ctypes\_ctypes.c" />
- <ClCompile Include="..\Modules\_ctypes\callbacks.c" />
- <ClCompile Include="..\Modules\_ctypes\callproc.c" />
- <ClCompile Include="..\Modules\_ctypes\cfield.c" />
- <ClCompile Include="..\Modules\_ctypes\libffi_msvc\ffi.c" />
- <ClCompile Include="..\Modules\_ctypes\malloc_closure.c" />
- <ClCompile Include="..\Modules\_ctypes\libffi_msvc\prep_cif.c" />
- <ClCompile Include="..\Modules\_ctypes\stgdict.c" />
- <ClCompile Include="..\Modules\_ctypes\libffi_msvc\win32.c">
- <ExcludedFromBuild Condition="'$(Platform)'=='x64'">true</ExcludedFromBuild>
- </ClCompile>
- </ItemGroup>
- <ItemGroup>
- <CustomBuild Include="..\Modules\_ctypes\libffi_msvc\win64.asm">
- <ExcludedFromBuild Condition="'$(Platform)'=='Win32'">true</ExcludedFromBuild>
- <Command>ml64 /nologo /c /Zi /Fo "$(IntDir)win64.obj" "%(FullPath)"</Command>
- <Outputs>$(IntDir)win64.obj;%(Outputs)</Outputs>
- </CustomBuild>
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{0E9791DB-593A-465F-98BC-681011311618}</ProjectGuid>\r
+ <RootNamespace>_ctypes</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>..\Modules\_ctypes\libffi_msvc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ <Link>\r
+ <BaseAddress>0x1D1A0000</BaseAddress>\r
+ <AdditionalOptions>/EXPORT:DllGetClassObject,PRIVATE /EXPORT:DllCanUnloadNow,PRIVATE %(AdditionalOptions)</AdditionalOptions>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_ctypes\ctypes.h" />\r
+ <ClInclude Include="..\Modules\_ctypes\ctypes_dlfcn.h" />\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi.h" />\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi_common.h" />\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\fficonfig.h" />\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffitarget.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_ctypes\_ctypes.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\callbacks.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\callproc.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\cfield.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\libffi_msvc\ffi.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\malloc_closure.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\libffi_msvc\prep_cif.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\stgdict.c" />\r
+ <ClCompile Include="..\Modules\_ctypes\libffi_msvc\win32.c">\r
+ <ExcludedFromBuild Condition="'$(Platform)'=='x64'">true</ExcludedFromBuild>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <CustomBuild Include="..\Modules\_ctypes\libffi_msvc\win64.asm">\r
+ <ExcludedFromBuild Condition="'$(Platform)'=='Win32'">true</ExcludedFromBuild>\r
+ <Command>ml64 /nologo /c /Zi /Fo "$(IntDir)win64.obj" "%(FullPath)"</Command>\r
+ <Outputs>$(IntDir)win64.obj;%(Outputs)</Outputs>\r
+ </CustomBuild>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{806081ee-2af0-48d0-a83e-ee02a74baa0f}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{dbdea1f2-ad8b-44ca-b782-fcf65d91559b}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_ctypes\ctypes.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_ctypes\ctypes_dlfcn.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi_common.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\fficonfig.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffitarget.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_ctypes\_ctypes.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\callbacks.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\callproc.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\cfield.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\libffi_msvc\ffi.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\malloc_closure.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\libffi_msvc\prep_cif.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\stgdict.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_ctypes\libffi_msvc\win32.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
- <ItemGroup>
- <CustomBuild Include="..\Modules\_ctypes\libffi_msvc\win64.asm">
- <Filter>Source Files</Filter>
- </CustomBuild>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{806081ee-2af0-48d0-a83e-ee02a74baa0f}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{dbdea1f2-ad8b-44ca-b782-fcf65d91559b}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_ctypes\ctypes.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_ctypes\ctypes_dlfcn.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffi_common.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\fficonfig.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_ctypes\libffi_msvc\ffitarget.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_ctypes\_ctypes.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\callbacks.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\callproc.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\cfield.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\libffi_msvc\ffi.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\malloc_closure.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\libffi_msvc\prep_cif.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\stgdict.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_ctypes\libffi_msvc\win32.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <CustomBuild Include="..\Modules\_ctypes\libffi_msvc\win64.asm">\r
+ <Filter>Source Files</Filter>\r
+ </CustomBuild>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{9EC7190A-249F-4180-A900-548FDCF3055F}</ProjectGuid>
- <RootNamespace>_ctypes_test</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- <SupportPGO>false</SupportPGO>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_ctypes\_ctypes_test.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_ctypes\_ctypes_test.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{9EC7190A-249F-4180-A900-548FDCF3055F}</ProjectGuid>\r
+ <RootNamespace>_ctypes_test</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ <SupportPGO>false</SupportPGO>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_ctypes\_ctypes_test.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_ctypes\_ctypes_test.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{8fd70119-5481-4e5d-b187-d0b14eb27e38}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{38abc486-e143-49dc-8cf0-8aefab0e0d3d}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_ctypes\_ctypes_test.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_ctypes\_ctypes_test.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{8fd70119-5481-4e5d-b187-d0b14eb27e38}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{38abc486-e143-49dc-8cf0-8aefab0e0d3d}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_ctypes\_ctypes_test.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_ctypes\_ctypes_test.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{17E1E049-C309-4D79-843F-AE483C264AEA}</ProjectGuid>
- <RootNamespace>_elementtree</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>..\Modules\expat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;USE_PYEXPAT_CAPI;XML_STATIC;HAVE_MEMMOVE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <BaseAddress>0x1D100000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\expat\ascii.h" />
- <ClInclude Include="..\Modules\expat\asciitab.h" />
- <ClInclude Include="..\Modules\expat\expat.h" />
- <ClInclude Include="..\Modules\expat\expat_config.h" />
- <ClInclude Include="..\Modules\expat\expat_external.h" />
- <ClInclude Include="..\Modules\expat\iasciitab.h" />
- <ClInclude Include="..\Modules\expat\internal.h" />
- <ClInclude Include="..\Modules\expat\latin1tab.h" />
- <ClInclude Include="..\Modules\expat\macconfig.h" />
- <ClInclude Include="..\Modules\expat\nametab.h" />
- <ClInclude Include="..\Modules\expat\pyexpatns.h" />
- <ClInclude Include="..\Modules\expat\utf8tab.h" />
- <ClInclude Include="..\Modules\expat\winconfig.h" />
- <ClInclude Include="..\Modules\expat\xmlrole.h" />
- <ClInclude Include="..\Modules\expat\xmltok.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_elementtree.c" />
- <ClCompile Include="..\Modules\expat\xmlparse.c" />
- <ClCompile Include="..\Modules\expat\xmlrole.c" />
- <ClCompile Include="..\Modules\expat\xmltok.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{17E1E049-C309-4D79-843F-AE483C264AEA}</ProjectGuid>\r
+ <RootNamespace>_elementtree</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>..\Modules\expat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;USE_PYEXPAT_CAPI;XML_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <Link>\r
+ <BaseAddress>0x1D100000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\expat\ascii.h" />\r
+ <ClInclude Include="..\Modules\expat\asciitab.h" />\r
+ <ClInclude Include="..\Modules\expat\expat.h" />\r
+ <ClInclude Include="..\Modules\expat\expat_config.h" />\r
+ <ClInclude Include="..\Modules\expat\expat_external.h" />\r
+ <ClInclude Include="..\Modules\expat\iasciitab.h" />\r
+ <ClInclude Include="..\Modules\expat\internal.h" />\r
+ <ClInclude Include="..\Modules\expat\latin1tab.h" />\r
+ <ClInclude Include="..\Modules\expat\macconfig.h" />\r
+ <ClInclude Include="..\Modules\expat\nametab.h" />\r
+ <ClInclude Include="..\Modules\expat\pyexpatns.h" />\r
+ <ClInclude Include="..\Modules\expat\utf8tab.h" />\r
+ <ClInclude Include="..\Modules\expat\winconfig.h" />\r
+ <ClInclude Include="..\Modules\expat\xmlrole.h" />\r
+ <ClInclude Include="..\Modules\expat\xmltok.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_elementtree.c" />\r
+ <ClCompile Include="..\Modules\expat\loadlibrary.c" />\r
+ <ClCompile Include="..\Modules\expat\xmlparse.c" />\r
+ <ClCompile Include="..\Modules\expat\xmlrole.c" />\r
+ <ClCompile Include="..\Modules\expat\xmltok.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{643d8607-d024-40fe-8583-1823c96430f0}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{7b5335ad-059f-486f-85e4-f4757e26a9bf}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\expat\ascii.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\asciitab.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\expat.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\expat_config.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\expat_external.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\iasciitab.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\internal.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\latin1tab.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\macconfig.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\nametab.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\pyexpatns.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\utf8tab.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\winconfig.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\xmlrole.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\xmltok.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_elementtree.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\expat\xmlparse.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\expat\xmlrole.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\expat\xmltok.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{643d8607-d024-40fe-8583-1823c96430f0}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{7b5335ad-059f-486f-85e4-f4757e26a9bf}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\expat\ascii.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\asciitab.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\expat.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\expat_config.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\expat_external.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\iasciitab.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\internal.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\latin1tab.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\loadlibrary.c">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\macconfig.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\nametab.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\pyexpatns.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\utf8tab.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\winconfig.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\xmlrole.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\xmltok.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_elementtree.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\expat\xmlparse.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\expat\xmlrole.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\expat\xmltok.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{447F05A8-F581-4CAC-A466-5AC7936E207E}</ProjectGuid>
- <RootNamespace>_hashlib</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(opensslIncludeDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- </ClCompile>
- <Link>
- <AdditionalDependencies>ws2_32.lib;$(OutDir)libeay$(PyDebugExt).lib;$(OutDir)ssleay$(PyDebugExt).lib;%(AdditionalDependencies)</AdditionalDependencies>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_hashopenssl.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="ssleay.vcxproj">
- <Project>{10615b24-73bf-4efa-93aa-236916321317}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="libeay.vcxproj">
- <Project>{e5b04cc0-eb4c-42ab-b4dc-18ef95f864b0}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{447F05A8-F581-4CAC-A466-5AC7936E207E}</ProjectGuid>\r
+ <RootNamespace>_hashlib</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(opensslIncludeDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ <Link>\r
+ <AdditionalDependencies>ws2_32.lib;$(OutDir)libeay$(PyDebugExt).lib;$(OutDir)ssleay$(PyDebugExt).lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_hashopenssl.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="ssleay.vcxproj">\r
+ <Project>{10615b24-73bf-4efa-93aa-236916321317}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="libeay.vcxproj">\r
+ <Project>{e5b04cc0-eb4c-42ab-b4dc-18ef95f864b0}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{cc45963d-bd25-4eb8-bdba-a5507090bca4}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_hashopenssl.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{cc45963d-bd25-4eb8-bdba-a5507090bca4}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_hashopenssl.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{31FFC478-7B4A-43E8-9954-8D03E2187E9C}</ProjectGuid>
- <RootNamespace>_msi</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <AdditionalDependencies>cabinet.lib;msi.lib;rpcrt4.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <BaseAddress>0x1D160000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\_msi.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{31FFC478-7B4A-43E8-9954-8D03E2187E9C}</ProjectGuid>\r
+ <RootNamespace>_msi</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <AdditionalDependencies>cabinet.lib;msi.lib;rpcrt4.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ <BaseAddress>0x1D160000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\_msi.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{bdef7710-e433-4ac0-84e0-14f34454bd3e}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\_msi.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{bdef7710-e433-4ac0-84e0-14f34454bd3e}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\_msi.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{9E48B300-37D1-11DD-8C41-005056C00008}</ProjectGuid>
- <RootNamespace>_multiprocessing</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <BaseAddress>0x1e1D0000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_multiprocessing\multiprocessing.h" />
- <ClInclude Include="..\Modules\_multiprocessing\connection.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_multiprocessing\multiprocessing.c" />
- <ClCompile Include="..\Modules\_multiprocessing\pipe_connection.c" />
- <ClCompile Include="..\Modules\_multiprocessing\semaphore.c" />
- <ClCompile Include="..\Modules\_multiprocessing\socket_connection.c" />
- <ClCompile Include="..\Modules\_multiprocessing\win32_functions.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{9E48B300-37D1-11DD-8C41-005056C00008}</ProjectGuid>\r
+ <RootNamespace>_multiprocessing</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ <BaseAddress>0x1e1D0000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_multiprocessing\multiprocessing.h" />\r
+ <ClInclude Include="..\Modules\_multiprocessing\connection.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_multiprocessing\multiprocessing.c" />\r
+ <ClCompile Include="..\Modules\_multiprocessing\pipe_connection.c" />\r
+ <ClCompile Include="..\Modules\_multiprocessing\semaphore.c" />\r
+ <ClCompile Include="..\Modules\_multiprocessing\socket_connection.c" />\r
+ <ClCompile Include="..\Modules\_multiprocessing\win32_functions.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{623c956c-1893-43d9-a7dc-96e4fef20f93}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{34615a62-f999-4659-83f5-19d17a644530}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_multiprocessing\multiprocessing.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_multiprocessing\connection.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_multiprocessing\multiprocessing.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_multiprocessing\pipe_connection.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_multiprocessing\semaphore.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_multiprocessing\socket_connection.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_multiprocessing\win32_functions.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{623c956c-1893-43d9-a7dc-96e4fef20f93}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{34615a62-f999-4659-83f5-19d17a644530}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_multiprocessing\multiprocessing.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_multiprocessing\connection.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_multiprocessing\multiprocessing.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_multiprocessing\pipe_connection.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_multiprocessing\semaphore.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_multiprocessing\socket_connection.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_multiprocessing\win32_functions.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{86937F53-C189-40EF-8CE8-8759D8E7D480}</ProjectGuid>
- <RootNamespace>_socket</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <BaseAddress>0x1e1D0000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\socketmodule.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\socketmodule.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{86937F53-C189-40EF-8CE8-8759D8E7D480}</ProjectGuid>\r
+ <RootNamespace>_socket</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ <BaseAddress>0x1e1D0000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\socketmodule.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\socketmodule.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{1452207f-707c-4e84-b532-307193a0fd85}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{1edfe0d0-7b9d-4dc8-a335-b21fef7cc77a}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\socketmodule.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\socketmodule.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{1452207f-707c-4e84-b532-307193a0fd85}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{1edfe0d0-7b9d-4dc8-a335-b21fef7cc77a}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\socketmodule.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\socketmodule.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{13CECB97-4119-4316-9D42-8534019A5A44}</ProjectGuid>
- <RootNamespace>_sqlite3</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(sqlite3Dir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>MODULE_NAME="sqlite3";%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <BaseAddress>0x1e180000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_sqlite\cache.h" />
- <ClInclude Include="..\Modules\_sqlite\connection.h" />
- <ClInclude Include="..\Modules\_sqlite\cursor.h" />
- <ClInclude Include="..\Modules\_sqlite\microprotocols.h" />
- <ClInclude Include="..\Modules\_sqlite\module.h" />
- <ClInclude Include="..\Modules\_sqlite\prepare_protocol.h" />
- <ClInclude Include="..\Modules\_sqlite\row.h" />
- <ClInclude Include="..\Modules\_sqlite\sqlitecompat.h" />
- <ClInclude Include="..\Modules\_sqlite\statement.h" />
- <ClInclude Include="..\Modules\_sqlite\util.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_sqlite\cache.c" />
- <ClCompile Include="..\Modules\_sqlite\connection.c" />
- <ClCompile Include="..\Modules\_sqlite\cursor.c" />
- <ClCompile Include="..\Modules\_sqlite\microprotocols.c" />
- <ClCompile Include="..\Modules\_sqlite\module.c" />
- <ClCompile Include="..\Modules\_sqlite\prepare_protocol.c" />
- <ClCompile Include="..\Modules\_sqlite\row.c" />
- <ClCompile Include="..\Modules\_sqlite\statement.c" />
- <ClCompile Include="..\Modules\_sqlite\util.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="sqlite3.vcxproj">
- <Project>{a1a295e5-463c-437f-81ca-1f32367685da}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{13CECB97-4119-4316-9D42-8534019A5A44}</ProjectGuid>\r
+ <RootNamespace>_sqlite3</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(sqlite3Dir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>MODULE_NAME="sqlite3";%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <Link>\r
+ <BaseAddress>0x1e180000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_sqlite\cache.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\connection.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\cursor.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\microprotocols.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\module.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\prepare_protocol.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\row.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\sqlitecompat.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\statement.h" />\r
+ <ClInclude Include="..\Modules\_sqlite\util.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_sqlite\cache.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\connection.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\cursor.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\microprotocols.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\module.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\prepare_protocol.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\row.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\statement.c" />\r
+ <ClCompile Include="..\Modules\_sqlite\util.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="sqlite3.vcxproj">\r
+ <Project>{a1a295e5-463c-437f-81ca-1f32367685da}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{dac8ab3b-ce16-4bef-bef9-76463a01f5c4}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{814b187d-44ad-4f2b-baa7-18ca8a8a6a77}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\_sqlite\cache.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\connection.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\cursor.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\microprotocols.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\module.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\prepare_protocol.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\row.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\sqlitecompat.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\statement.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_sqlite\util.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_sqlite\cache.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\connection.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\cursor.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\microprotocols.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\module.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\prepare_protocol.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\row.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\statement.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sqlite\util.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{dac8ab3b-ce16-4bef-bef9-76463a01f5c4}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{814b187d-44ad-4f2b-baa7-18ca8a8a6a77}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\_sqlite\cache.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\connection.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\cursor.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\microprotocols.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\module.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\prepare_protocol.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\row.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\sqlitecompat.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\statement.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_sqlite\util.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_sqlite\cache.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\connection.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\cursor.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\microprotocols.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\module.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\prepare_protocol.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\row.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\statement.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sqlite\util.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{C6E20F84-3247-4AD6-B051-B073268F73BA}</ProjectGuid>
- <RootNamespace>_ssl</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(opensslIncludeDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- </ClCompile>
- <Link>
- <AdditionalDependencies>ws2_32.lib;crypt32.lib;$(OutDir)libeay$(PyDebugExt).lib;$(OutDir)ssleay$(PyDebugExt).lib;%(AdditionalDependencies)</AdditionalDependencies>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_ssl.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="libeay.vcxproj">
- <Project>{e5b04cc0-eb4c-42ab-b4dc-18ef95f864b0}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="ssleay.vcxproj">
- <Project>{10615b24-73bf-4efa-93aa-236916321317}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="_socket.vcxproj">
- <Project>{86937f53-c189-40ef-8ce8-8759d8e7d480}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{C6E20F84-3247-4AD6-B051-B073268F73BA}</ProjectGuid>\r
+ <RootNamespace>_ssl</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(opensslIncludeDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ <Link>\r
+ <AdditionalDependencies>ws2_32.lib;crypt32.lib;$(OutDir)libeay$(PyDebugExt).lib;$(OutDir)ssleay$(PyDebugExt).lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_ssl.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="libeay.vcxproj">\r
+ <Project>{e5b04cc0-eb4c-42ab-b4dc-18ef95f864b0}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="ssleay.vcxproj">\r
+ <Project>{10615b24-73bf-4efa-93aa-236916321317}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="_socket.vcxproj">\r
+ <Project>{86937f53-c189-40ef-8ce8-8759d8e7d480}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{695348f7-e9f6-4fe1-bc03-5f08ffc8095b}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_ssl.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{695348f7-e9f6-4fe1-bc03-5f08ffc8095b}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_ssl.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{6901D91C-6E48-4BB7-9FEC-700C8131DF1D}</ProjectGuid>
- <RootNamespace>_testcapi</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- <SupportPGO>false</SupportPGO>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <BaseAddress>0x1e1F0000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_testcapimodule.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{6901D91C-6E48-4BB7-9FEC-700C8131DF1D}</ProjectGuid>\r
+ <RootNamespace>_testcapi</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ <SupportPGO>false</SupportPGO>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <BaseAddress>0x1e1F0000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_testcapimodule.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{a76a90d8-8e8b-4c36-8f58-8bd46abe9f5e}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_testcapimodule.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{a76a90d8-8e8b-4c36-8f58-8bd46abe9f5e}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_testcapimodule.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{4946ECAC-2E69-4BF8-A90A-F5136F5094DF}</ProjectGuid>
- <RootNamespace>_tkinter</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="tcltk.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(tcltkDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>WITH_APPINIT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <AdditionalDependencies>$(tcltkLib);%(AdditionalDependencies)</AdditionalDependencies>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_tkinter.c" />
- <ClCompile Include="..\Modules\tkappinit.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="tcl.vcxproj">
- <Project>{b5fd6f1d-129e-4bff-9340-03606fac7283}</Project>
- </ProjectReference>
- <ProjectReference Include="tk.vcxproj">
- <Project>{7e85eccf-a72c-4da4-9e52-884508e80ba1}</Project>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{4946ECAC-2E69-4BF8-A90A-F5136F5094DF}</ProjectGuid>\r
+ <RootNamespace>_tkinter</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="tcltk.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(tcltkDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>WITH_APPINIT;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <Link>\r
+ <AdditionalDependencies>$(tcltkLib);%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_tkinter.c" />\r
+ <ClCompile Include="..\Modules\tkappinit.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="tcl.vcxproj">\r
+ <Project>{b5fd6f1d-129e-4bff-9340-03606fac7283}</Project>\r
+ </ProjectReference>\r
+ <ProjectReference Include="tk.vcxproj">\r
+ <Project>{7e85eccf-a72c-4da4-9e52-884508e80ba1}</Project>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{b9ce64dd-cb95-472d-bbe8-5583b2cd375b}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_tkinter.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\tkappinit.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{b9ce64dd-cb95-472d-bbe8-5583b2cd375b}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_tkinter.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\tkappinit.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
)\r
)\r
\r
+if not exist "%GIT%" where git > "%TEMP%\git.loc" 2> nul && set /P GIT= < "%TEMP%\git.loc" & del "%TEMP%\git.loc"\r
+if exist "%GIT%" set GITProperty=/p:GIT="%GIT%"\r
+if not exist "%GIT%" echo Cannot find Git on PATH & set GITProperty=\r
+\r
rem Setup the environment\r
call "%dir%env.bat" %vs_platf% >nul\r
\r
/p:Configuration=%conf% /p:Platform=%platf%^\r
/p:IncludeExternals=%IncludeExternals%^\r
/p:IncludeSSL=%IncludeSSL% /p:IncludeTkinter=%IncludeTkinter%^\r
- /p:IncludeBsddb=%IncludeBsddb%^\r
+ /p:IncludeBsddb=%IncludeBsddb% %GITProperty%^\r
%1 %2 %3 %4 %5 %6 %7 %8 %9\r
\r
@echo off\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{73FCD2BD-F133-46B7-8EC1-144CD82A59D5}</ProjectGuid>
- <RootNamespace>bz2</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- <ProjectName>bz2</ProjectName>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <PropertyGroup Label="Configuration" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(bz2Dir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>WIN32;_FILE_OFFSET_BITS=64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <BaseAddress>0x1D170000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\bz2module.c" />
- <ClCompile Include="$(bz2Dir)\blocksort.c" />
- <ClCompile Include="$(bz2Dir)\bzlib.c" />
- <ClCompile Include="$(bz2Dir)\compress.c" />
- <ClCompile Include="$(bz2Dir)\crctable.c" />
- <ClCompile Include="$(bz2Dir)\decompress.c" />
- <ClCompile Include="$(bz2Dir)\huffman.c" />
- <ClCompile Include="$(bz2Dir)\randtable.c" />
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="$(bz2Dir)\bzlib.h" />
- <ClInclude Include="$(bz2Dir)\bzlib_private.h" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{73FCD2BD-F133-46B7-8EC1-144CD82A59D5}</ProjectGuid>\r
+ <RootNamespace>bz2</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ <ProjectName>bz2</ProjectName>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <PropertyGroup Label="Configuration" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(bz2Dir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>WIN32;_FILE_OFFSET_BITS=64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <Link>\r
+ <BaseAddress>0x1D170000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\bz2module.c" />\r
+ <ClCompile Include="$(bz2Dir)\blocksort.c" />\r
+ <ClCompile Include="$(bz2Dir)\bzlib.c" />\r
+ <ClCompile Include="$(bz2Dir)\compress.c" />\r
+ <ClCompile Include="$(bz2Dir)\crctable.c" />\r
+ <ClCompile Include="$(bz2Dir)\decompress.c" />\r
+ <ClCompile Include="$(bz2Dir)\huffman.c" />\r
+ <ClCompile Include="$(bz2Dir)\randtable.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="$(bz2Dir)\bzlib.h" />\r
+ <ClInclude Include="$(bz2Dir)\bzlib_private.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{f53a859d-dad2-4d5b-ae41-f28d8b571f5a}</UniqueIdentifier>
- </Filter>
- <Filter Include="bzip2 1.0.6 Header Files">
- <UniqueIdentifier>{7e0bed05-ae33-43b7-8797-656455bbb7f3}</UniqueIdentifier>
- </Filter>
- <Filter Include="bzip2 1.0.6 Source Files">
- <UniqueIdentifier>{ed574b89-6983-4cdf-9f98-fe7048d9e89c}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\bz2module.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bz2Dir)\blocksort.c">
- <Filter>bzip2 1.0.6 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bz2Dir)\bzlib.c">
- <Filter>bzip2 1.0.6 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bz2Dir)\compress.c">
- <Filter>bzip2 1.0.6 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bz2Dir)\crctable.c">
- <Filter>bzip2 1.0.6 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bz2Dir)\decompress.c">
- <Filter>bzip2 1.0.6 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bz2Dir)\huffman.c">
- <Filter>bzip2 1.0.6 Source Files</Filter>
- </ClCompile>
- <ClCompile Include="$(bz2Dir)\randtable.c">
- <Filter>bzip2 1.0.6 Source Files</Filter>
- </ClCompile>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="$(bz2Dir)\bzlib.h">
- <Filter>bzip2 1.0.6 Header Files</Filter>
- </ClInclude>
- <ClInclude Include="$(bz2Dir)\bzlib_private.h">
- <Filter>bzip2 1.0.6 Header Files</Filter>
- </ClInclude>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{f53a859d-dad2-4d5b-ae41-f28d8b571f5a}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="bzip2 1.0.6 Header Files">\r
+ <UniqueIdentifier>{7e0bed05-ae33-43b7-8797-656455bbb7f3}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="bzip2 1.0.6 Source Files">\r
+ <UniqueIdentifier>{ed574b89-6983-4cdf-9f98-fe7048d9e89c}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\bz2module.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bz2Dir)\blocksort.c">\r
+ <Filter>bzip2 1.0.6 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bz2Dir)\bzlib.c">\r
+ <Filter>bzip2 1.0.6 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bz2Dir)\compress.c">\r
+ <Filter>bzip2 1.0.6 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bz2Dir)\crctable.c">\r
+ <Filter>bzip2 1.0.6 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bz2Dir)\decompress.c">\r
+ <Filter>bzip2 1.0.6 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bz2Dir)\huffman.c">\r
+ <Filter>bzip2 1.0.6 Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="$(bz2Dir)\randtable.c">\r
+ <Filter>bzip2 1.0.6 Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="$(bz2Dir)\bzlib.h">\r
+ <Filter>bzip2 1.0.6 Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="$(bz2Dir)\bzlib_private.h">\r
+ <Filter>bzip2 1.0.6 Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+</Project>\r
set libraries=%libraries% bzip2-1.0.6\r
if NOT "%IncludeBsddb%"=="false" set libraries=%libraries% db-4.7.25.0\r
if NOT "%IncludeSSL%"=="false" set libraries=%libraries% nasm-2.11.06\r
-if NOT "%IncludeSSL%"=="false" set libraries=%libraries% openssl-1.0.2j\r
+if NOT "%IncludeSSL%"=="false" set libraries=%libraries% openssl-1.0.2k\r
set libraries=%libraries% sqlite-3.8.11.0\r
if NOT "%IncludeTkinter%"=="false" set libraries=%libraries% tcl-8.5.15.0\r
if NOT "%IncludeTkinter%"=="false" set libraries=%libraries% tk-8.5.15.0\r
echo.%%e already exists, skipping.\r
) else (\r
echo.Fetching %%e...\r
- svn export %SVNROOT%%%e\r
+ svn export -q %SVNROOT%%%e\r
)\r
)\r
\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{E5B04CC0-EB4C-42AB-B4DC-18EF95F864B0}</ProjectGuid>
- <RootNamespace>libeay</RootNamespace>
- </PropertyGroup>
-
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-
- <PropertyGroup Label="Configuration">
- <ConfigurationType>StaticLibrary</ConfigurationType>
- </PropertyGroup>
-
- <Import Project="openssl.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-
- <Target Name="CreateBuildinfH" Inputs="$(MSBuildProjectFullPath)" Outputs="$(IntDir)\buildinf.h" AfterTargets="PrepareForBuild">
- <PropertyGroup>
- <_DATEValue>#define DATE "$([System.DateTime]::Now.ToString(`ddd MMM dd HH':'mm':'ss yyyy`))"</_DATEValue>
- <_CFLAGSValue>#define CFLAGS "cl /MD /Ox -W3 -Gs0 -Gy -nologo @(PreprocessorDefinitions->'-D%(Identity)',' ')"</_CFLAGSValue>
- <_PLATFORMValue Condition="$(Platform)=='Win32'">#define PLATFORM "VC-WIN32"</_PLATFORMValue>
- <_PLATFORMValue Condition="$(Platform)=='x64'">#define PLATFORM "VC-WIN64A"</_PLATFORMValue>
- </PropertyGroup>
- <WriteLinesToFile File="$(IntDir)\buildinf.h"
- Lines="$(_DATEValue);$(_CFLAGSValue);$(_PLATFORMValue)"
- Overwrite="true" />
- <Message Text="Updating buildinf.h:
- $(_DATEValue)
- $(_CFLAGSValue)
- $(_PLATFORMValue)" Importance="normal" />
- </Target>
-
- <Target Name="SuppressOriginalBuildinfH" Condition="Exists('$(opensslDir)crypto\buildinf.h')" BeforeTargets="PrepareForBuild">
- <Move SourceFiles="$(opensslDir)crypto\buildinf.h" DestinationFiles="$(opensslDir)crypto\buildinf.h.orig" />
- </Target>
-
- <ItemGroup>
- <ClCompile Include="$(opensslDir)crypto\cversion.c">
- <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- </ClCompile>
- </ItemGroup>
-
- <ItemGroup>
- <!--
- <ClCompile Include="$(opensslDir)apps\errstr.c" />
- <ClCompile Include="$(opensslDir)crypto\aes\aes_cfb.c" />
- <ClCompile Include="$(opensslDir)crypto\aes\aes_ctr.c" />
- <ClCompile Include="$(opensslDir)crypto\aes\aes_ecb.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\aes\aes_ige.c" />
- <ClCompile Include="$(opensslDir)crypto\aes\aes_misc.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\aes\aes_ofb.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\aes\aes_wrap.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_bitstr.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_bool.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_bytes.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_d2i_fp.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_digest.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_dup.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_enum.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_gentm.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_i2d_fp.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_int.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_mbstr.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_object.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_octet.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_print.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_set.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_sign.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_strex.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_strnid.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_time.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_type.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_utctm.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_utf8.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\a_verify.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\ameth_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\asn_mime.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\asn_moid.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\asn_pack.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\asn1_err.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\asn1_gen.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\asn1_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\asn1_par.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\bio_asn1.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\bio_ndef.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\d2i_pr.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\asn1\d2i_pu.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\asn1\evp_asn1.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\asn1\f_enum.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\asn1\f_int.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\f_string.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\i2d_pr.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\asn1\i2d_pu.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\asn1\n_pkey.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\nsseq.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\p5_pbe.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\p5_pbev2.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\p8_pkey.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\asn1\t_bitst.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\t_crl.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\asn1\t_pkey.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\asn1\t_req.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\t_spki.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\asn1\t_x509.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\t_x509a.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\tasn_dec.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\tasn_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\tasn_fre.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\tasn_new.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\tasn_prn.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\tasn_typ.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\tasn_utl.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_algor.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_attrib.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_bignum.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_crl.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_exten.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_info.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_long.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_name.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_nx509.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_pkey.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_pubkey.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_req.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_sig.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_spki.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_val.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_x509.c" />
- <ClCompile Include="$(opensslDir)crypto\asn1\x_x509a.c" />
- <ClCompile Include="$(opensslDir)crypto\bf\bf_cfb64.c" />
- <ClCompile Include="$(opensslDir)crypto\bf\bf_ecb.c" />
- <ClCompile Include="$(opensslDir)crypto\bf\bf_ofb64.c" />
- <ClCompile Include="$(opensslDir)crypto\bf\bf_skey.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\b_dump.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\b_print.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\b_sock.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bf_buff.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bio\bf_nbio.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bf_null.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bio_cb.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\bio\bio_err.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bio_lib.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bio\bss_acpt.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bss_bio.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\bio\bss_conn.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bio\bss_dgram.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bss_fd.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\bio\bss_file.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bio\bss_log.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\bio\bss_mem.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bss_null.c" />
- <ClCompile Include="$(opensslDir)crypto\bio\bss_sock.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_add.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_blind.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bn\bn_const.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\bn\bn_ctx.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bn\bn_depr.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\bn\bn_div.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_err.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_exp.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_exp2.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_gcd.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_gf2m.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_kron.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_mod.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_mont.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bn\bn_mpi.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\bn\bn_mul.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_nist.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_prime.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_print.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_rand.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_recp.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_shift.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_sqr.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_sqrt.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_word.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\bn\bn_x931p.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\buffer\buf_err.c" />
- <ClCompile Include="$(opensslDir)crypto\buffer\buf_str.c" />
- <ClCompile Include="$(opensslDir)crypto\buffer\buffer.c" />
- <ClCompile Include="$(opensslDir)crypto\camellia\cmll_cfb.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\camellia\cmll_ctr.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\camellia\cmll_ecb.c" />
- <ClCompile Include="$(opensslDir)crypto\camellia\cmll_ofb.c" />
- <ClCompile Include="$(opensslDir)crypto\camellia\cmll_utl.c" />
- <ClCompile Include="$(opensslDir)crypto\cast\c_cfb64.c" />
- <ClCompile Include="$(opensslDir)crypto\cast\c_ecb.c" />
- <ClCompile Include="$(opensslDir)crypto\cast\c_ofb64.c" />
- <ClCompile Include="$(opensslDir)crypto\cast\c_skey.c" />
- <ClCompile Include="$(opensslDir)crypto\cmac\cm_ameth.c" />
- <ClCompile Include="$(opensslDir)crypto\cmac\cm_pmeth.c" />
- <ClCompile Include="$(opensslDir)crypto\cmac\cmac.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_asn1.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_att.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\cms\cms_cd.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\cms\cms_dd.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_env.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_err.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\cms\cms_ess.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\cms\cms_io.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_kari.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_pwri.c" />
- <ClCompile Include="$(opensslDir)crypto\cms\cms_sd.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\cms\cms_smime.c" />
- <ClCompile Include="$(opensslDir)crypto\comp\c_rle.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\comp\c_zlib.c" />
- <ClCompile Include="$(opensslDir)crypto\comp\comp_err.c" />
- <ClCompile Include="$(opensslDir)crypto\comp\comp_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\conf\conf_api.c" />
- <ClCompile Include="$(opensslDir)crypto\conf\conf_def.c" />
- <ClCompile Include="$(opensslDir)crypto\conf\conf_err.c" />
- <ClCompile Include="$(opensslDir)crypto\conf\conf_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\conf\conf_mall.c" />
- <ClCompile Include="$(opensslDir)crypto\conf\conf_mod.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\conf\conf_sap.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\cpt_err.c" />
- <ClCompile Include="$(opensslDir)crypto\cryptlib.c" />
- <ClCompile Include="$(opensslDir)crypto\des\cbc_cksm.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\des\cbc_enc.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\des\cfb_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\des\cfb64ede.c" />
- <ClCompile Include="$(opensslDir)crypto\des\cfb64enc.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\des\des_old.c" />
- <ClCompile Include="$(opensslDir)crypto\des\des_old2.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\des\ecb_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\des\ecb3_enc.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\des\ede_cbcm_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\des\enc_read.c" />
- <ClCompile Include="$(opensslDir)crypto\des\enc_writ.c" />
- <ClCompile Include="$(opensslDir)crypto\des\fcrypt.c" />
- <ClCompile Include="$(opensslDir)crypto\des\ofb_enc.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\des\ofb64ede.c" />
- <ClCompile Include="$(opensslDir)crypto\des\ofb64enc.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\des\pcbc_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\des\qud_cksm.c" />
- <ClCompile Include="$(opensslDir)crypto\des\rand_key.c" />
- <ClCompile Include="$(opensslDir)crypto\des\read2pwd.c" />
- <ClCompile Include="$(opensslDir)crypto\des\rpc_enc.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\des\set_key.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\des\str2key.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\des\xcbc_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_ameth.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_asn1.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_check.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\dh\dh_depr.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\dh\dh_err.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_gen.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_kdf.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_key.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\dh\dh_pmeth.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\dh\dh_prn.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\dh\dh_rfc5114.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_ameth.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_asn1.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_depr.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_err.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_gen.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_key.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_ossl.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_pmeth.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_prn.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_sign.c" />
- <ClCompile Include="$(opensslDir)crypto\dsa\dsa_vrf.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\dso\dso_beos.c" />
- <ClCompile Include="$(opensslDir)crypto\dso\dso_dl.c" />
- <ClCompile Include="$(opensslDir)crypto\dso\dso_dlfcn.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\dso\dso_err.c" />
- <ClCompile Include="$(opensslDir)crypto\dso\dso_lib.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\dso\dso_null.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\dso\dso_openssl.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\dso\dso_vms.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\dso\dso_win32.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ebcdic.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\ec\ec_ameth.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_asn1.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ec\ec_check.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\ec\ec_curve.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_cvt.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_err.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_key.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_mult.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_oct.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_pmeth.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec_print.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec2_mult.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec2_oct.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ec2_smpl.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\eck_prn.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_mont.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_nist.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistp224.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistp256.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistp521.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistputil.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_oct.c" />
- <ClCompile Include="$(opensslDir)crypto\ec\ecp_smpl.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdh\ech_err.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdh\ech_kdf.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdh\ech_key.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdh\ech_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdh\ech_ossl.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_asn1.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_err.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_ossl.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_sign.c" />
- <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_vrf.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_all.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_cnf.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\engine\eng_cryptodev.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\engine\eng_ctrl.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_dyn.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_err.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_fat.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_init.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_list.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\engine\eng_openssl.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\engine\eng_pkey.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\engine\eng_rdrand.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\eng_rsax.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\engine\eng_table.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_asnmth.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_cipher.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_dh.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_digest.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_dsa.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_ecdh.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_ecdsa.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_pkmeth.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_rand.c" />
- <ClCompile Include="$(opensslDir)crypto\engine\tb_rsa.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\engine\tb_store.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\err\err.c" />
- <ClCompile Include="$(opensslDir)crypto\err\err_all.c" />
- <ClCompile Include="$(opensslDir)crypto\err\err_prn.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\bio_b64.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\bio_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\bio_md.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\bio_ok.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\c_all.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\c_allc.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\c_alld.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\digest.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_aes.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_aes_cbc_hmac_sha1.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_aes_cbc_hmac_sha256.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_bf.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_camellia.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_cast.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_des.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_des3.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\e_idea.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\e_null.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\e_old.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\e_rc2.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_rc4.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_rc4_hmac_md5.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\e_rc5.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\e_seed.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\e_xcbc_d.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\encode.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\evp_acnf.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\evp_cnf.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\evp_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\evp_err.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\evp_fips.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\evp_key.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\evp_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\evp_pbe.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\evp_pkey.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_dss.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_dss1.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_ecdsa.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_md4.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_md5.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\m_null.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\m_ripemd.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_sha.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_sha1.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_sigver.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\m_wp.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\names.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\p_dec.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\p_lib.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\evp\p_open.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\p_seal.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\evp\p_sign.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\p_verify.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\p5_crpt.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\p5_crpt2.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\pmeth_fn.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\pmeth_gn.c" />
- <ClCompile Include="$(opensslDir)crypto\evp\pmeth_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\ex_data.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\fips_ers.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\hmac\hm_ameth.c" />
- <ClCompile Include="$(opensslDir)crypto\hmac\hm_pmeth.c" />
- <ClCompile Include="$(opensslDir)crypto\hmac\hmac.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\krb5\krb5_asn.c" />
- <ClCompile Include="$(opensslDir)crypto\lhash\lh_stats.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\lhash\lhash.c" />
- <ClCompile Include="$(opensslDir)crypto\md4\md4_dgst.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\md4\md4_one.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\md5\md5_dgst.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\md5\md5_one.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\mem.c" />
- <ClCompile Include="$(opensslDir)crypto\mem_dbg.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\cbc128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\ccm128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\cfb128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\ctr128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\cts128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\gcm128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\ofb128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\wrap128.c" />
- <ClCompile Include="$(opensslDir)crypto\modes\xts128.c" />
- <ClCompile Include="$(opensslDir)crypto\o_dir.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\o_fips.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\o_init.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\o_str.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\o_time.c" />
- <ClCompile Include="$(opensslDir)crypto\objects\o_names.c" />
- <ClCompile Include="$(opensslDir)crypto\objects\obj_dat.c" />
- <ClCompile Include="$(opensslDir)crypto\objects\obj_err.c" />
- <ClCompile Include="$(opensslDir)crypto\objects\obj_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\objects\obj_xref.c" />
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_asn.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_cl.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_err.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_ext.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_ht.c" />
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_lib.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_prn.c" />
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_srv.c" />
- <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_vfy.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\pem\pem_all.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_err.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_info.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_oth.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_pk8.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_pkey.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\pem\pem_seal.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_sign.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\pem\pem_x509.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pem_xaux.c" />
- <ClCompile Include="$(opensslDir)crypto\pem\pvkfmt.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_add.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_asn.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_attr.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_crpt.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_crt.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_decr.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_init.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_key.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_kiss.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_mutl.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_npas.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_p8d.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_p8e.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_utl.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs12\pk12err.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\pkcs7\bio_pk7.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_asn1.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_attr.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_doit.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_lib.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_mime.c" />
- <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_smime.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\pkcs7\pkcs7err.c" />
- <ClCompile Include="$(opensslDir)crypto\pqueue\pqueue.c" />
- <ClCompile Include="$(opensslDir)crypto\rand\md_rand.c" />
- <ClCompile Include="$(opensslDir)crypto\rand\rand_egd.c" />
- <ClCompile Include="$(opensslDir)crypto\rand\rand_err.c" />
- <ClCompile Include="$(opensslDir)crypto\rand\rand_lib.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\rand\rand_nw.c" />
- <ClCompile Include="$(opensslDir)crypto\rand\rand_os2.c" />
- <ClCompile Include="$(opensslDir)crypto\rand\rand_unix.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\rand\rand_win.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\rand\randfile.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\rc2\rc2_cbc.c" />
- <ClCompile Include="$(opensslDir)crypto\rc2\rc2_ecb.c" />
- <ClCompile Include="$(opensslDir)crypto\rc2\rc2_skey.c" />
- <ClCompile Include="$(opensslDir)crypto\rc2\rc2cfb64.c" />
- <ClCompile Include="$(opensslDir)crypto\rc2\rc2ofb64.c" />
- <ClCompile Include="$(opensslDir)crypto\rc4\rc4_utl.c" />
- <ClCompile Include="$(opensslDir)crypto\ripemd\rmd_dgst.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ripemd\rmd_one.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_ameth.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_asn1.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_chk.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_crpt.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_depr.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_eay.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_err.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_gen.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_none.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_null.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_oaep.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_pk1.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_pmeth.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_prn.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_pss.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_saos.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_sign.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_ssl.c" />
- <ClCompile Include="$(opensslDir)crypto\rsa\rsa_x931.c" />
- <ClCompile Include="$(opensslDir)crypto\seed\seed.c" />
- <ClCompile Include="$(opensslDir)crypto\seed\seed_cbc.c" />
- <ClCompile Include="$(opensslDir)crypto\seed\seed_cfb.c" />
- <ClCompile Include="$(opensslDir)crypto\seed\seed_ecb.c" />
- <ClCompile Include="$(opensslDir)crypto\seed\seed_ofb.c" />
- <ClCompile Include="$(opensslDir)crypto\sha\sha_dgst.c" />
- <ClCompile Include="$(opensslDir)crypto\sha\sha_one.c" />
- <ClCompile Include="$(opensslDir)crypto\sha\sha1_one.c" />
- <ClCompile Include="$(opensslDir)crypto\sha\sha1dgst.c" />
- <ClCompile Include="$(opensslDir)crypto\sha\sha256.c" />
- <ClCompile Include="$(opensslDir)crypto\sha\sha512.c" />
- <ClCompile Include="$(opensslDir)crypto\srp\srp_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\srp\srp_vfy.c" />
- <ClCompile Include="$(opensslDir)crypto\stack\stack.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ts\ts_asn1.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_conf.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\ts\ts_err.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ts\ts_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_req_print.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_req_utils.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_print.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_sign.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_utils.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_verify.c" />
- <ClCompile Include="$(opensslDir)crypto\ts\ts_verify_ctx.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\txt_db\txt_db.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\ui\ui_compat.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\ui\ui_err.c" />
- <ClCompile Include="$(opensslDir)crypto\ui\ui_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\ui\ui_openssl.c" />
- <ClCompile Include="$(opensslDir)crypto\ui\ui_util.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\uid.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\whrlpool\wp_dgst.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\by_dir.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\by_file.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x_all.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_att.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_cmp.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_d2.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_def.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_err.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_ext.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_lu.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_obj.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\x509\x509_r2x.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\x509\x509_req.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\x509\x509_set.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\x509\x509_trs.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_txt.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_v3.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_vfy.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509_vpm.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509cset.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509name.c" />
- <ClCompile Include="$(opensslDir)crypto\x509\x509rset.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\x509\x509spki.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\x509\x509type.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_cache.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_data.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_map.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_node.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_tree.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_addr.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_akey.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_akeya.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_alt.c" />
- <!--
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_asid.c" />
- -->
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_bcons.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_bitst.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_conf.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_cpols.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_crld.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_enum.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_extku.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_genn.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_ia5.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_info.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_int.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_lib.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_ncons.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_ocsp.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pci.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pcia.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pcons.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pku.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pmaps.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_prn.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_purp.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_scts.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_skey.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_sxnet.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3_utl.c" />
- <ClCompile Include="$(opensslDir)crypto\x509v3\v3err.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\e_gost_err.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_ameth.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_asn1.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_crypt.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_ctl.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_eng.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_keywrap.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_md.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_params.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_pmeth.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost_sign.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost2001.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost2001_keyx.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost89.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gost94_keyx.c" />
- <ClCompile Include="$(opensslDir)engines\ccgost\gosthash.c" />
- <ClCompile Include="$(opensslDir)engines\e_4758cca.c" />
- <ClCompile Include="$(opensslDir)engines\e_aep.c" />
- <ClCompile Include="$(opensslDir)engines\e_atalla.c" />
- <ClCompile Include="$(opensslDir)engines\e_capi.c" />
- <ClCompile Include="$(opensslDir)engines\e_chil.c" />
- <ClCompile Include="$(opensslDir)engines\e_cswift.c" />
- <ClCompile Include="$(opensslDir)engines\e_gmp.c" />
- <ClCompile Include="$(opensslDir)engines\e_nuron.c" />
- <ClCompile Include="$(opensslDir)engines\e_padlock.c" />
- <ClCompile Include="$(opensslDir)engines\e_sureware.c" />
- <ClCompile Include="$(opensslDir)engines\e_ubsec.c" />
- <ClCompile Include="$(opensslDir)ssl\d1_clnt.c" />
- <ClCompile Include="$(opensslDir)ssl\d1_meth.c" />
- <ClCompile Include="$(opensslDir)ssl\d1_lib.c" />
- <ClCompile Include="$(opensslDir)ssl\d1_srvr.c" />
- <ClCompile Include="$(opensslDir)ssl\s2_srvr.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_clnt.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_ext.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_srvr.c" />
- </ItemGroup>
- <ItemGroup Condition="$(Platform) == 'Win32'">
- <ClCompile Include="$(opensslDir)crypto\whrlpool\wp_block.c" />
- </ItemGroup>
- <ItemGroup Condition="$(Platform) == 'x64'">
- <ClCompile Include="$(opensslDir)crypto\bf\bf_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\bn\bn_asm.c" />
- <ClCompile Include="$(opensslDir)crypto\camellia\cmll_misc.c" />
- <ClCompile Include="$(opensslDir)crypto\cast\c_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\des\des_enc.c" />
- <ClCompile Include="$(opensslDir)crypto\des\fcrypt_b.c" />
- </ItemGroup>
-
- <ItemGroup Condition="$(Platform) == 'Win32'">
- <NasmCompile Include="$(opensslDir)tmp32\aes-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\aesni-x86.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\bf-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\bn-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\cast-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\cmll-x86.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\co-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\crypt586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\des-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\ghash-x86.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\md5-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\rc4-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\rmd-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\sha1-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\sha256-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\sha512-586.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\vpaes-x86.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\wp-mmx.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\x86cpuid.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\x86-gf2m.asm" />
- <NasmCompile Include="$(opensslDir)tmp32\x86-mont.asm" />
- </ItemGroup>
- <ItemGroup Condition="$(Platform) == 'x64'">
- <NasmCompile Include="$(opensslDir)tmp64\aesni-sha1-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\aesni-sha1-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\aesni-gcm-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\aesni-mb-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\aesni-sha256-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\aesni-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\aes-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\bsaes-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\cmll-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\ghash-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\md5-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\rc4-md5-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\rc4-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\sha1-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\sha1-mb-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\sha256-mb-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\sha256-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\sha512-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\vpaes-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\wp-x86_64.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\x86_64cpuid.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\x86_64-gf2m.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\x86_64-mont.asm" />
- <NasmCompile Include="$(opensslDir)tmp64\x86_64-mont5.asm" />
- </ItemGroup>
-
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <Target Name="Clean" />
- <Target Name="CleanAll">
- <Delete Files="$(TargetPath)" />
- <RemoveDir Directories="$(IntDir)" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{E5B04CC0-EB4C-42AB-B4DC-18EF95F864B0}</ProjectGuid>\r
+ <RootNamespace>libeay</RootNamespace>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>StaticLibrary</ConfigurationType>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="openssl.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+\r
+ <Target Name="CreateBuildinfH" Inputs="$(MSBuildProjectFullPath)" Outputs="$(IntDir)\buildinf.h" AfterTargets="PrepareForBuild">\r
+ <PropertyGroup>\r
+ <_DATEValue>#define DATE "$([System.DateTime]::Now.ToString(`ddd MMM dd HH':'mm':'ss yyyy`))"</_DATEValue>\r
+ <_CFLAGSValue>#define CFLAGS "cl /MD /Ox -W3 -Gs0 -Gy -nologo @(PreprocessorDefinitions->'-D%(Identity)',' ')"</_CFLAGSValue>\r
+ <_PLATFORMValue Condition="$(Platform)=='Win32'">#define PLATFORM "VC-WIN32"</_PLATFORMValue>\r
+ <_PLATFORMValue Condition="$(Platform)=='x64'">#define PLATFORM "VC-WIN64A"</_PLATFORMValue>\r
+ </PropertyGroup>\r
+ <WriteLinesToFile File="$(IntDir)\buildinf.h"\r
+ Lines="$(_DATEValue);$(_CFLAGSValue);$(_PLATFORMValue)"\r
+ Overwrite="true" />\r
+ <Message Text="Updating buildinf.h:\r
+ $(_DATEValue)\r
+ $(_CFLAGSValue)\r
+ $(_PLATFORMValue)" Importance="normal" />\r
+ </Target>\r
+\r
+ <Target Name="SuppressOriginalBuildinfH" Condition="Exists('$(opensslDir)crypto\buildinf.h')" BeforeTargets="PrepareForBuild">\r
+ <Move SourceFiles="$(opensslDir)crypto\buildinf.h" DestinationFiles="$(opensslDir)crypto\buildinf.h.orig" />\r
+ </Target>\r
+\r
+ <ItemGroup>\r
+ <ClCompile Include="$(opensslDir)crypto\cversion.c">\r
+ <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+\r
+ <ItemGroup>\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)apps\errstr.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\aes\aes_cfb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\aes\aes_ctr.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\aes\aes_ecb.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\aes\aes_ige.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\aes\aes_misc.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\aes\aes_ofb.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\aes\aes_wrap.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_bitstr.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_bool.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_bytes.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_d2i_fp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_digest.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_dup.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_enum.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_gentm.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_i2d_fp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_int.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_mbstr.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_object.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_octet.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_print.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_set.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_sign.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_strex.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_strnid.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_time.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_type.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_utctm.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_utf8.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\a_verify.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\ameth_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\asn_mime.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\asn_moid.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\asn_pack.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\asn1_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\asn1_gen.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\asn1_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\asn1_par.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\bio_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\bio_ndef.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\d2i_pr.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\d2i_pu.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\evp_asn1.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\f_enum.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\f_int.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\f_string.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\i2d_pr.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\i2d_pu.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\n_pkey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\nsseq.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\p5_pbe.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\p5_pbev2.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\p8_pkey.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\t_bitst.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\t_crl.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\t_pkey.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\t_req.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\t_spki.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\t_x509.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\t_x509a.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\tasn_dec.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\tasn_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\tasn_fre.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\tasn_new.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\tasn_prn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\tasn_typ.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\tasn_utl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_algor.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_attrib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_bignum.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_crl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_exten.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_info.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_long.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_name.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_nx509.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_pkey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_pubkey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_req.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_sig.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_spki.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_val.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_x509.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\asn1\x_x509a.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bf\bf_cfb64.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bf\bf_ecb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bf\bf_ofb64.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bf\bf_skey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\b_dump.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\b_print.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\b_sock.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bf_buff.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bf_nbio.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bf_null.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bio_cb.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bio_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bio_lib.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_acpt.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_bio.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_conn.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_dgram.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_fd.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_file.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_log.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_mem.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_null.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bio\bss_sock.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_add.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_blind.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_const.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_ctx.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_depr.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_div.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_exp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_exp2.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_gcd.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_gf2m.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_kron.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_mod.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_mont.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_mpi.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_mul.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_nist.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_prime.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_print.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_rand.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_recp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_shift.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_sqr.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_sqrt.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_word.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_x931p.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\buffer\buf_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\buffer\buf_str.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\buffer\buffer.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\camellia\cmll_cfb.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\camellia\cmll_ctr.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\camellia\cmll_ecb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\camellia\cmll_ofb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\camellia\cmll_utl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cast\c_cfb64.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cast\c_ecb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cast\c_ofb64.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cast\c_skey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cmac\cm_ameth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cmac\cm_pmeth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cmac\cmac.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_att.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_cd.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_dd.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_env.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_err.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_ess.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_io.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_kari.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_pwri.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_sd.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\cms\cms_smime.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\comp\c_rle.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\comp\c_zlib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\comp\comp_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\comp\comp_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\conf\conf_api.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\conf\conf_def.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\conf\conf_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\conf\conf_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\conf\conf_mall.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\conf\conf_mod.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\conf\conf_sap.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\cpt_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cryptlib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\cbc_cksm.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\des\cbc_enc.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\des\cfb_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\cfb64ede.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\cfb64enc.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\des\des_old.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\des_old2.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\des\ecb_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\ecb3_enc.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\des\ede_cbcm_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\enc_read.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\enc_writ.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\fcrypt.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\ofb_enc.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\des\ofb64ede.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\ofb64enc.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\des\pcbc_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\qud_cksm.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\rand_key.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\read2pwd.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\rpc_enc.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\des\set_key.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\des\str2key.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\des\xcbc_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_ameth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_check.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_depr.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_gen.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_kdf.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_key.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_pmeth.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_prn.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\dh\dh_rfc5114.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_ameth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_asn1.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_depr.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_gen.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_key.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_ossl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_pmeth.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_prn.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_sign.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dsa\dsa_vrf.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_beos.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_dl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_dlfcn.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_lib.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_null.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_openssl.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_vms.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\dso\dso_win32.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ebcdic.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_ameth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_asn1.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_check.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_curve.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_cvt.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_key.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_mult.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_oct.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_pmeth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec_print.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec2_mult.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec2_oct.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ec2_smpl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\eck_prn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_mont.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_nist.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistp224.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistp256.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistp521.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_nistputil.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_oct.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ec\ecp_smpl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdh\ech_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdh\ech_kdf.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdh\ech_key.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdh\ech_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdh\ech_ossl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_ossl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_sign.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ecdsa\ecs_vrf.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_all.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_cnf.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_cryptodev.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_ctrl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_dyn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_fat.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_init.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_list.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_openssl.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_pkey.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_rdrand.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_rsax.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\engine\eng_table.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_asnmth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_cipher.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_dh.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_digest.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_dsa.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_ecdh.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_ecdsa.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_pkmeth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_rand.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_rsa.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\engine\tb_store.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\err\err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\err\err_all.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\err\err_prn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\bio_b64.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\bio_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\bio_md.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\bio_ok.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\c_all.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\c_allc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\c_alld.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\digest.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_aes.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_aes_cbc_hmac_sha1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_aes_cbc_hmac_sha256.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_bf.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_camellia.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_cast.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_des.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_des3.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_idea.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_null.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_old.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_rc2.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_rc4.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_rc4_hmac_md5.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_rc5.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_seed.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\e_xcbc_d.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\encode.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_acnf.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_cnf.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_err.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_fips.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_key.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_pbe.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\evp_pkey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_dss.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_dss1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_ecdsa.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_md4.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_md5.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_null.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_ripemd.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_sha.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_sha1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_sigver.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\m_wp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\names.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p_dec.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p_lib.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p_open.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p_seal.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p_sign.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p_verify.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p5_crpt.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\p5_crpt2.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\pmeth_fn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\pmeth_gn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\evp\pmeth_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ex_data.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\fips_ers.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\hmac\hm_ameth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\hmac\hm_pmeth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\hmac\hmac.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\krb5\krb5_asn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\lhash\lh_stats.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\lhash\lhash.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\md4\md4_dgst.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\md4\md4_one.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\md5\md5_dgst.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\md5\md5_one.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\mem.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\mem_dbg.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\cbc128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\ccm128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\cfb128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\ctr128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\cts128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\gcm128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\ofb128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\wrap128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\modes\xts128.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\o_dir.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\o_fips.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\o_init.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\o_str.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\o_time.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\objects\o_names.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\objects\obj_dat.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\objects\obj_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\objects\obj_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\objects\obj_xref.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_asn.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_cl.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_err.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_ext.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_ht.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_lib.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_prn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_srv.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ocsp\ocsp_vfy.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_all.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_info.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_oth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_pk8.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_pkey.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_seal.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_sign.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_x509.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pem_xaux.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pem\pvkfmt.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_add.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_asn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_attr.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_crpt.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_crt.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_decr.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_init.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_key.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_kiss.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_mutl.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_npas.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_p8d.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_p8e.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\p12_utl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs12\pk12err.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\bio_pk7.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_attr.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_doit.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_lib.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_mime.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\pk7_smime.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\pkcs7\pkcs7err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\pqueue\pqueue.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rand\md_rand.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rand\rand_egd.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rand\rand_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rand\rand_lib.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\rand\rand_nw.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rand\rand_os2.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rand\rand_unix.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\rand\rand_win.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\rand\randfile.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\rc2\rc2_cbc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rc2\rc2_ecb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rc2\rc2_skey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rc2\rc2cfb64.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rc2\rc2ofb64.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rc4\rc4_utl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ripemd\rmd_dgst.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ripemd\rmd_one.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_ameth.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_asn1.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_chk.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_crpt.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_depr.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_eay.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_gen.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_none.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_null.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_oaep.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_pk1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_pmeth.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_prn.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_pss.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_saos.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_sign.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_ssl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\rsa\rsa_x931.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\seed\seed.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\seed\seed_cbc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\seed\seed_cfb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\seed\seed_ecb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\seed\seed_ofb.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\sha\sha_dgst.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\sha\sha_one.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\sha\sha1_one.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\sha\sha1dgst.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\sha\sha256.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\sha\sha512.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\srp\srp_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\srp\srp_vfy.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\stack\stack.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_conf.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_err.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_req_print.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_req_utils.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_print.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_sign.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_utils.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_rsp_verify.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ts\ts_verify_ctx.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\txt_db\txt_db.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\ui\ui_compat.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\ui\ui_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ui\ui_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ui\ui_openssl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\ui\ui_util.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\uid.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\whrlpool\wp_dgst.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\by_dir.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\by_file.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x_all.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_att.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_cmp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_d2.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_def.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_err.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_ext.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_lu.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_obj.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_r2x.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_req.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_set.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_trs.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_txt.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_v3.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_vfy.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509_vpm.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509cset.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509name.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509rset.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509spki.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\x509\x509type.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_cache.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_data.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_map.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_node.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\pcy_tree.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_addr.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_akey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_akeya.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_alt.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_asid.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_bcons.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_bitst.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_conf.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_cpols.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_crld.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_enum.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_extku.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_genn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_ia5.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_info.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_int.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_lib.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_ncons.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_ocsp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pci.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pcia.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pcons.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pku.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_pmaps.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_prn.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_purp.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_scts.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_skey.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_sxnet.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3_utl.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\x509v3\v3err.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\e_gost_err.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_ameth.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_crypt.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_ctl.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_eng.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_keywrap.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_md.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_params.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_pmeth.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost_sign.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost2001.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost2001_keyx.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost89.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gost94_keyx.c" />\r
+ <ClCompile Include="$(opensslDir)engines\ccgost\gosthash.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_4758cca.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_aep.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_atalla.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_capi.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_chil.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_cswift.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_gmp.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_nuron.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_padlock.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_sureware.c" />\r
+ <ClCompile Include="$(opensslDir)engines\e_ubsec.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\d1_clnt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\d1_meth.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\d1_lib.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\d1_srvr.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s2_srvr.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_clnt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_ext.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_srvr.c" />\r
+ </ItemGroup>\r
+ <ItemGroup Condition="$(Platform) == 'Win32'">\r
+ <ClCompile Include="$(opensslDir)crypto\whrlpool\wp_block.c" />\r
+ </ItemGroup>\r
+ <ItemGroup Condition="$(Platform) == 'x64'">\r
+ <ClCompile Include="$(opensslDir)crypto\bf\bf_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\bn\bn_asm.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\camellia\cmll_misc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\cast\c_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\des_enc.c" />\r
+ <ClCompile Include="$(opensslDir)crypto\des\fcrypt_b.c" />\r
+ </ItemGroup>\r
+\r
+ <ItemGroup Condition="$(Platform) == 'Win32'">\r
+ <NasmCompile Include="$(opensslDir)tmp32\aes-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\aesni-x86.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\bf-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\bn-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\cast-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\cmll-x86.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\co-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\crypt586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\des-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\ghash-x86.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\md5-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\rc4-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\rmd-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\sha1-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\sha256-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\sha512-586.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\vpaes-x86.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\wp-mmx.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\x86cpuid.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\x86-gf2m.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp32\x86-mont.asm" />\r
+ </ItemGroup>\r
+ <ItemGroup Condition="$(Platform) == 'x64'">\r
+ <NasmCompile Include="$(opensslDir)tmp64\aesni-sha1-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\aesni-sha1-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\aesni-gcm-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\aesni-mb-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\aesni-sha256-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\aesni-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\aes-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\bsaes-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\cmll-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\ghash-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\md5-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\rc4-md5-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\rc4-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\sha1-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\sha1-mb-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\sha256-mb-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\sha256-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\sha512-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\vpaes-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\wp-x86_64.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\x86_64cpuid.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\x86_64-gf2m.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\x86_64-mont.asm" />\r
+ <NasmCompile Include="$(opensslDir)tmp64\x86_64-mont5.asm" />\r
+ </ItemGroup>\r
+\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <Target Name="Clean" />\r
+ <Target Name="CleanAll">\r
+ <Delete Files="$(TargetPath)" />\r
+ <RemoveDir Directories="$(IntDir)" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <Import Project="pyproject.props" />
-
- <PropertyGroup Label="Configuration">
- <ConfigurationType>StaticLibrary</ConfigurationType>
- <IntDir>$(opensslDir)tmp\$(ArchName)_$(Configuration)\$(ProjectName)\</IntDir>
- <IntDir Condition="$(Configuration) == 'PGInstrument' or $(Configuration) == 'PGUpdate'">$(opensslDir)tmp\$(ArchName)\$(ProjectName)\</IntDir>
- </PropertyGroup>
-
- <ItemGroup>
- <PreprocessorDefinitions Include="DSO_WIN32" />
- <PreprocessorDefinitions Include="WIN32_LEAN_AND_MEAN" />
- <PreprocessorDefinitions Include="L_ENDIAN" />
- <PreprocessorDefinitions Include="_CRT_SECURE_NO_WARNINGS" />
- <PreprocessorDefinitions Include="_CRT_SECURE_NO_DEPRECATE" />
- <PreprocessorDefinitions Include="OPENSSL_THREADS" />
- <!-- <PreprocessorDefinitions Include="OPENSSL_SYSNAME_WIN32" /> -->
- <PreprocessorDefinitions Include="OPENSSL_IA32_SSE2" />
- <PreprocessorDefinitions Include="SHA1_ASM" />
- <PreprocessorDefinitions Include="SHA256_ASM" />
- <PreprocessorDefinitions Include="SHA512_ASM" />
- <PreprocessorDefinitions Include="MD5_ASM" />
- <PreprocessorDefinitions Include="AES_ASM" />
- <PreprocessorDefinitions Include="VPAES_ASM" />
- <PreprocessorDefinitions Include="WHIRLPOOL_ASM" />
- <PreprocessorDefinitions Include="GHASH_ASM" />
- <PreprocessorDefinitions Include="OPENSSL_NO_IDEA" />
- <PreprocessorDefinitions Include="OPENSSL_NO_RC5" />
- <PreprocessorDefinitions Include="OPENSSL_NO_MD2" />
- <PreprocessorDefinitions Include="OPENSSL_NO_MDC2" />
- <PreprocessorDefinitions Include="OPENSSL_NO_KRB5" />
- <PreprocessorDefinitions Include="OPENSSL_NO_JPAKE" />
- <PreprocessorDefinitions Include="OPENSSL_NO_RDRAND" />
- <PreprocessorDefinitions Include="OPENSSL_NO_RSAX" />
- <PreprocessorDefinitions Include="OPENSSL_NO_DYNAMIC_ENGINE" />
- </ItemGroup>
- <ItemGroup Condition="'$(Platform)'=='Win32'">
- <PreprocessorDefinitions Include="OPENSSL_BN_ASM_GF2m" />
- <PreprocessorDefinitions Include="OPENSSL_BN_ASM_PART_WORDS" />
- <PreprocessorDefinitions Include="OPENSSL_BN_ASM_MONT" />
- <PreprocessorDefinitions Include="RMD160_ASM" />
- </ItemGroup>
-
- <PropertyGroup>
- <_PreprocessorDefinitionList>@(PreprocessorDefinitions)</_PreprocessorDefinitionList>
- </PropertyGroup>
-
- <ItemDefinitionGroup>
- <ClCompile>
- <!-- Suppress 64-bit truncation warnings - they aren't ours to worry about -->
- <DisableSpecificWarnings>4244;4267</DisableSpecificWarnings>
- <AdditionalIncludeDirectories>$(opensslDir);$(opensslIncludeDir);$(opensslDir)crypto;$(opensslDir)crypto\asn1;$(opensslDir)crypto\evp;$(opensslDir)crypto\modes</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>$(_PreprocessorDefinitionList);%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- </ItemDefinitionGroup>
-
- <Target Name="FindNasm">
- <PropertyGroup>
- <nasm Condition="$(Platform) == 'Win32'">nasm.exe -f win32</nasm>
- <nasm Condition="$(Platform) == 'x64'">nasm.exe -f win64 -DNEAR -Ox -g</nasm>
- </PropertyGroup>
- </Target>
-
- <Target Name="BuildNasmFiles" BeforeTargets="PreBuildEvent" DependsOnTargets="PrepareForBuild;FindNasm" Inputs="@(NasmCompile)" Outputs="@(NasmCompile->'$(IntDir)%(Filename).obj')">
- <Exec Command='setlocal
-set PATH=$(nasmDir);%PATH%
-$(nasm) -o "$(IntDir)%(NasmCompile.Filename).obj" "%(NasmCompile.FullPath)"' />
- <ItemGroup>
- <Link Include="$(IntDir)%(NasmCompile.Filename).obj" />
- <Lib Include="$(IntDir)%(NasmCompile.Filename).obj" />
- </ItemGroup>
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <Import Project="pyproject.props" />\r
+\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>StaticLibrary</ConfigurationType>\r
+ <IntDir>$(opensslDir)tmp\$(ArchName)_$(Configuration)\$(ProjectName)\</IntDir>\r
+ <IntDir Condition="$(Configuration) == 'PGInstrument' or $(Configuration) == 'PGUpdate'">$(opensslDir)tmp\$(ArchName)\$(ProjectName)\</IntDir>\r
+ </PropertyGroup>\r
+\r
+ <ItemGroup>\r
+ <PreprocessorDefinitions Include="DSO_WIN32" />\r
+ <PreprocessorDefinitions Include="WIN32_LEAN_AND_MEAN" />\r
+ <PreprocessorDefinitions Include="L_ENDIAN" />\r
+ <PreprocessorDefinitions Include="_CRT_SECURE_NO_WARNINGS" />\r
+ <PreprocessorDefinitions Include="_CRT_SECURE_NO_DEPRECATE" />\r
+ <PreprocessorDefinitions Include="OPENSSL_THREADS" />\r
+ <!-- <PreprocessorDefinitions Include="OPENSSL_SYSNAME_WIN32" /> -->\r
+ <PreprocessorDefinitions Include="OPENSSL_IA32_SSE2" />\r
+ <PreprocessorDefinitions Include="SHA1_ASM" />\r
+ <PreprocessorDefinitions Include="SHA256_ASM" />\r
+ <PreprocessorDefinitions Include="SHA512_ASM" />\r
+ <PreprocessorDefinitions Include="MD5_ASM" />\r
+ <PreprocessorDefinitions Include="AES_ASM" />\r
+ <PreprocessorDefinitions Include="VPAES_ASM" />\r
+ <PreprocessorDefinitions Include="WHIRLPOOL_ASM" />\r
+ <PreprocessorDefinitions Include="GHASH_ASM" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_IDEA" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_RC5" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_MD2" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_MDC2" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_KRB5" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_JPAKE" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_RDRAND" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_RSAX" />\r
+ <PreprocessorDefinitions Include="OPENSSL_NO_DYNAMIC_ENGINE" />\r
+ </ItemGroup>\r
+ <ItemGroup Condition="'$(Platform)'=='Win32'">\r
+ <PreprocessorDefinitions Include="OPENSSL_BN_ASM_GF2m" />\r
+ <PreprocessorDefinitions Include="OPENSSL_BN_ASM_PART_WORDS" />\r
+ <PreprocessorDefinitions Include="OPENSSL_BN_ASM_MONT" />\r
+ <PreprocessorDefinitions Include="RMD160_ASM" />\r
+ </ItemGroup>\r
+\r
+ <PropertyGroup>\r
+ <_PreprocessorDefinitionList>@(PreprocessorDefinitions)</_PreprocessorDefinitionList>\r
+ </PropertyGroup>\r
+\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <!-- Suppress 64-bit truncation warnings - they aren't ours to worry about -->\r
+ <DisableSpecificWarnings>4244;4267</DisableSpecificWarnings>\r
+ <AdditionalIncludeDirectories>$(opensslDir);$(opensslIncludeDir);$(opensslDir)crypto;$(opensslDir)crypto\asn1;$(opensslDir)crypto\evp;$(opensslDir)crypto\modes</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>$(_PreprocessorDefinitionList);%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ </ItemDefinitionGroup>\r
+\r
+ <Target Name="FindNasm">\r
+ <PropertyGroup>\r
+ <nasm Condition="$(Platform) == 'Win32'">nasm.exe -f win32</nasm>\r
+ <nasm Condition="$(Platform) == 'x64'">nasm.exe -f win64 -DNEAR -Ox -g</nasm>\r
+ </PropertyGroup>\r
+ </Target>\r
+\r
+ <Target Name="BuildNasmFiles" BeforeTargets="PreBuildEvent" DependsOnTargets="PrepareForBuild;FindNasm" Inputs="@(NasmCompile)" Outputs="@(NasmCompile->'$(IntDir)%(Filename).obj')">\r
+ <Exec Command='setlocal\r
+set PATH=$(nasmDir);%PATH%\r
+$(nasm) -o "$(IntDir)%(NasmCompile.Filename).obj" "%(NasmCompile.FullPath)"' />\r
+ <ItemGroup>\r
+ <Link Include="$(IntDir)%(NasmCompile.Filename).obj" />\r
+ <Lib Include="$(IntDir)%(NasmCompile.Filename).obj" />\r
+ </ItemGroup>\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <PropertyGroup Label="Globals">
- <ProjectGuid>{CC9B93A2-439D-4058-9D29-6DCF43774405}</ProjectGuid>
- <Platform Condition="'$(Platform)' == ''">Win32</Platform>
- <Configuration Condition="'$(Configuration)' == ''">Release</Configuration>
- <IncludeExtensions Condition="'$(IncludeExtensions)' == ''">true</IncludeExtensions>
- <IncludeExternals Condition="'$(IncludeExternals)' == ''">true</IncludeExternals>
- <IncludeTests Condition="'$(IncludeTest)' == ''">true</IncludeTests>
- <IncludeSSL Condition="'$(IncludeSSL)' == ''">true</IncludeSSL>
- <IncludeTkinter Condition="'$(IncludeTkinter)' == ''">true</IncludeTkinter>
- <IncludeBsddb Condition="'$(IncludeBsddb)' == ''">true</IncludeBsddb>
- </PropertyGroup>
-
- <ItemDefinitionGroup>
- <Projects>
- <Platform>$(Platform)</Platform>
- <Configuration>$(Configuration)</Configuration>
- <Properties></Properties>
- <BuildTarget>Build</BuildTarget>
- <CleanTarget>Clean</CleanTarget>
- <CleanAllTarget>CleanAll</CleanAllTarget>
- <BuildInParallel>true</BuildInParallel>
- </Projects>
- </ItemDefinitionGroup>
- <ItemGroup>
- <!-- pythonXY.dll -->
- <!--
- Parallel build is explicitly disabled for this project because it
- causes many conflicts between pythoncore and projects that depend
- on pythoncore. Once the core DLL has been built, subsequent
- projects will be built in parallel.
- -->
- <Projects Include="pythoncore.vcxproj">
- <BuildInParallel>false</BuildInParallel>
- </Projects>
- <!-- python[w].exe -->
- <Projects Include="python.vcxproj;pythonw.vcxproj" />
- <!-- Extension modules -->
- <ExtensionModules Include="_ctypes;_elementtree;_msi;_multiprocessing;pyexpat;select;unicodedata;winsound" />
- <!-- Extension modules that require external sources -->
- <ExternalModules Include="bz2;_sqlite3" />
- <!-- _ssl will build _socket as well, which may cause conflicts in parallel builds -->
- <ExtensionModules Include="_socket" Condition="!$(IncludeSSL) or !$(IncludeExternals)" />
- <ExternalModules Include="_ssl;_hashlib" Condition="$(IncludeSSL)" />
- <ExternalModules Include="_tkinter;tix" Condition="$(IncludeTkinter)" />
- <ExternalModules Include="_bsddb" Condition="$(IncludeBsddb)" />
- <ExtensionModules Include="@(ExternalModules->'%(Identity)')" Condition="$(IncludeExternals)" />
- <Projects Include="@(ExtensionModules->'%(Identity).vcxproj')" Condition="$(IncludeExtensions)" />
- <!-- Test modules -->
- <TestModules Include="_ctypes_test;_testcapi" />
- <Projects Include="@(TestModules->'%(Identity).vcxproj')" Condition="$(IncludeTests)">
- <!-- Disable parallel build for test modules -->
- <BuildInParallel>false</BuildInParallel>
- </Projects>
- </ItemGroup>
-
- <Target Name="Build">
- <MSBuild Projects="@(Projects)"
- Properties="Configuration=%(Configuration);Platform=%(Platform);%(Properties)"
- BuildInParallel="%(BuildInParallel)"
- Targets="%(BuildTarget)" />
- </Target>
-
- <Target Name="Clean">
- <MSBuild Projects="@(Projects)"
- Properties="Configuration=%(Configuration);Platform=%(Platform);%(Properties)"
- BuildInParallel="%(BuildInParallel)"
- StopOnFirstFailure="false"
- Condition="%(CleanTarget) != ''"
- Targets="%(CleanTarget)" />
- </Target>
-
- <Target Name="CleanAll">
- <MSBuild Projects="@(Projects)"
- Properties="Configuration=%(Configuration);Platform=%(Platform);%(Properties)"
- BuildInParallel="%(BuildInParallel)"
- StopOnFirstFailure="false"
- Condition="%(CleanAllTarget) != ''"
- Targets="%(CleanAllTarget)" />
- </Target>
-
- <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
- <Target Name="RebuildAll" DependsOnTargets="CleanAll;Build" />
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{CC9B93A2-439D-4058-9D29-6DCF43774405}</ProjectGuid>\r
+ <Platform Condition="'$(Platform)' == ''">Win32</Platform>\r
+ <Configuration Condition="'$(Configuration)' == ''">Release</Configuration>\r
+ <IncludeExtensions Condition="'$(IncludeExtensions)' == ''">true</IncludeExtensions>\r
+ <IncludeExternals Condition="'$(IncludeExternals)' == ''">true</IncludeExternals>\r
+ <IncludeTests Condition="'$(IncludeTest)' == ''">true</IncludeTests>\r
+ <IncludeSSL Condition="'$(IncludeSSL)' == ''">true</IncludeSSL>\r
+ <IncludeTkinter Condition="'$(IncludeTkinter)' == ''">true</IncludeTkinter>\r
+ <IncludeBsddb Condition="'$(IncludeBsddb)' == ''">true</IncludeBsddb>\r
+ </PropertyGroup>\r
+\r
+ <ItemDefinitionGroup>\r
+ <Projects>\r
+ <Platform>$(Platform)</Platform>\r
+ <Configuration>$(Configuration)</Configuration>\r
+ <Properties></Properties>\r
+ <BuildTarget>Build</BuildTarget>\r
+ <CleanTarget>Clean</CleanTarget>\r
+ <CleanAllTarget>CleanAll</CleanAllTarget>\r
+ <BuildInParallel>true</BuildInParallel>\r
+ </Projects>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <!-- pythonXY.dll -->\r
+ <!--\r
+ Parallel build is explicitly disabled for this project because it\r
+ causes many conflicts between pythoncore and projects that depend\r
+ on pythoncore. Once the core DLL has been built, subsequent\r
+ projects will be built in parallel.\r
+ -->\r
+ <Projects Include="pythoncore.vcxproj">\r
+ <BuildInParallel>false</BuildInParallel>\r
+ </Projects>\r
+ <!-- python[w].exe -->\r
+ <Projects Include="python.vcxproj;pythonw.vcxproj" />\r
+ <!-- Extension modules -->\r
+ <ExtensionModules Include="_ctypes;_elementtree;_msi;_multiprocessing;pyexpat;select;unicodedata;winsound" />\r
+ <!-- Extension modules that require external sources -->\r
+ <ExternalModules Include="bz2;_sqlite3" />\r
+ <!-- _ssl will build _socket as well, which may cause conflicts in parallel builds -->\r
+ <ExtensionModules Include="_socket" Condition="!$(IncludeSSL) or !$(IncludeExternals)" />\r
+ <ExternalModules Include="_ssl;_hashlib" Condition="$(IncludeSSL)" />\r
+ <ExternalModules Include="_tkinter;tix" Condition="$(IncludeTkinter)" />\r
+ <ExternalModules Include="_bsddb" Condition="$(IncludeBsddb)" />\r
+ <ExtensionModules Include="@(ExternalModules->'%(Identity)')" Condition="$(IncludeExternals)" />\r
+ <Projects Include="@(ExtensionModules->'%(Identity).vcxproj')" Condition="$(IncludeExtensions)" />\r
+ <!-- Test modules -->\r
+ <TestModules Include="_ctypes_test;_testcapi" />\r
+ <Projects Include="@(TestModules->'%(Identity).vcxproj')" Condition="$(IncludeTests)">\r
+ <!-- Disable parallel build for test modules -->\r
+ <BuildInParallel>false</BuildInParallel>\r
+ </Projects>\r
+ </ItemGroup>\r
+\r
+ <Target Name="Build">\r
+ <MSBuild Projects="@(Projects)"\r
+ Properties="Configuration=%(Configuration);Platform=%(Platform);%(Properties)"\r
+ BuildInParallel="%(BuildInParallel)"\r
+ Targets="%(BuildTarget)" />\r
+ </Target>\r
+\r
+ <Target Name="Clean">\r
+ <MSBuild Projects="@(Projects)"\r
+ Properties="Configuration=%(Configuration);Platform=%(Platform);%(Properties)"\r
+ BuildInParallel="%(BuildInParallel)"\r
+ StopOnFirstFailure="false"\r
+ Condition="%(CleanTarget) != ''"\r
+ Targets="%(CleanTarget)" />\r
+ </Target>\r
+\r
+ <Target Name="CleanAll">\r
+ <MSBuild Projects="@(Projects)"\r
+ Properties="Configuration=%(Configuration);Platform=%(Platform);%(Properties)"\r
+ BuildInParallel="%(BuildInParallel)"\r
+ StopOnFirstFailure="false"\r
+ Condition="%(CleanAllTarget) != ''"\r
+ Targets="%(CleanAllTarget)" />\r
+ </Target>\r
+\r
+ <Target Name="Rebuild" DependsOnTargets="Clean;Build" />\r
+ <Target Name="RebuildAll" DependsOnTargets="CleanAll;Build" />\r
+</Project>\r
-Microsoft Visual Studio Solution File, Format Version 12.00\r
+Microsoft Visual Studio Solution File, Format Version 11.00\r
# Visual Studio 2010\r
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{553EC33E-9816-4996-A660-5D6186A0B0B3}"\r
ProjectSection(SolutionItems) = preProject\r
#! /usr/bin/env python3
+# -*- coding: utf8 -*-
+# The encoding declaration is required for running PC\VS9.0\build_ssl.py
+
# Script for preparing OpenSSL for building on Windows.
# Uses Perl to create nmake makefiles and otherwise prepare the way
# for building on 32 or 64 bit platforms.
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- <ProjectGuid>{D06B6426-4762-44CC-8BAD-D79052507F2F}</ProjectGuid>
- <RootNamespace>pyexpat</RootNamespace>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(PySourcePath)Modules\expat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>PYEXPAT_EXPORTS;HAVE_EXPAT_H;XML_NS;XML_DTD;BYTEORDER=1234;XML_CONTEXT_BYTES=1024;XML_STATIC;HAVE_MEMMOVE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\expat\xmlrole.h" />
- <ClInclude Include="..\Modules\expat\xmltok.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\pyexpat.c" />
- <ClCompile Include="..\Modules\expat\xmlparse.c" />
- <ClCompile Include="..\Modules\expat\xmlrole.c" />
- <ClCompile Include="..\Modules\expat\xmltok.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ <ProjectGuid>{D06B6426-4762-44CC-8BAD-D79052507F2F}</ProjectGuid>\r
+ <RootNamespace>pyexpat</RootNamespace>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(PySourcePath)Modules\expat;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;PYEXPAT_EXPORTS;XML_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\expat\xmlrole.h" />\r
+ <ClInclude Include="..\Modules\expat\xmltok.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\pyexpat.c" />\r
+ <ClCompile Include="..\Modules\expat\loadlibrary.c" />\r
+ <ClCompile Include="..\Modules\expat\xmlparse.c" />\r
+ <ClCompile Include="..\Modules\expat\xmlrole.c" />\r
+ <ClCompile Include="..\Modules\expat\xmltok.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{ddae77a6-7ca0-4a1b-b71c-deea5f4025de}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{5af9d40c-fc46-4640-ad84-3d1dd34a71d7}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\expat\xmlrole.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\expat\xmltok.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\pyexpat.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\expat\xmlparse.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\expat\xmlrole.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\expat\xmltok.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{ddae77a6-7ca0-4a1b-b71c-deea5f4025de}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{5af9d40c-fc46-4640-ad84-3d1dd34a71d7}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\expat\xmlrole.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\expat\xmltok.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\pyexpat.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\expat\loadlibrary.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\expat\xmlparse.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\expat\xmlrole.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\expat\xmltok.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <PropertyGroup Label="Globals">
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
- <OutDir>$(BuildPath)</OutDir>
- <IntDir>$(SolutionDir)obj\$(ArchName)_$(Configuration)\$(ProjectName)\</IntDir>
- <IntDir Condition="'$(Configuration)' == 'PGInstrument' or '$(Configuration)' == 'PGUpdate'">$(SolutionDir)obj\$(ArchName)\$(ProjectName)\</IntDir>
- <TargetName Condition="'$(TargetName)' == ''">$(ProjectName)</TargetName>
- <TargetName>$(TargetName)$(PyDebugExt)</TargetName>
- <GenerateManifest>false</GenerateManifest>
- <EmbedManifest>false</EmbedManifest>
- <!-- BasePlatformToolset is for ICC support -->
- <SupportPGO Condition="'$(SupportPGO)' == ''">true</SupportPGO>
- <SupportSigning Condition="'$(SupportSigning)' == ''">true</SupportSigning>
- <SupportSigning Condition="'$(Configuration)' == 'Debug'">false</SupportSigning>
- <SupportSigning Condition="'$(ConfigurationType)' == 'StaticLibrary'">false</SupportSigning>
- </PropertyGroup>
-
- <PropertyGroup>
- <_DebugPreprocessorDefinition>NDEBUG;</_DebugPreprocessorDefinition>
- <_DebugPreprocessorDefinition Condition="$(Configuration) == 'Debug'">_DEBUG;</_DebugPreprocessorDefinition>
- <_PlatformPreprocessorDefinition>_WIN32;</_PlatformPreprocessorDefinition>
- <_PlatformPreprocessorDefinition Condition="$(Platform) == 'x64'">_WIN64;_M_X64;</_PlatformPreprocessorDefinition>
- <_PydPreprocessorDefinition Condition="$(TargetExt) == '.pyd'">Py_BUILD_CORE_MODULE;</_PydPreprocessorDefinition>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(PySourcePath)Include;$(PySourcePath)PC;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>WIN32;$(_PlatformPreprocessorDefinition)$(_DebugPreprocessorDefinition)$(_PydPreprocessorDefinition)%(PreprocessorDefinitions)</PreprocessorDefinitions>
-
- <Optimization>MaxSpeed</Optimization>
- <IntrinsicFunctions>true</IntrinsicFunctions>
- <StringPooling>true</StringPooling>
- <ExceptionHandling></ExceptionHandling>
- <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
- <FunctionLevelLinking>true</FunctionLevelLinking>
- <WarningLevel>Level3</WarningLevel>
- <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
- <CompileAs>Default</CompileAs>
- <SuppressStartupBanner>true</SuppressStartupBanner>
- <WholeProgramOptimization>true</WholeProgramOptimization>
- </ClCompile>
- <ClCompile Condition="$(Configuration) == 'Debug'">
- <Optimization>Disabled</Optimization>
- <WholeProgramOptimization>false</WholeProgramOptimization>
- <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
- </ClCompile>
- <ClCompile Condition="$(ICCBuild) == 'true'">
- <FloatingPointModel>Strict</FloatingPointModel>
- </ClCompile>
- <Link>
- <AdditionalLibraryDirectories>$(OutDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
- <GenerateDebugInformation>true</GenerateDebugInformation>
- <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>
- <SubSystem>Windows</SubSystem>
- <RandomizedBaseAddress>true</RandomizedBaseAddress>
- <DataExecutionPrevention>true</DataExecutionPrevention>
- <SuppressStartupBanner>true</SuppressStartupBanner>
- <IgnoreSpecificDefaultLibraries>LIBC;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
- <TargetMachine>MachineX86</TargetMachine>
- <TargetMachine Condition="'$(Platform)' == 'x64'">MachineX64</TargetMachine>
- <ProfileGuidedDatabase Condition="$(SupportPGO)">$(OutDir)$(TargetName).pgd</ProfileGuidedDatabase>
- <LinkTimeCodeGeneration Condition="$(Configuration) == 'Release'">UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
- <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGInstrument'">PGInstrument</LinkTimeCodeGeneration>
- <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGUpdate'">PGUpdate</LinkTimeCodeGeneration>
- </Link>
- <Lib>
- <LinkTimeCodeGeneration Condition="$(Configuration) == 'Release'">true</LinkTimeCodeGeneration>
- <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGInstrument'">true</LinkTimeCodeGeneration>
- <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGUpdate'">true</LinkTimeCodeGeneration>
- </Lib>
- <ResourceCompile>
- <AdditionalIncludeDirectories>$(PySourcePath)PC;$(PySourcePath)Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>$(_DebugPreprocessorDefinition)%(PreprocessorDefinitions)</PreprocessorDefinitions>
- <Culture>0x0409</Culture>
- </ResourceCompile>
- <Midl>
- <PreprocessorDefinitions>$(_DebugPreprocessorDefinition)%(PreprocessorDefinitions)</PreprocessorDefinitions>
- <MkTypLibCompatible>true</MkTypLibCompatible>
- <SuppressStartupBanner>true</SuppressStartupBanner>
- <TargetEnvironment>Win32</TargetEnvironment>
- <TargetEnvironment Condition="'$(Platform)' == 'x64'">X64</TargetEnvironment>
- <TypeLibraryName>$(OutDir)wininst.tlb</TypeLibraryName>
- <HeaderFileName>
- </HeaderFileName>
- </Midl>
- </ItemDefinitionGroup>
-
- <Target Name="GeneratePythonNtRcH"
- BeforeTargets="$(MakeVersionInfoBeforeTarget)"
- Inputs="$(PySourcePath)Include\patchlevel.h"
- Outputs="$(PySourcePath)PC\pythonnt_rc$(PyDebugExt).h">
- <WriteLinesToFile File="$(PySourcePath)PC\pythonnt_rc$(PyDebugExt).h" Overwrite="true" Encoding="ascii"
- Lines='/* This file created by python.props /t:GeneratePythonNtRcH */
-#define FIELD3 $(Field3Value)
-#define MS_DLL_ID "$(SysWinVer)"
-#define PYTHON_DLL_NAME "$(PyDllName).dll"
-' />
- <ItemGroup>
- <FileWrites Include="$(PySourcePath)PC\pythonnt_rc$(PyDebugExt).h" />
- </ItemGroup>
- </Target>
-
- <UsingTask TaskName="KillPython" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
- <ParameterGroup>
- <FileName Required="true" />
- </ParameterGroup>
- <Task>
- <Code Type="Fragment" Language="cs">
-<![CDATA[
-string fullPath = System.IO.Path.GetFullPath(FileName);
-Log.LogMessage("Looking for " + fullPath, MessageImportance.Normal);
-foreach (System.Diagnostics.Process p in System.Diagnostics.Process.GetProcesses()) {
- try {
- Log.LogMessage("Found running process: " + p.MainModule.FileName, MessageImportance.Low);
- if (fullPath.Equals(System.IO.Path.GetFullPath(p.MainModule.FileName), StringComparison.OrdinalIgnoreCase)) {
- Log.LogMessage("Terminating " + p.MainModule.FileName, MessageImportance.High);
- p.Kill();
- }
- } catch {
- }
-}
-]]>
- </Code>
- </Task>
- </UsingTask>
-
- <Target Name="KillPython" BeforeTargets="PrepareForBuild" Condition="'$(KillPython)' == 'true'">
- <Message Text="Killing any running python.exe instances..." Importance="high" />
- <KillPython FileName="$(OutDir)python$(PyDebugExt).exe" />
- </Target>
-
- <!--
- A default target to handle msbuild pcbuild.proj /t:CleanAll.
-
- Some externals projects don't respond to /t:Clean, so we invoke
- CleanAll on them when we really want to clean up.
- -->
- <Target Name="CleanAll" DependsOnTargets="Clean">
- <MSBuild Projects="@(ProjectReference->'%(FullPath)')"
- Properties="Configuration=$(Configuration);Platform=$(Platform)"
- BuildInParallel="true"
- StopOnFirstFailure="false"
- Condition="Exists(%(FullPath))"
- Targets="CleanAll" />
- </Target>
-
- <PropertyGroup Condition="'$(SigningCertificate)' != '' and $(SupportSigning)">
- <SignToolPath Condition="'$(SignToolPath)' == '' or !Exists($(SignToolPath))">$(registry:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows Kits\Installed Roots@KitsRoot81)\bin\x86\signtool.exe</SignToolPath>
- <SignToolPath Condition="!Exists($(SignToolPath))">$(registry:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows Kits\Installed Roots@KitsRoot)\bin\x86\signtool.exe</SignToolPath>
- <SignToolPath Condition="!Exists($(SignToolPath))">$(registry:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Windows\v7.1A@InstallationFolder)\Bin\signtool.exe</SignToolPath>
- <_SignCommand Condition="Exists($(SignToolPath))">"$(SignToolPath)" sign /q /n "$(SigningCertificate)" /t http://timestamp.verisign.com/scripts/timestamp.dll /d "Python $(PythonVersion)"</_SignCommand>
- </PropertyGroup>
-
- <Target Name="_SignBuild" AfterTargets="AfterBuild" Condition="'$(SigningCertificate)' != '' and $(SupportSigning)">
- <Error Text="Unable to locate signtool.exe. Set /p:SignToolPath and rebuild" Condition="'$(_SignCommand)' == ''" />
- <Exec Command='$(_SignCommand) "$(TargetPath)" || $(_SignCommand) "$(TargetPath)" || $(_SignCommand) "$(TargetPath)"' ContinueOnError="false" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup Label="Globals">\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>\r
+ <OutDir>$(BuildPath)</OutDir>\r
+ <IntDir>$(SolutionDir)obj\$(ArchName)_$(Configuration)\$(ProjectName)\</IntDir>\r
+ <IntDir Condition="'$(Configuration)' == 'PGInstrument' or '$(Configuration)' == 'PGUpdate'">$(SolutionDir)obj\$(ArchName)\$(ProjectName)\</IntDir>\r
+ <TargetName Condition="'$(TargetName)' == ''">$(ProjectName)</TargetName>\r
+ <TargetName>$(TargetName)$(PyDebugExt)</TargetName>\r
+ <GenerateManifest>false</GenerateManifest>\r
+ <EmbedManifest>false</EmbedManifest>\r
+ <!-- BasePlatformToolset is for ICC support -->\r
+ <SupportPGO Condition="'$(SupportPGO)' == ''">true</SupportPGO>\r
+ <SupportSigning Condition="'$(SupportSigning)' == ''">true</SupportSigning>\r
+ <SupportSigning Condition="'$(Configuration)' == 'Debug'">false</SupportSigning>\r
+ <SupportSigning Condition="'$(ConfigurationType)' == 'StaticLibrary'">false</SupportSigning>\r
+ </PropertyGroup>\r
+\r
+ <PropertyGroup>\r
+ <_DebugPreprocessorDefinition>NDEBUG;</_DebugPreprocessorDefinition>\r
+ <_DebugPreprocessorDefinition Condition="$(Configuration) == 'Debug'">_DEBUG;</_DebugPreprocessorDefinition>\r
+ <_PlatformPreprocessorDefinition>_WIN32;</_PlatformPreprocessorDefinition>\r
+ <_PlatformPreprocessorDefinition Condition="$(Platform) == 'x64'">_WIN64;_M_X64;</_PlatformPreprocessorDefinition>\r
+ <_PydPreprocessorDefinition Condition="$(TargetExt) == '.pyd'">Py_BUILD_CORE_MODULE;</_PydPreprocessorDefinition>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(PySourcePath)Include;$(PySourcePath)PC;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>WIN32;$(_PlatformPreprocessorDefinition)$(_DebugPreprocessorDefinition)$(_PydPreprocessorDefinition)%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+\r
+ <Optimization>MaxSpeed</Optimization>\r
+ <IntrinsicFunctions>true</IntrinsicFunctions>\r
+ <StringPooling>true</StringPooling>\r
+ <ExceptionHandling></ExceptionHandling>\r
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>\r
+ <FunctionLevelLinking>true</FunctionLevelLinking>\r
+ <WarningLevel>Level3</WarningLevel>\r
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>\r
+ <CompileAs>Default</CompileAs>\r
+ <SuppressStartupBanner>true</SuppressStartupBanner>\r
+ <WholeProgramOptimization>true</WholeProgramOptimization>\r
+ </ClCompile>\r
+ <ClCompile Condition="$(Configuration) == 'Debug'">\r
+ <Optimization>Disabled</Optimization>\r
+ <WholeProgramOptimization>false</WholeProgramOptimization>\r
+ <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>\r
+ </ClCompile>\r
+ <ClCompile Condition="$(ICCBuild) == 'true'">\r
+ <FloatingPointModel>Strict</FloatingPointModel>\r
+ </ClCompile>\r
+ <Link>\r
+ <AdditionalLibraryDirectories>$(OutDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>\r
+ <GenerateDebugInformation>true</GenerateDebugInformation>\r
+ <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>\r
+ <SubSystem>Windows</SubSystem>\r
+ <RandomizedBaseAddress>true</RandomizedBaseAddress>\r
+ <DataExecutionPrevention>true</DataExecutionPrevention>\r
+ <SuppressStartupBanner>true</SuppressStartupBanner>\r
+ <IgnoreSpecificDefaultLibraries>LIBC;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>\r
+ <TargetMachine>MachineX86</TargetMachine>\r
+ <TargetMachine Condition="'$(Platform)' == 'x64'">MachineX64</TargetMachine>\r
+ <ProfileGuidedDatabase Condition="$(SupportPGO)">$(OutDir)$(TargetName).pgd</ProfileGuidedDatabase>\r
+ <LinkTimeCodeGeneration Condition="$(Configuration) == 'Release'">UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>\r
+ <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGInstrument'">PGInstrument</LinkTimeCodeGeneration>\r
+ <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGUpdate'">PGUpdate</LinkTimeCodeGeneration>\r
+ </Link>\r
+ <Lib>\r
+ <LinkTimeCodeGeneration Condition="$(Configuration) == 'Release'">true</LinkTimeCodeGeneration>\r
+ <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGInstrument'">true</LinkTimeCodeGeneration>\r
+ <LinkTimeCodeGeneration Condition="$(SupportPGO) and $(Configuration) == 'PGUpdate'">true</LinkTimeCodeGeneration>\r
+ </Lib>\r
+ <ResourceCompile>\r
+ <AdditionalIncludeDirectories>$(PySourcePath)PC;$(PySourcePath)Include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>$(_DebugPreprocessorDefinition)%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <Culture>0x0409</Culture>\r
+ </ResourceCompile>\r
+ <Midl>\r
+ <PreprocessorDefinitions>$(_DebugPreprocessorDefinition)%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <MkTypLibCompatible>true</MkTypLibCompatible>\r
+ <SuppressStartupBanner>true</SuppressStartupBanner>\r
+ <TargetEnvironment>Win32</TargetEnvironment>\r
+ <TargetEnvironment Condition="'$(Platform)' == 'x64'">X64</TargetEnvironment>\r
+ <TypeLibraryName>$(OutDir)wininst.tlb</TypeLibraryName>\r
+ <HeaderFileName>\r
+ </HeaderFileName>\r
+ </Midl>\r
+ </ItemDefinitionGroup>\r
+\r
+ <Target Name="GeneratePythonNtRcH"\r
+ BeforeTargets="$(MakeVersionInfoBeforeTarget)"\r
+ Inputs="$(PySourcePath)Include\patchlevel.h"\r
+ Outputs="$(PySourcePath)PC\pythonnt_rc$(PyDebugExt).h">\r
+ <WriteLinesToFile File="$(PySourcePath)PC\pythonnt_rc$(PyDebugExt).h" Overwrite="true" Encoding="ascii"\r
+ Lines='/* This file created by python.props /t:GeneratePythonNtRcH */\r
+#define FIELD3 $(Field3Value)\r
+#define MS_DLL_ID "$(SysWinVer)"\r
+#define PYTHON_DLL_NAME "$(PyDllName).dll"\r
+' />\r
+ <ItemGroup>\r
+ <FileWrites Include="$(PySourcePath)PC\pythonnt_rc$(PyDebugExt).h" />\r
+ </ItemGroup>\r
+ </Target>\r
+\r
+ <UsingTask TaskName="KillPython" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">\r
+ <ParameterGroup>\r
+ <FileName Required="true" />\r
+ </ParameterGroup>\r
+ <Task>\r
+ <Code Type="Fragment" Language="cs">\r
+<![CDATA[\r
+string fullPath = System.IO.Path.GetFullPath(FileName);\r
+Log.LogMessage("Looking for " + fullPath, MessageImportance.Normal);\r
+foreach (System.Diagnostics.Process p in System.Diagnostics.Process.GetProcesses()) {\r
+ try {\r
+ Log.LogMessage("Found running process: " + p.MainModule.FileName, MessageImportance.Low);\r
+ if (fullPath.Equals(System.IO.Path.GetFullPath(p.MainModule.FileName), StringComparison.OrdinalIgnoreCase)) {\r
+ Log.LogMessage("Terminating " + p.MainModule.FileName, MessageImportance.High);\r
+ p.Kill();\r
+ }\r
+ } catch {\r
+ }\r
+}\r
+]]>\r
+ </Code>\r
+ </Task>\r
+ </UsingTask>\r
+\r
+ <Target Name="KillPython" BeforeTargets="PrepareForBuild" Condition="'$(KillPython)' == 'true'">\r
+ <Message Text="Killing any running python.exe instances..." Importance="high" />\r
+ <KillPython FileName="$(OutDir)python$(PyDebugExt).exe" />\r
+ </Target>\r
+\r
+ <!--\r
+ A default target to handle msbuild pcbuild.proj /t:CleanAll.\r
+\r
+ Some externals projects don't respond to /t:Clean, so we invoke\r
+ CleanAll on them when we really want to clean up.\r
+ -->\r
+ <Target Name="CleanAll" DependsOnTargets="Clean">\r
+ <MSBuild Projects="@(ProjectReference->'%(FullPath)')"\r
+ Properties="Configuration=$(Configuration);Platform=$(Platform)"\r
+ BuildInParallel="true"\r
+ StopOnFirstFailure="false"\r
+ Condition="Exists(%(FullPath))"\r
+ Targets="CleanAll" />\r
+ </Target>\r
+\r
+ <PropertyGroup Condition="'$(SigningCertificate)' != '' and $(SupportSigning)">\r
+ <SignToolPath Condition="'$(SignToolPath)' == '' or !Exists($(SignToolPath))">$(registry:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows Kits\Installed Roots@KitsRoot81)\bin\x86\signtool.exe</SignToolPath>\r
+ <SignToolPath Condition="!Exists($(SignToolPath))">$(registry:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows Kits\Installed Roots@KitsRoot)\bin\x86\signtool.exe</SignToolPath>\r
+ <SignToolPath Condition="!Exists($(SignToolPath))">$(registry:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Windows\v7.1A@InstallationFolder)\Bin\signtool.exe</SignToolPath>\r
+ <_SignCommand Condition="Exists($(SignToolPath))">"$(SignToolPath)" sign /q /n "$(SigningCertificate)" /t http://timestamp.verisign.com/scripts/timestamp.dll /d "Python $(PythonVersion)"</_SignCommand>\r
+ </PropertyGroup>\r
+\r
+ <Target Name="_SignBuild" AfterTargets="AfterBuild" Condition="'$(SigningCertificate)' != '' and $(SupportSigning)">\r
+ <Error Text="Unable to locate signtool.exe. Set /p:SignToolPath and rebuild" Condition="'$(_SignCommand)' == ''" />\r
+ <Exec Command='$(_SignCommand) "$(TargetPath)" || $(_SignCommand) "$(TargetPath)" || $(_SignCommand) "$(TargetPath)"' ContinueOnError="false" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <PropertyGroup>
- <Platform Condition="'$(Platform)' == ''">Win32</Platform>
- <Configuration Condition="'$(Configuration)' == ''">Release</Configuration>
- <!--
- Use only MSVC 9.0, unless explicitly overridden
- -->
- <PlatformToolset Condition="'$(PlatformToolset)' == ''">v90</PlatformToolset>
- <!--
- Give a default for BasePlatformToolset as well, it's used by ICC and ignored otherwise
- -->
- <BasePlatformToolset Condition="'$(BasePlatformToolset)' == '' and '$(PlatformToolset)' != 'v90'">v90</BasePlatformToolset>
- <ICCBuild>false</ICCBuild>
- <ICCBuild Condition="$(PlatformToolset.StartsWith('Intel C++ Compiler'))">true</ICCBuild>
- <!--
- Convincing MSVC/MSBuild to prefer our platform names is too difficult,
- so we define our own constant ArchName and use wherever we need it.
- -->
- <ArchName Condition="'$(ArchName)' == '' and $(Platform) == 'x64'">amd64</ArchName>
- <ArchName Condition="'$(ArchName)' == ''">win32</ArchName>
- <ArchName Condition="$(Configuration) == 'PGInstrument' or $(Configuration) == 'PGUpdate'">$(ArchName)-pgo</ArchName>
-
- <!-- Root directory of the repository -->
- <PySourcePath Condition="'$(PySourcePath)' == ''">$([System.IO.Path]::GetFullPath($(MSBuildThisFileDirectory)\..\))</PySourcePath>
- <PySourcePath Condition="!HasTrailingSlash($(PySourcePath))">$(PySourcePath)\</PySourcePath>
-
- <!-- Directory where build outputs are put -->
- <BuildPath Condition="'$(BuildPath)' == ''">$(PySourcePath)PCBuild\</BuildPath>
- <BuildPath Condition="'$(ArchName)' != 'win32'">$(BuildPath)\$(ArchName)\</BuildPath>
- <BuildPath Condition="!HasTrailingSlash($(BuildPath))">$(BuildPath)\</BuildPath>
-
- <!-- Directories of external projects. tcltk is handled in tcltk.props -->
- <ExternalsDir>$([System.IO.Path]::GetFullPath(`$(PySourcePath)externals\`))</ExternalsDir>
- <sqlite3Dir>$(ExternalsDir)sqlite-3.8.11.0\</sqlite3Dir>
- <bz2Dir>$(ExternalsDir)bzip2-1.0.6\</bz2Dir>
- <bsddbDir>$(ExternalsDir)db-4.7.25.0</bsddbDir>
- <opensslDir>$(ExternalsDir)openssl-1.0.2j\</opensslDir>
- <opensslIncludeDir>$(opensslDir)include32</opensslIncludeDir>
- <opensslIncludeDir Condition="'$(ArchName)' == 'amd64'">$(opensslDir)include64</opensslIncludeDir>
- <nasmDir>$(ExternalsDir)\nasm-2.11.06\</nasmDir>
-
- <!-- Suffix for all binaries when building for debug -->
- <PyDebugExt Condition="'$(PyDebugExt)' == '' and $(Configuration) == 'Debug'">_d</PyDebugExt>
-
- <!-- Full path of the resulting python.exe binary -->
- <PythonExe Condition="'$(PythonExe)' == ''">$(BuildPath)python$(PyDebugExt).exe</PythonExe>
-
- <!--
- Read version information from Include\patchlevel.h. The following properties are set:
-
- MajorVersionNumber - the '3' in '3.5.2a1'
- MinorVersionNumber - the '5' in '3.5.2a1'
- MicroVersionNumber - the '2' in '3.5.2a1'
- ReleaseSerial - the '1' in '3.5.2a1'
- ReleaseLevelName - the 'a1' in '3.5.2a1'
- PythonVersionNumber - '3.5.2' for '3.5.2a1'
- PythonVersion - '3.5.2a1'
- PythonVersionHex - 0x030502a1 for '3.5.2a1'
- ReleaseLevelNumber - 10 for alpha, 11 for beta, 12 for RC (gamma), and 15 for final
- Field3Value - 2101 for '3.5.2a1' (== 1000*2 + 10*10 ('a') + 1)
- -->
- <_PatchLevelContent>$([System.IO.File]::ReadAllText(`$(PySourcePath)Include\patchlevel.h`))</_PatchLevelContent>
- <MajorVersionNumber>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_MAJOR_VERSION\s+(\d+)`).Groups[1].Value)</MajorVersionNumber>
- <MinorVersionNumber>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_MINOR_VERSION\s+(\d+)`).Groups[1].Value)</MinorVersionNumber>
- <MicroVersionNumber>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_MICRO_VERSION\s+(\d+)`).Groups[1].Value)</MicroVersionNumber>
- <_ReleaseLevel>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_RELEASE_LEVEL\s+PY_RELEASE_LEVEL_(\w+)`).Groups[1].Value)</_ReleaseLevel>
- <ReleaseSerial>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_RELEASE_SERIAL\s+(\d+)`).Groups[1].Value)</ReleaseSerial>
- <ReleaseLevelNumber>15</ReleaseLevelNumber>
- <ReleaseLevelNumber Condition="$(_ReleaseLevel) == 'ALPHA'">10</ReleaseLevelNumber>
- <ReleaseLevelNumber Condition="$(_ReleaseLevel) == 'BETA'">11</ReleaseLevelNumber>
- <ReleaseLevelNumber Condition="$(_ReleaseLevel) == 'GAMMA'">12</ReleaseLevelNumber>
- <ReleaseLevelName Condition="$(_ReleaseLevel) == 'ALPHA'">a$(ReleaseSerial)</ReleaseLevelName>
- <ReleaseLevelName Condition="$(_ReleaseLevel) == 'BETA'">b$(ReleaseSerial)</ReleaseLevelName>
- <ReleaseLevelName Condition="$(_ReleaseLevel) == 'GAMMA'">rc$(ReleaseSerial)</ReleaseLevelName>
-
- <PythonVersionNumber>$(MajorVersionNumber).$(MinorVersionNumber).$(MicroVersionNumber)</PythonVersionNumber>
- <PythonVersion>$(MajorVersionNumber).$(MinorVersionNumber).$(MicroVersionNumber)$(ReleaseLevelName)</PythonVersion>
- <PythonVersionHex>$([msbuild]::BitwiseOr(
- $([msbuild]::Multiply($(MajorVersionNumber), 16777216)),
- $([msbuild]::BitwiseOr(
- $([msbuild]::Multiply($(MinorVersionNumber), 65536)),
- $([msbuild]::BitwiseOr(
- $([msbuild]::Multiply($(MicroVersionNumber), 256)),
- $([msbuild]::BitwiseOr(
- $([msbuild]::Multiply($(ReleaseLevelNumber), 16)),
- $(ReleaseSerial)
- ))
- ))
- ))
- ))</PythonVersionHex>
- <Field3Value>$([msbuild]::Add(
- $(ReleaseSerial),
- $([msbuild]::Add(
- $([msbuild]::Multiply($(ReleaseLevelNumber), 10)),
- $([msbuild]::Multiply($(MicroVersionNumber), 1000))
- ))
- ))</Field3Value>
-
- <!-- The name of the resulting pythonXY.dll (without the extension) -->
- <PyDllName>python$(MajorVersionNumber)$(MinorVersionNumber)$(PyDebugExt)</PyDllName>
-
- <!-- The version and platform tag to include in .pyd filenames -->
- <PydTag Condition="$(Platform) == 'Win32' or $(Platform) == 'x86'">.cp$(MajorVersionNumber)$(MinorVersionNumber)-win32</PydTag>
- <PydTag Condition="$(Platform) == 'x64'">.cp$(MajorVersionNumber)$(MinorVersionNumber)-win_amd64</PydTag>
-
- <!-- The version number for sys.winver -->
- <SysWinVer>$(MajorVersionNumber).$(MinorVersionNumber)</SysWinVer>
- </PropertyGroup>
-
- <!-- Displays the calculated version info -->
- <Target Name="ShowVersionInfo">
- <Message Importance="high" Text="PythonVersionNumber: $(PythonVersionNumber)" />
- <Message Importance="high" Text="PythonVersion: $(PythonVersion)" />
- <Message Importance="high" Text="$([System.String]::Format(`PythonVersionHex: 0x{0:x}`, $([System.UInt32]::Parse($(PythonVersionHex)))))" />
- <Message Importance="high" Text="Field3Value: $(Field3Value)" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <Platform Condition="'$(Platform)' == ''">Win32</Platform>\r
+ <Configuration Condition="'$(Configuration)' == ''">Release</Configuration>\r
+ <!--\r
+ Use only MSVC 9.0, unless explicitly overridden\r
+ -->\r
+ <PlatformToolset Condition="'$(PlatformToolset)' == ''">v90</PlatformToolset>\r
+ <!--\r
+ Give a default for BasePlatformToolset as well, it's used by ICC and ignored otherwise\r
+ -->\r
+ <BasePlatformToolset Condition="'$(BasePlatformToolset)' == '' and '$(PlatformToolset)' != 'v90'">v90</BasePlatformToolset>\r
+ <ICCBuild>false</ICCBuild>\r
+ <ICCBuild Condition="$(PlatformToolset.StartsWith('Intel C++ Compiler'))">true</ICCBuild>\r
+ <!--\r
+ Convincing MSVC/MSBuild to prefer our platform names is too difficult,\r
+ so we define our own constant ArchName and use wherever we need it.\r
+ -->\r
+ <ArchName Condition="'$(ArchName)' == '' and $(Platform) == 'x64'">amd64</ArchName>\r
+ <ArchName Condition="'$(ArchName)' == ''">win32</ArchName>\r
+ <ArchName Condition="$(Configuration) == 'PGInstrument' or $(Configuration) == 'PGUpdate'">$(ArchName)-pgo</ArchName>\r
+\r
+ <!-- Root directory of the repository -->\r
+ <PySourcePath Condition="'$(PySourcePath)' == ''">$([System.IO.Path]::GetFullPath($(MSBuildThisFileDirectory)\..\))</PySourcePath>\r
+ <PySourcePath Condition="!HasTrailingSlash($(PySourcePath))">$(PySourcePath)\</PySourcePath>\r
+\r
+ <!-- Directory where build outputs are put -->\r
+ <BuildPath Condition="'$(BuildPath)' == ''">$(PySourcePath)PCBuild\</BuildPath>\r
+ <BuildPath Condition="'$(ArchName)' != 'win32'">$(BuildPath)\$(ArchName)\</BuildPath>\r
+ <BuildPath Condition="!HasTrailingSlash($(BuildPath))">$(BuildPath)\</BuildPath>\r
+\r
+ <!-- Directories of external projects. tcltk is handled in tcltk.props -->\r
+ <ExternalsDir>$([System.IO.Path]::GetFullPath(`$(PySourcePath)externals\`))</ExternalsDir>\r
+ <sqlite3Dir>$(ExternalsDir)sqlite-3.8.11.0\</sqlite3Dir>\r
+ <bz2Dir>$(ExternalsDir)bzip2-1.0.6\</bz2Dir>\r
+ <bsddbDir>$(ExternalsDir)db-4.7.25.0</bsddbDir>\r
+ <opensslDir>$(ExternalsDir)openssl-1.0.2k\</opensslDir>\r
+ <opensslIncludeDir>$(opensslDir)include32</opensslIncludeDir>\r
+ <opensslIncludeDir Condition="'$(ArchName)' == 'amd64'">$(opensslDir)include64</opensslIncludeDir>\r
+ <nasmDir>$(ExternalsDir)\nasm-2.11.06\</nasmDir>\r
+\r
+ <!-- Suffix for all binaries when building for debug -->\r
+ <PyDebugExt Condition="'$(PyDebugExt)' == '' and $(Configuration) == 'Debug'">_d</PyDebugExt>\r
+\r
+ <!-- Full path of the resulting python.exe binary -->\r
+ <PythonExe Condition="'$(PythonExe)' == ''">$(BuildPath)python$(PyDebugExt).exe</PythonExe>\r
+\r
+ <!--\r
+ Read version information from Include\patchlevel.h. The following properties are set:\r
+\r
+ MajorVersionNumber - the '3' in '3.5.2a1'\r
+ MinorVersionNumber - the '5' in '3.5.2a1'\r
+ MicroVersionNumber - the '2' in '3.5.2a1'\r
+ ReleaseSerial - the '1' in '3.5.2a1'\r
+ ReleaseLevelName - the 'a1' in '3.5.2a1'\r
+ PythonVersionNumber - '3.5.2' for '3.5.2a1'\r
+ PythonVersion - '3.5.2a1'\r
+ PythonVersionHex - 0x030502a1 for '3.5.2a1'\r
+ ReleaseLevelNumber - 10 for alpha, 11 for beta, 12 for RC (gamma), and 15 for final\r
+ Field3Value - 2101 for '3.5.2a1' (== 1000*2 + 10*10 ('a') + 1)\r
+ -->\r
+ <_PatchLevelContent>$([System.IO.File]::ReadAllText(`$(PySourcePath)Include\patchlevel.h`))</_PatchLevelContent>\r
+ <MajorVersionNumber>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_MAJOR_VERSION\s+(\d+)`).Groups[1].Value)</MajorVersionNumber>\r
+ <MinorVersionNumber>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_MINOR_VERSION\s+(\d+)`).Groups[1].Value)</MinorVersionNumber>\r
+ <MicroVersionNumber>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_MICRO_VERSION\s+(\d+)`).Groups[1].Value)</MicroVersionNumber>\r
+ <_ReleaseLevel>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_RELEASE_LEVEL\s+PY_RELEASE_LEVEL_(\w+)`).Groups[1].Value)</_ReleaseLevel>\r
+ <ReleaseSerial>$([System.Text.RegularExpressions.Regex]::Match($(_PatchLevelContent), `define\s+PY_RELEASE_SERIAL\s+(\d+)`).Groups[1].Value)</ReleaseSerial>\r
+ <ReleaseLevelNumber>15</ReleaseLevelNumber>\r
+ <ReleaseLevelNumber Condition="$(_ReleaseLevel) == 'ALPHA'">10</ReleaseLevelNumber>\r
+ <ReleaseLevelNumber Condition="$(_ReleaseLevel) == 'BETA'">11</ReleaseLevelNumber>\r
+ <ReleaseLevelNumber Condition="$(_ReleaseLevel) == 'GAMMA'">12</ReleaseLevelNumber>\r
+ <ReleaseLevelName Condition="$(_ReleaseLevel) == 'ALPHA'">a$(ReleaseSerial)</ReleaseLevelName>\r
+ <ReleaseLevelName Condition="$(_ReleaseLevel) == 'BETA'">b$(ReleaseSerial)</ReleaseLevelName>\r
+ <ReleaseLevelName Condition="$(_ReleaseLevel) == 'GAMMA'">rc$(ReleaseSerial)</ReleaseLevelName>\r
+\r
+ <PythonVersionNumber>$(MajorVersionNumber).$(MinorVersionNumber).$(MicroVersionNumber)</PythonVersionNumber>\r
+ <PythonVersion>$(MajorVersionNumber).$(MinorVersionNumber).$(MicroVersionNumber)$(ReleaseLevelName)</PythonVersion>\r
+ <PythonVersionHex>$([msbuild]::BitwiseOr(\r
+ $([msbuild]::Multiply($(MajorVersionNumber), 16777216)),\r
+ $([msbuild]::BitwiseOr(\r
+ $([msbuild]::Multiply($(MinorVersionNumber), 65536)),\r
+ $([msbuild]::BitwiseOr(\r
+ $([msbuild]::Multiply($(MicroVersionNumber), 256)),\r
+ $([msbuild]::BitwiseOr(\r
+ $([msbuild]::Multiply($(ReleaseLevelNumber), 16)),\r
+ $(ReleaseSerial)\r
+ ))\r
+ ))\r
+ ))\r
+ ))</PythonVersionHex>\r
+ <Field3Value>$([msbuild]::Add(\r
+ $(ReleaseSerial),\r
+ $([msbuild]::Add(\r
+ $([msbuild]::Multiply($(ReleaseLevelNumber), 10)),\r
+ $([msbuild]::Multiply($(MicroVersionNumber), 1000))\r
+ ))\r
+ ))</Field3Value>\r
+\r
+ <!-- The name of the resulting pythonXY.dll (without the extension) -->\r
+ <PyDllName>python$(MajorVersionNumber)$(MinorVersionNumber)$(PyDebugExt)</PyDllName>\r
+\r
+ <!-- The version and platform tag to include in .pyd filenames -->\r
+ <PydTag Condition="$(Platform) == 'Win32' or $(Platform) == 'x86'">.cp$(MajorVersionNumber)$(MinorVersionNumber)-win32</PydTag>\r
+ <PydTag Condition="$(Platform) == 'x64'">.cp$(MajorVersionNumber)$(MinorVersionNumber)-win_amd64</PydTag>\r
+\r
+ <!-- The version number for sys.winver -->\r
+ <SysWinVer>$(MajorVersionNumber).$(MinorVersionNumber)</SysWinVer>\r
+ </PropertyGroup>\r
+\r
+ <!-- Displays the calculated version info -->\r
+ <Target Name="ShowVersionInfo">\r
+ <Message Importance="high" Text="PythonVersionNumber: $(PythonVersionNumber)" />\r
+ <Message Importance="high" Text="PythonVersion: $(PythonVersion)" />\r
+ <Message Importance="high" Text="$([System.String]::Format(`PythonVersionHex: 0x{0:x}`, $([System.UInt32]::Parse($(PythonVersionHex)))))" />\r
+ <Message Importance="high" Text="Field3Value: $(Field3Value)" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{B11D750F-CD1F-4A96-85CE-E69A5C5259F9}</ProjectGuid>
- <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>Application</ConfigurationType>
- <UseOfMfc>false</UseOfMfc>
- <CharacterSet>MultiByte</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- <!-- For VS2008, we have to embed the manifest to be able to run -->
- <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>
- <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <PreprocessorDefinitions>_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <SubSystem>Console</SubSystem>
- <StackReserveSize>2000000</StackReserveSize>
- <BaseAddress>0x1d000000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <None Include="..\PC\pycon.ico" />
- </ItemGroup>
- <ItemGroup>
- <ResourceCompile Include="..\PC\python_exe.rc" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\python.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="w9xpopen.vcxproj">
- <Project>{e9e0a1f6-0009-4e8c-b8f8-1b8f5d49a058}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
- <Target Name="GeneratePythonBat" AfterTargets="AfterBuild">
- <PropertyGroup>
- <_Content>@rem This script invokes the most recently built Python with all arguments
-@rem passed through to the interpreter. This file is generated by the
-@rem build process and any changes *will* be thrown away by the next
-@rem rebuild.
-@rem This is only meant as a convenience for developing CPython
-@rem and using it outside of that context is ill-advised.
-@echo Running $(Configuration)^|$(Platform) interpreter...
-@"$(OutDir)python$(PyDebugExt).exe" %*
-</_Content>
- <_ExistingContent Condition="Exists('$(PySourcePath)python.bat')">$([System.IO.File]::ReadAllText('$(PySourcePath)python.bat'))</_ExistingContent>
- </PropertyGroup>
- <WriteLinesToFile File="$(PySourcePath)python.bat" Lines="$(_Content)" Overwrite="true" Condition="'$(_Content)' != '$(_ExistingContent)'" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{B11D750F-CD1F-4A96-85CE-E69A5C5259F9}</ProjectGuid>\r
+ <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>Application</ConfigurationType>\r
+ <UseOfMfc>false</UseOfMfc>\r
+ <CharacterSet>MultiByte</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ <!-- For VS2008, we have to embed the manifest to be able to run -->\r
+ <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>\r
+ <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <PreprocessorDefinitions>_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Console</SubSystem>\r
+ <StackReserveSize>2000000</StackReserveSize>\r
+ <BaseAddress>0x1d000000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <None Include="..\PC\pycon.ico" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="..\PC\python_exe.rc" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\python.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="w9xpopen.vcxproj">\r
+ <Project>{e9e0a1f6-0009-4e8c-b8f8-1b8f5d49a058}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+ <Target Name="GeneratePythonBat" AfterTargets="AfterBuild">\r
+ <PropertyGroup>\r
+ <_Content>@rem This script invokes the most recently built Python with all arguments\r
+@rem passed through to the interpreter. This file is generated by the\r
+@rem build process and any changes *will* be thrown away by the next\r
+@rem rebuild.\r
+@rem This is only meant as a convenience for developing CPython\r
+@rem and using it outside of that context is ill-advised.\r
+@echo Running $(Configuration)^|$(Platform) interpreter...\r
+@"$(OutDir)python$(PyDebugExt).exe" %*\r
+</_Content>\r
+ <_ExistingContent Condition="Exists('$(PySourcePath)python.bat')">$([System.IO.File]::ReadAllText('$(PySourcePath)python.bat'))</_ExistingContent>\r
+ </PropertyGroup>\r
+ <WriteLinesToFile File="$(PySourcePath)python.bat" Lines="$(_Content)" Overwrite="true" Condition="'$(_Content)' != '$(_ExistingContent)'" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Resource Files">
- <UniqueIdentifier>{2d690795-de83-4a33-8235-3c5dafe45efa}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{8b010a19-5b29-45f1-a8a0-f672e2bbb11a}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <None Include="..\PC\pycon.ico">
- <Filter>Resource Files</Filter>
- </None>
- </ItemGroup>
- <ItemGroup>
- <ResourceCompile Include="..\PC\python_exe.rc">
- <Filter>Resource Files</Filter>
- </ResourceCompile>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\python.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Resource Files">\r
+ <UniqueIdentifier>{2d690795-de83-4a33-8235-3c5dafe45efa}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{8b010a19-5b29-45f1-a8a0-f672e2bbb11a}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <None Include="..\PC\pycon.ico">\r
+ <Filter>Resource Files</Filter>\r
+ </None>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="..\PC\python_exe.rc">\r
+ <Filter>Resource Files</Filter>\r
+ </ResourceCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\python.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{CF7AC3D1-E2DF-41D2-BEA6-1E2556CDEA26}</ProjectGuid>
- <RootNamespace>pythoncore</RootNamespace>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <UseOfMfc>false</UseOfMfc>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <PropertyGroup>
- <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>
- <KillPython>true</KillPython>
- </PropertyGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- <TargetName>$(PyDllName)</TargetName>
- <!-- For VS2008, we have to embed the manifest to be able to run -->
- <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>
- <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>
- </PropertyGroup>
- <PropertyGroup>
- <CustomBuildBeforeTargets>Link</CustomBuildBeforeTargets>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalOptions>/Zm200 %(AdditionalOptions)</AdditionalOptions>
- <AdditionalIncludeDirectories>$(PySourcePath)Python;$(PySourcePath)Modules\zlib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>_USRDLL;Py_BUILD_CORE;Py_ENABLE_SHARED;MS_DLL_ID="$(SysWinVer)";%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <BaseAddress>0x1e000000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Include\abstract.h" />
- <ClInclude Include="..\Include\asdl.h" />
- <ClInclude Include="..\Include\ast.h" />
- <ClInclude Include="..\Include\bitset.h" />
- <ClInclude Include="..\Include\boolobject.h" />
- <ClInclude Include="..\Include\bufferobject.h" />
- <ClInclude Include="..\Include\bytes_methods.h" />
- <ClInclude Include="..\Include\bytearrayobject.h" />
- <ClInclude Include="..\Include\bytesobject.h" />
- <ClInclude Include="..\Include\cellobject.h" />
- <ClInclude Include="..\Include\ceval.h" />
- <ClInclude Include="..\Include\classobject.h" />
- <ClInclude Include="..\Include\cobject.h" />
- <ClInclude Include="..\Include\code.h" />
- <ClInclude Include="..\Include\codecs.h" />
- <ClInclude Include="..\Include\compile.h" />
- <ClInclude Include="..\Include\complexobject.h" />
- <ClInclude Include="..\Include\cStringIO.h" />
- <ClInclude Include="..\Include\datetime.h" />
- <ClInclude Include="..\Include\descrobject.h" />
- <ClInclude Include="..\Include\dictobject.h" />
- <ClInclude Include="..\Include\dtoa.h" />
- <ClInclude Include="..\Include\enumobject.h" />
- <ClInclude Include="..\Include\errcode.h" />
- <ClInclude Include="..\Include\eval.h" />
- <ClInclude Include="..\Include\fileobject.h" />
- <ClInclude Include="..\Include\floatobject.h" />
- <ClInclude Include="..\Include\frameobject.h" />
- <ClInclude Include="..\Include\funcobject.h" />
- <ClInclude Include="..\Include\genobject.h" />
- <ClInclude Include="..\Include\graminit.h" />
- <ClInclude Include="..\Include\grammar.h" />
- <ClInclude Include="..\Include\import.h" />
- <ClInclude Include="..\Include\intobject.h" />
- <ClInclude Include="..\Include\intrcheck.h" />
- <ClInclude Include="..\Include\iterobject.h" />
- <ClInclude Include="..\Include\listobject.h" />
- <ClInclude Include="..\Include\longintrepr.h" />
- <ClInclude Include="..\Include\longobject.h" />
- <ClInclude Include="..\Include\marshal.h" />
- <ClInclude Include="..\Include\memoryobject.h" />
- <ClInclude Include="..\Include\metagrammar.h" />
- <ClInclude Include="..\Include\methodobject.h" />
- <ClInclude Include="..\Include\modsupport.h" />
- <ClInclude Include="..\Include\moduleobject.h" />
- <ClInclude Include="..\Include\node.h" />
- <ClInclude Include="..\Include\object.h" />
- <ClInclude Include="..\Include\objimpl.h" />
- <ClInclude Include="..\Include\opcode.h" />
- <ClInclude Include="..\Include\osdefs.h" />
- <ClInclude Include="..\Include\parsetok.h" />
- <ClInclude Include="..\Include\patchlevel.h" />
- <ClInclude Include="..\Include\pgen.h" />
- <ClInclude Include="..\Include\pgenheaders.h" />
- <ClInclude Include="..\Include\py_curses.h" />
- <ClInclude Include="..\Include\pyarena.h" />
- <ClInclude Include="..\Include\pycapsule.h" />
- <ClInclude Include="..\Include\pyctype.h" />
- <ClInclude Include="..\Include\pydebug.h" />
- <ClInclude Include="..\Include\pyerrors.h" />
- <ClInclude Include="..\Include\pyexpat.h" />
- <ClInclude Include="..\Include\pyfpe.h" />
- <ClInclude Include="..\Include\pygetopt.h" />
- <ClInclude Include="..\Include\pymactoolbox.h" />
- <ClInclude Include="..\Include\pymath.h" />
- <ClInclude Include="..\Include\pymem.h" />
- <ClInclude Include="..\Include\pyport.h" />
- <ClInclude Include="..\Include\pystate.h" />
- <ClInclude Include="..\Include\pystrcmp.h" />
- <ClInclude Include="..\Include\pystrtod.h" />
- <ClInclude Include="..\Include\Python-ast.h" />
- <ClInclude Include="..\Include\Python.h" />
- <ClInclude Include="..\Include\pythonrun.h" />
- <ClInclude Include="..\Include\pythread.h" />
- <ClInclude Include="..\Include\rangeobject.h" />
- <ClInclude Include="..\Include\setobject.h" />
- <ClInclude Include="..\Include\sliceobject.h" />
- <ClInclude Include="..\Include\stringobject.h" />
- <ClInclude Include="..\Include\structmember.h" />
- <ClInclude Include="..\Include\structseq.h" />
- <ClInclude Include="..\Include\symtable.h" />
- <ClInclude Include="..\Include\sysmodule.h" />
- <ClInclude Include="..\Include\timefuncs.h" />
- <ClInclude Include="..\Include\token.h" />
- <ClInclude Include="..\Include\traceback.h" />
- <ClInclude Include="..\Include\tupleobject.h" />
- <ClInclude Include="..\Include\ucnhash.h" />
- <ClInclude Include="..\Include\unicodeobject.h" />
- <ClInclude Include="..\Include\weakrefobject.h" />
- <ClInclude Include="..\Modules\_math.h" />
- <ClInclude Include="..\Modules\md5.h" />
- <ClInclude Include="..\Modules\rotatingtree.h" />
- <ClInclude Include="..\Modules\zlib\crc32.h" />
- <ClInclude Include="..\Modules\zlib\deflate.h" />
- <ClInclude Include="..\Modules\zlib\inffast.h" />
- <ClInclude Include="..\Modules\zlib\inffixed.h" />
- <ClInclude Include="..\Modules\zlib\inflate.h" />
- <ClInclude Include="..\Modules\zlib\inftrees.h" />
- <ClInclude Include="..\Modules\zlib\trees.h" />
- <ClInclude Include="..\Modules\zlib\zconf.h" />
- <ClInclude Include="..\Modules\zlib\zconf.in.h" />
- <ClInclude Include="..\Modules\zlib\zlib.h" />
- <ClInclude Include="..\Modules\zlib\zutil.h" />
- <ClInclude Include="..\Modules\cjkcodecs\alg_jisx0201.h" />
- <ClInclude Include="..\Modules\cjkcodecs\cjkcodecs.h" />
- <ClInclude Include="..\Modules\cjkcodecs\emu_jisx0213_2000.h" />
- <ClInclude Include="..\Modules\cjkcodecs\mappings_cn.h" />
- <ClInclude Include="..\Modules\cjkcodecs\mappings_hk.h" />
- <ClInclude Include="..\Modules\cjkcodecs\mappings_jisx0213_pair.h" />
- <ClInclude Include="..\Modules\cjkcodecs\mappings_jp.h" />
- <ClInclude Include="..\Modules\cjkcodecs\mappings_kr.h" />
- <ClInclude Include="..\Modules\cjkcodecs\mappings_tw.h" />
- <ClInclude Include="..\Modules\cjkcodecs\multibytecodec.h" />
- <ClInclude Include="..\Modules\_io\_iomodule.h" />
- <ClInclude Include="..\Objects\stringlib\count.h" />
- <ClInclude Include="..\Objects\stringlib\fastsearch.h" />
- <ClInclude Include="..\Objects\stringlib\find.h" />
- <ClInclude Include="..\Objects\stringlib\partition.h" />
- <ClInclude Include="..\Objects\stringlib\split.h" />
- <ClInclude Include="..\Objects\unicodetype_db.h" />
- <ClInclude Include="..\Parser\parser.h" />
- <ClInclude Include="..\Parser\tokenizer.h" />
- <ClInclude Include="..\PC\errmap.h" />
- <ClInclude Include="..\PC\pyconfig.h" />
- <ClInclude Include="..\Python\importdl.h" />
- <ClInclude Include="..\Python\thread_nt.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_bisectmodule.c" />
- <ClCompile Include="..\Modules\_codecsmodule.c" />
- <ClCompile Include="..\Modules\_collectionsmodule.c" />
- <ClCompile Include="..\Modules\_csv.c" />
- <ClCompile Include="..\Modules\_functoolsmodule.c" />
- <ClCompile Include="..\Modules\_heapqmodule.c" />
- <ClCompile Include="..\Modules\_hotshot.c" />
- <ClCompile Include="..\Modules\_json.c" />
- <ClCompile Include="..\Modules\_localemodule.c" />
- <ClCompile Include="..\Modules\_lsprof.c" />
- <ClCompile Include="..\Modules\_math.c" />
- <ClCompile Include="..\Modules\_randommodule.c" />
- <ClCompile Include="..\Modules\_sre.c" />
- <ClCompile Include="..\Modules\_struct.c" />
- <ClCompile Include="..\Modules\_weakref.c" />
- <ClCompile Include="..\Modules\arraymodule.c" />
- <ClCompile Include="..\Modules\audioop.c" />
- <ClCompile Include="..\Modules\binascii.c" />
- <ClCompile Include="..\Modules\cmathmodule.c" />
- <ClCompile Include="..\Modules\cPickle.c" />
- <ClCompile Include="..\Modules\cStringIO.c" />
- <ClCompile Include="..\Modules\datetimemodule.c" />
- <ClCompile Include="..\Modules\errnomodule.c" />
- <ClCompile Include="..\Modules\future_builtins.c" />
- <ClCompile Include="..\Modules\gcmodule.c" />
- <ClCompile Include="..\Modules\imageop.c" />
- <ClCompile Include="..\Modules\itertoolsmodule.c" />
- <ClCompile Include="..\Modules\main.c" />
- <ClCompile Include="..\Modules\mathmodule.c" />
- <ClCompile Include="..\Modules\md5.c" />
- <ClCompile Include="..\Modules\md5module.c" />
- <ClCompile Include="..\Modules\mmapmodule.c" />
- <ClCompile Include="..\Modules\operator.c" />
- <ClCompile Include="..\Modules\parsermodule.c" />
- <ClCompile Include="..\Modules\posixmodule.c" />
- <ClCompile Include="..\Modules\rotatingtree.c" />
- <ClCompile Include="..\Modules\sha256module.c" />
- <ClCompile Include="..\Modules\sha512module.c" />
- <ClCompile Include="..\Modules\shamodule.c" />
- <ClCompile Include="..\Modules\signalmodule.c" />
- <ClCompile Include="..\Modules\stropmodule.c" />
- <ClCompile Include="..\Modules\symtablemodule.c" />
- <ClCompile Include="..\Modules\threadmodule.c" />
- <ClCompile Include="..\Modules\timemodule.c" />
- <ClCompile Include="..\Modules\xxsubtype.c" />
- <ClCompile Include="..\Modules\zipimport.c" />
- <ClCompile Include="..\Modules\zlibmodule.c" />
- <ClCompile Include="..\Modules\zlib\adler32.c" />
- <ClCompile Include="..\Modules\zlib\compress.c" />
- <ClCompile Include="..\Modules\zlib\crc32.c" />
- <ClCompile Include="..\Modules\zlib\deflate.c" />
- <ClCompile Include="..\Modules\zlib\gzclose.c" />
- <ClCompile Include="..\Modules\zlib\gzlib.c" />
- <ClCompile Include="..\Modules\zlib\gzread.c" />
- <ClCompile Include="..\Modules\zlib\gzwrite.c" />
- <ClCompile Include="..\Modules\zlib\infback.c" />
- <ClCompile Include="..\Modules\zlib\inffast.c" />
- <ClCompile Include="..\Modules\zlib\inflate.c" />
- <ClCompile Include="..\Modules\zlib\inftrees.c" />
- <ClCompile Include="..\Modules\zlib\trees.c" />
- <ClCompile Include="..\Modules\zlib\uncompr.c" />
- <ClCompile Include="..\Modules\zlib\zutil.c" />
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_cn.c" />
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_hk.c" />
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_iso2022.c" />
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_jp.c" />
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_kr.c" />
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_tw.c" />
- <ClCompile Include="..\Modules\cjkcodecs\multibytecodec.c" />
- <ClCompile Include="..\Modules\_io\_iomodule.c" />
- <ClCompile Include="..\Modules\_io\bufferedio.c" />
- <ClCompile Include="..\Modules\_io\bytesio.c" />
- <ClCompile Include="..\Modules\_io\fileio.c" />
- <ClCompile Include="..\Modules\_io\iobase.c" />
- <ClCompile Include="..\Modules\_io\stringio.c" />
- <ClCompile Include="..\Modules\_io\textio.c" />
- <ClCompile Include="..\Objects\abstract.c" />
- <ClCompile Include="..\Objects\boolobject.c" />
- <ClCompile Include="..\Objects\bufferobject.c" />
- <ClCompile Include="..\Objects\bytes_methods.c" />
- <ClCompile Include="..\Objects\bytearrayobject.c" />
- <ClCompile Include="..\Objects\capsule.c" />
- <ClCompile Include="..\Objects\cellobject.c" />
- <ClCompile Include="..\Objects\classobject.c" />
- <ClCompile Include="..\Objects\cobject.c" />
- <ClCompile Include="..\Objects\codeobject.c" />
- <ClCompile Include="..\Objects\complexobject.c" />
- <ClCompile Include="..\Objects\descrobject.c" />
- <ClCompile Include="..\Objects\dictobject.c" />
- <ClCompile Include="..\Objects\enumobject.c" />
- <ClCompile Include="..\Objects\exceptions.c" />
- <ClCompile Include="..\Objects\fileobject.c" />
- <ClCompile Include="..\Objects\floatobject.c" />
- <ClCompile Include="..\Objects\frameobject.c" />
- <ClCompile Include="..\Objects\funcobject.c" />
- <ClCompile Include="..\Objects\genobject.c" />
- <ClCompile Include="..\Objects\intobject.c" />
- <ClCompile Include="..\Objects\iterobject.c" />
- <ClCompile Include="..\Objects\listobject.c" />
- <ClCompile Include="..\Objects\longobject.c" />
- <ClCompile Include="..\Objects\memoryobject.c" />
- <ClCompile Include="..\Objects\methodobject.c" />
- <ClCompile Include="..\Objects\moduleobject.c" />
- <ClCompile Include="..\Objects\object.c" />
- <ClCompile Include="..\Objects\obmalloc.c" />
- <ClCompile Include="..\Objects\rangeobject.c" />
- <ClCompile Include="..\Objects\setobject.c" />
- <ClCompile Include="..\Objects\sliceobject.c" />
- <ClCompile Include="..\Objects\stringobject.c" />
- <ClCompile Include="..\Objects\structseq.c" />
- <ClCompile Include="..\Objects\tupleobject.c" />
- <ClCompile Include="..\Objects\typeobject.c" />
- <ClCompile Include="..\Objects\unicodectype.c" />
- <ClCompile Include="..\Objects\unicodeobject.c" />
- <ClCompile Include="..\Objects\weakrefobject.c" />
- <ClCompile Include="..\Parser\acceler.c" />
- <ClCompile Include="..\Parser\bitset.c" />
- <ClCompile Include="..\Parser\firstsets.c" />
- <ClCompile Include="..\Parser\grammar.c" />
- <ClCompile Include="..\Parser\grammar1.c" />
- <ClCompile Include="..\Parser\listnode.c" />
- <ClCompile Include="..\Parser\metagrammar.c" />
- <ClCompile Include="..\Parser\myreadline.c" />
- <ClCompile Include="..\Parser\node.c" />
- <ClCompile Include="..\Parser\parser.c" />
- <ClCompile Include="..\Parser\parsetok.c" />
- <ClCompile Include="..\Parser\tokenizer.c" />
- <ClCompile Include="..\PC\_subprocess.c" />
- <ClCompile Include="..\PC\_winreg.c" />
- <ClCompile Include="..\PC\config.c" />
- <ClCompile Include="..\PC\dl_nt.c" />
- <ClCompile Include="..\PC\getpathp.c" />
- <ClCompile Include="..\PC\import_nt.c" />
- <ClCompile Include="..\PC\msvcrtmodule.c" />
- <ClCompile Include="..\Python\_warnings.c" />
- <ClCompile Include="..\Python\asdl.c" />
- <ClCompile Include="..\Python\ast.c" />
- <ClCompile Include="..\Python\bltinmodule.c" />
- <ClCompile Include="..\Python\ceval.c" />
- <ClCompile Include="..\Python\codecs.c" />
- <ClCompile Include="..\Python\compile.c" />
- <ClCompile Include="..\Python\dtoa.c" />
- <ClCompile Include="..\Python\dynload_win.c" />
- <ClCompile Include="..\Python\errors.c" />
- <ClCompile Include="..\Python\formatter_string.c" />
- <ClCompile Include="..\Python\formatter_unicode.c" />
- <ClCompile Include="..\Python\frozen.c" />
- <ClCompile Include="..\Python\future.c" />
- <ClCompile Include="..\Python\getargs.c" />
- <ClCompile Include="..\Python\getcompiler.c" />
- <ClCompile Include="..\Python\getcopyright.c" />
- <ClCompile Include="..\Python\getopt.c" />
- <ClCompile Include="..\Python\getplatform.c" />
- <ClCompile Include="..\Python\getversion.c" />
- <ClCompile Include="..\Python\graminit.c" />
- <ClCompile Include="..\Python\import.c" />
- <ClCompile Include="..\Python\importdl.c" />
- <ClCompile Include="..\Python\marshal.c" />
- <ClCompile Include="..\Python\modsupport.c" />
- <ClCompile Include="..\Python\mysnprintf.c" />
- <ClCompile Include="..\Python\mystrtoul.c" />
- <ClCompile Include="..\Python\peephole.c" />
- <ClCompile Include="..\Python\pyarena.c" />
- <ClCompile Include="..\Python\pyctype.c" />
- <ClCompile Include="..\Python\pyfpe.c" />
- <ClCompile Include="..\Python\pymath.c" />
- <ClCompile Include="..\Python\pystate.c" />
- <ClCompile Include="..\Python\pystrcmp.c" />
- <ClCompile Include="..\Python\pystrtod.c" />
- <ClCompile Include="..\Python\Python-ast.c" />
- <ClCompile Include="..\Python\pythonrun.c" />
- <ClCompile Include="..\Python\random.c" />
- <ClCompile Include="..\Python\structmember.c" />
- <ClCompile Include="..\Python\symtable.c" />
- <ClCompile Include="..\Python\sysmodule.c" />
- <ClCompile Include="..\Python\thread.c" />
- <ClCompile Include="..\Python\traceback.c" />
- </ItemGroup>
- <ItemGroup>
- <ResourceCompile Include="..\PC\python_nt.rc" />
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
- <Target Name="_GetBuildInfo" BeforeTargets="PrepareForBuild">
- <Exec Command="hg id -b > "$(IntDir)hgbranch.txt"" ContinueOnError="true" />
- <Exec Command="hg id -i > "$(IntDir)hgversion.txt"" ContinueOnError="true" />
- <Exec Command="hg id -t > "$(IntDir)hgtag.txt"" ContinueOnError="true" />
- <PropertyGroup>
- <HgBranch Condition="Exists('$(IntDir)hgbranch.txt')">$([System.IO.File]::ReadAllText('$(IntDir)hgbranch.txt').Trim())</HgBranch>
- <HgVersion Condition="Exists('$(IntDir)hgversion.txt')">$([System.IO.File]::ReadAllText('$(IntDir)hgversion.txt').Trim())</HgVersion>
- <HgTag Condition="Exists('$(IntDir)hgtag.txt')">$([System.IO.File]::ReadAllText('$(IntDir)hgtag.txt').Trim())</HgTag>
- </PropertyGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\getbuildinfo.c">
- <PreprocessorDefinitions>HGVERSION="$(HgVersion)";HGTAG="$(HgTag)";HGBRANCH="$(HgBranch)";%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- </ItemGroup>
- </Target>
- <Target Name="_WarnAboutToolset" BeforeTargets="PrepareForBuild" Condition="$(PlatformToolset) != 'v90'">
- <Warning Text="Toolset $(PlatformToolset) is not used for official builds. Your build may have errors or incompatibilities." />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{CF7AC3D1-E2DF-41D2-BEA6-1E2556CDEA26}</ProjectGuid>\r
+ <RootNamespace>pythoncore</RootNamespace>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <UseOfMfc>false</UseOfMfc>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <PropertyGroup>\r
+ <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>\r
+ <KillPython>true</KillPython>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ <TargetName>$(PyDllName)</TargetName>\r
+ <!-- For VS2008, we have to embed the manifest to be able to run -->\r
+ <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>\r
+ <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>\r
+ </PropertyGroup>\r
+ <PropertyGroup>\r
+ <CustomBuildBeforeTargets>Link</CustomBuildBeforeTargets>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalOptions>/Zm200 %(AdditionalOptions)</AdditionalOptions>\r
+ <AdditionalIncludeDirectories>$(PySourcePath)Python;$(PySourcePath)Modules\zlib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>_USRDLL;Py_BUILD_CORE;Py_ENABLE_SHARED;MS_DLL_ID="$(SysWinVer)";%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ <Link>\r
+ <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ <BaseAddress>0x1e000000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Include\abstract.h" />\r
+ <ClInclude Include="..\Include\asdl.h" />\r
+ <ClInclude Include="..\Include\ast.h" />\r
+ <ClInclude Include="..\Include\bitset.h" />\r
+ <ClInclude Include="..\Include\boolobject.h" />\r
+ <ClInclude Include="..\Include\bufferobject.h" />\r
+ <ClInclude Include="..\Include\bytes_methods.h" />\r
+ <ClInclude Include="..\Include\bytearrayobject.h" />\r
+ <ClInclude Include="..\Include\bytesobject.h" />\r
+ <ClInclude Include="..\Include\cellobject.h" />\r
+ <ClInclude Include="..\Include\ceval.h" />\r
+ <ClInclude Include="..\Include\classobject.h" />\r
+ <ClInclude Include="..\Include\cobject.h" />\r
+ <ClInclude Include="..\Include\code.h" />\r
+ <ClInclude Include="..\Include\codecs.h" />\r
+ <ClInclude Include="..\Include\compile.h" />\r
+ <ClInclude Include="..\Include\complexobject.h" />\r
+ <ClInclude Include="..\Include\cStringIO.h" />\r
+ <ClInclude Include="..\Include\datetime.h" />\r
+ <ClInclude Include="..\Include\descrobject.h" />\r
+ <ClInclude Include="..\Include\dictobject.h" />\r
+ <ClInclude Include="..\Include\dtoa.h" />\r
+ <ClInclude Include="..\Include\enumobject.h" />\r
+ <ClInclude Include="..\Include\errcode.h" />\r
+ <ClInclude Include="..\Include\eval.h" />\r
+ <ClInclude Include="..\Include\fileobject.h" />\r
+ <ClInclude Include="..\Include\floatobject.h" />\r
+ <ClInclude Include="..\Include\frameobject.h" />\r
+ <ClInclude Include="..\Include\funcobject.h" />\r
+ <ClInclude Include="..\Include\genobject.h" />\r
+ <ClInclude Include="..\Include\graminit.h" />\r
+ <ClInclude Include="..\Include\grammar.h" />\r
+ <ClInclude Include="..\Include\import.h" />\r
+ <ClInclude Include="..\Include\intobject.h" />\r
+ <ClInclude Include="..\Include\intrcheck.h" />\r
+ <ClInclude Include="..\Include\iterobject.h" />\r
+ <ClInclude Include="..\Include\listobject.h" />\r
+ <ClInclude Include="..\Include\longintrepr.h" />\r
+ <ClInclude Include="..\Include\longobject.h" />\r
+ <ClInclude Include="..\Include\marshal.h" />\r
+ <ClInclude Include="..\Include\memoryobject.h" />\r
+ <ClInclude Include="..\Include\metagrammar.h" />\r
+ <ClInclude Include="..\Include\methodobject.h" />\r
+ <ClInclude Include="..\Include\modsupport.h" />\r
+ <ClInclude Include="..\Include\moduleobject.h" />\r
+ <ClInclude Include="..\Include\node.h" />\r
+ <ClInclude Include="..\Include\object.h" />\r
+ <ClInclude Include="..\Include\objimpl.h" />\r
+ <ClInclude Include="..\Include\opcode.h" />\r
+ <ClInclude Include="..\Include\osdefs.h" />\r
+ <ClInclude Include="..\Include\parsetok.h" />\r
+ <ClInclude Include="..\Include\patchlevel.h" />\r
+ <ClInclude Include="..\Include\pgen.h" />\r
+ <ClInclude Include="..\Include\pgenheaders.h" />\r
+ <ClInclude Include="..\Include\py_curses.h" />\r
+ <ClInclude Include="..\Include\pyarena.h" />\r
+ <ClInclude Include="..\Include\pycapsule.h" />\r
+ <ClInclude Include="..\Include\pyctype.h" />\r
+ <ClInclude Include="..\Include\pydebug.h" />\r
+ <ClInclude Include="..\Include\pyerrors.h" />\r
+ <ClInclude Include="..\Include\pyexpat.h" />\r
+ <ClInclude Include="..\Include\pyfpe.h" />\r
+ <ClInclude Include="..\Include\pygetopt.h" />\r
+ <ClInclude Include="..\Include\pymactoolbox.h" />\r
+ <ClInclude Include="..\Include\pymath.h" />\r
+ <ClInclude Include="..\Include\pymem.h" />\r
+ <ClInclude Include="..\Include\pyport.h" />\r
+ <ClInclude Include="..\Include\pystate.h" />\r
+ <ClInclude Include="..\Include\pystrcmp.h" />\r
+ <ClInclude Include="..\Include\pystrtod.h" />\r
+ <ClInclude Include="..\Include\Python-ast.h" />\r
+ <ClInclude Include="..\Include\Python.h" />\r
+ <ClInclude Include="..\Include\pythonrun.h" />\r
+ <ClInclude Include="..\Include\pythread.h" />\r
+ <ClInclude Include="..\Include\rangeobject.h" />\r
+ <ClInclude Include="..\Include\setobject.h" />\r
+ <ClInclude Include="..\Include\sliceobject.h" />\r
+ <ClInclude Include="..\Include\stringobject.h" />\r
+ <ClInclude Include="..\Include\structmember.h" />\r
+ <ClInclude Include="..\Include\structseq.h" />\r
+ <ClInclude Include="..\Include\symtable.h" />\r
+ <ClInclude Include="..\Include\sysmodule.h" />\r
+ <ClInclude Include="..\Include\timefuncs.h" />\r
+ <ClInclude Include="..\Include\token.h" />\r
+ <ClInclude Include="..\Include\traceback.h" />\r
+ <ClInclude Include="..\Include\tupleobject.h" />\r
+ <ClInclude Include="..\Include\ucnhash.h" />\r
+ <ClInclude Include="..\Include\unicodeobject.h" />\r
+ <ClInclude Include="..\Include\weakrefobject.h" />\r
+ <ClInclude Include="..\Modules\_math.h" />\r
+ <ClInclude Include="..\Modules\md5.h" />\r
+ <ClInclude Include="..\Modules\rotatingtree.h" />\r
+ <ClInclude Include="..\Modules\zlib\crc32.h" />\r
+ <ClInclude Include="..\Modules\zlib\deflate.h" />\r
+ <ClInclude Include="..\Modules\zlib\inffast.h" />\r
+ <ClInclude Include="..\Modules\zlib\inffixed.h" />\r
+ <ClInclude Include="..\Modules\zlib\inflate.h" />\r
+ <ClInclude Include="..\Modules\zlib\inftrees.h" />\r
+ <ClInclude Include="..\Modules\zlib\trees.h" />\r
+ <ClInclude Include="..\Modules\zlib\zconf.h" />\r
+ <ClInclude Include="..\Modules\zlib\zconf.in.h" />\r
+ <ClInclude Include="..\Modules\zlib\zlib.h" />\r
+ <ClInclude Include="..\Modules\zlib\zutil.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\alg_jisx0201.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\cjkcodecs.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\emu_jisx0213_2000.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_cn.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_hk.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_jisx0213_pair.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_jp.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_kr.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_tw.h" />\r
+ <ClInclude Include="..\Modules\cjkcodecs\multibytecodec.h" />\r
+ <ClInclude Include="..\Modules\_io\_iomodule.h" />\r
+ <ClInclude Include="..\Objects\stringlib\count.h" />\r
+ <ClInclude Include="..\Objects\stringlib\fastsearch.h" />\r
+ <ClInclude Include="..\Objects\stringlib\find.h" />\r
+ <ClInclude Include="..\Objects\stringlib\partition.h" />\r
+ <ClInclude Include="..\Objects\stringlib\split.h" />\r
+ <ClInclude Include="..\Objects\unicodetype_db.h" />\r
+ <ClInclude Include="..\Parser\parser.h" />\r
+ <ClInclude Include="..\Parser\tokenizer.h" />\r
+ <ClInclude Include="..\PC\errmap.h" />\r
+ <ClInclude Include="..\PC\pyconfig.h" />\r
+ <ClInclude Include="..\Python\importdl.h" />\r
+ <ClInclude Include="..\Python\thread_nt.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_bisectmodule.c" />\r
+ <ClCompile Include="..\Modules\_codecsmodule.c" />\r
+ <ClCompile Include="..\Modules\_collectionsmodule.c" />\r
+ <ClCompile Include="..\Modules\_csv.c" />\r
+ <ClCompile Include="..\Modules\_functoolsmodule.c" />\r
+ <ClCompile Include="..\Modules\_heapqmodule.c" />\r
+ <ClCompile Include="..\Modules\_hotshot.c" />\r
+ <ClCompile Include="..\Modules\_json.c" />\r
+ <ClCompile Include="..\Modules\_localemodule.c" />\r
+ <ClCompile Include="..\Modules\_lsprof.c" />\r
+ <ClCompile Include="..\Modules\_math.c" />\r
+ <ClCompile Include="..\Modules\_randommodule.c" />\r
+ <ClCompile Include="..\Modules\_sre.c" />\r
+ <ClCompile Include="..\Modules\_struct.c" />\r
+ <ClCompile Include="..\Modules\_weakref.c" />\r
+ <ClCompile Include="..\Modules\arraymodule.c" />\r
+ <ClCompile Include="..\Modules\audioop.c" />\r
+ <ClCompile Include="..\Modules\binascii.c" />\r
+ <ClCompile Include="..\Modules\cmathmodule.c" />\r
+ <ClCompile Include="..\Modules\cPickle.c" />\r
+ <ClCompile Include="..\Modules\cStringIO.c" />\r
+ <ClCompile Include="..\Modules\datetimemodule.c" />\r
+ <ClCompile Include="..\Modules\errnomodule.c" />\r
+ <ClCompile Include="..\Modules\future_builtins.c" />\r
+ <ClCompile Include="..\Modules\gcmodule.c" />\r
+ <ClCompile Include="..\Modules\imageop.c" />\r
+ <ClCompile Include="..\Modules\itertoolsmodule.c" />\r
+ <ClCompile Include="..\Modules\main.c" />\r
+ <ClCompile Include="..\Modules\mathmodule.c" />\r
+ <ClCompile Include="..\Modules\md5.c" />\r
+ <ClCompile Include="..\Modules\md5module.c" />\r
+ <ClCompile Include="..\Modules\mmapmodule.c" />\r
+ <ClCompile Include="..\Modules\operator.c" />\r
+ <ClCompile Include="..\Modules\parsermodule.c" />\r
+ <ClCompile Include="..\Modules\posixmodule.c" />\r
+ <ClCompile Include="..\Modules\rotatingtree.c" />\r
+ <ClCompile Include="..\Modules\sha256module.c" />\r
+ <ClCompile Include="..\Modules\sha512module.c" />\r
+ <ClCompile Include="..\Modules\shamodule.c" />\r
+ <ClCompile Include="..\Modules\signalmodule.c" />\r
+ <ClCompile Include="..\Modules\stropmodule.c" />\r
+ <ClCompile Include="..\Modules\symtablemodule.c" />\r
+ <ClCompile Include="..\Modules\threadmodule.c" />\r
+ <ClCompile Include="..\Modules\timemodule.c" />\r
+ <ClCompile Include="..\Modules\xxsubtype.c" />\r
+ <ClCompile Include="..\Modules\zipimport.c" />\r
+ <ClCompile Include="..\Modules\zlibmodule.c" />\r
+ <ClCompile Include="..\Modules\zlib\adler32.c" />\r
+ <ClCompile Include="..\Modules\zlib\compress.c" />\r
+ <ClCompile Include="..\Modules\zlib\crc32.c" />\r
+ <ClCompile Include="..\Modules\zlib\deflate.c" />\r
+ <ClCompile Include="..\Modules\zlib\gzclose.c" />\r
+ <ClCompile Include="..\Modules\zlib\gzlib.c" />\r
+ <ClCompile Include="..\Modules\zlib\gzread.c" />\r
+ <ClCompile Include="..\Modules\zlib\gzwrite.c" />\r
+ <ClCompile Include="..\Modules\zlib\infback.c" />\r
+ <ClCompile Include="..\Modules\zlib\inffast.c" />\r
+ <ClCompile Include="..\Modules\zlib\inflate.c" />\r
+ <ClCompile Include="..\Modules\zlib\inftrees.c" />\r
+ <ClCompile Include="..\Modules\zlib\trees.c" />\r
+ <ClCompile Include="..\Modules\zlib\uncompr.c" />\r
+ <ClCompile Include="..\Modules\zlib\zutil.c" />\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_cn.c" />\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_hk.c" />\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_iso2022.c" />\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_jp.c" />\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_kr.c" />\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_tw.c" />\r
+ <ClCompile Include="..\Modules\cjkcodecs\multibytecodec.c" />\r
+ <ClCompile Include="..\Modules\_io\_iomodule.c" />\r
+ <ClCompile Include="..\Modules\_io\bufferedio.c" />\r
+ <ClCompile Include="..\Modules\_io\bytesio.c" />\r
+ <ClCompile Include="..\Modules\_io\fileio.c" />\r
+ <ClCompile Include="..\Modules\_io\iobase.c" />\r
+ <ClCompile Include="..\Modules\_io\stringio.c" />\r
+ <ClCompile Include="..\Modules\_io\textio.c" />\r
+ <ClCompile Include="..\Objects\abstract.c" />\r
+ <ClCompile Include="..\Objects\boolobject.c" />\r
+ <ClCompile Include="..\Objects\bufferobject.c" />\r
+ <ClCompile Include="..\Objects\bytes_methods.c" />\r
+ <ClCompile Include="..\Objects\bytearrayobject.c" />\r
+ <ClCompile Include="..\Objects\capsule.c" />\r
+ <ClCompile Include="..\Objects\cellobject.c" />\r
+ <ClCompile Include="..\Objects\classobject.c" />\r
+ <ClCompile Include="..\Objects\cobject.c" />\r
+ <ClCompile Include="..\Objects\codeobject.c" />\r
+ <ClCompile Include="..\Objects\complexobject.c" />\r
+ <ClCompile Include="..\Objects\descrobject.c" />\r
+ <ClCompile Include="..\Objects\dictobject.c" />\r
+ <ClCompile Include="..\Objects\enumobject.c" />\r
+ <ClCompile Include="..\Objects\exceptions.c" />\r
+ <ClCompile Include="..\Objects\fileobject.c" />\r
+ <ClCompile Include="..\Objects\floatobject.c" />\r
+ <ClCompile Include="..\Objects\frameobject.c" />\r
+ <ClCompile Include="..\Objects\funcobject.c" />\r
+ <ClCompile Include="..\Objects\genobject.c" />\r
+ <ClCompile Include="..\Objects\intobject.c" />\r
+ <ClCompile Include="..\Objects\iterobject.c" />\r
+ <ClCompile Include="..\Objects\listobject.c" />\r
+ <ClCompile Include="..\Objects\longobject.c" />\r
+ <ClCompile Include="..\Objects\memoryobject.c" />\r
+ <ClCompile Include="..\Objects\methodobject.c" />\r
+ <ClCompile Include="..\Objects\moduleobject.c" />\r
+ <ClCompile Include="..\Objects\object.c" />\r
+ <ClCompile Include="..\Objects\obmalloc.c" />\r
+ <ClCompile Include="..\Objects\rangeobject.c" />\r
+ <ClCompile Include="..\Objects\setobject.c" />\r
+ <ClCompile Include="..\Objects\sliceobject.c" />\r
+ <ClCompile Include="..\Objects\stringobject.c" />\r
+ <ClCompile Include="..\Objects\structseq.c" />\r
+ <ClCompile Include="..\Objects\tupleobject.c" />\r
+ <ClCompile Include="..\Objects\typeobject.c" />\r
+ <ClCompile Include="..\Objects\unicodectype.c" />\r
+ <ClCompile Include="..\Objects\unicodeobject.c" />\r
+ <ClCompile Include="..\Objects\weakrefobject.c" />\r
+ <ClCompile Include="..\Parser\acceler.c" />\r
+ <ClCompile Include="..\Parser\bitset.c" />\r
+ <ClCompile Include="..\Parser\firstsets.c" />\r
+ <ClCompile Include="..\Parser\grammar.c" />\r
+ <ClCompile Include="..\Parser\grammar1.c" />\r
+ <ClCompile Include="..\Parser\listnode.c" />\r
+ <ClCompile Include="..\Parser\metagrammar.c" />\r
+ <ClCompile Include="..\Parser\myreadline.c" />\r
+ <ClCompile Include="..\Parser\node.c" />\r
+ <ClCompile Include="..\Parser\parser.c" />\r
+ <ClCompile Include="..\Parser\parsetok.c" />\r
+ <ClCompile Include="..\Parser\tokenizer.c" />\r
+ <ClCompile Include="..\PC\_subprocess.c" />\r
+ <ClCompile Include="..\PC\_winreg.c" />\r
+ <ClCompile Include="..\PC\config.c" />\r
+ <ClCompile Include="..\PC\dl_nt.c" />\r
+ <ClCompile Include="..\PC\getpathp.c" />\r
+ <ClCompile Include="..\PC\import_nt.c" />\r
+ <ClCompile Include="..\PC\msvcrtmodule.c" />\r
+ <ClCompile Include="..\Python\_warnings.c" />\r
+ <ClCompile Include="..\Python\asdl.c" />\r
+ <ClCompile Include="..\Python\ast.c" />\r
+ <ClCompile Include="..\Python\bltinmodule.c" />\r
+ <ClCompile Include="..\Python\ceval.c" />\r
+ <ClCompile Include="..\Python\codecs.c" />\r
+ <ClCompile Include="..\Python\compile.c" />\r
+ <ClCompile Include="..\Python\dtoa.c" />\r
+ <ClCompile Include="..\Python\dynload_win.c" />\r
+ <ClCompile Include="..\Python\errors.c" />\r
+ <ClCompile Include="..\Python\formatter_string.c" />\r
+ <ClCompile Include="..\Python\formatter_unicode.c" />\r
+ <ClCompile Include="..\Python\frozen.c" />\r
+ <ClCompile Include="..\Python\future.c" />\r
+ <ClCompile Include="..\Python\getargs.c" />\r
+ <ClCompile Include="..\Python\getcompiler.c" />\r
+ <ClCompile Include="..\Python\getcopyright.c" />\r
+ <ClCompile Include="..\Python\getopt.c" />\r
+ <ClCompile Include="..\Python\getplatform.c" />\r
+ <ClCompile Include="..\Python\getversion.c" />\r
+ <ClCompile Include="..\Python\graminit.c" />\r
+ <ClCompile Include="..\Python\import.c" />\r
+ <ClCompile Include="..\Python\importdl.c" />\r
+ <ClCompile Include="..\Python\marshal.c" />\r
+ <ClCompile Include="..\Python\modsupport.c" />\r
+ <ClCompile Include="..\Python\mysnprintf.c" />\r
+ <ClCompile Include="..\Python\mystrtoul.c" />\r
+ <ClCompile Include="..\Python\peephole.c" />\r
+ <ClCompile Include="..\Python\pyarena.c" />\r
+ <ClCompile Include="..\Python\pyctype.c" />\r
+ <ClCompile Include="..\Python\pyfpe.c" />\r
+ <ClCompile Include="..\Python\pymath.c" />\r
+ <ClCompile Include="..\Python\pystate.c" />\r
+ <ClCompile Include="..\Python\pystrcmp.c" />\r
+ <ClCompile Include="..\Python\pystrtod.c" />\r
+ <ClCompile Include="..\Python\Python-ast.c" />\r
+ <ClCompile Include="..\Python\pythonrun.c" />\r
+ <ClCompile Include="..\Python\random.c" />\r
+ <ClCompile Include="..\Python\structmember.c" />\r
+ <ClCompile Include="..\Python\symtable.c" />\r
+ <ClCompile Include="..\Python\sysmodule.c" />\r
+ <ClCompile Include="..\Python\thread.c" />\r
+ <ClCompile Include="..\Python\traceback.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="..\PC\python_nt.rc" />\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+ <Target Name="_GetBuildInfo" BeforeTargets="PrepareForBuild">\r
+ <PropertyGroup>\r
+ <GIT Condition="$(GIT) == ''">git</GIT>\r
+ <_GIT>$(GIT)</_GIT>\r
+ <_GIT Condition="$(GIT.Contains(` `))">"$(GIT)"</_GIT>\r
+ </PropertyGroup>\r
+ <Message Text="Getting build info from $(_GIT)" Importance="high" />\r
+ <MakeDir Directories="$(IntDir)" Condition="!Exists($(IntDir))" />\r
+ <Exec Command="$(_GIT) name-rev --name-only HEAD > "$(IntDir)gitbranch.txt"" ContinueOnError="true" />\r
+ <Exec Command="$(_GIT) rev-parse --short HEAD > "$(IntDir)gitversion.txt"" ContinueOnError="true" />\r
+ <Exec Command="$(_GIT) describe --all --always --dirty > "$(IntDir)gittag.txt"" ContinueOnError="true" />\r
+ <PropertyGroup>\r
+ <GitBranch Condition="Exists('$(IntDir)gitbranch.txt')">$([System.IO.File]::ReadAllText('$(IntDir)gitbranch.txt').Trim())</GitBranch>\r
+ <GitVersion Condition="Exists('$(IntDir)gitversion.txt')">$([System.IO.File]::ReadAllText('$(IntDir)gitversion.txt').Trim())</GitVersion>\r
+ <GitTag Condition="Exists('$(IntDir)gittag.txt')">$([System.IO.File]::ReadAllText('$(IntDir)gittag.txt').Trim())</GitTag>\r
+ </PropertyGroup>\r
+ <Message Text="Building $(GitTag):$(GitVersion) $(GitBranch)" Importance="high" />\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\getbuildinfo.c">\r
+ <PreprocessorDefinitions>GITVERSION="$(GitVersion)";GITTAG="$(GitTag)";GITBRANCH="$(GitBranch)";%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ </Target>\r
+ <Target Name="_WarnAboutToolset" BeforeTargets="PrepareForBuild" Condition="$(PlatformToolset) != 'v90'">\r
+ <Warning Text="Toolset $(PlatformToolset) is not used for official builds. Your build may have errors or incompatibilities." />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Include">
- <UniqueIdentifier>{086b0afb-270c-4603-a02a-63d46f0b2b92}</UniqueIdentifier>
- </Filter>
- <Filter Include="Modules">
- <UniqueIdentifier>{8e81609f-13ca-4eae-9fdb-f8af20c710c7}</UniqueIdentifier>
- </Filter>
- <Filter Include="Modules\_io">
- <UniqueIdentifier>{8787c5bb-bab6-4586-a42e-4a27c7b3ffb6}</UniqueIdentifier>
- </Filter>
- <Filter Include="Modules\zlib">
- <UniqueIdentifier>{5d6d2d6c-9e61-4a1d-b0b2-5cc2f446d69e}</UniqueIdentifier>
- </Filter>
- <Filter Include="Modules\cjkcodecs">
- <UniqueIdentifier>{9f12c4b1-322e-431e-abf1-e02550f50032}</UniqueIdentifier>
- </Filter>
- <Filter Include="Objects">
- <UniqueIdentifier>{ab29a558-143d-4fe7-a039-b431fb429856}</UniqueIdentifier>
- </Filter>
- <Filter Include="Parser">
- <UniqueIdentifier>{97349fee-0abf-48b0-a8f5-771bf39b8aee}</UniqueIdentifier>
- </Filter>
- <Filter Include="PC">
- <UniqueIdentifier>{ea21fc98-de89-4746-a979-c5616964329a}</UniqueIdentifier>
- </Filter>
- <Filter Include="Python">
- <UniqueIdentifier>{f2696406-14bc-48bd-90c5-e93ab82a21ac}</UniqueIdentifier>
- </Filter>
- <Filter Include="Resource Files">
- <UniqueIdentifier>{c3e03a5c-56c7-45fd-8543-e5d2326b907d}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Include\abstract.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\asdl.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\ast.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\bitset.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\boolobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\bufferobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\bytes_methods.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\bytearrayobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\bytesobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\cellobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\ceval.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\classobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\cobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\code.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\codecs.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\compile.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\complexobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\cStringIO.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\datetime.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\descrobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\dictobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\dtoa.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\enumobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\errcode.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\eval.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\fileobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\floatobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\frameobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\funcobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\genobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\graminit.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\grammar.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\import.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\intobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\intrcheck.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\iterobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\listobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\longintrepr.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\longobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\marshal.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\memoryobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\metagrammar.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\methodobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\modsupport.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\moduleobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\node.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\object.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\objimpl.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\opcode.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\osdefs.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\parsetok.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\patchlevel.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pgen.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pgenheaders.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\py_curses.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pyarena.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pycapsule.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pyctype.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pydebug.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pyerrors.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pyexpat.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pyfpe.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pygetopt.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pymactoolbox.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pymath.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pymem.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pyport.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pystate.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pystrcmp.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pystrtod.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\Python-ast.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\Python.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pythonrun.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\pythread.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\rangeobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\setobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\sliceobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\stringobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\structmember.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\structseq.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\symtable.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\sysmodule.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\timefuncs.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\token.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\traceback.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\tupleobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\ucnhash.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\unicodeobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Include\weakrefobject.h">
- <Filter>Include</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_math.h">
- <Filter>Modules</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\md5.h">
- <Filter>Modules</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\rotatingtree.h">
- <Filter>Modules</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\crc32.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\deflate.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\inffast.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\inffixed.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\inflate.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\inftrees.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\trees.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\zconf.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\zconf.in.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\zlib.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\zlib\zutil.h">
- <Filter>Modules\zlib</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\alg_jisx0201.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\cjkcodecs.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\emu_jisx0213_2000.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\mappings_cn.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\mappings_hk.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\mappings_jisx0213_pair.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\mappings_jp.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\mappings_kr.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\mappings_tw.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\cjkcodecs\multibytecodec.h">
- <Filter>Modules\cjkcodecs</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\_io\_iomodule.h">
- <Filter>Modules\_io</Filter>
- </ClInclude>
- <ClInclude Include="..\Objects\stringlib\count.h">
- <Filter>Objects</Filter>
- </ClInclude>
- <ClInclude Include="..\Objects\stringlib\fastsearch.h">
- <Filter>Objects</Filter>
- </ClInclude>
- <ClInclude Include="..\Objects\stringlib\find.h">
- <Filter>Objects</Filter>
- </ClInclude>
- <ClInclude Include="..\Objects\stringlib\partition.h">
- <Filter>Objects</Filter>
- </ClInclude>
- <ClInclude Include="..\Objects\stringlib\split.h">
- <Filter>Objects</Filter>
- </ClInclude>
- <ClInclude Include="..\Objects\unicodetype_db.h">
- <Filter>Objects</Filter>
- </ClInclude>
- <ClInclude Include="..\Parser\parser.h">
- <Filter>Parser</Filter>
- </ClInclude>
- <ClInclude Include="..\Parser\tokenizer.h">
- <Filter>Parser</Filter>
- </ClInclude>
- <ClInclude Include="..\PC\errmap.h">
- <Filter>PC</Filter>
- </ClInclude>
- <ClInclude Include="..\PC\pyconfig.h">
- <Filter>PC</Filter>
- </ClInclude>
- <ClInclude Include="..\Python\importdl.h">
- <Filter>Python</Filter>
- </ClInclude>
- <ClInclude Include="..\Python\thread_nt.h">
- <Filter>Python</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\_bisectmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_codecsmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_collectionsmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_csv.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_functoolsmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_heapqmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_hotshot.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_json.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_localemodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_lsprof.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_math.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_randommodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_sre.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_struct.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_weakref.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\arraymodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\audioop.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\binascii.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cmathmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cPickle.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cStringIO.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\datetimemodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\errnomodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\future_builtins.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\gcmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\imageop.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\itertoolsmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\main.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\mathmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\md5.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\md5module.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\mmapmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\operator.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\parsermodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\posixmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\rotatingtree.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\sha256module.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\sha512module.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\shamodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\signalmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\stropmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\symtablemodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\threadmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\timemodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\xxsubtype.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zipimport.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlibmodule.c">
- <Filter>Modules</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\adler32.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\compress.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\crc32.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\deflate.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\gzclose.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\gzlib.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\gzread.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\gzwrite.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\infback.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\inffast.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\inflate.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\inftrees.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\trees.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\uncompr.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\zlib\zutil.c">
- <Filter>Modules\zlib</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_cn.c">
- <Filter>Modules\cjkcodecs</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_hk.c">
- <Filter>Modules\cjkcodecs</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_iso2022.c">
- <Filter>Modules\cjkcodecs</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_jp.c">
- <Filter>Modules\cjkcodecs</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_kr.c">
- <Filter>Modules\cjkcodecs</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cjkcodecs\_codecs_tw.c">
- <Filter>Modules\cjkcodecs</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\cjkcodecs\multibytecodec.c">
- <Filter>Modules\cjkcodecs</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_io\_iomodule.c">
- <Filter>Modules\_io</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_io\bufferedio.c">
- <Filter>Modules\_io</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_io\bytesio.c">
- <Filter>Modules\_io</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_io\fileio.c">
- <Filter>Modules\_io</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_io\iobase.c">
- <Filter>Modules\_io</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_io\stringio.c">
- <Filter>Modules\_io</Filter>
- </ClCompile>
- <ClCompile Include="..\Modules\_io\textio.c">
- <Filter>Modules\_io</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\abstract.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\boolobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\bufferobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\bytes_methods.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\bytearrayobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\capsule.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\cellobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\classobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\cobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\codeobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\complexobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\descrobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\dictobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\enumobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\exceptions.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\fileobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\floatobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\frameobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\funcobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\genobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\intobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\iterobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\listobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\longobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\memoryobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\methodobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\moduleobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\object.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\obmalloc.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\rangeobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\setobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\sliceobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\stringobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\structseq.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\tupleobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\typeobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\unicodectype.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\unicodeobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Objects\weakrefobject.c">
- <Filter>Objects</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\acceler.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\bitset.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\firstsets.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\grammar.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\grammar1.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\listnode.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\metagrammar.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\myreadline.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\node.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\parser.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\parsetok.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\Parser\tokenizer.c">
- <Filter>Parser</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\_subprocess.c">
- <Filter>PC</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\_winreg.c">
- <Filter>PC</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\config.c">
- <Filter>PC</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\dl_nt.c">
- <Filter>PC</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\getpathp.c">
- <Filter>PC</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\import_nt.c">
- <Filter>PC</Filter>
- </ClCompile>
- <ClCompile Include="..\PC\msvcrtmodule.c">
- <Filter>PC</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\_warnings.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\asdl.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\ast.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\bltinmodule.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\ceval.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\codecs.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\compile.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\dtoa.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\dynload_win.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\errors.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\formatter_string.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\formatter_unicode.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\frozen.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\future.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\getargs.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\getcompiler.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\getcopyright.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\getopt.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\getplatform.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\getversion.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\graminit.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\import.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\importdl.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\marshal.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\modsupport.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\mysnprintf.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\mystrtoul.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\peephole.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pyarena.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pyctype.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pyfpe.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pymath.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pystate.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pystrcmp.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pystrtod.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\Python-ast.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\pythonrun.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\random.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\structmember.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\symtable.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\sysmodule.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\thread.c">
- <Filter>Python</Filter>
- </ClCompile>
- <ClCompile Include="..\Python\traceback.c">
- <Filter>Python</Filter>
- </ClCompile>
- </ItemGroup>
- <ItemGroup>
- <ResourceCompile Include="..\PC\python_nt.rc">
- <Filter>Resource Files</Filter>
- </ResourceCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Include">\r
+ <UniqueIdentifier>{086b0afb-270c-4603-a02a-63d46f0b2b92}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Modules">\r
+ <UniqueIdentifier>{8e81609f-13ca-4eae-9fdb-f8af20c710c7}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Modules\_io">\r
+ <UniqueIdentifier>{8787c5bb-bab6-4586-a42e-4a27c7b3ffb6}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Modules\zlib">\r
+ <UniqueIdentifier>{5d6d2d6c-9e61-4a1d-b0b2-5cc2f446d69e}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Modules\cjkcodecs">\r
+ <UniqueIdentifier>{9f12c4b1-322e-431e-abf1-e02550f50032}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Objects">\r
+ <UniqueIdentifier>{ab29a558-143d-4fe7-a039-b431fb429856}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Parser">\r
+ <UniqueIdentifier>{97349fee-0abf-48b0-a8f5-771bf39b8aee}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="PC">\r
+ <UniqueIdentifier>{ea21fc98-de89-4746-a979-c5616964329a}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Python">\r
+ <UniqueIdentifier>{f2696406-14bc-48bd-90c5-e93ab82a21ac}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Resource Files">\r
+ <UniqueIdentifier>{c3e03a5c-56c7-45fd-8543-e5d2326b907d}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Include\abstract.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\asdl.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\ast.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\bitset.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\boolobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\bufferobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\bytes_methods.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\bytearrayobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\bytesobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\cellobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\ceval.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\classobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\cobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\code.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\codecs.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\compile.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\complexobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\cStringIO.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\datetime.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\descrobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\dictobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\dtoa.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\enumobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\errcode.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\eval.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\fileobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\floatobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\frameobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\funcobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\genobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\graminit.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\grammar.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\import.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\intobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\intrcheck.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\iterobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\listobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\longintrepr.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\longobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\marshal.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\memoryobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\metagrammar.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\methodobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\modsupport.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\moduleobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\node.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\object.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\objimpl.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\opcode.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\osdefs.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\parsetok.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\patchlevel.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pgen.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pgenheaders.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\py_curses.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pyarena.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pycapsule.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pyctype.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pydebug.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pyerrors.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pyexpat.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pyfpe.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pygetopt.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pymactoolbox.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pymath.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pymem.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pyport.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pystate.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pystrcmp.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pystrtod.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\Python-ast.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\Python.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pythonrun.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\pythread.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\rangeobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\setobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\sliceobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\stringobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\structmember.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\structseq.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\symtable.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\sysmodule.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\timefuncs.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\token.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\traceback.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\tupleobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\ucnhash.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\unicodeobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Include\weakrefobject.h">\r
+ <Filter>Include</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_math.h">\r
+ <Filter>Modules</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\md5.h">\r
+ <Filter>Modules</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\rotatingtree.h">\r
+ <Filter>Modules</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\crc32.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\deflate.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\inffast.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\inffixed.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\inflate.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\inftrees.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\trees.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\zconf.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\zconf.in.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\zlib.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\zlib\zutil.h">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\alg_jisx0201.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\cjkcodecs.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\emu_jisx0213_2000.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_cn.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_hk.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_jisx0213_pair.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_jp.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_kr.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\mappings_tw.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\cjkcodecs\multibytecodec.h">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\_io\_iomodule.h">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Objects\stringlib\count.h">\r
+ <Filter>Objects</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Objects\stringlib\fastsearch.h">\r
+ <Filter>Objects</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Objects\stringlib\find.h">\r
+ <Filter>Objects</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Objects\stringlib\partition.h">\r
+ <Filter>Objects</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Objects\stringlib\split.h">\r
+ <Filter>Objects</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Objects\unicodetype_db.h">\r
+ <Filter>Objects</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Parser\parser.h">\r
+ <Filter>Parser</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Parser\tokenizer.h">\r
+ <Filter>Parser</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\PC\errmap.h">\r
+ <Filter>PC</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\PC\pyconfig.h">\r
+ <Filter>PC</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Python\importdl.h">\r
+ <Filter>Python</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Python\thread_nt.h">\r
+ <Filter>Python</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\_bisectmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_codecsmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_collectionsmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_csv.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_functoolsmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_heapqmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_hotshot.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_json.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_localemodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_lsprof.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_math.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_randommodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_sre.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_struct.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_weakref.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\arraymodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\audioop.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\binascii.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cmathmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cPickle.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cStringIO.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\datetimemodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\errnomodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\future_builtins.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\gcmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\imageop.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\itertoolsmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\main.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\mathmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\md5.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\md5module.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\mmapmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\operator.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\parsermodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\posixmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\rotatingtree.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\sha256module.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\sha512module.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\shamodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\signalmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\stropmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\symtablemodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\threadmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\timemodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\xxsubtype.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zipimport.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlibmodule.c">\r
+ <Filter>Modules</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\adler32.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\compress.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\crc32.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\deflate.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\gzclose.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\gzlib.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\gzread.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\gzwrite.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\infback.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\inffast.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\inflate.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\inftrees.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\trees.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\uncompr.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\zlib\zutil.c">\r
+ <Filter>Modules\zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_cn.c">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_hk.c">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_iso2022.c">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_jp.c">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_kr.c">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cjkcodecs\_codecs_tw.c">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\cjkcodecs\multibytecodec.c">\r
+ <Filter>Modules\cjkcodecs</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_io\_iomodule.c">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_io\bufferedio.c">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_io\bytesio.c">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_io\fileio.c">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_io\iobase.c">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_io\stringio.c">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Modules\_io\textio.c">\r
+ <Filter>Modules\_io</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\abstract.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\boolobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\bufferobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\bytes_methods.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\bytearrayobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\capsule.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\cellobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\classobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\cobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\codeobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\complexobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\descrobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\dictobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\enumobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\exceptions.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\fileobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\floatobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\frameobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\funcobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\genobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\intobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\iterobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\listobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\longobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\memoryobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\methodobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\moduleobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\object.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\obmalloc.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\rangeobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\setobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\sliceobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\stringobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\structseq.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\tupleobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\typeobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\unicodectype.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\unicodeobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Objects\weakrefobject.c">\r
+ <Filter>Objects</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\acceler.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\bitset.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\firstsets.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\grammar.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\grammar1.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\listnode.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\metagrammar.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\myreadline.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\node.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\parser.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\parsetok.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Parser\tokenizer.c">\r
+ <Filter>Parser</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\_subprocess.c">\r
+ <Filter>PC</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\_winreg.c">\r
+ <Filter>PC</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\config.c">\r
+ <Filter>PC</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\dl_nt.c">\r
+ <Filter>PC</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\getpathp.c">\r
+ <Filter>PC</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\import_nt.c">\r
+ <Filter>PC</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\PC\msvcrtmodule.c">\r
+ <Filter>PC</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\_warnings.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\asdl.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\ast.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\bltinmodule.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\ceval.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\codecs.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\compile.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\dtoa.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\dynload_win.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\errors.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\formatter_string.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\formatter_unicode.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\frozen.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\future.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\getargs.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\getcompiler.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\getcopyright.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\getopt.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\getplatform.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\getversion.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\graminit.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\import.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\importdl.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\marshal.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\modsupport.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\mysnprintf.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\mystrtoul.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\peephole.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pyarena.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pyctype.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pyfpe.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pymath.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pystate.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pystrcmp.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pystrtod.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\Python-ast.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\pythonrun.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\random.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\structmember.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\symtable.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\sysmodule.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\thread.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="..\Python\traceback.c">\r
+ <Filter>Python</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="..\PC\python_nt.rc">\r
+ <Filter>Resource Files</Filter>\r
+ </ResourceCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{F4229CC3-873C-49AE-9729-DD308ED4CD4A}</ProjectGuid>
- <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>
- <SupportPGO>false</SupportPGO>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>Application</ConfigurationType>
- <UseOfMfc>false</UseOfMfc>
- <!-- For VS2008, we have to embed the manifest to be able to run -->
- <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>
- <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- <!-- For VS2008, we have to embed the manifest to be able to run -->
- <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>
- <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <StackReserveSize>2000000</StackReserveSize>
- <BaseAddress>0x1d000000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ResourceCompile Include="..\PC\python_exe.rc" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\WinMain.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{F4229CC3-873C-49AE-9729-DD308ED4CD4A}</ProjectGuid>\r
+ <MakeVersionInfoBeforeTarget>ClCompile</MakeVersionInfoBeforeTarget>\r
+ <SupportPGO>false</SupportPGO>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>Application</ConfigurationType>\r
+ <UseOfMfc>false</UseOfMfc>\r
+ <!-- For VS2008, we have to embed the manifest to be able to run -->\r
+ <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>\r
+ <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ <!-- For VS2008, we have to embed the manifest to be able to run -->\r
+ <GenerateManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</GenerateManifest>\r
+ <EmbedManifest Condition="'$(PlatformToolset)' == 'v90' or '$(BasePlatformToolset)' == 'v90'">true</EmbedManifest>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <StackReserveSize>2000000</StackReserveSize>\r
+ <BaseAddress>0x1d000000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="..\PC\python_exe.rc" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\WinMain.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Resource Files">
- <UniqueIdentifier>{0434cf11-a311-4a92-8a6c-4164aa79a7f2}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{e1d8ea6b-c65d-42f4-9eed-6010846ed378}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ResourceCompile Include="..\PC\python_exe.rc">
- <Filter>Resource Files</Filter>
- </ResourceCompile>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\WinMain.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Resource Files">\r
+ <UniqueIdentifier>{0434cf11-a311-4a92-8a6c-4164aa79a7f2}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{e1d8ea6b-c65d-42f4-9eed-6010846ed378}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ResourceCompile Include="..\PC\python_exe.rc">\r
+ <Filter>Resource Files</Filter>\r
+ </ResourceCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\WinMain.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
Homepage:\r
http://www.bzip.org/\r
_ssl\r
- Python wrapper for version 1.0.2j of the OpenSSL secure sockets\r
+ Python wrapper for version 1.0.2k of the OpenSSL secure sockets\r
library, which is built by ssl.vcxproj\r
Homepage:\r
http://www.openssl.org/\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{18CAE28C-B454-46C1-87A0-493D91D97F03}</ProjectGuid>
- <RootNamespace>select</RootNamespace>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <BaseAddress>0x1D110000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\selectmodule.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{18CAE28C-B454-46C1-87A0-493D91D97F03}</ProjectGuid>\r
+ <RootNamespace>select</RootNamespace>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ <BaseAddress>0x1D110000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\selectmodule.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{98346077-900c-4c7a-852f-a23470e37b40}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\selectmodule.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{98346077-900c-4c7a-852f-a23470e37b40}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\selectmodule.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{A1A295E5-463C-437F-81CA-1F32367685DA}</ProjectGuid>
- <RootNamespace>sqlite3</RootNamespace>
- <TargetExt>.pyd</TargetExt>
- <SupportPGO>false</SupportPGO>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <ClCompile>
- <AdditionalIncludeDirectories>$(sqlite3Dir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
- <PreprocessorDefinitions>SQLITE_API=__declspec(dllexport);%(PreprocessorDefinitions)</PreprocessorDefinitions>
- <WarningLevel>Level1</WarningLevel>
- </ClCompile>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="$(sqlite3Dir)\sqlite3.h" />
- <ClInclude Include="$(sqlite3Dir)\sqlite3ext.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="$(sqlite3Dir)\sqlite3.c" />
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{A1A295E5-463C-437F-81CA-1F32367685DA}</ProjectGuid>\r
+ <RootNamespace>sqlite3</RootNamespace>\r
+ <TargetExt>.pyd</TargetExt>\r
+ <SupportPGO>false</SupportPGO>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <AdditionalIncludeDirectories>$(sqlite3Dir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ <PreprocessorDefinitions>SQLITE_API=__declspec(dllexport);%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <WarningLevel>Level1</WarningLevel>\r
+ </ClCompile>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="$(sqlite3Dir)\sqlite3.h" />\r
+ <ClInclude Include="$(sqlite3Dir)\sqlite3ext.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="$(sqlite3Dir)\sqlite3.c" />\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{ce5b649d-a6f7-4459-9425-c883795d79df}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{0e842fe2-176b-4e83-9d1f-0ad13a859efd}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="$(sqlite3Dir)\sqlite3.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="$(sqlite3Dir)\sqlite3ext.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="$(sqlite3Dir)\sqlite3.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{ce5b649d-a6f7-4459-9425-c883795d79df}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{0e842fe2-176b-4e83-9d1f-0ad13a859efd}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="$(sqlite3Dir)\sqlite3.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="$(sqlite3Dir)\sqlite3ext.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="$(sqlite3Dir)\sqlite3.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{10615B24-73BF-4EFA-93AA-236916321317}</ProjectGuid>
- <RootNamespace>ssleay</RootNamespace>
- </PropertyGroup>
-
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-
- <PropertyGroup Label="Configuration">
- <ConfigurationType>StaticLibrary</ConfigurationType>
- </PropertyGroup>
-
- <Import Project="openssl.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-
- <ItemGroup>
- <!--
- <ClCompile Include="$(opensslDir)ssl\bio_ssl.c" />
- -->
- <ClCompile Include="$(opensslDir)ssl\d1_both.c" />
- <!--
- <ClCompile Include="$(opensslDir)ssl\d1_clnt.c" />
- <ClCompile Include="$(opensslDir)ssl\d1_enc.c" />
- -->
- <ClCompile Include="$(opensslDir)ssl\d1_lib.c" />
- <!--
- <ClCompile Include="$(opensslDir)ssl\d1_meth.c" />
- -->
- <ClCompile Include="$(opensslDir)ssl\d1_pkt.c" />
- <ClCompile Include="$(opensslDir)ssl\d1_srtp.c" />
- <!--
- <ClCompile Include="$(opensslDir)ssl\d1_srvr.c" />
- <ClCompile Include="$(opensslDir)ssl\kssl.c" />
- -->
- <ClCompile Include="$(opensslDir)ssl\s2_clnt.c" />
- <ClCompile Include="$(opensslDir)ssl\s2_enc.c" />
- <ClCompile Include="$(opensslDir)ssl\s2_lib.c" />
- <ClCompile Include="$(opensslDir)ssl\s2_meth.c" />
- <ClCompile Include="$(opensslDir)ssl\s2_pkt.c" />
- <ClCompile Include="$(opensslDir)ssl\s2_srvr.c" />
- <ClCompile Include="$(opensslDir)ssl\s23_clnt.c" />
- <ClCompile Include="$(opensslDir)ssl\s23_lib.c" />
- <ClCompile Include="$(opensslDir)ssl\s23_meth.c" />
- <ClCompile Include="$(opensslDir)ssl\s23_pkt.c" />
- <ClCompile Include="$(opensslDir)ssl\s23_srvr.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_both.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_cbc.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_clnt.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_enc.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_lib.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_meth.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_pkt.c" />
- <ClCompile Include="$(opensslDir)ssl\s3_srvr.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_algs.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_asn1.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_cert.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_ciph.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_err.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_err2.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_lib.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_rsa.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_sess.c" />
- <!--
- <ClCompile Include="$(opensslDir)ssl\ssl_stat.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_txt.c" />
- <ClCompile Include="$(opensslDir)ssl\ssl_utst.c" />
- -->
- <ClCompile Include="$(opensslDir)ssl\t1_clnt.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_enc.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_lib.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_meth.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_reneg.c" />
- <ClCompile Include="$(opensslDir)ssl\t1_srvr.c" />
- <ClCompile Include="$(opensslDir)ssl\tls_srp.c" />
- </ItemGroup>
-
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <Target Name="Clean" />
- <Target Name="CleanAll">
- <Delete Files="$(TargetPath)" />
- <RemoveDir Directories="$(IntDir)" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{10615B24-73BF-4EFA-93AA-236916321317}</ProjectGuid>\r
+ <RootNamespace>ssleay</RootNamespace>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>StaticLibrary</ConfigurationType>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="openssl.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+\r
+ <ItemGroup>\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)ssl\bio_ssl.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)ssl\d1_both.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)ssl\d1_clnt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\d1_enc.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)ssl\d1_lib.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)ssl\d1_meth.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)ssl\d1_pkt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\d1_srtp.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)ssl\d1_srvr.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\kssl.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)ssl\s2_clnt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s2_enc.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s2_lib.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s2_meth.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s2_pkt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s2_srvr.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s23_clnt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s23_lib.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s23_meth.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s23_pkt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s23_srvr.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_both.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_cbc.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_clnt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_enc.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_lib.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_meth.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_pkt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\s3_srvr.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_algs.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_asn1.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_cert.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_ciph.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_err.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_err2.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_lib.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_rsa.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_sess.c" />\r
+ <!--\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_stat.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_txt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\ssl_utst.c" />\r
+ -->\r
+ <ClCompile Include="$(opensslDir)ssl\t1_clnt.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_enc.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_lib.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_meth.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_reneg.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\t1_srvr.c" />\r
+ <ClCompile Include="$(opensslDir)ssl\tls_srp.c" />\r
+ </ItemGroup>\r
+\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <Target Name="Clean" />\r
+ <Target Name="CleanAll">\r
+ <Delete Files="$(TargetPath)" />\r
+ <RemoveDir Directories="$(IntDir)" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{B5FD6F1D-129E-4BFF-9340-03606FAC7283}</ProjectGuid>
- </PropertyGroup>
-
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <Import Project="tcltk.props" />
-
- <PropertyGroup Label="Configuration">
- <ConfigurationType>Makefile</ConfigurationType>
- <OutDir>$(tcltkDir)</OutDir>
- <TargetPath>$(OutDir)bin\$(tclDLLName)</TargetPath>
- </PropertyGroup>
-
- <ItemGroup>
- <ExpectedOutputs Include="
- $(OutDir)\bin\$(tclDLLName);
- $(OutDir)\bin\$(tclShExeName);
- $(OutDir)\include\tcl.h;
- $(OutDir)\lib\tcl$(TclMajorVersion);
- $(OutDir)\lib\tcl$(TclMajorVersion).$(TclMinorVersion);
- $(OutDir)\lib\$(tclLibName)" />
- </ItemGroup>
-
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-
- <PropertyGroup>
- <TclOpts Condition="$(Configuration) == 'Debug'">symbols</TclOpts>
- <TclDirs>INSTALLDIR="$(OutDir.TrimEnd(`\`))" INSTALL_DIR="$(OutDir.TrimEnd(`\`))"</TclDirs>
- <DebugFlags Condition="'$(Configuration)' == 'Debug'">DEBUGFLAGS="-wd4456 -wd4457 -wd4458 -wd4459 -wd4996"</DebugFlags>
- <NMakeBuildCommandLine>setlocal
-@(ExpectedOutputs->'if not exist "%(FullPath)" goto build','
-')
-goto :eof
-:build
-set VCINSTALLDIR=$(VCInstallDir)
-cd /D "$(tclDir)win"
-nmake -f makefile.vc MACHINE=$(TclMachine) OPTS=$(TclOpts) $(TclDirs) $(DebugFlags) core shell dlls
-nmake -f makefile.vc MACHINE=$(TclMachine) OPTS=$(TclOpts) $(TclDirs) $(DebugFlags) install-binaries install-libraries
-</NMakeBuildCommandLine>
- </PropertyGroup>
-
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-
- <Target Name="CopyDll" Inputs="$(OutDir)\bin\$(tclDLLName)" Outputs="$(BuildPath)$(tclDLLName)" AfterTargets="Build">
- <Copy SourceFiles="$(OutDir)\bin\$(tclDLLName)" DestinationFiles="$(BuildPath)$(tclDLLName)" />
- </Target>
-
- <Target Name="Clean" />
- <Target Name="CleanAll">
- <Delete Files="$(TargetPath);$(BuildPath)$(tclDLLName)" />
- <RemoveDir Directories="$(IntDir)" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{B5FD6F1D-129E-4BFF-9340-03606FAC7283}</ProjectGuid>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <Import Project="tcltk.props" />\r
+\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>Makefile</ConfigurationType>\r
+ <OutDir>$(tcltkDir)</OutDir>\r
+ <TargetPath>$(OutDir)bin\$(tclDLLName)</TargetPath>\r
+ </PropertyGroup>\r
+\r
+ <ItemGroup>\r
+ <ExpectedOutputs Include="\r
+ $(OutDir)\bin\$(tclDLLName);\r
+ $(OutDir)\bin\$(tclShExeName);\r
+ $(OutDir)\include\tcl.h;\r
+ $(OutDir)\lib\tcl$(TclMajorVersion);\r
+ $(OutDir)\lib\tcl$(TclMajorVersion).$(TclMinorVersion);\r
+ $(OutDir)\lib\$(tclLibName)" />\r
+ </ItemGroup>\r
+\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+\r
+ <PropertyGroup>\r
+ <TclOpts Condition="$(Configuration) == 'Debug'">symbols</TclOpts>\r
+ <TclDirs>INSTALLDIR="$(OutDir.TrimEnd(`\`))" INSTALL_DIR="$(OutDir.TrimEnd(`\`))"</TclDirs>\r
+ <DebugFlags Condition="'$(Configuration)' == 'Debug'">DEBUGFLAGS="-wd4456 -wd4457 -wd4458 -wd4459 -wd4996"</DebugFlags>\r
+ <NMakeBuildCommandLine>setlocal\r
+@(ExpectedOutputs->'if not exist "%(FullPath)" goto build','\r
+')\r
+goto :eof\r
+:build\r
+set VCINSTALLDIR=$(VCInstallDir)\r
+cd /D "$(tclDir)win"\r
+nmake -f makefile.vc MACHINE=$(TclMachine) OPTS=$(TclOpts) $(TclDirs) $(DebugFlags) core shell dlls\r
+nmake -f makefile.vc MACHINE=$(TclMachine) OPTS=$(TclOpts) $(TclDirs) $(DebugFlags) install-binaries install-libraries\r
+</NMakeBuildCommandLine>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+\r
+ <Target Name="CopyDll" Inputs="$(OutDir)\bin\$(tclDLLName)" Outputs="$(BuildPath)$(tclDLLName)" AfterTargets="Build">\r
+ <Copy SourceFiles="$(OutDir)\bin\$(tclDLLName)" DestinationFiles="$(BuildPath)$(tclDLLName)" />\r
+ </Target>\r
+\r
+ <Target Name="Clean" />\r
+ <Target Name="CleanAll">\r
+ <Delete Files="$(TargetPath);$(BuildPath)$(tclDLLName)" />\r
+ <RemoveDir Directories="$(IntDir)" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <Import Project="pyproject.props" />
- <PropertyGroup>
- <TclMajorVersion>8</TclMajorVersion>
- <TclMinorVersion>5</TclMinorVersion>
- <TclPatchLevel>15</TclPatchLevel>
- <TclRevision>0</TclRevision>
- <TkMajorVersion>$(TclMajorVersion)</TkMajorVersion>
- <TkMinorVersion>$(TclMinorVersion)</TkMinorVersion>
- <TkPatchLevel>$(TclPatchLevel)</TkPatchLevel>
- <TkRevision>$(TclRevision)</TkRevision>
- <TixMajorVersion>8</TixMajorVersion>
- <TixMinorVersion>4</TixMinorVersion>
- <TixPatchLevel>3</TixPatchLevel>
- <TixRevision>5</TixRevision>
- <tclDir>$(ExternalsDir)tcl-$(TclMajorVersion).$(TclMinorVersion).$(TclPatchLevel).$(TclRevision)\</tclDir>
- <tkDir>$(ExternalsDir)tk-$(TkMajorVersion).$(TkMinorVersion).$(TkPatchLevel).$(TkRevision)\</tkDir>
- <tixDir>$(ExternalsDir)tix-$(TixMajorVersion).$(TixMinorVersion).$(TixPatchLevel).$(TixRevision)\</tixDir>
- <tcltkDir>$(ExternalsDir)tcltk\</tcltkDir>
- <tcltkDir Condition="'$(Platform)' == 'x64'">$(ExternalsDir)tcltk64\</tcltkDir>
- <TclDebugExt Condition="'$(Configuration)' == 'Debug'">g</TclDebugExt>
- <tclDLLName>tcl$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).dll</tclDLLName>
- <tclLibName>tcl$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).lib</tclLibName>
- <tclShExeName>tclsh$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).exe</tclShExeName>
- <tkDLLName>tk$(TkMajorVersion)$(TkMinorVersion)$(TclDebugExt).dll</tkDLLName>
- <tkLibName>tk$(TkMajorVersion)$(TkMinorVersion)$(TclDebugExt).lib</tkLibName>
- <tixDLLName>tix$(TixMajorVersion)$(TixMinorVersion)$(TclDebugExt).dll</tixDLLName>
- <tixDLLPath>$(tcltkDir)lib\tix$(TixMajorVersion).$(TixMinorVersion).$(TixPatchLevel)\$(tixDLLName)</tixDLLPath>
- <tcltkLib>$(tcltkDir)lib\tcl$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).lib;$(tcltkDir)lib\tk$(TkMajorVersion)$(TkMinorVersion)$(TclDebugExt).lib</tcltkLib>
- <TclMachine>IX86</TclMachine>
- <TclMachine Condition="'$(Platform)' == 'x64'">AMD64</TclMachine>
- <TclVersions>TCL_MAJOR_VERSION=$(TclMajorVersion) TCL_MINOR_VERSION=$(TclMinorVersion) TCL_PATCH_LEVEL=$(TclPatchLevel)</TclVersions>
- <TclShortVersions>TCL_MAJOR=$(TclMajorVersion) TCL_MINOR=$(TclMinorVersion) TCL_PATCH=$(TclPatchLevel)</TclShortVersions>
- <TkVersions>TK_MAJOR_VERSION=$(TkMajorVersion) TK_MINOR_VERSION=$(TkMinorVersion) TK_PATCH_LEVEL=$(TkPatchLevel)</TkVersions>
-
- <BuildDirTop>Release</BuildDirTop>
- <BuildDirTop Condition="$(Configuration) == 'Debug'">Debug</BuildDirTop>
- <BuildDirTop Condition="$(TclMachine) != 'IX86'">$(BuildDirTop)_$(TclMachine)</BuildDirTop>
- <!-- This completely breaks building Tix for any toolset but v90 and should be fixed -->
- <BuildDirTop>$(BuildDirTop)_VC9</BuildDirTop>
- </PropertyGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <Import Project="pyproject.props" />\r
+ <PropertyGroup>\r
+ <TclMajorVersion>8</TclMajorVersion>\r
+ <TclMinorVersion>5</TclMinorVersion>\r
+ <TclPatchLevel>15</TclPatchLevel>\r
+ <TclRevision>0</TclRevision>\r
+ <TkMajorVersion>$(TclMajorVersion)</TkMajorVersion>\r
+ <TkMinorVersion>$(TclMinorVersion)</TkMinorVersion>\r
+ <TkPatchLevel>$(TclPatchLevel)</TkPatchLevel>\r
+ <TkRevision>$(TclRevision)</TkRevision>\r
+ <TixMajorVersion>8</TixMajorVersion>\r
+ <TixMinorVersion>4</TixMinorVersion>\r
+ <TixPatchLevel>3</TixPatchLevel>\r
+ <TixRevision>5</TixRevision>\r
+ <tclDir>$(ExternalsDir)tcl-$(TclMajorVersion).$(TclMinorVersion).$(TclPatchLevel).$(TclRevision)\</tclDir>\r
+ <tkDir>$(ExternalsDir)tk-$(TkMajorVersion).$(TkMinorVersion).$(TkPatchLevel).$(TkRevision)\</tkDir>\r
+ <tixDir>$(ExternalsDir)tix-$(TixMajorVersion).$(TixMinorVersion).$(TixPatchLevel).$(TixRevision)\</tixDir>\r
+ <tcltkDir>$(ExternalsDir)tcltk\</tcltkDir>\r
+ <tcltkDir Condition="'$(Platform)' == 'x64'">$(ExternalsDir)tcltk64\</tcltkDir>\r
+ <TclDebugExt Condition="'$(Configuration)' == 'Debug'">g</TclDebugExt>\r
+ <tclDLLName>tcl$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).dll</tclDLLName>\r
+ <tclLibName>tcl$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).lib</tclLibName>\r
+ <tclShExeName>tclsh$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).exe</tclShExeName>\r
+ <tkDLLName>tk$(TkMajorVersion)$(TkMinorVersion)$(TclDebugExt).dll</tkDLLName>\r
+ <tkLibName>tk$(TkMajorVersion)$(TkMinorVersion)$(TclDebugExt).lib</tkLibName>\r
+ <tixDLLName>tix$(TixMajorVersion)$(TixMinorVersion)$(TclDebugExt).dll</tixDLLName>\r
+ <tixDLLPath>$(tcltkDir)lib\tix$(TixMajorVersion).$(TixMinorVersion).$(TixPatchLevel)\$(tixDLLName)</tixDLLPath>\r
+ <tcltkLib>$(tcltkDir)lib\tcl$(TclMajorVersion)$(TclMinorVersion)$(TclDebugExt).lib;$(tcltkDir)lib\tk$(TkMajorVersion)$(TkMinorVersion)$(TclDebugExt).lib</tcltkLib>\r
+ <TclMachine>IX86</TclMachine>\r
+ <TclMachine Condition="'$(Platform)' == 'x64'">AMD64</TclMachine>\r
+ <TclVersions>TCL_MAJOR_VERSION=$(TclMajorVersion) TCL_MINOR_VERSION=$(TclMinorVersion) TCL_PATCH_LEVEL=$(TclPatchLevel)</TclVersions>\r
+ <TclShortVersions>TCL_MAJOR=$(TclMajorVersion) TCL_MINOR=$(TclMinorVersion) TCL_PATCH=$(TclPatchLevel)</TclShortVersions>\r
+ <TkVersions>TK_MAJOR_VERSION=$(TkMajorVersion) TK_MINOR_VERSION=$(TkMinorVersion) TK_PATCH_LEVEL=$(TkPatchLevel)</TkVersions>\r
+\r
+ <BuildDirTop>Release</BuildDirTop>\r
+ <BuildDirTop Condition="$(Configuration) == 'Debug'">Debug</BuildDirTop>\r
+ <BuildDirTop Condition="$(TclMachine) != 'IX86'">$(BuildDirTop)_$(TclMachine)</BuildDirTop>\r
+ <!-- This completely breaks building Tix for any toolset but v90 and should be fixed -->\r
+ <BuildDirTop>$(BuildDirTop)_VC9</BuildDirTop>\r
+ </PropertyGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{C5A3E7FB-9695-4B2E-960B-1D9F43F1E555}</ProjectGuid>
- <RootNamespace>tix</RootNamespace>
- </PropertyGroup>
-
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <Import Project="tcltk.props" />
-
- <PropertyGroup Label="Configuration">
- <ConfigurationType>Makefile</ConfigurationType>
- <OutDir>$(tcltkDir)</OutDir>
- <TargetPath>$(tixDLLPath)</TargetPath>
- </PropertyGroup>
-
- <ItemGroup>
- <ExpectedOutputs Include="$(TargetPath)" />
- </ItemGroup>
-
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-
- <PropertyGroup>
- <TkOpts>msvcrt</TkOpts>
- <TkOpts Condition="$(Configuration) == 'Debug'">symbols,msvcrt</TkOpts>
- <TixDirs>BUILDDIRTOP="$(BuildDirTop)" TCL_DIR="$(tclDir.TrimEnd(`\`))" TK_DIR="$(tkDir.TrimEnd(`\`))" INSTALL_DIR="$(OutDir.TrimEnd(`\`))"</TixDirs>
- <DebugFlags Condition="'$(Configuration)' == 'Debug'">DEBUG=1 NODEBUG=0 TCL_DBGX=g DEBUGFLAGS="-wd4456 -wd4457 -wd4458 -wd4459 -wd4996"</DebugFlags>
- <DebugFlags Condition="'$(Configuration)' != 'Debug'">DEBUG=0 NODEBUG=1</DebugFlags>
- <NMakeBuildCommandLine>setlocal
-@(ExpectedOutputs->'if not exist "%(FullPath)" goto build','
-')
-goto :eof
-:build
-set VCINSTALLDIR=$(VCInstallDir)
-cd /D "$(tixDir)win"
-nmake /nologo -f makefile.vc MACHINE=$(TclMachine) $(DebugFlags) $(TclShortVersions) $(TixDirs) all install
-</NMakeBuildCommandLine>
- <NMakeCleanCommandLine>rmdir /q/s "$(OutDir.TrimEnd(`\`))"</NMakeCleanCommandLine>
- </PropertyGroup>
-
- <ItemGroup>
- <ProjectReference Include="tcl.vcxproj">
- <Project>{b5fd6f1d-129e-4bff-9340-03606fac7283}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- <ProjectReference Include="tk.vcxproj">
- <Project>{7e85eccf-a72c-4da4-9e52-884508e80ba1}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
-
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-
- <Target Name="Clean" />
- <Target Name="CleanAll">
- <RemoveDir Directories="$(OutDir)" />
- <RemoveDir Directories="$(IntDir)" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{C5A3E7FB-9695-4B2E-960B-1D9F43F1E555}</ProjectGuid>\r
+ <RootNamespace>tix</RootNamespace>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <Import Project="tcltk.props" />\r
+\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>Makefile</ConfigurationType>\r
+ <OutDir>$(tcltkDir)</OutDir>\r
+ <TargetPath>$(tixDLLPath)</TargetPath>\r
+ </PropertyGroup>\r
+\r
+ <ItemGroup>\r
+ <ExpectedOutputs Include="$(TargetPath)" />\r
+ </ItemGroup>\r
+\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+\r
+ <PropertyGroup>\r
+ <TkOpts>msvcrt</TkOpts>\r
+ <TkOpts Condition="$(Configuration) == 'Debug'">symbols,msvcrt</TkOpts>\r
+ <TixDirs>BUILDDIRTOP="$(BuildDirTop)" TCL_DIR="$(tclDir.TrimEnd(`\`))" TK_DIR="$(tkDir.TrimEnd(`\`))" INSTALL_DIR="$(OutDir.TrimEnd(`\`))"</TixDirs>\r
+ <DebugFlags Condition="'$(Configuration)' == 'Debug'">DEBUG=1 NODEBUG=0 TCL_DBGX=g DEBUGFLAGS="-wd4456 -wd4457 -wd4458 -wd4459 -wd4996"</DebugFlags>\r
+ <DebugFlags Condition="'$(Configuration)' != 'Debug'">DEBUG=0 NODEBUG=1</DebugFlags>\r
+ <NMakeBuildCommandLine>setlocal\r
+@(ExpectedOutputs->'if not exist "%(FullPath)" goto build','\r
+')\r
+goto :eof\r
+:build\r
+set VCINSTALLDIR=$(VCInstallDir)\r
+cd /D "$(tixDir)win"\r
+nmake /nologo -f makefile.vc MACHINE=$(TclMachine) $(DebugFlags) $(TclShortVersions) $(TixDirs) all install\r
+</NMakeBuildCommandLine>\r
+ <NMakeCleanCommandLine>rmdir /q/s "$(OutDir.TrimEnd(`\`))"</NMakeCleanCommandLine>\r
+ </PropertyGroup>\r
+\r
+ <ItemGroup>\r
+ <ProjectReference Include="tcl.vcxproj">\r
+ <Project>{b5fd6f1d-129e-4bff-9340-03606fac7283}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ <ProjectReference Include="tk.vcxproj">\r
+ <Project>{7e85eccf-a72c-4da4-9e52-884508e80ba1}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+\r
+ <Target Name="Clean" />\r
+ <Target Name="CleanAll">\r
+ <RemoveDir Directories="$(OutDir)" />\r
+ <RemoveDir Directories="$(IntDir)" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{7E85ECCF-A72C-4DA4-9E52-884508E80BA1}</ProjectGuid>
- <RootNamespace>tk</RootNamespace>
- </PropertyGroup>
-
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <Import Project="tcltk.props" />
-
- <PropertyGroup Label="Configuration">
- <ConfigurationType>Makefile</ConfigurationType>
- <OutDir>$(tcltkDir)</OutDir>
- <TargetPath>$(OutDir)bin\$(tkDLLName)</TargetPath>
- </PropertyGroup>
-
- <ItemGroup>
- <ExpectedOutputs Include="
- $(OutDir)bin\$(tkDLLName);
- $(OutDir)include\tk.h;
- $(OutDir)lib\$(tkLibName);
- $(OutDir)lib\tk$(TkMajorVersion).$(TkMinorVersion)" />
- </ItemGroup>
-
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-
- <PropertyGroup>
- <TkOpts>msvcrt</TkOpts>
- <TkOpts Condition="$(Configuration) == 'Debug'">symbols,msvcrt</TkOpts>
- <TkDirs>TCLDIR="$(tclDir.TrimEnd(`\`))" INSTALLDIR="$(OutDir.TrimEnd(`\`))"</TkDirs>
- <DebugFlags Condition="'$(Configuration)' == 'Debug'">DEBUGFLAGS="-wd4456 -wd4457 -wd4458 -wd4459 -wd4996"</DebugFlags>
- <NMakeBuildCommandLine>setlocal
-@(ExpectedOutputs->'if not exist "%(FullPath)" goto build','
-')
-goto :eof
-:build
-set VCINSTALLDIR=$(VCInstallDir)
-cd /D "$(tkDir)win"
-nmake /nologo -f makefile.vc RC=rc MACHINE=$(TclMachine) OPTS=$(TkOpts) $(TkDirs) $(DebugFlags) all
-nmake /nologo -f makefile.vc RC=rc MACHINE=$(TclMachine) OPTS=$(TkOpts) $(TkDirs) $(DebugFlags) install-binaries install-libraries
-</NMakeBuildCommandLine>
- </PropertyGroup>
- <ItemGroup>
- <ProjectReference Include="tcl.vcxproj">
- <Project>{b5fd6f1d-129e-4bff-9340-03606fac7283}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-
- <Target Name="CopyDll" Inputs="$(OutDir)\bin\$(tkDLLName)" Outputs="$(BuildPath)$(tkDLLName)" AfterTargets="Build">
- <Copy SourceFiles="$(OutDir)\bin\$(tkDLLName)" DestinationFiles="$(BuildPath)$(tkDLLName)" />
- </Target>
-
- <Target Name="Clean" />
- <Target Name="CleanAll">
- <Delete Files="$(TargetPath);$(BuildPath)$(tkDLLName)" />
- <RemoveDir Directories="$(IntDir)" />
- </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{7E85ECCF-A72C-4DA4-9E52-884508E80BA1}</ProjectGuid>\r
+ <RootNamespace>tk</RootNamespace>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <Import Project="tcltk.props" />\r
+\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>Makefile</ConfigurationType>\r
+ <OutDir>$(tcltkDir)</OutDir>\r
+ <TargetPath>$(OutDir)bin\$(tkDLLName)</TargetPath>\r
+ </PropertyGroup>\r
+\r
+ <ItemGroup>\r
+ <ExpectedOutputs Include="\r
+ $(OutDir)bin\$(tkDLLName);\r
+ $(OutDir)include\tk.h;\r
+ $(OutDir)lib\$(tkLibName);\r
+ $(OutDir)lib\tk$(TkMajorVersion).$(TkMinorVersion)" />\r
+ </ItemGroup>\r
+\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+\r
+ <PropertyGroup>\r
+ <TkOpts>msvcrt</TkOpts>\r
+ <TkOpts Condition="$(Configuration) == 'Debug'">symbols,msvcrt</TkOpts>\r
+ <TkDirs>TCLDIR="$(tclDir.TrimEnd(`\`))" INSTALLDIR="$(OutDir.TrimEnd(`\`))"</TkDirs>\r
+ <DebugFlags Condition="'$(Configuration)' == 'Debug'">DEBUGFLAGS="-wd4456 -wd4457 -wd4458 -wd4459 -wd4996"</DebugFlags>\r
+ <NMakeBuildCommandLine>setlocal\r
+@(ExpectedOutputs->'if not exist "%(FullPath)" goto build','\r
+')\r
+goto :eof\r
+:build\r
+set VCINSTALLDIR=$(VCInstallDir)\r
+cd /D "$(tkDir)win"\r
+nmake /nologo -f makefile.vc RC=rc MACHINE=$(TclMachine) OPTS=$(TkOpts) $(TkDirs) $(DebugFlags) all\r
+nmake /nologo -f makefile.vc RC=rc MACHINE=$(TclMachine) OPTS=$(TkOpts) $(TkDirs) $(DebugFlags) install-binaries install-libraries\r
+</NMakeBuildCommandLine>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="tcl.vcxproj">\r
+ <Project>{b5fd6f1d-129e-4bff-9340-03606fac7283}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+\r
+ <Target Name="CopyDll" Inputs="$(OutDir)\bin\$(tkDLLName)" Outputs="$(BuildPath)$(tkDLLName)" AfterTargets="Build">\r
+ <Copy SourceFiles="$(OutDir)\bin\$(tkDLLName)" DestinationFiles="$(BuildPath)$(tkDLLName)" />\r
+ </Target>\r
+\r
+ <Target Name="Clean" />\r
+ <Target Name="CleanAll">\r
+ <Delete Files="$(TargetPath);$(BuildPath)$(tkDLLName)" />\r
+ <RemoveDir Directories="$(IntDir)" />\r
+ </Target>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{ECC7CEAC-A5E5-458E-BB9E-2413CC847881}</ProjectGuid>
- <RootNamespace>unicodedata</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <BaseAddress>0x1D120000</BaseAddress>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\unicodedata_db.h" />
- <ClInclude Include="..\Modules\unicodename_db.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\unicodedata.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{ECC7CEAC-A5E5-458E-BB9E-2413CC847881}</ProjectGuid>\r
+ <RootNamespace>unicodedata</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <BaseAddress>0x1D120000</BaseAddress>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\unicodedata_db.h" />\r
+ <ClInclude Include="..\Modules\unicodename_db.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\unicodedata.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Header Files">
- <UniqueIdentifier>{b939a8f1-ccd7-420a-974a-243606dccd74}</UniqueIdentifier>
- </Filter>
- <Filter Include="Source Files">
- <UniqueIdentifier>{e2c055bb-ec62-4bbc-aa1c-d88da4d4ad1c}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="..\Modules\unicodedata_db.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="..\Modules\unicodename_db.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\Modules\unicodedata.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{b939a8f1-ccd7-420a-974a-243606dccd74}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{e2c055bb-ec62-4bbc-aa1c-d88da4d4ad1c}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="..\Modules\unicodedata_db.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="..\Modules\unicodename_db.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\Modules\unicodedata.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{E9E0A1F6-0009-4E8C-B8F8-1B8F5D49A058}</ProjectGuid>
- <RootNamespace>w9xpopen</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- <SupportPGO>false</SupportPGO>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>Application</ConfigurationType>
- <UseOfMfc>false</UseOfMfc>
- <CharacterSet>MultiByte</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <ItemDefinitionGroup>
- <ClCompile>
- <PreprocessorDefinitions>_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- <Optimization>MaxSpeed</Optimization>
- <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
- <StringPooling>true</StringPooling>
- <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
- <FunctionLevelLinking>true</FunctionLevelLinking>
- </ClCompile>
- <Link>
- <SubSystem>Console</SubSystem>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\w9xpopen.c" />
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{E9E0A1F6-0009-4E8C-B8F8-1B8F5D49A058}</ProjectGuid>\r
+ <RootNamespace>w9xpopen</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ <SupportPGO>false</SupportPGO>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>Application</ConfigurationType>\r
+ <UseOfMfc>false</UseOfMfc>\r
+ <CharacterSet>MultiByte</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <ItemDefinitionGroup>\r
+ <ClCompile>\r
+ <PreprocessorDefinitions>_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <Optimization>MaxSpeed</Optimization>\r
+ <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>\r
+ <StringPooling>true</StringPooling>\r
+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>\r
+ <FunctionLevelLinking>true</FunctionLevelLinking>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Console</SubSystem>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\w9xpopen.c" />\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{abc2dffd-3f2a-47bd-b89b-0314c99ef21e}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\w9xpopen.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{abc2dffd-3f2a-47bd-b89b-0314c99ef21e}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\w9xpopen.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|Win32">
- <Configuration>PGInstrument</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGInstrument|x64">
- <Configuration>PGInstrument</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|Win32">
- <Configuration>PGUpdate</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="PGUpdate|x64">
- <Configuration>PGUpdate</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{28B5D777-DDF2-4B6B-B34F-31D938813856}</ProjectGuid>
- <RootNamespace>winsound</RootNamespace>
- <Keyword>Win32Proj</Keyword>
- </PropertyGroup>
- <Import Project="python.props" />
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <CharacterSet>NotSet</CharacterSet>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <PropertyGroup>
- <TargetExt>.pyd</TargetExt>
- </PropertyGroup>
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- <Import Project="pyproject.props" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup>
- <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
- </PropertyGroup>
- <ItemDefinitionGroup>
- <Link>
- <AdditionalDependencies>winmm.lib;%(AdditionalDependencies)</AdditionalDependencies>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\winsound.c" />
- </ItemGroup>
- <ItemGroup>
- <ProjectReference Include="pythoncore.vcxproj">
- <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>
- <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
- </ProjectReference>
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|Win32">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGInstrument|x64">\r
+ <Configuration>PGInstrument</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|Win32">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="PGUpdate|x64">\r
+ <Configuration>PGUpdate</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{28B5D777-DDF2-4B6B-B34F-31D938813856}</ProjectGuid>\r
+ <RootNamespace>winsound</RootNamespace>\r
+ <Keyword>Win32Proj</Keyword>\r
+ </PropertyGroup>\r
+ <Import Project="python.props" />\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <PropertyGroup>\r
+ <TargetExt>.pyd</TargetExt>\r
+ </PropertyGroup>\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ <Import Project="pyproject.props" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup>\r
+ <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup>\r
+ <Link>\r
+ <AdditionalDependencies>winmm.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\winsound.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ProjectReference Include="pythoncore.vcxproj">\r
+ <Project>{cf7ac3d1-e2df-41d2-bea6-1e2556cdea26}</Project>\r
+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\r
+ </ProjectReference>\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>\r
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
- <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="..\PC\winsound.c">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>\r
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="..\PC\winsound.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+</Project>\r
self.emit("%s = asdl_seq_new(len, arena);" % field.name, depth+1)
self.emit("if (%s == NULL) goto failed;" % field.name, depth+1)
self.emit("for (i = 0; i < len; i++) {", depth+1)
- self.emit("%s value;" % ctype, depth+2)
- self.emit("res = obj2ast_%s(PyList_GET_ITEM(tmp, i), &value, arena);" %
+ self.emit("%s val;" % ctype, depth+2)
+ self.emit("res = obj2ast_%s(PyList_GET_ITEM(tmp, i), &val, arena);" %
field.type, depth+2, reflow=False)
self.emit("if (res != 0) goto failed;", depth+2)
self.emit("if (len != PyList_GET_SIZE(tmp)) {", depth+2)
depth+3, reflow=False)
self.emit("goto failed;", depth+3)
self.emit("}", depth+2)
- self.emit("asdl_seq_SET(%s, i, value);" % field.name, depth+2)
+ self.emit("asdl_seq_SET(%s, i, val);" % field.name, depth+2)
self.emit("}", depth+1)
else:
self.emit("res = obj2ast_%s(tmp, &%s, arena);" %
PyOS_AfterFork(void)
{
#ifdef WITH_THREAD
- PyEval_ReInitThreads();
PyThread_ReInitTLS();
+ PyEval_ReInitThreads();
#endif
}
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Module field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Interactive field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Suite field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
decorator_list = asdl_seq_new(len, arena);
if (decorator_list == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"decorator_list\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(decorator_list, i, value);
+ asdl_seq_SET(decorator_list, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
bases = asdl_seq_new(len, arena);
if (bases == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"bases\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(bases, i, value);
+ asdl_seq_SET(bases, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
decorator_list = asdl_seq_new(len, arena);
if (decorator_list == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"decorator_list\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(decorator_list, i, value);
+ asdl_seq_SET(decorator_list, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
targets = asdl_seq_new(len, arena);
if (targets == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Delete field \"targets\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(targets, i, value);
+ asdl_seq_SET(targets, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
targets = asdl_seq_new(len, arena);
if (targets == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Assign field \"targets\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(targets, i, value);
+ asdl_seq_SET(targets, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
values = asdl_seq_new(len, arena);
if (values == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Print field \"values\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(values, i, value);
+ asdl_seq_SET(values, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "For field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
orelse = asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "For field \"orelse\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(orelse, i, value);
+ asdl_seq_SET(orelse, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "While field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
orelse = asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "While field \"orelse\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(orelse, i, value);
+ asdl_seq_SET(orelse, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "If field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
orelse = asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "If field \"orelse\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(orelse, i, value);
+ asdl_seq_SET(orelse, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "With field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "TryExcept field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
handlers = asdl_seq_new(len, arena);
if (handlers == NULL) goto failed;
for (i = 0; i < len; i++) {
- excepthandler_ty value;
- res = obj2ast_excepthandler(PyList_GET_ITEM(tmp, i), &value, arena);
+ excepthandler_ty val;
+ res = obj2ast_excepthandler(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "TryExcept field \"handlers\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(handlers, i, value);
+ asdl_seq_SET(handlers, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
orelse = asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "TryExcept field \"orelse\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(orelse, i, value);
+ asdl_seq_SET(orelse, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "TryFinally field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
finalbody = asdl_seq_new(len, arena);
if (finalbody == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "TryFinally field \"finalbody\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(finalbody, i, value);
+ asdl_seq_SET(finalbody, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
names = asdl_seq_new(len, arena);
if (names == NULL) goto failed;
for (i = 0; i < len; i++) {
- alias_ty value;
- res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena);
+ alias_ty val;
+ res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Import field \"names\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(names, i, value);
+ asdl_seq_SET(names, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
names = asdl_seq_new(len, arena);
if (names == NULL) goto failed;
for (i = 0; i < len; i++) {
- alias_ty value;
- res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena);
+ alias_ty val;
+ res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ImportFrom field \"names\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(names, i, value);
+ asdl_seq_SET(names, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
names = asdl_seq_new(len, arena);
if (names == NULL) goto failed;
for (i = 0; i < len; i++) {
- identifier value;
- res = obj2ast_identifier(PyList_GET_ITEM(tmp, i), &value, arena);
+ identifier val;
+ res = obj2ast_identifier(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Global field \"names\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(names, i, value);
+ asdl_seq_SET(names, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
values = asdl_seq_new(len, arena);
if (values == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "BoolOp field \"values\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(values, i, value);
+ asdl_seq_SET(values, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
keys = asdl_seq_new(len, arena);
if (keys == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Dict field \"keys\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(keys, i, value);
+ asdl_seq_SET(keys, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
values = asdl_seq_new(len, arena);
if (values == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Dict field \"values\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(values, i, value);
+ asdl_seq_SET(values, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
elts = asdl_seq_new(len, arena);
if (elts == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Set field \"elts\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(elts, i, value);
+ asdl_seq_SET(elts, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
generators = asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
- comprehension_ty value;
- res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
+ comprehension_ty val;
+ res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ListComp field \"generators\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(generators, i, value);
+ asdl_seq_SET(generators, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
generators = asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
- comprehension_ty value;
- res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
+ comprehension_ty val;
+ res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "SetComp field \"generators\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(generators, i, value);
+ asdl_seq_SET(generators, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
generators = asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
- comprehension_ty value;
- res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
+ comprehension_ty val;
+ res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "DictComp field \"generators\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(generators, i, value);
+ asdl_seq_SET(generators, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
generators = asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
- comprehension_ty value;
- res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
+ comprehension_ty val;
+ res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "GeneratorExp field \"generators\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(generators, i, value);
+ asdl_seq_SET(generators, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
ops = asdl_int_seq_new(len, arena);
if (ops == NULL) goto failed;
for (i = 0; i < len; i++) {
- cmpop_ty value;
- res = obj2ast_cmpop(PyList_GET_ITEM(tmp, i), &value, arena);
+ cmpop_ty val;
+ res = obj2ast_cmpop(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Compare field \"ops\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(ops, i, value);
+ asdl_seq_SET(ops, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
comparators = asdl_seq_new(len, arena);
if (comparators == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Compare field \"comparators\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(comparators, i, value);
+ asdl_seq_SET(comparators, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
args = asdl_seq_new(len, arena);
if (args == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Call field \"args\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(args, i, value);
+ asdl_seq_SET(args, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
keywords = asdl_seq_new(len, arena);
if (keywords == NULL) goto failed;
for (i = 0; i < len; i++) {
- keyword_ty value;
- res = obj2ast_keyword(PyList_GET_ITEM(tmp, i), &value, arena);
+ keyword_ty val;
+ res = obj2ast_keyword(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Call field \"keywords\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(keywords, i, value);
+ asdl_seq_SET(keywords, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
elts = asdl_seq_new(len, arena);
if (elts == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "List field \"elts\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(elts, i, value);
+ asdl_seq_SET(elts, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
elts = asdl_seq_new(len, arena);
if (elts == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Tuple field \"elts\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(elts, i, value);
+ asdl_seq_SET(elts, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
dims = asdl_seq_new(len, arena);
if (dims == NULL) goto failed;
for (i = 0; i < len; i++) {
- slice_ty value;
- res = obj2ast_slice(PyList_GET_ITEM(tmp, i), &value, arena);
+ slice_ty val;
+ res = obj2ast_slice(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ExtSlice field \"dims\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(dims, i, value);
+ asdl_seq_SET(dims, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
ifs = asdl_seq_new(len, arena);
if (ifs == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "comprehension field \"ifs\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(ifs, i, value);
+ asdl_seq_SET(ifs, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
body = asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
- stmt_ty value;
- res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
+ stmt_ty val;
+ res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ExceptHandler field \"body\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(body, i, value);
+ asdl_seq_SET(body, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
args = asdl_seq_new(len, arena);
if (args == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "arguments field \"args\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(args, i, value);
+ asdl_seq_SET(args, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
defaults = asdl_seq_new(len, arena);
if (defaults == NULL) goto failed;
for (i = 0; i < len; i++) {
- expr_ty value;
- res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
+ expr_ty val;
+ res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &val, arena);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "arguments field \"defaults\" changed size during iteration");
goto failed;
}
- asdl_seq_SET(defaults, i, value);
+ asdl_seq_SET(defaults, i, val);
}
Py_XDECREF(tmp);
tmp = NULL;
}
PyDoc_STRVAR(sum_doc,
-"sum(sequence[, start]) -> value\n\
+"sum(iterable[, start]) -> value\n\
\n\
-Return the sum of a sequence of numbers (NOT strings) plus the value\n\
-of parameter 'start' (which defaults to 0). When the sequence is\n\
+Return the sum of an iterable or sequence of numbers (NOT strings)\n\
+plus the value of 'start' (which defaults to 0). When the sequence is\n\
empty, return start.");
{
w = POP();
v = TOP();
- if (PyString_CheckExact(v))
+ if (PyString_CheckExact(v)
+ && (!PyString_Check(w) || PyString_CheckExact(w))) {
+ /* fast path; string formatting, but not if the RHS is a str subclass
+ (see issue28598) */
x = PyString_Format(v, w);
- else
+ } else {
x = PyNumber_Remainder(v, w);
+ }
Py_DECREF(v);
Py_DECREF(w);
SET_TOP(x);
if ((x = f->f_locals) == NULL) {
PyErr_SetString(PyExc_SystemError,
"no locals found during 'import *'");
+ Py_DECREF(v);
break;
}
READ_TIMESTAMP(intr0);
/* Extract a slice index from a PyInt or PyLong or an object with the
nb_index slot defined, and store in *pi.
Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
- and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
+ and silently boost values less than PY_SSIZE_T_MIN to PY_SSIZE_T_MIN.
Return 0 on error, 1 on success.
*/
/* Note: If v is NULL, return success without storing into *pi. This
int
_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
{
- if (v != NULL) {
+ if (v != NULL && v != Py_None) {
Py_ssize_t x;
if (PyInt_Check(v)) {
/* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
return 1;
}
+int
+_PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
+{
+ Py_ssize_t x;
+ if (PyIndex_Check(v)) {
+ x = PyNumber_AsSsize_t(v, NULL);
+ if (x == -1 && PyErr_Occurred())
+ return 0;
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "slice indices must be integers or "
+ "have an __index__ method");
+ return 0;
+ }
+ *pi = x;
+ return 1;
+}
+
+
#undef ISINDEX
#define ISINDEX(x) ((x) == NULL || \
PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
static char cprt[] =
"\
-Copyright (c) 2001-2016 Python Software Foundation.\n\
+Copyright (c) 2001-2017 Python Software Foundation.\n\
All Rights Reserved.\n\
\n\
Copyright (c) 2000 BeOpen.com.\n\
/* If we failed to dig out the 'code' attribute,
just let the else clause below print the error. */
}
- if (PyInt_Check(value))
+ if (PyInt_Check(value) || PyLong_Check(value))
exitcode = (int)PyInt_AsLong(value);
else {
PyObject *sys_stderr = PySys_GetObject("stderr");
#include <windows.h>
#else
#include <fcntl.h>
-#if defined(HAVE_GETRANDOM) || defined(HAVE_GETENTROPY)
+#if defined(HAVE_SYS_RANDOM_H) && (defined(HAVE_GETRANDOM) || defined(HAVE_GETENTROPY))
#include <sys/random.h>
#endif
#endif
}
/* Issue #25003: Don't use getentropy() on Solaris (available since
- * Solaris 11.3), it is blocking whereas os.urandom() should not block. */
-#elif defined(HAVE_GETENTROPY) && !defined(sun)
+ Solaris 11.3), it is blocking whereas os.urandom() should not block.
+
+ Issue #29188: Don't use getentropy() on Linux since the glibc 2.24
+ implements it with the getrandom() syscall which can fail with ENOSYS,
+ and this error is not supported in py_getentropy() and getrandom() is called
+ with flags=0 which blocks until system urandom is initialized, which is not
+ the desired behaviour to seed the Python hash secret nor for os.urandom():
+ see the PEP 524 which was only implemented in Python 3.6. */
+#elif defined(HAVE_GETENTROPY) && !defined(sun) && !defined(linux)
#define PY_GETENTROPY 1
/* Fill buffer with size pseudo-random bytes generated by getentropy().
SET_SYS_FROM_STRING("subversion",
Py_BuildValue("(ssz)", "CPython", branch,
svn_revision));
- SET_SYS_FROM_STRING("_mercurial",
- Py_BuildValue("(szz)", "CPython", _Py_hgidentifier(),
- _Py_hgversion()));
+ SET_SYS_FROM_STRING("_git",
+ Py_BuildValue("(szz)", "CPython", _Py_gitidentifier(),
+ _Py_gitversion()));
SET_SYS_FROM_STRING("dont_write_bytecode",
PyBool_FromLong(Py_DontWriteBytecodeFlag));
SET_SYS_FROM_STRING("api_version",
int
PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
{
- int success;
+ int success = 0;
pthread_lock *thelock = (pthread_lock *)lock;
int status, error = 0;
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
- status = pthread_mutex_lock( &thelock->mut );
- CHECK_STATUS("pthread_mutex_lock[1]");
- success = thelock->locked == 0;
-
- if ( !success && waitflag ) {
- /* continue trying until we get the lock */
-
- /* mut must be locked by me -- part of the condition
- * protocol */
- while ( thelock->locked ) {
- status = pthread_cond_wait(&thelock->lock_released,
- &thelock->mut);
- CHECK_STATUS("pthread_cond_wait");
+ if (waitflag) {
+ status = pthread_mutex_lock( &thelock->mut );
+ CHECK_STATUS("pthread_mutex_lock[1]");
+ }
+ else {
+ status = pthread_mutex_trylock( &thelock->mut );
+ if (status != EBUSY)
+ CHECK_STATUS("pthread_mutex_trylock[1]");
+ }
+ if (status == 0) {
+ success = thelock->locked == 0;
+
+ if ( !success && waitflag ) {
+ /* continue trying until we get the lock */
+
+ /* mut must be locked by me -- part of the condition
+ * protocol */
+ while ( thelock->locked ) {
+ status = pthread_cond_wait(&thelock->lock_released,
+ &thelock->mut);
+ CHECK_STATUS("pthread_cond_wait");
+ }
+ success = 1;
}
- success = 1;
+
+ if (success) thelock->locked = 1;
+ status = pthread_mutex_unlock( &thelock->mut );
+ CHECK_STATUS("pthread_mutex_unlock[1]");
}
- if (success) thelock->locked = 1;
- status = pthread_mutex_unlock( &thelock->mut );
- CHECK_STATUS("pthread_mutex_unlock[1]");
if (error) success = 0;
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-This is Python version 2.7.13
+This is Python version 2.7.14
=============================
Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
-2012, 2013, 2014, 2015, 2016 Python Software Foundation. All rights reserved.
+2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation. All rights
+reserved.
Copyright (c) 2000 BeOpen.com.
All rights reserved.
out where in the world those addresses originate from,
based on the top-level domain country code found in
the address.
+
+A generic benchmark suite is maintained separately at https://github.com/python/performance
if NOT "%1"=="" (set regrtest_args=%regrtest_args% %1) & shift & goto CheckOpts\r
\r
echo on\r
-call "%here%..\..\PCbuild\rt.bat" %rt_opts% -uall -rwW %regrtest_args%\r
+call "%here%..\..\PCbuild\rt.bat" %rt_opts% -uall -rwW --slowest %regrtest_args%\r
--- /dev/null
+"""distutils.command.bdist_wininst
+
+Suppresses the 'bdist_wininst' command, while still allowing
+setuptools to import it without breaking."""
+
+from distutils.core import Command
+from distutils.errors import DistutilsPlatformError
+
+class bdist_wininst(Command):
+ description = "create an executable installer for MS Windows"
+
+ def initialize_options(self):
+ pass
+
+ def finalize_options(self):
+ pass
+
+ def run(self):
+ raise DistutilsPlatformError("bdist_wininst is not supported "
+ "in this Python distribution")
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <PropertyGroup>
- <ProjectGuid>{6BA7092C-0093-47F0-9ED2-282AEE981E14}</ProjectGuid>
- <OutputName>python2</OutputName>
- <OutputName Condition="$(Platform) == 'x86' or $(Platform) == 'Win32' or $(Platform) == ''">$(OutputName)x86</OutputName>
- <OutputPath Condition="$(OutputPath) == ''">$(MSBuildThisFileDirectory)</OutputPath>
- <OutputSuffix></OutputSuffix>
- <SupportSigning>false</SupportSigning>
- <BuildForRelease Condition="$(BuildForRelease) == ''">true</BuildForRelease>
- </PropertyGroup>
-
- <Import Project="..\..\PCBuild\python.props" />
-
- <PropertyGroup>
- <NuspecVersion>$(MajorVersionNumber).$(MinorVersionNumber).$(MicroVersionNumber)</NuspecVersion>
- <SignOutput>false</SignOutput>
- <TargetName>$(OutputName).$(NuspecVersion)</TargetName>
- <TargetExt>.nupkg</TargetExt>
- <TargetPath>$(OutputPath)\$(TargetName)$(TargetExt)</TargetPath>
- <IntermediateOutputPath>$(MSBuildThisFileDirectory)\obj_$(ArchName)</IntermediateOutputPath>
-
- <CleanCommand>rmdir /q/s "$(IntermediateOutputPath)"</CleanCommand>
-
- <Python Condition="$(Python) == ''">py</Python>
- <PythonArguments>"$(Python)" "$(MSBuildThisFileDirectory)\make_zip.py"</PythonArguments>
- <PythonArguments>$(PythonArguments) -s "$(PySourcePath.Trim('\'))" -t "$(IntermediateOutputPath)" -a $(ArchName)</PythonArguments>
-
- <PipArguments>"$(IntermediateOutputPath)\python.exe" -B -c "import sys; sys.path.append(r'$(PySourcePath)\Lib'); import ensurepip; ensurepip._main()"</PipArguments>
- <PackageArguments Condition="$(Packages) != ''">"$(IntermediateOutputPath)\python.exe" -B -m pip install -U $(Packages)</PackageArguments>
-
- <NugetArguments>"$(Nuget)" pack "$(MSBuildThisFileDirectory)\$(OutputName).nuspec"</NugetArguments>
- <NugetArguments>$(NugetArguments) -BasePath "$(IntermediateOutputPath)"</NugetArguments>
- <NugetArguments>$(NugetArguments) -OutputDirectory "$(OutputPath.Trim(`\`))"</NugetArguments>
- <NugetArguments>$(NugetArguments) -Version "$(NuspecVersion)"</NugetArguments>
- <NugetArguments>$(NugetArguments) -NoPackageAnalysis -NonInteractive</NugetArguments>
- </PropertyGroup>
-
- <Target Name="_NugetMissing" BeforeTargets="_Build" Condition="!Exists($(Nuget))">
- <Error Text="$$(Nuget) could not be found. Specify a valid path on the command line." />
- </Target>
-
- <Target Name="_Build">
- <Exec Command="$(CleanCommand)" />
- <Exec Command="$(PythonArguments)" />
- <Exec Command="$(PipArguments)" />
- <Exec Command="$(PackageArguments)" Condition="$(PackageArguments) != ''" />
- <Exec Command="$(NugetArguments)" />
- </Target>
-
- <Target Name="AfterBuild" />
- <Target Name="Build" DependsOnTargets="_Build;AfterBuild" />
-</Project>
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectGuid>{6BA7092C-0093-47F0-9ED2-282AEE981E14}</ProjectGuid>\r
+ <OutputName>python2</OutputName>\r
+ <OutputName Condition="$(Platform) == 'x86' or $(Platform) == 'Win32' or $(Platform) == ''">$(OutputName)x86</OutputName>\r
+ <OutputPath Condition="$(OutputPath) == ''">$(MSBuildThisFileDirectory)</OutputPath>\r
+ <OutputSuffix></OutputSuffix>\r
+ <SupportSigning>false</SupportSigning>\r
+ <BuildForRelease Condition="$(BuildForRelease) == ''">true</BuildForRelease>\r
+ </PropertyGroup>\r
+\r
+ <Import Project="..\..\PCBuild\python.props" />\r
+\r
+ <PropertyGroup>\r
+ <NuspecVersion>$(MajorVersionNumber).$(MinorVersionNumber).$(MicroVersionNumber)</NuspecVersion>\r
+ <SignOutput>false</SignOutput>\r
+ <TargetName>$(OutputName).$(NuspecVersion)</TargetName>\r
+ <TargetExt>.nupkg</TargetExt>\r
+ <TargetPath>$(OutputPath)\$(TargetName)$(TargetExt)</TargetPath>\r
+ <IntermediateOutputPath>$(MSBuildThisFileDirectory)\obj_$(ArchName)</IntermediateOutputPath>\r
+ \r
+ <CleanCommand>rmdir /q/s "$(IntermediateOutputPath)"</CleanCommand>\r
+ \r
+ <Python Condition="$(Python) == ''">py</Python>\r
+ <PythonArguments>"$(Python)" "$(MSBuildThisFileDirectory)\make_zip.py"</PythonArguments>\r
+ <PythonArguments>$(PythonArguments) -s "$(PySourcePath.Trim('\'))" -t "$(IntermediateOutputPath)" -a $(ArchName)</PythonArguments>\r
+ \r
+ <PipArguments>"$(IntermediateOutputPath)\python.exe" -B -c "import sys; sys.path.append(r'$(PySourcePath)\Lib'); import ensurepip; ensurepip._main()"</PipArguments>\r
+ <PackageArguments Condition="$(Packages) != ''">"$(IntermediateOutputPath)\python.exe" -B -m pip install -U $(Packages)</PackageArguments>\r
+ \r
+ <NugetArguments>"$(Nuget)" pack "$(MSBuildThisFileDirectory)\$(OutputName).nuspec"</NugetArguments>\r
+ <NugetArguments>$(NugetArguments) -BasePath "$(IntermediateOutputPath)"</NugetArguments>\r
+ <NugetArguments>$(NugetArguments) -OutputDirectory "$(OutputPath.Trim(`\`))"</NugetArguments>\r
+ <NugetArguments>$(NugetArguments) -Version "$(NuspecVersion)"</NugetArguments>\r
+ <NugetArguments>$(NugetArguments) -NoPackageAnalysis -NonInteractive</NugetArguments>\r
+ </PropertyGroup>\r
+\r
+ <Target Name="_NugetMissing" BeforeTargets="_Build" Condition="!Exists($(Nuget))">\r
+ <Error Text="$$(Nuget) could not be found. Specify a valid path on the command line." />\r
+ </Target>\r
+\r
+ <Target Name="_Build">\r
+ <Exec Command="$(CleanCommand)" />\r
+ <Exec Command="$(PythonArguments)" />\r
+ <Exec Command="$(PipArguments)" />\r
+ <Exec Command="$(PackageArguments)" Condition="$(PackageArguments) != ''" />\r
+ <Exec Command="$(NugetArguments)" />\r
+ </Target>\r
+\r
+ <Target Name="AfterBuild" />\r
+ <Target Name="Build" DependsOnTargets="_Build;AfterBuild" />\r
+</Project>\r
import os
import tempfile
+from itertools import chain
from pathlib import Path
from zipfile import ZipFile, ZIP_DEFLATED
import subprocess
try:
for t, s, p, c in layout:
- s = source / s.replace("$arch", arch)
- copied = copy_to_layout(temp / t.rstrip('/'), rglob(s, p, c))
+ fs = source / s.replace("$arch", arch)
+ files = rglob(fs, p, c)
+ extra_files = []
+ if s == 'Lib' and p == '**/*':
+ extra_files.append((
+ source / 'tools' / 'nuget' / 'distutils.command.bdist_wininst.py',
+ Path('distutils') / 'command' / 'bdist_wininst.py'
+ ))
+ copied = copy_to_layout(temp / t.rstrip('/'), chain(files, extra_files))
print('Copied {} files'.format(copied))
if out:
import untabify
+# Excluded directories which are copies of external libraries:
+# don't check their coding style
+EXCLUDE_DIRS = [os.path.join('Modules', '_ctypes', 'libffi'),
+ os.path.join('Modules', '_ctypes', 'libffi_osx'),
+ os.path.join('Modules', '_ctypes', 'libffi_msvc'),
+ os.path.join('Modules', 'expat'),
+ os.path.join('Modules', 'zlib')]
SRCDIR = sysconfig.get_config_var('srcdir')
st.stderr.close()
+def get_git_branch():
+ """Get the symbolic name for the current git branch"""
+ cmd = "git rev-parse --abbrev-ref HEAD".split()
+ try:
+ return subprocess.check_output(cmd, stderr=subprocess.PIPE)
+ except subprocess.CalledProcessError:
+ return None
+
+
+def get_git_upstream_remote():
+ """Get the remote name to use for upstream branches
+
+ Uses "upstream" if it exists, "origin" otherwise
+ """
+ cmd = "git remote get-url upstream".split()
+ try:
+ subprocess.check_output(cmd, stderr=subprocess.PIPE)
+ except subprocess.CalledProcessError:
+ return "origin"
+ return "upstream"
+
+
+@status("Getting base branch for PR",
+ info=lambda x: x if x is not None else "not a PR branch")
+def get_base_branch():
+ if not os.path.exists(os.path.join(SRCDIR, '.git')):
+ # Not a git checkout, so there's no base branch
+ return None
+ version = sys.version_info
+ if version.releaselevel == 'alpha':
+ base_branch = "master"
+ else:
+ base_branch = "{0.major}.{0.minor}".format(version)
+ this_branch = get_git_branch()
+ if this_branch is None or this_branch == base_branch:
+ # Not on a git PR branch, so there's no base branch
+ return None
+ upstream_remote = get_git_upstream_remote()
+ return upstream_remote + "/" + base_branch
+
+
@status("Getting the list of files that have been added/changed",
info=lambda x: n_files_str(len(x)))
-def changed_files():
- """Get the list of changed or added files from the VCS."""
+def changed_files(base_branch=None):
+ """Get the list of changed or added files from Mercurial or git."""
if os.path.isdir(os.path.join(SRCDIR, '.hg')):
- vcs = 'hg'
+ if base_branch is not None:
+ sys.exit('need a git checkout to check PR status')
cmd = 'hg status --added --modified --no-status'
if mq_patches_applied():
cmd += ' --rev qparent'
- elif os.path.isdir('.svn'):
- vcs = 'svn'
- cmd = 'svn status --quiet --non-interactive --ignore-externals'
+ st = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
+ try:
+ filenames = [x.decode().rstrip() for x in st.stdout]
+ finally:
+ st.stdout.close()
+ elif os.path.exists(os.path.join(SRCDIR, '.git')):
+ # We just use an existence check here as:
+ # directory = normal git checkout/clone
+ # file = git worktree directory
+ if base_branch:
+ cmd = 'git diff --name-status ' + base_branch
+ else:
+ cmd = 'git status --porcelain'
+ filenames = []
+ st = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
+ try:
+ for line in st.stdout:
+ line = line.decode().rstrip()
+ status_text, filename = line.split(None, 1)
+ status = set(status_text)
+ # modified, added or unmerged files
+ if not status.intersection('MAU'):
+ continue
+ if ' -> ' in filename:
+ # file is renamed
+ filename = filename.split(' -> ', 2)[1].strip()
+ filenames.append(filename)
+ finally:
+ st.stdout.close()
else:
- sys.exit('need a checkout to get modified files')
+ sys.exit('need a Mercurial or git checkout to get modified files')
- st = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
- try:
- st.wait()
- if vcs == 'hg':
- return [x.decode().rstrip() for x in st.stdout]
- else:
- output = (x.decode().rstrip().rsplit(None, 1)[-1]
- for x in st.stdout if x[0] in 'AM')
- return set(path for path in output if os.path.isfile(path))
- finally:
- st.stdout.close()
+ filenames2 = []
+ for filename in filenames:
+ # Normalize the path to be able to match using .startswith()
+ filename = os.path.normpath(filename)
+ if any(filename.startswith(path) for path in EXCLUDE_DIRS):
+ # Exclude the file
+ continue
+ filenames2.append(filename)
+
+ return filenames2
def report_modified_files(file_paths):
def main():
- file_paths = changed_files()
+ base_branch = get_base_branch()
+ file_paths = changed_files(base_branch)
python_files = [fn for fn in file_paths if fn.endswith('.py')]
c_files = [fn for fn in file_paths if fn.endswith(('.c', '.h'))]
doc_files = [fn for fn in file_paths if fn.startswith('Doc') and
#! /bin/sh
# Attempt to guess a canonical system name.
-# Copyright 1992-2016 Free Software Foundation, Inc.
+# Copyright 1992-2017 Free Software Foundation, Inc.
-timestamp='2016-10-02'
+timestamp='2017-05-27'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
GNU config.guess ($timestamp)
Originally written by Per Bothner.
-Copyright 1992-2016 Free Software Foundation, Inc.
+Copyright 1992-2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
UNAME_PROCESSOR=`/usr/bin/uname -p`
case ${UNAME_PROCESSOR} in
amd64)
- echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
- *)
- echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+ UNAME_PROCESSOR=x86_64 ;;
+ i386)
+ UNAME_PROCESSOR=i586 ;;
esac
+ echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
exit ;;
i*:CYGWIN*:*)
echo ${UNAME_MACHINE}-pc-cygwin
if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then
if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
- (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
- grep IS_64BIT_ARCH >/dev/null
+ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+ grep IS_64BIT_ARCH >/dev/null
then
case $UNAME_PROCESSOR in
i386) UNAME_PROCESSOR=x86_64 ;;
powerpc) UNAME_PROCESSOR=powerpc64 ;;
esac
fi
+ # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
+ if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
+ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+ grep IS_PPC >/dev/null
+ then
+ UNAME_PROCESSOR=powerpc
+ fi
fi
elif test "$UNAME_PROCESSOR" = i386 ; then
# Avoid executing cc on OS X 10.9, as it ships with a stub
*:QNX:*:4*)
echo i386-pc-qnx
exit ;;
- NEO-?:NONSTOP_KERNEL:*:*)
+ NEO-*:NONSTOP_KERNEL:*:*)
echo neo-tandem-nsk${UNAME_RELEASE}
exit ;;
NSE-*:NONSTOP_KERNEL:*:*)
echo nse-tandem-nsk${UNAME_RELEASE}
exit ;;
- NSR-?:NONSTOP_KERNEL:*:*)
+ NSR-*:NONSTOP_KERNEL:*:*)
echo nsr-tandem-nsk${UNAME_RELEASE}
exit ;;
+ NSX-*:NONSTOP_KERNEL:*:*)
+ echo nsx-tandem-nsk${UNAME_RELEASE}
+ exit ;;
*:NonStop-UX:*:*)
echo mips-compaq-nonstopux
exit ;;
#! /bin/sh
# Configuration validation subroutine script.
-# Copyright 1992-2016 Free Software Foundation, Inc.
+# Copyright 1992-2017 Free Software Foundation, Inc.
-timestamp='2016-11-19'
+timestamp='2017-04-02'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
version="\
GNU config.sub ($timestamp)
-Copyright 1992-2016 Free Software Foundation, Inc.
+Copyright 1992-2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
| fido | fr30 | frv | ft32 \
| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
| hexagon \
- | i370 | i860 | i960 | ia64 \
+ | i370 | i860 | i960 | ia16 | ia64 \
| ip2k | iq2000 \
| k1om \
| le32 | le64 \
| ubicom32 \
| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
| visium \
+ | wasm32 \
| we32k \
| x86 | xc16x | xstormy16 | xtensa \
| z8k | z80)
| h8300-* | h8500-* \
| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
| hexagon-* \
- | i*86-* | i860-* | i960-* | ia64-* \
+ | i*86-* | i860-* | i960-* | ia16-* | ia64-* \
| ip2k-* | iq2000-* \
| k1om-* \
| le32-* | le64-* \
| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
| vax-* \
| visium-* \
+ | wasm32-* \
| we32k-* \
| x86-* | x86_64-* | xc16x-* | xps100-* \
| xstormy16-* | xtensa*-* \
nsr-tandem)
basic_machine=nsr-tandem
;;
+ nsx-tandem)
+ basic_machine=nsx-tandem
+ ;;
op50n-* | op60c-*)
basic_machine=hppa1.1-oki
os=-proelf
basic_machine=a29k-wrs
os=-vxworks
;;
+ wasm32)
+ basic_machine=wasm32-unknown
+ ;;
w65*)
basic_machine=w65-wdc
os=-none
| -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
| -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
| -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
- | -onefs* | -tirtos* | -phoenix* | -fuchsia*)
+ | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox*)
# Remember, each alternative MUST END IN *, to match a version number.
;;
-qnx*)
sparc-* | *-sun)
os=-sunos4.1.1
;;
+ pru-*)
+ os=-elf
+ ;;
*-be)
os=-beos
;;
INSTALL_DATA
INSTALL_SCRIPT
INSTALL_PROGRAM
-HAS_HG
-HGBRANCH
-HGTAG
-HGVERSION
-SVNVERSION
+HAS_GIT
+GITBRANCH
+GITTAG
+GITVERSION
ARFLAGS
ac_ct_AR
AR
CONFIG_ARGS
SOVERSION
VERSION
-GENERATED_COMMENT
PYTHON_FOR_BUILD
+PYTHON_FOR_REGEN
host_os
host_vendor
host_cpu
docdir
oldincludedir
includedir
-runstatedir
localstatedir
sharedstatedir
sysconfdir
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
-runstatedir='${localstatedir}/run'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
| -silent | --silent | --silen | --sile | --sil)
silent=yes ;;
- -runstatedir | --runstatedir | --runstatedi | --runstated \
- | --runstate | --runstat | --runsta | --runst | --runs \
- | --run | --ru | --r)
- ac_prev=runstatedir ;;
- -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
- | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
- | --run=* | --ru=* | --r=*)
- runstatedir=$ac_optarg ;;
-
-sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
ac_prev=sbindir ;;
-sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
datadir sysconfdir sharedstatedir localstatedir includedir \
oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
- libdir localedir mandir runstatedir
+ libdir localedir mandir
do
eval ac_val=\$$ac_var
# Remove trailing slashes.
--sysconfdir=DIR read-only single-machine data [PREFIX/etc]
--sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
--localstatedir=DIR modifiable single-machine data [PREFIX/var]
- --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run]
--libdir=DIR object code libraries [EPREFIX/lib]
--includedir=DIR C header files [PREFIX/include]
--oldincludedir=DIR C header files for non-gcc [/usr/include]
# pybuilddir.txt will be created by --generate-posix-vars in the Makefile
rm -f pybuilddir.txt
+for ac_prog in python$PACKAGE_VERSION python3 python
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_PYTHON_FOR_REGEN+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$PYTHON_FOR_REGEN"; then
+ ac_cv_prog_PYTHON_FOR_REGEN="$PYTHON_FOR_REGEN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_PYTHON_FOR_REGEN="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+PYTHON_FOR_REGEN=$ac_cv_prog_PYTHON_FOR_REGEN
+if test -n "$PYTHON_FOR_REGEN"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_FOR_REGEN" >&5
+$as_echo "$PYTHON_FOR_REGEN" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$PYTHON_FOR_REGEN" && break
+done
+test -n "$PYTHON_FOR_REGEN" || PYTHON_FOR_REGEN="python3"
+
+
+
if test "$cross_compiling" = yes; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for python interpreter for cross build" >&5
$as_echo_n "checking for python interpreter for cross build... " >&6; }
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $interp" >&5
$as_echo "$interp" >&6; }
- PYTHON_FOR_BUILD='_PYTHON_PROJECT_BASE=$(abs_builddir) _PYTHON_HOST_PLATFORM=$(_PYTHON_HOST_PLATFORM) PYTHONPATH=$(shell test -f pybuilddir.txt && echo $(abs_builddir)/`cat pybuilddir.txt`:)$(srcdir)/Lib:$(srcdir)/Lib/$(PLATDIR) '$interp
+ PYTHON_FOR_BUILD='_PYTHON_PROJECT_BASE=$(abs_builddir) _PYTHON_HOST_PLATFORM=$(_PYTHON_HOST_PLATFORM) PYTHONPATH=$(shell test -f pybuilddir.txt && echo $(abs_builddir)/`cat pybuilddir.txt`:)$(srcdir)/Lib _PYTHON_SYSCONFIGDATA_NAME=_sysconfigdata_$(ABIFLAGS)_$(MACHDEP)_$(MULTIARCH) '$interp
fi
- # Used to comment out stuff for rebuilding generated files
- GENERATED_COMMENT='#'
elif test "$cross_compiling" = maybe; then
as_fn_error $? "Cross compiling required --host=HOST-TUPLE and --build=ARCH" "$LINENO" 5
else
PYTHON_FOR_BUILD='./$(BUILDPYTHON) -E'
- GENERATED_COMMENT=''
fi
-
if test "$prefix" != "/"; then
prefix=`echo "$prefix" | sed -e 's/\/$//g'`
fi
fi
-# Extract the first word of "svnversion", so it can be a program name with args.
-set dummy svnversion; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_SVNVERSION+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- if test -n "$SVNVERSION"; then
- ac_cv_prog_SVNVERSION="$SVNVERSION" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for ac_exec_ext in '' $ac_executable_extensions; do
- if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
- ac_cv_prog_SVNVERSION="found"
- $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
- break 2
- fi
-done
- done
-IFS=$as_save_IFS
- test -z "$ac_cv_prog_SVNVERSION" && ac_cv_prog_SVNVERSION="not-found"
-fi
-fi
-SVNVERSION=$ac_cv_prog_SVNVERSION
-if test -n "$SVNVERSION"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SVNVERSION" >&5
-$as_echo "$SVNVERSION" >&6; }
-else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-if test $SVNVERSION = found
+if test -e $srcdir/.git
then
- SVNVERSION="svnversion \$(srcdir)"
-else
- SVNVERSION="echo Unversioned directory"
-fi
-
-
-
-
-# Extract the first word of "hg", so it can be a program name with args.
-set dummy hg; ac_word=$2
+# Extract the first word of "git", so it can be a program name with args.
+set dummy git; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_HAS_HG+:} false; then :
+if ${ac_cv_prog_HAS_GIT+:} false; then :
$as_echo_n "(cached) " >&6
else
- if test -n "$HAS_HG"; then
- ac_cv_prog_HAS_HG="$HAS_HG" # Let the user override the test.
+ if test -n "$HAS_GIT"; then
+ ac_cv_prog_HAS_GIT="$HAS_GIT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
- ac_cv_prog_HAS_HG="found"
+ ac_cv_prog_HAS_GIT="found"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
IFS=$as_save_IFS
- test -z "$ac_cv_prog_HAS_HG" && ac_cv_prog_HAS_HG="not-found"
+ test -z "$ac_cv_prog_HAS_GIT" && ac_cv_prog_HAS_GIT="not-found"
fi
fi
-HAS_HG=$ac_cv_prog_HAS_HG
-if test -n "$HAS_HG"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAS_HG" >&5
-$as_echo "$HAS_HG" >&6; }
+HAS_GIT=$ac_cv_prog_HAS_GIT
+if test -n "$HAS_GIT"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAS_GIT" >&5
+$as_echo "$HAS_GIT" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
-if test $HAS_HG = found
+else
+HAS_GIT=no-repository
+fi
+if test $HAS_GIT = found
then
- HGVERSION="hg id -i \$(srcdir)"
- HGTAG="hg id -t \$(srcdir)"
- HGBRANCH="hg id -b \$(srcdir)"
+ GITVERSION="git -C \$(srcdir) rev-parse --short HEAD"
+ GITTAG="git -C \$(srcdir) describe --all --always --dirty"
+ GITBRANCH="git -C \$(srcdir) name-rev --name-only HEAD"
else
- HGVERSION=""
- HGTAG=""
- HGBRANCH=""
+ GITVERSION=""
+ GITTAG=""
+ GITBRANCH=""
fi
case $MACHDEP in
# Check whether --enable-optimizations was given.
if test "${enable_optimizations+set}" = set; then :
enableval=$enable_optimizations;
-if test "$withval" != no
+if test "$enableval" != no
then
Py_OPT='true'
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
# compile working code using it and both test_distutils and test_gdb are
# broken when you do managed to get a toolchain that works with it. People
# who want LTO need to use --with-lto themselves.
- Py_LTO='true'
DEF_MAKE_ALL_RULE="profile-opt"
REQUIRE_PGO="yes"
DEF_MAKE_RULE="build_all"
unistd.h utime.h \
sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
sys/lock.h sys/mkdev.h sys/modem.h \
-sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
+sys/param.h sys/poll.h sys/random.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
sys/termio.h sys/time.h \
sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
done
-SRCDIRS="Parser Grammar Objects Python Modules Mac"
+SRCDIRS="Parser Objects Python Modules"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for build directories" >&5
$as_echo_n "checking for build directories... " >&6; }
for dir in $SRCDIRS; do
# pybuilddir.txt will be created by --generate-posix-vars in the Makefile
rm -f pybuilddir.txt
+AC_CHECK_PROGS(PYTHON_FOR_REGEN, python$PACKAGE_VERSION python3 python, python3)
+AC_SUBST(PYTHON_FOR_REGEN)
+
if test "$cross_compiling" = yes; then
AC_MSG_CHECKING([for python interpreter for cross build])
if test -z "$PYTHON_FOR_BUILD"; then
AC_MSG_RESULT($interp)
PYTHON_FOR_BUILD='_PYTHON_PROJECT_BASE=$(abs_builddir) _PYTHON_HOST_PLATFORM=$(_PYTHON_HOST_PLATFORM) PYTHONPATH=$(shell test -f pybuilddir.txt && echo $(abs_builddir)/`cat pybuilddir.txt`:)$(srcdir)/Lib:$(srcdir)/Lib/$(PLATDIR) '$interp
fi
- # Used to comment out stuff for rebuilding generated files
- GENERATED_COMMENT='#'
elif test "$cross_compiling" = maybe; then
AC_MSG_ERROR([Cross compiling required --host=HOST-TUPLE and --build=ARCH])
else
PYTHON_FOR_BUILD='./$(BUILDPYTHON) -E'
- GENERATED_COMMENT=''
fi
AC_SUBST(PYTHON_FOR_BUILD)
-AC_SUBST(GENERATED_COMMENT)
dnl Ensure that if prefix is specified, it does not end in a slash. If
dnl it does, we get path names containing '//' which is both ugly and
ARFLAGS="rc"
fi
-AC_SUBST(SVNVERSION)
-AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
-if test $SVNVERSION = found
+AC_SUBST(GITVERSION)
+AC_SUBST(GITTAG)
+AC_SUBST(GITBRANCH)
+
+if test -e $srcdir/.git
then
- SVNVERSION="svnversion \$(srcdir)"
+AC_CHECK_PROG(HAS_GIT, git, found, not-found)
else
- SVNVERSION="echo Unversioned directory"
+HAS_GIT=no-repository
fi
-
-AC_SUBST(HGVERSION)
-AC_SUBST(HGTAG)
-AC_SUBST(HGBRANCH)
-AC_CHECK_PROG(HAS_HG, hg, found, not-found)
-if test $HAS_HG = found
+if test $HAS_GIT = found
then
- HGVERSION="hg id -i \$(srcdir)"
- HGTAG="hg id -t \$(srcdir)"
- HGBRANCH="hg id -b \$(srcdir)"
+ GITVERSION="git -C \$(srcdir) rev-parse --short HEAD"
+ GITTAG="git -C \$(srcdir) describe --all --always --dirty"
+ GITBRANCH="git -C \$(srcdir) name-rev --name-only HEAD"
else
- HGVERSION=""
- HGTAG=""
- HGBRANCH=""
+ GITVERSION=""
+ GITTAG=""
+ GITBRANCH=""
fi
case $MACHDEP in
AC_MSG_CHECKING(for --enable-optimizations)
AC_ARG_ENABLE(optimizations, AS_HELP_STRING([--enable-optimizations], [Enable expensive optimizations (PGO, maybe LTO, etc). Disabled by default.]),
[
-if test "$withval" != no
+if test "$enableval" != no
then
Py_OPT='true'
AC_MSG_RESULT(yes);
unistd.h utime.h \
sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
sys/lock.h sys/mkdev.h sys/modem.h \
-sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
+sys/param.h sys/poll.h sys/random.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
sys/termio.h sys/time.h \
sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
done
AC_SUBST(SRCDIRS)
-SRCDIRS="Parser Grammar Objects Python Modules Mac"
+SRCDIRS="Parser Objects Python Modules"
AC_MSG_CHECKING(for build directories)
for dir in $SRCDIRS; do
if test ! -d $dir; then
/* Define to 1 if you have the <sys/poll.h> header file. */
#undef HAVE_SYS_POLL_H
+/* Define to 1 if you have the <sys/random.h> header file. */
+#undef HAVE_SYS_RANDOM_H
+
/* Define to 1 if you have the <sys/resource.h> header file. */
#undef HAVE_SYS_RESOURCE_H
expat_inc = [os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')]
define_macros = [
('HAVE_EXPAT_CONFIG_H', '1'),
+ # bpo-30947: Python uses best available entropy sources to
+ # call XML_SetHashSalt(), expat entropy sources are not needed
+ ('XML_POOR_ENTROPY', '1'),
]
expat_lib = []
expat_sources = ['expat/xmlparse.c',
projects / platform / upstream / python.git / commitdiff