Merged revisions 78760,78771-78773,78802,78922,78952 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r78760 | georg.brandl | 2010-03-07 16:23:59 +0100 (So, 07 Mär 2010) | 1 line

  #5341: more built-in vs builtin fixes.
........
  r78771 | georg.brandl | 2010-03-07 21:58:31 +0100 (So, 07 Mär 2010) | 1 line

  #8085: The function is called PyObject_NewVar, not PyObject_VarNew.
........
  r78772 | georg.brandl | 2010-03-07 22:12:28 +0100 (So, 07 Mär 2010) | 1 line

  #8039: document conditional expressions better, giving them their own section.
........
  r78773 | georg.brandl | 2010-03-07 22:32:06 +0100 (So, 07 Mär 2010) | 1 line

  #8044: document Py_{Enter,Leave}RecursiveCall functions.
........
  r78802 | georg.brandl | 2010-03-08 17:28:40 +0100 (Mo, 08 Mär 2010) | 1 line

  Fix typo.
........
  r78922 | georg.brandl | 2010-03-13 14:41:58 +0100 (Sa, 13 Mär 2010) | 1 line

  Update for new download location.
........
  r78952 | georg.brandl | 2010-03-14 10:55:08 +0100 (So, 14 Mär 2010) | 1 line

  #8137: add iso-8859-16 to the standard encodings table.
........

Doc/c-api/exceptions.rst

@@ -471,6 +471,36 @@ Exception Objects
    This steals a reference to *ctx*.
 
 
+Recursion Control
+=================
+
+These two functions provide a way to perform safe recursive calls at the C
+level, both in the core and in extension modules.  They are needed if the
+recursive code does not necessarily invoke Python code (which tracks its
+recursion depth automatically).
+
+.. cfunction:: int Py_EnterRecursiveCall(char *where)
+
+   Marks a point where a recursive C-level call is about to be performed.
+
+   If :const:`USE_STACKCHECK` is defined, this function checks if the the OS
+   stack overflowed using :cfunc:`PyOS_CheckStack`.  In this is the case, it
+   sets a :exc:`MemoryError` and returns a nonzero value.
+
+   The function then checks if the recursion limit is reached.  If this is the
+   case, a :exc:`RuntimeError` is set and a nonzero value is returned.
+   Otherwise, zero is returned.
+
+   *where* should be a string such as ``" in instance check"`` to be
+   concatenated to the :exc:`RuntimeError` message caused by the recursion depth
+   limit.
+
+.. cfunction:: void Py_LeaveRecursiveCall()
+
+   Ends a :cfunc:`Py_EnterRecursiveCall`.  Must be called once for each
+   *successful* invocation of :cfunc:`Py_EnterRecursiveCall`.
+
+
 .. _standardexceptions:
 
 Standard Exceptions

Doc/c-api/gcsupport.rst

@@ -28,7 +28,7 @@ include the :const:`Py_TPFLAGS_HAVE_GC` and provide an implementation of the
 Constructors for container types must conform to two rules:
 
 #. The memory for the object must be allocated using :cfunc:`PyObject_GC_New`
-   or :cfunc:`PyObject_GC_VarNew`.
+   or :cfunc:`PyObject_GC_NewVar`.
 
 #. Once all the fields which may contain references to other containers are
    initialized, it must call :cfunc:`PyObject_GC_Track`.

Doc/c-api/typeobj.rst

@@ -182,7 +182,7 @@ type objects) *must* have the :attr:`ob_size` field.
    instance; this is normally :cfunc:`PyObject_Del` if the instance was allocated
    using :cfunc:`PyObject_New` or :cfunc:`PyObject_VarNew`, or
    :cfunc:`PyObject_GC_Del` if the instance was allocated using
-   :cfunc:`PyObject_GC_New` or :cfunc:`PyObject_GC_VarNew`.
+   :cfunc:`PyObject_GC_New` or :cfunc:`PyObject_GC_NewVar`.
 
    This field is inherited by subtypes.
 

Doc/library/argparse.rst

@@ -855,7 +855,7 @@ By default, ArgumentParser objects read command-line args in as simple strings.
 However, quite often the command-line string should instead be interpreted as
 another type, like a :class:`float`, :class:`int` or :class:`file`.  The
 ``type`` keyword argument of :meth:`add_argument` allows any necessary
-type-checking and type-conversions to be performed.  Many common builtin types
+type-checking and type-conversions to be performed.  Many common built-in types
 can be used directly as the value of the ``type`` argument::
 
    >>> parser = argparse.ArgumentParser()

Doc/library/codecs.rst

@@ -1065,11 +1065,13 @@ particular, the following variants typically exist:
 +-----------------+--------------------------------+--------------------------------+
 | iso8859_10      | iso-8859-10, latin6, L6        | Nordic languages               |
 +-----------------+--------------------------------+--------------------------------+
-| iso8859_13      | iso-8859-13                    | Baltic languages               |
+| iso8859_13      | iso-8859-13, latin7, L7        | Baltic languages               |
 +-----------------+--------------------------------+--------------------------------+
 | iso8859_14      | iso-8859-14, latin8, L8        | Celtic languages               |
 +-----------------+--------------------------------+--------------------------------+
-| iso8859_15      | iso-8859-15                    | Western Europe                 |
+| iso8859_15      | iso-8859-15, latin9, L9        | Western Europe                 |
++-----------------+--------------------------------+--------------------------------+
+| iso8859_16      | iso-8859-16, latin10, L10      | South-Eastern Europe           |
 +-----------------+--------------------------------+--------------------------------+
 | johab           | cp1361, ms1361                 | Korean                         |
 +-----------------+--------------------------------+--------------------------------+

Doc/reference/executionmodel.rst

@@ -120,7 +120,7 @@ namespace is searched.  The global statement must precede all uses of the name.
 
 .. index:: pair: restricted; execution
 
-The built-in namespace associated with the execution of a code block is actually
+The builtins namespace associated with the execution of a code block is actually
 found by looking up the name ``__builtins__`` in its global namespace; this
 should be a dictionary or a module (in the latter case the module's dictionary
 is used).  By default, when in the :mod:`__main__` module, ``__builtins__`` is
@@ -132,7 +132,7 @@ weak form of restricted execution.
 .. impl-detail::
 
    Users should not touch ``__builtins__``; it is strictly an implementation
-   detail.  Users wanting to override values in the built-in namespace should
+   detail.  Users wanting to override values in the builtins namespace should
    :keyword:`import` the :mod:`builtins` module and modify its
    attributes appropriately.
 

Doc/reference/expressions.rst

@@ -1113,12 +1113,7 @@ Boolean operations
    pair: Conditional; expression
    pair: Boolean; operation
 
-Boolean operations have the lowest priority of all Python operations:
-
 .. productionlist::
-   expression: `conditional_expression` | `lambda_form`
-   expression_nocond: `or_test` | `lambda_form_nocond`
-   conditional_expression: `or_test` ["if" `or_test` "else" `expression`]
    or_test: `and_test` | `or_test` "or" `and_test`
    and_test: `not_test` | `and_test` "and" `not_test`
    not_test: `comparison` | "not" `not_test`
@@ -1135,10 +1130,6 @@ truth value by providing a :meth:`__bool__` method.
 The operator :keyword:`not` yields ``True`` if its argument is false, ``False``
 otherwise.
 
-The expression ``x if C else y`` first evaluates *C* (*not* *x*); if *C* is
-true, *x* is evaluated and its value is returned; otherwise, *y* is evaluated
-and its value is returned.
-
 .. index:: operator: and
 
 The expression ``x and y`` first evaluates *x*; if *x* is false, its value is
@@ -1158,6 +1149,30 @@ not bother to return a value of the same type as its argument, so e.g., ``not
 'foo'`` yields ``False``, not ``''``.)
 
 
+Conditional Expressions
+=======================
+
+.. versionadded:: 2.5
+
+.. index::
+   pair: conditional; expression
+   pair: ternary; operator
+
+.. productionlist::
+   conditional_expression: `or_test` ["if" `or_test` "else" `expression`]
+   expression: `conditional_expression` | `lambda_form`
+   expression_nocond: `or_test` | `lambda_form_nocond`
+
+Conditional expressions (sometimes called a "ternary operator") have the lowest
+priority of all Python operations.
+
+The expression ``x if C else y`` first evaluates the condition, *C* (*not* *x*);
+if *C* is true, *x* is evaluated and its value is returned; otherwise, *y* is
+evaluated and its value is returned.
+
+See :pep:`308` for more details about conditional expressions.
+
+
 .. _lambdas:
 .. _lambda:
 
@@ -1252,6 +1267,8 @@ groups from right to left).
 +===============================================+=====================================+
 | :keyword:`lambda`                             | Lambda expression                   |
 +-----------------------------------------------+-------------------------------------+
+| :keyword:`if` -- :keyword:`else`              | Conditional expression              |
++-----------------------------------------------+-------------------------------------+
 | :keyword:`or`                                 | Boolean OR                          |
 +-----------------------------------------------+-------------------------------------+
 | :keyword:`and`                                | Boolean AND                         |

Doc/whatsnew/2.6.rst

@@ -111,9 +111,9 @@ are:
   :func:`reduce` function.
 
 Python 3.0 adds several new built-in functions and changes the
-semantics of some existing built-ins.  Functions that are new in 3.0
+semantics of some existing builtins.  Functions that are new in 3.0
 such as :func:`bin` have simply been added to Python 2.6, but existing
-built-ins haven't been changed; instead, the :mod:`future_builtins`
+builtins haven't been changed; instead, the :mod:`future_builtins`
 module has versions with the new 3.0 semantics.  Code written to be
 compatible with 3.0 can do ``from future_builtins import hex, map`` as
 necessary.
@@ -837,7 +837,7 @@ formatted.  It receives a single argument, the format specifier::
        else:
            return str(self)
 
-There's also a :func:`format` built-in that will format a single
+There's also a :func:`format` builtin that will format a single
 value.  It calls the type's :meth:`__format__` method with the
 provided specifier::
 
@@ -1168,7 +1168,7 @@ access protocol.  Abstract Base Classes (or ABCs) are an equivalent
 feature for Python. The ABC support consists of an :mod:`abc` module
 containing a metaclass called :class:`ABCMeta`, special handling of
 this metaclass by the :func:`isinstance` and :func:`issubclass`
-built-ins, and a collection of basic ABCs that the Python developers
+builtins, and a collection of basic ABCs that the Python developers
 think will be widely useful.  Future versions of Python will probably
 add more ABCs.
 
@@ -1322,9 +1322,9 @@ an octal number, but it does add support for "0o" and "0b"::
     >>> 0b101111
     47
 
-The :func:`oct` built-in still returns numbers
+The :func:`oct` builtin still returns numbers
 prefixed with a leading zero, and a new :func:`bin`
-built-in returns the binary representation for a number::
+builtin returns the binary representation for a number::
 
     >>> oct(42)
     '052'
@@ -1333,7 +1333,7 @@ built-in returns the binary representation for a number::
     >>> bin(173)
     '0b10101101'
 
-The :func:`int` and :func:`long` built-ins will now accept the "0o"
+The :func:`int` and :func:`long` builtins will now accept the "0o"
 and "0b" prefixes when base-8 or base-2 are requested, or when the
 *base* argument is zero (signalling that the base used should be
 determined from the string)::
@@ -1419,7 +1419,7 @@ can be shifted left and right with ``<<`` and ``>>``,
 combined using bitwise operations such as ``&`` and ``|``,
 and can be used as array indexes and slice boundaries.
 
-In Python 3.0, the PEP slightly redefines the existing built-ins
+In Python 3.0, the PEP slightly redefines the existing builtins
 :func:`round`, :func:`math.floor`, :func:`math.ceil`, and adds a new
 one, :func:`math.trunc`, that's been backported to Python 2.6.
 :func:`math.trunc` rounds toward zero, returning the closest
@@ -1527,7 +1527,7 @@ Some smaller changes made to the core Python language are:
   Previously this would have been a syntax error.
   (Contributed by Amaury Forgeot d'Arc; :issue:`3473`.)
 
-* A new built-in, ``next(iterator, [default])`` returns the next item
+* A new builtin, ``next(iterator, [default])`` returns the next item
   from the specified iterator.  If the *default* argument is supplied,
   it will be returned if *iterator* has been exhausted; otherwise,
   the :exc:`StopIteration` exception will be raised.  (Backported
@@ -1956,9 +1956,9 @@ changes, or look through the Subversion logs for all the details.
   (Contributed by Phil Schwartz; :issue:`1221598`.)
 
 * The :func:`reduce` built-in function is also available in the
-  :mod:`functools` module.  In Python 3.0, the built-in has been
+  :mod:`functools` module.  In Python 3.0, the builtin has been
   dropped and :func:`reduce` is only available from :mod:`functools`;
-  currently there are no plans to drop the built-in in the 2.x series.
+  currently there are no plans to drop the builtin in the 2.x series.
   (Patched by Christian Heimes; :issue:`1739906`.)
 
 * When possible, the :mod:`getpass` module will now use
@@ -2760,7 +2760,7 @@ The functions in this module currently include:
 
 * ``filter(predicate, iterable)``,
   ``map(func, iterable1, ...)``: the 3.0 versions
-  return iterators, unlike the 2.x built-ins which return lists.
+  return iterators, unlike the 2.x builtins which return lists.
 
 * ``hex(value)``, ``oct(value)``: instead of calling the
   :meth:`__hex__` or :meth:`__oct__` methods, these versions will

Misc/SpecialBuilds.txt

@@ -37,7 +37,7 @@ Py_TRACE_REFS                                             introduced in 1.4
 
 Turn on heavy reference debugging.  This is major surgery.  Every PyObject
 grows two more pointers, to maintain a doubly-linked list of all live
-heap-allocated objects.  Most builtin type objects are not in this list,
+heap-allocated objects.  Most built-in type objects are not in this list,
 as they're statically allocated.  Starting in Python 2.3, if COUNT_ALLOCS
 (see below) is also defined, a static type object T does appear in this
 list if at least one object of type T has been created.