[Python-checkins] r57148 - in python/trunk/Doc: documenting/markup.rst glossary.rst

[georg.brandl]

Author: georg.brandl
Date: Fri Aug 17 18:54:59 2007
New Revision: 57148

Modified:
   python/trunk/Doc/documenting/markup.rst
   python/trunk/Doc/glossary.rst
Log:
Use glossary x-refs, document new ``!`` feature.


Modified: python/trunk/Doc/documenting/markup.rst
==============================================================================
--- python/trunk/Doc/documenting/markup.rst	(original)
+++ python/trunk/Doc/documenting/markup.rst	Fri Aug 17 18:54:59 2007
@@ -290,6 +290,11 @@
 
 For all other roles, you have to write ``:rolename:`content```.
 
+.. note::
+
+   For all cross-referencing roles, if you prefix the content with ``!``, no
+   reference/hyperlink will be created.
+
 The following roles refer to objects in modules and are possibly hyperlinked if
 a matching identifier is found:
 

Modified: python/trunk/Doc/glossary.rst
==============================================================================
--- python/trunk/Doc/glossary.rst	(original)
+++ python/trunk/Doc/glossary.rst	Fri Aug 17 18:54:59 2007
@@ -30,7 +30,7 @@
     
    classic class
       Any class which does not inherit from :class:`object`.  See
-      :dfn:`new-style class`.
+      :term:`new-style class`.
     
    coercion
       The implicit conversion of an instance of one type to another during an
@@ -82,14 +82,14 @@
       well-designed code improves its flexibility by allowing polymorphic
       substitution.  Duck-typing avoids tests using :func:`type` or
       :func:`isinstance`. Instead, it typically employs :func:`hasattr` tests or
-      :dfn:`EAFP` programming.
+      :term:`EAFP` programming.
     
    EAFP
       Easier to ask for forgiveness than permission.  This common Python coding
       style assumes the existence of valid keys or attributes and catches
       exceptions if the assumption proves false.  This clean and fast style is
       characterized by the presence of many :keyword:`try` and :keyword:`except`
-      statements.  The technique contrasts with the :dfn:`LBYL` style that is
+      statements.  The technique contrasts with the :term:`LBYL` style that is
       common in many other languages such as C.
 
    extension module
@@ -140,7 +140,7 @@
          285
     
    GIL
-      See :dfn:`global interpreter lock`.
+      See :term:`global interpreter lock`.
     
    global interpreter lock
       The lock used by Python threads to assure that only one thread can be run
@@ -173,10 +173,10 @@
       When dividing two integers the outcome will always be another integer
       (having the floor function applied to it). However, if one of the operands
       is another numeric type (such as a :class:`float`), the result will be
-      coerced (see :dfn:`coercion`) to a common type.  For example, an integer
+      coerced (see :term:`coercion`) to a common type.  For example, an integer
       divided by a float will result in a float value, possibly with a decimal
       fraction.  Integer division can be forced by using the ``//`` operator
-      instead of the ``/`` operator.  See also :dfn:`__future__`.
+      instead of the ``/`` operator.  See also :term:`__future__`.
     
    interactive
       Python has an interactive interpreter which means that you can try out
@@ -190,7 +190,7 @@
       means that the source files can be run directly without first creating an
       executable which is then run.  Interpreted languages typically have a
       shorter development/debug cycle than compiled ones, though their programs
-      generally also run more slowly.  See also :dfn:`interactive`.
+      generally also run more slowly.  See also :term:`interactive`.
     
    iterable
       A container object capable of returning its members one at a
@@ -206,7 +206,7 @@
       to call :func:`iter` or deal with iterator objects yourself.  The ``for``
       statement does that automatically for you, creating a temporary unnamed
       variable to hold the iterator for the duration of the loop.  See also
-      :dfn:`iterator`, :dfn:`sequence`, and :dfn:`generator`.
+      :term:`iterator`, :term:`sequence`, and :term:`generator`.
     
    iterator
       An object representing a stream of data.  Repeated calls to the iterator's
@@ -226,7 +226,7 @@
    LBYL
       Look before you leap.  This coding style explicitly tests for
       pre-conditions before making calls or lookups.  This style contrasts with
-      the :dfn:`EAFP` approach and is characterized by the presence of many
+      the :term:`EAFP` approach and is characterized by the presence of many
       :keyword:`if` statements.
     
    list comprehension
@@ -254,7 +254,7 @@
     
    mutable
       Mutable objects can change their value but keep their :func:`id`.  See
-      also :dfn:`immutable`.
+      also :term:`immutable`.
     
    namespace
       The place where a variable is stored.  Namespaces are implemented as
@@ -294,20 +294,20 @@
       implementation level to keep track of allocated memory.
     
    __slots__
-      A declaration inside a :dfn:`new-style class` that saves memory by
+      A declaration inside a :term:`new-style class` that saves memory by
       pre-declaring space for instance attributes and eliminating instance
       dictionaries.  Though popular, the technique is somewhat tricky to get
       right and is best reserved for rare cases where there are large numbers of
       instances in a memory-critical application.
     
    sequence
-      An :dfn:`iterable` which supports efficient element access using integer
+      An :term:`iterable` which supports efficient element access using integer
       indices via the :meth:`__getitem__` and :meth:`__len__` special methods.
       Some built-in sequence types are :class:`list`, :class:`str`,
       :class:`tuple`, and :class:`unicode`. Note that :class:`dict` also
       supports :meth:`__getitem__` and :meth:`__len__`, but is considered a
       mapping rather than a sequence because the lookups use arbitrary
-      :dfn:`immutable` keys rather than integers.
+      :term:`immutable` keys rather than integers.
 
    type
       The type of a Python object determines what kind of object it is; every