Commits

Christian Heimes committed 05da49e

Merged revisions 59333-59370 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk

........
r59343 | georg.brandl | 2007-12-05 08:02:47 +0100 (Wed, 05 Dec 2007) | 2 lines

Fix typo.
........
r59347 | christian.heimes | 2007-12-05 13:31:44 +0100 (Wed, 05 Dec 2007) | 1 line

Fixed quoting and paths in the sqlite project file
........
r59348 | christian.heimes | 2007-12-05 13:45:11 +0100 (Wed, 05 Dec 2007) | 1 line

Fixed error in regrtest. I must have missed the spot.
........
r59350 | christian.heimes | 2007-12-05 13:49:14 +0100 (Wed, 05 Dec 2007) | 1 line

merge -r59315:59316 from py3k: Fix issue #1553: An errornous __length_hint__ can make list() raise a SystemError
........
r59352 | christian.heimes | 2007-12-05 13:52:34 +0100 (Wed, 05 Dec 2007) | 1 line

Added msg to Misc/NEWS
........
r59354 | andrew.kuchling | 2007-12-05 14:27:20 +0100 (Wed, 05 Dec 2007) | 1 line

Spelling fix
........
r59356 | georg.brandl | 2007-12-05 18:56:50 +0100 (Wed, 05 Dec 2007) | 3 lines

Add examples to csv, pprint and traceback docs.
Written by Ross for GHOP.
........
r59358 | raymond.hettinger | 2007-12-05 19:11:08 +0100 (Wed, 05 Dec 2007) | 1 line

Error checking was too aggressive (reported by Chris Tismer)
........
r59359 | georg.brandl | 2007-12-05 19:30:48 +0100 (Wed, 05 Dec 2007) | 2 lines

Add examples to re docs. Written for GHOP by Dan Finnie.
........
r59366 | georg.brandl | 2007-12-05 20:49:21 +0100 (Wed, 05 Dec 2007) | 2 lines

Fix markup.
........
r59367 | christian.heimes | 2007-12-05 20:57:54 +0100 (Wed, 05 Dec 2007) | 1 line

Updated documentation and build_tkinter.py script
........
r59368 | georg.brandl | 2007-12-05 21:03:57 +0100 (Wed, 05 Dec 2007) | 2 lines

Another markup fix.
........
r59369 | ronald.oussoren | 2007-12-05 21:07:36 +0100 (Wed, 05 Dec 2007) | 7 lines

This "fixes" compilation issues for the Carbon._OSA module on OSX Leopard
by purging bindings to OSA's debug API's. Those APIs we're completely
unsupported on OSX 10.4 and are no longer available on OSX 10.5.

Note that this patches a generated file. This is somewhat acceptable because
regenerating the file is non-trivial and wouldn't use system headers anyway.
........
r59370 | christian.heimes | 2007-12-05 21:10:38 +0100 (Wed, 05 Dec 2007) | 1 line

Fixed bug #1557 by using popen.communicate() before popen.wait()
........

  • Participants
  • Parent commits 320f7ec

Comments (0)

Files changed (14)

 * Carey Evans
 * Martijn Faassen
 * Carl Feynman
+* Dan Finnie
 * Hernán Martínez Foffani
 * Stefan Franke
 * Jim Fulton

Doc/c-api/refcounting.rst

 
 
 The following functions are for runtime dynamic embedding of Python:
-``Py_IncRef(PyObject \*o)``, `Py_DecRef(PyObject \*o)``. They are simply
-exported function versions of :cfunc:`Py_XINCREF` and :cfunc:`Py_XDECREF`,
-respectively.
+``Py_IncRef(PyObject *o)``, ``Py_DecRef(PyObject *o)``. They are
+simply exported function versions of :cfunc:`Py_XINCREF` and
+:cfunc:`Py_XDECREF`, respectively.
 
 The following functions or macros are only for use within the interpreter core:
 :cfunc:`_Py_Dealloc`, :cfunc:`_Py_ForgetReference`, :cfunc:`_Py_NewReference`,

Doc/documenting/fromlatex.rst

 * :file:`ext` -> :file:`extending`
 * :file:`inst` -> :file:`installing`
 * :file:`lib` -> :file:`library`
-* :file:`mac` -> merged into :file:`library`, with `mac/using.tex`
-  moved to `howto/pythonmac.rst`
+* :file:`mac` -> merged into :file:`library`, with :file:`mac/using.tex`
+  moved to :file:`howto/pythonmac.rst`
 * :file:`ref` -> :file:`reference`
 * :file:`tut` -> :file:`tutorial`, with the single TeX file split up
 

Doc/library/csv.rst

 
 .. seealso::
 
-   .. % \seemodule{array}{Arrays of uniformly types numeric values.}
-
    :pep:`305` - CSV File API
       The Python Enhancement Proposal which proposed this addition to Python.
 
    consequence, if newlines embedded within fields are important, the input should
    be split into lines in a manner which preserves the newline characters.
 
+   A short usage example::
+ 
+      >>> import csv
+      >>> spamReader = csv.reader(open('eggs.csv'), delimiter=' ', quotechar='|')
+      >>> for row in spamReader:
+      ...     print ', '.join(row)
+      Spam, Spam, Spam, Spam, Spam, Baked Beans
+      Spam, Lovely Spam, Wonderful Spam
+
 
 .. function:: writer(csvfile[, dialect='excel'][, fmtparam])
 
    CSV files without preprocessing the data returned from a ``cursor.fetch*`` call.
    All other non-string data are stringified with :func:`str` before being written.
 
+   A short usage example::
+
+      >>> import csv
+      >>> spamWriter = csv.writer(open('eggs.csv', 'w'), delimiter=' ',
+      ...                         quotechar='|', quoting=QUOTE_MINIMAL)
+      >>> spamWriter.writerow(['Spam'] * 5 + ['Baked Beans'])
+      >>> spamWriter.writerow(['Spam', 'Lovely Spam', 'Wonderful Spam'])
+
 
 .. function:: register_dialect(name[, dialect][, fmtparam])
 

Doc/library/pprint.rst

    structure cannot be formatted within the constrained width, a best effort will
    be made. ::
 
-      >>> import pprint, sys
-      >>> stuff = sys.path[:]
+      >>> import pprint
+      >>> stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
       >>> stuff.insert(0, stuff[:])
       >>> pp = pprint.PrettyPrinter(indent=4)
       >>> pp.pprint(stuff)
-      [   [   '',
-              '/usr/local/lib/python1.5',
-              '/usr/local/lib/python1.5/test',
-              '/usr/local/lib/python1.5/sunos5',
-              '/usr/local/lib/python1.5/sharedmodules',
-              '/usr/local/lib/python1.5/tkinter'],
-          '',
-          '/usr/local/lib/python1.5',
-          '/usr/local/lib/python1.5/test',
-          '/usr/local/lib/python1.5/sunos5',
-          '/usr/local/lib/python1.5/sharedmodules',
-          '/usr/local/lib/python1.5/tkinter']
-      >>>
-      >>> import parser
-      >>> tup = parser.ast2tuple(
-      ...     parser.suite(open('pprint.py').read()))[1][1][1]
+      [   ['spam', 'eggs', 'lumberjack', 'knights', 'ni'],
+          'spam',
+          'eggs',
+          'lumberjack',
+          'knights',
+          'ni']
+      >>> tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead',
+      ... ('parrot', ('fresh fruit',))))))))
       >>> pp = pprint.PrettyPrinter(depth=6)
       >>> pp.pprint(tup)
-      (266, (267, (307, (287, (288, (...))))))
+      ('spam',
+       ('eggs', ('lumberjack', ('knights', ('ni', ('dead', ('parrot', (...,))))))))
 
 The :class:`PrettyPrinter` class supports several derivative functions:
 
    within a scope).  *indent*, *width* and *depth* will be passed to the
    :class:`PrettyPrinter` constructor as formatting parameters. ::
 
-      >>> stuff = sys.path[:]
+      >>> import pprint
+      >>> stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
       >>> stuff.insert(0, stuff)
       >>> pprint.pprint(stuff)
       [<Recursion on list with id=869440>,
    is no requested limit.  This argument should be passed unmodified to recursive
    calls. The fourth argument, *level*, gives the current level; recursive calls
    should be passed a value less than that of the current call.
+
+
+.. _pprint-example:
+
+pprint Example
+--------------
+
+This example demonstrates several uses of the :func:`pprint` function and its parameters.
+
+   >>> import pprint
+   >>> tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead',
+   ... ('parrot', ('fresh fruit',))))))))
+   >>> stuff = ['a' * 10, tup, ['a' * 30, 'b' * 30], ['c' * 20, 'd' * 20]]
+   >>> pprint.pprint(stuff)
+   ['aaaaaaaaaa',
+    ('spam',
+     ('eggs',
+      ('lumberjack',
+       ('knights', ('ni', ('dead', ('parrot', ('fresh fruit',)))))))),
+    ['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'],
+    ['cccccccccccccccccccc', 'dddddddddddddddddddd']]
+   >>> pprint.pprint(stuff, depth=3)
+   ['aaaaaaaaaa',
+    ('spam', ('eggs', ('lumberjack', (...)))),
+    ['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'],
+    ['cccccccccccccccccccc', 'dddddddddddddddddddd']]
+   >>> pprint.pprint(stuff, width=60)
+   ['aaaaaaaaaa',
+    ('spam',
+     ('eggs',
+      ('lumberjack',
+       ('knights',
+        ('ni', ('dead', ('parrot', ('fresh fruit',)))))))),
+    ['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+     'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'],
+    ['cccccccccccccccccccc', 'dddddddddddddddddddd']]
+

Doc/library/re.rst

 newline.  Usually patterns will be expressed in Python code using this raw
 string notation.
 
+It is important to note that most regular expression operations are available as
+module-level functions and :class:`RegexObject` methods.  The functions are
+shortcuts that don't require you to compile a regex object first, but miss some
+fine-tuning parameters.
+
 .. seealso::
 
    Mastering Regular Expressions
 
 ::
 
-   re.compile("a").match("ba", 1)           # succeeds
-   re.compile("^a").search("ba", 1)         # fails; 'a' not at start
-   re.compile("^a").search("\na", 1)        # fails; 'a' not at start
-   re.compile("^a", re.M).search("\na", 1)  # succeeds
-   re.compile("^a", re.M).search("ba", 1)   # fails; no preceding \n
+   >>> re.match("c", "abcdef") # No match
+   >>> re.search("c", "abcdef")
+  <_sre.SRE_Match object at 0x827e9c0> # Match
 
 
 .. _contents-of-module-re:
    character class or preceded by an unescaped backslash, all characters from the
    leftmost such ``'#'`` through the end of the line are ignored.
 
-   This means that the two following regular expression objects are equal::
+   That means that the two following regular expression objects that match a
+   decimal number are functionally equal::
 
-      re.compile(r""" [a-z]+   # some letters
-                      \.\.     # two dots
-                      [a-z]*   # perhaps more letters""")
-      re.compile(r"[a-z]+\.\.[a-z]*")
+      a = re.compile(r"""\d +  # the integral part
+                         \.    # the decimal point
+                         \d *  # some fractional digits""", re.X)
+      b = re.compile(r"\d+\.\d*")
 
 
 .. function:: search(pattern, string[, flags])
 
    .. note::
 
-      If you want to locate a match anywhere in *string*, use :meth:`search` instead.
+      If you want to locate a match anywhere in *string*, use :meth:`search`
+      instead.
 
 
 .. function:: split(pattern, string[, maxsplit=0])
 
    .. note::
 
-      If you want to locate a match anywhere in *string*, use :meth:`search` instead.
+      If you want to locate a match anywhere in *string*, use :meth:`search`
+      instead.
 
    The optional second parameter *pos* gives an index in the string where the
    search is to start; it defaults to ``0``.  This is not completely equivalent to
    from *pos* to ``endpos - 1`` will be searched for a match.  If *endpos* is less
    than *pos*, no match will be found, otherwise, if *rx* is a compiled regular
    expression object, ``rx.match(string, 0, 50)`` is equivalent to
-   ``rx.match(string[:50], 0)``.
+   ``rx.match(string[:50], 0)``. ::
+
+      >>> pattern = re.compile("o")
+      >>> pattern.match("dog")      # No match as "o" is not at the start of "dog."
+      >>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
+      <_sre.SRE_Match object at 0x827eb10>
 
 
 .. method:: RegexObject.search(string[, pos[, endpos]])
    pattern, an :exc:`IndexError` exception is raised. If a group is contained in a
    part of the pattern that did not match, the corresponding result is ``None``.
    If a group is contained in a part of the pattern that matched multiple times,
-   the last match is returned.
+   the last match is returned. ::
+
+      >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
+      >>> m.group(0)
+      'Isaac Newton'       # The entire match
+      >>> m.group(1)
+      'Isaac'              # The first parenthesized subgroup.
+      >>> m.group(2)
+      'Newton'             # The second parenthesized subgroup.
+      >>> m.group(1, 2)
+      ('Isaac', 'Newton')  # Multiple arguments give us a tuple.
 
    If the regular expression uses the ``(?P<name>...)`` syntax, the *groupN*
    arguments may also be strings identifying groups by their group name.  If a
 
    A moderately complicated example::
 
-      m = re.match(r"(?P<int>\d+)\.(\d*)", '3.14')
+      >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcom Reynolds")
+      >>> m.group('first_name')
+      'Malcom'
+      >>> m.group('last_name')
+      'Reynolds'
 
-   After performing this match, ``m.group(1)`` is ``'3'``, as is
-   ``m.group('int')``, and ``m.group(2)`` is ``'14'``.
+   Named groups can also be referred to by their index::
+
+      >>> m.group(1)
+      'Malcom'
+      >>> m.group(2)
+      'Reynolds'
+
+   If a group matches multiple times, only the last match is accessible::
+      >>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
+      >>> m.group(1)                        # Returns only the last match.
+      'c3'
 
 
 .. method:: MatchObject.groups([default])
    string would be returned instead.  In later versions (from 1.5.1 on), a
    singleton tuple is returned in such cases.)
 
+   For example::
+
+      >>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
+      >>> m.groups()
+      ('24', '1632')
+
+   If we make the decimal place and everything after it optional, not all groups
+   might participate in the match.  These groups will default to ``None`` unless
+   the *default* argument is given::
+
+      >>> m = re.match(r"(\d+)\.?(\d+)?", "24")
+      >>> m.groups()
+      ('24', None)      # Second group defaults to None.
+      >>> m.groups('0')
+      ('24', '0')       # Now, the second group defaults to '0'.
+
 
 .. method:: MatchObject.groupdict([default])
 
    Return a dictionary containing all the *named* subgroups of the match, keyed by
    the subgroup name.  The *default* argument is used for groups that did not
-   participate in the match; it defaults to ``None``.
+   participate in the match; it defaults to ``None``.  For example::
+
+      >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcom Reynolds")
+      >>> m.groupdict()
+      {'first_name': 'Malcom', 'last_name': 'Reynolds'}
 
 
 .. method:: MatchObject.start([group])
    ``m.start(0)`` is 1, ``m.end(0)`` is 2, ``m.start(1)`` and ``m.end(1)`` are both
    2, and ``m.start(2)`` raises an :exc:`IndexError` exception.
 
+   An example that will remove *remove_this* from email addresses::
+
+      >>> email = "tony@tiremove_thisger.net"
+      >>> m = re.search("remove_this", email)
+      >>> email[:m.start()] + email[m.end():]
+      'tony@tiger.net'
+
 
 .. method:: MatchObject.span([group])
 
    For :class:`MatchObject` *m*, return the 2-tuple ``(m.start(group),
    m.end(group))``. Note that if *group* did not contribute to the match, this is
-   ``(-1, -1)``.  Again, *group* defaults to zero.
+   ``(-1, -1)``.  *group* defaults to zero, the entire match.
 
 
 .. attribute:: MatchObject.pos
 Examples
 --------
 
-**Simulating scanf()**
+
+Checking For a Pair
+^^^^^^^^^^^^^^^^^^^
+
+In this example, we'll use the following helper function to display match
+objects a little more gracefully::
+
+   def displaymatch(match):
+       if match is None:
+           return None
+       return '<Match: %r, groups=%r>' % (match.group(), match.groups())
+
+Suppose you are writing a poker program where a player's hand is represented as
+a 5-character string with each character representing a card, "a" for ace, "k"
+for king, "q" for queen, j for jack, "0" for 10, and "1" through "9"
+representing the card with that value.
+
+To see if a given string is a valid hand, one could do the following::
+
+   >>> valid = re.compile(r"[0-9akqj]{5}$"
+   >>> displaymatch(valid.match("ak05q"))  # Valid.
+   <Match: 'ak05q', groups=()>
+   >>> displaymatch(valid.match("ak05e"))  # Invalid.
+   >>> displaymatch(valid.match("ak0"))    # Invalid.
+   >>> displaymatch(valid.match("727ak"))  # Valid.
+   <Match: '727ak', groups=()>
+
+That last hand, ``"727ak"``, contained a pair, or two of the same valued cards.
+To match this with a regular expression, one could use backreferences as such::
+
+   >>> pair = re.compile(r".*(.).*\1")
+   >>> displaymatch(pair.match("717ak"))     # Pair of 7s.
+   <Match: '717', groups=('7',)>
+   >>> displaymatch(pair.match("718ak"))     # No pairs.
+   >>> displaymatch(pair.match("354aa"))     # Pair of aces.
+   <Match: '345aa', groups=('a',)>
+
+To find out what card the pair consists of, one could use the :func:`group`
+method of :class:`MatchObject` in the following manner::
+
+   >>> pair.match("717ak").group(1)
+   '7'
+   
+   # Error because re.match() returns None, which doesn't have a group() method:
+   >>> pair.match("718ak").group(1)
+   Traceback (most recent call last):
+     File "<pyshell#23>", line 1, in <module>
+       re.match(r".*(.).*\1", "718ak").group(1)
+   AttributeError: 'NoneType' object has no attribute 'group'
+   
+   >>> pair.match("354aa").group(1)
+   'a'
+
+
+Simulating scanf()
+^^^^^^^^^^^^^^^^^^
 
 .. index:: single: scanf()
 
 
    (\S+) - (\d+) errors, (\d+) warnings
 
-**Avoiding recursion**
+
+Avoiding recursion
+^^^^^^^^^^^^^^^^^^
 
 If you create regular expressions that require the engine to perform a lot of
 recursion, you may encounter a :exc:`RuntimeError` exception with the message
 being recast as ``Begin [a-zA-Z0-9_ ]*?end``.  As a further benefit, such
 regular expressions will run faster than their recursive equivalents.
 
+
+search() vs. match()
+^^^^^^^^^^^^^^^^^^^^
+
+In a nutshell, :func:`match` only attempts to match a pattern at the beginning
+of a string where :func:`search` will match a pattern anywhere in a string.
+For example::
+
+   >>> re.match("o", "dog")  # No match as "o" is not the first letter of "dog".
+   >>> re.search("o", "dog") # Match as search() looks everywhere in the string.
+   <_sre.SRE_Match object at 0x827e9f8>
+
+.. note::
+
+      The following applies only to regular expression objects like those created
+      with ``re.compile("pattern")``, not the primitives
+      ``re.match(pattern, string)`` or ``re.search(pattern, string)``.
+
+:func:`match` has an optional second parameter that gives an index in the string
+where the search is to start::
+
+   >>> pattern = re.compile("o")
+   >>> pattern.match("dog")      # No match as "o" is not at the start of "dog."
+   # Equivalent to the above expression as 0 is the default starting index:
+   >>> pattern.match("dog", 0)
+   # Match as "o" is the 2nd character of "dog" (index 0 is the first):
+   >>> pattern.match("dog", 1)
+   <_sre.SRE_Match object at 0x827eb10>
+   >>> pattern.match("dog", 2)   # No match as "o" is not the 3rd character of "dog."
+
+
+Making a Phonebook
+^^^^^^^^^^^^^^^^^^
+
+:func:`split` splits a string into a list delimited by the passed pattern.  The 
+method is invaluable for converting textual data into data structures that can be
+easily read and modified by Python as demonstrated in the following example that
+creates a phonebook.
+
+First, get the input using triple-quoted string syntax::
+
+   >>> input = """Ross McFluff 834.345.1254 155 Elm Street
+   Ronald Heathmore 892.345.3428 436 Finley Avenue
+   Frank Burger 925.541.7625 662 South Dogwood Way
+   Heather Albrecht 548.326.4584 919 Park Place"""
+
+Then, convert the string into a list with each line having its own entry::
+
+   >>> entries = re.split("\n", input)
+   >>> entries
+   ['Ross McFluff 834.345.1254 155 Elm Street',
+   'Ronald Heathmore 892.345.3428 436 Finley Avenue',
+   'Frank Burger 925.541.7625 662 South Dogwood Way',
+   'Heather Albrecht 548.326.4584 919 Park Place']
+
+Finally, split each entry into a list with first name, last name, telephone
+number, and address.  We use the ``maxsplit`` paramater of :func:`split`
+because the address has spaces, our splitting pattern, in it::
+
+   >>> [re.split(" ", entry, 3) for entry in entries]
+   [['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],
+   ['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],
+   ['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
+   ['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]
+
+With a ``maxsplit`` of ``4``, we could seperate the house number from the street
+name::
+
+   >>> [re.split(" ", entry, 4) for entry in entries]
+   [['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],
+   ['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],
+   ['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
+   ['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]
+
+
+Text Munging
+^^^^^^^^^^^^
+
+:func:`sub` replaces every occurrence of a pattern with a string or the
+result of a function.  This example demonstrates using :func:`sub` with
+a function to "munge" text, or randomize the order of all the characters
+in each word of a sentence except for the first and last characters::
+
+   >>> def repl(m):
+   ...   inner_word = list(m.group(2))
+   ...   random.shuffle(inner_word)
+   ...   return m.group(1) + "".join(inner_word) + m.group(3)
+   >>> text = "Professor Abdolmalek, please report your absences promptly."
+   >>> re.sub("(\w)(\w+)(\w)", repl, text)
+   'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
+   >>> re.sub("(\w)(\w+)(\w)", repl, text)
+   'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'
+
+
+Finding all Adverbs
+^^^^^^^^^^^^^^^^^^^
+
+:func:`findall` matches *all* occurences of a pattern, not just the first
+one as :func:`search` does.  For example, if one was a writer and wanted to
+find all of the adverbs in some text, he or she might use :func:`findall` in
+the following manner::
+
+   >>> text = "He was carefully disguised but captured quickly by police."
+   >>> re.findall(r"\w+ly", text)
+   ['carefully', 'quickly']
+
+
+Finding all Adverbs and their Positions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If one wants more information about all matches of a pattern than the matched
+text, :func:`finditer` is useful as it provides instances of
+:class:`MatchObject` instead of strings.  Continuing with the previous example,
+if one was a writer who wanted to find all of the adverbs *and their positions*
+in some text, he or she would use :func:`finditer` in the following manner::
+
+   >>> text = "He was carefully disguised but captured quickly by police."
+   >>> for m in re.finditer(r"\w+ly", text):
+         print '%02d-%02d: %s' % (m.start(), m.end(), m.group(0))
+   07-16: carefully
+   40-47: quickly
+
+
+Raw String Notation
+^^^^^^^^^^^^^^^^^^^
+
+Raw string notation (``r"text"``) keeps regular expressions sane.  Without it,
+every backslash (``'\'``) in a regular expression would have to be prefixed with
+another one to escape it.  For example, the two following lines of code are
+functionally identical::
+
+   >>> re.match(r"\W(.)\1\W", " ff ")
+   <_sre.SRE_Match object at 0x8262760>
+   >>> re.match("\\W(.)\\1\\W", " ff ")
+   <_sre.SRE_Match object at 0x82627a0>
+
+When one wants to match a literal backslash, it must be escaped in the regular
+expression.  With raw string notation, this means ``r"\\"``.  Without raw string
+notation, one must use ``"\\\\"``, making the following lines of code
+functionally identical::
+
+   >>> re.match(r"\\", r"\\")
+   <_sre.SRE_Match object at 0x827eb48>
+   >>> re.match("\\\\", r"\\")
+   <_sre.SRE_Match object at 0x827ec60>

Doc/library/traceback.rst

 
 .. _traceback-example:
 
-Traceback Example
------------------
+Traceback Examples
+------------------
 
 This simple example implements a basic read-eval-print loop, similar to (but
 less useful than) the standard Python interactive interpreter loop.  For a more
    while True:
        run_user_code(envdir)
 
+
+The following example demonstrates the different ways to print and format the
+exception and traceback::
+
+   import sys, traceback
+
+   def lumberjack():
+       bright_side_of_death()
+   
+   def bright_side_of_death():
+       return tuple()[0]
+   
+   try:
+       lumberjack()
+   except:
+       exceptionType, exceptionValue, exceptionTraceback = sys.exc_info()
+       print "*** print_tb:"
+       traceback.print_tb(exceptionTraceback, limit=1, file=sys.stdout)
+       print "*** print_exception:"
+       traceback.print_exception(exceptionType, exceptionValue, exceptionTraceback,
+                                 limit=2, file=sys.stdout)
+       print "*** print_exc:"
+       traceback.print_exc()
+       print "*** format_exc, first and last line:"
+       formatted_lines = traceback.format_exc().splitlines()
+       print formatted_lines[0]
+       print formatted_lines[-1]
+       print "*** format_exception:"
+       print repr(traceback.format_exception(exceptionType, exceptionValue,
+                                             exceptionTraceback))
+       print "*** extract_tb:"
+       print repr(traceback.extract_tb(exceptionTraceback))
+       print "*** format_tb:"
+       print repr(traceback.format_tb(exceptionTraceback))
+       print "*** tb_lineno:", traceback.tb_lineno(exceptionTraceback)
+   print "*** print_last:"
+   traceback.print_last()
+
+
+The output for the example would look similar to this::
+
+   *** print_tb:
+     File "<doctest>", line 9, in <module>
+       lumberjack()
+   *** print_exception:
+   Traceback (most recent call last):
+     File "<doctest>", line 9, in <module>
+       lumberjack()
+     File "<doctest>", line 3, in lumberjack
+       bright_side_of_death()
+   IndexError: tuple index out of range
+   *** print_exc:
+   Traceback (most recent call last):
+     File "<doctest>", line 9, in <module>
+       lumberjack()
+     File "<doctest>", line 3, in lumberjack
+       bright_side_of_death()
+   IndexError: tuple index out of range
+   *** format_exc, first and last line:
+   Traceback (most recent call last):
+   IndexError: tuple index out of range
+   *** format_exception:
+   ['Traceback (most recent call last):\n',
+    '  File "<doctest>", line 9, in <module>\n    lumberjack()\n',
+    '  File "<doctest>", line 3, in lumberjack\n    bright_side_of_death()\n',
+    '  File "<doctest>", line 6, in bright_side_of_death\n    return tuple()[0]\n',
+    'IndexError: tuple index out of range\n']
+   *** extract_tb:
+   [('<doctest>', 9, '<module>', 'lumberjack()'),
+    ('<doctest>', 3, 'lumberjack', 'bright_side_of_death()'),
+    ('<doctest>', 6, 'bright_side_of_death', 'return tuple()[0]')]
+   *** format_tb:
+   ['  File "<doctest>", line 9, in <module>\n    lumberjack()\n',
+    '  File "<doctest>", line 3, in lumberjack\n    bright_side_of_death()\n',
+    '  File "<doctest>", line 6, in bright_side_of_death\n    return tuple()[0]\n']
+   *** tb_lineno: 2
+   *** print_last:
+   Traceback (most recent call last):
+     File "<doctest>", line 9, in <module>
+       lumberjack()
+     File "<doctest>", line 3, in lumberjack
+       bright_side_of_death()
+   IndexError: tuple index out of range
+
+
+The following example shows the different ways to print and format the stack::
+
+   >>> import traceback
+   >>> def another_function():
+   ...     lumberstack()
+   ... 
+   >>> def lumberstack():
+   ...     traceback.print_stack()
+   ...     print repr(traceback.extract_stack())
+   ...     print repr(traceback.format_stack())
+   ... 
+   >>> another_function()
+     File "<doctest>", line 10, in <module>
+       another_function()
+     File "<doctest>", line 3, in another_function
+       lumberstack()
+     File "<doctest>", line 6, in lumberstack
+       traceback.print_stack()
+   [('<doctest>', 10, '<module>', 'another_function()'),
+    ('<doctest>', 3, 'another_function', 'lumberstack()'),
+    ('<doctest>', 7, 'lumberstack', 'print repr(traceback.extract_stack())')]
+   ['  File "<doctest>", line 10, in <module>\n    another_function()\n',
+    '  File "<doctest>", line 3, in another_function\n    lumberstack()\n',
+    '  File "<doctest>", line 8, in lumberstack\n    print repr(traceback.format_stack())\n']
+
+
+This last example demonstrates the final few formatting functions::
+
+   >>> import traceback
+   >>> format_list([('spam.py', 3, '<module>', 'spam.eggs()'),
+   ...              ('eggs.py', 42, 'eggs', 'return "bacon"')])
+   ['  File "spam.py", line 3, in <module>\n    spam.eggs()\n',
+    '  File "eggs.py", line 42, in eggs\n    return "bacon"\n']
+   >>> theError = IndexError('tuple indx out of range')
+   >>> traceback.format_exception_only(type(theError), theError)
+   ['IndexError: tuple index out of range\n']

Lib/collections.py

         field_names = field_names.replace(',', ' ').split() # names separated by whitespace and/or commas
     field_names = tuple(field_names)
     for name in (typename,) + field_names:
-        if not name.replace('_', '').isalnum():
+        if not all(c.isalnum() or c=='_' for c in name):
             raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name)
         if _iskeyword(name):
             raise ValueError('Type names and field names cannot be a keyword: %r' % name)
             raise ValueError('Type names and field names cannot start with a number: %r' % name)
     seen_names = set()
     for name in field_names:
-        if name.startswith('__') and name.endswith('__'):
+        if name.startswith('__') and name.endswith('__') and len(name) > 3:
             raise ValueError('Field names cannot start and end with double underscores: %r' % name)
         if name in seen_names:
             raise ValueError('Encountered duplicate field name: %r' % name)

Lib/distutils/msvc9compiler.py

     popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
+
+    stdout, stderr = popen.communicate()
     if popen.wait() != 0:
-        raise IOError(popen.stderr.read())
+        raise IOError(stderr.decode("mbcs"))
 
-    for line in popen.stdout:
+    stdout = stdout.decode("mbcs")
+    for line in stdout.split("\n"):
         line = Reg.convert_mbcs(line)
         if '=' not in line:
             continue

Lib/test/test_collections.py

         self.assertRaises(ValueError, namedtuple, 'abc', 'efg efg ghi')    # duplicate field
 
         namedtuple('Point0', 'x1 y2')   # Verify that numbers are allowed in names
+        namedtuple('_', '_ __ ___')     # Verify that underscores are allowed
 
     def test_instance(self):
         Point = namedtuple('Point', 'x y')

Mac/Modules/osa/_OSAmodule.c

 	return _res;
 }
 
-static PyObject *OSAObj_OSADebuggerCreateSession(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSAID inScript;
-	OSAID inContext;
-	OSADebugSessionRef outSession;
-#ifndef OSADebuggerCreateSession
-	PyMac_PRECHECK(OSADebuggerCreateSession);
-#endif
-	if (!PyArg_ParseTuple(_args, "ll",
-	                      &inScript,
-	                      &inContext))
-		return NULL;
-	_err = OSADebuggerCreateSession(_self->ob_itself,
-	                                inScript,
-	                                inContext,
-	                                &outSession);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("l",
-	                     outSession);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetSessionState(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-	AERecord outState;
-#ifndef OSADebuggerGetSessionState
-	PyMac_PRECHECK(OSADebuggerGetSessionState);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inSession))
-		return NULL;
-	_err = OSADebuggerGetSessionState(_self->ob_itself,
-	                                  inSession,
-	                                  &outState);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &outState);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerSessionStep(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-	OSADebugStepKind inKind;
-#ifndef OSADebuggerSessionStep
-	PyMac_PRECHECK(OSADebuggerSessionStep);
-#endif
-	if (!PyArg_ParseTuple(_args, "ll",
-	                      &inSession,
-	                      &inKind))
-		return NULL;
-	_err = OSADebuggerSessionStep(_self->ob_itself,
-	                              inSession,
-	                              inKind);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerDisposeSession(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-#ifndef OSADebuggerDisposeSession
-	PyMac_PRECHECK(OSADebuggerDisposeSession);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inSession))
-		return NULL;
-	_err = OSADebuggerDisposeSession(_self->ob_itself,
-	                                 inSession);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetStatementRanges(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-	AEDescList outStatementRangeArray;
-#ifndef OSADebuggerGetStatementRanges
-	PyMac_PRECHECK(OSADebuggerGetStatementRanges);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inSession))
-		return NULL;
-	_err = OSADebuggerGetStatementRanges(_self->ob_itself,
-	                                     inSession,
-	                                     &outStatementRangeArray);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &outStatementRangeArray);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetBreakpoint(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-	UInt32 inSrcOffset;
-	OSAID outBreakpoint;
-#ifndef OSADebuggerGetBreakpoint
-	PyMac_PRECHECK(OSADebuggerGetBreakpoint);
-#endif
-	if (!PyArg_ParseTuple(_args, "ll",
-	                      &inSession,
-	                      &inSrcOffset))
-		return NULL;
-	_err = OSADebuggerGetBreakpoint(_self->ob_itself,
-	                                inSession,
-	                                inSrcOffset,
-	                                &outBreakpoint);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("l",
-	                     outBreakpoint);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerSetBreakpoint(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-	UInt32 inSrcOffset;
-	OSAID inBreakpoint;
-#ifndef OSADebuggerSetBreakpoint
-	PyMac_PRECHECK(OSADebuggerSetBreakpoint);
-#endif
-	if (!PyArg_ParseTuple(_args, "lll",
-	                      &inSession,
-	                      &inSrcOffset,
-	                      &inBreakpoint))
-		return NULL;
-	_err = OSADebuggerSetBreakpoint(_self->ob_itself,
-	                                inSession,
-	                                inSrcOffset,
-	                                inBreakpoint);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetDefaultBreakpoint(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-	OSAID outBreakpoint;
-#ifndef OSADebuggerGetDefaultBreakpoint
-	PyMac_PRECHECK(OSADebuggerGetDefaultBreakpoint);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inSession))
-		return NULL;
-	_err = OSADebuggerGetDefaultBreakpoint(_self->ob_itself,
-	                                       inSession,
-	                                       &outBreakpoint);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("l",
-	                     outBreakpoint);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetCurrentCallFrame(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugSessionRef inSession;
-	OSADebugCallFrameRef outCallFrame;
-#ifndef OSADebuggerGetCurrentCallFrame
-	PyMac_PRECHECK(OSADebuggerGetCurrentCallFrame);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inSession))
-		return NULL;
-	_err = OSADebuggerGetCurrentCallFrame(_self->ob_itself,
-	                                      inSession,
-	                                      &outCallFrame);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("l",
-	                     outCallFrame);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetCallFrameState(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugCallFrameRef inCallFrame;
-	AERecord outState;
-#ifndef OSADebuggerGetCallFrameState
-	PyMac_PRECHECK(OSADebuggerGetCallFrameState);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inCallFrame))
-		return NULL;
-	_err = OSADebuggerGetCallFrameState(_self->ob_itself,
-	                                    inCallFrame,
-	                                    &outState);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &outState);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetVariable(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugCallFrameRef inCallFrame;
-	AEDesc inVariableName;
-	OSAID outVariable;
-#ifndef OSADebuggerGetVariable
-	PyMac_PRECHECK(OSADebuggerGetVariable);
-#endif
-	if (!PyArg_ParseTuple(_args, "lO&",
-	                      &inCallFrame,
-	                      AEDesc_Convert, &inVariableName))
-		return NULL;
-	_err = OSADebuggerGetVariable(_self->ob_itself,
-	                              inCallFrame,
-	                              &inVariableName,
-	                              &outVariable);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("l",
-	                     outVariable);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerSetVariable(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugCallFrameRef inCallFrame;
-	AEDesc inVariableName;
-	OSAID inVariable;
-#ifndef OSADebuggerSetVariable
-	PyMac_PRECHECK(OSADebuggerSetVariable);
-#endif
-	if (!PyArg_ParseTuple(_args, "lO&l",
-	                      &inCallFrame,
-	                      AEDesc_Convert, &inVariableName,
-	                      &inVariable))
-		return NULL;
-	_err = OSADebuggerSetVariable(_self->ob_itself,
-	                              inCallFrame,
-	                              &inVariableName,
-	                              inVariable);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerGetPreviousCallFrame(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugCallFrameRef inCurrentFrame;
-	OSADebugCallFrameRef outPrevFrame;
-#ifndef OSADebuggerGetPreviousCallFrame
-	PyMac_PRECHECK(OSADebuggerGetPreviousCallFrame);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inCurrentFrame))
-		return NULL;
-	_err = OSADebuggerGetPreviousCallFrame(_self->ob_itself,
-	                                       inCurrentFrame,
-	                                       &outPrevFrame);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("l",
-	                     outPrevFrame);
-	return _res;
-}
-
-static PyObject *OSAObj_OSADebuggerDisposeCallFrame(OSAComponentInstanceObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	OSAError _err;
-	OSADebugCallFrameRef inCallFrame;
-#ifndef OSADebuggerDisposeCallFrame
-	PyMac_PRECHECK(OSADebuggerDisposeCallFrame);
-#endif
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &inCallFrame))
-		return NULL;
-	_err = OSADebuggerDisposeCallFrame(_self->ob_itself,
-	                                   inCallFrame);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
 static PyMethodDef OSAObj_methods[] = {
 	{"OSALoad", (PyCFunction)OSAObj_OSALoad, 1,
 	 PyDoc_STR("(AEDesc scriptData, long modeFlags) -> (OSAID resultingScriptID)")},
 	 PyDoc_STR("(AppleEvent theAppleEvent, OSAID contextID, long modeFlags) -> (AppleEvent reply)")},
 	{"OSAMakeContext", (PyCFunction)OSAObj_OSAMakeContext, 1,
 	 PyDoc_STR("(AEDesc contextName, OSAID parentContext) -> (OSAID resultingContextID)")},
-	{"OSADebuggerCreateSession", (PyCFunction)OSAObj_OSADebuggerCreateSession, 1,
-	 PyDoc_STR("(OSAID inScript, OSAID inContext) -> (OSADebugSessionRef outSession)")},
-	{"OSADebuggerGetSessionState", (PyCFunction)OSAObj_OSADebuggerGetSessionState, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession) -> (AERecord outState)")},
-	{"OSADebuggerSessionStep", (PyCFunction)OSAObj_OSADebuggerSessionStep, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession, OSADebugStepKind inKind) -> None")},
-	{"OSADebuggerDisposeSession", (PyCFunction)OSAObj_OSADebuggerDisposeSession, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession) -> None")},
-	{"OSADebuggerGetStatementRanges", (PyCFunction)OSAObj_OSADebuggerGetStatementRanges, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession) -> (AEDescList outStatementRangeArray)")},
-	{"OSADebuggerGetBreakpoint", (PyCFunction)OSAObj_OSADebuggerGetBreakpoint, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession, UInt32 inSrcOffset) -> (OSAID outBreakpoint)")},
-	{"OSADebuggerSetBreakpoint", (PyCFunction)OSAObj_OSADebuggerSetBreakpoint, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession, UInt32 inSrcOffset, OSAID inBreakpoint) -> None")},
-	{"OSADebuggerGetDefaultBreakpoint", (PyCFunction)OSAObj_OSADebuggerGetDefaultBreakpoint, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession) -> (OSAID outBreakpoint)")},
-	{"OSADebuggerGetCurrentCallFrame", (PyCFunction)OSAObj_OSADebuggerGetCurrentCallFrame, 1,
-	 PyDoc_STR("(OSADebugSessionRef inSession) -> (OSADebugCallFrameRef outCallFrame)")},
-	{"OSADebuggerGetCallFrameState", (PyCFunction)OSAObj_OSADebuggerGetCallFrameState, 1,
-	 PyDoc_STR("(OSADebugCallFrameRef inCallFrame) -> (AERecord outState)")},
-	{"OSADebuggerGetVariable", (PyCFunction)OSAObj_OSADebuggerGetVariable, 1,
-	 PyDoc_STR("(OSADebugCallFrameRef inCallFrame, AEDesc inVariableName) -> (OSAID outVariable)")},
-	{"OSADebuggerSetVariable", (PyCFunction)OSAObj_OSADebuggerSetVariable, 1,
-	 PyDoc_STR("(OSADebugCallFrameRef inCallFrame, AEDesc inVariableName, OSAID inVariable) -> None")},
-	{"OSADebuggerGetPreviousCallFrame", (PyCFunction)OSAObj_OSADebuggerGetPreviousCallFrame, 1,
-	 PyDoc_STR("(OSADebugCallFrameRef inCurrentFrame) -> (OSADebugCallFrameRef outPrevFrame)")},
-	{"OSADebuggerDisposeCallFrame", (PyCFunction)OSAObj_OSADebuggerDisposeCallFrame, 1,
-	 PyDoc_STR("(OSADebugCallFrameRef inCallFrame) -> None")},
 	{NULL, NULL, 0}
 };
 

PCbuild9/build_tkinter.py

 here = os.path.abspath(os.path.dirname(__file__))
 par = os.path.pardir
 
-#TCL = "tcl8.4.16"
+TCL = "tcl8.4.16"
+TK = "tk8.4.16"
+TIX = "Tix8.4.0"
 #TIX = "Tix8.4.2"
-#TK = "tk8.4.16"
-TCL = "tcl8.4.12"
-TIX = "Tix8.4.0"
-TK = "tk8.4.12"
 ROOT = os.path.abspath(os.path.join(here, par, par))
 NMAKE = "nmake /nologo "
 
     if True:
         os.chdir(os.path.join(ROOT, TIX, "win"))
         if clean:
-            system(NMAKE + "/f makefile.vc clean")
-        system(NMAKE + "/f makefile.vc MACHINE=%s" % machine)
-        system(NMAKE + "/f makefile.vc INSTALL_DIR=%s install" % dest)
+            system(NMAKE + "/f python9.mak clean")
+        system(NMAKE + "/f python9.mak MACHINE=%s" % machine)
+        system(NMAKE + "/f python9.mak install")
 
 
 def main():

PCbuild9/readme.txt

     svn export http://svn.python.org/projects/external/tk8.4.16
     svn export http://svn.python.org/projects/external/tix-8.4.0
 
-    Build Tcl first (done here w/ MSVC 7.1 on Windows XP)
+    Build with build_tkinter.py
+    ---------------------------
+    The PCbuild9 directory contains a Python script which automates all
+    steps. Run the script in a Visual Studio 2009 command prompt with 
+
+      python build_tkinter.py Win32
+
+    Use x64 instead of Win32 for the x64 platform.
+    
+    Build Tcl first 
     ---------------
-    Use "Start -> All Programs -> Microsoft Visual Studio .NET 2003
-         -> Visual Studio .NET Tools -> Visual Studio .NET 2003 Command Prompt"
+    Use "Start -> All Programs -> Microsoft Visual Studio 2008
+         -> Visual Studio Tools -> Visual Studio 2008 Command Prompt"
     to get a shell window with the correct environment settings
     cd dist\tcl8.4.16\win
     nmake -f makefile.vc
 	next opcode.
 
 	A successful prediction saves a trip through the eval-loop including
-	its two unpredictable branches, the HASARG test and the switch-case.
+	its two unpredictable branches, the HAS_ARG test and the switch-case.
 
         If collecting opcode statistics, turn off prediction so that
 	statistics are accurately maintained (the predictions bypass