AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python 2.7.3 made them unavailable from the python.org web site.

These files are a subset of the python-2.7.2.tgz distribution from python.org.  Changed files from PyMod-2.7.2 have been copied into the corresponding directories of this tree, replacing the original files in the distribution.

Signed-off-by: daryl.mcdaniel@intel.com


git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@13197 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 117 insertions, 0 deletions

diff --git a/AppPkg/Applications/Python/Python-2.7.2/Tools/scripts/find_recursionlimit.py b/AppPkg/Applications/Python/Python-2.7.2/Tools/scripts/find_recursionlimit.py
new file mode 100644
index 0000000000..8b578e9294
--- /dev/null
+++ b/AppPkg/Applications/Python/Python-2.7.2/Tools/scripts/find_recursionlimit.py
@@ -0,0 +1,117 @@
+#! /usr/bin/env python

+"""Find the maximum recursion limit that prevents interpreter termination.

+

+This script finds the maximum safe recursion limit on a particular

+platform.  If you need to change the recursion limit on your system,

+this script will tell you a safe upper bound.  To use the new limit,

+call sys.setrecursionlimit().

+

+This module implements several ways to create infinite recursion in

+Python.  Different implementations end up pushing different numbers of

+C stack frames, depending on how many calls through Python's abstract

+C API occur.

+

+After each round of tests, it prints a message:

+"Limit of NNNN is fine".

+

+The highest printed value of "NNNN" is therefore the highest potentially

+safe limit for your system (which depends on the OS, architecture, but also

+the compilation flags). Please note that it is practically impossible to

+test all possible recursion paths in the interpreter, so the results of

+this test should not be trusted blindly -- although they give a good hint

+of which values are reasonable.

+

+NOTE: When the C stack space allocated by your system is exceeded due

+to excessive recursion, exact behaviour depends on the platform, although

+the interpreter will always fail in a likely brutal way: either a

+segmentation fault, a MemoryError, or just a silent abort.

+

+NB: A program that does not use __methods__ can set a higher limit.

+"""

+

+import sys

+import itertools

+

+class RecursiveBlowup1:

+    def __init__(self):

+        self.__init__()

+

+def test_init():

+    return RecursiveBlowup1()

+

+class RecursiveBlowup2:

+    def __repr__(self):

+        return repr(self)

+

+def test_repr():

+    return repr(RecursiveBlowup2())

+

+class RecursiveBlowup4:

+    def __add__(self, x):

+        return x + self

+

+def test_add():

+    return RecursiveBlowup4() + RecursiveBlowup4()

+

+class RecursiveBlowup5:

+    def __getattr__(self, attr):

+        return getattr(self, attr)

+

+def test_getattr():

+    return RecursiveBlowup5().attr

+

+class RecursiveBlowup6:

+    def __getitem__(self, item):

+        return self[item - 2] + self[item - 1]

+

+def test_getitem():

+    return RecursiveBlowup6()[5]

+

+def test_recurse():

+    return test_recurse()

+

+def test_cpickle(_cache={}):

+    try:

+        import cPickle

+    except ImportError:

+        print "cannot import cPickle, skipped!"

+        return

+    l = None

+    for n in itertools.count():

+        try:

+            l = _cache[n]

+            continue  # Already tried and it works, let's save some time

+        except KeyError:

+            for i in range(100):

+                l = [l]

+        cPickle.dumps(l, protocol=-1)

+        _cache[n] = l

+

+def check_limit(n, test_func_name):

+    sys.setrecursionlimit(n)

+    if test_func_name.startswith("test_"):

+        print test_func_name[5:]

+    else:

+        print test_func_name

+    test_func = globals()[test_func_name]

+    try:

+        test_func()

+    # AttributeError can be raised because of the way e.g. PyDict_GetItem()

+    # silences all exceptions and returns NULL, which is usually interpreted

+    # as "missing attribute".

+    except (RuntimeError, AttributeError):

+        pass

+    else:

+        print "Yikes!"

+

+limit = 1000

+while 1:

+    check_limit(limit, "test_recurse")

+    check_limit(limit, "test_add")

+    check_limit(limit, "test_repr")

+    check_limit(limit, "test_init")

+    check_limit(limit, "test_getattr")

+    check_limit(limit, "test_getitem")

+    check_limit(limit, "test_cpickle")

+    print "Limit of %d is fine" % limit

+    limit = limit + 100