Clean up escape-decode decoder tests.

author: Serhiy Storchaka <storchaka@gmail.com> 2013-01-29 09:07:27 (GMT)
committer: Serhiy Storchaka <storchaka@gmail.com> 2013-01-29 09:07:27 (GMT)
commit: db6add7d7114a1cc86d5d62df7f625a37deee2d4 (patch)
tree: de1660a59904f12938a025ae965fd3391bab3be3 /Python/strdup.c
parent: 0ef48f02f2161c035679f85782fd5a0a712e032a (diff)
parent: 077cb347a9ecfa5736050292045fb702ede9bed9 (diff)
download: cpython-db6add7d7114a1cc86d5d62df7f625a37deee2d4.zip
cpython-db6add7d7114a1cc86d5d62df7f625a37deee2d4.tar.gz
cpython-db6add7d7114a1cc86d5d62df7f625a37deee2d4.tar.bz2
0 files changed, 0 insertions, 0 deletions
diff --git a/.bzrignore b/.bzrignore
index 463e983..959a7df 100644
--- a/.bzrignore
+++ b/.bzrignore
@@ -11,27 +11,13 @@ python
 build
 Makefile.pre
 platform
+pybuilddir.txt
 pyconfig.h
 libpython*.a
+libpython*.so*
 python.exe
-CP936.TXT
-SHIFT_JISX0213.TXT
-JOHAB.TXT
-EUC-JP.TXT
-NormalizationTest-3.2.0.txt
-NormalizationTest.txt
-BIG5.TXT
-BIG5HKSCS-2004.TXT
-CP949.TXT
-EUC-CN.TXT
-BIG5HKSCS.TXT
-SHIFTJIS.TXT
-EUC-KR.TXT
-EUC-JISX0213.TXT
-CP932.TXT
-CP950.TXT
+python-gdb.py
 reflog.txt
-gb-18030-2000.xml
 tags
 TAGS
 .gdb_history
@@ -47,5 +33,11 @@ Modules/Setup.local
 Modules/config.c
 Modules/ld_so_aix
 Parser/pgen
+Parser/pgen.stamp
+Lib/test/data/*
 Lib/lib2to3/Grammar*.pickle
 Lib/lib2to3/PatternGrammar*.pickle
+__pycache__
+.coverage
+coverage/*
+htmlcov/*
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..7dfc5ad
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,49 @@
+*.cover
+*.o
+*.orig
+*.pyc
+*.pyd
+*.pyo
+*.rej
+*~
+Doc/build/
+Doc/tools/docutils/
+Doc/tools/jinja2/
+Doc/tools/pygments/
+Doc/tools/sphinx/
+Lib/lib2to3/*.pickle
+Makefile
+Makefile.pre
+Misc/python.pc
+Modules/Setup
+Modules/Setup.config
+Modules/Setup.local
+Modules/config.c
+Modules/ld_so_aix
+Modules/_testembed
+PCbuild/*.bsc
+PCbuild/*.dll
+PCbuild/*.exe
+PCbuild/*.exp
+PCbuild/*.lib
+PCbuild/*.ncb
+PCbuild/*.o
+PCbuild/*.pdb
+PCbuild/Win32-temp-*
+Parser/pgen
+Parser/pgen.stamp
+__pycache__
+autom4te.cache
+build/
+config.log
+config.status
+libpython*.a
+libpython*.so*
+pybuilddir.txt
+pyconfig.h
+python
+python-gdb.py
+tags
+.coverage
+coverage/
+htmlcov/
diff --git a/.hgignore b/.hgignore
index 33e6caa..24df3b9 100644
--- a/.hgignore
+++ b/.hgignore
@@ -1,40 +1,23 @@
 .gdb_history
 .purify
-.svn
-BIG5.TXT
-BIG5HKSCS-2004.TXT
-BIG5HKSCS.TXT
-CP932.TXT
-CP936.TXT
-CP949.TXT
-CP950.TXT
-EUC-CN.TXT
-EUC-JISX0213.TXT
-EUC-JP.TXT
-EUC-KR.TXT
-JOHAB.TXT
+.svn/
 Makefile$
 Makefile.pre$
-NormalizationTest-3.2.0.txt
-NormalizationTest.txt
-SHIFTJIS.TXT
-SHIFT_JISX0213.TXT
-TAGS
-autom4te.cache
-build
-buildno
+TAGS$
+autom4te.cache$
+build/
+buildno$
 config.cache
 config.log
 config.status
 config.status.lineno
 db_home
-gb-18030-2000.xml
-platform
-pyconfig.h
-python
-python.exe
-reflog.txt
-tags
+platform$
+pyconfig.h$
+python$
+python.exe$
+reflog.txt$
+tags$
 Lib/plat-mac/errors.rsrc.df.rsrc
 Doc/tools/sphinx/
 Doc/tools/docutils/
@@ -42,27 +25,35 @@ Doc/tools/jinja/
 Doc/tools/jinja2/
 Doc/tools/pygments/
 Misc/python.pc
-Modules/Setup
+Modules/Setup$
 Modules/Setup.config
 Modules/Setup.local
 Modules/config.c
-Parser/pgen
-core
 Modules/ld_so_aix$
+Parser/pgen$
+Parser/pgen.stamp$
+^core
+^python-gdb.py
+^python.exe-gdb.py
+^pybuilddir.txt
+
 syntax: glob
 libpython*.a
+libpython*.so*
+*.swp
 *.o
 *.pyc
 *.pyo
 *.pyd
 *.cover
-*.orig
-*.rej
 *~
 Lib/lib2to3/*.pickle
+Lib/test/data/*
+Misc/*.wpu
 PC/python_nt*.h
 PC/pythonnt_rc*.h
 PC/*.obj
+PC/*.exe
 PCbuild/*.exe
 PCbuild/*.dll
 PCbuild/*.pdb
@@ -72,3 +63,8 @@ PCbuild/*.o
 PCbuild/*.ncb
 PCbuild/*.bsc
 PCbuild/Win32-temp-*
+__pycache__
+Modules/_testembed
+.coverage
+coverage/
+htmlcov/
diff --git a/.hgtags b/.hgtags
index 71d5cc9..0830aaf 100644
--- a/.hgtags
+++ b/.hgtags
@@ -78,3 +78,20 @@ a4f75773c0060cee38b0bb651a7aba6f56b0e996 v3.1.3
 32fcb9e94985cb19ce37ba9543f091c0dbe9d7dd v3.1.4rc1
 c918ec9f3a76d6afedfbb5d455004de880443a3d v3.1.4
 ee26aca3219cf4bb0b93352e83edcc9cb28c7802 v3.1.5rc1
+b37b7834757492d009b99cf0ca4d42d2153d7fac v3.2a1
+56d4373cecb73c8b45126ba7b045b3c7b3f94b0b v3.2a2
+da012d9a2c23d144e399d2e01a55b8a83ad94573 v3.2a3
+d92a5b850f5e56808bedc01723906ed64c5e6e2e v3.2a4
+b635cea94195780c8716e236479af319bcc26253 v3.2b1
+e3af5f3a7904c0d5343ec9633ea66e7acfd23a66 v3.2b2
+865d5b24bf28ca41b536befc326407c03e74a4d5 v3.2rc1
+acf3e24dd0d0dfd1e20c907d696d3da965a8f56f v3.2rc2
+18c1f52896501c7ee13b038454a39acb45a87979 v3.2rc3
+a222a015e28d8ae9af3899258dc6c15c3d40add0 v3.2
+8ffac2337a3323323d02153ac919fd1483176652 v3.2.1b1
+cfa9364997c7f2e67b9cbb45c3a5fa3bba4e4999 v3.2.1rc1
+5df549718fb4841ff521fe051f6b54f290fad5d8 v3.2.1rc2
+ac1f7e5c05104d557d5acd922e95625ba5d1fe10 v3.2.1
+c860feaa348d663e598986894ee4680480577e15 v3.2.2rc1
+137e45f15c0bd262c9ad4c032d97425bc0589456 v3.2.2
+7085403daf439adb3f9e70ef13f6bedb1c447376 v3.2.3rc1
diff --git a/Demo/README b/Demo/README
deleted file mode 100644
index 9d150d6..0000000
--- a/Demo/README
+++ /dev/null
@@ -1,61 +0,0 @@
-This directory contains various demonstrations of what you can do with
-Python.  They were all written by me except where explicitly stated
-otherwise -- in general, demos contributed by others ends up in the
-../Contrib directory, unless I think they're of utmost general
-importance (like Matt Conway's Tk demos).
-
-A fair number of utilities that are useful when while developing
-Python code can be found in the ../Tools directory -- some of these
-can also be considered good examples of how to write Python code.
-
-Finally, in order to save disk space and net bandwidth, not all
-subdirectories listed here are distributed.  They are listed just
-in case I change my mind about them.
-
-
-cgi             CGI examples (see also ../Tools/faqwiz/.)
-
-classes		Some examples of how to use classes.
-
-comparisons	A set of responses to a really old language-comparison
-		challenge.
-
-curses		A set of curses demos.
-
-embed		An example of embedding Python in another application
-		(see also pysvr).
-
-imputil		Demonstration subclasses of imputil.Importer.
-
-md5test		Test program for the optional md5 module.
-
-metaclasses	The code from the 1.5 metaclasses paper on the web.
-
-parser		Example using the parser module.
-
-pdist		Old, unfinished code messing with CVS, RCS and remote
-		files.
-
-pysvr		An example of embedding Python in a threaded
-		application.
-
-rpc		A set of classes for building clients and servers for
-		Sun RPC.
-
-scripts		Some useful Python scripts that I put in my bin
-		directory.  No optional built-in modules needed.
-
-sockets		Examples for the new built-in module 'socket'.
-
-threads		Demos that use the 'thread' module.  (Currently these
-		only run on SGIs, but this may change in the future.)
-
-tix		Demos using the Tix widget set addition to Tkinter.
-
-tkinter		Demos using the Tk interface (including Matt Conway's
-		excellent set of demos).
-
-xml		Some XML demos.
-
-zlib		Some demos for the zlib module (see also the standard
-		library module gzip.py).
diff --git a/Demo/cgi/README b/Demo/cgi/README
deleted file mode 100644
index c0631b6..0000000
--- a/Demo/cgi/README
+++ /dev/null
@@ -1,10 +0,0 @@
-CGI Examples
-------------
-
-Here are some example CGI programs.
-
-cgi0.sh -- A shell script to test your server is configured for CGI
-cgi1.py -- A Python script to test your server is configured for CGI
-cgi2.py -- A Python script showing how to parse a form
-cgi3.py -- A Python script for driving an arbitrary CGI application
-wiki.py -- Sample CGI application: a minimal Wiki implementation
diff --git a/Demo/cgi/cgi0.sh b/Demo/cgi/cgi0.sh
deleted file mode 100755
index 5cefcd3..0000000
--- a/Demo/cgi/cgi0.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#! /bin/sh
-
-# If you can't get this to work, your web server isn't set up right
-
-echo Content-type: text/plain
-echo
-echo Hello world
-echo This is cgi0.sh
diff --git a/Demo/cgi/cgi1.py b/Demo/cgi/cgi1.py
deleted file mode 100755
index 842fef2..0000000
--- a/Demo/cgi/cgi1.py
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/local/bin/python
-
-"""CGI test 1 - check server setup."""
-
-# Until you get this to work, your web server isn't set up right or
-# your Python isn't set up right.
-
-# If cgi0.sh works but cgi1.py doesn't, check the #! line and the file
-# permissions.  The docs for the cgi.py module have debugging tips.
-
-print("Content-type: text/html")
-print()
-print("<h1>Hello world</h1>")
-print("<p>This is cgi1.py")
diff --git a/Demo/cgi/cgi2.py b/Demo/cgi/cgi2.py
deleted file mode 100755
index 1d5822c..0000000
--- a/Demo/cgi/cgi2.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/local/bin/python
-
-"""CGI test 2 - basic use of cgi module."""
-
-import cgitb; cgitb.enable()
-
-import cgi
-
-def main():
-    form = cgi.FieldStorage()
-    print("Content-type: text/html")
-    print()
-    if not form:
-        print("<h1>No Form Keys</h1>")
-    else:
-        print("<h1>Form Keys</h1>")
-        for key in form.keys():
-            value = form[key].value
-            print("<p>", cgi.escape(key), ":", cgi.escape(value))
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/cgi/cgi3.py b/Demo/cgi/cgi3.py
deleted file mode 100755
index a3421b5..0000000
--- a/Demo/cgi/cgi3.py
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/local/bin/python
-
-"""CGI test 3 (persistent data)."""
-
-import cgitb; cgitb.enable()
-
-from wiki import main
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/cgi/wiki.py b/Demo/cgi/wiki.py
deleted file mode 100644
index 6b97113..0000000
--- a/Demo/cgi/wiki.py
+++ /dev/null
@@ -1,123 +0,0 @@
-"""Wiki main program.  Imported and run by cgi3.py."""
-
-import os, re, cgi, sys, tempfile
-escape = cgi.escape
-
-def main():
-    form = cgi.FieldStorage()
-    print("Content-type: text/html")
-    print()
-    cmd = form.getvalue("cmd", "view")
-    page = form.getvalue("page", "FrontPage")
-    wiki = WikiPage(page)
-    method = getattr(wiki, 'cmd_' + cmd, None) or wiki.cmd_view
-    method(form)
-
-class WikiPage:
-
-    homedir = tempfile.gettempdir()
-    scripturl = os.path.basename(sys.argv[0])
-
-    def __init__(self, name):
-        if not self.iswikiword(name):
-            raise ValueError("page name is not a wiki word")
-        self.name = name
-        self.load()
-
-    def cmd_view(self, form):
-        print("<h1>", escape(self.splitwikiword(self.name)), "</h1>")
-        print("<p>")
-        for line in self.data.splitlines():
-            line = line.rstrip()
-            if not line:
-                print("<p>")
-            else:
-                print(self.formatline(line))
-        print("<hr>")
-        print("<p>", self.mklink("edit", self.name, "Edit this page") + ";")
-        print(self.mklink("view", "FrontPage", "go to front page") + ".")
-
-    def formatline(self, line):
-        words = []
-        for word in re.split('(\W+)', line):
-            if self.iswikiword(word):
-                if os.path.isfile(self.mkfile(word)):
-                    word = self.mklink("view", word, word)
-                else:
-                    word = self.mklink("new", word, word + "*")
-            else:
-                word = escape(word)
-            words.append(word)
-        return "".join(words)
-
-    def cmd_edit(self, form, label="Change"):
-        print("<h1>", label, self.name, "</h1>")
-        print('<form method="POST" action="%s">' % self.scripturl)
-        s = '<textarea cols="70" rows="20" name="text">%s</textarea>'
-        print(s % self.data)
-        print('<input type="hidden" name="cmd" value="create">')
-        print('<input type="hidden" name="page" value="%s">' % self.name)
-        print('<br>')
-        print('<input type="submit" value="%s Page">' % label)
-        print("</form>")
-
-    def cmd_create(self, form):
-        self.data = form.getvalue("text", "").strip()
-        error = self.store()
-        if error:
-            print("<h1>I'm sorry.  That didn't work</h1>")
-            print("<p>An error occurred while attempting to write the file:")
-            print("<p>", escape(error))
-        else:
-            # Use a redirect directive, to avoid "reload page" problems
-            print("<head>")
-            s = '<meta http-equiv="refresh" content="1; URL=%s">'
-            print(s % (self.scripturl + "?cmd=view&page=" + self.name))
-            print("<head>")
-            print("<h1>OK</h1>")
-            print("<p>If nothing happens, please click here:", end=' ')
-            print(self.mklink("view", self.name, self.name))
-
-    def cmd_new(self, form):
-        self.cmd_edit(form, label="Create")
-
-    def iswikiword(self, word):
-        return re.match("[A-Z][a-z]+([A-Z][a-z]*)+", word)
-
-    def splitwikiword(self, word):
-        chars = []
-        for c in word:
-            if chars and c.isupper():
-                chars.append(' ')
-            chars.append(c)
-        return "".join(chars)
-
-    def mkfile(self, name=None):
-        if name is None:
-            name = self.name
-        return os.path.join(self.homedir, name + ".txt")
-
-    def mklink(self, cmd, page, text):
-        link = self.scripturl + "?cmd=" + cmd + "&page=" + page
-        return '<a href="%s">%s</a>' % (link, text)
-
-    def load(self):
-        try:
-            f = open(self.mkfile())
-            data = f.read().strip()
-            f.close()
-        except IOError:
-            data = ""
-        self.data = data
-
-    def store(self):
-        data = self.data
-        try:
-            f = open(self.mkfile(), "w")
-            f.write(data)
-            if data and not data.endswith('\n'):
-                f.write('\n')
-            f.close()
-            return ""
-        except IOError as err:
-            return "IOError: %s" % str(err)
diff --git a/Demo/classes/Complex.py b/Demo/classes/Complex.py
deleted file mode 100755
index 64c56d4..0000000
--- a/Demo/classes/Complex.py
+++ /dev/null
@@ -1,314 +0,0 @@
-# Complex numbers
-# ---------------
-
-# [Now that Python has a complex data type built-in, this is not very
-# useful, but it's still a nice example class]
-
-# This module represents complex numbers as instances of the class Complex.
-# A Complex instance z has two data attribues, z.re (the real part) and z.im
-# (the imaginary part).  In fact, z.re and z.im can have any value -- all
-# arithmetic operators work regardless of the type of z.re and z.im (as long
-# as they support numerical operations).
-#
-# The following functions exist (Complex is actually a class):
-# Complex([re [,im]) -> creates a complex number from a real and an imaginary part
-# IsComplex(z) -> true iff z is a complex number (== has .re and .im attributes)
-# ToComplex(z) -> a complex number equal to z; z itself if IsComplex(z) is true
-#                 if z is a tuple(re, im) it will also be converted
-# PolarToComplex([r [,phi [,fullcircle]]]) ->
-#       the complex number z for which r == z.radius() and phi == z.angle(fullcircle)
-#       (r and phi default to 0)
-# exp(z) -> returns the complex exponential of z. Equivalent to pow(math.e,z).
-#
-# Complex numbers have the following methods:
-# z.abs() -> absolute value of z
-# z.radius() == z.abs()
-# z.angle([fullcircle]) -> angle from positive X axis; fullcircle gives units
-# z.phi([fullcircle]) == z.angle(fullcircle)
-#
-# These standard functions and unary operators accept complex arguments:
-# abs(z)
-# -z
-# +z
-# not z
-# repr(z) == `z`
-# str(z)
-# hash(z) -> a combination of hash(z.re) and hash(z.im) such that if z.im is zero
-#            the result equals hash(z.re)
-# Note that hex(z) and oct(z) are not defined.
-#
-# These conversions accept complex arguments only if their imaginary part is zero:
-# int(z)
-# float(z)
-#
-# The following operators accept two complex numbers, or one complex number
-# and one real number (int, long or float):
-# z1 + z2
-# z1 - z2
-# z1 * z2
-# z1 / z2
-# pow(z1, z2)
-# cmp(z1, z2)
-# Note that z1 % z2 and divmod(z1, z2) are not defined,
-# nor are shift and mask operations.
-#
-# The standard module math does not support complex numbers.
-# The cmath modules should be used instead.
-#
-# Idea:
-# add a class Polar(r, phi) and mixed-mode arithmetic which
-# chooses the most appropriate type for the result:
-# Complex for +,-,cmp
-# Polar   for *,/,pow
-
-import math
-import sys
-
-twopi = math.pi*2.0
-halfpi = math.pi/2.0
-
-def IsComplex(obj):
-    return hasattr(obj, 're') and hasattr(obj, 'im')
-
-def ToComplex(obj):
-    if IsComplex(obj):
-        return obj
-    elif isinstance(obj, tuple):
-        return Complex(*obj)
-    else:
-        return Complex(obj)
-
-def PolarToComplex(r = 0, phi = 0, fullcircle = twopi):
-    phi = phi * (twopi / fullcircle)
-    return Complex(math.cos(phi)*r, math.sin(phi)*r)
-
-def Re(obj):
-    if IsComplex(obj):
-        return obj.re
-    return obj
-
-def Im(obj):
-    if IsComplex(obj):
-        return obj.im
-    return 0
-
-class Complex:
-
-    def __init__(self, re=0, im=0):
-        _re = 0
-        _im = 0
-        if IsComplex(re):
-            _re = re.re
-            _im = re.im
-        else:
-            _re = re
-        if IsComplex(im):
-            _re = _re - im.im
-            _im = _im + im.re
-        else:
-            _im = _im + im
-        # this class is immutable, so setting self.re directly is
-        # not possible.
-        self.__dict__['re'] = _re
-        self.__dict__['im'] = _im
-
-    def __setattr__(self, name, value):
-        raise TypeError('Complex numbers are immutable')
-
-    def __hash__(self):
-        if not self.im:
-            return hash(self.re)
-        return hash((self.re, self.im))
-
-    def __repr__(self):
-        if not self.im:
-            return 'Complex(%r)' % (self.re,)
-        else:
-            return 'Complex(%r, %r)' % (self.re, self.im)
-
-    def __str__(self):
-        if not self.im:
-            return repr(self.re)
-        else:
-            return 'Complex(%r, %r)' % (self.re, self.im)
-
-    def __neg__(self):
-        return Complex(-self.re, -self.im)
-
-    def __pos__(self):
-        return self
-
-    def __abs__(self):
-        return math.hypot(self.re, self.im)
-
-    def __int__(self):
-        if self.im:
-            raise ValueError("can't convert Complex with nonzero im to int")
-        return int(self.re)
-
-    def __float__(self):
-        if self.im:
-            raise ValueError("can't convert Complex with nonzero im to float")
-        return float(self.re)
-
-    def __cmp__(self, other):
-        other = ToComplex(other)
-        return cmp((self.re, self.im), (other.re, other.im))
-
-    def __rcmp__(self, other):
-        other = ToComplex(other)
-        return cmp(other, self)
-
-    def __bool__(self):
-        return not (self.re == self.im == 0)
-
-    abs = radius = __abs__
-
-    def angle(self, fullcircle = twopi):
-        return (fullcircle/twopi) * ((halfpi - math.atan2(self.re, self.im)) % twopi)
-
-    phi = angle
-
-    def __add__(self, other):
-        other = ToComplex(other)
-        return Complex(self.re + other.re, self.im + other.im)
-
-    __radd__ = __add__
-
-    def __sub__(self, other):
-        other = ToComplex(other)
-        return Complex(self.re - other.re, self.im - other.im)
-
-    def __rsub__(self, other):
-        other = ToComplex(other)
-        return other - self
-
-    def __mul__(self, other):
-        other = ToComplex(other)
-        return Complex(self.re*other.re - self.im*other.im,
-                       self.re*other.im + self.im*other.re)
-
-    __rmul__ = __mul__
-
-    def __div__(self, other):
-        other = ToComplex(other)
-        d = float(other.re*other.re + other.im*other.im)
-        if not d: raise ZeroDivisionError('Complex division')
-        return Complex((self.re*other.re + self.im*other.im) / d,
-                       (self.im*other.re - self.re*other.im) / d)
-
-    def __rdiv__(self, other):
-        other = ToComplex(other)
-        return other / self
-
-    def __pow__(self, n, z=None):
-        if z is not None:
-            raise TypeError('Complex does not support ternary pow()')
-        if IsComplex(n):
-            if n.im:
-                if self.im: raise TypeError('Complex to the Complex power')
-                else: return exp(math.log(self.re)*n)
-            n = n.re
-        r = pow(self.abs(), n)
-        phi = n*self.angle()
-        return Complex(math.cos(phi)*r, math.sin(phi)*r)
-
-    def __rpow__(self, base):
-        base = ToComplex(base)
-        return pow(base, self)
-
-def exp(z):
-    r = math.exp(z.re)
-    return Complex(math.cos(z.im)*r,math.sin(z.im)*r)
-
-
-def checkop(expr, a, b, value, fuzz = 1e-6):
-    print('       ', a, 'and', b, end=' ')
-    try:
-        result = eval(expr)
-    except:
-        result = sys.exc_info()[0]
-    print('->', result)
-    if isinstance(result, str) or isinstance(value, str):
-        ok = (result == value)
-    else:
-        ok = abs(result - value) <= fuzz
-    if not ok:
-        print('!!\t!!\t!! should be', value, 'diff', abs(result - value))
-
-def test():
-    print('test constructors')
-    constructor_test = (
-        # "expect" is an array [re,im] "got" the Complex.
-            ( (0,0), Complex() ),
-            ( (0,0), Complex() ),
-            ( (1,0), Complex(1) ),
-            ( (0,1), Complex(0,1) ),
-            ( (1,2), Complex(Complex(1,2)) ),
-            ( (1,3), Complex(Complex(1,2),1) ),
-            ( (0,0), Complex(0,Complex(0,0)) ),
-            ( (3,4), Complex(3,Complex(4)) ),
-            ( (-1,3), Complex(1,Complex(3,2)) ),
-            ( (-7,6), Complex(Complex(1,2),Complex(4,8)) ) )
-    cnt = [0,0]
-    for t in constructor_test:
-        cnt[0] += 1
-        if ((t[0][0]!=t[1].re)or(t[0][1]!=t[1].im)):
-            print("        expected", t[0], "got", t[1])
-            cnt[1] += 1
-    print("  ", cnt[1], "of", cnt[0], "tests failed")
-    # test operators
-    testsuite = {
-            'a+b': [
-                    (1, 10, 11),
-                    (1, Complex(0,10), Complex(1,10)),
-                    (Complex(0,10), 1, Complex(1,10)),
-                    (Complex(0,10), Complex(1), Complex(1,10)),
-                    (Complex(1), Complex(0,10), Complex(1,10)),
-            ],
-            'a-b': [
-                    (1, 10, -9),
-                    (1, Complex(0,10), Complex(1,-10)),
-                    (Complex(0,10), 1, Complex(-1,10)),
-                    (Complex(0,10), Complex(1), Complex(-1,10)),
-                    (Complex(1), Complex(0,10), Complex(1,-10)),
-            ],
-            'a*b': [
-                    (1, 10, 10),
-                    (1, Complex(0,10), Complex(0, 10)),
-                    (Complex(0,10), 1, Complex(0,10)),
-                    (Complex(0,10), Complex(1), Complex(0,10)),
-                    (Complex(1), Complex(0,10), Complex(0,10)),
-            ],
-            'a/b': [
-                    (1., 10, 0.1),
-                    (1, Complex(0,10), Complex(0, -0.1)),
-                    (Complex(0, 10), 1, Complex(0, 10)),
-                    (Complex(0, 10), Complex(1), Complex(0, 10)),
-                    (Complex(1), Complex(0,10), Complex(0, -0.1)),
-            ],
-            'pow(a,b)': [
-                    (1, 10, 1),
-                    (1, Complex(0,10), 1),
-                    (Complex(0,10), 1, Complex(0,10)),
-                    (Complex(0,10), Complex(1), Complex(0,10)),
-                    (Complex(1), Complex(0,10), 1),
-                    (2, Complex(4,0), 16),
-            ],
-            'cmp(a,b)': [
-                    (1, 10, -1),
-                    (1, Complex(0,10), 1),
-                    (Complex(0,10), 1, -1),
-                    (Complex(0,10), Complex(1), -1),
-                    (Complex(1), Complex(0,10), 1),
-            ],
-    }
-    for expr in sorted(testsuite):
-        print(expr + ':')
-        t = (expr,)
-        for item in testsuite[expr]:
-            checkop(*(t+item))
-
-
-if __name__ == '__main__':
-    test()
diff --git a/Demo/classes/Dates.py b/Demo/classes/Dates.py
deleted file mode 100755
index e1b054f..0000000
--- a/Demo/classes/Dates.py
+++ /dev/null
@@ -1,227 +0,0 @@
-# Class Date supplies date objects that support date arithmetic.
-#
-# Date(month,day,year) returns a Date object.  An instance prints as,
-# e.g., 'Mon 16 Aug 1993'.
-#
-# Addition, subtraction, comparison operators, min, max, and sorting
-# all work as expected for date objects:  int+date or date+int returns
-# the date `int' days from `date'; date+date raises an exception;
-# date-int returns the date `int' days before `date'; date2-date1 returns
-# an integer, the number of days from date1 to date2; int-date raises an
-# exception; date1 < date2 is true iff date1 occurs before date2 (&
-# similarly for other comparisons); min(date1,date2) is the earlier of
-# the two dates and max(date1,date2) the later; and date objects can be
-# used as dictionary keys.
-#
-# Date objects support one visible method, date.weekday().  This returns
-# the day of the week the date falls on, as a string.
-#
-# Date objects also have 4 read-only data attributes:
-#   .month  in 1..12
-#   .day    in 1..31
-#   .year   int or long int
-#   .ord    the ordinal of the date relative to an arbitrary staring point
-#
-# The Dates module also supplies function today(), which returns the
-# current date as a date object.
-#
-# Those entranced by calendar trivia will be disappointed, as no attempt
-# has been made to accommodate the Julian (etc) system.  On the other
-# hand, at least this package knows that 2000 is a leap year but 2100
-# isn't, and works fine for years with a hundred decimal digits <wink>.
-
-# Tim Peters   tim@ksr.com
-# not speaking for Kendall Square Research Corp
-
-# Adapted to Python 1.1 (where some hacks to overcome coercion are unnecessary)
-# by Guido van Rossum
-
-# Note that as of Python 2.3, a datetime module is included in the stardard
-# library.
-
-# vi:set tabsize=8:
-
-_MONTH_NAMES = [ 'January', 'February', 'March', 'April', 'May',
-                 'June', 'July', 'August', 'September', 'October',
-                 'November', 'December' ]
-
-_DAY_NAMES = [ 'Friday', 'Saturday', 'Sunday', 'Monday',
-               'Tuesday', 'Wednesday', 'Thursday' ]
-
-_DAYS_IN_MONTH = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]
-
-_DAYS_BEFORE_MONTH = []
-dbm = 0
-for dim in _DAYS_IN_MONTH:
-    _DAYS_BEFORE_MONTH.append(dbm)
-    dbm = dbm + dim
-del dbm, dim
-
-_INT_TYPES = type(1), type(1)
-
-def _is_leap(year):           # 1 if leap year, else 0
-    if year % 4 != 0: return 0
-    if year % 400 == 0: return 1
-    return year % 100 != 0
-
-def _days_in_year(year):      # number of days in year
-    return 365 + _is_leap(year)
-
-def _days_before_year(year):  # number of days before year
-    return year*365 + (year+3)//4 - (year+99)//100 + (year+399)//400
-
-def _days_in_month(month, year):      # number of days in month of year
-    if month == 2 and _is_leap(year): return 29
-    return _DAYS_IN_MONTH[month-1]
-
-def _days_before_month(month, year):  # number of days in year before month
-    return _DAYS_BEFORE_MONTH[month-1] + (month > 2 and _is_leap(year))
-
-def _date2num(date):          # compute ordinal of date.month,day,year
-    return _days_before_year(date.year) + \
-           _days_before_month(date.month, date.year) + \
-           date.day
-
-_DI400Y = _days_before_year(400)      # number of days in 400 years
-
-def _num2date(n):             # return date with ordinal n
-    if type(n) not in _INT_TYPES:
-        raise TypeError('argument must be integer: %r' % type(n))
-
-    ans = Date(1,1,1)   # arguments irrelevant; just getting a Date obj
-    del ans.ord, ans.month, ans.day, ans.year # un-initialize it
-    ans.ord = n
-
-    n400 = (n-1)//_DI400Y                # # of 400-year blocks preceding
-    year, n = 400 * n400, n - _DI400Y * n400
-    more = n // 365
-    dby = _days_before_year(more)
-    if dby >= n:
-        more = more - 1
-        dby = dby - _days_in_year(more)
-    year, n = year + more, int(n - dby)
-
-    try: year = int(year)               # chop to int, if it fits
-    except (ValueError, OverflowError): pass
-
-    month = min(n//29 + 1, 12)
-    dbm = _days_before_month(month, year)
-    if dbm >= n:
-        month = month - 1
-        dbm = dbm - _days_in_month(month, year)
-
-    ans.month, ans.day, ans.year = month, n-dbm, year
-    return ans
-
-def _num2day(n):      # return weekday name of day with ordinal n
-    return _DAY_NAMES[ int(n % 7) ]
-
-
-class Date:
-    def __init__(self, month, day, year):
-        if not 1 <= month <= 12:
-            raise ValueError('month must be in 1..12: %r' % (month,))
-        dim = _days_in_month(month, year)
-        if not 1 <= day <= dim:
-            raise ValueError('day must be in 1..%r: %r' % (dim, day))
-        self.month, self.day, self.year = month, day, year
-        self.ord = _date2num(self)
-
-    # don't allow setting existing attributes
-    def __setattr__(self, name, value):
-        if name in self.__dict__:
-            raise AttributeError('read-only attribute ' + name)
-        self.__dict__[name] = value
-
-    def __cmp__(self, other):
-        return cmp(self.ord, other.ord)
-
-    # define a hash function so dates can be used as dictionary keys
-    def __hash__(self):
-        return hash(self.ord)
-
-    # print as, e.g., Mon 16 Aug 1993
-    def __repr__(self):
-        return '%.3s %2d %.3s %r' % (
-              self.weekday(),
-              self.day,
-              _MONTH_NAMES[self.month-1],
-              self.year)
-
-    # Python 1.1 coerces neither int+date nor date+int
-    def __add__(self, n):
-        if type(n) not in _INT_TYPES:
-            raise TypeError('can\'t add %r to date' % type(n))
-        return _num2date(self.ord + n)
-    __radd__ = __add__ # handle int+date
-
-    # Python 1.1 coerces neither date-int nor date-date
-    def __sub__(self, other):
-        if type(other) in _INT_TYPES:           # date-int
-            return _num2date(self.ord - other)
-        else:
-            return self.ord - other.ord         # date-date
-
-    # complain about int-date
-    def __rsub__(self, other):
-        raise TypeError('Can\'t subtract date from integer')
-
-    def weekday(self):
-        return _num2day(self.ord)
-
-def today():
-    import time
-    local = time.localtime(time.time())
-    return Date(local[1], local[2], local[0])
-
-class DateTestError(Exception):
-    pass
-
-def test(firstyear, lastyear):
-    a = Date(9,30,1913)
-    b = Date(9,30,1914)
-    if repr(a) != 'Tue 30 Sep 1913':
-        raise DateTestError('__repr__ failure')
-    if (not a < b) or a == b or a > b or b != b:
-        raise DateTestError('__cmp__ failure')
-    if a+365 != b or 365+a != b:
-        raise DateTestError('__add__ failure')
-    if b-a != 365 or b-365 != a:
-        raise DateTestError('__sub__ failure')
-    try:
-        x = 1 - a
-        raise DateTestError('int-date should have failed')
-    except TypeError:
-        pass
-    try:
-        x = a + b
-        raise DateTestError('date+date should have failed')
-    except TypeError:
-        pass
-    if a.weekday() != 'Tuesday':
-        raise DateTestError('weekday() failure')
-    if max(a,b) is not b or min(a,b) is not a:
-        raise DateTestError('min/max failure')
-    d = {a-1:b, b:a+1}
-    if d[b-366] != b or d[a+(b-a)] != Date(10,1,1913):
-        raise DateTestError('dictionary failure')
-
-    # verify date<->number conversions for first and last days for
-    # all years in firstyear .. lastyear
-
-    lord = _days_before_year(firstyear)
-    y = firstyear
-    while y <= lastyear:
-        ford = lord + 1
-        lord = ford + _days_in_year(y) - 1
-        fd, ld = Date(1,1,y), Date(12,31,y)
-        if (fd.ord,ld.ord) != (ford,lord):
-            raise DateTestError('date->num failed', y)
-        fd, ld = _num2date(ford), _num2date(lord)
-        if (1,1,y,12,31,y) != \
-           (fd.month,fd.day,fd.year,ld.month,ld.day,ld.year):
-            raise DateTestError('num->date failed', y)
-        y = y + 1
-
-if __name__ == '__main__':
-    test(1850, 2150)
diff --git a/Demo/classes/Dbm.py b/Demo/classes/Dbm.py
deleted file mode 100755
index f931e93..0000000
--- a/Demo/classes/Dbm.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# A wrapper around the (optional) built-in class dbm, supporting keys
-# and values of almost any type instead of just string.
-# (Actually, this works only for keys and values that can be read back
-# correctly after being converted to a string.)
-
-
-class Dbm:
-
-    def __init__(self, filename, mode, perm):
-        import dbm.ndbm
-        self.db = dbm.ndbm.open(filename, mode, perm)
-
-    def __repr__(self):
-        s = ''
-        for key in self.keys():
-            t = repr(key) + ': ' + repr(self[key])
-            if s: t = ', ' + t
-            s = s + t
-        return '{' + s + '}'
-
-    def __len__(self):
-        return len(self.db)
-
-    def __getitem__(self, key):
-        return eval(self.db[repr(key)])
-
-    def __setitem__(self, key, value):
-        self.db[repr(key)] = repr(value)
-
-    def __delitem__(self, key):
-        del self.db[repr(key)]
-
-    def keys(self):
-        res = []
-        for key in self.db.keys():
-            res.append(eval(key))
-        return res
-
-    def has_key(self, key):
-        return repr(key) in self.db
-
-
-def test():
-    d = Dbm('@dbm', 'rw', 0o600)
-    print(d)
-    while 1:
-        try:
-            key = eval(input('key: '))
-            if key in d:
-                value = d[key]
-                print('currently:', value)
-            value = eval(input('value: '))
-            if value is None:
-                del d[key]
-            else:
-                d[key] = value
-        except KeyboardInterrupt:
-            print('')
-            print(d)
-        except EOFError:
-            print('[eof]')
-            break
-    print(d)
-
-
-test()
diff --git a/Demo/classes/README b/Demo/classes/README
deleted file mode 100644
index e5bc289..0000000
--- a/Demo/classes/README
+++ /dev/null
@@ -1,12 +0,0 @@
-Examples of classes that implement special operators (see reference manual):
-
-Complex.py	Complex numbers
-Dates.py	Date manipulation package by Tim Peters
-Dbm.py		Wrapper around built-in dbm, supporting	arbitrary values
-Range.py	Example of a generator: re-implement built-in range()
-Rev.py		Yield the reverse of a sequence
-Vec.py		A simple vector class
-bitvec.py	A bit-vector class by Jan-Hein B\"uhrman
-
-(For straightforward examples of basic class features, such as use of
-methods and inheritance, see the library code.)
diff --git a/Demo/classes/Range.py b/Demo/classes/Range.py
deleted file mode 100755
index a0cef74..0000000
--- a/Demo/classes/Range.py
+++ /dev/null
@@ -1,93 +0,0 @@
-"""Example of a generator: re-implement the built-in range function
-without actually constructing the list of values.
-
-OldStyleRange is coded in the way required to work in a 'for' loop before
-iterators were introduced into the language; using __getitem__ and __len__ .
-
-"""
-def handleargs(arglist):
-    """Take list of arguments and extract/create proper start, stop, and step
-    values and return in a tuple"""
-    try:
-        if len(arglist) == 1:
-            return 0, int(arglist[0]), 1
-        elif len(arglist) == 2:
-            return int(arglist[0]), int(arglist[1]), 1
-        elif len(arglist) == 3:
-            if arglist[2] == 0:
-                raise ValueError("step argument must not be zero")
-            return tuple(int(x) for x in arglist)
-        else:
-            raise TypeError("range() accepts 1-3 arguments, given", len(arglist))
-    except TypeError:
-        raise TypeError("range() arguments must be numbers or strings "
-        "representing numbers")
-
-def genrange(*a):
-    """Function to implement 'range' as a generator"""
-    start, stop, step = handleargs(a)
-    value = start
-    while value < stop:
-        yield value
-        value += step
-
-class oldrange:
-    """Class implementing a range object.
-    To the user the instances feel like immutable sequences
-    (and you can't concatenate or slice them)
-
-    Done using the old way (pre-iterators; __len__ and __getitem__) to have an
-    object be used by a 'for' loop.
-
-    """
-
-    def __init__(self, *a):
-        """ Initialize start, stop, and step values along with calculating the
-        nubmer of values (what __len__ will return) in the range"""
-        self.start, self.stop, self.step = handleargs(a)
-        self.len = max(0, (self.stop - self.start) // self.step)
-
-    def __repr__(self):
-        """implement repr(x) which is also used by print"""
-        return 'range(%r, %r, %r)' % (self.start, self.stop, self.step)
-
-    def __len__(self):
-        """implement len(x)"""
-        return self.len
-
-    def __getitem__(self, i):
-        """implement x[i]"""
-        if 0 <= i <= self.len:
-            return self.start + self.step * i
-        else:
-            raise IndexError('range[i] index out of range')
-
-
-def test():
-    import time, builtins
-    #Just a quick sanity check
-    correct_result = builtins.range(5, 100, 3)
-    oldrange_result = list(oldrange(5, 100, 3))
-    genrange_result = list(genrange(5, 100, 3))
-    if genrange_result != correct_result or oldrange_result != correct_result:
-        raise Exception("error in implementation:\ncorrect   = %s"
-                         "\nold-style = %s\ngenerator = %s" %
-                         (correct_result, oldrange_result, genrange_result))
-    print("Timings for range(1000):")
-    t1 = time.time()
-    for i in oldrange(1000):
-        pass
-    t2 = time.time()
-    for i in genrange(1000):
-        pass
-    t3 = time.time()
-    for i in builtins.range(1000):
-        pass
-    t4 = time.time()
-    print(t2-t1, 'sec (old-style class)')
-    print(t3-t2, 'sec (generator)')
-    print(t4-t3, 'sec (built-in)')
-
-
-if __name__ == '__main__':
-    test()
diff --git a/Demo/classes/Rev.py b/Demo/classes/Rev.py
deleted file mode 100755
index 7fd78e0..0000000
--- a/Demo/classes/Rev.py
+++ /dev/null
@@ -1,95 +0,0 @@
-'''
-A class which presents the reverse of a sequence without duplicating it.
-From: "Steven D. Majewski" <sdm7g@elvis.med.virginia.edu>
-
-It works on mutable or inmutable sequences.
-
->>> chars = list(Rev('Hello World!'))
->>> print ''.join(chars)
-!dlroW olleH
-
-The .forw is so you can use anonymous sequences in __init__, and still
-keep a reference the forward sequence. )
-If you give it a non-anonymous mutable sequence, the reverse sequence
-will track the updated values. ( but not reassignment! - another
-good reason to use anonymous values in creating the sequence to avoid
-confusion. Maybe it should be change to copy input sequence to break
-the connection completely ? )
-
->>> nnn = range(3)
->>> rnn = Rev(nnn)
->>> for n in rnn: print n
-...
-2
-1
-0
->>> for n in range(4, 6): nnn.append(n)   # update nnn
-...
->>> for n in rnn: print n     # prints reversed updated values
-...
-5
-4
-2
-1
-0
->>> nnn = nnn[1:-1]
->>> nnn
-[1, 2, 4]
->>> for n in rnn: print n     # prints reversed values of old nnn
-...
-5
-4
-2
-1
-0
-
-#
->>> WH = Rev('Hello World!')
->>> print WH.forw, WH.back
-Hello World! !dlroW olleH
->>> nnn = Rev(range(1, 10))
->>> print nnn.forw
-[1, 2, 3, 4, 5, 6, 7, 8, 9]
->>> print nnn.back
-[9, 8, 7, 6, 5, 4, 3, 2, 1]
-
->>> rrr = Rev(nnn)
->>> rrr
-<1, 2, 3, 4, 5, 6, 7, 8, 9>
-
-'''
-
-class Rev:
-    def __init__(self, seq):
-        self.forw = seq
-        self.back = self
-
-    def __len__(self):
-        return len(self.forw)
-
-    def __getitem__(self, j):
-        return self.forw[-(j + 1)]
-
-    def __repr__(self):
-        seq = self.forw
-        if isinstance(seq, list):
-            wrap = '[]'
-            sep = ', '
-        elif isinstance(seq, tuple):
-            wrap = '()'
-            sep = ', '
-        elif isinstance(seq, str):
-            wrap = ''
-            sep = ''
-        else:
-            wrap = '<>'
-            sep = ', '
-        outstrs = [str(item) for item in self.back]
-        return wrap[:1] + sep.join(outstrs) + wrap[-1:]
-
-def _test():
-    import doctest, Rev
-    return doctest.testmod(Rev)
-
-if __name__ == "__main__":
-    _test()
diff --git a/Demo/classes/Vec.py b/Demo/classes/Vec.py
deleted file mode 100755
index 787af69..0000000
--- a/Demo/classes/Vec.py
+++ /dev/null
@@ -1,68 +0,0 @@
-class Vec:
-    """ A simple vector class
-
-    Instances of the Vec class  can be constructed from numbers
-
-    >>> a = Vec(1, 2, 3)
-    >>> b = Vec(3, 2, 1)
-
-    added
-    >>> a + b
-    Vec(4, 4, 4)
-
-    subtracted
-    >>> a - b
-    Vec(-2, 0, 2)
-
-    and multiplied by a scalar on the left
-    >>> 3.0 * a
-    Vec(3.0, 6.0, 9.0)
-
-    or on the right
-    >>> a * 3.0
-    Vec(3.0, 6.0, 9.0)
-    """
-    def __init__(self, *v):
-        self.v = list(v)
-
-    @classmethod
-    def fromlist(cls, v):
-        if not isinstance(v, list):
-            raise TypeError
-        inst = cls()
-        inst.v = v
-        return inst
-
-    def __repr__(self):
-        args = ', '.join(repr(x) for x in self.v)
-        return 'Vec({})'.format(args)
-
-    def __len__(self):
-        return len(self.v)
-
-    def __getitem__(self, i):
-        return self.v[i]
-
-    def __add__(self, other):
-        # Element-wise addition
-        v = [x + y for x, y in zip(self.v, other.v)]
-        return Vec.fromlist(v)
-
-    def __sub__(self, other):
-        # Element-wise subtraction
-        v = [x - y for x, y in zip(self.v, other.v)]
-        return Vec.fromlist(v)
-
-    def __mul__(self, scalar):
-        # Multiply by scalar
-        v = [x * scalar for x in self.v]
-        return Vec.fromlist(v)
-
-    __rmul__ = __mul__
-
-
-def test():
-    import doctest
-    doctest.testmod()
-
-test()
diff --git a/Demo/classes/bitvec.py b/Demo/classes/bitvec.py
deleted file mode 100755
index 62b26cc..0000000
--- a/Demo/classes/bitvec.py
+++ /dev/null
@@ -1,322 +0,0 @@
-#
-# this is a rather strict implementation of a bit vector class
-# it is accessed the same way as an array of python-ints, except
-# the value must be 0 or 1
-#
-
-import sys; rprt = sys.stderr.write #for debugging
-
-class error(Exception):
-    pass
-
-
-def _check_value(value):
-    if type(value) != type(0) or not 0 <= value < 2:
-        raise error('bitvec() items must have int value 0 or 1')
-
-
-import math
-
-def _compute_len(param):
-    mant, l = math.frexp(float(param))
-    bitmask = 1 << l
-    if bitmask <= param:
-        raise ValueError('(param, l) = %r' % ((param, l),))
-    while l:
-        bitmask = bitmask >> 1
-        if param & bitmask:
-            break
-        l = l - 1
-    return l
-
-
-def _check_key(len, key):
-    if type(key) != type(0):
-        raise TypeError('sequence subscript not int')
-    if key < 0:
-        key = key + len
-    if not 0 <= key < len:
-        raise IndexError('list index out of range')
-    return key
-
-def _check_slice(len, i, j):
-    #the type is ok, Python already checked that
-    i, j = max(i, 0), min(len, j)
-    if i > j:
-        i = j
-    return i, j
-
-
-class BitVec:
-
-    def __init__(self, *params):
-        self._data = 0
-        self._len = 0
-        if not len(params):
-            pass
-        elif len(params) == 1:
-            param, = params
-            if type(param) == type([]):
-                value = 0
-                bit_mask = 1
-                for item in param:
-                    # strict check
-                    #_check_value(item)
-                    if item:
-                        value = value | bit_mask
-                    bit_mask = bit_mask << 1
-                self._data = value
-                self._len = len(param)
-            elif type(param) == type(0):
-                if param < 0:
-                    raise error('bitvec() can\'t handle negative longs')
-                self._data = param
-                self._len = _compute_len(param)
-            else:
-                raise error('bitvec() requires array or long parameter')
-        elif len(params) == 2:
-            param, length = params
-            if type(param) == type(0):
-                if param < 0:
-                    raise error('can\'t handle negative longs')
-                self._data = param
-                if type(length) != type(0):
-                    raise error('bitvec()\'s 2nd parameter must be int')
-                computed_length = _compute_len(param)
-                if computed_length > length:
-                    print('warning: bitvec() value is longer than the length indicates, truncating value')
-                    self._data = self._data & \
-                              ((1 << length) - 1)
-                self._len = length
-            else:
-                raise error('bitvec() requires array or long parameter')
-        else:
-            raise error('bitvec() requires 0 -- 2 parameter(s)')
-
-
-    def append(self, item):
-        #_check_value(item)
-        #self[self._len:self._len] = [item]
-        self[self._len:self._len] = \
-                  BitVec(int(not not item), 1)
-
-
-    def count(self, value):
-        #_check_value(value)
-        if value:
-            data = self._data
-        else:
-            data = (~self)._data
-        count = 0
-        while data:
-            data, count = data >> 1, count + (data & 1 != 0)
-        return count
-
-
-    def index(self, value):
-        #_check_value(value):
-        if value:
-            data = self._data
-        else:
-            data = (~self)._data
-        index = 0
-        if not data:
-            raise ValueError('list.index(x): x not in list')
-        while not (data & 1):
-            data, index = data >> 1, index + 1
-        return index
-
-
-    def insert(self, index, item):
-        #_check_value(item)
-        #self[index:index] = [item]
-        self[index:index] = BitVec(int(not not item), 1)
-
-
-    def remove(self, value):
-        del self[self.index(value)]
-
-
-    def reverse(self):
-        #ouch, this one is expensive!
-        #for i in self._len>>1: self[i], self[l-i] = self[l-i], self[i]
-        data, result = self._data, 0
-        for i in range(self._len):
-            if not data:
-                result = result << (self._len - i)
-                break
-            result, data = (result << 1) | (data & 1), data >> 1
-        self._data = result
-
-
-    def sort(self):
-        c = self.count(1)
-        self._data = ((1 << c) - 1) << (self._len - c)
-
-
-    def copy(self):
-        return BitVec(self._data, self._len)
-
-
-    def seq(self):
-        result = []
-        for i in self:
-            result.append(i)
-        return result
-
-
-    def __repr__(self):
-        ##rprt('<bitvec class instance object>.' + '__repr__()\n')
-        return 'bitvec(%r, %r)' % (self._data, self._len)
-
-    def __cmp__(self, other, *rest):
-        #rprt('%r.__cmp__%r\n' % (self, (other,) + rest))
-        if type(other) != type(self):
-            other = bitvec(other, *rest)
-        #expensive solution... recursive binary, with slicing
-        length = self._len
-        if length == 0 or other._len == 0:
-            return cmp(length, other._len)
-        if length != other._len:
-            min_length = min(length, other._len)
-            return cmp(self[:min_length], other[:min_length]) or \
-                      cmp(self[min_length:], other[min_length:])
-        #the lengths are the same now...
-        if self._data == other._data:
-            return 0
-        if length == 1:
-            return cmp(self[0], other[0])
-        else:
-            length = length >> 1
-            return cmp(self[:length], other[:length]) or \
-                      cmp(self[length:], other[length:])
-
-
-    def __len__(self):
-        #rprt('%r.__len__()\n' % (self,))
-        return self._len
-
-    def __getitem__(self, key):
-        #rprt('%r.__getitem__(%r)\n' % (self, key))
-        key = _check_key(self._len, key)
-        return self._data & (1 << key) != 0
-
-    def __setitem__(self, key, value):
-        #rprt('%r.__setitem__(%r, %r)\n' % (self, key, value))
-        key = _check_key(self._len, key)
-        #_check_value(value)
-        if value:
-            self._data = self._data | (1 << key)
-        else:
-            self._data = self._data & ~(1 << key)
-
-    def __delitem__(self, key):
-        #rprt('%r.__delitem__(%r)\n' % (self, key))
-        key = _check_key(self._len, key)
-        #el cheapo solution...
-        self._data = self[:key]._data | self[key+1:]._data >> key
-        self._len = self._len - 1
-
-    def __getslice__(self, i, j):
-        #rprt('%r.__getslice__(%r, %r)\n' % (self, i, j))
-        i, j = _check_slice(self._len, i, j)
-        if i >= j:
-            return BitVec(0, 0)
-        if i:
-            ndata = self._data >> i
-        else:
-            ndata = self._data
-        nlength = j - i
-        if j != self._len:
-            #we'll have to invent faster variants here
-            #e.g. mod_2exp
-            ndata = ndata & ((1 << nlength) - 1)
-        return BitVec(ndata, nlength)
-
-    def __setslice__(self, i, j, sequence, *rest):
-        #rprt('%s.__setslice__%r\n' % (self, (i, j, sequence) + rest))
-        i, j = _check_slice(self._len, i, j)
-        if type(sequence) != type(self):
-            sequence = bitvec(sequence, *rest)
-        #sequence is now of our own type
-        ls_part = self[:i]
-        ms_part = self[j:]
-        self._data = ls_part._data | \
-                  ((sequence._data | \
-                  (ms_part._data << sequence._len)) << ls_part._len)
-        self._len = self._len - j + i + sequence._len
-
-    def __delslice__(self, i, j):
-        #rprt('%r.__delslice__(%r, %r)\n' % (self, i, j))
-        i, j = _check_slice(self._len, i, j)
-        if i == 0 and j == self._len:
-            self._data, self._len = 0, 0
-        elif i < j:
-            self._data = self[:i]._data | (self[j:]._data >> i)
-            self._len = self._len - j + i
-
-    def __add__(self, other):
-        #rprt('%r.__add__(%r)\n' % (self, other))
-        retval = self.copy()
-        retval[self._len:self._len] = other
-        return retval
-
-    def __mul__(self, multiplier):
-        #rprt('%r.__mul__(%r)\n' % (self, multiplier))
-        if type(multiplier) != type(0):
-            raise TypeError('sequence subscript not int')
-        if multiplier <= 0:
-            return BitVec(0, 0)
-        elif multiplier == 1:
-            return self.copy()
-        #handle special cases all 0 or all 1...
-        if self._data == 0:
-            return BitVec(0, self._len * multiplier)
-        elif (~self)._data == 0:
-            return ~BitVec(0, self._len * multiplier)
-        #otherwise el cheapo again...
-        retval = BitVec(0, 0)
-        while multiplier:
-            retval, multiplier = retval + self, multiplier - 1
-        return retval
-
-    def __and__(self, otherseq, *rest):
-        #rprt('%r.__and__%r\n' % (self, (otherseq,) + rest))
-        if type(otherseq) != type(self):
-            otherseq = bitvec(otherseq, *rest)
-        #sequence is now of our own type
-        return BitVec(self._data & otherseq._data, \
-                  min(self._len, otherseq._len))
-
-
-    def __xor__(self, otherseq, *rest):
-        #rprt('%r.__xor__%r\n' % (self, (otherseq,) + rest))
-        if type(otherseq) != type(self):
-            otherseq = bitvec(otherseq, *rest)
-        #sequence is now of our own type
-        return BitVec(self._data ^ otherseq._data, \
-                  max(self._len, otherseq._len))
-
-
-    def __or__(self, otherseq, *rest):
-        #rprt('%r.__or__%r\n' % (self, (otherseq,) + rest))
-        if type(otherseq) != type(self):
-            otherseq = bitvec(otherseq, *rest)
-        #sequence is now of our own type
-        return BitVec(self._data | otherseq._data, \
-                  max(self._len, otherseq._len))
-
-
-    def __invert__(self):
-        #rprt('%r.__invert__()\n' % (self,))
-        return BitVec(~self._data & ((1 << self._len) - 1), \
-                  self._len)
-
-    def __int__(self):
-        return int(self._data)
-
-    def __float__(self):
-        return float(self._data)
-
-
-bitvec = BitVec
diff --git a/Demo/comparisons/README b/Demo/comparisons/README
deleted file mode 100644
index 111667c..0000000
--- a/Demo/comparisons/README
+++ /dev/null
@@ -1,60 +0,0 @@
-Subject: Re: What language would you use?
-From: Tom Christiansen <tchrist@mox.perl.com>
-Date: 6 Nov 1994 15:14:51 GMT
-Newsgroups: comp.lang.python,comp.lang.tcl,comp.lang.scheme,comp.lang.misc,comp.lang.perl
-Message-Id: <39irtb$3t4@csnews.cs.Colorado.EDU>
-References: <39b7ha$j9v@zeno.nscf.org> <39hhjp$lgn@csnews.cs.Colorado.EDU> <39hvsu$dus@mathserv.mps.ohio-state.edu>
-
-[...]
-If you're really into benchmarks, I'd love it if someone were to code up
-the following problems in tcl, python, and scheme (and whatever else you'd
-like).  Separate versions (one optimized for speed, one for beauty :-) are
-ok.  Post your code so we can time it on our own systems.
-
-0)  Factorial Test  (numerics and function calls)
-
-        (we did this already)
-
-1)  Regular Expressions Test
-
-    Read a file of (extended per egrep) regular expressions (one per line), 
-    and apply those to all files whose names are listed on the command line.
-    Basically, an 'egrep -f' simulator.  Test it with 20 "vt100" patterns
-    against a five /etc/termcap files.  Tests using more elaborate patters
-    would also be interesting.  Your code should not break if given hundreds
-    of regular expressions or binary files to scan.  
-
-2)  Sorting Test
-
-    Sort an input file that consists of lines like this
-
-        var1=23 other=14 ditto=23 fred=2
-
-    such that each output line is sorted WRT to the number.  Order
-    of output lines does not change.  Resolve collisions using the
-    variable name.   e.g.
-
-        fred=2 other=14 ditto=23 var1=23 
-
-    Lines may be up to several kilobytes in length and contain
-    zillions of variables.
-
-3)  System Test
-
-    Given a list of directories, report any bogus symbolic links contained
-    anywhere in those subtrees.  A bogus symbolic link is one that cannot
-    be resolved because it points to a nonexistent or otherwise
-    unresolvable file.  Do *not* use an external find executable.
-    Directories may be very very deep.  Print a warning immediately if the
-    system you're running on doesn't support symbolic links.
-
-
-I'll post perl solutions if people post the others.
-
-
---tom
--- 
-Tom Christiansen      Perl Consultant, Gamer, Hiker      tchrist@mox.perl.com
-
- "But Billy! A *small* allowance prepares you for a lifetime of small
- salaries and for your Social Security payments."    --Family Circus
diff --git a/Demo/comparisons/patterns b/Demo/comparisons/patterns
deleted file mode 100755
index f4da846..0000000
--- a/Demo/comparisons/patterns
+++ /dev/null
@@ -1,4 +0,0 @@
-^def 
-^class 
-^import 
-^from 
diff --git a/Demo/comparisons/regextest.py b/Demo/comparisons/regextest.py
deleted file mode 100755
index d2c534d..0000000
--- a/Demo/comparisons/regextest.py
+++ /dev/null
@@ -1,47 +0,0 @@
-#! /usr/bin/env python
-
-# 1)  Regular Expressions Test
-#
-#     Read a file of (extended per egrep) regular expressions (one per line),
-#     and apply those to all files whose names are listed on the command line.
-#     Basically, an 'egrep -f' simulator.  Test it with 20 "vt100" patterns
-#     against a five /etc/termcap files.  Tests using more elaborate patters
-#     would also be interesting.  Your code should not break if given hundreds
-#     of regular expressions or binary files to scan.
-
-# This implementation:
-# - combines all patterns into a single one using ( ... | ... | ... )
-# - reads patterns from stdin, scans files given as command line arguments
-# - produces output in the format <file>:<lineno>:<line>
-# - is only about 2.5 times as slow as egrep (though I couldn't run
-#   Tom's test -- this system, a vanilla SGI, only has /etc/terminfo)
-
-import string
-import sys
-import re
-
-def main():
-    pats = list(map(chomp, sys.stdin.readlines()))
-    bigpat = '(' + '|'.join(pats) + ')'
-    prog = re.compile(bigpat)
-
-    for file in sys.argv[1:]:
-        try:
-            fp = open(file, 'r')
-        except IOError as msg:
-            print("%s: %s" % (file, msg))
-            continue
-        lineno = 0
-        while 1:
-            line = fp.readline()
-            if not line:
-                break
-            lineno = lineno + 1
-            if prog.search(line):
-                print("%s:%s:%s" % (file, lineno, line), end=' ')
-
-def chomp(s):
-    return s.rstrip('\n')
-
-if __name__ == '__main__':
-    main()
diff --git a/Demo/comparisons/sortingtest.py b/Demo/comparisons/sortingtest.py
deleted file mode 100755
index f9ed854..0000000
--- a/Demo/comparisons/sortingtest.py
+++ /dev/null
@@ -1,45 +0,0 @@
-#! /usr/bin/env python
-
-# 2)  Sorting Test
-#
-#     Sort an input file that consists of lines like this
-#
-#         var1=23 other=14 ditto=23 fred=2
-#
-#     such that each output line is sorted WRT to the number.  Order
-#     of output lines does not change.  Resolve collisions using the
-#     variable name.   e.g.
-#
-#         fred=2 other=14 ditto=23 var1=23
-#
-#     Lines may be up to several kilobytes in length and contain
-#     zillions of variables.
-
-# This implementation:
-# - Reads stdin, writes stdout
-# - Uses any amount of whitespace to separate fields
-# - Allows signed numbers
-# - Treats illegally formatted fields as field=0
-# - Outputs the sorted fields with exactly one space between them
-# - Handles blank input lines correctly
-
-import re
-import sys
-
-def main():
-    prog = re.compile('^(.*)=([-+]?[0-9]+)')
-    def makekey(item, prog=prog):
-        match = prog.match(item)
-        if match:
-            var, num = match.groups()
-            return int(num), var
-        else:
-            # Bad input -- pretend it's a var with value 0
-            return 0, item
-    for line in sys.stdin:
-        items = sorted(makekey(item) for item in line.split())
-        for num, var in items:
-            print("%s=%s" % (var, num), end=' ')
-        print()
-
-main()
diff --git a/Demo/comparisons/systemtest.py b/Demo/comparisons/systemtest.py
deleted file mode 100755
index e3d840e..0000000
--- a/Demo/comparisons/systemtest.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#! /usr/bin/env python
-
-# 3)  System Test
-#
-#     Given a list of directories, report any bogus symbolic links contained
-#     anywhere in those subtrees.  A bogus symbolic link is one that cannot
-#     be resolved because it points to a nonexistent or otherwise
-#     unresolvable file.  Do *not* use an external find executable.
-#     Directories may be very very deep.  Print a warning immediately if the
-#     system you're running on doesn't support symbolic links.
-
-# This implementation:
-# - takes one optional argument, using the current directory as default
-# - uses chdir to increase performance
-# - sorts the names per directory
-# - prints output lines of the form "path1 -> path2" as it goes
-# - prints error messages about directories it can't list or chdir into
-
-import os
-import sys
-from stat import *
-
-def main():
-    try:
-        # Note: can't test for presence of lstat -- it's always there
-        dummy = os.readlink
-    except AttributeError:
-        print("This system doesn't have symbolic links")
-        sys.exit(0)
-    if sys.argv[1:]:
-        prefix = sys.argv[1]
-    else:
-        prefix = ''
-    if prefix:
-        os.chdir(prefix)
-        if prefix[-1:] != '/': prefix = prefix + '/'
-        reportboguslinks(prefix)
-    else:
-        reportboguslinks('')
-
-def reportboguslinks(prefix):
-    try:
-        names = os.listdir('.')
-    except os.error as msg:
-        print("%s%s: can't list: %s" % (prefix, '.', msg))
-        return
-    names.sort()
-    for name in names:
-        if name == os.curdir or name == os.pardir:
-            continue
-        try:
-            mode = os.lstat(name)[ST_MODE]
-        except os.error:
-            print("%s%s: can't stat: %s" % (prefix, name, msg))
-            continue
-        if S_ISLNK(mode):
-            try:
-                os.stat(name)
-            except os.error:
-                print("%s%s -> %s" % \
-                      (prefix, name, os.readlink(name)))
-        elif S_ISDIR(mode):
-            try:
-                os.chdir(name)
-            except os.error as msg:
-                print("%s%s: can't chdir: %s" % \
-                      (prefix, name, msg))
-                continue
-            try:
-                reportboguslinks(prefix + name + '/')
-            finally:
-                os.chdir('..')
-
-main()
diff --git a/Demo/curses/README b/Demo/curses/README
deleted file mode 100644
index 2d1c4b1..0000000
--- a/Demo/curses/README
+++ /dev/null
@@ -1,25 +0,0 @@
-This is a collection of demos and tests for the curses module. 
-
-ncurses demos
-=============
-
-These demos are converted from the C versions in the ncurses
-distribution, and were contributed by Thomas Gellekum <tg@FreeBSD.org>
-I didn't strive for a `pythonic' style, but bluntly copied the
-originals. I won't attempt to `beautify' the program anytime soon, but
-I wouldn't mind someone else making an effort in that direction, of
-course.
-
-ncurses.py      -- currently only a panels demo
-rain.py         -- raindrops keep falling on my desktop
-tclock.py       -- ASCII clock, by Howard Jones
-xmas.py         -- I'm dreaming of an ASCII christmas
-
-Please submit bugfixes and new contributions to the Python bug tracker.
-
-
-Other demos
-===========
-
-life.py         -- Simple game of Life
-repeat.py       -- Repeatedly execute a shell command (like watch(1))
diff --git a/Demo/curses/life.py b/Demo/curses/life.py
deleted file mode 100755
index ddff8fa..0000000
--- a/Demo/curses/life.py
+++ /dev/null
@@ -1,216 +0,0 @@
-#!/usr/bin/env python
-# life.py -- A curses-based version of Conway's Game of Life.
-# Contributed by AMK
-#
-# An empty board will be displayed, and the following commands are available:
-#  E : Erase the board
-#  R : Fill the board randomly
-#  S : Step for a single generation
-#  C : Update continuously until a key is struck
-#  Q : Quit
-#  Cursor keys :  Move the cursor around the board
-#  Space or Enter : Toggle the contents of the cursor's position
-#
-# TODO :
-#   Support the mouse
-#   Use colour if available
-#   Make board updates faster
-#
-
-import random, string, traceback
-import curses
-
-class LifeBoard:
-    """Encapsulates a Life board
-
-    Attributes:
-    X,Y : horizontal and vertical size of the board
-    state : dictionary mapping (x,y) to 0 or 1
-
-    Methods:
-    display(update_board) -- If update_board is true, compute the
-                             next generation.  Then display the state
-                             of the board and refresh the screen.
-    erase() -- clear the entire board
-    makeRandom() -- fill the board randomly
-    set(y,x) -- set the given cell to Live; doesn't refresh the screen
-    toggle(y,x) -- change the given cell from live to dead, or vice
-                   versa, and refresh the screen display
-
-    """
-    def __init__(self, scr, char=ord('*')):
-        """Create a new LifeBoard instance.
-
-        scr -- curses screen object to use for display
-        char -- character used to render live cells (default: '*')
-        """
-        self.state = {}
-        self.scr = scr
-        Y, X = self.scr.getmaxyx()
-        self.X, self.Y = X-2, Y-2-1
-        self.char = char
-        self.scr.clear()
-
-        # Draw a border around the board
-        border_line = '+'+(self.X*'-')+'+'
-        self.scr.addstr(0, 0, border_line)
-        self.scr.addstr(self.Y+1,0, border_line)
-        for y in range(0, self.Y):
-            self.scr.addstr(1+y, 0, '|')
-            self.scr.addstr(1+y, self.X+1, '|')
-        self.scr.refresh()
-
-    def set(self, y, x):
-        """Set a cell to the live state"""
-        if x<0 or self.X<=x or y<0 or self.Y<=y:
-            raise ValueError("Coordinates out of range %i,%i"% (y,x))
-        self.state[x,y] = 1
-
-    def toggle(self, y, x):
-        """Toggle a cell's state between live and dead"""
-        if x<0 or self.X<=x or y<0 or self.Y<=y:
-            raise ValueError("Coordinates out of range %i,%i"% (y,x))
-        if (x,y) in self.state:
-            del self.state[x,y]
-            self.scr.addch(y+1, x+1, ' ')
-        else:
-            self.state[x,y] = 1
-            self.scr.addch(y+1, x+1, self.char)
-        self.scr.refresh()
-
-    def erase(self):
-        """Clear the entire board and update the board display"""
-        self.state = {}
-        self.display(update_board=False)
-
-    def display(self, update_board=True):
-        """Display the whole board, optionally computing one generation"""
-        M,N = self.X, self.Y
-        if not update_board:
-            for i in range(0, M):
-                for j in range(0, N):
-                    if (i,j) in self.state:
-                        self.scr.addch(j+1, i+1, self.char)
-                    else:
-                        self.scr.addch(j+1, i+1, ' ')
-            self.scr.refresh()
-            return
-
-        d = {}
-        self.boring = 1
-        for i in range(0, M):
-            L = range( max(0, i-1), min(M, i+2) )
-            for j in range(0, N):
-                s = 0
-                live = (i,j) in self.state
-                for k in range( max(0, j-1), min(N, j+2) ):
-                    for l in L:
-                        if (l,k) in self.state:
-                            s += 1
-                s -= live
-                if s == 3:
-                    # Birth
-                    d[i,j] = 1
-                    self.scr.addch(j+1, i+1, self.char)
-                    if not live: self.boring = 0
-                elif s == 2 and live: d[i,j] = 1       # Survival
-                elif live:
-                    # Death
-                    self.scr.addch(j+1, i+1, ' ')
-                    self.boring = 0
-        self.state = d
-        self.scr.refresh()
-
-    def makeRandom(self):
-        "Fill the board with a random pattern"
-        self.state = {}
-        for i in range(0, self.X):
-            for j in range(0, self.Y):
-                if random.random() > 0.5:
-                    self.set(j,i)
-
-
-def erase_menu(stdscr, menu_y):
-    "Clear the space where the menu resides"
-    stdscr.move(menu_y, 0)
-    stdscr.clrtoeol()
-    stdscr.move(menu_y+1, 0)
-    stdscr.clrtoeol()
-
-def display_menu(stdscr, menu_y):
-    "Display the menu of possible keystroke commands"
-    erase_menu(stdscr, menu_y)
-    stdscr.addstr(menu_y, 4,
-                  'Use the cursor keys to move, and space or Enter to toggle a cell.')
-    stdscr.addstr(menu_y+1, 4,
-                  'E)rase the board, R)andom fill, S)tep once or C)ontinuously, Q)uit')
-
-def keyloop(stdscr):
-    # Clear the screen and display the menu of keys
-    stdscr.clear()
-    stdscr_y, stdscr_x = stdscr.getmaxyx()
-    menu_y = (stdscr_y-3)-1
-    display_menu(stdscr, menu_y)
-
-    # Allocate a subwindow for the Life board and create the board object
-    subwin = stdscr.subwin(stdscr_y-3, stdscr_x, 0, 0)
-    board = LifeBoard(subwin, char=ord('*'))
-    board.display(update_board=False)
-
-    # xpos, ypos are the cursor's position
-    xpos, ypos = board.X//2, board.Y//2
-
-    # Main loop:
-    while (1):
-        stdscr.move(1+ypos, 1+xpos)     # Move the cursor
-        c = stdscr.getch()                # Get a keystroke
-        if 0<c<256:
-            c = chr(c)
-            if c in ' \n':
-                board.toggle(ypos, xpos)
-            elif c in 'Cc':
-                erase_menu(stdscr, menu_y)
-                stdscr.addstr(menu_y, 6, ' Hit any key to stop continuously '
-                              'updating the screen.')
-                stdscr.refresh()
-                # Activate nodelay mode; getch() will return -1
-                # if no keystroke is available, instead of waiting.
-                stdscr.nodelay(1)
-                while (1):
-                    c = stdscr.getch()
-                    if c != -1:
-                        break
-                    stdscr.addstr(0,0, '/')
-                    stdscr.refresh()
-                    board.display()
-                    stdscr.addstr(0,0, '+')
-                    stdscr.refresh()
-
-                stdscr.nodelay(0)       # Disable nodelay mode
-                display_menu(stdscr, menu_y)
-
-            elif c in 'Ee':
-                board.erase()
-            elif c in 'Qq':
-                break
-            elif c in 'Rr':
-                board.makeRandom()
-                board.display(update_board=False)
-            elif c in 'Ss':
-                board.display()
-            else: pass                  # Ignore incorrect keys
-        elif c == curses.KEY_UP and ypos>0:            ypos -= 1
-        elif c == curses.KEY_DOWN and ypos<board.Y-1:  ypos += 1
-        elif c == curses.KEY_LEFT and xpos>0:          xpos -= 1
-        elif c == curses.KEY_RIGHT and xpos<board.X-1: xpos += 1
-        else:
-            # Ignore incorrect keys
-            pass
-
-
-def main(stdscr):
-    keyloop(stdscr)                    # Enter the main loop
-
-
-if __name__ == '__main__':
-    curses.wrapper(main)
diff --git a/Demo/curses/ncurses.py b/Demo/curses/ncurses.py
deleted file mode 100644
index 0bdc1a9..0000000
--- a/Demo/curses/ncurses.py
+++ /dev/null
@@ -1,273 +0,0 @@
-#!/usr/bin/env python
-#
-# $Id$
-#
-# (n)curses exerciser in Python, an interactive test for the curses
-# module. Currently, only the panel demos are ported.
-
-import curses
-from curses import panel
-
-def wGetchar(win = None):
-    if win is None: win = stdscr
-    return win.getch()
-
-def Getchar():
-    wGetchar()
-
-#
-# Panels tester
-#
-def wait_a_while():
-    if nap_msec == 1:
-        Getchar()
-    else:
-        curses.napms(nap_msec)
-
-def saywhat(text):
-    stdscr.move(curses.LINES - 1, 0)
-    stdscr.clrtoeol()
-    stdscr.addstr(text)
-
-def mkpanel(color, rows, cols, tly, tlx):
-    win = curses.newwin(rows, cols, tly, tlx)
-    pan = panel.new_panel(win)
-    if curses.has_colors():
-        if color == curses.COLOR_BLUE:
-            fg = curses.COLOR_WHITE
-        else:
-            fg = curses.COLOR_BLACK
-        bg = color
-        curses.init_pair(color, fg, bg)
-        win.bkgdset(ord(' '), curses.color_pair(color))
-    else:
-        win.bkgdset(ord(' '), curses.A_BOLD)
-
-    return pan
-
-def pflush():
-    panel.update_panels()
-    curses.doupdate()
-
-def fill_panel(pan):
-    win = pan.window()
-    num = pan.userptr()[1]
-
-    win.move(1, 1)
-    win.addstr("-pan%c-" % num)
-    win.clrtoeol()
-    win.box()
-
-    maxy, maxx = win.getmaxyx()
-    for y in range(2, maxy - 1):
-        for x in range(1, maxx - 1):
-            win.move(y, x)
-            win.addch(num)
-
-def demo_panels(win):
-    global stdscr, nap_msec, mod
-    stdscr = win
-    nap_msec = 1
-    mod = ["test", "TEST", "(**)", "*()*", "<-->", "LAST"]
-
-    stdscr.refresh()
-
-    for y in range(0, curses.LINES - 1):
-        for x in range(0, curses.COLS):
-            stdscr.addstr("%d" % ((y + x) % 10))
-    for y in range(0, 1):
-        p1 = mkpanel(curses.COLOR_RED,
-                     curses.LINES // 2 - 2,
-                     curses.COLS // 8 + 1,
-                     0,
-                     0)
-        p1.set_userptr("p1")
-
-        p2 = mkpanel(curses.COLOR_GREEN,
-                     curses.LINES // 2 + 1,
-                     curses.COLS // 7,
-                     curses.LINES // 4,
-                     curses.COLS // 10)
-        p2.set_userptr("p2")
-
-        p3 = mkpanel(curses.COLOR_YELLOW,
-                     curses.LINES // 4,
-                     curses.COLS // 10,
-                     curses.LINES // 2,
-                     curses.COLS // 9)
-        p3.set_userptr("p3")
-
-        p4 = mkpanel(curses.COLOR_BLUE,
-                     curses.LINES // 2 - 2,
-                     curses.COLS // 8,
-                     curses.LINES // 2 - 2,
-                     curses.COLS // 3)
-        p4.set_userptr("p4")
-
-        p5 = mkpanel(curses.COLOR_MAGENTA,
-                     curses.LINES // 2 - 2,
-                     curses.COLS // 8,
-                     curses.LINES // 2,
-                     curses.COLS // 2 - 2)
-        p5.set_userptr("p5")
-
-        fill_panel(p1)
-        fill_panel(p2)
-        fill_panel(p3)
-        fill_panel(p4)
-        fill_panel(p5)
-        p4.hide()
-        p5.hide()
-        pflush()
-        saywhat("press any key to continue")
-        wait_a_while()
-
-        saywhat("h3 s1 s2 s4 s5;press any key to continue")
-        p1.move(0, 0)
-        p3.hide()
-        p1.show()
-        p2.show()
-        p4.show()
-        p5.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("s1; press any key to continue")
-        p1.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("s2; press any key to continue")
-        p2.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("m2; press any key to continue")
-        p2.move(curses.LINES // 3 + 1, curses.COLS // 8)
-        pflush()
-        wait_a_while()
-
-        saywhat("s3; press any key to continue")
-        p3.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("m3; press any key to continue")
-        p3.move(curses.LINES // 4 + 1, curses.COLS // 15)
-        pflush()
-        wait_a_while()
-
-        saywhat("b3; press any key to continue")
-        p3.bottom()
-        pflush()
-        wait_a_while()
-
-        saywhat("s4; press any key to continue")
-        p4.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("s5; press any key to continue")
-        p5.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("t3; press any key to continue")
-        p3.top()
-        pflush()
-        wait_a_while()
-
-        saywhat("t1; press any key to continue")
-        p1.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("t2; press any key to continue")
-        p2.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("t3; press any key to continue")
-        p3.show()
-        pflush()
-        wait_a_while()
-
-        saywhat("t4; press any key to continue")
-        p4.show()
-        pflush()
-        wait_a_while()
-
-        for itmp in range(0, 6):
-            w4 = p4.window()
-            w5 = p5.window()
-
-            saywhat("m4; press any key to continue")
-            w4.move(curses.LINES // 8, 1)
-            w4.addstr(mod[itmp])
-            p4.move(curses.LINES // 6, itmp * curses.COLS // 8)
-            w5.move(curses.LINES // 6, 1)
-            w5.addstr(mod[itmp])
-            pflush()
-            wait_a_while()
-
-            saywhat("m5; press any key to continue")
-            w4.move(curses.LINES // 6, 1)
-            w4.addstr(mod[itmp])
-            p5.move(curses.LINES // 3 - 1, itmp * 10 + 6)
-            w5.move(curses.LINES // 8, 1)
-            w5.addstr(mod[itmp])
-            pflush()
-            wait_a_while()
-
-        saywhat("m4; press any key to continue")
-        p4.move(curses.LINES // 6, (itmp + 1) * curses.COLS // 8)
-        pflush()
-        wait_a_while()
-
-        saywhat("t5; press any key to continue")
-        p5.top()
-        pflush()
-        wait_a_while()
-
-        saywhat("t2; press any key to continue")
-        p2.top()
-        pflush()
-        wait_a_while()
-
-        saywhat("t1; press any key to continue")
-        p1.top()
-        pflush()
-        wait_a_while()
-
-        saywhat("d2; press any key to continue")
-        del p2
-        pflush()
-        wait_a_while()
-
-        saywhat("h3; press any key to continue")
-        p3.hide()
-        pflush()
-        wait_a_while()
-
-        saywhat("d1; press any key to continue")
-        del p1
-        pflush()
-        wait_a_while()
-
-        saywhat("d4; press any key to continue")
-        del p4
-        pflush()
-        wait_a_while()
-
-        saywhat("d5; press any key to continue")
-        del p5
-        pflush()
-        wait_a_while()
-        if nap_msec == 1:
-            break
-        nap_msec = 100
-
-#
-# one fine day there'll be the menu at this place
-#
-curses.wrapper(demo_panels)
diff --git a/Demo/curses/rain.py b/Demo/curses/rain.py
deleted file mode 100644
index 9d46e6e..0000000
--- a/Demo/curses/rain.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/env python
-#
-# $Id$
-#
-# somebody should probably check the randrange()s...
-
-import curses
-from random import randrange
-
-def next_j(j):
-    if j == 0:
-        j = 4
-    else:
-        j -= 1
-
-    if curses.has_colors():
-        z = randrange(0, 3)
-        color = curses.color_pair(z)
-        if z:
-            color = color | curses.A_BOLD
-        stdscr.attrset(color)
-
-    return j
-
-def main(win):
-    # we know that the first argument from curses.wrapper() is stdscr.
-    # Initialize it globally for convenience.
-    global stdscr
-    stdscr = win
-
-    if curses.has_colors():
-        bg = curses.COLOR_BLACK
-        curses.init_pair(1, curses.COLOR_BLUE, bg)
-        curses.init_pair(2, curses.COLOR_CYAN, bg)
-
-    curses.nl()
-    curses.noecho()
-    # XXX curs_set() always returns ERR
-    # curses.curs_set(0)
-    stdscr.timeout(0)
-
-    c = curses.COLS - 4
-    r = curses.LINES - 4
-    xpos = [0] * c
-    ypos = [0] * r
-    for j in range(4, -1, -1):
-        xpos[j] = randrange(0, c) + 2
-        ypos[j] = randrange(0, r) + 2
-
-    j = 0
-    while True:
-        x = randrange(0, c) + 2
-        y = randrange(0, r) + 2
-
-        stdscr.addch(y, x, ord('.'))
-
-        stdscr.addch(ypos[j], xpos[j], ord('o'))
-
-        j = next_j(j)
-        stdscr.addch(ypos[j], xpos[j], ord('O'))
-
-        j = next_j(j)
-        stdscr.addch( ypos[j] - 1, xpos[j],     ord('-'))
-        stdscr.addstr(ypos[j],     xpos[j] - 1, "|.|")
-        stdscr.addch( ypos[j] + 1, xpos[j],     ord('-'))
-
-        j = next_j(j)
-        stdscr.addch( ypos[j] - 2, xpos[j],     ord('-'))
-        stdscr.addstr(ypos[j] - 1, xpos[j] - 1, "/ \\")
-        stdscr.addstr(ypos[j],     xpos[j] - 2, "| O |")
-        stdscr.addstr(ypos[j] + 1, xpos[j] - 1, "\\ /")
-        stdscr.addch( ypos[j] + 2, xpos[j],     ord('-'))
-
-        j = next_j(j)
-        stdscr.addch( ypos[j] - 2, xpos[j],     ord(' '))
-        stdscr.addstr(ypos[j] - 1, xpos[j] - 1, "   ")
-        stdscr.addstr(ypos[j],     xpos[j] - 2, "     ")
-        stdscr.addstr(ypos[j] + 1, xpos[j] - 1, "   ")
-        stdscr.addch( ypos[j] + 2, xpos[j],     ord(' '))
-
-        xpos[j] = x
-        ypos[j] = y
-
-        ch = stdscr.getch()
-        if ch == ord('q') or ch == ord('Q'):
-            return
-        elif ch == ord('s'):
-            stdscr.nodelay(0)
-        elif ch == ord(' '):
-            stdscr.nodelay(1)
-
-        curses.napms(50)
-
-curses.wrapper(main)
diff --git a/Demo/curses/repeat.py b/Demo/curses/repeat.py
deleted file mode 100755
index 93372c5..0000000
--- a/Demo/curses/repeat.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#! /usr/bin/env python
-
-"""repeat [-i SECONDS] <shell-command>
-
-This simple program repeatedly (at 1-second intervals) executes the
-shell command given on the command line and displays the output (or as
-much of it as fits on the screen).  It uses curses to paint each new
-output on top of the old output, so that if nothing changes, the
-screen doesn't change.  This is handy to watch for changes in e.g. a
-directory or process listing.
-
-The -i option lets you override the sleep time between executions.
-
-To end, hit Control-C.
-"""
-
-# Author: Guido van Rossum
-
-# Disclaimer: there's a Linux program named 'watch' that does the same
-# thing.  Honestly, I didn't know of its existence when I wrote this!
-
-# To do: add features until it has the same functionality as watch(1);
-# then compare code size and development time.
-
-import os
-import sys
-import time
-import curses
-import getopt
-
-def main():
-    interval = 1.0
-    try:
-        opts, args = getopt.getopt(sys.argv[1:], "hi:")
-    except getopt.error as err:
-        print(err, file=sys.stderr)
-        sys.exit(2)
-    if not args:
-        print(__doc__)
-        sys.exit(0)
-    for opt, arg in opts:
-        if opt == "-i":
-            interval = float(arg)
-        if opt == "-h":
-            print(__doc__)
-            sys.exit(0)
-    cmd = " ".join(args)
-    cmd_really = cmd + " 2>&1"
-    p = os.popen(cmd_really, "r")
-    text = p.read()
-    sts = p.close()
-    text = addsts(interval, cmd, text, sts)
-    w = curses.initscr()
-    try:
-        while True:
-            w.erase()
-            try:
-                w.addstr(text)
-            except curses.error:
-                pass
-            w.refresh()
-            time.sleep(interval)
-            p = os.popen(cmd_really, "r")
-            text = p.read()
-            sts = p.close()
-            text = addsts(interval, cmd, text, sts)
-    finally:
-        curses.endwin()
-
-def addsts(interval, cmd, text, sts):
-    now = time.strftime("%H:%M:%S")
-    text = "%s, every %g sec: %s\n%s" % (now, interval, cmd, text)
-    if sts:
-        msg = "Exit status: %d; signal: %d" % (sts>>8, sts&0xFF)
-        if text and not text.endswith("\n"):
-            msg = "\n" + msg
-        text += msg
-    return text
-
-main()
diff --git a/Demo/curses/tclock.py b/Demo/curses/tclock.py
deleted file mode 100644
index 8058d9a..0000000
--- a/Demo/curses/tclock.py
+++ /dev/null
@@ -1,147 +0,0 @@
-#!/usr/bin/env python
-#
-# $Id$
-#
-# From tclock.c, Copyright Howard Jones <ha.jones@ic.ac.uk>, September 1994.
-
-from math import *
-import curses, time
-
-ASPECT = 2.2
-
-def sign(_x):
-    if _x < 0: return -1
-    return 1
-
-def A2XY(angle, radius):
-    return (int(round(ASPECT * radius * sin(angle))),
-            int(round(radius * cos(angle))))
-
-def plot(x, y, col):
-    stdscr.addch(y, x, col)
-
-# draw a diagonal line using Bresenham's algorithm
-def dline(pair, from_x, from_y, x2, y2, ch):
-    if curses.has_colors():
-        stdscr.attrset(curses.color_pair(pair))
-
-    dx = x2 - from_x
-    dy = y2 - from_y
-
-    ax = abs(dx * 2)
-    ay = abs(dy * 2)
-
-    sx = sign(dx)
-    sy = sign(dy)
-
-    x = from_x
-    y = from_y
-
-    if ax > ay:
-        d = ay - ax // 2
-
-        while True:
-            plot(x, y, ch)
-            if x == x2:
-                return
-
-            if d >= 0:
-                y += sy
-                d -= ax
-            x += sx
-            d += ay
-    else:
-        d = ax - ay // 2
-
-        while True:
-            plot(x, y, ch)
-            if y == y2:
-                return
-
-            if d >= 0:
-                x += sx
-                d -= ay
-            y += sy
-            d += ax
-
-def main(win):
-    global stdscr
-    stdscr = win
-
-    lastbeep = -1
-    my_bg = curses.COLOR_BLACK
-
-    stdscr.nodelay(1)
-    stdscr.timeout(0)
-#    curses.curs_set(0)
-    if curses.has_colors():
-        curses.init_pair(1, curses.COLOR_RED, my_bg)
-        curses.init_pair(2, curses.COLOR_MAGENTA, my_bg)
-        curses.init_pair(3, curses.COLOR_GREEN, my_bg)
-
-    cx = (curses.COLS - 1) // 2
-    cy = curses.LINES // 2
-    ch = min( cy-1, int(cx // ASPECT) - 1)
-    mradius = (3 * ch) // 4
-    hradius = ch // 2
-    sradius = 5 * ch // 6
-
-    for i in range(0, 12):
-        sangle = (i + 1) * 2.0 * pi / 12.0
-        sdx, sdy = A2XY(sangle, sradius)
-
-        stdscr.addstr(cy - sdy, cx + sdx, "%d" % (i + 1))
-
-    stdscr.addstr(0, 0,
-                  "ASCII Clock by Howard Jones <ha.jones@ic.ac.uk>, 1994")
-
-    sradius = max(sradius-4, 8)
-
-    while True:
-        curses.napms(1000)
-
-        tim = time.time()
-        t = time.localtime(tim)
-
-        hours = t[3] + t[4] / 60.0
-        if hours > 12.0:
-            hours -= 12.0
-
-        mangle = t[4] * 2 * pi / 60.0
-        mdx, mdy = A2XY(mangle, mradius)
-
-        hangle = hours * 2 * pi / 12.0
-        hdx, hdy = A2XY(hangle, hradius)
-
-        sangle = t[5] * 2 * pi / 60.0
-        sdx, sdy = A2XY(sangle, sradius)
-
-        dline(3, cx, cy, cx + mdx, cy - mdy, ord('#'))
-
-        stdscr.attrset(curses.A_REVERSE)
-        dline(2, cx, cy, cx + hdx, cy - hdy, ord('.'))
-        stdscr.attroff(curses.A_REVERSE)
-
-        if curses.has_colors():
-            stdscr.attrset(curses.color_pair(1))
-
-        plot(cx + sdx, cy - sdy, ord('O'))
-
-        if curses.has_colors():
-            stdscr.attrset(curses.color_pair(0))
-
-        stdscr.addstr(curses.LINES - 2, 0, time.ctime(tim))
-        stdscr.refresh()
-        if (t[5] % 5) == 0 and t[5] != lastbeep:
-            lastbeep = t[5]
-            curses.beep()
-
-        ch = stdscr.getch()
-        if ch == ord('q'):
-            return 0
-
-        plot(cx + sdx, cy - sdy, ord(' '))
-        dline(0, cx, cy, cx + hdx, cy - hdy, ord(' '))
-        dline(0, cx, cy, cx + mdx, cy - mdy, ord(' '))
-
-curses.wrapper(main)
diff --git a/Demo/curses/xmas.py b/Demo/curses/xmas.py
deleted file mode 100644
index 349b3a8..0000000
--- a/Demo/curses/xmas.py
+++ /dev/null
@@ -1,906 +0,0 @@
-# asciixmas
-# December 1989             Larry Bartz           Indianapolis, IN
-#
-# $Id$
-#
-# I'm dreaming of an ascii character-based monochrome Christmas,
-# Just like the ones I used to know!
-# Via a full duplex communications channel,
-# At 9600 bits per second,
-# Even though it's kinda slow.
-#
-# I'm dreaming of an ascii character-based monochrome Christmas,
-# With ev'ry C program I write!
-# May your screen be merry and bright!
-# And may all your Christmases be amber or green,
-# (for reduced eyestrain and improved visibility)!
-#
-#
-# Notes on the Python version:
-# I used a couple of `try...except curses.error' to get around some functions
-# returning ERR. The errors come from using wrapping functions to fill
-# windows to the last character cell. The C version doesn't have this problem,
-# it simply ignores any return values.
-#
-
-import curses
-import sys
-
-FROMWHO = "Thomas Gellekum <tg@FreeBSD.org>"
-
-def set_color(win, color):
-    if curses.has_colors():
-        n = color + 1
-        curses.init_pair(n, color, my_bg)
-        win.attroff(curses.A_COLOR)
-        win.attron(curses.color_pair(n))
-
-def unset_color(win):
-    if curses.has_colors():
-        win.attrset(curses.color_pair(0))
-
-def look_out(msecs):
-    curses.napms(msecs)
-    if stdscr.getch() != -1:
-        curses.beep()
-        sys.exit(0)
-
-def boxit():
-    for y in range(0, 20):
-        stdscr.addch(y, 7, ord('|'))
-
-    for x in range(8, 80):
-        stdscr.addch(19, x, ord('_'))
-
-    for x in range(0, 80):
-        stdscr.addch(22, x, ord('_'))
-
-    return
-
-def seas():
-    stdscr.addch(4, 1, ord('S'))
-    stdscr.addch(6, 1, ord('E'))
-    stdscr.addch(8, 1, ord('A'))
-    stdscr.addch(10, 1, ord('S'))
-    stdscr.addch(12, 1, ord('O'))
-    stdscr.addch(14, 1, ord('N'))
-    stdscr.addch(16, 1, ord("'"))
-    stdscr.addch(18, 1, ord('S'))
-
-    return
-
-def greet():
-    stdscr.addch(3, 5, ord('G'))
-    stdscr.addch(5, 5, ord('R'))
-    stdscr.addch(7, 5, ord('E'))
-    stdscr.addch(9, 5, ord('E'))
-    stdscr.addch(11, 5, ord('T'))
-    stdscr.addch(13, 5, ord('I'))
-    stdscr.addch(15, 5, ord('N'))
-    stdscr.addch(17, 5, ord('G'))
-    stdscr.addch(19, 5, ord('S'))
-
-    return
-
-def fromwho():
-    stdscr.addstr(21, 13, FROMWHO)
-    return
-
-def tree():
-    set_color(treescrn, curses.COLOR_GREEN)
-    treescrn.addch(1, 11, ord('/'))
-    treescrn.addch(2, 11, ord('/'))
-    treescrn.addch(3, 10, ord('/'))
-    treescrn.addch(4, 9, ord('/'))
-    treescrn.addch(5, 9, ord('/'))
-    treescrn.addch(6, 8, ord('/'))
-    treescrn.addch(7, 7, ord('/'))
-    treescrn.addch(8, 6, ord('/'))
-    treescrn.addch(9, 6, ord('/'))
-    treescrn.addch(10, 5, ord('/'))
-    treescrn.addch(11, 3, ord('/'))
-    treescrn.addch(12, 2, ord('/'))
-
-    treescrn.addch(1, 13, ord('\\'))
-    treescrn.addch(2, 13, ord('\\'))
-    treescrn.addch(3, 14, ord('\\'))
-    treescrn.addch(4, 15, ord('\\'))
-    treescrn.addch(5, 15, ord('\\'))
-    treescrn.addch(6, 16, ord('\\'))
-    treescrn.addch(7, 17, ord('\\'))
-    treescrn.addch(8, 18, ord('\\'))
-    treescrn.addch(9, 18, ord('\\'))
-    treescrn.addch(10, 19, ord('\\'))
-    treescrn.addch(11, 21, ord('\\'))
-    treescrn.addch(12, 22, ord('\\'))
-
-    treescrn.addch(4, 10, ord('_'))
-    treescrn.addch(4, 14, ord('_'))
-    treescrn.addch(8, 7, ord('_'))
-    treescrn.addch(8, 17, ord('_'))
-
-    treescrn.addstr(13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\")
-
-    treescrn.addstr(14, 11, "| |")
-    treescrn.addstr(15, 11, "|_|")
-
-    unset_color(treescrn)
-    treescrn.refresh()
-    w_del_msg.refresh()
-
-    return
-
-def balls():
-    treescrn.overlay(treescrn2)
-
-    set_color(treescrn2, curses.COLOR_BLUE)
-    treescrn2.addch(3, 9, ord('@'))
-    treescrn2.addch(3, 15, ord('@'))
-    treescrn2.addch(4, 8, ord('@'))
-    treescrn2.addch(4, 16, ord('@'))
-    treescrn2.addch(5, 7, ord('@'))
-    treescrn2.addch(5, 17, ord('@'))
-    treescrn2.addch(7, 6, ord('@'))
-    treescrn2.addch(7, 18, ord('@'))
-    treescrn2.addch(8, 5, ord('@'))
-    treescrn2.addch(8, 19, ord('@'))
-    treescrn2.addch(10, 4, ord('@'))
-    treescrn2.addch(10, 20, ord('@'))
-    treescrn2.addch(11, 2, ord('@'))
-    treescrn2.addch(11, 22, ord('@'))
-    treescrn2.addch(12, 1, ord('@'))
-    treescrn2.addch(12, 23, ord('@'))
-
-    unset_color(treescrn2)
-    treescrn2.refresh()
-    w_del_msg.refresh()
-    return
-
-def star():
-    treescrn2.attrset(curses.A_BOLD | curses.A_BLINK)
-    set_color(treescrn2, curses.COLOR_YELLOW)
-
-    treescrn2.addch(0, 12, ord('*'))
-    treescrn2.standend()
-
-    unset_color(treescrn2)
-    treescrn2.refresh()
-    w_del_msg.refresh()
-    return
-
-def strng1():
-    treescrn2.attrset(curses.A_BOLD | curses.A_BLINK)
-    set_color(treescrn2, curses.COLOR_WHITE)
-
-    treescrn2.addch(3, 13, ord('\''))
-    treescrn2.addch(3, 12, ord(':'))
-    treescrn2.addch(3, 11, ord('.'))
-
-    treescrn2.attroff(curses.A_BOLD | curses.A_BLINK)
-    unset_color(treescrn2)
-
-    treescrn2.refresh()
-    w_del_msg.refresh()
-    return
-
-def strng2():
-    treescrn2.attrset(curses.A_BOLD | curses.A_BLINK)
-    set_color(treescrn2, curses.COLOR_WHITE)
-
-    treescrn2.addch(5, 14, ord('\''))
-    treescrn2.addch(5, 13, ord(':'))
-    treescrn2.addch(5, 12, ord('.'))
-    treescrn2.addch(5, 11, ord(','))
-    treescrn2.addch(6, 10, ord('\''))
-    treescrn2.addch(6, 9, ord(':'))
-
-    treescrn2.attroff(curses.A_BOLD | curses.A_BLINK)
-    unset_color(treescrn2)
-
-    treescrn2.refresh()
-    w_del_msg.refresh()
-    return
-
-def strng3():
-    treescrn2.attrset(curses.A_BOLD | curses.A_BLINK)
-    set_color(treescrn2, curses.COLOR_WHITE)
-
-    treescrn2.addch(7, 16, ord('\''))
-    treescrn2.addch(7, 15, ord(':'))
-    treescrn2.addch(7, 14, ord('.'))
-    treescrn2.addch(7, 13, ord(','))
-    treescrn2.addch(8, 12, ord('\''))
-    treescrn2.addch(8, 11, ord(':'))
-    treescrn2.addch(8, 10, ord('.'))
-    treescrn2.addch(8, 9, ord(','))
-
-    treescrn2.attroff(curses.A_BOLD | curses.A_BLINK)
-    unset_color(treescrn2)
-
-    treescrn2.refresh()
-    w_del_msg.refresh()
-    return
-
-def strng4():
-    treescrn2.attrset(curses.A_BOLD | curses.A_BLINK)
-    set_color(treescrn2, curses.COLOR_WHITE)
-
-    treescrn2.addch(9, 17, ord('\''))
-    treescrn2.addch(9, 16, ord(':'))
-    treescrn2.addch(9, 15, ord('.'))
-    treescrn2.addch(9, 14, ord(','))
-    treescrn2.addch(10, 13, ord('\''))
-    treescrn2.addch(10, 12, ord(':'))
-    treescrn2.addch(10, 11, ord('.'))
-    treescrn2.addch(10, 10, ord(','))
-    treescrn2.addch(11, 9, ord('\''))
-    treescrn2.addch(11, 8, ord(':'))
-    treescrn2.addch(11, 7, ord('.'))
-    treescrn2.addch(11, 6, ord(','))
-    treescrn2.addch(12, 5, ord('\''))
-
-    treescrn2.attroff(curses.A_BOLD | curses.A_BLINK)
-    unset_color(treescrn2)
-
-    treescrn2.refresh()
-    w_del_msg.refresh()
-    return
-
-def strng5():
-    treescrn2.attrset(curses.A_BOLD | curses.A_BLINK)
-    set_color(treescrn2, curses.COLOR_WHITE)
-
-    treescrn2.addch(11, 19, ord('\''))
-    treescrn2.addch(11, 18, ord(':'))
-    treescrn2.addch(11, 17, ord('.'))
-    treescrn2.addch(11, 16, ord(','))
-    treescrn2.addch(12, 15, ord('\''))
-    treescrn2.addch(12, 14, ord(':'))
-    treescrn2.addch(12, 13, ord('.'))
-    treescrn2.addch(12, 12, ord(','))
-
-    treescrn2.attroff(curses.A_BOLD | curses.A_BLINK)
-    unset_color(treescrn2)
-
-    # save a fully lit tree
-    treescrn2.overlay(treescrn)
-
-    treescrn2.refresh()
-    w_del_msg.refresh()
-    return
-
-def blinkit():
-    treescrn8.touchwin()
-
-    for cycle in range(5):
-        if cycle == 0:
-            treescrn3.overlay(treescrn8)
-            treescrn8.refresh()
-            w_del_msg.refresh()
-            break
-        elif cycle == 1:
-            treescrn4.overlay(treescrn8)
-            treescrn8.refresh()
-            w_del_msg.refresh()
-            break
-        elif cycle == 2:
-            treescrn5.overlay(treescrn8)
-            treescrn8.refresh()
-            w_del_msg.refresh()
-            break
-        elif cycle == 3:
-            treescrn6.overlay(treescrn8)
-            treescrn8.refresh()
-            w_del_msg.refresh()
-            break
-        elif cycle == 4:
-            treescrn7.overlay(treescrn8)
-            treescrn8.refresh()
-            w_del_msg.refresh()
-            break
-
-        treescrn8.touchwin()
-
-    # ALL ON
-    treescrn.overlay(treescrn8)
-    treescrn8.refresh()
-    w_del_msg.refresh()
-
-    return
-
-def deer_step(win, y, x):
-    win.mvwin(y, x)
-    win.refresh()
-    w_del_msg.refresh()
-    look_out(5)
-
-def reindeer():
-    y_pos = 0
-
-    for x_pos in range(70, 62, -1):
-        if x_pos < 66: y_pos = 1
-        for looper in range(0, 4):
-            dotdeer0.addch(y_pos, x_pos, ord('.'))
-            dotdeer0.refresh()
-            w_del_msg.refresh()
-            dotdeer0.erase()
-            dotdeer0.refresh()
-            w_del_msg.refresh()
-            look_out(50)
-
-    y_pos = 2
-
-    for x_pos in range(x_pos - 1, 50, -1):
-        for looper in range(0, 4):
-            if x_pos < 56:
-                y_pos = 3
-
-                try:
-                    stardeer0.addch(y_pos, x_pos, ord('*'))
-                except curses.error:
-                    pass
-                stardeer0.refresh()
-                w_del_msg.refresh()
-                stardeer0.erase()
-                stardeer0.refresh()
-                w_del_msg.refresh()
-            else:
-                dotdeer0.addch(y_pos, x_pos, ord('*'))
-                dotdeer0.refresh()
-                w_del_msg.refresh()
-                dotdeer0.erase()
-                dotdeer0.refresh()
-                w_del_msg.refresh()
-
-    x_pos = 58
-
-    for y_pos in range(2, 5):
-        lildeer0.touchwin()
-        lildeer0.refresh()
-        w_del_msg.refresh()
-
-        for looper in range(0, 4):
-            deer_step(lildeer3, y_pos, x_pos)
-            deer_step(lildeer2, y_pos, x_pos)
-            deer_step(lildeer1, y_pos, x_pos)
-            deer_step(lildeer2, y_pos, x_pos)
-            deer_step(lildeer3, y_pos, x_pos)
-
-            lildeer0.touchwin()
-            lildeer0.refresh()
-            w_del_msg.refresh()
-
-            x_pos -= 2
-
-    x_pos = 35
-
-    for y_pos in range(5, 10):
-
-        middeer0.touchwin()
-        middeer0.refresh()
-        w_del_msg.refresh()
-
-        for looper in range(2):
-            deer_step(middeer3, y_pos, x_pos)
-            deer_step(middeer2, y_pos, x_pos)
-            deer_step(middeer1, y_pos, x_pos)
-            deer_step(middeer2, y_pos, x_pos)
-            deer_step(middeer3, y_pos, x_pos)
-
-            middeer0.touchwin()
-            middeer0.refresh()
-            w_del_msg.refresh()
-
-            x_pos -= 3
-
-    look_out(300)
-
-    y_pos = 1
-
-    for x_pos in range(8, 16):
-        deer_step(bigdeer4, y_pos, x_pos)
-        deer_step(bigdeer3, y_pos, x_pos)
-        deer_step(bigdeer2, y_pos, x_pos)
-        deer_step(bigdeer1, y_pos, x_pos)
-        deer_step(bigdeer2, y_pos, x_pos)
-        deer_step(bigdeer3, y_pos, x_pos)
-        deer_step(bigdeer4, y_pos, x_pos)
-        deer_step(bigdeer0, y_pos, x_pos)
-
-    x_pos -= 1
-
-    for looper in range(0, 6):
-        deer_step(lookdeer4, y_pos, x_pos)
-        deer_step(lookdeer3, y_pos, x_pos)
-        deer_step(lookdeer2, y_pos, x_pos)
-        deer_step(lookdeer1, y_pos, x_pos)
-        deer_step(lookdeer2, y_pos, x_pos)
-        deer_step(lookdeer3, y_pos, x_pos)
-        deer_step(lookdeer4, y_pos, x_pos)
-
-    deer_step(lookdeer0, y_pos, x_pos)
-
-    for y_pos in range(y_pos, 10):
-        for looper in range(0, 2):
-            deer_step(bigdeer4, y_pos, x_pos)
-            deer_step(bigdeer3, y_pos, x_pos)
-            deer_step(bigdeer2, y_pos, x_pos)
-            deer_step(bigdeer1, y_pos, x_pos)
-            deer_step(bigdeer2, y_pos, x_pos)
-            deer_step(bigdeer3, y_pos, x_pos)
-            deer_step(bigdeer4, y_pos, x_pos)
-        deer_step(bigdeer0, y_pos, x_pos)
-
-    y_pos -= 1
-
-    deer_step(lookdeer3, y_pos, x_pos)
-    return
-
-def main(win):
-    global stdscr
-    stdscr = win
-
-    global my_bg, y_pos, x_pos
-    global treescrn, treescrn2, treescrn3, treescrn4
-    global treescrn5, treescrn6, treescrn7, treescrn8
-    global dotdeer0, stardeer0
-    global lildeer0, lildeer1, lildeer2, lildeer3
-    global middeer0, middeer1, middeer2, middeer3
-    global bigdeer0, bigdeer1, bigdeer2, bigdeer3, bigdeer4
-    global lookdeer0, lookdeer1, lookdeer2, lookdeer3, lookdeer4
-    global w_holiday, w_del_msg
-
-    my_bg = curses.COLOR_BLACK
-    # curses.curs_set(0)
-
-    treescrn = curses.newwin(16, 27, 3, 53)
-    treescrn2 = curses.newwin(16, 27, 3, 53)
-    treescrn3 = curses.newwin(16, 27, 3, 53)
-    treescrn4 = curses.newwin(16, 27, 3, 53)
-    treescrn5 = curses.newwin(16, 27, 3, 53)
-    treescrn6 = curses.newwin(16, 27, 3, 53)
-    treescrn7 = curses.newwin(16, 27, 3, 53)
-    treescrn8 = curses.newwin(16, 27, 3, 53)
-
-    dotdeer0 = curses.newwin(3, 71, 0, 8)
-
-    stardeer0 = curses.newwin(4, 56, 0, 8)
-
-    lildeer0 = curses.newwin(7, 53, 0, 8)
-    lildeer1 = curses.newwin(2, 4, 0, 0)
-    lildeer2 = curses.newwin(2, 4, 0, 0)
-    lildeer3 = curses.newwin(2, 4, 0, 0)
-
-    middeer0 = curses.newwin(15, 42, 0, 8)
-    middeer1 = curses.newwin(3, 7, 0, 0)
-    middeer2 = curses.newwin(3, 7, 0, 0)
-    middeer3 = curses.newwin(3, 7, 0, 0)
-
-    bigdeer0 = curses.newwin(10, 23, 0, 0)
-    bigdeer1 = curses.newwin(10, 23, 0, 0)
-    bigdeer2 = curses.newwin(10, 23, 0, 0)
-    bigdeer3 = curses.newwin(10, 23, 0, 0)
-    bigdeer4 = curses.newwin(10, 23, 0, 0)
-
-    lookdeer0 = curses.newwin(10, 25, 0, 0)
-    lookdeer1 = curses.newwin(10, 25, 0, 0)
-    lookdeer2 = curses.newwin(10, 25, 0, 0)
-    lookdeer3 = curses.newwin(10, 25, 0, 0)
-    lookdeer4 = curses.newwin(10, 25, 0, 0)
-
-    w_holiday = curses.newwin(1, 27, 3, 27)
-
-    w_del_msg = curses.newwin(1, 20, 23, 60)
-
-    try:
-        w_del_msg.addstr(0, 0, "Hit any key to quit")
-    except curses.error:
-        pass
-
-    try:
-        w_holiday.addstr(0, 0, "H A P P Y  H O L I D A Y S")
-    except curses.error:
-        pass
-
-    # set up the windows for our various reindeer
-    lildeer1.addch(0, 0, ord('V'))
-    lildeer1.addch(1, 0, ord('@'))
-    lildeer1.addch(1, 1, ord('<'))
-    lildeer1.addch(1, 2, ord('>'))
-    try:
-        lildeer1.addch(1, 3, ord('~'))
-    except curses.error:
-        pass
-
-    lildeer2.addch(0, 0, ord('V'))
-    lildeer2.addch(1, 0, ord('@'))
-    lildeer2.addch(1, 1, ord('|'))
-    lildeer2.addch(1, 2, ord('|'))
-    try:
-        lildeer2.addch(1, 3, ord('~'))
-    except curses.error:
-        pass
-
-    lildeer3.addch(0, 0, ord('V'))
-    lildeer3.addch(1, 0, ord('@'))
-    lildeer3.addch(1, 1, ord('>'))
-    lildeer3.addch(1, 2, ord('<'))
-    try:
-        lildeer2.addch(1, 3, ord('~'))  # XXX
-    except curses.error:
-        pass
-
-    middeer1.addch(0, 2, ord('y'))
-    middeer1.addch(0, 3, ord('y'))
-    middeer1.addch(1, 2, ord('0'))
-    middeer1.addch(1, 3, ord('('))
-    middeer1.addch(1, 4, ord('='))
-    middeer1.addch(1, 5, ord(')'))
-    middeer1.addch(1, 6, ord('~'))
-    middeer1.addch(2, 3, ord('\\'))
-    middeer1.addch(2, 5, ord('/'))
-
-    middeer2.addch(0, 2, ord('y'))
-    middeer2.addch(0, 3, ord('y'))
-    middeer2.addch(1, 2, ord('0'))
-    middeer2.addch(1, 3, ord('('))
-    middeer2.addch(1, 4, ord('='))
-    middeer2.addch(1, 5, ord(')'))
-    middeer2.addch(1, 6, ord('~'))
-    middeer2.addch(2, 3, ord('|'))
-    middeer2.addch(2, 5, ord('|'))
-
-    middeer3.addch(0, 2, ord('y'))
-    middeer3.addch(0, 3, ord('y'))
-    middeer3.addch(1, 2, ord('0'))
-    middeer3.addch(1, 3, ord('('))
-    middeer3.addch(1, 4, ord('='))
-    middeer3.addch(1, 5, ord(')'))
-    middeer3.addch(1, 6, ord('~'))
-    middeer3.addch(2, 3, ord('/'))
-    middeer3.addch(2, 5, ord('\\'))
-
-    bigdeer1.addch(0, 17, ord('\\'))
-    bigdeer1.addch(0, 18, ord('/'))
-    bigdeer1.addch(0, 19, ord('\\'))
-    bigdeer1.addch(0, 20, ord('/'))
-    bigdeer1.addch(1, 18, ord('\\'))
-    bigdeer1.addch(1, 20, ord('/'))
-    bigdeer1.addch(2, 19, ord('|'))
-    bigdeer1.addch(2, 20, ord('_'))
-    bigdeer1.addch(3, 18, ord('/'))
-    bigdeer1.addch(3, 19, ord('^'))
-    bigdeer1.addch(3, 20, ord('0'))
-    bigdeer1.addch(3, 21, ord('\\'))
-    bigdeer1.addch(4, 17, ord('/'))
-    bigdeer1.addch(4, 18, ord('/'))
-    bigdeer1.addch(4, 19, ord('\\'))
-    bigdeer1.addch(4, 22, ord('\\'))
-    bigdeer1.addstr(5, 7, "^~~~~~~~~//  ~~U")
-    bigdeer1.addstr(6, 7, "( \\_____( /")       # ))
-    bigdeer1.addstr(7, 8, "( )    /")
-    bigdeer1.addstr(8, 9, "\\\\   /")
-    bigdeer1.addstr(9, 11, "\\>/>")
-
-    bigdeer2.addch(0, 17, ord('\\'))
-    bigdeer2.addch(0, 18, ord('/'))
-    bigdeer2.addch(0, 19, ord('\\'))
-    bigdeer2.addch(0, 20, ord('/'))
-    bigdeer2.addch(1, 18, ord('\\'))
-    bigdeer2.addch(1, 20, ord('/'))
-    bigdeer2.addch(2, 19, ord('|'))
-    bigdeer2.addch(2, 20, ord('_'))
-    bigdeer2.addch(3, 18, ord('/'))
-    bigdeer2.addch(3, 19, ord('^'))
-    bigdeer2.addch(3, 20, ord('0'))
-    bigdeer2.addch(3, 21, ord('\\'))
-    bigdeer2.addch(4, 17, ord('/'))
-    bigdeer2.addch(4, 18, ord('/'))
-    bigdeer2.addch(4, 19, ord('\\'))
-    bigdeer2.addch(4, 22, ord('\\'))
-    bigdeer2.addstr(5, 7, "^~~~~~~~~//  ~~U")
-    bigdeer2.addstr(6, 7, "(( )____( /")        # ))
-    bigdeer2.addstr(7, 7, "( /    |")
-    bigdeer2.addstr(8, 8, "\\/    |")
-    bigdeer2.addstr(9, 9, "|>   |>")
-
-    bigdeer3.addch(0, 17, ord('\\'))
-    bigdeer3.addch(0, 18, ord('/'))
-    bigdeer3.addch(0, 19, ord('\\'))
-    bigdeer3.addch(0, 20, ord('/'))
-    bigdeer3.addch(1, 18, ord('\\'))
-    bigdeer3.addch(1, 20, ord('/'))
-    bigdeer3.addch(2, 19, ord('|'))
-    bigdeer3.addch(2, 20, ord('_'))
-    bigdeer3.addch(3, 18, ord('/'))
-    bigdeer3.addch(3, 19, ord('^'))
-    bigdeer3.addch(3, 20, ord('0'))
-    bigdeer3.addch(3, 21, ord('\\'))
-    bigdeer3.addch(4, 17, ord('/'))
-    bigdeer3.addch(4, 18, ord('/'))
-    bigdeer3.addch(4, 19, ord('\\'))
-    bigdeer3.addch(4, 22, ord('\\'))
-    bigdeer3.addstr(5, 7, "^~~~~~~~~//  ~~U")
-    bigdeer3.addstr(6, 6, "( ()_____( /")       # ))
-    bigdeer3.addstr(7, 6, "/ /       /")
-    bigdeer3.addstr(8, 5, "|/          \\")
-    bigdeer3.addstr(9, 5, "/>           \\>")
-
-    bigdeer4.addch(0, 17, ord('\\'))
-    bigdeer4.addch(0, 18, ord('/'))
-    bigdeer4.addch(0, 19, ord('\\'))
-    bigdeer4.addch(0, 20, ord('/'))
-    bigdeer4.addch(1, 18, ord('\\'))
-    bigdeer4.addch(1, 20, ord('/'))
-    bigdeer4.addch(2, 19, ord('|'))
-    bigdeer4.addch(2, 20, ord('_'))
-    bigdeer4.addch(3, 18, ord('/'))
-    bigdeer4.addch(3, 19, ord('^'))
-    bigdeer4.addch(3, 20, ord('0'))
-    bigdeer4.addch(3, 21, ord('\\'))
-    bigdeer4.addch(4, 17, ord('/'))
-    bigdeer4.addch(4, 18, ord('/'))
-    bigdeer4.addch(4, 19, ord('\\'))
-    bigdeer4.addch(4, 22, ord('\\'))
-    bigdeer4.addstr(5, 7, "^~~~~~~~~//  ~~U")
-    bigdeer4.addstr(6, 6, "( )______( /")       # )
-    bigdeer4.addstr(7, 5, "(/          \\")     # )
-    bigdeer4.addstr(8, 0, "v___=             ----^")
-
-    lookdeer1.addstr(0, 16, "\\/     \\/")
-    lookdeer1.addstr(1, 17, "\\Y/ \\Y/")
-    lookdeer1.addstr(2, 19, "\\=/")
-    lookdeer1.addstr(3, 17, "^\\o o/^")
-    lookdeer1.addstr(4, 17, "//( )")
-    lookdeer1.addstr(5, 7, "^~~~~~~~~// \\O/")
-    lookdeer1.addstr(6, 7, "( \\_____( /")      # ))
-    lookdeer1.addstr(7, 8, "( )    /")
-    lookdeer1.addstr(8, 9, "\\\\   /")
-    lookdeer1.addstr(9, 11, "\\>/>")
-
-    lookdeer2.addstr(0, 16, "\\/     \\/")
-    lookdeer2.addstr(1, 17, "\\Y/ \\Y/")
-    lookdeer2.addstr(2, 19, "\\=/")
-    lookdeer2.addstr(3, 17, "^\\o o/^")
-    lookdeer2.addstr(4, 17, "//( )")
-    lookdeer2.addstr(5, 7, "^~~~~~~~~// \\O/")
-    lookdeer2.addstr(6, 7, "(( )____( /")       # ))
-    lookdeer2.addstr(7, 7, "( /    |")
-    lookdeer2.addstr(8, 8, "\\/    |")
-    lookdeer2.addstr(9, 9, "|>   |>")
-
-    lookdeer3.addstr(0, 16, "\\/     \\/")
-    lookdeer3.addstr(1, 17, "\\Y/ \\Y/")
-    lookdeer3.addstr(2, 19, "\\=/")
-    lookdeer3.addstr(3, 17, "^\\o o/^")
-    lookdeer3.addstr(4, 17, "//( )")
-    lookdeer3.addstr(5, 7, "^~~~~~~~~// \\O/")
-    lookdeer3.addstr(6, 6, "( ()_____( /")      # ))
-    lookdeer3.addstr(7, 6, "/ /       /")
-    lookdeer3.addstr(8, 5, "|/          \\")
-    lookdeer3.addstr(9, 5, "/>           \\>")
-
-    lookdeer4.addstr(0, 16, "\\/     \\/")
-    lookdeer4.addstr(1, 17, "\\Y/ \\Y/")
-    lookdeer4.addstr(2, 19, "\\=/")
-    lookdeer4.addstr(3, 17, "^\\o o/^")
-    lookdeer4.addstr(4, 17, "//( )")
-    lookdeer4.addstr(5, 7, "^~~~~~~~~// \\O/")
-    lookdeer4.addstr(6, 6, "( )______( /")      # )
-    lookdeer4.addstr(7, 5, "(/          \\")    # )
-    lookdeer4.addstr(8, 0, "v___=             ----^")
-
-    ###############################################
-    curses.cbreak()
-    stdscr.nodelay(1)
-
-    while 1:
-        stdscr.clear()
-        treescrn.erase()
-        w_del_msg.touchwin()
-        treescrn.touchwin()
-        treescrn2.erase()
-        treescrn2.touchwin()
-        treescrn8.erase()
-        treescrn8.touchwin()
-        stdscr.refresh()
-        look_out(150)
-        boxit()
-        stdscr.refresh()
-        look_out(150)
-        seas()
-        stdscr.refresh()
-        greet()
-        stdscr.refresh()
-        look_out(150)
-        fromwho()
-        stdscr.refresh()
-        look_out(150)
-        tree()
-        look_out(150)
-        balls()
-        look_out(150)
-        star()
-        look_out(150)
-        strng1()
-        strng2()
-        strng3()
-        strng4()
-        strng5()
-
-        # set up the windows for our blinking trees
-        #
-        # treescrn3
-        treescrn.overlay(treescrn3)
-
-        # balls
-        treescrn3.addch(4, 18, ord(' '))
-        treescrn3.addch(7, 6, ord(' '))
-        treescrn3.addch(8, 19, ord(' '))
-        treescrn3.addch(11, 22, ord(' '))
-
-        # star
-        treescrn3.addch(0, 12, ord('*'))
-
-        # strng1
-        treescrn3.addch(3, 11, ord(' '))
-
-        # strng2
-        treescrn3.addch(5, 13, ord(' '))
-        treescrn3.addch(6, 10, ord(' '))
-
-        # strng3
-        treescrn3.addch(7, 16, ord(' '))
-        treescrn3.addch(7, 14, ord(' '))
-
-        # strng4
-        treescrn3.addch(10, 13, ord(' '))
-        treescrn3.addch(10, 10, ord(' '))
-        treescrn3.addch(11, 8, ord(' '))
-
-        # strng5
-        treescrn3.addch(11, 18, ord(' '))
-        treescrn3.addch(12, 13, ord(' '))
-
-        # treescrn4
-        treescrn.overlay(treescrn4)
-
-        # balls
-        treescrn4.addch(3, 9, ord(' '))
-        treescrn4.addch(4, 16, ord(' '))
-        treescrn4.addch(7, 6, ord(' '))
-        treescrn4.addch(8, 19, ord(' '))
-        treescrn4.addch(11, 2, ord(' '))
-        treescrn4.addch(12, 23, ord(' '))
-
-        # star
-        treescrn4.standout()
-        treescrn4.addch(0, 12, ord('*'))
-        treescrn4.standend()
-
-        # strng1
-        treescrn4.addch(3, 13, ord(' '))
-
-        # strng2
-
-        # strng3
-        treescrn4.addch(7, 15, ord(' '))
-        treescrn4.addch(8, 11, ord(' '))
-
-        # strng4
-        treescrn4.addch(9, 16, ord(' '))
-        treescrn4.addch(10, 12, ord(' '))
-        treescrn4.addch(11, 8, ord(' '))
-
-        # strng5
-        treescrn4.addch(11, 18, ord(' '))
-        treescrn4.addch(12, 14, ord(' '))
-
-        # treescrn5
-        treescrn.overlay(treescrn5)
-
-        # balls
-        treescrn5.addch(3, 15, ord(' '))
-        treescrn5.addch(10, 20, ord(' '))
-        treescrn5.addch(12, 1, ord(' '))
-
-        # star
-        treescrn5.addch(0, 12, ord(' '))
-
-        # strng1
-        treescrn5.addch(3, 11, ord(' '))
-
-        # strng2
-        treescrn5.addch(5, 12, ord(' '))
-
-        # strng3
-        treescrn5.addch(7, 14, ord(' '))
-        treescrn5.addch(8, 10, ord(' '))
-
-        # strng4
-        treescrn5.addch(9, 15, ord(' '))
-        treescrn5.addch(10, 11, ord(' '))
-        treescrn5.addch(11, 7, ord(' '))
-
-        # strng5
-        treescrn5.addch(11, 17, ord(' '))
-        treescrn5.addch(12, 13, ord(' '))
-
-        # treescrn6
-        treescrn.overlay(treescrn6)
-
-        # balls
-        treescrn6.addch(6, 7, ord(' '))
-        treescrn6.addch(7, 18, ord(' '))
-        treescrn6.addch(10, 4, ord(' '))
-        treescrn6.addch(11, 23, ord(' '))
-
-        # star
-        treescrn6.standout()
-        treescrn6.addch(0, 12, ord('*'))
-        treescrn6.standend()
-
-        # strng1
-
-        # strng2
-        treescrn6.addch(5, 11, ord(' '))
-
-        # strng3
-        treescrn6.addch(7, 13, ord(' '))
-        treescrn6.addch(8, 9, ord(' '))
-
-        # strng4
-        treescrn6.addch(9, 14, ord(' '))
-        treescrn6.addch(10, 10, ord(' '))
-        treescrn6.addch(11, 6, ord(' '))
-
-        # strng5
-        treescrn6.addch(11, 16, ord(' '))
-        treescrn6.addch(12, 12, ord(' '))
-
-        #  treescrn7
-
-        treescrn.overlay(treescrn7)
-
-        # balls
-        treescrn7.addch(3, 15, ord(' '))
-        treescrn7.addch(6, 7, ord(' '))
-        treescrn7.addch(7, 18, ord(' '))
-        treescrn7.addch(10, 4, ord(' '))
-        treescrn7.addch(11, 22, ord(' '))
-
-        # star
-        treescrn7.addch(0, 12, ord('*'))
-
-        # strng1
-        treescrn7.addch(3, 12, ord(' '))
-
-        # strng2
-        treescrn7.addch(5, 13, ord(' '))
-        treescrn7.addch(6, 9, ord(' '))
-
-        # strng3
-        treescrn7.addch(7, 15, ord(' '))
-        treescrn7.addch(8, 11, ord(' '))
-
-        # strng4
-        treescrn7.addch(9, 16, ord(' '))
-        treescrn7.addch(10, 12, ord(' '))
-        treescrn7.addch(11, 8, ord(' '))
-
-        # strng5
-        treescrn7.addch(11, 18, ord(' '))
-        treescrn7.addch(12, 14, ord(' '))
-
-        look_out(150)
-        reindeer()
-
-        w_holiday.touchwin()
-        w_holiday.refresh()
-        w_del_msg.refresh()
-
-        look_out(500)
-        for i in range(0, 20):
-            blinkit()
-
-curses.wrapper(main)
diff --git a/Demo/distutils/test2to3/maintest.py b/Demo/distutils/test2to3/maintest.py
deleted file mode 100644
index 72a26dd..0000000
--- a/Demo/distutils/test2to3/maintest.py
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env python
-
-# The above line should get replaced with the path to the Python
-# interpreter; the block below should get 2to3-converted.
-
-try:
-    from test2to3.hello import hello
-except ImportError, e:
-    print "Import failed", e
-hello()
diff --git a/Demo/embed/Makefile b/Demo/embed/Makefile
deleted file mode 100644
index 711b95b..0000000
--- a/Demo/embed/Makefile
+++ /dev/null
@@ -1,57 +0,0 @@
-# Makefile for embedded Python use demo.
-# (This version tailored for my Red Hat Linux 6.1 setup;
-# edit lines marked with XXX.)
-
-# XXX The compiler you are using
-CC=	 	gcc
-
-# XXX Top of the build tree and source tree
-blddir=		../..
-srcdir=		../..
-
-# Python version
-VERSION=	3.0
-
-# Compiler flags
-OPT=		-g
-INCLUDES=	-I$(srcdir)/Include -I$(blddir)
-CFLAGS=		$(OPT)
-CPPFLAGS=	$(INCLUDES)
-
-# The Python library
-LIBPYTHON=	$(blddir)/libpython$(VERSION).a
-
-# XXX edit LIBS (in particular) to match $(blddir)/Modules/Makefile
-LIBS=		-lnsl -ldl -lreadline -lieee -lpthread -lutil
-LDFLAGS=	-Xlinker -export-dynamic
-SYSLIBS=	-lm
-MODLIBS=	
-ALLLIBS=	$(LIBPYTHON) $(MODLIBS) $(LIBS) $(SYSLIBS)
-
-# Build the demo applications
-all:		demo loop importexc
-demo:		demo.o
-		$(CC) $(LDFLAGS) demo.o $(ALLLIBS) -o demo
-
-loop:		loop.o
-		$(CC) $(LDFLAGS) loop.o $(ALLLIBS) -o loop
-
-importexc:	importexc.o
-		$(CC) $(LDFLAGS) importexc.o $(ALLLIBS) -o importexc
-
-# Administrative targets
-
-test:		demo
-		./demo
-
-COMMAND="print 'hello world'"
-looptest:	loop
-		./loop $(COMMAND)
-
-clean:
-		-rm -f *.o core
-
-clobber:	clean
-		-rm -f *~ @* '#'* demo loop importexc
-
-realclean:	clobber
diff --git a/Demo/embed/README b/Demo/embed/README
deleted file mode 100644
index a0f7af8..0000000
--- a/Demo/embed/README
+++ /dev/null
@@ -1,19 +0,0 @@
-This directory show how to embed the Python interpreter in your own
-application.  The file demo.c shows you all that is needed in your C
-code.
-
-To build it, you may have to edit the Makefile:
-
-1) set blddir to the directory where you built Python, if it isn't in
-the source directory (../..)
-
-2) change the variables that together define the list of libraries
-(MODLIBS, LIBS, SYSLIBS) to link with, to match their definitions in
-$(blddir)/Modules/Makefile
-
-An additional test program, loop.c, is used to experiment with memory
-leakage caused by repeated initialization and finalization of the
-interpreter.  It can be build by saying "make loop" and tested with
-"make looptest".  Command line usage is "./loop <python-command>",
-e.g. "./loop 'print 2+2'" should spit out an endless number of lines
-containing the number 4.
diff --git a/Demo/embed/demo.c b/Demo/embed/demo.c
deleted file mode 100644
index 99d39ca..0000000
--- a/Demo/embed/demo.c
+++ /dev/null
@@ -1,89 +0,0 @@
-/* Example of embedding Python in another program */
-
-#include "Python.h"
-
-PyObject* PyInit_xyzzy(void); /* Forward */
-
-main(int argc, char **argv)
-{
-    /* Ignore passed-in argc/argv. If desired, conversion
-       should use mbstowcs to convert them. */
-    wchar_t *args[] = {L"embed", L"hello", 0};
-
-    /* Pass argv[0] to the Python interpreter */
-    Py_SetProgramName(args[0]);
-
-    /* Add a static module */
-    PyImport_AppendInittab("xyzzy", PyInit_xyzzy);
-
-    /* Initialize the Python interpreter.  Required. */
-    Py_Initialize();
-
-    /* Define sys.argv.  It is up to the application if you
-       want this; you can also let it undefined (since the Python
-       code is generally not a main program it has no business
-       touching sys.argv...)
-
-       If the third argument is true, sys.path is modified to include
-       either the directory containing the script named by argv[0], or
-       the current working directory.  This can be risky; if you run
-       an application embedding Python in a directory controlled by
-       someone else, attackers could put a Trojan-horse module in the
-       directory (say, a file named os.py) that your application would
-       then import and run.
-    */
-    PySys_SetArgvEx(2, args, 0);
-
-    /* Do some application specific code */
-    printf("Hello, brave new world\n\n");
-
-    /* Execute some Python statements (in module __main__) */
-    PyRun_SimpleString("import sys\n");
-    PyRun_SimpleString("print(sys.builtin_module_names)\n");
-    PyRun_SimpleString("print(sys.modules.keys())\n");
-    PyRun_SimpleString("print(sys.executable)\n");
-    PyRun_SimpleString("print(sys.argv)\n");
-
-    /* Note that you can call any public function of the Python
-       interpreter here, e.g. call_object(). */
-
-    /* Some more application specific code */
-    printf("\nGoodbye, cruel world\n");
-
-    /* Exit, cleaning up the interpreter */
-    Py_Exit(0);
-    /*NOTREACHED*/
-}
-
-/* A static module */
-
-/* 'self' is not used */
-static PyObject *
-xyzzy_foo(PyObject *self, PyObject* args)
-{
-    return PyLong_FromLong(42L);
-}
-
-static PyMethodDef xyzzy_methods[] = {
-    {"foo",             xyzzy_foo,      METH_NOARGS,
-     "Return the meaning of everything."},
-    {NULL,              NULL}           /* sentinel */
-};
-
-static struct PyModuleDef xyzzymodule = {
-    {}, /* m_base */
-    "xyzzy",  /* m_name */
-    0,  /* m_doc */
-    0,  /* m_size */
-    xyzzy_methods,  /* m_methods */
-    0,  /* m_reload */
-    0,  /* m_traverse */
-    0,  /* m_clear */
-    0,  /* m_free */
-};
-
-PyObject*
-PyInit_xyzzy(void)
-{
-    return PyModule_Create(&xyzzymodule);
-}
diff --git a/Demo/embed/importexc.c b/Demo/embed/importexc.c
deleted file mode 100644
index 59b1d01..0000000
--- a/Demo/embed/importexc.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <Python.h>
-
-#if 0
-char* cmd = "import codecs, encodings.utf_8, types; print(types)";
-#else
-char* cmd = "import types; print(types)";
-#endif
-
-int main()
-{
-	printf("Initialize interpreter\n");
-	Py_Initialize();
-	PyEval_InitThreads();
-	PyRun_SimpleString(cmd);
-	Py_EndInterpreter(PyThreadState_Get());
-
-	printf("\nInitialize subinterpreter\n");
-	Py_NewInterpreter();
-	PyRun_SimpleString(cmd);
-	Py_Finalize();
-
-	return 0;
-}
diff --git a/Demo/embed/loop.c b/Demo/embed/loop.c
deleted file mode 100644
index 4a341fd..0000000
--- a/Demo/embed/loop.c
+++ /dev/null
@@ -1,33 +0,0 @@
-/* Simple program that repeatedly calls Py_Initialize(), does something, and
-   then calls Py_Finalize().  This should help finding leaks related to
-   initialization. */
-
-#include "Python.h"
-
-main(int argc, char **argv)
-{
-    int count = -1;
-    char *command;
-
-    if (argc < 2 || argc > 3) {
-        fprintf(stderr, "usage: loop <python-command> [count]\n");
-        exit(2);
-    }
-    command = argv[1];
-
-    if (argc == 3) {
-        count = atoi(argv[2]);
-    }
-
-    Py_SetProgramName(L"loop");
-
-    /* uncomment this if you don't want to load site.py */
-    /* Py_NoSiteFlag = 1; */
-
-    while (count == -1 || --count >= 0 ) {
-        Py_Initialize();
-        PyRun_SimpleString(command);
-        Py_Finalize();
-    }
-    return 0;
-}
diff --git a/Demo/md5test/README b/Demo/md5test/README
deleted file mode 100644
index be7621e..0000000
--- a/Demo/md5test/README
+++ /dev/null
@@ -1,10 +0,0 @@
-This is the Python version of the MD5 test program from the MD5
-Internet Draft (Rivest and Dusse, The MD5 Message-Digest Algorithm, 10
-July 1991).  The file "foo" contains the string "abc" with no trailing
-newline.
-
-When called without arguments, it acts as a filter.  When called with
-"-x", it executes a self-test, and the output should literally match
-the output given in the RFC.
-
-Code by Jan-Hein B\"uhrman after the original in C.
diff --git a/Demo/md5test/foo b/Demo/md5test/foo
deleted file mode 100755
index f2ba8f8..0000000
--- a/Demo/md5test/foo
+++ /dev/null
@@ -1 +0,0 @@
-abc
-\ No newline at end of file
diff --git a/Demo/md5test/md5driver.py b/Demo/md5test/md5driver.py
deleted file mode 100755
index 7f561ab..0000000
--- a/Demo/md5test/md5driver.py
+++ /dev/null
@@ -1,122 +0,0 @@
-from hashlib import md5
-import string
-from sys import argv
-
-def MDPrint(str):
-    outstr = ''
-    for o in str:
-        outstr = (outstr
-                  + string.hexdigits[(o >> 4) & 0xF]
-                  + string.hexdigits[o & 0xF])
-    print(outstr, end=' ')
-
-
-from time import time
-
-def makestr(start, end):
-    result = ''
-    for i in range(start, end + 1):
-        result = result + chr(i)
-
-    return result
-
-
-def MDTimeTrial():
-    TEST_BLOCK_SIZE = 1000
-    TEST_BLOCKS = 10000
-
-    TEST_BYTES = TEST_BLOCK_SIZE * TEST_BLOCKS
-
-    # initialize test data, need temporary string filler
-
-    filsiz = 1 << 8
-    filler = makestr(0, filsiz-1)
-    data = filler * (TEST_BLOCK_SIZE // filsiz)
-    data = data + filler[:(TEST_BLOCK_SIZE % filsiz)]
-
-    del filsiz, filler
-
-
-    # start timer
-    print('MD5 time trial. Processing', TEST_BYTES, 'characters...')
-    t1 = time()
-
-    mdContext = md5()
-
-    for i in range(TEST_BLOCKS):
-        mdContext.update(data)
-
-    str = mdContext.digest()
-    t2 = time()
-
-    MDPrint(str)
-    print('is digest of test input.')
-    print('Seconds to process test input:', t2 - t1)
-    print('Characters processed per second:', TEST_BYTES / (t2 - t1))
-
-
-def MDString(str):
-    MDPrint(md5(str.encode("utf-8")).digest())
-    print('"' + str + '"')
-
-
-def MDFile(filename):
-    f = open(filename, 'rb')
-    mdContext = md5()
-
-    while 1:
-        data = f.read(1024)
-        if not data:
-            break
-        mdContext.update(data)
-
-    MDPrint(mdContext.digest())
-    print(filename)
-
-
-import sys
-
-def MDFilter():
-    mdContext = md5()
-
-    while 1:
-        data = sys.stdin.read(16).encode()
-        if not data:
-            break
-        mdContext.update(data)
-
-    MDPrint(mdContext.digest())
-    print()
-
-
-def MDTestSuite():
-    print('MD5 test suite results:')
-    MDString('')
-    MDString('a')
-    MDString('abc')
-    MDString('message digest')
-    MDString(makestr(ord('a'), ord('z')))
-    MDString(makestr(ord('A'), ord('Z'))
-              + makestr(ord('a'), ord('z'))
-              + makestr(ord('0'), ord('9')))
-    MDString((makestr(ord('1'), ord('9')) + '0') * 8)
-
-    # Contents of file foo are "abc"
-    MDFile('foo')
-
-
-# I don't wanna use getopt(), since I want to use the same i/f...
-def main():
-    if len(argv) == 1:
-        MDFilter()
-    for arg in argv[1:]:
-        if arg[:2] == '-s':
-            MDString(arg[2:])
-        elif arg == '-t':
-            MDTimeTrial()
-        elif arg == '-x':
-            MDTestSuite()
-        else:
-            MDFile(arg)
-
-main()
diff --git a/Demo/newmetaclasses/Eiffel.py b/Demo/newmetaclasses/Eiffel.py
deleted file mode 100644
index 15fa58a..0000000
--- a/Demo/newmetaclasses/Eiffel.py
+++ /dev/null
@@ -1,141 +0,0 @@
-"""Support Eiffel-style preconditions and postconditions."""
-
-from types import FunctionType as function
-
-class EiffelBaseMetaClass(type):
-
-    def __new__(meta, name, bases, dict):
-        meta.convert_methods(dict)
-        return super(EiffelBaseMetaClass, meta).__new__(meta, name, bases,
-                                                        dict)
-
-    @classmethod
-    def convert_methods(cls, dict):
-        """Replace functions in dict with EiffelMethod wrappers.
-
-        The dict is modified in place.
-
-        If a method ends in _pre or _post, it is removed from the dict
-        regardless of whether there is a corresponding method.
-        """
-        # find methods with pre or post conditions
-        methods = []
-        for k, v in dict.items():
-            if k.endswith('_pre') or k.endswith('_post'):
-                assert isinstance(v, function)
-            elif isinstance(v, function):
-                methods.append(k)
-        for m in methods:
-            pre = dict.get("%s_pre" % m)
-            post = dict.get("%s_post" % m)
-            if pre or post:
-                dict[k] = cls.make_eiffel_method(dict[m], pre, post)
-
-class EiffelMetaClass1(EiffelBaseMetaClass):
-    # an implementation of the "eiffel" meta class that uses nested functions
-
-    @staticmethod
-    def make_eiffel_method(func, pre, post):
-        def method(self, *args, **kwargs):
-            if pre:
-                pre(self, *args, **kwargs)
-            x = func(self, *args, **kwargs)
-            if post:
-                post(self, x, *args, **kwargs)
-            return x
-
-        if func.__doc__:
-            method.__doc__ = func.__doc__
-
-        return method
-
-class EiffelMethodWrapper:
-
-    def __init__(self, inst, descr):
-        self._inst = inst
-        self._descr = descr
-
-    def __call__(self, *args, **kwargs):
-        return self._descr.callmethod(self._inst, args, kwargs)
-
-class EiffelDescriptor(object):
-
-    def __init__(self, func, pre, post):
-        self._func = func
-        self._pre = pre
-        self._post = post
-
-        self.__name__ = func.__name__
-        self.__doc__ = func.__doc__
-
-    def __get__(self, obj, cls):
-        return EiffelMethodWrapper(obj, self)
-
-    def callmethod(self, inst, args, kwargs):
-        if self._pre:
-            self._pre(inst, *args, **kwargs)
-        x = self._func(inst, *args, **kwargs)
-        if self._post:
-            self._post(inst, x, *args, **kwargs)
-        return x
-
-class EiffelMetaClass2(EiffelBaseMetaClass):
-    # an implementation of the "eiffel" meta class that uses descriptors
-
-    make_eiffel_method = EiffelDescriptor
-
-def _test(metaclass):
-    class Eiffel(metaclass=metaclass):
-        pass
-
-    class Test(Eiffel):
-
-        def m(self, arg):
-            """Make it a little larger"""
-            return arg + 1
-
-        def m2(self, arg):
-            """Make it a little larger"""
-            return arg + 1
-
-        def m2_pre(self, arg):
-            assert arg > 0
-
-        def m2_post(self, result, arg):
-            assert result > arg
-
-    class Sub(Test):
-        def m2(self, arg):
-            return arg**2
-        def m2_post(self, Result, arg):
-            super(Sub, self).m2_post(Result, arg)
-            assert Result < 100
-
-    t = Test()
-    t.m(1)
-    t.m2(1)
-    try:
-        t.m2(0)
-    except AssertionError:
-        pass
-    else:
-        assert False
-
-    s = Sub()
-    try:
-        s.m2(1)
-    except AssertionError:
-        pass # result == arg
-    else:
-        assert False
-    try:
-        s.m2(10)
-    except AssertionError:
-        pass # result ==  100
-    else:
-        assert False
-    s.m2(5)
-
-if __name__ == "__main__":
-    _test(EiffelMetaClass1)
-    _test(EiffelMetaClass2)
diff --git a/Demo/newmetaclasses/Enum.py b/Demo/newmetaclasses/Enum.py
deleted file mode 100644
index 3ff8ddd..0000000
--- a/Demo/newmetaclasses/Enum.py
+++ /dev/null
@@ -1,177 +0,0 @@
-"""Enumeration metaclass."""
-
-class EnumMetaclass(type):
-    """Metaclass for enumeration.
-
-    To define your own enumeration, do something like
-
-    class Color(Enum):
-        red = 1
-        green = 2
-        blue = 3
-
-    Now, Color.red, Color.green and Color.blue behave totally
-    different: they are enumerated values, not integers.
-
-    Enumerations cannot be instantiated; however they can be
-    subclassed.
-    """
-
-    def __init__(cls, name, bases, dict):
-        super(EnumMetaclass, cls).__init__(name, bases, dict)
-        cls._members = []
-        for attr in dict.keys():
-            if not (attr.startswith('__') and attr.endswith('__')):
-                enumval = EnumInstance(name, attr, dict[attr])
-                setattr(cls, attr, enumval)
-                cls._members.append(attr)
-
-    def __getattr__(cls, name):
-        if name == "__members__":
-            return cls._members
-        raise AttributeError(name)
-
-    def __repr__(cls):
-        s1 = s2 = ""
-        enumbases = [base.__name__ for base in cls.__bases__
-                     if isinstance(base, EnumMetaclass) and not base is Enum]
-        if enumbases:
-            s1 = "(%s)" % ", ".join(enumbases)
-        enumvalues = ["%s: %d" % (val, getattr(cls, val))
-                      for val in cls._members]
-        if enumvalues:
-            s2 = ": {%s}" % ", ".join(enumvalues)
-        return "%s%s%s" % (cls.__name__, s1, s2)
-
-class FullEnumMetaclass(EnumMetaclass):
-    """Metaclass for full enumerations.
-
-    A full enumeration displays all the values defined in base classes.
-    """
-
-    def __init__(cls, name, bases, dict):
-        super(FullEnumMetaclass, cls).__init__(name, bases, dict)
-        for obj in cls.__mro__:
-            if isinstance(obj, EnumMetaclass):
-                for attr in obj._members:
-                    # XXX inefficient
-                    if not attr in cls._members:
-                        cls._members.append(attr)
-
-class EnumInstance(int):
-    """Class to represent an enumeration value.
-
-    EnumInstance('Color', 'red', 12) prints as 'Color.red' and behaves
-    like the integer 12 when compared, but doesn't support arithmetic.
-
-    XXX Should it record the actual enumeration rather than just its
-    name?
-    """
-
-    def __new__(cls, classname, enumname, value):
-        return int.__new__(cls, value)
-
-    def __init__(self, classname, enumname, value):
-        self.__classname = classname
-        self.__enumname = enumname
-
-    def __repr__(self):
-        return "EnumInstance(%s, %s, %d)" % (self.__classname, self.__enumname,
-                                             self)
-
-    def __str__(self):
-        return "%s.%s" % (self.__classname, self.__enumname)
-
-class Enum(metaclass=EnumMetaclass):
-    pass
-
-class FullEnum(metaclass=FullEnumMetaclass):
-    pass
-
-def _test():
-
-    class Color(Enum):
-        red = 1
-        green = 2
-        blue = 3
-
-    print(Color.red)
-
-    print(repr(Color.red))
-    print(Color.red == Color.red)
-    print(Color.red == Color.blue)
-    print(Color.red == 1)
-    print(Color.red == 2)
-
-    class ExtendedColor(Color):
-        white = 0
-        orange = 4
-        yellow = 5
-        purple = 6
-        black = 7
-
-    print(ExtendedColor.orange)
-    print(ExtendedColor.red)
-
-    print(Color.red == ExtendedColor.red)
-
-    class OtherColor(Enum):
-        white = 4
-        blue = 5
-
-    class MergedColor(Color, OtherColor):
-        pass
-
-    print(MergedColor.red)
-    print(MergedColor.white)
-
-    print(Color)
-    print(ExtendedColor)
-    print(OtherColor)
-    print(MergedColor)
-
-def _test2():
-
-    class Color(FullEnum):
-        red = 1
-        green = 2
-        blue = 3
-
-    print(Color.red)
-
-    print(repr(Color.red))
-    print(Color.red == Color.red)
-    print(Color.red == Color.blue)
-    print(Color.red == 1)
-    print(Color.red == 2)
-
-    class ExtendedColor(Color):
-        white = 0
-        orange = 4
-        yellow = 5
-        purple = 6
-        black = 7
-
-    print(ExtendedColor.orange)
-    print(ExtendedColor.red)
-
-    print(Color.red == ExtendedColor.red)
-
-    class OtherColor(FullEnum):
-        white = 4
-        blue = 5
-
-    class MergedColor(Color, OtherColor):
-        pass
-
-    print(MergedColor.red)
-    print(MergedColor.white)
-
-    print(Color)
-    print(ExtendedColor)
-    print(OtherColor)
-    print(MergedColor)
-
-if __name__ == '__main__':
-    _test()
-    _test2()
diff --git a/Demo/parser/FILES b/Demo/parser/FILES
deleted file mode 100644
index 1ff59a3..0000000
--- a/Demo/parser/FILES
+++ /dev/null
@@ -1,6 +0,0 @@
-Demo/parser
-Doc/libparser.tex
-Lib/AST.py
-Lib/symbol.py
-Lib/token.py
-Modules/parsermodule.c
diff --git a/Demo/parser/README b/Demo/parser/README
deleted file mode 100644
index a576d33..0000000
--- a/Demo/parser/README
+++ /dev/null
@@ -1,31 +0,0 @@
-These files are from the large example of using the `parser' module.  Refer
-to the Python Library Reference for more information.
-
-It also contains examples for the AST parser.
-
-Files:
-------
-
-	FILES	     -- list of files associated with the parser module.
-
-	README	     -- this file.
-
-	example.py   --	module that uses the `parser' module to extract
-			information from the parse tree of Python source
-			code.
-
-	docstring.py -- sample source file containing only a module docstring.
-
-	simple.py    -- sample source containing a "short form" definition.
-
-	source.py    --	sample source code used to demonstrate ability to
-			handle nested constructs easily using the functions
-			and classes in example.py.
-
-	test_parser.py  program to put the parser module through its paces.
-
-	unparse.py	AST (2.5) based example to recreate source code
-			from an AST. This is incomplete; contributions
-			are welcome.
-
-Enjoy!
diff --git a/Demo/parser/docstring.py b/Demo/parser/docstring.py
deleted file mode 100644
index 45a261b..0000000
--- a/Demo/parser/docstring.py
+++ /dev/null
@@ -1,2 +0,0 @@
-"""Some documentation.
-"""
diff --git a/Demo/parser/example.py b/Demo/parser/example.py
deleted file mode 100644
index c2f0883..0000000
--- a/Demo/parser/example.py
+++ /dev/null
@@ -1,190 +0,0 @@
-"""Simple code to extract class & function docstrings from a module.
-
-This code is used as an example in the library reference manual in the
-section on using the parser module.  Refer to the manual for a thorough
-discussion of the operation of this code.
-"""
-
-import os
-import parser
-import symbol
-import token
-import types
-
-from types import ListType, TupleType
-
-
-def get_docs(fileName):
-    """Retrieve information from the parse tree of a source file.
-
-    fileName
-        Name of the file to read Python source code from.
-    """
-    source = open(fileName).read()
-    basename = os.path.basename(os.path.splitext(fileName)[0])
-    ast = parser.suite(source)
-    return ModuleInfo(ast.totuple(), basename)
-
-
-class SuiteInfoBase:
-    _docstring = ''
-    _name = ''
-
-    def __init__(self, tree = None):
-        self._class_info = {}
-        self._function_info = {}
-        if tree:
-            self._extract_info(tree)
-
-    def _extract_info(self, tree):
-        # extract docstring
-        if len(tree) == 2:
-            found, vars = match(DOCSTRING_STMT_PATTERN[1], tree[1])
-        else:
-            found, vars = match(DOCSTRING_STMT_PATTERN, tree[3])
-        if found:
-            self._docstring = eval(vars['docstring'])
-        # discover inner definitions
-        for node in tree[1:]:
-            found, vars = match(COMPOUND_STMT_PATTERN, node)
-            if found:
-                cstmt = vars['compound']
-                if cstmt[0] == symbol.funcdef:
-                    name = cstmt[2][1]
-                    self._function_info[name] = FunctionInfo(cstmt)
-                elif cstmt[0] == symbol.classdef:
-                    name = cstmt[2][1]
-                    self._class_info[name] = ClassInfo(cstmt)
-
-    def get_docstring(self):
-        return self._docstring
-
-    def get_name(self):
-        return self._name
-
-    def get_class_names(self):
-        return list(self._class_info.keys())
-
-    def get_class_info(self, name):
-        return self._class_info[name]
-
-    def __getitem__(self, name):
-        try:
-            return self._class_info[name]
-        except KeyError:
-            return self._function_info[name]
-
-
-class SuiteFuncInfo:
-    #  Mixin class providing access to function names and info.
-
-    def get_function_names(self):
-        return list(self._function_info.keys())
-
-    def get_function_info(self, name):
-        return self._function_info[name]
-
-
-class FunctionInfo(SuiteInfoBase, SuiteFuncInfo):
-    def __init__(self, tree = None):
-        self._name = tree[2][1]
-        SuiteInfoBase.__init__(self, tree and tree[-1] or None)
-
-
-class ClassInfo(SuiteInfoBase):
-    def __init__(self, tree = None):
-        self._name = tree[2][1]
-        SuiteInfoBase.__init__(self, tree and tree[-1] or None)
-
-    def get_method_names(self):
-        return list(self._function_info.keys())
-
-    def get_method_info(self, name):
-        return self._function_info[name]
-
-
-class ModuleInfo(SuiteInfoBase, SuiteFuncInfo):
-    def __init__(self, tree = None, name = "<string>"):
-        self._name = name
-        SuiteInfoBase.__init__(self, tree)
-        if tree:
-            found, vars = match(DOCSTRING_STMT_PATTERN, tree[1])
-            if found:
-                self._docstring = vars["docstring"]
-
-
-def match(pattern, data, vars=None):
-    """Match `data' to `pattern', with variable extraction.
-
-    pattern
-        Pattern to match against, possibly containing variables.
-
-    data
-        Data to be checked and against which variables are extracted.
-
-    vars
-        Dictionary of variables which have already been found.  If not
-        provided, an empty dictionary is created.
-
-    The `pattern' value may contain variables of the form ['varname'] which
-    are allowed to match anything.  The value that is matched is returned as
-    part of a dictionary which maps 'varname' to the matched value.  'varname'
-    is not required to be a string object, but using strings makes patterns
-    and the code which uses them more readable.
-
-    This function returns two values: a boolean indicating whether a match
-    was found and a dictionary mapping variable names to their associated
-    values.
-    """
-    if vars is None:
-        vars = {}
-    if type(pattern) is ListType:       # 'variables' are ['varname']
-        vars[pattern[0]] = data
-        return 1, vars
-    if type(pattern) is not TupleType:
-        return (pattern == data), vars
-    if len(data) != len(pattern):
-        return 0, vars
-    for pattern, data in map(None, pattern, data):
-        same, vars = match(pattern, data, vars)
-        if not same:
-            break
-    return same, vars
-
-
-#  This pattern identifies compound statements, allowing them to be readily
-#  differentiated from simple statements.
-#
-COMPOUND_STMT_PATTERN = (
-    symbol.stmt,
-    (symbol.compound_stmt, ['compound'])
-    )
-
-
-#  This pattern will match a 'stmt' node which *might* represent a docstring;
-#  docstrings require that the statement which provides the docstring be the
-#  first statement in the class or function, which this pattern does not check.
-#
-DOCSTRING_STMT_PATTERN = (
-    symbol.stmt,
-    (symbol.simple_stmt,
-     (symbol.small_stmt,
-      (symbol.expr_stmt,
-       (symbol.testlist,
-        (symbol.test,
-         (symbol.and_test,
-          (symbol.not_test,
-           (symbol.comparison,
-            (symbol.expr,
-             (symbol.xor_expr,
-              (symbol.and_expr,
-               (symbol.shift_expr,
-                (symbol.arith_expr,
-                 (symbol.term,
-                  (symbol.factor,
-                   (symbol.power,
-                    (symbol.atom,
-                     (token.STRING, ['docstring'])
-                     )))))))))))))))),
-     (token.NEWLINE, '')
-     ))
diff --git a/Demo/parser/simple.py b/Demo/parser/simple.py
deleted file mode 100644
index 184e2fe..0000000
--- a/Demo/parser/simple.py
+++ /dev/null
@@ -1 +0,0 @@
-def f(): "maybe a docstring"
diff --git a/Demo/parser/source.py b/Demo/parser/source.py
deleted file mode 100644
index b900628..0000000
--- a/Demo/parser/source.py
+++ /dev/null
@@ -1,27 +0,0 @@
-"""Exmaple file to be parsed for the parsermodule example.
-
-The classes and functions in this module exist only to exhibit the ability
-of the handling information extraction from nested definitions using parse
-trees.  They shouldn't interest you otherwise!
-"""
-
-class Simple:
-    "This class does very little."
-
-    def method(self):
-        "This method does almost nothing."
-        return 1
-
-    class Nested:
-        "This is a nested class."
-
-        def nested_method(self):
-            "Method of Nested class."
-            def nested_function():
-                "Function in method of Nested class."
-                pass
-            return nested_function
-
-def function():
-    "This function lives at the module level."
-    return 0
diff --git a/Demo/parser/test_parser.py b/Demo/parser/test_parser.py
deleted file mode 100755
index e4d5571..0000000
--- a/Demo/parser/test_parser.py
+++ /dev/null
@@ -1,48 +0,0 @@
-#! /usr/bin/env python
-#  (Force the script to use the latest build.)
-#
-#  test_parser.py
-
-import parser, traceback
-
-_numFailed = 0
-
-def testChunk(t, fileName):
-    global _numFailed
-    print('----', fileName, end=' ')
-    try:
-        ast = parser.suite(t)
-        tup = parser.ast2tuple(ast)
-        # this discards the first AST; a huge memory savings when running
-        # against a large source file like Tkinter.py.
-        ast = None
-        new = parser.tuple2ast(tup)
-    except parser.ParserError as err:
-        print()
-        print('parser module raised exception on input file', fileName + ':')
-        traceback.print_exc()
-        _numFailed = _numFailed + 1
-    else:
-        if tup != parser.ast2tuple(new):
-            print()
-            print('parser module failed on input file', fileName)
-            _numFailed = _numFailed + 1
-        else:
-            print('o.k.')
-
-def testFile(fileName):
-    t = open(fileName).read()
-    testChunk(t, fileName)
-
-def test():
-    import sys
-    args = sys.argv[1:]
-    if not args:
-        import glob
-        args = glob.glob("*.py")
-        args.sort()
-    list(map(testFile, args))
-    sys.exit(_numFailed != 0)
-
-if __name__ == '__main__':
-    test()
diff --git a/Demo/parser/texipre.dat b/Demo/parser/texipre.dat
deleted file mode 100644
index 8ad03a6..0000000
--- a/Demo/parser/texipre.dat
+++ /dev/null
@@ -1,100 +0,0 @@
-\input texinfo   @c -*-texinfo-*-
-@c %**start of header
-@setfilename parser.info
-@settitle Python Parser Module Reference
-@setchapternewpage odd
-@footnotestyle end
-@c %**end of header
-
-@ifinfo
-This file describes the interfaces
-published by the optional @code{parser} module and gives examples of
-how they may be used.  It contains the same text as the chapter on the
-@code{parser} module in the @cite{Python Library Reference}, but is
-presented as a separate document.
-
-Copyright 1995-1996 by Fred L. Drake, Jr., Reston, Virginia, USA, and
-Virginia Polytechnic Institute and State University, Blacksburg,
-Virginia, USA.  Portions of the software copyright 1991-1995 by
-Stichting Mathematisch Centrum, Amsterdam, The Netherlands.  Copying is
-permitted under the terms associated with the main Python distribution,
-with the additional restriction that this additional notice be included
-and maintained on all distributed copies.
-
-                        All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the names of Fred L. Drake, Jr. and
-Virginia Polytechnic Institute and State University not be used in
-advertising or publicity pertaining to distribution of the software
-without specific, written prior permission.
-
-FRED L. DRAKE, JR. AND VIRGINIA POLYTECHNIC INSTITUTE AND STATE
-UNIVERSITY DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
-EVENT SHALL FRED L. DRAKE, JR. OR VIRGINIA POLYTECHNIC INSTITUTE AND
-STATE UNIVERSITY BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
-DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
-PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-@end ifinfo
-
-@titlepage
-@title Python Parser Module Reference
-@author Fred L. Drake, Jr.
-
-@c  The following two commands start the copyright page.
-@page
-@vskip 0pt plus 1filll
-Copyright 1995-1996 by Fred L. Drake, Jr., Reston, Virginia, USA, and
-Virginia Polytechnic Institute and State University, Blacksburg,
-Virginia, USA.  Portions of the software copyright 1991-1995 by
-Stichting Mathematisch Centrum, Amsterdam, The Netherlands.  Copying is
-permitted under the terms associated with the main Python distribution,
-with the additional restriction that this additional notice be included
-and maintained on all distributed copies.
-
-@center All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the names of Fred L. Drake, Jr. and
-Virginia Polytechnic Institute and State University not be used in
-advertising or publicity pertaining to distribution of the software
-without specific, written prior permission.
-
-FRED L. DRAKE, JR. AND VIRGINIA POLYTECHNIC INSTITUTE AND STATE
-UNIVERSITY DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
-EVENT SHALL FRED L. DRAKE, JR. OR VIRGINIA POLYTECHNIC INSTITUTE AND
-STATE UNIVERSITY BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
-DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
-PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-@end titlepage
-
-
-@node Top, Overview, (dir), (dir)
-@top The Python Parser Module
-
-@ifinfo
-This file describes the interfaces
-published by the optional @code{parser} module and gives examples of
-how they may be used.  It contains the same text as the chapter on the
-@code{parser} module in the @cite{Python Library Reference}, but is
-presented as a separate document.
-
-This version corresponds to Python version 1.4 (1 Sept. 1996).
-
-@end ifinfo
-
-@c placeholder for the master menu -- patched by texinfo-all-menus-update
-@menu
-@end menu
diff --git a/Demo/parser/unparse.py b/Demo/parser/unparse.py
deleted file mode 100644
index d53a6c4..0000000
--- a/Demo/parser/unparse.py
+++ /dev/null
@@ -1,509 +0,0 @@
-"Usage: unparse.py <path to source file>"
-import sys
-import _ast
-import io
-import os
-
-def interleave(inter, f, seq):
-    """Call f on each item in seq, calling inter() in between.
-    """
-    seq = iter(seq)
-    try:
-        f(next(seq))
-    except StopIteration:
-        pass
-    else:
-        for x in seq:
-            inter()
-            f(x)
-
-class Unparser:
-    """Methods in this class recursively traverse an AST and
-    output source code for the abstract syntax; original formatting
-    is disregarged. """
-
-    def __init__(self, tree, file = sys.stdout):
-        """Unparser(tree, file=sys.stdout) -> None.
-         Print the source for tree to file."""
-        self.f = file
-        self._indent = 0
-        self.dispatch(tree)
-        print("", file=self.f)
-        self.f.flush()
-
-    def fill(self, text = ""):
-        "Indent a piece of text, according to the current indentation level"
-        self.f.write("\n"+"    "*self._indent + text)
-
-    def write(self, text):
-        "Append a piece of text to the current line."
-        self.f.write(text)
-
-    def enter(self):
-        "Print ':', and increase the indentation."
-        self.write(":")
-        self._indent += 1
-
-    def leave(self):
-        "Decrease the indentation level."
-        self._indent -= 1
-
-    def dispatch(self, tree):
-        "Dispatcher function, dispatching tree type T to method _T."
-        if isinstance(tree, list):
-            for t in tree:
-                self.dispatch(t)
-            return
-        meth = getattr(self, "_"+tree.__class__.__name__)
-        meth(tree)
-
-
-    ############### Unparsing methods ######################
-    # There should be one method per concrete grammar type #
-    # Constructors should be grouped by sum type. Ideally, #
-    # this would follow the order in the grammar, but      #
-    # currently doesn't.                                   #
-    ########################################################
-
-    def _Module(self, tree):
-        for stmt in tree.body:
-            self.dispatch(stmt)
-
-    # stmt
-    def _Expr(self, tree):
-        self.fill()
-        self.dispatch(tree.value)
-
-    def _Import(self, t):
-        self.fill("import ")
-        interleave(lambda: self.write(", "), self.dispatch, t.names)
-
-    def _ImportFrom(self, t):
-        self.fill("from ")
-        self.write(t.module)
-        self.write(" import ")
-        interleave(lambda: self.write(", "), self.dispatch, t.names)
-        # XXX(jpe) what is level for?
-
-    def _Assign(self, t):
-        self.fill()
-        for target in t.targets:
-            self.dispatch(target)
-            self.write(" = ")
-        self.dispatch(t.value)
-
-    def _AugAssign(self, t):
-        self.fill()
-        self.dispatch(t.target)
-        self.write(" "+self.binop[t.op.__class__.__name__]+"= ")
-        self.dispatch(t.value)
-
-    def _Return(self, t):
-        self.fill("return")
-        if t.value:
-            self.write(" ")
-            self.dispatch(t.value)
-
-    def _Pass(self, t):
-        self.fill("pass")
-
-    def _Break(self, t):
-        self.fill("break")
-
-    def _Continue(self, t):
-        self.fill("continue")
-
-    def _Delete(self, t):
-        self.fill("del ")
-        self.dispatch(t.targets)
-
-    def _Assert(self, t):
-        self.fill("assert ")
-        self.dispatch(t.test)
-        if t.msg:
-            self.write(", ")
-            self.dispatch(t.msg)
-
-    def _Print(self, t):
-        self.fill("print ")
-        do_comma = False
-        if t.dest:
-            self.write(">>")
-            self.dispatch(t.dest)
-            do_comma = True
-        for e in t.values:
-            if do_comma:self.write(", ")
-            else:do_comma=True
-            self.dispatch(e)
-        if not t.nl:
-            self.write(",")
-
-    def _Global(self, t):
-        self.fill("global ")
-        interleave(lambda: self.write(", "), self.write, t.names)
-
-    def _Yield(self, t):
-        self.write("(")
-        self.write("yield")
-        if t.value:
-            self.write(" ")
-            self.dispatch(t.value)
-        self.write(")")
-
-    def _Raise(self, t):
-        self.fill('raise ')
-        if t.type:
-            self.dispatch(t.type)
-        if t.inst:
-            self.write(", ")
-            self.dispatch(t.inst)
-        if t.tback:
-            self.write(", ")
-            self.dispatch(t.tback)
-
-    def _TryExcept(self, t):
-        self.fill("try")
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-
-        for ex in t.handlers:
-            self.dispatch(ex)
-        if t.orelse:
-            self.fill("else")
-            self.enter()
-            self.dispatch(t.orelse)
-            self.leave()
-
-    def _TryFinally(self, t):
-        self.fill("try")
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-
-        self.fill("finally")
-        self.enter()
-        self.dispatch(t.finalbody)
-        self.leave()
-
-    def _ExceptHandler(self, t):
-        self.fill("except")
-        if t.type:
-            self.write(" ")
-            self.dispatch(t.type)
-        if t.name:
-            self.write(", ")
-            self.dispatch(t.name)
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-
-    def _ClassDef(self, t):
-        self.write("\n")
-        self.fill("class "+t.name)
-        if t.bases:
-            self.write("(")
-            for a in t.bases:
-                self.dispatch(a)
-                self.write(", ")
-            self.write(")")
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-
-    def _FunctionDef(self, t):
-        self.write("\n")
-        for deco in t.decorator_list:
-            self.fill("@")
-            self.dispatch(deco)
-        self.fill("def "+t.name + "(")
-        self.dispatch(t.args)
-        self.write(")")
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-
-    def _For(self, t):
-        self.fill("for ")
-        self.dispatch(t.target)
-        self.write(" in ")
-        self.dispatch(t.iter)
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-        if t.orelse:
-            self.fill("else")
-            self.enter()
-            self.dispatch(t.orelse)
-            self.leave
-
-    def _If(self, t):
-        self.fill("if ")
-        self.dispatch(t.test)
-        self.enter()
-        # XXX elif?
-        self.dispatch(t.body)
-        self.leave()
-        if t.orelse:
-            self.fill("else")
-            self.enter()
-            self.dispatch(t.orelse)
-            self.leave()
-
-    def _While(self, t):
-        self.fill("while ")
-        self.dispatch(t.test)
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-        if t.orelse:
-            self.fill("else")
-            self.enter()
-            self.dispatch(t.orelse)
-            self.leave
-
-    def _With(self, t):
-        self.fill("with ")
-        self.dispatch(t.context_expr)
-        if t.optional_vars:
-            self.write(" as ")
-            self.dispatch(t.optional_vars)
-        self.enter()
-        self.dispatch(t.body)
-        self.leave()
-
-    # expr
-    def _Str(self, tree):
-        self.write(repr(tree.s))
-
-    def _Name(self, t):
-        self.write(t.id)
-
-    def _Repr(self, t):
-        self.write("`")
-        self.dispatch(t.value)
-        self.write("`")
-
-    def _Num(self, t):
-        self.write(repr(t.n))
-
-    def _List(self, t):
-        self.write("[")
-        interleave(lambda: self.write(", "), self.dispatch, t.elts)
-        self.write("]")
-
-    def _ListComp(self, t):
-        self.write("[")
-        self.dispatch(t.elt)
-        for gen in t.generators:
-            self.dispatch(gen)
-        self.write("]")
-
-    def _GeneratorExp(self, t):
-        self.write("(")
-        self.dispatch(t.elt)
-        for gen in t.generators:
-            self.dispatch(gen)
-        self.write(")")
-
-    def _comprehension(self, t):
-        self.write(" for ")
-        self.dispatch(t.target)
-        self.write(" in ")
-        self.dispatch(t.iter)
-        for if_clause in t.ifs:
-            self.write(" if ")
-            self.dispatch(if_clause)
-
-    def _IfExp(self, t):
-        self.write("(")
-        self.dispatch(t.body)
-        self.write(" if ")
-        self.dispatch(t.test)
-        self.write(" else ")
-        self.dispatch(t.orelse)
-        self.write(")")
-
-    def _Dict(self, t):
-        self.write("{")
-        def writem(xxx_todo_changeme):
-            (k, v) = xxx_todo_changeme
-            self.dispatch(k)
-            self.write(": ")
-            self.dispatch(v)
-        interleave(lambda: self.write(", "), writem, zip(t.keys, t.values))
-        self.write("}")
-
-    def _Tuple(self, t):
-        self.write("(")
-        if len(t.elts) == 1:
-            (elt,) = t.elts
-            self.dispatch(elt)
-            self.write(",")
-        else:
-            interleave(lambda: self.write(", "), self.dispatch, t.elts)
-        self.write(")")
-
-    unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
-    def _UnaryOp(self, t):
-        self.write(self.unop[t.op.__class__.__name__])
-        self.write("(")
-        self.dispatch(t.operand)
-        self.write(")")
-
-    binop = { "Add":"+", "Sub":"-", "Mult":"*", "Div":"/", "Mod":"%",
-                    "LShift":">>", "RShift":"<<", "BitOr":"|", "BitXor":"^", "BitAnd":"&",
-                    "FloorDiv":"//", "Pow": "**"}
-    def _BinOp(self, t):
-        self.write("(")
-        self.dispatch(t.left)
-        self.write(" " + self.binop[t.op.__class__.__name__] + " ")
-        self.dispatch(t.right)
-        self.write(")")
-
-    cmpops = {"Eq":"==", "NotEq":"!=", "Lt":"<", "LtE":"<=", "Gt":">", "GtE":">=",
-                        "Is":"is", "IsNot":"is not", "In":"in", "NotIn":"not in"}
-    def _Compare(self, t):
-        self.write("(")
-        self.dispatch(t.left)
-        for o, e in zip(t.ops, t.comparators):
-            self.write(" " + self.cmpops[o.__class__.__name__] + " ")
-            self.dispatch(e)
-            self.write(")")
-
-    boolops = {_ast.And: 'and', _ast.Or: 'or'}
-    def _BoolOp(self, t):
-        self.write("(")
-        s = " %s " % self.boolops[t.op.__class__]
-        interleave(lambda: self.write(s), self.dispatch, t.values)
-        self.write(")")
-
-    def _Attribute(self,t):
-        self.dispatch(t.value)
-        self.write(".")
-        self.write(t.attr)
-
-    def _Call(self, t):
-        self.dispatch(t.func)
-        self.write("(")
-        comma = False
-        for e in t.args:
-            if comma: self.write(", ")
-            else: comma = True
-            self.dispatch(e)
-        for e in t.keywords:
-            if comma: self.write(", ")
-            else: comma = True
-            self.dispatch(e)
-        if t.starargs:
-            if comma: self.write(", ")
-            else: comma = True
-            self.write("*")
-            self.dispatch(t.starargs)
-        if t.kwargs:
-            if comma: self.write(", ")
-            else: comma = True
-            self.write("**")
-            self.dispatch(t.kwargs)
-        self.write(")")
-
-    def _Subscript(self, t):
-        self.dispatch(t.value)
-        self.write("[")
-        self.dispatch(t.slice)
-        self.write("]")
-
-    # slice
-    def _Ellipsis(self, t):
-        self.write("...")
-
-    def _Index(self, t):
-        self.dispatch(t.value)
-
-    def _Slice(self, t):
-        if t.lower:
-            self.dispatch(t.lower)
-        self.write(":")
-        if t.upper:
-            self.dispatch(t.upper)
-        if t.step:
-            self.write(":")
-            self.dispatch(t.step)
-
-    def _ExtSlice(self, t):
-        interleave(lambda: self.write(', '), self.dispatch, t.dims)
-
-    # others
-    def _arguments(self, t):
-        first = True
-        nonDef = len(t.args)-len(t.defaults)
-        for a in t.args[0:nonDef]:
-            if first:first = False
-            else: self.write(", ")
-            self.dispatch(a)
-        for a,d in zip(t.args[nonDef:], t.defaults):
-            if first:first = False
-            else: self.write(", ")
-            self.dispatch(a),
-            self.write("=")
-            self.dispatch(d)
-        if t.vararg:
-            if first:first = False
-            else: self.write(", ")
-            self.write("*"+t.vararg)
-        if t.kwarg:
-            if first:first = False
-            else: self.write(", ")
-            self.write("**"+t.kwarg)
-
-    def _keyword(self, t):
-        self.write(t.arg)
-        self.write("=")
-        self.dispatch(t.value)
-
-    def _Lambda(self, t):
-        self.write("lambda ")
-        self.dispatch(t.args)
-        self.write(": ")
-        self.dispatch(t.body)
-
-    def _alias(self, t):
-        self.write(t.name)
-        if t.asname:
-            self.write(" as "+t.asname)
-
-def roundtrip(filename, output=sys.stdout):
-    source = open(filename).read()
-    tree = compile(source, filename, "exec", _ast.PyCF_ONLY_AST)
-    Unparser(tree, output)
-
-
-
-def testdir(a):
-    try:
-        names = [n for n in os.listdir(a) if n.endswith('.py')]
-    except OSError:
-        print("Directory not readable: %s" % a, file=sys.stderr)
-    else:
-        for n in names:
-            fullname = os.path.join(a, n)
-            if os.path.isfile(fullname):
-                output = io.StringIO()
-                print('Testing %s' % fullname)
-                try:
-                    roundtrip(fullname, output)
-                except Exception as e:
-                    print('  Failed to compile, exception is %s' % repr(e))
-            elif os.path.isdir(fullname):
-                testdir(fullname)
-
-def main(args):
-    if args[0] == '--testdir':
-        for a in args[1:]:
-            testdir(a)
-    else:
-        for a in args:
-            roundtrip(a)
-
-if __name__=='__main__':
-    main(sys.argv[1:])
diff --git a/Demo/pdist/FSProxy.py b/Demo/pdist/FSProxy.py
deleted file mode 100755
index 510ac76..0000000
--- a/Demo/pdist/FSProxy.py
+++ /dev/null
@@ -1,322 +0,0 @@
-"""File System Proxy.
-
-Provide an OS-neutral view on a file system, locally or remotely.
-The functionality is geared towards implementing some sort of
-rdist-like utility between a Mac and a UNIX system.
-
-The module defines three classes:
-
-FSProxyLocal  -- used for local access
-FSProxyServer -- used on the server side of remote access
-FSProxyClient -- used on the client side of remote access
-
-The remote classes are instantiated with an IP address and an optional
-verbosity flag.
-"""
-
-import server
-import client
-import md5
-import os
-import fnmatch
-from stat import *
-import time
-import fnmatch
-
-if os.name == 'mac':
-    import macfs
-    maxnamelen = 31
-else:
-    macfs = None
-    maxnamelen = 255
-
-skipnames = (os.curdir, os.pardir)
-
-
-class FSProxyLocal:
-
-    def __init__(self):
-        self._dirstack = []
-        self._ignore = ['*.pyc'] + self._readignore()
-
-    def _close(self):
-        while self._dirstack:
-            self.back()
-
-    def _readignore(self):
-        file = self._hide('ignore')
-        try:
-            f = open(file)
-        except IOError:
-            file = self._hide('synctree.ignorefiles')
-            try:
-                f = open(file)
-            except IOError:
-                return []
-        ignore = []
-        while 1:
-            line = f.readline()
-            if not line: break
-            if line[-1] == '\n': line = line[:-1]
-            ignore.append(line)
-        f.close()
-        return ignore
-
-    def _hidden(self, name):
-        if os.name == 'mac':
-            return name[0] == '(' and name[-1] == ')'
-        else:
-            return name[0] == '.'
-
-    def _hide(self, name):
-        if os.name == 'mac':
-            return '(%s)' % name
-        else:
-            return '.%s' % name
-
-    def visible(self, name):
-        if len(name) > maxnamelen: return 0
-        if name[-1] == '~': return 0
-        if name in skipnames: return 0
-        if self._hidden(name): return 0
-        head, tail = os.path.split(name)
-        if head or not tail: return 0
-        if macfs:
-            if os.path.exists(name) and not os.path.isdir(name):
-                try:
-                    fs = macfs.FSSpec(name)
-                    c, t = fs.GetCreatorType()
-                    if t != 'TEXT': return 0
-                except macfs.error as msg:
-                    print("***", name, msg)
-                    return 0
-        else:
-            if os.path.islink(name): return 0
-            if '\0' in open(name, 'rb').read(512): return 0
-        for ign in self._ignore:
-            if fnmatch.fnmatch(name, ign): return 0
-        return 1
-
-    def check(self, name):
-        if not self.visible(name):
-            raise os.error("protected name %s" % repr(name))
-
-    def checkfile(self, name):
-        self.check(name)
-        if not os.path.isfile(name):
-            raise os.error("not a plain file %s" % repr(name))
-
-    def pwd(self):
-        return os.getcwd()
-
-    def cd(self, name):
-        self.check(name)
-        save = os.getcwd(), self._ignore
-        os.chdir(name)
-        self._dirstack.append(save)
-        self._ignore = self._ignore + self._readignore()
-
-    def back(self):
-        if not self._dirstack:
-            raise os.error("empty directory stack")
-        dir, ignore = self._dirstack[-1]
-        os.chdir(dir)
-        del self._dirstack[-1]
-        self._ignore = ignore
-
-    def _filter(self, files, pat = None):
-        if pat:
-            def keep(name, pat = pat):
-                return fnmatch.fnmatch(name, pat)
-            files = list(filter(keep, files))
-        files = list(filter(self.visible, files))
-        files.sort()
-        return files
-
-    def list(self, pat = None):
-        files = os.listdir(os.curdir)
-        return self._filter(files, pat)
-
-    def listfiles(self, pat = None):
-        files = os.listdir(os.curdir)
-        files = list(filter(os.path.isfile, files))
-        return self._filter(files, pat)
-
-    def listsubdirs(self, pat = None):
-        files = os.listdir(os.curdir)
-        files = list(filter(os.path.isdir, files))
-        return self._filter(files, pat)
-
-    def exists(self, name):
-        return self.visible(name) and os.path.exists(name)
-
-    def isdir(self, name):
-        return self.visible(name) and os.path.isdir(name)
-
-    def islink(self, name):
-        return self.visible(name) and os.path.islink(name)
-
-    def isfile(self, name):
-        return self.visible(name) and os.path.isfile(name)
-
-    def sum(self, name):
-        self.checkfile(name)
-        BUFFERSIZE = 1024*8
-        f = open(name)
-        sum = md5.new()
-        while 1:
-            buffer = f.read(BUFFERSIZE)
-            if not buffer:
-                break
-            sum.update(buffer)
-        return sum.digest()
-
-    def size(self, name):
-        self.checkfile(name)
-        return os.stat(name)[ST_SIZE]
-
-    def mtime(self, name):
-        self.checkfile(name)
-        return time.localtime(os.stat(name)[ST_MTIME])
-
-    def stat(self, name):
-        self.checkfile(name)
-        size = os.stat(name)[ST_SIZE]
-        mtime = time.localtime(os.stat(name)[ST_MTIME])
-        return size, mtime
-
-    def info(self, name):
-        sum = self.sum(name)
-        size = os.stat(name)[ST_SIZE]
-        mtime = time.localtime(os.stat(name)[ST_MTIME])
-        return sum, size, mtime
-
-    def _list(self, function, list):
-        if list is None:
-            list = self.listfiles()
-        res = []
-        for name in list:
-            try:
-                res.append((name, function(name)))
-            except (os.error, IOError):
-                res.append((name, None))
-        return res
-
-    def sumlist(self, list = None):
-        return self._list(self.sum, list)
-
-    def statlist(self, list = None):
-        return self._list(self.stat, list)
-
-    def mtimelist(self, list = None):
-        return self._list(self.mtime, list)
-
-    def sizelist(self, list = None):
-        return self._list(self.size, list)
-
-    def infolist(self, list = None):
-        return self._list(self.info, list)
-
-    def _dict(self, function, list):
-        if list is None:
-            list = self.listfiles()
-        dict = {}
-        for name in list:
-            try:
-                dict[name] = function(name)
-            except (os.error, IOError):
-                pass
-        return dict
-
-    def sumdict(self, list = None):
-        return self.dict(self.sum, list)
-
-    def sizedict(self, list = None):
-        return self.dict(self.size, list)
-
-    def mtimedict(self, list = None):
-        return self.dict(self.mtime, list)
-
-    def statdict(self, list = None):
-        return self.dict(self.stat, list)
-
-    def infodict(self, list = None):
-        return self._dict(self.info, list)
-
-    def read(self, name, offset = 0, length = -1):
-        self.checkfile(name)
-        f = open(name)
-        f.seek(offset)
-        if length == 0:
-            data = ''
-        elif length < 0:
-            data = f.read()
-        else:
-            data = f.read(length)
-        f.close()
-        return data
-
-    def create(self, name):
-        self.check(name)
-        if os.path.exists(name):
-            self.checkfile(name)
-            bname = name + '~'
-            try:
-                os.unlink(bname)
-            except os.error:
-                pass
-            os.rename(name, bname)
-        f = open(name, 'w')
-        f.close()
-
-    def write(self, name, data, offset = 0):
-        self.checkfile(name)
-        f = open(name, 'r+')
-        f.seek(offset)
-        f.write(data)
-        f.close()
-
-    def mkdir(self, name):
-        self.check(name)
-        os.mkdir(name, 0o777)
-
-    def rmdir(self, name):
-        self.check(name)
-        os.rmdir(name)
-
-
-class FSProxyServer(FSProxyLocal, server.Server):
-
-    def __init__(self, address, verbose = server.VERBOSE):
-        FSProxyLocal.__init__(self)
-        server.Server.__init__(self, address, verbose)
-
-    def _close(self):
-        server.Server._close(self)
-        FSProxyLocal._close(self)
-
-    def _serve(self):
-        server.Server._serve(self)
-        # Retreat into start directory
-        while self._dirstack: self.back()
-
-
-class FSProxyClient(client.Client):
-
-    def __init__(self, address, verbose = client.VERBOSE):
-        client.Client.__init__(self, address, verbose)
-
-
-def test():
-    import string
-    import sys
-    if sys.argv[1:]:
-        port = string.atoi(sys.argv[1])
-    else:
-        port = 4127
-    proxy = FSProxyServer(('', port))
-    proxy._serverloop()
-
-
-if __name__ == '__main__':
-    test()
diff --git a/Demo/pdist/RCSProxy.py b/Demo/pdist/RCSProxy.py
deleted file mode 100755
index 7c3b24f..0000000
--- a/Demo/pdist/RCSProxy.py
+++ /dev/null
@@ -1,198 +0,0 @@
-#! /usr/bin/env python
-
-"""RCS Proxy.
-
-Provide a simplified interface on RCS files, locally or remotely.
-The functionality is geared towards implementing some sort of
-remote CVS like utility.  It is modeled after the similar module
-FSProxy.
-
-The module defines two classes:
-
-RCSProxyLocal  -- used for local access
-RCSProxyServer -- used on the server side of remote access
-
-The corresponding client class, RCSProxyClient, is defined in module
-rcsclient.
-
-The remote classes are instantiated with an IP address and an optional
-verbosity flag.
-"""
-
-import server
-import md5
-import os
-import fnmatch
-import string
-import tempfile
-import rcslib
-
-
-class DirSupport:
-
-    def __init__(self):
-        self._dirstack = []
-
-    def __del__(self):
-        self._close()
-
-    def _close(self):
-        while self._dirstack:
-            self.back()
-
-    def pwd(self):
-        return os.getcwd()
-
-    def cd(self, name):
-        save = os.getcwd()
-        os.chdir(name)
-        self._dirstack.append(save)
-
-    def back(self):
-        if not self._dirstack:
-            raise os.error("empty directory stack")
-        dir = self._dirstack[-1]
-        os.chdir(dir)
-        del self._dirstack[-1]
-
-    def listsubdirs(self, pat = None):
-        files = os.listdir(os.curdir)
-        files = list(filter(os.path.isdir, files))
-        return self._filter(files, pat)
-
-    def isdir(self, name):
-        return os.path.isdir(name)
-
-    def mkdir(self, name):
-        os.mkdir(name, 0o777)
-
-    def rmdir(self, name):
-        os.rmdir(name)
-
-
-class RCSProxyLocal(rcslib.RCS, DirSupport):
-
-    def __init__(self):
-        rcslib.RCS.__init__(self)
-        DirSupport.__init__(self)
-
-    def __del__(self):
-        DirSupport.__del__(self)
-        rcslib.RCS.__del__(self)
-
-    def sumlist(self, list = None):
-        return self._list(self.sum, list)
-
-    def sumdict(self, list = None):
-        return self._dict(self.sum, list)
-
-    def sum(self, name_rev):
-        f = self._open(name_rev)
-        BUFFERSIZE = 1024*8
-        sum = md5.new()
-        while 1:
-            buffer = f.read(BUFFERSIZE)
-            if not buffer:
-                break
-            sum.update(buffer)
-        self._closepipe(f)
-        return sum.digest()
-
-    def get(self, name_rev):
-        f = self._open(name_rev)
-        data = f.read()
-        self._closepipe(f)
-        return data
-
-    def put(self, name_rev, data, message=None):
-        name, rev = self._unmangle(name_rev)
-        f = open(name, 'w')
-        f.write(data)
-        f.close()
-        self.checkin(name_rev, message)
-        self._remove(name)
-
-    def _list(self, function, list = None):
-        """INTERNAL: apply FUNCTION to all files in LIST.
-
-        Return a list of the results.
-
-        The list defaults to all files in the directory if None.
-
-        """
-        if list is None:
-            list = self.listfiles()
-        res = []
-        for name in list:
-            try:
-                res.append((name, function(name)))
-            except (os.error, IOError):
-                res.append((name, None))
-        return res
-
-    def _dict(self, function, list = None):
-        """INTERNAL: apply FUNCTION to all files in LIST.
-
-        Return a dictionary mapping files to results.
-
-        The list defaults to all files in the directory if None.
-
-        """
-        if list is None:
-            list = self.listfiles()
-        dict = {}
-        for name in list:
-            try:
-                dict[name] = function(name)
-            except (os.error, IOError):
-                pass
-        return dict
-
-
-class RCSProxyServer(RCSProxyLocal, server.SecureServer):
-
-    def __init__(self, address, verbose = server.VERBOSE):
-        RCSProxyLocal.__init__(self)
-        server.SecureServer.__init__(self, address, verbose)
-
-    def _close(self):
-        server.SecureServer._close(self)
-        RCSProxyLocal._close(self)
-
-    def _serve(self):
-        server.SecureServer._serve(self)
-        # Retreat into start directory
-        while self._dirstack: self.back()
-
-
-def test_server():
-    import string
-    import sys
-    if sys.argv[1:]:
-        port = string.atoi(sys.argv[1])
-    else:
-        port = 4127
-    proxy = RCSProxyServer(('', port))
-    proxy._serverloop()
-
-
-def test():
-    import sys
-    if not sys.argv[1:] or sys.argv[1] and sys.argv[1][0] in '0123456789':
-        test_server()
-        sys.exit(0)
-    proxy = RCSProxyLocal()
-    what = sys.argv[1]
-    if hasattr(proxy, what):
-        attr = getattr(proxy, what)
-        if hasattr(attr, '__call__'):
-            print(attr(*sys.argv[2:]))
-        else:
-            print(repr(attr))
-    else:
-        print("%s: no such attribute" % what)
-        sys.exit(2)
-
-
-if __name__ == '__main__':
-    test()
diff --git a/Demo/pdist/README b/Demo/pdist/README
deleted file mode 100644
index b3fac24..0000000
--- a/Demo/pdist/README
+++ /dev/null
@@ -1,121 +0,0 @@
-Filesystem, RCS and CVS client and server classes
-=================================================
-
-*** See the security warning at the end of this file! ***
-
-This directory contains various modules and classes that support
-remote file system operations.
-
-CVS stuff
----------
-
-rcvs			Script to put in your bin directory
-rcvs.py			Remote CVS client command line interface
-
-cvslib.py		CVS admin files classes (used by rrcs)
-cvslock.py		CVS locking algorithms
-
-RCS stuff
----------
-
-rrcs			Script to put in your bin directory
-rrcs.py			Remote RCS client command line interface
-
-rcsclient.py		Return an RCSProxyClient instance
-			(has reasonable default server/port/directory)
-
-RCSProxy.py		RCS proxy and server classes (on top of rcslib.py)
-
-rcslib.py		Local-only RCS base class (affects stdout &
-			local work files)
-
-FSProxy stuff
--------------
-
-sumtree.py		Old demo for FSProxy
-cmptree.py		First FSProxy client (used to sync from the Mac)
-FSProxy.py		Filesystem interface classes
-
-Generic client/server stuff
----------------------------
-
-client.py		Client class
-server.py		Server class
-
-security.py		Security mix-in class (not very secure I think)
-
-Other generic stuff
--------------------
-
-cmdfw.py		CommandFrameWork class
-			(used by rcvs, should be used by rrcs as well)
-
-
-Client/Server operation
------------------------
-
-The Client and Server classes implement a simple-minded RPC protocol,
-using Python's pickle module to transfer arguments, return values and
-exceptions with the most generality.  The Server class is instantiated
-with a port number on which it should listen for requests; the Client
-class is instantiated with a host name and a port number where it
-should connect to.  Once a client is connected, a TCP connection is
-maintained between client and server.
-
-The Server class currently handles only one connection at a time;
-however it could be rewritten to allow various modes of operations,
-using multiple threads or processes or the select() system call as
-desired to serve multiple clients simultaneously (when using select(),
-still handling one request at a time).  This would not require
-rewriting of the Client class.  It may also be possible to adapt the
-code to use UDP instead of TCP, but then both classes will have to be
-rewritten (and unless extensive acknowlegements and request serial
-numbers are used, the server should handle duplicate requests, so its
-semantics should be idempotent -- shrudder).
-
-Even though the FSProxy and RCSProxy modules define client classes,
-the client class is fully generic -- what methods it supports is
-determined entirely by the server.  The server class, however, must be
-derived from.  This is generally done as follows:
-
-	from server import Server
-	from client import Client
-
-	# Define a class that performs the operations locally
-	class MyClassLocal:
-		def __init__(self): ...
-		def _close(self): ...
-
-	# Derive a server class using multiple inheritance
-	class MyClassServer(MyClassLocal, Server):
-		def __init__(self, address):
-			# Must initialize MyClassLocal as well as Server
-			MyClassLocal.__init__(self)
-			Server.__init__(self, address)
-		def _close(self):
-			Server._close()
-			MyClassLocal._close()
-
-	# A dummy client class
-	class MyClassClient(Client): pass
-
-Note that because MyClassLocal isn't used in the definition of
-MyClassClient, it would actually be better to place it in a separate
-module so the definition of MyClassLocal isn't executed when we only
-instantiate a client.
-
-The modules client and server should probably be renamed to Client and
-Server in order to match the class names.
-
-
-*** Security warning: this version requires that you have a file
-$HOME/.python_keyfile at the server and client side containing two
-comma- separated numbers.  The security system at the moment makes no
-guarantees of actuallng being secure -- however it requires that the
-key file exists and contains the same numbers at both ends for this to
-work.  (You can specify an alternative keyfile in $PYTHON_KEYFILE).
-Have a look at the Security class in security.py for details;
-basically, if the key file contains (x, y), then the security server
-class chooses a random number z (the challenge) in the range
-10..100000 and the client must be able to produce pow(z, x, y)
-(i.e. z**x mod y).
diff --git a/Demo/pdist/client.py b/Demo/pdist/client.py
deleted file mode 100755
index c9fe369..0000000
--- a/Demo/pdist/client.py
+++ /dev/null
@@ -1,156 +0,0 @@
-"""RPC Client module."""
-
-import sys
-import socket
-import pickle
-import builtins
-import os
-
-
-# Default verbosity (0 = silent, 1 = print connections, 2 = print requests too)
-VERBOSE = 1
-
-
-class Client:
-
-    """RPC Client class.  No need to derive a class -- it's fully generic."""
-
-    def __init__(self, address, verbose = VERBOSE):
-        self._pre_init(address, verbose)
-        self._post_init()
-
-    def _pre_init(self, address, verbose = VERBOSE):
-        if type(address) == type(0):
-            address = ('', address)
-        self._address = address
-        self._verbose = verbose
-        if self._verbose: print("Connecting to %s ..." % repr(address))
-        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self._socket.connect(address)
-        if self._verbose: print("Connected.")
-        self._lastid = 0 # Last id for which a reply has been received
-        self._nextid = 1 # Id of next request
-        self._replies = {} # Unprocessed replies
-        self._rf = self._socket.makefile('r')
-        self._wf = self._socket.makefile('w')
-
-    def _post_init(self):
-        self._methods = self._call('.methods')
-
-    def __del__(self):
-        self._close()
-
-    def _close(self):
-        if self._rf: self._rf.close()
-        self._rf = None
-        if self._wf: self._wf.close()
-        self._wf = None
-        if self._socket: self._socket.close()
-        self._socket = None
-
-    def __getattr__(self, name):
-        if name in self._methods:
-            method = _stub(self, name)
-            setattr(self, name, method) # XXX circular reference
-            return method
-        raise AttributeError(name)
-
-    def _setverbose(self, verbose):
-        self._verbose = verbose
-
-    def _call(self, name, *args):
-        return self._vcall(name, args)
-
-    def _vcall(self, name, args):
-        return self._recv(self._vsend(name, args))
-
-    def _send(self, name, *args):
-        return self._vsend(name, args)
-
-    def _send_noreply(self, name, *args):
-        return self._vsend(name, args, 0)
-
-    def _vsend_noreply(self, name, args):
-        return self._vsend(name, args, 0)
-
-    def _vsend(self, name, args, wantreply = 1):
-        id = self._nextid
-        self._nextid = id+1
-        if not wantreply: id = -id
-        request = (name, args, id)
-        if self._verbose > 1: print("sending request: %s" % repr(request))
-        wp = pickle.Pickler(self._wf)
-        wp.dump(request)
-        return id
-
-    def _recv(self, id):
-        exception, value, rid = self._vrecv(id)
-        if rid != id:
-            raise RuntimeError("request/reply id mismatch: %d/%d" % (id, rid))
-        if exception is None:
-            return value
-        x = exception
-        if hasattr(builtins, exception):
-            x = getattr(builtins, exception)
-        elif exception in ('posix.error', 'mac.error'):
-            x = os.error
-        if x == exception:
-            exception = x
-        raise exception(value)
-
-    def _vrecv(self, id):
-        self._flush()
-        if id in self._replies:
-            if self._verbose > 1: print("retrieving previous reply, id = %d" % id)
-            reply = self._replies[id]
-            del self._replies[id]
-            return reply
-        aid = abs(id)
-        while 1:
-            if self._verbose > 1: print("waiting for reply, id = %d" % id)
-            rp = pickle.Unpickler(self._rf)
-            reply = rp.load()
-            del rp
-            if self._verbose > 1: print("got reply: %s" % repr(reply))
-            rid = reply[2]
-            arid = abs(rid)
-            if arid == aid:
-                if self._verbose > 1: print("got it")
-                return reply
-            self._replies[rid] = reply
-            if arid > aid:
-                if self._verbose > 1: print("got higher id, assume all ok")
-                return (None, None, id)
-
-    def _flush(self):
-        self._wf.flush()
-
-
-from security import Security
-
-
-class SecureClient(Client, Security):
-
-    def __init__(self, *args):
-        self._pre_init(*args)
-        Security.__init__(self)
-        self._wf.flush()
-        line = self._rf.readline()
-        challenge = int(line.strip())
-        response = self._encode_challenge(challenge)
-        line = repr(int(response))
-        if line[-1] in 'Ll': line = line[:-1]
-        self._wf.write(line + '\n')
-        self._wf.flush()
-        self._post_init()
-
-class _stub:
-
-    """Helper class for Client -- each instance serves as a method of the client."""
-
-    def __init__(self, client, name):
-        self._client = client
-        self._name = name
-
-    def __call__(self, *args):
-        return self._client._vcall(self._name, args)
diff --git a/Demo/pdist/cmdfw.py b/Demo/pdist/cmdfw.py
deleted file mode 100755
index ec854b1..0000000
--- a/Demo/pdist/cmdfw.py
+++ /dev/null
@@ -1,142 +0,0 @@
-"Framework for command line interfaces like CVS.  See class CmdFrameWork."
-
-
-class CommandFrameWork:
-
-    """Framework class for command line interfaces like CVS.
-
-    The general command line structure is
-
-            command [flags] subcommand [subflags] [argument] ...
-
-    There's a class variable GlobalFlags which specifies the
-    global flags options.  Subcommands are defined by defining
-    methods named do_<subcommand>.  Flags for the subcommand are
-    defined by defining class or instance variables named
-    flags_<subcommand>.  If there's no command, method default()
-    is called.  The __doc__ strings for the do_ methods are used
-    for the usage message, printed after the general usage message
-    which is the class variable UsageMessage.  The class variable
-    PostUsageMessage is printed after all the do_ methods' __doc__
-    strings.  The method's return value can be a suggested exit
-    status.  [XXX Need to rewrite this to clarify it.]
-
-    Common usage is to derive a class, instantiate it, and then call its
-    run() method; by default this takes its arguments from sys.argv[1:].
-    """
-
-    UsageMessage = \
-      "usage: (name)s [flags] subcommand [subflags] [argument] ..."
-
-    PostUsageMessage = None
-
-    GlobalFlags = ''
-
-    def __init__(self):
-        """Constructor, present for completeness."""
-        pass
-
-    def run(self, args = None):
-        """Process flags, subcommand and options, then run it."""
-        import getopt, sys
-        if args is None: args = sys.argv[1:]
-        try:
-            opts, args = getopt.getopt(args, self.GlobalFlags)
-        except getopt.error as msg:
-            return self.usage(msg)
-        self.options(opts)
-        if not args:
-            self.ready()
-            return self.default()
-        else:
-            cmd = args[0]
-            mname = 'do_' + cmd
-            fname = 'flags_' + cmd
-            try:
-                method = getattr(self, mname)
-            except AttributeError:
-                return self.usage("command %r unknown" % (cmd,))
-            try:
-                flags = getattr(self, fname)
-            except AttributeError:
-                flags = ''
-            try:
-                opts, args = getopt.getopt(args[1:], flags)
-            except getopt.error as msg:
-                return self.usage(
-                        "subcommand %s: " % cmd + str(msg))
-            self.ready()
-            return method(opts, args)
-
-    def options(self, opts):
-        """Process the options retrieved by getopt.
-        Override this if you have any options."""
-        if opts:
-            print("-"*40)
-            print("Options:")
-            for o, a in opts:
-                print('option', o, 'value', repr(a))
-            print("-"*40)
-
-    def ready(self):
-        """Called just before calling the subcommand."""
-        pass
-
-    def usage(self, msg = None):
-        """Print usage message.  Return suitable exit code (2)."""
-        if msg: print(msg)
-        print(self.UsageMessage % {'name': self.__class__.__name__})
-        docstrings = {}
-        c = self.__class__
-        while 1:
-            for name in dir(c):
-                if name[:3] == 'do_':
-                    if name in docstrings:
-                        continue
-                    try:
-                        doc = getattr(c, name).__doc__
-                    except:
-                        doc = None
-                    if doc:
-                        docstrings[name] = doc
-            if not c.__bases__:
-                break
-            c = c.__bases__[0]
-        if docstrings:
-            print("where subcommand can be:")
-            for name in sorted(docstrings.keys()):
-                print(docstrings[name])
-        if self.PostUsageMessage:
-            print(self.PostUsageMessage)
-        return 2
-
-    def default(self):
-        """Default method, called when no subcommand is given.
-        You should always override this."""
-        print("Nobody expects the Spanish Inquisition!")
-
-
-def test():
-    """Test script -- called when this module is run as a script."""
-    import sys
-    class Hello(CommandFrameWork):
-        def do_hello(self, opts, args):
-            "hello -- print 'hello world', needs no arguments"
-            print("Hello, world")
-    x = Hello()
-    tests = [
-            [],
-            ['hello'],
-            ['spam'],
-            ['-x'],
-            ['hello', '-x'],
-            None,
-            ]
-    for t in tests:
-        print('-'*10, t, '-'*10)
-        sts = x.run(t)
-        print("Exit status:", repr(sts))
-
-
-if __name__ == '__main__':
-    test()
diff --git a/Demo/pdist/cmptree.py b/Demo/pdist/cmptree.py
deleted file mode 100755
index c1bbf1a..0000000
--- a/Demo/pdist/cmptree.py
+++ /dev/null
@@ -1,213 +0,0 @@
-"""Compare local and remote dictionaries and transfer differing files -- like rdist."""
-
-import sys
-from reprlib import repr
-import FSProxy
-import time
-import os
-
-def raw_input(prompt):
-    sys.stdout.write(prompt)
-    sys.stdout.flush()
-    return sys.stdin.readline()
-
-def main():
-    pwd = os.getcwd()
-    s = input("chdir [%s] " % pwd)
-    if s:
-        os.chdir(s)
-        pwd = os.getcwd()
-    host = ask("host", 'voorn.cwi.nl')
-    port = 4127
-    verbose = 1
-    mode = ''
-    print("""\
-Mode should be a string of characters, indicating what to do with differences.
-r - read different files to local file system
-w - write different files to remote file system
-c - create new files, either remote or local
-d - delete disappearing files, either remote or local
-""")
-    s = input("mode [%s] " % mode)
-    if s: mode = s
-    address = (host, port)
-    t1 = time.time()
-    local = FSProxy.FSProxyLocal()
-    remote = FSProxy.FSProxyClient(address, verbose)
-    compare(local, remote, mode)
-    remote._close()
-    local._close()
-    t2 = time.time()
-    dt = t2-t1
-    mins, secs = divmod(dt, 60)
-    print(mins, "minutes and", round(secs), "seconds")
-    input("[Return to exit] ")
-
-def ask(prompt, default):
-    s = input("%s [%s] " % (prompt, default))
-    return s or default
-
-def askint(prompt, default):
-    s = input("%s [%s] " % (prompt, str(default)))
-    if s: return string.atoi(s)
-    return default
-
-def compare(local, remote, mode):
-    print()
-    print("PWD =", repr(os.getcwd()))
-    sums_id = remote._send('sumlist')
-    subdirs_id = remote._send('listsubdirs')
-    remote._flush()
-    print("calculating local sums ...")
-    lsumdict = {}
-    for name, info in local.sumlist():
-        lsumdict[name] = info
-    print("getting remote sums ...")
-    sums = remote._recv(sums_id)
-    print("got", len(sums))
-    rsumdict = {}
-    for name, rsum in sums:
-        rsumdict[name] = rsum
-        if name not in lsumdict:
-            print(repr(name), "only remote")
-            if 'r' in mode and 'c' in mode:
-                recvfile(local, remote, name)
-        else:
-            lsum = lsumdict[name]
-            if lsum != rsum:
-                print(repr(name), end=' ')
-                rmtime = remote.mtime(name)
-                lmtime = local.mtime(name)
-                if rmtime > lmtime:
-                    print("remote newer", end=' ')
-                    if 'r' in mode:
-                        recvfile(local, remote, name)
-                elif lmtime > rmtime:
-                    print("local newer", end=' ')
-                    if 'w' in mode:
-                        sendfile(local, remote, name)
-                else:
-                    print("same mtime but different sum?!?!", end=' ')
-                print()
-    for name in lsumdict.keys():
-        if not list(rsumdict.keys()):
-            print(repr(name), "only locally", end=' ')
-            fl()
-            if 'w' in mode and 'c' in mode:
-                sendfile(local, remote, name)
-            elif 'r' in mode and 'd' in mode:
-                os.unlink(name)
-                print("removed.")
-            print()
-    print("gettin subdirs ...")
-    subdirs = remote._recv(subdirs_id)
-    common = []
-    for name in subdirs:
-        if local.isdir(name):
-            print("Common subdirectory", repr(name))
-            common.append(name)
-        else:
-            print("Remote subdirectory", repr(name), "not found locally")
-            if 'r' in mode and 'c' in mode:
-                pr = "Create local subdirectory %s? [y] " % \
-                     repr(name)
-                if 'y' in mode:
-                    ok = 'y'
-                else:
-                    ok = ask(pr, "y")
-                if ok[:1] in ('y', 'Y'):
-                    local.mkdir(name)
-                    print("Subdirectory %s made" % \
-                            repr(name))
-                    common.append(name)
-    lsubdirs = local.listsubdirs()
-    for name in lsubdirs:
-        if name not in subdirs:
-            print("Local subdirectory", repr(name), "not found remotely")
-    for name in common:
-        print("Entering subdirectory", repr(name))
-        local.cd(name)
-        remote.cd(name)
-        compare(local, remote, mode)
-        remote.back()
-        local.back()
-
-def sendfile(local, remote, name):
-    try:
-        remote.create(name)
-    except (IOError, os.error) as msg:
-        print("cannot create:", msg)
-        return
-
-    print("sending ...", end=' ')
-    fl()
-
-    data = open(name).read()
-
-    t1 = time.time()
-
-    remote._send_noreply('write', name, data)
-    remote._flush()
-
-    t2 = time.time()
-
-    dt = t2-t1
-    print(len(data), "bytes in", round(dt), "seconds", end=' ')
-    if dt:
-        print("i.e.", round(len(data)/dt), "bytes/sec", end=' ')
-    print()
-
-def recvfile(local, remote, name):
-    ok = 0
-    try:
-        rv = recvfile_real(local, remote, name)
-        ok = 1
-        return rv
-    finally:
-        if not ok:
-            print("*** recvfile of %r failed, deleting" % (name,))
-            local.delete(name)
-
-def recvfile_real(local, remote, name):
-    try:
-        local.create(name)
-    except (IOError, os.error) as msg:
-        print("cannot create:", msg)
-        return
-
-    print("receiving ...", end=' ')
-    fl()
-
-    f = open(name, 'w')
-    t1 = time.time()
-
-    length = 4*1024
-    offset = 0
-    id = remote._send('read', name, offset, length)
-    remote._flush()
-    while 1:
-        newoffset = offset + length
-        newid = remote._send('read', name, newoffset, length)
-        data = remote._recv(id)
-        id = newid
-        if not data: break
-        f.seek(offset)
-        f.write(data)
-        offset = newoffset
-    size = f.tell()
-
-    t2 = time.time()
-    f.close()
-
-    dt = t2-t1
-    print(size, "bytes in", round(dt), "seconds", end=' ')
-    if dt:
-        print("i.e.", int(size//dt), "bytes/sec", end=' ')
-    print()
-    remote._recv(id) # ignored
-
-def fl():
-    sys.stdout.flush()
-
-if __name__ == '__main__':
-    main()
diff --git a/Demo/pdist/cvslib.py b/Demo/pdist/cvslib.py
deleted file mode 100755
index 78e4fbb..0000000
--- a/Demo/pdist/cvslib.py
+++ /dev/null
@@ -1,359 +0,0 @@
-"""Utilities for CVS administration."""
-
-import string
-import os
-import time
-import md5
-import fnmatch
-
-if not hasattr(time, 'timezone'):
-    time.timezone = 0
-
-class File:
-
-    """Represent a file's status.
-
-    Instance variables:
-
-    file -- the filename (no slashes), None if uninitialized
-    lseen -- true if the data for the local file is up to date
-    eseen -- true if the data from the CVS/Entries entry is up to date
-             (this implies that the entry must be written back)
-    rseen -- true if the data for the remote file is up to date
-    proxy -- RCSProxy instance used to contact the server, or None
-
-    Note that lseen and rseen don't necessary mean that a local
-    or remote file *exists* -- they indicate that we've checked it.
-    However, eseen means that this instance corresponds to an
-    entry in the CVS/Entries file.
-
-    If lseen is true:
-
-    lsum -- checksum of the local file, None if no local file
-    lctime -- ctime of the local file, None if no local file
-    lmtime -- mtime of the local file, None if no local file
-
-    If eseen is true:
-
-    erev -- revision, None if this is a no revision (not '0')
-    enew -- true if this is an uncommitted added file
-    edeleted -- true if this is an uncommitted removed file
-    ectime -- ctime of last local file corresponding to erev
-    emtime -- mtime of last local file corresponding to erev
-    extra -- 5th string from CVS/Entries file
-
-    If rseen is true:
-
-    rrev -- revision of head, None if non-existent
-    rsum -- checksum of that revision, Non if non-existent
-
-    If eseen and rseen are both true:
-
-    esum -- checksum of revision erev, None if no revision
-
-    Note
-    """
-
-    def __init__(self, file = None):
-        if file and '/' in file:
-            raise ValueError("no slash allowed in file")
-        self.file = file
-        self.lseen = self.eseen = self.rseen = 0
-        self.proxy = None
-
-    def __cmp__(self, other):
-        return cmp(self.file, other.file)
-
-    def getlocal(self):
-        try:
-            self.lmtime, self.lctime = os.stat(self.file)[-2:]
-        except os.error:
-            self.lmtime = self.lctime = self.lsum = None
-        else:
-            self.lsum = md5.new(open(self.file).read()).digest()
-        self.lseen = 1
-
-    def getentry(self, line):
-        words = string.splitfields(line, '/')
-        if self.file and words[1] != self.file:
-            raise ValueError("file name mismatch")
-        self.file = words[1]
-        self.erev = words[2]
-        self.edeleted = 0
-        self.enew = 0
-        self.ectime = self.emtime = None
-        if self.erev[:1] == '-':
-            self.edeleted = 1
-            self.erev = self.erev[1:]
-        if self.erev == '0':
-            self.erev = None
-            self.enew = 1
-        else:
-            dates = words[3]
-            self.ectime = unctime(dates[:24])
-            self.emtime = unctime(dates[25:])
-        self.extra = words[4]
-        if self.rseen:
-            self.getesum()
-        self.eseen = 1
-
-    def getremote(self, proxy = None):
-        if proxy:
-            self.proxy = proxy
-        try:
-            self.rrev = self.proxy.head(self.file)
-        except (os.error, IOError):
-            self.rrev = None
-        if self.rrev:
-            self.rsum = self.proxy.sum(self.file)
-        else:
-            self.rsum = None
-        if self.eseen:
-            self.getesum()
-        self.rseen = 1
-
-    def getesum(self):
-        if self.erev == self.rrev:
-            self.esum = self.rsum
-        elif self.erev:
-            name = (self.file, self.erev)
-            self.esum = self.proxy.sum(name)
-        else:
-            self.esum = None
-
-    def putentry(self):
-        """Return a line suitable for inclusion in CVS/Entries.
-
-        The returned line is terminated by a newline.
-        If no entry should be written for this file,
-        return "".
-        """
-        if not self.eseen:
-            return ""
-
-        rev = self.erev or '0'
-        if self.edeleted:
-            rev = '-' + rev
-        if self.enew:
-            dates = 'Initial ' + self.file
-        else:
-            dates = gmctime(self.ectime) + ' ' + \
-                    gmctime(self.emtime)
-        return "/%s/%s/%s/%s/\n" % (
-                self.file,
-                rev,
-                dates,
-                self.extra)
-
-    def report(self):
-        print('-'*50)
-        def r(key, repr=repr, self=self):
-            try:
-                value = repr(getattr(self, key))
-            except AttributeError:
-                value = "?"
-            print("%-15s:" % key, value)
-        r("file")
-        if self.lseen:
-            r("lsum", hexify)
-            r("lctime", gmctime)
-            r("lmtime", gmctime)
-        if self.eseen:
-            r("erev")
-            r("enew")
-            r("edeleted")
-            r("ectime", gmctime)
-            r("emtime", gmctime)
-        if self.rseen:
-            r("rrev")
-            r("rsum", hexify)
-            if self.eseen:
-                r("esum", hexify)
-
-
-class CVS:
-
-    """Represent the contents of a CVS admin file (and more).
-
-    Class variables:
-
-    FileClass -- the class to be instantiated for entries
-                 (this should be derived from class File above)
-    IgnoreList -- shell patterns for local files to be ignored
-
-    Instance variables:
-
-    entries -- a dictionary containing File instances keyed by
-               their file name
-    proxy -- an RCSProxy instance, or None
-    """
-
-    FileClass = File
-
-    IgnoreList = ['.*', '@*', ',*', '*~', '*.o', '*.a', '*.so', '*.pyc']
-
-    def __init__(self):
-        self.entries = {}
-        self.proxy = None
-
-    def setproxy(self, proxy):
-        if proxy is self.proxy:
-            return
-        self.proxy = proxy
-        for e in list(self.entries.values()):
-            e.rseen = 0
-
-    def getentries(self):
-        """Read the contents of CVS/Entries"""
-        self.entries = {}
-        f = self.cvsopen("Entries")
-        while 1:
-            line = f.readline()
-            if not line: break
-            e = self.FileClass()
-            e.getentry(line)
-            self.entries[e.file] = e
-        f.close()
-
-    def putentries(self):
-        """Write CVS/Entries back"""
-        f = self.cvsopen("Entries", 'w')
-        for e in list(self.values()):
-            f.write(e.putentry())
-        f.close()
-
-    def getlocalfiles(self):
-        entries_keys = set(self.entries.keys())
-        addlist = os.listdir(os.curdir)
-        for name in addlist:
-            if not self.ignored(name):
-                entries_keys.add(name)
-        for file in sorted(entries_keys):
-            try:
-                e = self.entries[file]
-            except KeyError:
-                e = self.entries[file] = self.FileClass(file)
-            e.getlocal()
-
-    def getremotefiles(self, proxy = None):
-        if proxy:
-            self.proxy = proxy
-        if not self.proxy:
-            raise RuntimeError("no RCS proxy")
-        addlist = self.proxy.listfiles()
-        for file in addlist:
-            try:
-                e = self.entries[file]
-            except KeyError:
-                e = self.entries[file] = self.FileClass(file)
-            e.getremote(self.proxy)
-
-    def report(self):
-        for e in list(self.values()):
-            e.report()
-        print('-'*50)
-
-    def keys(self):
-        return sorted(self.entries.keys())
-
-    def values(self):
-        def value(key, self=self):
-            return self.entries[key]
-        return [value(k) for k in self.keys()]
-
-    def items(self):
-        def item(key, self=self):
-            return (key, self.entries[key])
-        return [item(k) for k in self.keys()]
-
-    def cvsexists(self, file):
-        file = os.path.join("CVS", file)
-        return os.path.exists(file)
-
-    def cvsopen(self, file, mode = 'r'):
-        file = os.path.join("CVS", file)
-        if 'r' not in mode:
-            self.backup(file)
-        return open(file, mode)
-
-    def backup(self, file):
-        if os.path.isfile(file):
-            bfile = file + '~'
-            try: os.unlink(bfile)
-            except os.error: pass
-            os.rename(file, bfile)
-
-    def ignored(self, file):
-        if os.path.isdir(file): return True
-        for pat in self.IgnoreList:
-            if fnmatch.fnmatch(file, pat): return True
-        return False
-
-
-# hexify and unhexify are useful to print MD5 checksums in hex format
-
-hexify_format = '%02x' * 16
-def hexify(sum):
-    "Return a hex representation of a 16-byte string (e.g. an MD5 digest)"
-    if sum is None:
-        return "None"
-    return hexify_format % tuple(map(ord, sum))
-
-def unhexify(hexsum):
-    "Return the original from a hexified string"
-    if hexsum == "None":
-        return None
-    sum = ''
-    for i in range(0, len(hexsum), 2):
-        sum = sum + chr(string.atoi(hexsum[i:i+2], 16))
-    return sum
-
-
-unctime_monthmap = {}
-def unctime(date):
-    if date == "None": return None
-    if not unctime_monthmap:
-        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
-                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-        i = 0
-        for m in months:
-            i = i+1
-            unctime_monthmap[m] = i
-    words = string.split(date) # Day Mon DD HH:MM:SS YEAR
-    year = string.atoi(words[4])
-    month = unctime_monthmap[words[1]]
-    day = string.atoi(words[2])
-    [hh, mm, ss] = list(map(string.atoi, string.splitfields(words[3], ':')))
-    ss = ss - time.timezone
-    return time.mktime((year, month, day, hh, mm, ss, 0, 0, 0))
-
-def gmctime(t):
-    if t is None: return "None"
-    return time.asctime(time.gmtime(t))
-
-def test_unctime():
-    now = int(time.time())
-    t = time.gmtime(now)
-    at = time.asctime(t)
-    print('GMT', now, at)
-    print('timezone', time.timezone)
-    print('local', time.ctime(now))
-    u = unctime(at)
-    print('unctime()', u)
-    gu = time.gmtime(u)
-    print('->', gu)
-    print(time.asctime(gu))
-
-def test():
-    x = CVS()
-    x.getentries()
-    x.getlocalfiles()
-##      x.report()
-    import rcsclient
-    proxy = rcsclient.openrcsclient()
-    x.getremotefiles(proxy)
-    x.report()
-
-
-if __name__ == "__main__":
-    test()
diff --git a/Demo/pdist/cvslock.py b/Demo/pdist/cvslock.py
deleted file mode 100755
index ffaa15e..0000000
--- a/Demo/pdist/cvslock.py
+++ /dev/null
@@ -1,279 +0,0 @@
-"""CVS locking algorithm.
-
-CVS locking strategy
-====================
-
-As reverse engineered from the CVS 1.3 sources (file lock.c):
-
-- Locking is done on a per repository basis (but a process can hold
-write locks for multiple directories); all lock files are placed in
-the repository and have names beginning with "#cvs.".
-
-- Before even attempting to lock, a file "#cvs.tfl.<pid>" is created
-(and removed again), to test that we can write the repository.  [The
-algorithm can still be fooled (1) if the repository's mode is changed
-while attempting to lock; (2) if this file exists and is writable but
-the directory is not.]
-
-- While creating the actual read/write lock files (which may exist for
-a long time), a "meta-lock" is held.  The meta-lock is a directory
-named "#cvs.lock" in the repository.  The meta-lock is also held while
-a write lock is held.
-
-- To set a read lock:
-
-        - acquire the meta-lock
-        - create the file "#cvs.rfl.<pid>"
-        - release the meta-lock
-
-- To set a write lock:
-
-        - acquire the meta-lock
-        - check that there are no files called "#cvs.rfl.*"
-                - if there are, release the meta-lock, sleep, try again
-        - create the file "#cvs.wfl.<pid>"
-
-- To release a write lock:
-
-        - remove the file "#cvs.wfl.<pid>"
-        - rmdir the meta-lock
-
-- To release a read lock:
-
-        - remove the file "#cvs.rfl.<pid>"
-
-
-Additional notes
-----------------
-
-- A process should read-lock at most one repository at a time.
-
-- A process may write-lock as many repositories as it wishes (to avoid
-deadlocks, I presume it should always lock them top-down in the
-directory hierarchy).
-
-- A process should make sure it removes all its lock files and
-directories when it crashes.
-
-- Limitation: one user id should not be committing files into the same
-repository at the same time.
-
-
-Turn this into Python code
---------------------------
-
-rl = ReadLock(repository, waittime)
-
-wl = WriteLock(repository, waittime)
-
-list = MultipleWriteLock([repository1, repository2, ...], waittime)
-
-"""
-
-
-import os
-import time
-import stat
-import pwd
-
-
-# Default wait time
-DELAY = 10
-
-
-# XXX This should be the same on all Unix versions
-EEXIST = 17
-
-
-# Files used for locking (must match cvs.h in the CVS sources)
-CVSLCK = "#cvs.lck"
-CVSRFL = "#cvs.rfl."
-CVSWFL = "#cvs.wfl."
-
-
-class Error:
-
-    def __init__(self, msg):
-        self.msg = msg
-
-    def __repr__(self):
-        return repr(self.msg)
-
-    def __str__(self):
-        return str(self.msg)
-
-
-class Locked(Error):
-    pass
-
-
-class Lock:
-
-    def __init__(self, repository = ".", delay = DELAY):
-        self.repository = repository
-        self.delay = delay
-        self.lockdir = None
-        self.lockfile = None
-        pid = repr(os.getpid())
-        self.cvslck = self.join(CVSLCK)
-        self.cvsrfl = self.join(CVSRFL + pid)
-        self.cvswfl = self.join(CVSWFL + pid)
-
-    def __del__(self):
-        print("__del__")
-        self.unlock()
-
-    def setlockdir(self):
-        while 1:
-            try:
-                self.lockdir = self.cvslck
-                os.mkdir(self.cvslck, 0o777)
-                return
-            except os.error as msg:
-                self.lockdir = None
-                if msg.args[0] == EEXIST:
-                    try:
-                        st = os.stat(self.cvslck)
-                    except os.error:
-                        continue
-                    self.sleep(st)
-                    continue
-                raise Error("failed to lock %s: %s" % (
-                        self.repository, msg))
-
-    def unlock(self):
-        self.unlockfile()
-        self.unlockdir()
-
-    def unlockfile(self):
-        if self.lockfile:
-            print("unlink", self.lockfile)
-            try:
-                os.unlink(self.lockfile)
-            except os.error:
-                pass
-            self.lockfile = None
-
-    def unlockdir(self):
-        if self.lockdir:
-            print("rmdir", self.lockdir)
-            try:
-                os.rmdir(self.lockdir)
-            except os.error:
-                pass
-            self.lockdir = None
-
-    def sleep(self, st):
-        sleep(st, self.repository, self.delay)
-
-    def join(self, name):
-        return os.path.join(self.repository, name)
-
-
-def sleep(st, repository, delay):
-    if delay <= 0:
-        raise Locked(st)
-    uid = st[stat.ST_UID]
-    try:
-        pwent = pwd.getpwuid(uid)
-        user = pwent[0]
-    except KeyError:
-        user = "uid %d" % uid
-    print("[%s]" % time.ctime(time.time())[11:19], end=' ')
-    print("Waiting for %s's lock in" % user, repository)
-    time.sleep(delay)
-
-
-class ReadLock(Lock):
-
-    def __init__(self, repository, delay = DELAY):
-        Lock.__init__(self, repository, delay)
-        ok = 0
-        try:
-            self.setlockdir()
-            self.lockfile = self.cvsrfl
-            fp = open(self.lockfile, 'w')
-            fp.close()
-            ok = 1
-        finally:
-            if not ok:
-                self.unlockfile()
-            self.unlockdir()
-
-
-class WriteLock(Lock):
-
-    def __init__(self, repository, delay = DELAY):
-        Lock.__init__(self, repository, delay)
-        self.setlockdir()
-        while 1:
-            uid = self.readers_exist()
-            if not uid:
-                break
-            self.unlockdir()
-            self.sleep(uid)
-        self.lockfile = self.cvswfl
-        fp = open(self.lockfile, 'w')
-        fp.close()
-
-    def readers_exist(self):
-        n = len(CVSRFL)
-        for name in os.listdir(self.repository):
-            if name[:n] == CVSRFL:
-                try:
-                    st = os.stat(self.join(name))
-                except os.error:
-                    continue
-                return st
-        return None
-
-
-def MultipleWriteLock(repositories, delay = DELAY):
-    while 1:
-        locks = []
-        for r in repositories:
-            try:
-                locks.append(WriteLock(r, 0))
-            except Locked as instance:
-                del locks
-                break
-        else:
-            break
-        sleep(instance.msg, r, delay)
-    return list
-
-
-def test():
-    import sys
-    if sys.argv[1:]:
-        repository = sys.argv[1]
-    else:
-        repository = "."
-    rl = None
-    wl = None
-    try:
-        print("attempting write lock ...")
-        wl = WriteLock(repository)
-        print("got it.")
-        wl.unlock()
-        print("attempting read lock ...")
-        rl = ReadLock(repository)
-        print("got it.")
-        rl.unlock()
-    finally:
-        print([1])
-        print([2])
-        if rl:
-            rl.unlock()
-        print([3])
-        if wl:
-            wl.unlock()
-        print([4])
-        rl = None
-        print([5])
-        wl = None
-        print([6])
-
-
-if __name__ == '__main__':
-    test()
diff --git a/Demo/pdist/mac.py b/Demo/pdist/mac.py
deleted file mode 100755
index beb77ec..0000000
--- a/Demo/pdist/mac.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import sys
-import rcvs
-
-def raw_input(prompt):
-    sys.stdout.write(prompt)
-    sys.stdout.flush()
-    return sys.stdin.readline()
-
-def main():
-    while 1:
-        try:
-            line = input('$ ')
-        except EOFError:
-            break
-        words = line.split()
-        if not words:
-            continue
-        if words[0] != 'rcvs':
-            words.insert(0, 'rcvs')
-        sys.argv = words
-        rcvs.main()
-
-if __name__ == '__main__':
-    main()
diff --git a/Demo/pdist/makechangelog.py b/Demo/pdist/makechangelog.py
deleted file mode 100755
index db66e8f..0000000
--- a/Demo/pdist/makechangelog.py
+++ /dev/null
@@ -1,109 +0,0 @@
-#! /usr/bin/env python
-
-"""Turn a pile of RCS log output into ChangeLog file entries.
-
-"""
-
-import sys
-import string
-import re
-import getopt
-import time
-
-def main():
-    args = sys.argv[1:]
-    opts, args = getopt.getopt(args, 'p:')
-    prefix = ''
-    for o, a in opts:
-        if p == '-p': prefix = a
-
-    f = sys.stdin
-    allrevs = []
-    while 1:
-        file = getnextfile(f)
-        if not file: break
-        revs = []
-        while 1:
-            rev = getnextrev(f, file)
-            if not rev:
-                break
-            revs.append(rev)
-        if revs:
-            allrevs[len(allrevs):] = revs
-    allrevs.sort()
-    allrevs.reverse()
-    for rev in allrevs:
-        formatrev(rev, prefix)
-
-parsedateprog = re.compile(
-    '^date: ([0-9]+)/([0-9]+)/([0-9]+) ' +
-    '([0-9]+):([0-9]+):([0-9]+);  author: ([^ ;]+)')
-
-authormap = {
-    'guido': 'Guido van Rossum  <guido@cnri.reston.va.us>',
-    'jack': 'Jack Jansen  <jack@cwi.nl>',
-    'sjoerd': 'Sjoerd Mullender  <sjoerd@cwi.nl>',
-    }
-
-def formatrev(rev, prefix):
-    dateline, file, revline, log = rev
-    if parsedateprog.match(dateline) >= 0:
-        fields = parsedateprog.group(1, 2, 3, 4, 5, 6)
-        author = parsedateprog.group(7)
-        if author in authormap: author = authormap[author]
-        tfields = list(map(string.atoi, fields)) + [0, 0, 0]
-        tfields[5] = tfields[5] - time.timezone
-        t = time.mktime(tuple(tfields))
-        print(time.ctime(t), '', author)
-        words = string.split(log)
-        words[:0] = ['*', prefix + file + ':']
-        maxcol = 72-8
-        col = maxcol
-        for word in words:
-            if col > 0 and col + len(word) >= maxcol:
-                print()
-                print('\t' + word, end=' ')
-                col = -1
-            else:
-                print(word, end=' ')
-            col = col + 1 + len(word)
-        print()
-        print()
-
-startprog = re.compile("^Working file: (.*)$")
-
-def getnextfile(f):
-    while 1:
-        line = f.readline()
-        if not line: return None
-        if startprog.match(line) >= 0:
-            file = startprog.group(1)
-            # Skip until first revision
-            while 1:
-                line = f.readline()
-                if not line: return None
-                if line[:10] == '='*10: return None
-                if line[:10] == '-'*10: break
-##              print "Skipped", line,
-            return file
-##      else:
-##          print "Ignored", line,
-
-def getnextrev(f, file):
-    # This is called when we are positioned just after a '---' separator
-    revline = f.readline()
-    dateline = f.readline()
-    log = ''
-    while 1:
-        line = f.readline()
-        if not line: break
-        if line[:10] == '='*10:
-            # Ignore the *last* log entry for each file since it
-            # is the revision since which we are logging.
-            return None
-        if line[:10] == '-'*10: break
-        log = log + line
-    return dateline, file, revline, log
-
-if __name__ == '__main__':
-    main()
diff --git a/Demo/pdist/rcsbump b/Demo/pdist/rcsbump
deleted file mode 100755
index 4fa078e..0000000
--- a/Demo/pdist/rcsbump
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-# -*- python -*-
-#
-# guido's version, from rcsbump,v 1.2 1995/06/22 21:27:27 bwarsaw Exp
-#
-# Python script for bumping up an RCS major revision number.
-
-import sys
-import re
-import rcslib
-import string
-
-WITHLOCK = 1
-majorrev_re = re.compile('^[0-9]+')
-
-dir = rcslib.RCS()
-
-if sys.argv[1:]:
-    files = sys.argv[1:]
-else:
-    files = dir.listfiles()
-
-for file in files:
-    # get the major revnumber of the file
-    headbranch = dir.info(file)['head']
-    majorrev_re.match(headbranch)
-    majorrev = string.atoi(majorrev_re.group(0)) + 1
-
-    if not dir.islocked(file):
-        dir.checkout(file, WITHLOCK)
-
-    msg = "Bumping major revision number (to %d)" % majorrev
-    dir.checkin((file, "%s.0" % majorrev), msg, "-f")
diff --git a/Demo/pdist/rcsclient.py b/Demo/pdist/rcsclient.py
deleted file mode 100755
index d8cb004..0000000
--- a/Demo/pdist/rcsclient.py
+++ /dev/null
@@ -1,71 +0,0 @@
-"""Customize this file to change the default client etc.
-
-(In general, it is probably be better to make local operation the
-default and to require something like an RCSSERVER environment
-variable to enable remote operation.)
-
-"""
-
-import string
-import os
-
-# These defaults don't belong here -- they should be taken from the
-# environment or from a hidden file in the current directory
-
-HOST = 'voorn.cwi.nl'
-PORT = 4127
-VERBOSE = 1
-LOCAL = 0
-
-import client
-
-
-class RCSProxyClient(client.SecureClient):
-
-    def __init__(self, address, verbose = client.VERBOSE):
-        client.SecureClient.__init__(self, address, verbose)
-
-
-def openrcsclient(opts = []):
-    "open an RCSProxy client based on a list of options returned by getopt"
-    import RCSProxy
-    host = HOST
-    port = PORT
-    verbose = VERBOSE
-    local = LOCAL
-    directory = None
-    for o, a in opts:
-        if o == '-h':
-            host = a
-            if ':' in host:
-                i = string.find(host, ':')
-                host, p = host[:i], host[i+1:]
-                if p:
-                    port = string.atoi(p)
-        if o == '-p':
-            port = string.atoi(a)
-        if o == '-d':
-            directory = a
-        if o == '-v':
-            verbose = verbose + 1
-        if o == '-q':
-            verbose = 0
-        if o == '-L':
-            local = 1
-    if local:
-        import RCSProxy
-        x = RCSProxy.RCSProxyLocal()
-    else:
-        address = (host, port)
-        x = RCSProxyClient(address, verbose)
-    if not directory:
-        try:
-            directory = open(os.path.join("CVS", "Repository")).readline()
-        except IOError:
-            pass
-        else:
-            if directory[-1] == '\n':
-                directory = directory[:-1]
-    if directory:
-        x.cd(directory)
-    return x
diff --git a/Demo/pdist/rcslib.py b/Demo/pdist/rcslib.py
deleted file mode 100755
index 9690f3b..0000000
--- a/Demo/pdist/rcslib.py
+++ /dev/null
@@ -1,334 +0,0 @@
-"""RCS interface module.
-
-Defines the class RCS, which represents a directory with rcs version
-files and (possibly) corresponding work files.
-
-"""
-
-
-import fnmatch
-import os
-import re
-import string
-import tempfile
-
-
-class RCS:
-
-    """RCS interface class (local filesystem version).
-
-    An instance of this class represents a directory with rcs version
-    files and (possible) corresponding work files.
-
-    Methods provide access to most rcs operations such as
-    checkin/checkout, access to the rcs metadata (revisions, logs,
-    branches etc.) as well as some filesystem operations such as
-    listing all rcs version files.
-
-    XXX BUGS / PROBLEMS
-
-    - The instance always represents the current directory so it's not
-    very useful to have more than one instance around simultaneously
-
-    """
-
-    # Characters allowed in work file names
-    okchars = string.ascii_letters + string.digits + '-_=+'
-
-    def __init__(self):
-        """Constructor."""
-        pass
-
-    def __del__(self):
-        """Destructor."""
-        pass
-
-    # --- Informational methods about a single file/revision ---
-
-    def log(self, name_rev, otherflags = ''):
-        """Return the full log text for NAME_REV as a string.
-
-        Optional OTHERFLAGS are passed to rlog.
-
-        """
-        f = self._open(name_rev, 'rlog ' + otherflags)
-        data = f.read()
-        status = self._closepipe(f)
-        if status:
-            data = data + "%s: %s" % status
-        elif data[-1] == '\n':
-            data = data[:-1]
-        return data
-
-    def head(self, name_rev):
-        """Return the head revision for NAME_REV"""
-        dict = self.info(name_rev)
-        return dict['head']
-
-    def info(self, name_rev):
-        """Return a dictionary of info (from rlog -h) for NAME_REV
-
-        The dictionary's keys are the keywords that rlog prints
-        (e.g. 'head' and its values are the corresponding data
-        (e.g. '1.3').
-
-        XXX symbolic names and locks are not returned
-
-        """
-        f = self._open(name_rev, 'rlog -h')
-        dict = {}
-        while 1:
-            line = f.readline()
-            if not line: break
-            if line[0] == '\t':
-                # XXX could be a lock or symbolic name
-                # Anything else?
-                continue
-            i = string.find(line, ':')
-            if i > 0:
-                key, value = line[:i], string.strip(line[i+1:])
-                dict[key] = value
-        status = self._closepipe(f)
-        if status:
-            raise IOError(status)
-        return dict
-
-    # --- Methods that change files ---
-
-    def lock(self, name_rev):
-        """Set an rcs lock on NAME_REV."""
-        name, rev = self.checkfile(name_rev)
-        cmd = "rcs -l%s %s" % (rev, name)
-        return self._system(cmd)
-
-    def unlock(self, name_rev):
-        """Clear an rcs lock on NAME_REV."""
-        name, rev = self.checkfile(name_rev)
-        cmd = "rcs -u%s %s" % (rev, name)
-        return self._system(cmd)
-
-    def checkout(self, name_rev, withlock=0, otherflags=""):
-        """Check out NAME_REV to its work file.
-
-        If optional WITHLOCK is set, check out locked, else unlocked.
-
-        The optional OTHERFLAGS is passed to co without
-        interpretation.
-
-        Any output from co goes to directly to stdout.
-
-        """
-        name, rev = self.checkfile(name_rev)
-        if withlock: lockflag = "-l"
-        else: lockflag = "-u"
-        cmd = 'co %s%s %s %s' % (lockflag, rev, otherflags, name)
-        return self._system(cmd)
-
-    def checkin(self, name_rev, message=None, otherflags=""):
-        """Check in NAME_REV from its work file.
-
-        The optional MESSAGE argument becomes the checkin message
-        (default "<none>" if None); or the file description if this is
-        a new file.
-
-        The optional OTHERFLAGS argument is passed to ci without
-        interpretation.
-
-        Any output from ci goes to directly to stdout.
-
-        """
-        name, rev = self._unmangle(name_rev)
-        new = not self.isvalid(name)
-        if not message: message = "<none>"
-        if message and message[-1] != '\n':
-            message = message + '\n'
-        lockflag = "-u"
-        if new:
-            f = tempfile.NamedTemporaryFile()
-            f.write(message)
-            f.flush()
-            cmd = 'ci %s%s -t%s %s %s' % \
-                  (lockflag, rev, f.name, otherflags, name)
-        else:
-            message = re.sub(r'([\"$`])', r'\\\1', message)
-            cmd = 'ci %s%s -m"%s" %s %s' % \
-                  (lockflag, rev, message, otherflags, name)
-        return self._system(cmd)
-
-    # --- Exported support methods ---
-
-    def listfiles(self, pat = None):
-        """Return a list of all version files matching optional PATTERN."""
-        files = os.listdir(os.curdir)
-        files = list(filter(self._isrcs, files))
-        if os.path.isdir('RCS'):
-            files2 = os.listdir('RCS')
-            files2 = list(filter(self._isrcs, files2))
-            files = files + files2
-        files = list(map(self.realname, files))
-        return self._filter(files, pat)
-
-    def isvalid(self, name):
-        """Test whether NAME has a version file associated."""
-        namev = self.rcsname(name)
-        return (os.path.isfile(namev) or
-                os.path.isfile(os.path.join('RCS', namev)))
-
-    def rcsname(self, name):
-        """Return the pathname of the version file for NAME.
-
-        The argument can be a work file name or a version file name.
-        If the version file does not exist, the name of the version
-        file that would be created by "ci" is returned.
-
-        """
-        if self._isrcs(name): namev = name
-        else: namev = name + ',v'
-        if os.path.isfile(namev): return namev
-        namev = os.path.join('RCS', os.path.basename(namev))
-        if os.path.isfile(namev): return namev
-        if os.path.isdir('RCS'):
-            return os.path.join('RCS', namev)
-        else:
-            return namev
-
-    def realname(self, namev):
-        """Return the pathname of the work file for NAME.
-
-        The argument can be a work file name or a version file name.
-        If the work file does not exist, the name of the work file
-        that would be created by "co" is returned.
-
-        """
-        if self._isrcs(namev): name = namev[:-2]
-        else: name = namev
-        if os.path.isfile(name): return name
-        name = os.path.basename(name)
-        return name
-
-    def islocked(self, name_rev):
-        """Test whether FILE (which must have a version file) is locked.
-
-        XXX This does not tell you which revision number is locked and
-        ignores any revision you may pass in (by virtue of using rlog
-        -L -R).
-
-        """
-        f = self._open(name_rev, 'rlog -L -R')
-        line = f.readline()
-        status = self._closepipe(f)
-        if status:
-            raise IOError(status)
-        if not line: return None
-        if line[-1] == '\n':
-            line = line[:-1]
-        return self.realname(name_rev) == self.realname(line)
-
-    def checkfile(self, name_rev):
-        """Normalize NAME_REV into a (NAME, REV) tuple.
-
-        Raise an exception if there is no corresponding version file.
-
-        """
-        name, rev = self._unmangle(name_rev)
-        if not self.isvalid(name):
-            raise os.error('not an rcs file %r' % (name,))
-        return name, rev
-
-    # --- Internal methods ---
-
-    def _open(self, name_rev, cmd = 'co -p', rflag = '-r'):
-        """INTERNAL: open a read pipe to NAME_REV using optional COMMAND.
-
-        Optional FLAG is used to indicate the revision (default -r).
-
-        Default COMMAND is "co -p".
-
-        Return a file object connected by a pipe to the command's
-        output.
-
-        """
-        name, rev = self.checkfile(name_rev)
-        namev = self.rcsname(name)
-        if rev:
-            cmd = cmd + ' ' + rflag + rev
-        return os.popen("%s %r" % (cmd, namev))
-
-    def _unmangle(self, name_rev):
-        """INTERNAL: Normalize NAME_REV argument to (NAME, REV) tuple.
-
-        Raise an exception if NAME contains invalid characters.
-
-        A NAME_REV argument is either NAME string (implying REV='') or
-        a tuple of the form (NAME, REV).
-
-        """
-        if type(name_rev) == type(''):
-            name_rev = name, rev = name_rev, ''
-        else:
-            name, rev = name_rev
-        for c in rev:
-            if c not in self.okchars:
-                raise ValueError("bad char in rev")
-        return name_rev
-
-    def _closepipe(self, f):
-        """INTERNAL: Close PIPE and print its exit status if nonzero."""
-        sts = f.close()
-        if not sts: return None
-        detail, reason = divmod(sts, 256)
-        if reason == 0: return 'exit', detail   # Exit status
-        signal = reason&0x7F
-        if signal == 0x7F:
-            code = 'stopped'
-            signal = detail
-        else:
-            code = 'killed'
-        if reason&0x80:
-            code = code + '(coredump)'
-        return code, signal
-
-    def _system(self, cmd):
-        """INTERNAL: run COMMAND in a subshell.
-
-        Standard input for the command is taken from /dev/null.
-
-        Raise IOError when the exit status is not zero.
-
-        Return whatever the calling method should return; normally
-        None.
-
-        A derived class may override this method and redefine it to
-        capture stdout/stderr of the command and return it.
-
-        """
-        cmd = cmd + " </dev/null"
-        sts = os.system(cmd)
-        if sts: raise IOError("command exit status %d" % sts)
-
-    def _filter(self, files, pat = None):
-        """INTERNAL: Return a sorted copy of the given list of FILES.
-
-        If a second PATTERN argument is given, only files matching it
-        are kept.  No check for valid filenames is made.
-
-        """
-        if pat:
-            def keep(name, pat = pat):
-                return fnmatch.fnmatch(name, pat)
-            files = list(filter(keep, files))
-        else:
-            files = files[:]
-        files.sort()
-        return files
-
-    def _remove(self, fn):
-        """INTERNAL: remove FILE without complaints."""
-        try:
-            os.unlink(fn)
-        except os.error:
-            pass
-
-    def _isrcs(self, name):
-        """INTERNAL: Test whether NAME ends in ',v'."""
-        return name[-2:] == ',v'
diff --git a/Demo/pdist/rcvs b/Demo/pdist/rcvs
deleted file mode 100755
index f82a27a..0000000
--- a/Demo/pdist/rcvs
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/usr/bin/env python
-
-import addpack
-addpack.addpack('/home/guido/src/python/Demo/pdist')
-
-import rcvs
-
-rcvs.main()
diff --git a/Demo/pdist/rcvs.py b/Demo/pdist/rcvs.py
deleted file mode 100755
index 4e2532a..0000000
--- a/Demo/pdist/rcvs.py
+++ /dev/null
@@ -1,476 +0,0 @@
-#! /usr/bin/env python
-
-"""Remote CVS -- command line interface"""
-
-# XXX To do:
-#
-# Bugs:
-# - if the remote file is deleted, "rcvs update" will fail
-#
-# Functionality:
-# - cvs rm
-# - descend into directories (alraedy done for update)
-# - conflict resolution
-# - other relevant commands?
-# - branches
-#
-# - Finesses:
-# - retain file mode's x bits
-# - complain when "nothing known about filename"
-# - edit log message the way CVS lets you edit it
-# - cvs diff -rREVA -rREVB
-# - send mail the way CVS sends it
-#
-# Performance:
-# - cache remote checksums (for every revision ever seen!)
-# - translate symbolic revisions to numeric revisions
-#
-# Reliability:
-# - remote locking
-#
-# Security:
-# - Authenticated RPC?
-
-
-from cvslib import CVS, File
-import md5
-import os
-import sys
-from cmdfw import CommandFrameWork
-
-
-DEF_LOCAL = 1                           # Default -l
-
-
-class MyFile(File):
-
-    def action(self):
-        """Return a code indicating the update status of this file.
-
-        The possible return values are:
-
-        '=' -- everything's fine
-        '0' -- file doesn't exist anywhere
-        '?' -- exists locally only
-        'A' -- new locally
-        'R' -- deleted locally
-        'U' -- changed remotely, no changes locally
-               (includes new remotely or deleted remotely)
-        'M' -- changed locally, no changes remotely
-        'C' -- conflict: changed locally as well as remotely
-               (includes cases where the file has been added
-               or removed locally and remotely)
-        'D' -- deleted remotely
-        'N' -- new remotely
-        'r' -- get rid of entry
-        'c' -- create entry
-        'u' -- update entry
-
-        (and probably others :-)
-        """
-        if not self.lseen:
-            self.getlocal()
-        if not self.rseen:
-            self.getremote()
-        if not self.eseen:
-            if not self.lsum:
-                if not self.rsum: return '0' # Never heard of
-                else:
-                    return 'N' # New remotely
-            else: # self.lsum
-                if not self.rsum: return '?' # Local only
-                # Local and remote, but no entry
-                if self.lsum == self.rsum:
-                    return 'c' # Restore entry only
-                else: return 'C' # Real conflict
-        else: # self.eseen
-            if not self.lsum:
-                if self.edeleted:
-                    if self.rsum: return 'R' # Removed
-                    else: return 'r' # Get rid of entry
-                else: # not self.edeleted
-                    if self.rsum:
-                        print("warning:", end=' ')
-                        print(self.file, end=' ')
-                        print("was lost")
-                        return 'U'
-                    else: return 'r' # Get rid of entry
-            else: # self.lsum
-                if not self.rsum:
-                    if self.enew: return 'A' # New locally
-                    else: return 'D' # Deleted remotely
-                else: # self.rsum
-                    if self.enew:
-                        if self.lsum == self.rsum:
-                            return 'u'
-                        else:
-                            return 'C'
-                    if self.lsum == self.esum:
-                        if self.esum == self.rsum:
-                            return '='
-                        else:
-                            return 'U'
-                    elif self.esum == self.rsum:
-                        return 'M'
-                    elif self.lsum == self.rsum:
-                        return 'u'
-                    else:
-                        return 'C'
-
-    def update(self):
-        code = self.action()
-        if code == '=': return
-        print(code, self.file)
-        if code in ('U', 'N'):
-            self.get()
-        elif code == 'C':
-            print("%s: conflict resolution not yet implemented" % \
-                  self.file)
-        elif code == 'D':
-            remove(self.file)
-            self.eseen = 0
-        elif code == 'r':
-            self.eseen = 0
-        elif code in ('c', 'u'):
-            self.eseen = 1
-            self.erev = self.rrev
-            self.enew = 0
-            self.edeleted = 0
-            self.esum = self.rsum
-            self.emtime, self.ectime = os.stat(self.file)[-2:]
-            self.extra = ''
-
-    def commit(self, message = ""):
-        code = self.action()
-        if code in ('A', 'M'):
-            self.put(message)
-            return 1
-        elif code == 'R':
-            print("%s: committing removes not yet implemented" % \
-                  self.file)
-        elif code == 'C':
-            print("%s: conflict resolution not yet implemented" % \
-                  self.file)
-
-    def diff(self, opts = []):
-        self.action()           # To update lseen, rseen
-        flags = ''
-        rev = self.rrev
-        # XXX should support two rev options too!
-        for o, a in opts:
-            if o == '-r':
-                rev = a
-            else:
-                flags = flags + ' ' + o + a
-        if rev == self.rrev and self.lsum == self.rsum:
-            return
-        flags = flags[1:]
-        fn = self.file
-        data = self.proxy.get((fn, rev))
-        sum = md5.new(data).digest()
-        if self.lsum == sum:
-            return
-        import tempfile
-        tf = tempfile.NamedTemporaryFile()
-        tf.write(data)
-        tf.flush()
-        print('diff %s -r%s %s' % (flags, rev, fn))
-        sts = os.system('diff %s %s %s' % (flags, tf.name, fn))
-        if sts:
-            print('='*70)
-
-    def commitcheck(self):
-        return self.action() != 'C'
-
-    def put(self, message = ""):
-        print("Checking in", self.file, "...")
-        data = open(self.file).read()
-        if not self.enew:
-            self.proxy.lock(self.file)
-        messages = self.proxy.put(self.file, data, message)
-        if messages:
-            print(messages)
-        self.setentry(self.proxy.head(self.file), self.lsum)
-
-    def get(self):
-        data = self.proxy.get(self.file)
-        f = open(self.file, 'w')
-        f.write(data)
-        f.close()
-        self.setentry(self.rrev, self.rsum)
-
-    def log(self, otherflags):
-        print(self.proxy.log(self.file, otherflags))
-
-    def add(self):
-        self.eseen = 0          # While we're hacking...
-        self.esum = self.lsum
-        self.emtime, self.ectime = 0, 0
-        self.erev = ''
-        self.enew = 1
-        self.edeleted = 0
-        self.eseen = 1          # Done
-        self.extra = ''
-
-    def setentry(self, erev, esum):
-        self.eseen = 0          # While we're hacking...
-        self.esum = esum
-        self.emtime, self.ectime = os.stat(self.file)[-2:]
-        self.erev = erev
-        self.enew = 0
-        self.edeleted = 0
-        self.eseen = 1          # Done
-        self.extra = ''
-
-
-SENDMAIL = "/usr/lib/sendmail -t"
-MAILFORM = """To: %s
-Subject: CVS changes: %s
-
-...Message from rcvs...
-
-Committed files:
-        %s
-
-Log message:
-        %s
-"""
-
-
-class RCVS(CVS):
-
-    FileClass = MyFile
-
-    def __init__(self):
-        CVS.__init__(self)
-
-    def update(self, files):
-        for e in self.whichentries(files, 1):
-            e.update()
-
-    def commit(self, files, message = ""):
-        list = self.whichentries(files)
-        if not list: return
-        ok = 1
-        for e in list:
-            if not e.commitcheck():
-                ok = 0
-        if not ok:
-            print("correct above errors first")
-            return
-        if not message:
-            message = input("One-liner: ")
-        committed = []
-        for e in list:
-            if e.commit(message):
-                committed.append(e.file)
-        self.mailinfo(committed, message)
-
-    def mailinfo(self, files, message = ""):
-        towhom = "sjoerd@cwi.nl, jack@cwi.nl" # XXX
-        mailtext = MAILFORM % (towhom, ' '.join(files),
-                                ' '.join(files), message)
-        print('-'*70)
-        print(mailtext)
-        print('-'*70)
-        ok = input("OK to mail to %s? " % towhom)
-        if ok.lower().strip() in ('y', 'ye', 'yes'):
-            p = os.popen(SENDMAIL, "w")
-            p.write(mailtext)
-            sts = p.close()
-            if sts:
-                print("Sendmail exit status %s" % str(sts))
-            else:
-                print("Mail sent.")
-        else:
-            print("No mail sent.")
-
-    def report(self, files):
-        for e in self.whichentries(files):
-            e.report()
-
-    def diff(self, files, opts):
-        for e in self.whichentries(files):
-            e.diff(opts)
-
-    def add(self, files):
-        if not files:
-            raise RuntimeError("'cvs add' needs at least one file")
-        list = []
-        for e in self.whichentries(files, 1):
-            e.add()
-
-    def rm(self, files):
-        if not files:
-            raise RuntimeError("'cvs rm' needs at least one file")
-        raise RuntimeError("'cvs rm' not yet imlemented")
-
-    def log(self, files, opts):
-        flags = ''
-        for o, a in opts:
-            flags = flags + ' ' + o + a
-        for e in self.whichentries(files):
-            e.log(flags)
-
-    def whichentries(self, files, localfilestoo = 0):
-        if files:
-            list = []
-            for file in files:
-                if file in self.entries:
-                    e = self.entries[file]
-                else:
-                    e = self.FileClass(file)
-                    self.entries[file] = e
-                list.append(e)
-        else:
-            list = list(self.entries.values())
-            for file in self.proxy.listfiles():
-                if file in self.entries:
-                    continue
-                e = self.FileClass(file)
-                self.entries[file] = e
-                list.append(e)
-            if localfilestoo:
-                for file in os.listdir(os.curdir):
-                    if file not in self.entries \
-                       and not self.ignored(file):
-                        e = self.FileClass(file)
-                        self.entries[file] = e
-                        list.append(e)
-            list.sort()
-        if self.proxy:
-            for e in list:
-                if e.proxy is None:
-                    e.proxy = self.proxy
-        return list
-
-
-class rcvs(CommandFrameWork):
-
-    GlobalFlags = 'd:h:p:qvL'
-    UsageMessage = \
-"usage: rcvs [-d directory] [-h host] [-p port] [-q] [-v] [subcommand arg ...]"
-    PostUsageMessage = \
-            "If no subcommand is given, the status of all files is listed"
-
-    def __init__(self):
-        """Constructor."""
-        CommandFrameWork.__init__(self)
-        self.proxy = None
-        self.cvs = RCVS()
-
-    def close(self):
-        if self.proxy:
-            self.proxy._close()
-        self.proxy = None
-
-    def recurse(self):
-        self.close()
-        names = os.listdir(os.curdir)
-        for name in names:
-            if name == os.curdir or name == os.pardir:
-                continue
-            if name == "CVS":
-                continue
-            if not os.path.isdir(name):
-                continue
-            if os.path.islink(name):
-                continue
-            print("--- entering subdirectory", name, "---")
-            os.chdir(name)
-            try:
-                if os.path.isdir("CVS"):
-                    self.__class__().run()
-                else:
-                    self.recurse()
-            finally:
-                os.chdir(os.pardir)
-                print("--- left subdirectory", name, "---")
-
-    def options(self, opts):
-        self.opts = opts
-
-    def ready(self):
-        import rcsclient
-        self.proxy = rcsclient.openrcsclient(self.opts)
-        self.cvs.setproxy(self.proxy)
-        self.cvs.getentries()
-
-    def default(self):
-        self.cvs.report([])
-
-    def do_report(self, opts, files):
-        self.cvs.report(files)
-
-    def do_update(self, opts, files):
-        """update [-l] [-R] [file] ..."""
-        local = DEF_LOCAL
-        for o, a in opts:
-            if o == '-l': local = 1
-            if o == '-R': local = 0
-        self.cvs.update(files)
-        self.cvs.putentries()
-        if not local and not files:
-            self.recurse()
-    flags_update = '-lR'
-    do_up = do_update
-    flags_up = flags_update
-
-    def do_commit(self, opts, files):
-        """commit [-m message] [file] ..."""
-        message = ""
-        for o, a in opts:
-            if o == '-m': message = a
-        self.cvs.commit(files, message)
-        self.cvs.putentries()
-    flags_commit = 'm:'
-    do_com = do_commit
-    flags_com = flags_commit
-
-    def do_diff(self, opts, files):
-        """diff [difflags] [file] ..."""
-        self.cvs.diff(files, opts)
-    flags_diff = 'cbitwcefhnlr:sD:S:'
-    do_dif = do_diff
-    flags_dif = flags_diff
-
-    def do_add(self, opts, files):
-        """add file ..."""
-        if not files:
-            print("'rcvs add' requires at least one file")
-            return
-        self.cvs.add(files)
-        self.cvs.putentries()
-
-    def do_remove(self, opts, files):
-        """remove file ..."""
-        if not files:
-            print("'rcvs remove' requires at least one file")
-            return
-        self.cvs.remove(files)
-        self.cvs.putentries()
-    do_rm = do_remove
-
-    def do_log(self, opts, files):
-        """log [rlog-options] [file] ..."""
-        self.cvs.log(files, opts)
-    flags_log = 'bhLNRtd:s:V:r:'
-
-
-def remove(fn):
-    try:
-        os.unlink(fn)
-    except os.error:
-        pass
-
-
-def main():
-    r = rcvs()
-    try:
-        r.run()
-    finally:
-        r.close()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/pdist/rrcs b/Demo/pdist/rrcs
deleted file mode 100755
index 31fc2c5..0000000
--- a/Demo/pdist/rrcs
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/usr/bin/env python
-
-import addpack
-addpack.addpack('/home/guido/src/python/Demo/pdist')
-
-import rrcs
-
-rrcs.main()
diff --git a/Demo/pdist/rrcs.py b/Demo/pdist/rrcs.py
deleted file mode 100755
index 647ecc5..0000000
--- a/Demo/pdist/rrcs.py
+++ /dev/null
@@ -1,158 +0,0 @@
-#! /usr/bin/env python
-
-"Remote RCS -- command line interface"
-
-import sys
-import os
-import getopt
-import string
-import md5
-import tempfile
-from rcsclient import openrcsclient
-
-def main():
-    sys.stdout = sys.stderr
-    try:
-        opts, rest = getopt.getopt(sys.argv[1:], 'h:p:d:qvL')
-        if not rest:
-            cmd = 'head'
-        else:
-            cmd, rest = rest[0], rest[1:]
-        if cmd not in commands:
-            raise getopt.error("unknown command")
-        coptset, func = commands[cmd]
-        copts, files = getopt.getopt(rest, coptset)
-    except getopt.error as msg:
-        print(msg)
-        print("usage: rrcs [options] command [options] [file] ...")
-        print("where command can be:")
-        print("      ci|put      # checkin the given files")
-        print("      co|get      # checkout")
-        print("      info        # print header info")
-        print("      head        # print revision of head branch")
-        print("      list        # list filename if valid")
-        print("      log         # print full log")
-        print("      diff        # diff rcs file and work file")
-        print("if no files are given, all remote rcs files are assumed")
-        sys.exit(2)
-    x = openrcsclient(opts)
-    if not files:
-        files = x.listfiles()
-    for fn in files:
-        try:
-            func(x, copts, fn)
-        except (IOError, os.error) as msg:
-            print("%s: %s" % (fn, msg))
-
-def checkin(x, copts, fn):
-    f = open(fn)
-    data = f.read()
-    f.close()
-    new = not x.isvalid(fn)
-    if not new and same(x, copts, fn, data):
-        print("%s: unchanged since last checkin" % fn)
-        return
-    print("Checking in", fn, "...")
-    message = asklogmessage(new)
-    messages = x.put(fn, data, message)
-    if messages:
-        print(messages)
-
-def checkout(x, copts, fn):
-    data = x.get(fn)
-    f = open(fn, 'w')
-    f.write(data)
-    f.close()
-
-def lock(x, copts, fn):
-    x.lock(fn)
-
-def unlock(x, copts, fn):
-    x.unlock(fn)
-
-def info(x, copts, fn):
-    info_dict = x.info(fn)
-    for key in sorted(info_dict.keys()):
-        print(key + ':', info_dict[key])
-    print('='*70)
-
-def head(x, copts, fn):
-    head = x.head(fn)
-    print(fn, head)
-
-def list(x, copts, fn):
-    if x.isvalid(fn):
-        print(fn)
-
-def log(x, copts, fn):
-    flags = ''
-    for o, a in copts:
-        flags = flags + ' ' + o + a
-    flags = flags[1:]
-    messages = x.log(fn, flags)
-    print(messages)
-
-def diff(x, copts, fn):
-    if same(x, copts, fn):
-        return
-    flags = ''
-    for o, a in copts:
-        flags = flags + ' ' + o + a
-    flags = flags[1:]
-    data = x.get(fn)
-    tf = tempfile.NamedTemporaryFile()
-    tf.write(data)
-    tf.flush()
-    print('diff %s -r%s %s' % (flags, x.head(fn), fn))
-    sts = os.system('diff %s %s %s' % (flags, tf.name, fn))
-    if sts:
-        print('='*70)
-
-def same(x, copts, fn, data = None):
-    if data is None:
-        f = open(fn)
-        data = f.read()
-        f.close()
-    lsum = md5.new(data).digest()
-    rsum = x.sum(fn)
-    return lsum == rsum
-
-def asklogmessage(new):
-    if new:
-        print("enter description,", end=' ')
-    else:
-        print("enter log message,", end=' ')
-    print("terminate with single '.' or end of file:")
-    if new:
-        print("NOTE: This is NOT the log message!")
-    message = ""
-    while 1:
-        sys.stderr.write(">> ")
-        sys.stderr.flush()
-        line = sys.stdin.readline()
-        if not line or line == '.\n': break
-        message = message + line
-    return message
-
-def remove(fn):
-    try:
-        os.unlink(fn)
-    except os.error:
-        pass
-
-commands = {
-        'ci': ('', checkin),
-        'put': ('', checkin),
-        'co': ('', checkout),
-        'get': ('', checkout),
-        'info': ('', info),
-        'head': ('', head),
-        'list': ('', list),
-        'lock': ('', lock),
-        'unlock': ('', unlock),
-        'log': ('bhLRtd:l:r:s:w:V:', log),
-        'diff': ('c', diff),
-        }
-
-if __name__ == '__main__':
-    main()
diff --git a/Demo/pdist/security.py b/Demo/pdist/security.py
deleted file mode 100755
index ffdbe2d..0000000
--- a/Demo/pdist/security.py
+++ /dev/null
@@ -1,33 +0,0 @@
-class Security:
-
-    def __init__(self):
-        import os
-        env = os.environ
-        if 'PYTHON_KEYFILE' in env:
-            keyfile = env['PYTHON_KEYFILE']
-        else:
-            keyfile = '.python_keyfile'
-            if 'HOME' in env:
-                keyfile = os.path.join(env['HOME'], keyfile)
-            if not os.path.exists(keyfile):
-                import sys
-                for dir in sys.path:
-                    kf = os.path.join(dir, keyfile)
-                    if os.path.exists(kf):
-                        keyfile = kf
-                        break
-        try:
-            self._key = eval(open(keyfile).readline())
-        except IOError:
-            raise IOError("python keyfile %s: cannot open" % keyfile)
-
-    def _generate_challenge(self):
-        import random
-        return random.randint(100, 100000)
-
-    def _compare_challenge_response(self, challenge, response):
-        return self._encode_challenge(challenge) == response
-
-    def _encode_challenge(self, challenge):
-        p, m = self._key
-        return pow(int(challenge), p, m)
diff --git a/Demo/pdist/server.py b/Demo/pdist/server.py
deleted file mode 100755
index b3943ff..0000000
--- a/Demo/pdist/server.py
+++ /dev/null
@@ -1,143 +0,0 @@
-"""RPC Server module."""
-
-import sys
-import socket
-import pickle
-from fnmatch import fnmatch
-from reprlib import repr
-
-
-# Default verbosity (0 = silent, 1 = print connections, 2 = print requests too)
-VERBOSE = 1
-
-
-class Server:
-
-    """RPC Server class.  Derive a class to implement a particular service."""
-
-    def __init__(self, address, verbose = VERBOSE):
-        if type(address) == type(0):
-            address = ('', address)
-        self._address = address
-        self._verbose = verbose
-        self._socket = None
-        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self._socket.bind(address)
-        self._socket.listen(1)
-        self._listening = 1
-
-    def _setverbose(self, verbose):
-        self._verbose = verbose
-
-    def __del__(self):
-        self._close()
-
-    def _close(self):
-        self._listening = 0
-        if self._socket:
-            self._socket.close()
-        self._socket = None
-
-    def _serverloop(self):
-        while self._listening:
-            self._serve()
-
-    def _serve(self):
-        if self._verbose: print("Wait for connection ...")
-        conn, address = self._socket.accept()
-        if self._verbose: print("Accepted connection from %s" % repr(address))
-        if not self._verify(conn, address):
-            print("*** Connection from %s refused" % repr(address))
-            conn.close()
-            return
-        rf = conn.makefile('r')
-        wf = conn.makefile('w')
-        ok = 1
-        while ok:
-            wf.flush()
-            if self._verbose > 1: print("Wait for next request ...")
-            ok = self._dorequest(rf, wf)
-
-    _valid = ['192.16.201.*', '192.16.197.*', '132.151.1.*', '129.6.64.*']
-
-    def _verify(self, conn, address):
-        host, port = address
-        for pat in self._valid:
-            if fnmatch(host, pat): return 1
-        return 0
-
-    def _dorequest(self, rf, wf):
-        rp = pickle.Unpickler(rf)
-        try:
-            request = rp.load()
-        except EOFError:
-            return 0
-        if self._verbose > 1: print("Got request: %s" % repr(request))
-        try:
-            methodname, args, id = request
-            if '.' in methodname:
-                reply = (None, self._special(methodname, args), id)
-            elif methodname[0] == '_':
-                raise NameError("illegal method name %s" % repr(methodname))
-            else:
-                method = getattr(self, methodname)
-                reply = (None, method(*args), id)
-        except:
-            reply = (sys.exc_info()[:2], id)
-        if id < 0 and reply[:2] == (None, None):
-            if self._verbose > 1: print("Suppress reply")
-            return 1
-        if self._verbose > 1: print("Send reply: %s" % repr(reply))
-        wp = pickle.Pickler(wf)
-        wp.dump(reply)
-        return 1
-
-    def _special(self, methodname, args):
-        if methodname == '.methods':
-            if not hasattr(self, '_methods'):
-                self._methods = tuple(self._listmethods())
-            return self._methods
-        raise NameError("unrecognized special method name %s" % repr(methodname))
-
-    def _listmethods(self, cl=None):
-        if not cl: cl = self.__class__
-        names = sorted([x for x in cl.__dict__.keys() if x[0] != '_'])
-        for base in cl.__bases__:
-            basenames = self._listmethods(base)
-            basenames = list(filter(lambda x, names=names: x not in names, basenames))
-            names[len(names):] = basenames
-        return names
-
-
-from security import Security
-
-
-class SecureServer(Server, Security):
-
-    def __init__(self, *args):
-        Server.__init__(self, *args)
-        Security.__init__(self)
-
-    def _verify(self, conn, address):
-        import string
-        challenge = self._generate_challenge()
-        conn.send("%d\n" % challenge)
-        response = ""
-        while "\n" not in response and len(response) < 100:
-            data = conn.recv(100)
-            if not data:
-                break
-            response = response + data
-        try:
-            response = string.atol(string.strip(response))
-        except string.atol_error:
-            if self._verbose > 0:
-                print("Invalid response syntax", repr(response))
-            return 0
-        if not self._compare_challenge_response(challenge, response):
-            if self._verbose > 0:
-                print("Invalid response value", repr(response))
-            return 0
-        if self._verbose > 1:
-            print("Response matches challenge.  Go ahead!")
-        return 1
diff --git a/Demo/pdist/sumtree.py b/Demo/pdist/sumtree.py
deleted file mode 100755
index 92e7771..0000000
--- a/Demo/pdist/sumtree.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import time
-import sys
-import FSProxy
-
-def main():
-    t1 = time.time()
-    #proxy = FSProxy.FSProxyClient(('voorn.cwi.nl', 4127))
-    proxy = FSProxy.FSProxyLocal()
-    sumtree(proxy)
-    proxy._close()
-    t2 = time.time()
-    print(t2-t1, "seconds")
-    sys.stdout.write("[Return to exit] ")
-    sys.stdout.flush()
-    sys.stdin.readline()
-
-def sumtree(proxy):
-    print("PWD =", proxy.pwd())
-    files = proxy.listfiles()
-    proxy.infolist(files)
-    subdirs = proxy.listsubdirs()
-    for name in subdirs:
-        proxy.cd(name)
-        sumtree(proxy)
-        proxy.back()
-
-main()
diff --git a/Demo/pysvr/Makefile b/Demo/pysvr/Makefile
deleted file mode 100644
index b4b9f3e..0000000
--- a/Demo/pysvr/Makefile
+++ /dev/null
@@ -1,57 +0,0 @@
-# Makefile for 'pysvr' application embedding Python.
-# Tailored for Python 1.5a3 or later.
-# Some details are specific for Solaris or CNRI.
-# Also see ## comments for tailoring.
-
-# Which C compiler
-CC=gcc
-##PURIFY=/usr/local/pure/purify
-LINKCC=$(PURIFY) $(CC)
-
-# Optimization preferences
-OPT=-g
-
-# Which Python version we're using
-VER=2.2
-
-# Expressions using the above definitions
-PYVER=python$(VER)
-
-# Use these defs when compiling against installed Python
-##INST=/usr/local
-##PYC=$(INST)/lib/$(PYVER)/config
-##PYINCL=-I$(INST)/include/$(PYVER) -I$(PYC)
-##PYLIBS=$(PYC)/lib$(PYVER).a
-
-# Use these defs when compiling against built Python
-PLAT=linux
-PYINCL=-I../../Include -I../../$(PLAT)
-PYLIBS=../../$(PLAT)/lib$(PYVER).a
-
-# Libraries to link with -- very installation dependent
-# (See LIBS= in Modules/Makefile in build tree)
-RLLIBS=-lreadline -ltermcap
-OTHERLIBS=-lnsl -lpthread -ldl -lm -ldb -lutil
-
-# Compilation and link flags -- no need to change normally
-CFLAGS=$(OPT)
-CPPFLAGS=$(PYINCL)
-LIBS=$(PYLIBS) $(RLLIBS) $(OTHERLIBS)
-
-# Default port for the pysvr application
-PORT=4000
-
-# Default target
-all: pysvr
-
-# Target to build pysvr
-pysvr: pysvr.o $(PYOBJS) $(PYLIBS)
-	$(LINKCC) pysvr.o $(LIBS) -o pysvr
-
-# Target to build and run pysvr
-run: pysvr
-	pysvr $(PORT)
-
-# Target to clean up the directory
-clean:
-	-rm -f pysvr *.o *~ core
diff --git a/Demo/pysvr/README b/Demo/pysvr/README
deleted file mode 100644
index 5e64e38..0000000
--- a/Demo/pysvr/README
+++ /dev/null
@@ -1,9 +0,0 @@
-This is an example of a multi-threaded C application embedding a
-Python interpreter.
-
-The particular application is a multi-threaded telnet-like server that
-provides you with a Python prompt (instead of a shell prompt).
-
-The file pysvr.py is a prototype in Python.
-
-THIS APPLICATION IS NOT SECURE -- ONLY USE IT FOR TESTING!
diff --git a/Demo/pysvr/pysvr.c b/Demo/pysvr/pysvr.c
deleted file mode 100644
index 706cd2a..0000000
--- a/Demo/pysvr/pysvr.c
+++ /dev/null
@@ -1,370 +0,0 @@
-/* A multi-threaded telnet-like server that gives a Python prompt.
-
-Usage: pysvr [port]
-
-For security reasons, it only accepts requests from the current host.
-This can still be insecure, but restricts violations from people who
-can log in on your machine.  Use with caution!
-
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-
-#include <pthread.h>
-#include <getopt.h>
-
-/* XXX Umpfh.
-   Python.h defines a typedef destructor, which conflicts with pthread.h.
-   So Python.h must be included after pthread.h. */
-
-#include "Python.h"
-
-extern int Py_VerboseFlag;
-
-#ifndef PORT
-#define PORT 4000
-#endif
-
-struct workorder {
-    int conn;
-    struct sockaddr_in addr;
-};
-
-/* Forward */
-static void init_python(void);
-static void usage(void);
-static void oprogname(void);
-static void main_thread(int);
-static void create_thread(int, struct sockaddr_in *);
-static void *service_thread(struct workorder *);
-static void run_interpreter(FILE *, FILE *);
-static int run_command(char *, PyObject *);
-static void ps(void);
-
-static char *progname = "pysvr";
-
-static PyThreadState *gtstate;
-
-main(int argc, char **argv)
-{
-    int port = PORT;
-    int c;
-
-    if (argc > 0 && argv[0] != NULL && argv[0][0] != '\0')
-        progname = argv[0];
-
-    while ((c = getopt(argc, argv, "v")) != EOF) {
-        switch (c) {
-        case 'v':
-            Py_VerboseFlag++;
-            break;
-        default:
-            usage();
-        }
-    }
-
-    if (optind < argc) {
-        if (optind+1 < argc) {
-            oprogname();
-            fprintf(stderr, "too many arguments\n");
-            usage();
-        }
-        port = atoi(argv[optind]);
-        if (port <= 0) {
-            fprintf(stderr, "bad port (%s)\n", argv[optind]);
-            usage();
-        }
-    }
-
-    main_thread(port);
-
-    fprintf(stderr, "Bye.\n");
-
-    exit(0);
-}
-
-static char usage_line[] = "usage: %s [port]\n";
-
-static void
-usage(void)
-{
-    fprintf(stderr, usage_line, progname);
-    exit(2);
-}
-
-static void
-main_thread(int port)
-{
-    int sock, conn, size, i;
-    struct sockaddr_in addr, clientaddr;
-
-    sock = socket(PF_INET, SOCK_STREAM, 0);
-    if (sock < 0) {
-        oprogname();
-        perror("can't create socket");
-        exit(1);
-    }
-
-#ifdef SO_REUSEADDR
-    i = 1;
-    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof i);
-#endif
-
-    memset((char *)&addr, '\0', sizeof addr);
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(port);
-    addr.sin_addr.s_addr = 0L;
-    if (bind(sock, (struct sockaddr *)&addr, sizeof addr) < 0) {
-        oprogname();
-        perror("can't bind socket to address");
-        exit(1);
-    }
-
-    if (listen(sock, 5) < 0) {
-        oprogname();
-        perror("can't listen on socket");
-        exit(1);
-    }
-
-    fprintf(stderr, "Listening on port %d...\n", port);
-
-    for (i = 0; ; i++) {
-        size = sizeof clientaddr;
-        memset((char *) &clientaddr, '\0', size);
-        conn = accept(sock, (struct sockaddr *) &clientaddr, &size);
-        if (conn < 0) {
-            oprogname();
-            perror("can't accept connection from socket");
-            exit(1);
-        }
-
-        size = sizeof addr;
-        memset((char *) &addr, '\0', size);
-        if (getsockname(conn, (struct sockaddr *)&addr, &size) < 0) {
-            oprogname();
-            perror("can't get socket name of connection");
-            exit(1);
-        }
-        if (clientaddr.sin_addr.s_addr != addr.sin_addr.s_addr) {
-            oprogname();
-            perror("connection from non-local host refused");
-            fprintf(stderr, "(addr=%lx, clientaddr=%lx)\n",
-                ntohl(addr.sin_addr.s_addr),
-                ntohl(clientaddr.sin_addr.s_addr));
-            close(conn);
-            continue;
-        }
-        if (i == 4) {
-            close(conn);
-            break;
-        }
-        create_thread(conn, &clientaddr);
-    }
-
-    close(sock);
-
-    if (gtstate) {
-        PyEval_AcquireThread(gtstate);
-        gtstate = NULL;
-        Py_Finalize();
-        /* And a second time, just because we can. */
-        Py_Finalize(); /* This should be harmless. */
-    }
-    exit(0);
-}
-
-static void
-create_thread(int conn, struct sockaddr_in *addr)
-{
-    struct workorder *work;
-    pthread_t tdata;
-
-    work = malloc(sizeof(struct workorder));
-    if (work == NULL) {
-        oprogname();
-        fprintf(stderr, "out of memory for thread.\n");
-        close(conn);
-        return;
-    }
-    work->conn = conn;
-    work->addr = *addr;
-
-    init_python();
-
-    if (pthread_create(&tdata, NULL, (void *)service_thread, work) < 0) {
-        oprogname();
-        perror("can't create new thread");
-        close(conn);
-        return;
-    }
-
-    if (pthread_detach(tdata) < 0) {
-        oprogname();
-        perror("can't detach from thread");
-    }
-}
-
-static PyThreadState *the_tstate;
-static PyInterpreterState *the_interp;
-static PyObject *the_builtins;
-
-static void
-init_python(void)
-{
-    if (gtstate)
-        return;
-    Py_Initialize(); /* Initialize the interpreter */
-    PyEval_InitThreads(); /* Create (and acquire) the interpreter lock */
-    gtstate = PyEval_SaveThread(); /* Release the thread state */
-}
-
-static void *
-service_thread(struct workorder *work)
-{
-    FILE *input, *output;
-
-    fprintf(stderr, "Start thread for connection %d.\n", work->conn);
-
-    ps();
-
-    input = fdopen(work->conn, "r");
-    if (input == NULL) {
-        oprogname();
-        perror("can't create input stream");
-        goto done;
-    }
-
-    output = fdopen(work->conn, "w");
-    if (output == NULL) {
-        oprogname();
-        perror("can't create output stream");
-        fclose(input);
-        goto done;
-    }
-
-    setvbuf(input, NULL, _IONBF, 0);
-    setvbuf(output, NULL, _IONBF, 0);
-
-    run_interpreter(input, output);
-
-    fclose(input);
-    fclose(output);
-
-  done:
-    fprintf(stderr, "End thread for connection %d.\n", work->conn);
-    close(work->conn);
-    free(work);
-}
-
-static void
-oprogname(void)
-{
-    int save = errno;
-    fprintf(stderr, "%s: ", progname);
-    errno = save;
-}
-
-static void
-run_interpreter(FILE *input, FILE *output)
-{
-    PyThreadState *tstate;
-    PyObject *new_stdin, *new_stdout;
-    PyObject *mainmod, *globals;
-    char buffer[1000];
-    char *p, *q;
-    int n, end;
-
-    PyEval_AcquireLock();
-    tstate = Py_NewInterpreter();
-    if (tstate == NULL) {
-        fprintf(output, "Sorry -- can't create an interpreter\n");
-        return;
-    }
-
-    mainmod = PyImport_AddModule("__main__");
-    globals = PyModule_GetDict(mainmod);
-    Py_INCREF(globals);
-
-    new_stdin = PyFile_FromFile(input, "<socket-in>", "r", NULL);
-    new_stdout = PyFile_FromFile(output, "<socket-out>", "w", NULL);
-
-    PySys_SetObject("stdin", new_stdin);
-    PySys_SetObject("stdout", new_stdout);
-    PySys_SetObject("stderr", new_stdout);
-
-    for (n = 1; !PyErr_Occurred(); n++) {
-        Py_BEGIN_ALLOW_THREADS
-        fprintf(output, "%d> ", n);
-        p = fgets(buffer, sizeof buffer, input);
-        Py_END_ALLOW_THREADS
-
-        if (p == NULL)
-            break;
-        if (p[0] == '\377' && p[1] == '\354')
-            break;
-
-        q = strrchr(p, '\r');
-        if (q && q[1] == '\n' && q[2] == '\0') {
-            *q++ = '\n';
-            *q++ = '\0';
-        }
-
-        while (*p && isspace(*p))
-            p++;
-        if (p[0] == '#' || p[0] == '\0')
-            continue;
-
-        end = run_command(buffer, globals);
-        if (end < 0)
-            PyErr_Print();
-
-        if (end)
-            break;
-    }
-
-    Py_XDECREF(globals);
-    Py_XDECREF(new_stdin);
-    Py_XDECREF(new_stdout);
-
-    Py_EndInterpreter(tstate);
-    PyEval_ReleaseLock();
-
-    fprintf(output, "Goodbye!\n");
-}
-
-static int
-run_command(char *buffer, PyObject *globals)
-{
-    PyObject *m, *d, *v;
-    fprintf(stderr, "run_command: %s", buffer);
-    if (strchr(buffer, '\n') == NULL)
-        fprintf(stderr, "\n");
-    v = PyRun_String(buffer, Py_single_input, globals, globals);
-    if (v == NULL) {
-        if (PyErr_Occurred() == PyExc_SystemExit) {
-            PyErr_Clear();
-            return 1;
-        }
-        PyErr_Print();
-        return 0;
-    }
-    Py_DECREF(v);
-    return 0;
-}
-
-static void
-ps(void)
-{
-    char buffer[100];
-    PyOS_snprintf(buffer, sizeof(buffer),
-                  "ps -l -p %d </dev/null | sed 1d\n", getpid());
-    system(buffer);
-}
diff --git a/Demo/pysvr/pysvr.py b/Demo/pysvr/pysvr.py
deleted file mode 100755
index 3e94dbe..0000000
--- a/Demo/pysvr/pysvr.py
+++ /dev/null
@@ -1,124 +0,0 @@
-#! /usr/bin/env python
-
-"""A multi-threaded telnet-like server that gives a Python prompt.
-
-This is really a prototype for the same thing in C.
-
-Usage: pysvr.py [port]
-
-For security reasons, it only accepts requests from the current host.
-This can still be insecure, but restricts violations from people who
-can log in on your machine.  Use with caution!
-
-"""
-
-import sys, os, string, getopt, _thread, socket, traceback
-
-PORT = 4000                             # Default port
-
-def main():
-    try:
-        opts, args = getopt.getopt(sys.argv[1:], "")
-        if len(args) > 1:
-            raise getopt.error("Too many arguments.")
-    except getopt.error as msg:
-        usage(msg)
-    for o, a in opts:
-        pass
-    if args:
-        try:
-            port = string.atoi(args[0])
-        except ValueError as msg:
-            usage(msg)
-    else:
-        port = PORT
-    main_thread(port)
-
-def usage(msg=None):
-    sys.stdout = sys.stderr
-    if msg:
-        print(msg)
-    print("\n", __doc__, end=' ')
-    sys.exit(2)
-
-def main_thread(port):
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.bind(("", port))
-    sock.listen(5)
-    print("Listening on port", port, "...")
-    while 1:
-        (conn, addr) = sock.accept()
-        if addr[0] != conn.getsockname()[0]:
-            conn.close()
-            print("Refusing connection from non-local host", addr[0], ".")
-            continue
-        _thread.start_new_thread(service_thread, (conn, addr))
-        del conn, addr
-
-def service_thread(conn, addr):
-    (caddr, cport) = addr
-    print("Thread %s has connection from %s.\n" % (str(_thread.get_ident()),
-                                                   caddr), end=' ')
-    stdin = conn.makefile("r")
-    stdout = conn.makefile("w", 0)
-    run_interpreter(stdin, stdout)
-    print("Thread %s is done.\n" % str(_thread.get_ident()), end=' ')
-
-def run_interpreter(stdin, stdout):
-    globals = {}
-    try:
-        str(sys.ps1)
-    except:
-        sys.ps1 = ">>> "
-    source = ""
-    while 1:
-        stdout.write(sys.ps1)
-        line = stdin.readline()
-        if line[:2] == '\377\354':
-            line = ""
-        if not line and not source:
-            break
-        if line[-2:] == '\r\n':
-            line = line[:-2] + '\n'
-        source = source + line
-        try:
-            code = compile_command(source)
-        except SyntaxError as err:
-            source = ""
-            traceback.print_exception(SyntaxError, err, None, file=stdout)
-            continue
-        if not code:
-            continue
-        source = ""
-        try:
-            run_command(code, stdin, stdout, globals)
-        except SystemExit as how:
-            if how:
-                try:
-                    how = str(how)
-                except:
-                    how = ""
-                stdout.write("Exit %s\n" % how)
-            break
-    stdout.write("\nGoodbye.\n")
-
-def run_command(code, stdin, stdout, globals):
-    save = sys.stdin, sys.stdout, sys.stderr
-    try:
-        sys.stdout = sys.stderr = stdout
-        sys.stdin = stdin
-        try:
-            exec(code, globals)
-        except SystemExit as how:
-            raise SystemExit(how).with_traceback(sys.exc_info()[2])
-        except:
-            type, value, tb = sys.exc_info()
-            if tb: tb = tb.tb_next
-            traceback.print_exception(type, value, tb)
-            del tb
-    finally:
-        sys.stdin, sys.stdout, sys.stderr = save
-
-from code import compile_command
-
-main()
diff --git a/Demo/rpc/MANIFEST b/Demo/rpc/MANIFEST
deleted file mode 100644
index e65f3eb..0000000
--- a/Demo/rpc/MANIFEST
+++ /dev/null
@@ -1,10 +0,0 @@
-   File Name		Archive #	Description
------------------------------------------------------------
- MANIFEST                   1	This shipping list
- README                     1	
- T.py                       1	
- mountclient.py             1	
- nfsclient.py               1	
- rpc.py                     1	
- test                       1
- xdr.py                     1	
diff --git a/Demo/rpc/README b/Demo/rpc/README
deleted file mode 100644
index 97948a3..0000000
--- a/Demo/rpc/README
+++ /dev/null
@@ -1,31 +0,0 @@
-This is a Python interface to Sun RPC, designed and implemented mostly
-by reading the Internet RFCs about the subject.
-
-*** NOTE: xdr.py has evolved into the standard module xdrlib.py ***
-
-There are two library modules, xdr.py and rpc.py, and several example
-clients: mountclient.py, nfsclient.py, and rnusersclient.py,
-implementing the NFS Mount protocol, (part of) the NFS protocol, and
-the "rnusers" protocol (used by rusers(1)), respectively.  The latter
-demonstrates the use of broadcast via the Port mapper's CALLIT
-procedure.
-
-There is also a way to create servers in Python.
-
-To test the nfs client, run it from the shell with something like this:
-
-  python -c 'import nfsclient; nfsclient.test()' [hostname [filesystemname]]
-
-When called without a filesystemname, it lists the filesystems at the
-host; default host is the local machine.
-
-Other clients are tested similarly.
-
-For hostname, use e.g. wuarchive.wustl.edu or gatekeeper.dec.com (two
-hosts that are known to export NFS filesystems with little restrictions).
-
-There are now two different RPC compilers:
-
-1) Wim Lewis rpcgen.py found on http://www.omnigroup.com/~wiml/soft/stale-index.html#python. 
-
-2) Peter �strands rpcgen.py, which is part of "pynfs" (http://www.cendio.se/~peter/pynfs/). 
diff --git a/Demo/rpc/T.py b/Demo/rpc/T.py
deleted file mode 100644
index 3325507..0000000
--- a/Demo/rpc/T.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Simple interface to report execution times of program fragments.
-# Call TSTART() to reset the timer, TSTOP(...) to report times.
-
-import sys, os, time
-
-def TSTART():
-    global t0, t1
-    u, s, cu, cs = os.times()
-    t0 = u+cu, s+cs, time.time()
-
-def TSTOP(*label):
-    global t0, t1
-    u, s, cu, cs = os.times()
-    t1 = u+cu, s+cs, time.time()
-    tt = []
-    for i in range(3):
-        tt.append(t1[i] - t0[i])
-    [u, s, r] = tt
-    msg = ''
-    for x in label: msg = msg + (x + ' ')
-    msg = msg + '%r user, %r sys, %r real\n' % (u, s, r)
-    sys.stderr.write(msg)
diff --git a/Demo/rpc/mountclient.py b/Demo/rpc/mountclient.py
deleted file mode 100644
index 81797df..0000000
--- a/Demo/rpc/mountclient.py
+++ /dev/null
@@ -1,202 +0,0 @@
-# Mount RPC client -- RFC 1094 (NFS), Appendix A
-
-# This module demonstrates how to write your own RPC client in Python.
-# When this example was written, there was no RPC compiler for
-# Python. Without such a compiler, you must first create classes
-# derived from Packer and Unpacker to handle the data types for the
-# server you want to interface to.  You then write the client class.
-# If you want to support both the TCP and the UDP version of a
-# protocol, use multiple inheritance as shown below.
-
-
-import rpc
-from rpc import Packer, Unpacker, TCPClient, UDPClient
-
-
-# Program number and version for the mount protocol
-MOUNTPROG = 100005
-MOUNTVERS = 1
-
-# Size of the 'fhandle' opaque structure
-FHSIZE = 32
-
-
-# Packer derived class for Mount protocol clients.
-# The only thing we need to pack beyond basic types is an 'fhandle'
-
-class MountPacker(Packer):
-
-    def pack_fhandle(self, fhandle):
-        self.pack_fopaque(FHSIZE, fhandle)
-
-
-# Unpacker derived class for Mount protocol clients.
-# The important types we need to unpack are fhandle, fhstatus,
-# mountlist and exportlist; mountstruct, exportstruct and groups are
-# used to unpack components of mountlist and exportlist and the
-# corresponding functions are passed as function argument to the
-# generic unpack_list function.
-
-class MountUnpacker(Unpacker):
-
-    def unpack_fhandle(self):
-        return self.unpack_fopaque(FHSIZE)
-
-    def unpack_fhstatus(self):
-        status = self.unpack_uint()
-        if status == 0:
-            fh = self.unpack_fhandle()
-        else:
-            fh = None
-        return status, fh
-
-    def unpack_mountlist(self):
-        return self.unpack_list(self.unpack_mountstruct)
-
-    def unpack_mountstruct(self):
-        hostname = self.unpack_string()
-        directory = self.unpack_string()
-        return (hostname, directory)
-
-    def unpack_exportlist(self):
-        return self.unpack_list(self.unpack_exportstruct)
-
-    def unpack_exportstruct(self):
-        filesys = self.unpack_string()
-        groups = self.unpack_groups()
-        return (filesys, groups)
-
-    def unpack_groups(self):
-        return self.unpack_list(self.unpack_string)
-
-
-# These are the procedures specific to the Mount client class.
-# Think of this as a derived class of either TCPClient or UDPClient.
-
-class PartialMountClient:
-
-    # This method is called by Client.__init__ to initialize
-    # self.packer and self.unpacker
-    def addpackers(self):
-        self.packer = MountPacker()
-        self.unpacker = MountUnpacker('')
-
-    # This method is called by Client.__init__ to bind the socket
-    # to a particular network interface and port.  We use the
-    # default network interface, but if we're running as root,
-    # we want to bind to a reserved port
-    def bindsocket(self):
-        import os
-        try:
-            uid = os.getuid()
-        except AttributeError:
-            uid = 1
-        if uid == 0:
-            port = rpc.bindresvport(self.sock, '')
-            # 'port' is not used
-        else:
-            self.sock.bind(('', 0))
-
-    # This function is called to cough up a suitable
-    # authentication object for a call to procedure 'proc'.
-    def mkcred(self):
-        if self.cred is None:
-            self.cred = rpc.AUTH_UNIX, rpc.make_auth_unix_default()
-        return self.cred
-
-    # The methods Mnt, Dump etc. each implement one Remote
-    # Procedure Call.  This is done by calling self.make_call()
-    # with as arguments:
-    #
-    # - the procedure number
-    # - the arguments (or None)
-    # - the "packer" function for the arguments (or None)
-    # - the "unpacker" function for the return value (or None)
-    #
-    # The packer and unpacker function, if not None, *must* be
-    # methods of self.packer and self.unpacker, respectively.
-    # A value of None means that there are no arguments or is no
-    # return value, respectively.
-    #
-    # The return value from make_call() is the return value from
-    # the remote procedure call, as unpacked by the "unpacker"
-    # function, or None if the unpacker function is None.
-    #
-    # (Even if you expect a result of None, you should still
-    # return the return value from make_call(), since this may be
-    # needed by a broadcasting version of the class.)
-    #
-    # If the call fails, make_call() raises an exception
-    # (this includes time-outs and invalid results).
-    #
-    # Note that (at least with the UDP protocol) there is no
-    # guarantee that a call is executed at most once.  When you do
-    # get a reply, you know it has been executed at least once;
-    # when you don't get a reply, you know nothing.
-
-    def Mnt(self, directory):
-        return self.make_call(1, directory, \
-                self.packer.pack_string, \
-                self.unpacker.unpack_fhstatus)
-
-    def Dump(self):
-        return self.make_call(2, None, \
-                None, self.unpacker.unpack_mountlist)
-
-    def Umnt(self, directory):
-        return self.make_call(3, directory, \
-                self.packer.pack_string, None)
-
-    def Umntall(self):
-        return self.make_call(4, None, None, None)
-
-    def Export(self):
-        return self.make_call(5, None, \
-                None, self.unpacker.unpack_exportlist)
-
-
-# We turn the partial Mount client into a full one for either protocol
-# by use of multiple inheritance.  (In general, when class C has base
-# classes B1...Bn, if x is an instance of class C, methods of x are
-# searched first in C, then in B1, then in B2, ..., finally in Bn.)
-
-class TCPMountClient(PartialMountClient, TCPClient):
-
-    def __init__(self, host):
-        TCPClient.__init__(self, host, MOUNTPROG, MOUNTVERS)
-
-
-class UDPMountClient(PartialMountClient, UDPClient):
-
-    def __init__(self, host):
-        UDPClient.__init__(self, host, MOUNTPROG, MOUNTVERS)
-
-
-# A little test program for the Mount client.  This takes a host as
-# command line argument (default the local machine), prints its export
-# list, and attempts to mount and unmount each exported files system.
-# An optional first argument of -t or -u specifies the protocol to use
-# (TCP or UDP), default is UDP.
-
-def test():
-    import sys
-    if sys.argv[1:] and sys.argv[1] == '-t':
-        C = TCPMountClient
-        del sys.argv[1]
-    elif sys.argv[1:] and sys.argv[1] == '-u':
-        C = UDPMountClient
-        del sys.argv[1]
-    else:
-        C = UDPMountClient
-    if sys.argv[1:]: host = sys.argv[1]
-    else: host = ''
-    mcl = C(host)
-    list = mcl.Export()
-    for item in list:
-        print(item)
-        try:
-            mcl.Mnt(item[0])
-        except:
-            print('Sorry')
-            continue
-        mcl.Umnt(item[0])
diff --git a/Demo/rpc/nfsclient.py b/Demo/rpc/nfsclient.py
deleted file mode 100644
index a291ce0..0000000
--- a/Demo/rpc/nfsclient.py
+++ /dev/null
@@ -1,201 +0,0 @@
-# NFS RPC client -- RFC 1094
-
-# XXX This is not yet complete.
-# XXX Only GETATTR, SETTTR, LOOKUP and READDIR are supported.
-
-# (See mountclient.py for some hints on how to write RPC clients in
-# Python in general)
-
-import rpc
-from rpc import UDPClient, TCPClient
-from mountclient import FHSIZE, MountPacker, MountUnpacker
-
-NFS_PROGRAM = 100003
-NFS_VERSION = 2
-
-# enum stat
-NFS_OK = 0
-# (...many error values...)
-
-# enum ftype
-NFNON = 0
-NFREG = 1
-NFDIR = 2
-NFBLK = 3
-NFCHR = 4
-NFLNK = 5
-
-
-class NFSPacker(MountPacker):
-
-    def pack_sattrargs(self, sa):
-        file, attributes = sa
-        self.pack_fhandle(file)
-        self.pack_sattr(attributes)
-
-    def pack_sattr(self, sa):
-        mode, uid, gid, size, atime, mtime = sa
-        self.pack_uint(mode)
-        self.pack_uint(uid)
-        self.pack_uint(gid)
-        self.pack_uint(size)
-        self.pack_timeval(atime)
-        self.pack_timeval(mtime)
-
-    def pack_diropargs(self, da):
-        dir, name = da
-        self.pack_fhandle(dir)
-        self.pack_string(name)
-
-    def pack_readdirargs(self, ra):
-        dir, cookie, count = ra
-        self.pack_fhandle(dir)
-        self.pack_uint(cookie)
-        self.pack_uint(count)
-
-    def pack_timeval(self, tv):
-        secs, usecs = tv
-        self.pack_uint(secs)
-        self.pack_uint(usecs)
-
-
-class NFSUnpacker(MountUnpacker):
-
-    def unpack_readdirres(self):
-        status = self.unpack_enum()
-        if status == NFS_OK:
-            entries = self.unpack_list(self.unpack_entry)
-            eof = self.unpack_bool()
-            rest = (entries, eof)
-        else:
-            rest = None
-        return (status, rest)
-
-    def unpack_entry(self):
-        fileid = self.unpack_uint()
-        name = self.unpack_string()
-        cookie = self.unpack_uint()
-        return (fileid, name, cookie)
-
-    def unpack_diropres(self):
-        status = self.unpack_enum()
-        if status == NFS_OK:
-            fh = self.unpack_fhandle()
-            fa = self.unpack_fattr()
-            rest = (fh, fa)
-        else:
-            rest = None
-        return (status, rest)
-
-    def unpack_attrstat(self):
-        status = self.unpack_enum()
-        if status == NFS_OK:
-            attributes = self.unpack_fattr()
-        else:
-            attributes = None
-        return status, attributes
-
-    def unpack_fattr(self):
-        type = self.unpack_enum()
-        mode = self.unpack_uint()
-        nlink = self.unpack_uint()
-        uid = self.unpack_uint()
-        gid = self.unpack_uint()
-        size = self.unpack_uint()
-        blocksize = self.unpack_uint()
-        rdev = self.unpack_uint()
-        blocks = self.unpack_uint()
-        fsid = self.unpack_uint()
-        fileid = self.unpack_uint()
-        atime = self.unpack_timeval()
-        mtime = self.unpack_timeval()
-        ctime = self.unpack_timeval()
-        return (type, mode, nlink, uid, gid, size, blocksize, \
-                rdev, blocks, fsid, fileid, atime, mtime, ctime)
-
-    def unpack_timeval(self):
-        secs = self.unpack_uint()
-        usecs = self.unpack_uint()
-        return (secs, usecs)
-
-
-class NFSClient(UDPClient):
-
-    def __init__(self, host):
-        UDPClient.__init__(self, host, NFS_PROGRAM, NFS_VERSION)
-
-    def addpackers(self):
-        self.packer = NFSPacker()
-        self.unpacker = NFSUnpacker('')
-
-    def mkcred(self):
-        if self.cred is None:
-            self.cred = rpc.AUTH_UNIX, rpc.make_auth_unix_default()
-        return self.cred
-
-    def Getattr(self, fh):
-        return self.make_call(1, fh, \
-                self.packer.pack_fhandle, \
-                self.unpacker.unpack_attrstat)
-
-    def Setattr(self, sa):
-        return self.make_call(2, sa, \
-                self.packer.pack_sattrargs, \
-                self.unpacker.unpack_attrstat)
-
-    # Root() is obsolete
-
-    def Lookup(self, da):
-        return self.make_call(4, da, \
-                self.packer.pack_diropargs, \
-                self.unpacker.unpack_diropres)
-
-    # ...
-
-    def Readdir(self, ra):
-        return self.make_call(16, ra, \
-                self.packer.pack_readdirargs, \
-                self.unpacker.unpack_readdirres)
-
-    # Shorthand to get the entire contents of a directory
-    def Listdir(self, dir):
-        list = []
-        ra = (dir, 0, 2000)
-        while 1:
-            (status, rest) = self.Readdir(ra)
-            if status != NFS_OK:
-                break
-            entries, eof = rest
-            last_cookie = None
-            for fileid, name, cookie in entries:
-                list.append((fileid, name))
-                last_cookie = cookie
-            if eof or last_cookie is None:
-                break
-            ra = (ra[0], last_cookie, ra[2])
-        return list
-
-
-def test():
-    import sys
-    if sys.argv[1:]: host = sys.argv[1]
-    else: host = ''
-    if sys.argv[2:]: filesys = sys.argv[2]
-    else: filesys = None
-    from mountclient import UDPMountClient, TCPMountClient
-    mcl = TCPMountClient(host)
-    if filesys is None:
-        list = mcl.Export()
-        for item in list:
-            print(item)
-        return
-    sf = mcl.Mnt(filesys)
-    print(sf)
-    fh = sf[1]
-    if fh:
-        ncl = NFSClient(host)
-        attrstat = ncl.Getattr(fh)
-        print(attrstat)
-        list = ncl.Listdir(fh)
-        for item in list: print(item)
-        mcl.Umnt(filesys)
diff --git a/Demo/rpc/rnusersclient.py b/Demo/rpc/rnusersclient.py
deleted file mode 100644
index eaabefe..0000000
--- a/Demo/rpc/rnusersclient.py
+++ /dev/null
@@ -1,98 +0,0 @@
-# Remote nusers client interface
-
-import rpc
-from rpc import Packer, Unpacker, UDPClient, BroadcastUDPClient
-
-
-class RnusersPacker(Packer):
-    def pack_utmp(self, ui):
-        ut_line, ut_name, ut_host, ut_time = utmp
-        self.pack_string(ut_line)
-        self.pack_string(ut_name)
-        self.pack_string(ut_host)
-        self.pack_int(ut_time)
-    def pack_utmpidle(self, ui):
-        ui_itmp, ui_idle = ui
-        self.pack_utmp(ui_utmp)
-        self.pack_uint(ui_idle)
-    def pack_utmpidlearr(self, list):
-        self.pack_array(list, self.pack_itmpidle)
-
-
-class RnusersUnpacker(Unpacker):
-    def unpack_utmp(self):
-        ut_line = self.unpack_string()
-        ut_name = self.unpack_string()
-        ut_host = self.unpack_string()
-        ut_time = self.unpack_int()
-        return ut_line, ut_name, ut_host, ut_time
-    def unpack_utmpidle(self):
-        ui_utmp = self.unpack_utmp()
-        ui_idle = self.unpack_uint()
-        return ui_utmp, ui_idle
-    def unpack_utmpidlearr(self):
-        return self.unpack_array(self.unpack_utmpidle)
-
-
-class PartialRnusersClient:
-
-    def addpackers(self):
-        self.packer = RnusersPacker()
-        self.unpacker = RnusersUnpacker('')
-
-    def Num(self):
-        return self.make_call(1, None, None, self.unpacker.unpack_int)
-
-    def Names(self):
-        return self.make_call(2, None, \
-                None, self.unpacker.unpack_utmpidlearr)
-
-    def Allnames(self):
-        return self.make_call(3, None, \
-                None, self.unpacker.unpack_utmpidlearr)
-
-
-class RnusersClient(PartialRnusersClient, UDPClient):
-
-    def __init__(self, host):
-        UDPClient.__init__(self, host, 100002, 2)
-
-
-class BroadcastRnusersClient(PartialRnusersClient, BroadcastUDPClient):
-
-    def __init__(self, bcastaddr):
-        BroadcastUDPClient.__init__(self, bcastaddr, 100002, 2)
-
-
-def test():
-    import sys
-    if not sys.argv[1:]:
-        testbcast()
-        return
-    else:
-        host = sys.argv[1]
-    c = RnusersClient(host)
-    list = c.Names()
-    for (line, name, host, time), idle in list:
-        line = strip0(line)
-        name = strip0(name)
-        host = strip0(host)
-        print("%r %r %r %s %s" % (name, host, line, time, idle))
-
-def testbcast():
-    c = BroadcastRnusersClient('<broadcast>')
-    def listit(list, fromaddr):
-        host, port = fromaddr
-        print(host + '\t:', end=' ')
-        for (line, name, host, time), idle in list:
-            print(strip0(name), end=' ')
-        print()
-    c.set_reply_handler(listit)
-    all = c.Names()
-    print('Total Count:', len(all))
-
-def strip0(s):
-    while s and s[-1] == '\0': s = s[:-1]
-    return s
-
-test()
diff --git a/Demo/rpc/rpc.py b/Demo/rpc/rpc.py
deleted file mode 100644
index 30b3017..0000000
--- a/Demo/rpc/rpc.py
+++ /dev/null
@@ -1,890 +0,0 @@
-# Sun RPC version 2 -- RFC1057.
-
-# XXX There should be separate exceptions for the various reasons why
-# XXX an RPC can fail, rather than using RuntimeError for everything
-
-# XXX Need to use class based exceptions rather than string exceptions
-
-# XXX The UDP version of the protocol resends requests when it does
-# XXX not receive a timely reply -- use only for idempotent calls!
-
-# XXX There is no provision for call timeout on TCP connections
-
-import xdr
-import socket
-import os
-
-RPCVERSION = 2
-
-CALL = 0
-REPLY = 1
-
-AUTH_NULL = 0
-AUTH_UNIX = 1
-AUTH_SHORT = 2
-AUTH_DES = 3
-
-MSG_ACCEPTED = 0
-MSG_DENIED = 1
-
-SUCCESS = 0                             # RPC executed successfully
-PROG_UNAVAIL  = 1                       # remote hasn't exported program
-PROG_MISMATCH = 2                       # remote can't support version #
-PROC_UNAVAIL  = 3                       # program can't support procedure
-GARBAGE_ARGS  = 4                       # procedure can't decode params
-
-RPC_MISMATCH = 0                        # RPC version number != 2
-AUTH_ERROR = 1                          # remote can't authenticate caller
-
-AUTH_BADCRED      = 1                   # bad credentials (seal broken)
-AUTH_REJECTEDCRED = 2                   # client must begin new session
-AUTH_BADVERF      = 3                   # bad verifier (seal broken)
-AUTH_REJECTEDVERF = 4                   # verifier expired or replayed
-AUTH_TOOWEAK      = 5                   # rejected for security reasons
-
-
-class Packer(xdr.Packer):
-
-    def pack_auth(self, auth):
-        flavor, stuff = auth
-        self.pack_enum(flavor)
-        self.pack_opaque(stuff)
-
-    def pack_auth_unix(self, stamp, machinename, uid, gid, gids):
-        self.pack_uint(stamp)
-        self.pack_string(machinename)
-        self.pack_uint(uid)
-        self.pack_uint(gid)
-        self.pack_uint(len(gids))
-        for i in gids:
-            self.pack_uint(i)
-
-    def pack_callheader(self, xid, prog, vers, proc, cred, verf):
-        self.pack_uint(xid)
-        self.pack_enum(CALL)
-        self.pack_uint(RPCVERSION)
-        self.pack_uint(prog)
-        self.pack_uint(vers)
-        self.pack_uint(proc)
-        self.pack_auth(cred)
-        self.pack_auth(verf)
-        # Caller must add procedure-specific part of call
-
-    def pack_replyheader(self, xid, verf):
-        self.pack_uint(xid)
-        self.pack_enum(REPLY)
-        self.pack_uint(MSG_ACCEPTED)
-        self.pack_auth(verf)
-        self.pack_enum(SUCCESS)
-        # Caller must add procedure-specific part of reply
-
-
-# Exceptions
-class BadRPCFormat(Exception): pass
-class BadRPCVersion(Exception): pass
-class GarbageArgs(Exception): pass
-
-class Unpacker(xdr.Unpacker):
-
-    def unpack_auth(self):
-        flavor = self.unpack_enum()
-        stuff = self.unpack_opaque()
-        return (flavor, stuff)
-
-    def unpack_callheader(self):
-        xid = self.unpack_uint()
-        temp = self.unpack_enum()
-        if temp != CALL:
-            raise BadRPCFormat('no CALL but %r' % (temp,))
-        temp = self.unpack_uint()
-        if temp != RPCVERSION:
-            raise BadRPCVersion('bad RPC version %r' % (temp,))
-        prog = self.unpack_uint()
-        vers = self.unpack_uint()
-        proc = self.unpack_uint()
-        cred = self.unpack_auth()
-        verf = self.unpack_auth()
-        return xid, prog, vers, proc, cred, verf
-        # Caller must add procedure-specific part of call
-
-    def unpack_replyheader(self):
-        xid = self.unpack_uint()
-        mtype = self.unpack_enum()
-        if mtype != REPLY:
-            raise RuntimeError('no REPLY but %r' % (mtype,))
-        stat = self.unpack_enum()
-        if stat == MSG_DENIED:
-            stat = self.unpack_enum()
-            if stat == RPC_MISMATCH:
-                low = self.unpack_uint()
-                high = self.unpack_uint()
-                raise RuntimeError('MSG_DENIED: RPC_MISMATCH: %r' % ((low, high),))
-            if stat == AUTH_ERROR:
-                stat = self.unpack_uint()
-                raise RuntimeError('MSG_DENIED: AUTH_ERROR: %r' % (stat,))
-            raise RuntimeError('MSG_DENIED: %r' % (stat,))
-        if stat != MSG_ACCEPTED:
-            raise RuntimeError('Neither MSG_DENIED nor MSG_ACCEPTED: %r' % (stat,))
-        verf = self.unpack_auth()
-        stat = self.unpack_enum()
-        if stat == PROG_UNAVAIL:
-            raise RuntimeError('call failed: PROG_UNAVAIL')
-        if stat == PROG_MISMATCH:
-            low = self.unpack_uint()
-            high = self.unpack_uint()
-            raise RuntimeError('call failed: PROG_MISMATCH: %r' % ((low, high),))
-        if stat == PROC_UNAVAIL:
-            raise RuntimeError('call failed: PROC_UNAVAIL')
-        if stat == GARBAGE_ARGS:
-            raise RuntimeError('call failed: GARBAGE_ARGS')
-        if stat != SUCCESS:
-            raise RuntimeError('call failed: %r' % (stat,))
-        return xid, verf
-        # Caller must get procedure-specific part of reply
-
-
-# Subroutines to create opaque authentication objects
-
-def make_auth_null():
-    return ''
-
-def make_auth_unix(seed, host, uid, gid, groups):
-    p = Packer()
-    p.pack_auth_unix(seed, host, uid, gid, groups)
-    return p.get_buf()
-
-def make_auth_unix_default():
-    try:
-        from os import getuid, getgid
-        uid = getuid()
-        gid = getgid()
-    except ImportError:
-        uid = gid = 0
-    import time
-    return make_auth_unix(int(time.time()-unix_epoch()), \
-              socket.gethostname(), uid, gid, [])
-
-_unix_epoch = -1
-def unix_epoch():
-    """Very painful calculation of when the Unix Epoch is.
-
-    This is defined as the return value of time.time() on Jan 1st,
-    1970, 00:00:00 GMT.
-
-    On a Unix system, this should always return 0.0.  On a Mac, the
-    calculations are needed -- and hard because of integer overflow
-    and other limitations.
-
-    """
-    global _unix_epoch
-    if _unix_epoch >= 0: return _unix_epoch
-    import time
-    now = time.time()
-    localt = time.localtime(now)        # (y, m, d, hh, mm, ss, ..., ..., ...)
-    gmt = time.gmtime(now)
-    offset = time.mktime(localt) - time.mktime(gmt)
-    y, m, d, hh, mm, ss = 1970, 1, 1, 0, 0, 0
-    offset, ss = divmod(ss + offset, 60)
-    offset, mm = divmod(mm + offset, 60)
-    offset, hh = divmod(hh + offset, 24)
-    d = d + offset
-    _unix_epoch = time.mktime((y, m, d, hh, mm, ss, 0, 0, 0))
-    print("Unix epoch:", time.ctime(_unix_epoch))
-    return _unix_epoch
-
-
-# Common base class for clients
-
-class Client:
-
-    def __init__(self, host, prog, vers, port):
-        self.host = host
-        self.prog = prog
-        self.vers = vers
-        self.port = port
-        self.makesocket() # Assigns to self.sock
-        self.bindsocket()
-        self.connsocket()
-        self.lastxid = 0 # XXX should be more random?
-        self.addpackers()
-        self.cred = None
-        self.verf = None
-
-    def close(self):
-        self.sock.close()
-
-    def makesocket(self):
-        # This MUST be overridden
-        raise RuntimeError('makesocket not defined')
-
-    def connsocket(self):
-        # Override this if you don't want/need a connection
-        self.sock.connect((self.host, self.port))
-
-    def bindsocket(self):
-        # Override this to bind to a different port (e.g. reserved)
-        self.sock.bind(('', 0))
-
-    def addpackers(self):
-        # Override this to use derived classes from Packer/Unpacker
-        self.packer = Packer()
-        self.unpacker = Unpacker('')
-
-    def make_call(self, proc, args, pack_func, unpack_func):
-        # Don't normally override this (but see Broadcast)
-        if pack_func is None and args is not None:
-            raise TypeError('non-null args with null pack_func')
-        self.start_call(proc)
-        if pack_func:
-            pack_func(args)
-        self.do_call()
-        if unpack_func:
-            result = unpack_func()
-        else:
-            result = None
-        self.unpacker.done()
-        return result
-
-    def start_call(self, proc):
-        # Don't override this
-        self.lastxid = xid = self.lastxid + 1
-        cred = self.mkcred()
-        verf = self.mkverf()
-        p = self.packer
-        p.reset()
-        p.pack_callheader(xid, self.prog, self.vers, proc, cred, verf)
-
-    def do_call(self):
-        # This MUST be overridden
-        raise RuntimeError('do_call not defined')
-
-    def mkcred(self):
-        # Override this to use more powerful credentials
-        if self.cred is None:
-            self.cred = (AUTH_NULL, make_auth_null())
-        return self.cred
-
-    def mkverf(self):
-        # Override this to use a more powerful verifier
-        if self.verf is None:
-            self.verf = (AUTH_NULL, make_auth_null())
-        return self.verf
-
-    def call_0(self):               # Procedure 0 is always like this
-        return self.make_call(0, None, None, None)
-
-
-# Record-Marking standard support
-
-def sendfrag(sock, last, frag):
-    x = len(frag)
-    if last: x = x | 0x80000000
-    header = (chr(int(x>>24 & 0xff)) + chr(int(x>>16 & 0xff)) + \
-              chr(int(x>>8 & 0xff)) + chr(int(x & 0xff)))
-    sock.send(header + frag)
-
-def sendrecord(sock, record):
-    sendfrag(sock, 1, record)
-
-def recvfrag(sock):
-    header = sock.recv(4)
-    if len(header) < 4:
-        raise EOFError
-    x = int(ord(header[0]))<<24 | ord(header[1])<<16 | \
-        ord(header[2])<<8 | ord(header[3])
-    last = ((x & 0x80000000) != 0)
-    n = int(x & 0x7fffffff)
-    frag = ''
-    while n > 0:
-        buf = sock.recv(n)
-        if not buf: raise EOFError
-        n = n - len(buf)
-        frag = frag + buf
-    return last, frag
-
-def recvrecord(sock):
-    record = ''
-    last = 0
-    while not last:
-        last, frag = recvfrag(sock)
-        record = record + frag
-    return record
-
-
-# Try to bind to a reserved port (must be root)
-
-last_resv_port_tried = None
-def bindresvport(sock, host):
-    global last_resv_port_tried
-    FIRST, LAST = 600, 1024 # Range of ports to try
-    if last_resv_port_tried is None:
-        import os
-        last_resv_port_tried = FIRST + os.getpid() % (LAST-FIRST)
-    for i in range(last_resv_port_tried, LAST) + \
-              range(FIRST, last_resv_port_tried):
-        last_resv_port_tried = i
-        try:
-            sock.bind((host, i))
-            return last_resv_port_tried
-        except socket.error as e:
-            (errno, msg) = e
-            if errno != 114:
-                raise socket.error(errno, msg)
-    raise RuntimeError('can\'t assign reserved port')
-
-
-# Client using TCP to a specific port
-
-class RawTCPClient(Client):
-
-    def makesocket(self):
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-
-    def do_call(self):
-        call = self.packer.get_buf()
-        sendrecord(self.sock, call)
-        reply = recvrecord(self.sock)
-        u = self.unpacker
-        u.reset(reply)
-        xid, verf = u.unpack_replyheader()
-        if xid != self.lastxid:
-            # Can't really happen since this is TCP...
-            raise RuntimeError('wrong xid in reply %r instead of %r' % (
-                                 xid, self.lastxid))
-
-
-# Client using UDP to a specific port
-
-class RawUDPClient(Client):
-
-    def makesocket(self):
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-
-    def do_call(self):
-        call = self.packer.get_buf()
-        self.sock.send(call)
-        try:
-            from select import select
-        except ImportError:
-            print('WARNING: select not found, RPC may hang')
-            select = None
-        BUFSIZE = 8192 # Max UDP buffer size
-        timeout = 1
-        count = 5
-        while 1:
-            r, w, x = [self.sock], [], []
-            if select:
-                r, w, x = select(r, w, x, timeout)
-            if self.sock not in r:
-                count = count - 1
-                if count < 0: raise RuntimeError('timeout')
-                if timeout < 25: timeout = timeout *2
-##                              print 'RESEND', timeout, count
-                self.sock.send(call)
-                continue
-            reply = self.sock.recv(BUFSIZE)
-            u = self.unpacker
-            u.reset(reply)
-            xid, verf = u.unpack_replyheader()
-            if xid != self.lastxid:
-##                              print 'BAD xid'
-                continue
-            break
-
-
-# Client using UDP broadcast to a specific port
-
-class RawBroadcastUDPClient(RawUDPClient):
-
-    def __init__(self, bcastaddr, prog, vers, port):
-        RawUDPClient.__init__(self, bcastaddr, prog, vers, port)
-        self.reply_handler = None
-        self.timeout = 30
-
-    def connsocket(self):
-        # Don't connect -- use sendto
-        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
-
-    def set_reply_handler(self, reply_handler):
-        self.reply_handler = reply_handler
-
-    def set_timeout(self, timeout):
-        self.timeout = timeout # Use None for infinite timeout
-
-    def make_call(self, proc, args, pack_func, unpack_func):
-        if pack_func is None and args is not None:
-            raise TypeError('non-null args with null pack_func')
-        self.start_call(proc)
-        if pack_func:
-            pack_func(args)
-        call = self.packer.get_buf()
-        self.sock.sendto(call, (self.host, self.port))
-        try:
-            from select import select
-        except ImportError:
-            print('WARNING: select not found, broadcast will hang')
-            select = None
-        BUFSIZE = 8192 # Max UDP buffer size (for reply)
-        replies = []
-        if unpack_func is None:
-            def dummy(): pass
-            unpack_func = dummy
-        while 1:
-            r, w, x = [self.sock], [], []
-            if select:
-                if self.timeout is None:
-                    r, w, x = select(r, w, x)
-                else:
-                    r, w, x = select(r, w, x, self.timeout)
-            if self.sock not in r:
-                break
-            reply, fromaddr = self.sock.recvfrom(BUFSIZE)
-            u = self.unpacker
-            u.reset(reply)
-            xid, verf = u.unpack_replyheader()
-            if xid != self.lastxid:
-##                              print 'BAD xid'
-                continue
-            reply = unpack_func()
-            self.unpacker.done()
-            replies.append((reply, fromaddr))
-            if self.reply_handler:
-                self.reply_handler(reply, fromaddr)
-        return replies
-
-
-# Port mapper interface
-
-# Program number, version and (fixed!) port number
-PMAP_PROG = 100000
-PMAP_VERS = 2
-PMAP_PORT = 111
-
-# Procedure numbers
-PMAPPROC_NULL = 0                       # (void) -> void
-PMAPPROC_SET = 1                        # (mapping) -> bool
-PMAPPROC_UNSET = 2                      # (mapping) -> bool
-PMAPPROC_GETPORT = 3                    # (mapping) -> unsigned int
-PMAPPROC_DUMP = 4                       # (void) -> pmaplist
-PMAPPROC_CALLIT = 5                     # (call_args) -> call_result
-
-# A mapping is (prog, vers, prot, port) and prot is one of:
-
-IPPROTO_TCP = 6
-IPPROTO_UDP = 17
-
-# A pmaplist is a variable-length list of mappings, as follows:
-# either (1, mapping, pmaplist) or (0).
-
-# A call_args is (prog, vers, proc, args) where args is opaque;
-# a call_result is (port, res) where res is opaque.
-
-
-class PortMapperPacker(Packer):
-
-    def pack_mapping(self, mapping):
-        prog, vers, prot, port = mapping
-        self.pack_uint(prog)
-        self.pack_uint(vers)
-        self.pack_uint(prot)
-        self.pack_uint(port)
-
-    def pack_pmaplist(self, list):
-        self.pack_list(list, self.pack_mapping)
-
-    def pack_call_args(self, ca):
-        prog, vers, proc, args = ca
-        self.pack_uint(prog)
-        self.pack_uint(vers)
-        self.pack_uint(proc)
-        self.pack_opaque(args)
-
-
-class PortMapperUnpacker(Unpacker):
-
-    def unpack_mapping(self):
-        prog = self.unpack_uint()
-        vers = self.unpack_uint()
-        prot = self.unpack_uint()
-        port = self.unpack_uint()
-        return prog, vers, prot, port
-
-    def unpack_pmaplist(self):
-        return self.unpack_list(self.unpack_mapping)
-
-    def unpack_call_result(self):
-        port = self.unpack_uint()
-        res = self.unpack_opaque()
-        return port, res
-
-
-class PartialPortMapperClient:
-
-    def addpackers(self):
-        self.packer = PortMapperPacker()
-        self.unpacker = PortMapperUnpacker('')
-
-    def Set(self, mapping):
-        return self.make_call(PMAPPROC_SET, mapping, \
-                self.packer.pack_mapping, \
-                self.unpacker.unpack_uint)
-
-    def Unset(self, mapping):
-        return self.make_call(PMAPPROC_UNSET, mapping, \
-                self.packer.pack_mapping, \
-                self.unpacker.unpack_uint)
-
-    def Getport(self, mapping):
-        return self.make_call(PMAPPROC_GETPORT, mapping, \
-                self.packer.pack_mapping, \
-                self.unpacker.unpack_uint)
-
-    def Dump(self):
-        return self.make_call(PMAPPROC_DUMP, None, \
-                None, \
-                self.unpacker.unpack_pmaplist)
-
-    def Callit(self, ca):
-        return self.make_call(PMAPPROC_CALLIT, ca, \
-                self.packer.pack_call_args, \
-                self.unpacker.unpack_call_result)
-
-
-class TCPPortMapperClient(PartialPortMapperClient, RawTCPClient):
-
-    def __init__(self, host):
-        RawTCPClient.__init__(self, \
-                host, PMAP_PROG, PMAP_VERS, PMAP_PORT)
-
-
-class UDPPortMapperClient(PartialPortMapperClient, RawUDPClient):
-
-    def __init__(self, host):
-        RawUDPClient.__init__(self, \
-                host, PMAP_PROG, PMAP_VERS, PMAP_PORT)
-
-
-class BroadcastUDPPortMapperClient(PartialPortMapperClient, \
-                                   RawBroadcastUDPClient):
-
-    def __init__(self, bcastaddr):
-        RawBroadcastUDPClient.__init__(self, \
-                bcastaddr, PMAP_PROG, PMAP_VERS, PMAP_PORT)
-
-
-# Generic clients that find their server through the Port mapper
-
-class TCPClient(RawTCPClient):
-
-    def __init__(self, host, prog, vers):
-        pmap = TCPPortMapperClient(host)
-        port = pmap.Getport((prog, vers, IPPROTO_TCP, 0))
-        pmap.close()
-        if port == 0:
-            raise RuntimeError('program not registered')
-        RawTCPClient.__init__(self, host, prog, vers, port)
-
-
-class UDPClient(RawUDPClient):
-
-    def __init__(self, host, prog, vers):
-        pmap = UDPPortMapperClient(host)
-        port = pmap.Getport((prog, vers, IPPROTO_UDP, 0))
-        pmap.close()
-        if port == 0:
-            raise RuntimeError('program not registered')
-        RawUDPClient.__init__(self, host, prog, vers, port)
-
-
-class BroadcastUDPClient(Client):
-
-    def __init__(self, bcastaddr, prog, vers):
-        self.pmap = BroadcastUDPPortMapperClient(bcastaddr)
-        self.pmap.set_reply_handler(self.my_reply_handler)
-        self.prog = prog
-        self.vers = vers
-        self.user_reply_handler = None
-        self.addpackers()
-
-    def close(self):
-        self.pmap.close()
-
-    def set_reply_handler(self, reply_handler):
-        self.user_reply_handler = reply_handler
-
-    def set_timeout(self, timeout):
-        self.pmap.set_timeout(timeout)
-
-    def my_reply_handler(self, reply, fromaddr):
-        port, res = reply
-        self.unpacker.reset(res)
-        result = self.unpack_func()
-        self.unpacker.done()
-        self.replies.append((result, fromaddr))
-        if self.user_reply_handler is not None:
-            self.user_reply_handler(result, fromaddr)
-
-    def make_call(self, proc, args, pack_func, unpack_func):
-        self.packer.reset()
-        if pack_func:
-            pack_func(args)
-        if unpack_func is None:
-            def dummy(): pass
-            self.unpack_func = dummy
-        else:
-            self.unpack_func = unpack_func
-        self.replies = []
-        packed_args = self.packer.get_buf()
-        dummy_replies = self.pmap.Callit( \
-                (self.prog, self.vers, proc, packed_args))
-        return self.replies
-
-
-# Server classes
-
-# These are not symmetric to the Client classes
-# XXX No attempt is made to provide authorization hooks yet
-
-class Server:
-
-    def __init__(self, host, prog, vers, port):
-        self.host = host # Should normally be '' for default interface
-        self.prog = prog
-        self.vers = vers
-        self.port = port # Should normally be 0 for random port
-        self.makesocket() # Assigns to self.sock and self.prot
-        self.bindsocket()
-        self.host, self.port = self.sock.getsockname()
-        self.addpackers()
-
-    def register(self):
-        mapping = self.prog, self.vers, self.prot, self.port
-        p = TCPPortMapperClient(self.host)
-        if not p.Set(mapping):
-            raise RuntimeError('register failed')
-
-    def unregister(self):
-        mapping = self.prog, self.vers, self.prot, self.port
-        p = TCPPortMapperClient(self.host)
-        if not p.Unset(mapping):
-            raise RuntimeError('unregister failed')
-
-    def handle(self, call):
-        # Don't use unpack_header but parse the header piecewise
-        # XXX I have no idea if I am using the right error responses!
-        self.unpacker.reset(call)
-        self.packer.reset()
-        xid = self.unpacker.unpack_uint()
-        self.packer.pack_uint(xid)
-        temp = self.unpacker.unpack_enum()
-        if temp != CALL:
-            return None # Not worthy of a reply
-        self.packer.pack_uint(REPLY)
-        temp = self.unpacker.unpack_uint()
-        if temp != RPCVERSION:
-            self.packer.pack_uint(MSG_DENIED)
-            self.packer.pack_uint(RPC_MISMATCH)
-            self.packer.pack_uint(RPCVERSION)
-            self.packer.pack_uint(RPCVERSION)
-            return self.packer.get_buf()
-        self.packer.pack_uint(MSG_ACCEPTED)
-        self.packer.pack_auth((AUTH_NULL, make_auth_null()))
-        prog = self.unpacker.unpack_uint()
-        if prog != self.prog:
-            self.packer.pack_uint(PROG_UNAVAIL)
-            return self.packer.get_buf()
-        vers = self.unpacker.unpack_uint()
-        if vers != self.vers:
-            self.packer.pack_uint(PROG_MISMATCH)
-            self.packer.pack_uint(self.vers)
-            self.packer.pack_uint(self.vers)
-            return self.packer.get_buf()
-        proc = self.unpacker.unpack_uint()
-        methname = 'handle_' + repr(proc)
-        try:
-            meth = getattr(self, methname)
-        except AttributeError:
-            self.packer.pack_uint(PROC_UNAVAIL)
-            return self.packer.get_buf()
-        cred = self.unpacker.unpack_auth()
-        verf = self.unpacker.unpack_auth()
-        try:
-            meth() # Unpack args, call turn_around(), pack reply
-        except (EOFError, GarbageArgs):
-            # Too few or too many arguments
-            self.packer.reset()
-            self.packer.pack_uint(xid)
-            self.packer.pack_uint(REPLY)
-            self.packer.pack_uint(MSG_ACCEPTED)
-            self.packer.pack_auth((AUTH_NULL, make_auth_null()))
-            self.packer.pack_uint(GARBAGE_ARGS)
-        return self.packer.get_buf()
-
-    def turn_around(self):
-        try:
-            self.unpacker.done()
-        except RuntimeError:
-            raise GarbageArgs
-        self.packer.pack_uint(SUCCESS)
-
-    def handle_0(self): # Handle NULL message
-        self.turn_around()
-
-    def makesocket(self):
-        # This MUST be overridden
-        raise RuntimeError('makesocket not defined')
-
-    def bindsocket(self):
-        # Override this to bind to a different port (e.g. reserved)
-        self.sock.bind((self.host, self.port))
-
-    def addpackers(self):
-        # Override this to use derived classes from Packer/Unpacker
-        self.packer = Packer()
-        self.unpacker = Unpacker('')
-
-
-class TCPServer(Server):
-
-    def makesocket(self):
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.prot = IPPROTO_TCP
-
-    def loop(self):
-        self.sock.listen(0)
-        while 1:
-            self.session(self.sock.accept())
-
-    def session(self, connection):
-        sock, (host, port) = connection
-        while 1:
-            try:
-                call = recvrecord(sock)
-            except EOFError:
-                break
-            except socket.error as msg:
-                print('socket error:', msg)
-                break
-            reply = self.handle(call)
-            if reply is not None:
-                sendrecord(sock, reply)
-
-    def forkingloop(self):
-        # Like loop but uses forksession()
-        self.sock.listen(0)
-        while 1:
-            self.forksession(self.sock.accept())
-
-    def forksession(self, connection):
-        # Like session but forks off a subprocess
-        import os
-        # Wait for deceased children
-        try:
-            while 1:
-                pid, sts = os.waitpid(0, 1)
-        except os.error:
-            pass
-        pid = None
-        try:
-            pid = os.fork()
-            if pid: # Parent
-                connection[0].close()
-                return
-            # Child
-            self.session(connection)
-        finally:
-            # Make sure we don't fall through in the parent
-            if pid == 0:
-                os._exit(0)
-
-
-class UDPServer(Server):
-
-    def makesocket(self):
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self.prot = IPPROTO_UDP
-
-    def loop(self):
-        while 1:
-            self.session()
-
-    def session(self):
-        call, host_port = self.sock.recvfrom(8192)
-        reply = self.handle(call)
-        if reply is not None:
-            self.sock.sendto(reply, host_port)
-
-
-# Simple test program -- dump local portmapper status
-
-def test():
-    pmap = UDPPortMapperClient('')
-    list = pmap.Dump()
-    list.sort()
-    for prog, vers, prot, port in list:
-        print(prog, vers, end=' ')
-        if prot == IPPROTO_TCP: print('tcp', end=' ')
-        elif prot == IPPROTO_UDP: print('udp', end=' ')
-        else: print(prot, end=' ')
-        print(port)
-
-
-# Test program for broadcast operation -- dump everybody's portmapper status
-
-def testbcast():
-    import sys
-    if sys.argv[1:]:
-        bcastaddr = sys.argv[1]
-    else:
-        bcastaddr = '<broadcast>'
-    def rh(reply, fromaddr):
-        host, port = fromaddr
-        print(host + '\t' + repr(reply))
-    pmap = BroadcastUDPPortMapperClient(bcastaddr)
-    pmap.set_reply_handler(rh)
-    pmap.set_timeout(5)
-    replies = pmap.Getport((100002, 1, IPPROTO_UDP, 0))
-
-
-# Test program for server, with corresponding client
-# On machine A: python -c 'import rpc; rpc.testsvr()'
-# On machine B: python -c 'import rpc; rpc.testclt()' A
-# (A may be == B)
-
-def testsvr():
-    # Simple test class -- proc 1 doubles its string argument as reply
-    class S(UDPServer):
-        def handle_1(self):
-            arg = self.unpacker.unpack_string()
-            self.turn_around()
-            print('RPC function 1 called, arg', repr(arg))
-            self.packer.pack_string(arg + arg)
-    #
-    s = S('', 0x20000000, 1, 0)
-    try:
-        s.unregister()
-    except RuntimeError as msg:
-        print('RuntimeError:', msg, '(ignored)')
-    s.register()
-    print('Service started...')
-    try:
-        s.loop()
-    finally:
-        s.unregister()
-        print('Service interrupted.')
-
-
-def testclt():
-    import sys
-    if sys.argv[1:]: host = sys.argv[1]
-    else: host = ''
-    # Client for above server
-    class C(UDPClient):
-        def call_1(self, arg):
-            return self.make_call(1, arg, \
-                    self.packer.pack_string, \
-                    self.unpacker.unpack_string)
-    c = C(host, 0x20000000, 1)
-    print('making call...')
-    reply = c.call_1('hello, world, ')
-    print('call returned', repr(reply))
diff --git a/Demo/rpc/test b/Demo/rpc/test
deleted file mode 100755
index ba220f2..0000000
--- a/Demo/rpc/test
+++ /dev/null
@@ -1,24 +0,0 @@
-: ${PYTHON=python}
-: ${SERVER=charon.cwi.nl}
-
-set -xe
-
-$PYTHON -c 'from rpc import test; test()'
-$PYTHON -c 'from rpc import test; test()' ${SERVER}
-
-$PYTHON -c 'from rpc import testsvr; testsvr()' &
-PID=$!
-sleep 2
-$PYTHON -c 'from rpc import testclt; testclt()'
-kill -2 $PID
-
-$PYTHON -c 'from mountclient import test; test()'
-$PYTHON -c 'from mountclient import test; test()' gatekeeper.dec.com
-
-$PYTHON -c 'from nfsclient import test; test()'
-$PYTHON -c 'from nfsclient import test; test()' gatekeeper.dec.com
-$PYTHON -c 'from nfsclient import test; test()' gatekeeper.dec.com /archive
-
-$PYTHON -c 'from rnusersclient import test; test()' ''
-
-$PYTHON -c 'from rpc import testbcast; testbcast()'
diff --git a/Demo/rpc/xdr.py b/Demo/rpc/xdr.py
deleted file mode 100644
index 2d5f9c3..0000000
--- a/Demo/rpc/xdr.py
+++ /dev/null
@@ -1,200 +0,0 @@
-# Implement (a subset of) Sun XDR -- RFC1014.
-
-
-try:
-    import struct
-except ImportError:
-    struct = None
-
-
-Long = type(0)
-
-
-class Packer:
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.buf = ''
-
-    def get_buf(self):
-        return self.buf
-
-    def pack_uint(self, x):
-        self.buf = self.buf + \
-                (chr(int(x>>24 & 0xff)) + chr(int(x>>16 & 0xff)) + \
-                 chr(int(x>>8 & 0xff)) + chr(int(x & 0xff)))
-    if struct and struct.pack('l', 1) == '\0\0\0\1':
-        def pack_uint(self, x):
-            if type(x) == Long:
-                x = int((x + 0x80000000) % 0x100000000 \
-                           - 0x80000000)
-            self.buf = self.buf + struct.pack('l', x)
-
-    pack_int = pack_uint
-
-    pack_enum = pack_int
-
-    def pack_bool(self, x):
-        if x: self.buf = self.buf + '\0\0\0\1'
-        else: self.buf = self.buf + '\0\0\0\0'
-
-    def pack_uhyper(self, x):
-        self.pack_uint(int(x>>32 & 0xffffffff))
-        self.pack_uint(int(x & 0xffffffff))
-
-    pack_hyper = pack_uhyper
-
-    def pack_float(self, x):
-        # XXX
-        self.buf = self.buf + struct.pack('f', x)
-
-    def pack_double(self, x):
-        # XXX
-        self.buf = self.buf + struct.pack('d', x)
-
-    def pack_fstring(self, n, s):
-        if n < 0:
-            raise ValueError('fstring size must be nonnegative')
-        n = ((n + 3)//4)*4
-        data = s[:n]
-        data = data + (n - len(data)) * '\0'
-        self.buf = self.buf + data
-
-    pack_fopaque = pack_fstring
-
-    def pack_string(self, s):
-        n = len(s)
-        self.pack_uint(n)
-        self.pack_fstring(n, s)
-
-    pack_opaque = pack_string
-
-    def pack_list(self, list, pack_item):
-        for item in list:
-            self.pack_uint(1)
-            pack_item(item)
-        self.pack_uint(0)
-
-    def pack_farray(self, n, list, pack_item):
-        if len(list) != n:
-            raise ValueError('wrong array size')
-        for item in list:
-            pack_item(item)
-
-    def pack_array(self, list, pack_item):
-        n = len(list)
-        self.pack_uint(n)
-        self.pack_farray(n, list, pack_item)
-
-
-class Unpacker:
-
-    def __init__(self, data):
-        self.reset(data)
-
-    def reset(self, data):
-        self.buf = data
-        self.pos = 0
-
-    def done(self):
-        if self.pos < len(self.buf):
-            raise RuntimeError('unextracted data remains')
-
-    def unpack_uint(self):
-        i = self.pos
-        self.pos = j = i+4
-        data = self.buf[i:j]
-        if len(data) < 4:
-            raise EOFError
-        x = int(ord(data[0]))<<24 | ord(data[1])<<16 | \
-                ord(data[2])<<8 | ord(data[3])
-        # Return a Python long only if the value is not representable
-        # as a nonnegative Python int
-        if x < 0x80000000: x = int(x)
-        return x
-    if struct and struct.unpack('l', '\0\0\0\1') == 1:
-        def unpack_uint(self):
-            i = self.pos
-            self.pos = j = i+4
-            data = self.buf[i:j]
-            if len(data) < 4:
-                raise EOFError
-            return struct.unpack('l', data)
-
-    def unpack_int(self):
-        x = self.unpack_uint()
-        if x >= 0x80000000: x = x - 0x100000000
-        return int(x)
-
-    unpack_enum = unpack_int
-
-    unpack_bool = unpack_int
-
-    def unpack_uhyper(self):
-        hi = self.unpack_uint()
-        lo = self.unpack_uint()
-        return int(hi)<<32 | lo
-
-    def unpack_hyper(self):
-        x = self.unpack_uhyper()
-        if x >= 0x8000000000000000: x = x - 0x10000000000000000
-        return x
-
-    def unpack_float(self):
-        # XXX
-        i = self.pos
-        self.pos = j = i+4
-        data = self.buf[i:j]
-        if len(data) < 4:
-            raise EOFError
-        return struct.unpack('f', data)[0]
-
-    def unpack_double(self):
-        # XXX
-        i = self.pos
-        self.pos = j = i+8
-        data = self.buf[i:j]
-        if len(data) < 8:
-            raise EOFError
-        return struct.unpack('d', data)[0]
-
-    def unpack_fstring(self, n):
-        if n < 0:
-            raise ValueError('fstring size must be nonnegative')
-        i = self.pos
-        j = i + (n+3)//4*4
-        if j > len(self.buf):
-            raise EOFError
-        self.pos = j
-        return self.buf[i:i+n]
-
-    unpack_fopaque = unpack_fstring
-
-    def unpack_string(self):
-        n = self.unpack_uint()
-        return self.unpack_fstring(n)
-
-    unpack_opaque = unpack_string
-
-    def unpack_list(self, unpack_item):
-        list = []
-        while 1:
-            x = self.unpack_uint()
-            if x == 0: break
-            if x != 1:
-                raise RuntimeError('0 or 1 expected, got %r' % (x, ))
-            item = unpack_item()
-            list.append(item)
-        return list
-
-    def unpack_farray(self, n, unpack_item):
-        list = []
-        for i in range(n):
-            list.append(unpack_item())
-        return list
-
-    def unpack_array(self, unpack_item):
-        n = self.unpack_uint()
-        return self.unpack_farray(n, unpack_item)
diff --git a/Demo/scripts/README b/Demo/scripts/README
deleted file mode 100644
index 097b9b7..0000000
--- a/Demo/scripts/README
+++ /dev/null
@@ -1,22 +0,0 @@
-This directory contains a collection of executable Python scripts.
-
-See also the Tools/scripts directory!
-
-beer.py			Print the classic 'bottles of beer' list.
-eqfix.py		Fix .py files to use the correct equality test operator
-fact.py			Factorize numbers
-find-uname.py		Search for Unicode characters using regexps
-from.py			Summarize mailbox
-lpwatch.py		Watch BSD line printer queues
-makedir.py		Like mkdir -p
-markov.py		Markov chain simulation of words or characters
-mboxconvert.py		Convert MH or MMDF mailboxes to unix mailbox format
-morse.py		Produce morse code (as an AIFF file)
-newslist.py		List all newsgroups on a NNTP server as HTML pages
-pi.py			Print all digits of pi -- given enough time and memory
-pp.py			Emulate some Perl command line options
-primes.py		Print prime numbers
-queens.py		Dijkstra's solution to Wirth's "N Queens problem"
-script.py		Equivalent to BSD script(1) -- by Steen Lumholt
-unbirthday.py		Print unbirthday count
-update.py		Update a bunch of files according to a script.
diff --git a/Demo/scripts/beer.py b/Demo/scripts/beer.py
deleted file mode 100644
index 8135509..0000000
--- a/Demo/scripts/beer.py
+++ /dev/null
@@ -1,20 +0,0 @@
-#! /usr/bin/env python
-
-# By GvR, demystified after a version by Fredrik Lundh.
-
-import sys
-
-n = 100
-if sys.argv[1:]:
-    n = int(sys.argv[1])
-
-def bottle(n):
-    if n == 0: return "no more bottles of beer"
-    if n == 1: return "one bottle of beer"
-    return str(n) + " bottles of beer"
-
-for i in range(n, 0, -1):
-    print(bottle(i), "on the wall,")
-    print(bottle(i) + ".")
-    print("Take one down, pass it around,")
-    print(bottle(i-1), "on the wall.")
diff --git a/Demo/scripts/eqfix.py b/Demo/scripts/eqfix.py
deleted file mode 100755
index 47c00d3..0000000
--- a/Demo/scripts/eqfix.py
+++ /dev/null
@@ -1,198 +0,0 @@
-#! /usr/bin/env python
-
-# Fix Python source files to use the new equality test operator, i.e.,
-#       if x = y: ...
-# is changed to
-#       if x == y: ...
-# The script correctly tokenizes the Python program to reliably
-# distinguish between assignments and equality tests.
-#
-# Command line arguments are files or directories to be processed.
-# Directories are searched recursively for files whose name looks
-# like a python module.
-# Symbolic links are always ignored (except as explicit directory
-# arguments).  Of course, the original file is kept as a back-up
-# (with a "~" attached to its name).
-# It complains about binaries (files containing null bytes)
-# and about files that are ostensibly not Python files: if the first
-# line starts with '#!' and does not contain the string 'python'.
-#
-# Changes made are reported to stdout in a diff-like format.
-#
-# Undoubtedly you can do this using find and sed or perl, but this is
-# a nice example of Python code that recurses down a directory tree
-# and uses regular expressions.  Also note several subtleties like
-# preserving the file's mode and avoiding to even write a temp file
-# when no changes are needed for a file.
-#
-# NB: by changing only the function fixline() you can turn this
-# into a program for a different change to Python programs...
-
-import sys
-import re
-import os
-from stat import *
-import string
-
-err = sys.stderr.write
-dbg = err
-rep = sys.stdout.write
-
-def main():
-    bad = 0
-    if not sys.argv[1:]: # No arguments
-        err('usage: ' + sys.argv[0] + ' file-or-directory ...\n')
-        sys.exit(2)
-    for arg in sys.argv[1:]:
-        if os.path.isdir(arg):
-            if recursedown(arg): bad = 1
-        elif os.path.islink(arg):
-            err(arg + ': will not process symbolic links\n')
-            bad = 1
-        else:
-            if fix(arg): bad = 1
-    sys.exit(bad)
-
-ispythonprog = re.compile('^[a-zA-Z0-9_]+\.py$')
-def ispython(name):
-    return ispythonprog.match(name) >= 0
-
-def recursedown(dirname):
-    dbg('recursedown(%r)\n' % (dirname,))
-    bad = 0
-    try:
-        names = os.listdir(dirname)
-    except os.error as msg:
-        err('%s: cannot list directory: %r\n' % (dirname, msg))
-        return 1
-    names.sort()
-    subdirs = []
-    for name in names:
-        if name in (os.curdir, os.pardir): continue
-        fullname = os.path.join(dirname, name)
-        if os.path.islink(fullname): pass
-        elif os.path.isdir(fullname):
-            subdirs.append(fullname)
-        elif ispython(name):
-            if fix(fullname): bad = 1
-    for fullname in subdirs:
-        if recursedown(fullname): bad = 1
-    return bad
-
-def fix(filename):
-##      dbg('fix(%r)\n' % (dirname,))
-    try:
-        f = open(filename, 'r')
-    except IOError as msg:
-        err('%s: cannot open: %r\n' % (filename, msg))
-        return 1
-    head, tail = os.path.split(filename)
-    tempname = os.path.join(head, '@' + tail)
-    g = None
-    # If we find a match, we rewind the file and start over but
-    # now copy everything to a temp file.
-    lineno = 0
-    while 1:
-        line = f.readline()
-        if not line: break
-        lineno = lineno + 1
-        if g is None and '\0' in line:
-            # Check for binary files
-            err(filename + ': contains null bytes; not fixed\n')
-            f.close()
-            return 1
-        if lineno == 1 and g is None and line[:2] == '#!':
-            # Check for non-Python scripts
-            words = string.split(line[2:])
-            if words and re.search('[pP]ython', words[0]) < 0:
-                msg = filename + ': ' + words[0]
-                msg = msg + ' script; not fixed\n'
-                err(msg)
-                f.close()
-                return 1
-        while line[-2:] == '\\\n':
-            nextline = f.readline()
-            if not nextline: break
-            line = line + nextline
-            lineno = lineno + 1
-        newline = fixline(line)
-        if newline != line:
-            if g is None:
-                try:
-                    g = open(tempname, 'w')
-                except IOError as msg:
-                    f.close()
-                    err('%s: cannot create: %r\n' % (tempname, msg))
-                    return 1
-                f.seek(0)
-                lineno = 0
-                rep(filename + ':\n')
-                continue # restart from the beginning
-            rep(repr(lineno) + '\n')
-            rep('< ' + line)
-            rep('> ' + newline)
-        if g is not None:
-            g.write(newline)
-
-    # End of file
-    f.close()
-    if not g: return 0 # No changes
-
-    # Finishing touch -- move files
-
-    # First copy the file's mode to the temp file
-    try:
-        statbuf = os.stat(filename)
-        os.chmod(tempname, statbuf[ST_MODE] & 0o7777)
-    except os.error as msg:
-        err('%s: warning: chmod failed (%r)\n' % (tempname, msg))
-    # Then make a backup of the original file as filename~
-    try:
-        os.rename(filename, filename + '~')
-    except os.error as msg:
-        err('%s: warning: backup failed (%r)\n' % (filename, msg))
-    # Now move the temp file to the original file
-    try:
-        os.rename(tempname, filename)
-    except os.error as msg:
-        err('%s: rename failed (%r)\n' % (filename, msg))
-        return 1
-    # Return succes
-    return 0
-
-
-from tokenize import tokenprog
-
-match = {'if':':', 'elif':':', 'while':':', 'return':'\n', \
-         '(':')', '[':']', '{':'}', '`':'`'}
-
-def fixline(line):
-    # Quick check for easy case
-    if '=' not in line: return line
-
-    i, n = 0, len(line)
-    stack = []
-    while i < n:
-        j = tokenprog.match(line, i)
-        if j < 0:
-            # A bad token; forget about the rest of this line
-            print('(Syntax error:)')
-            print(line, end=' ')
-            return line
-        a, b = tokenprog.regs[3] # Location of the token proper
-        token = line[a:b]
-        i = i+j
-        if stack and token == stack[-1]:
-            del stack[-1]
-        elif token in match:
-            stack.append(match[token])
-        elif token == '=' and stack:
-            line = line[:a] + '==' + line[b:]
-            i, n = a + len('=='), len(line)
-        elif token == '==' and not stack:
-            print('(Warning: \'==\' at top level:)')
-            print(line, end=' ')
-    return line
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/fact.py b/Demo/scripts/fact.py
deleted file mode 100755
index 71fcda2..0000000
--- a/Demo/scripts/fact.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#! /usr/bin/env python
-
-# Factorize numbers.
-# The algorithm is not efficient, but easy to understand.
-# If there are large factors, it will take forever to find them,
-# because we try all odd numbers between 3 and sqrt(n)...
-
-import sys
-from math import sqrt
-
-def fact(n):
-    if n < 1:
-        raise ValueError('fact() argument should be >= 1')
-    if n == 1:
-        return []  # special case
-    res = []
-    # Treat even factors special, so we can use i += 2 later
-    while n % 2 == 0:
-        res.append(2)
-        n //= 2
-    # Try odd numbers up to sqrt(n)
-    limit = sqrt(n+1)
-    i = 3
-    while i <= limit:
-        if n % i == 0:
-            res.append(i)
-            n //= i
-            limit = sqrt(n+1)
-        else:
-            i += 2
-    if n != 1:
-        res.append(n)
-    return res
-
-def main():
-    if len(sys.argv) > 1:
-        source = sys.argv[1:]
-    else:
-        source = iter(input, '')
-    for arg in source:
-        try:
-            n = int(arg)
-        except ValueError:
-            print(arg, 'is not an integer')
-        else:
-            print(n, fact(n))
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/find-uname.py b/Demo/scripts/find-uname.py
deleted file mode 100644
index 1902423..0000000
--- a/Demo/scripts/find-uname.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env python
-
-"""
-For each argument on the command line, look for it in the set of all Unicode
-names.  Arguments are treated as case-insensitive regular expressions, e.g.:
-
-    % find-uname 'small letter a$' 'horizontal line'
-    *** small letter a$ matches ***
-    LATIN SMALL LETTER A (97)
-    COMBINING LATIN SMALL LETTER A (867)
-    CYRILLIC SMALL LETTER A (1072)
-    PARENTHESIZED LATIN SMALL LETTER A (9372)
-    CIRCLED LATIN SMALL LETTER A (9424)
-    FULLWIDTH LATIN SMALL LETTER A (65345)
-    *** horizontal line matches ***
-    HORIZONTAL LINE EXTENSION (9135)
-"""
-
-import unicodedata
-import sys
-import re
-
-def main(args):
-    unicode_names = []
-    for ix in range(sys.maxunicode+1):
-        try:
-            unicode_names.append((ix, unicodedata.name(chr(ix))))
-        except ValueError: # no name for the character
-            pass
-    for arg in args:
-        pat = re.compile(arg, re.I)
-        matches = [(y,x) for (x,y) in unicode_names
-                   if pat.search(y) is not None]
-        if matches:
-            print("***", arg, "matches", "***")
-            for match in matches:
-                print("%s (%d)" % match)
-
-if __name__ == "__main__":
-    main(sys.argv[1:])
diff --git a/Demo/scripts/from.py b/Demo/scripts/from.py
deleted file mode 100755
index 323e684..0000000
--- a/Demo/scripts/from.py
+++ /dev/null
@@ -1,35 +0,0 @@
-#! /usr/bin/env python
-
-# Print From and Subject of messages in $MAIL.
-# Extension to multiple mailboxes and other bells & whistles are left
-# as exercises for the reader.
-
-import sys, os
-
-# Open mailbox file.  Exits with exception when this fails.
-
-try:
-    mailbox = os.environ['MAIL']
-except (AttributeError, KeyError):
-    sys.stderr.write('No environment variable $MAIL\n')
-    sys.exit(2)
-
-try:
-    mail = open(mailbox)
-except IOError:
-    sys.exit('Cannot open mailbox file: ' + mailbox)
-
-while 1:
-    line = mail.readline()
-    if not line:
-        break # EOF
-    if line.startswith('From '):
-        # Start of message found
-        print(line[:-1], end=' ')
-        while 1:
-            line = mail.readline()
-            if not line or line == '\n':
-                break
-            if line.startswith('Subject: '):
-                print(repr(line[9:-1]), end=' ')
-        print()
diff --git a/Demo/scripts/lpwatch.py b/Demo/scripts/lpwatch.py
deleted file mode 100755
index 90b3ecf..0000000
--- a/Demo/scripts/lpwatch.py
+++ /dev/null
@@ -1,102 +0,0 @@
-#! /usr/bin/env python
-
-# Watch line printer queue(s).
-# Intended for BSD 4.3 lpq.
-
-import os
-import sys
-import time
-
-DEF_PRINTER = 'psc'
-DEF_DELAY = 10
-
-def main():
-    delay = DEF_DELAY # XXX Use getopt() later
-    try:
-        thisuser = os.environ['LOGNAME']
-    except:
-        thisuser = os.environ['USER']
-    printers = sys.argv[1:]
-    if printers:
-        # Strip '-P' from printer names just in case
-        # the user specified it...
-        for i, name in enumerate(printers):
-            if name[:2] == '-P':
-                printers[i] = name[2:]
-    else:
-        if 'PRINTER' in os.environ:
-            printers = [os.environ['PRINTER']]
-        else:
-            printers = [DEF_PRINTER]
-
-    clearhome = os.popen('clear', 'r').read()
-
-    while True:
-        text = clearhome
-        for name in printers:
-            text += makestatus(name, thisuser) + '\n'
-        print(text)
-        time.sleep(delay)
-
-def makestatus(name, thisuser):
-    pipe = os.popen('lpq -P' + name + ' 2>&1', 'r')
-    lines = []
-    users = {}
-    aheadbytes = 0
-    aheadjobs = 0
-    userseen = False
-    totalbytes = 0
-    totaljobs = 0
-    for line in pipe:
-        fields = line.split()
-        n = len(fields)
-        if len(fields) >= 6 and fields[n-1] == 'bytes':
-            rank, user, job = fields[0:3]
-            files = fields[3:-2]
-            bytes = int(fields[n-2])
-            if user == thisuser:
-                userseen = True
-            elif not userseen:
-                aheadbytes += bytes
-                aheadjobs += 1
-            totalbytes += bytes
-            totaljobs += 1
-            ujobs, ubytes = users.get(user, (0, 0))
-            ujobs += 1
-            ubytes += bytes
-            users[user] = ujobs, ubytes
-        else:
-            if fields and fields[0] != 'Rank':
-                line = line.strip()
-                if line == 'no entries':
-                    line = name + ': idle'
-                elif line[-22:] == ' is ready and printing':
-                    line = name
-                lines.append(line)
-
-    if totaljobs:
-        line = '%d K' % ((totalbytes+1023) // 1024)
-        if totaljobs != len(users):
-            line += ' (%d jobs)' % totaljobs
-        if len(users) == 1:
-            line += ' for %s' % next(iter(users))
-        else:
-            line += ' for %d users' % len(users)
-            if userseen:
-                if aheadjobs == 0:
-                    line += ' (%s first)' % thisuser
-                else:
-                    line += ' (%d K before %s)' % (
-                        (aheadbytes+1023) // 1024, thisuser)
-        lines.append(line)
-
-    sts = pipe.close()
-    if sts:
-        lines.append('lpq exit status %r' % (sts,))
-    return ': '.join(lines)
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        pass
diff --git a/Demo/scripts/makedir.py b/Demo/scripts/makedir.py
deleted file mode 100755
index 7095868..0000000
--- a/Demo/scripts/makedir.py
+++ /dev/null
@@ -1,21 +0,0 @@
-#! /usr/bin/env python
-
-# Like mkdir, but also make intermediate directories if necessary.
-# It is not an error if the given directory already exists (as long
-# as it is a directory).
-# Errors are not treated specially -- you just get a Python exception.
-
-import sys, os
-
-def main():
-    for p in sys.argv[1:]:
-        makedirs(p)
-
-def makedirs(p):
-    if p and not os.path.isdir(p):
-        head, tail = os.path.split(p)
-        makedirs(head)
-        os.mkdir(p, 0o777)
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/markov.py b/Demo/scripts/markov.py
deleted file mode 100755
index 990c972..0000000
--- a/Demo/scripts/markov.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#! /usr/bin/env python
-
-class Markov:
-    def __init__(self, histsize, choice):
-        self.histsize = histsize
-        self.choice = choice
-        self.trans = {}
-
-    def add(self, state, next):
-        self.trans.setdefault(state, []).append(next)
-
-    def put(self, seq):
-        n = self.histsize
-        add = self.add
-        add(None, seq[:0])
-        for i in range(len(seq)):
-            add(seq[max(0, i-n):i], seq[i:i+1])
-        add(seq[len(seq)-n:], None)
-
-    def get(self):
-        choice = self.choice
-        trans = self.trans
-        n = self.histsize
-        seq = choice(trans[None])
-        while True:
-            subseq = seq[max(0, len(seq)-n):]
-            options = trans[subseq]
-            next = choice(options)
-            if not next:
-                break
-            seq += next
-        return seq
-
-
-def test():
-    import sys, random, getopt
-    args = sys.argv[1:]
-    try:
-        opts, args = getopt.getopt(args, '0123456789cdwq')
-    except getopt.error:
-        print('Usage: %s [-#] [-cddqw] [file] ...' % sys.argv[0])
-        print('Options:')
-        print('-#: 1-digit history size (default 2)')
-        print('-c: characters (default)')
-        print('-w: words')
-        print('-d: more debugging output')
-        print('-q: no debugging output')
-        print('Input files (default stdin) are split in paragraphs')
-        print('separated blank lines and each paragraph is split')
-        print('in words by whitespace, then reconcatenated with')
-        print('exactly one space separating words.')
-        print('Output consists of paragraphs separated by blank')
-        print('lines, where lines are no longer than 72 characters.')
-        sys.exit(2)
-    histsize = 2
-    do_words = False
-    debug = 1
-    for o, a in opts:
-        if '-0' <= o <= '-9': histsize = int(o[1:])
-        if o == '-c': do_words = False
-        if o == '-d': debug += 1
-        if o == '-q': debug = 0
-        if o == '-w': do_words = True
-    if not args:
-        args = ['-']
-
-    m = Markov(histsize, random.choice)
-    try:
-        for filename in args:
-            if filename == '-':
-                f = sys.stdin
-                if f.isatty():
-                    print('Sorry, need stdin from file')
-                    continue
-            else:
-                f = open(filename, 'r')
-            if debug: print('processing', filename, '...')
-            text = f.read()
-            f.close()
-            paralist = text.split('\n\n')
-            for para in paralist:
-                if debug > 1: print('feeding ...')
-                words = para.split()
-                if words:
-                    if do_words:
-                        data = tuple(words)
-                    else:
-                        data = ' '.join(words)
-                    m.put(data)
-    except KeyboardInterrupt:
-        print('Interrupted -- continue with data read so far')
-    if not m.trans:
-        print('No valid input files')
-        return
-    if debug: print('done.')
-
-    if debug > 1:
-        for key in m.trans.keys():
-            if key is None or len(key) < histsize:
-                print(repr(key), m.trans[key])
-        if histsize == 0: print(repr(''), m.trans[''])
-        print()
-    while True:
-        data = m.get()
-        if do_words:
-            words = data
-        else:
-            words = data.split()
-        n = 0
-        limit = 72
-        for w in words:
-            if n + len(w) > limit:
-                print()
-                n = 0
-            print(w, end=' ')
-            n += len(w) + 1
-        print()
-        print()
-
-if __name__ == "__main__":
-    test()
diff --git a/Demo/scripts/mboxconvert.py b/Demo/scripts/mboxconvert.py
deleted file mode 100755
index 2e44f06..0000000
--- a/Demo/scripts/mboxconvert.py
+++ /dev/null
@@ -1,124 +0,0 @@
-#! /usr/bin/env python
-
-# Convert  MH directories (1 message per file) or MMDF mailboxes (4x^A
-# delimited) to unix mailbox (From ... delimited) on stdout.
-# If -f is given, files contain one message per file (e.g. MH messages)
-
-import rfc822
-import sys
-import time
-import os
-import stat
-import getopt
-import re
-
-def main():
-    dofile = mmdf
-    try:
-        opts, args = getopt.getopt(sys.argv[1:], 'f')
-    except getopt.error as msg:
-        sys.stderr.write('%s\n' % msg)
-        sys.exit(2)
-    for o, a in opts:
-        if o == '-f':
-            dofile = message
-    if not args:
-        args = ['-']
-    sts = 0
-    for arg in args:
-        if arg == '-' or arg == '':
-            sts = dofile(sys.stdin) or sts
-        elif os.path.isdir(arg):
-            sts = mh(arg) or sts
-        elif os.path.isfile(arg):
-            try:
-                f = open(arg)
-            except IOError as msg:
-                sys.stderr.write('%s: %s\n' % (arg, msg))
-                sts = 1
-                continue
-            sts = dofile(f) or sts
-            f.close()
-        else:
-            sys.stderr.write('%s: not found\n' % arg)
-            sts = 1
-    if sts:
-        sys.exit(sts)
-
-numeric = re.compile('[1-9][0-9]*')
-
-def mh(dir):
-    sts = 0
-    msgs = os.listdir(dir)
-    for msg in msgs:
-        if numeric.match(msg) != len(msg):
-            continue
-        fn = os.path.join(dir, msg)
-        try:
-            f = open(fn)
-        except IOError as msg:
-            sys.stderr.write('%s: %s\n' % (fn, msg))
-            sts = 1
-            continue
-        sts = message(f) or sts
-    return sts
-
-def mmdf(f):
-    sts = 0
-    while 1:
-        line = f.readline()
-        if not line:
-            break
-        if line == '\1\1\1\1\n':
-            sts = message(f, line) or sts
-        else:
-            sys.stderr.write(
-                    'Bad line in MMFD mailbox: %r\n' % (line,))
-    return sts
-
-counter = 0 # for generating unique Message-ID headers
-
-def message(f, delimiter = ''):
-    sts = 0
-    # Parse RFC822 header
-    m = rfc822.Message(f)
-    # Write unix header line
-    fullname, email = m.getaddr('From')
-    tt = m.getdate('Date')
-    if tt:
-        t = time.mktime(tt)
-    else:
-        sys.stderr.write(
-                'Unparseable date: %r\n' % (m.get('Date'),))
-        t = os.fstat(f.fileno())[stat.ST_MTIME]
-    print('From', email, time.ctime(t))
-    # Copy RFC822 header
-    for line in m.headers:
-        print(line, end=' ')
-    # Invent Message-ID header if none is present
-    if 'message-id' not in m:
-        global counter
-        counter = counter + 1
-        msgid = "<%s.%d>" % (hex(t), counter)
-        sys.stderr.write("Adding Message-ID %s (From %s)\n" %
-                         (msgid, email))
-        print("Message-ID:", msgid)
-    print()
-    # Copy body
-    while 1:
-        line = f.readline()
-        if line == delimiter:
-            break
-        if not line:
-            sys.stderr.write('Unexpected EOF in message\n')
-            sts = 1
-            break
-        if line[:5] == 'From ':
-            line = '>' + line
-        print(line, end=' ')
-    # Print trailing newline
-    print()
-    return sts
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/morse.py b/Demo/scripts/morse.py
deleted file mode 100755
index 5aacaa1..0000000
--- a/Demo/scripts/morse.py
+++ /dev/null
@@ -1,128 +0,0 @@
-#! /usr/bin/env python
-
-# DAH should be three DOTs.
-# Space between DOTs and DAHs should be one DOT.
-# Space between two letters should be one DAH.
-# Space between two words should be DOT DAH DAH.
-
-import sys, math, aifc
-from contextlib import closing
-
-DOT = 30
-DAH = 3 * DOT
-OCTAVE = 2                              # 1 == 441 Hz, 2 == 882 Hz, ...
-
-morsetab = {
-        'A': '.-',              'a': '.-',
-        'B': '-...',            'b': '-...',
-        'C': '-.-.',            'c': '-.-.',
-        'D': '-..',             'd': '-..',
-        'E': '.',               'e': '.',
-        'F': '..-.',            'f': '..-.',
-        'G': '--.',             'g': '--.',
-        'H': '....',            'h': '....',
-        'I': '..',              'i': '..',
-        'J': '.---',            'j': '.---',
-        'K': '-.-',             'k': '-.-',
-        'L': '.-..',            'l': '.-..',
-        'M': '--',              'm': '--',
-        'N': '-.',              'n': '-.',
-        'O': '---',             'o': '---',
-        'P': '.--.',            'p': '.--.',
-        'Q': '--.-',            'q': '--.-',
-        'R': '.-.',             'r': '.-.',
-        'S': '...',             's': '...',
-        'T': '-',               't': '-',
-        'U': '..-',             'u': '..-',
-        'V': '...-',            'v': '...-',
-        'W': '.--',             'w': '.--',
-        'X': '-..-',            'x': '-..-',
-        'Y': '-.--',            'y': '-.--',
-        'Z': '--..',            'z': '--..',
-        '0': '-----',           ',': '--..--',
-        '1': '.----',           '.': '.-.-.-',
-        '2': '..---',           '?': '..--..',
-        '3': '...--',           ';': '-.-.-.',
-        '4': '....-',           ':': '---...',
-        '5': '.....',           "'": '.----.',
-        '6': '-....',           '-': '-....-',
-        '7': '--...',           '/': '-..-.',
-        '8': '---..',           '(': '-.--.-',
-        '9': '----.',           ')': '-.--.-',
-        ' ': ' ',               '_': '..--.-',
-}
-
-nowave = b'\0' * 200
-
-# If we play at 44.1 kHz (which we do), then if we produce one sine
-# wave in 100 samples, we get a tone of 441 Hz.  If we produce two
-# sine waves in these 100 samples, we get a tone of 882 Hz.  882 Hz
-# appears to be a nice one for playing morse code.
-def mkwave(octave):
-    sinewave = bytearray()
-    for i in range(100):
-        val = int(math.sin(math.pi * i * octave / 50.0) * 30000)
-        sinewave.extend([(val >> 8) & 255, val & 255])
-    return bytes(sinewave)
-
-defaultwave = mkwave(OCTAVE)
-
-def main():
-    import getopt
-    try:
-        opts, args = getopt.getopt(sys.argv[1:], 'o:p:')
-    except getopt.error:
-        sys.stderr.write('Usage ' + sys.argv[0] +
-                         ' [ -o outfile ] [ -p octave ] [ words ] ...\n')
-        sys.exit(1)
-    wave = defaultwave
-    outfile = 'morse.aifc'
-    for o, a in opts:
-        if o == '-o':
-            outfile = a
-        if o == '-p':
-            wave = mkwave(int(a))
-    with closing(aifc.open(outfile, 'w')) as fp:
-        fp.setframerate(44100)
-        fp.setsampwidth(2)
-        fp.setnchannels(1)
-        if args:
-            source = [' '.join(args)]
-        else:
-            source = iter(sys.stdin.readline, '')
-        for line in source:
-            mline = morse(line)
-            play(mline, fp, wave)
-
-# Convert a string to morse code with \001 between the characters in
-# the string.
-def morse(line):
-    res = ''
-    for c in line:
-        try:
-            res += morsetab[c] + '\001'
-        except KeyError:
-            pass
-    return res
-
-# Play a line of morse code.
-def play(line, fp, wave):
-    for c in line:
-        if c == '.':
-            sine(fp, DOT, wave)
-        elif c == '-':
-            sine(fp, DAH, wave)
-        else:                   # space
-            pause(fp, DAH + DOT)
-        pause(fp, DOT)
-
-def sine(fp, length, wave):
-    for i in range(length):
-        fp.writeframesraw(wave)
-
-def pause(fp, length):
-    for i in range(length):
-        fp.writeframesraw(nowave)
-
-if __name__ == '__main__':
-    main()
diff --git a/Demo/scripts/newslist.doc b/Demo/scripts/newslist.doc
deleted file mode 100755
index 87fd9ba..0000000
--- a/Demo/scripts/newslist.doc
+++ /dev/null
@@ -1,59 +0,0 @@
-                             NEWSLIST
-                             ========    
-            A program to assist HTTP browsing of newsgroups
-            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-WWW browsers such as NCSA Mosaic allow the user to read newsgroup
-articles by specifying the group name in a URL eg 'news:comp.answers'.
-
-To browse through many groups, though, (and there are several thousand
-of them) you really need a page or pages containing links to all the
-groups. There are some good ones out there, for example,
-
-    http://info.cern.ch/hypertext/DataSources/News/Groups/Overview.html
-
-is the standard one at CERN, but it only shows the groups available there,
-which may be rather different from those available on your machine.
-
-Newslist is a program which creates a hierarchy of pages for you based
-on the groups available from YOUR server. It is written in python - a
-splendid interpreted object-oriented language which I suggest you get
-right now from the directory /pub/python at ftp.cwi.nl, if you haven't
-already got it.
-
-You should be able to see some sample output by looking at:
-   http://pelican.cl.cam.ac.uk/newspage/root.html
-
-Descriptions of newsgroups can be added from a file with one group
-per line. eg:
-
-	alt.foo   Articles about foo
-	comp.bar  Programming in 'bar' and related languages
-
-A suitable list detailing most groups can be found at ftp.uu.net in
-/uunet-info/newsgroups.gz.
-
-Make sure you read the information at the beginning of the program source and
-configure the variables before running.
-
-In addition to python, you need:
-
-	An NNTP-based news feed.
-	A directory in which to put the pages.
-
-The programming is not very beautiful, but it works!  It comes with no
-warranty, express or implied, but with the hope that some others may
-find it useful.
-
-Comments, improvements & suggestions welcomed.
-Quentin Stafford-Fraser
-
- ----------------------------------------------------------------------
-                       Quentin Stafford-Fraser
-            http://pelican.cl.cam.ac.uk/people/qs101/me.html
- 
- Cambridge University Computer Lab        Rank Xerox Cambridge EuroPARC
- qs101@cl.cam.ac.uk                           fraser@europarc.xerox.com
- Tel: +44 223 334411                                Tel: +44 223 341521
- Fax: +44 223 334679                                Fax: +44 223 341510
- ----------------------------------------------------------------------
diff --git a/Demo/scripts/newslist.py b/Demo/scripts/newslist.py
deleted file mode 100755
index 9cea1b4..0000000
--- a/Demo/scripts/newslist.py
+++ /dev/null
@@ -1,361 +0,0 @@
-#! /usr/bin/env python
-#######################################################################
-# Newslist  $Revision$
-#
-# Syntax:
-#    newslist [ -a ]
-#
-# This is a program to create a directory full of HTML pages
-# which between them contain links to all the newsgroups available
-# on your server.
-#
-# The -a option causes a complete list of all groups to be read from
-# the server rather than just the ones which have appeared since last
-# execution. This recreates the local list from scratch. Use this on
-# the first invocation of the program, and from time to time thereafter.
-#   When new groups are first created they may appear on your server as
-# empty groups. By default, empty groups are ignored by the -a option.
-# However, these new groups will not be created again, and so will not
-# appear in the server's list of 'new groups' at a later date. Hence it
-# won't appear until you do a '-a' after some articles have appeared.
-#
-# I should really keep a list of ignored empty groups and re-check them
-# for articles on every run, but I haven't got around to it yet.
-#
-# This assumes an NNTP news feed.
-#
-# Feel free to copy, distribute and modify this code for
-# non-commercial use. If you make any useful modifications, let me
-# know!
-#
-# (c) Quentin Stafford-Fraser 1994
-# fraser@europarc.xerox.com                     qs101@cl.cam.ac.uk
-#                                                                     #
-#######################################################################
-import sys, nntplib, marshal, time, os
-
-#######################################################################
-# Check these variables before running!                               #
-
-# Top directory.
-# Filenames which don't start with / are taken as being relative to this.
-topdir = os.path.expanduser('~/newspage')
-
-# The name of your NNTP host
-# eg.
-#    newshost = 'nntp-serv.cl.cam.ac.uk'
-# or use following to get the name from the NNTPSERVER environment
-# variable:
-#    newshost = os.environ['NNTPSERVER']
-newshost = 'news.example.com'
-
-# The filename for a local cache of the newsgroup list
-treefile = 'grouptree'
-
-# The filename for descriptions of newsgroups
-# I found a suitable one at ftp.uu.net in /uunet-info/newgroups.gz
-# You can set this to '' if you don't wish to use one.
-descfile = 'newsgroups'
-
-# The directory in which HTML pages should be created
-# eg.
-#   pagedir  = '/usr/local/lib/html/newspage'
-#   pagedir  = 'pages'
-pagedir  = topdir
-
-# The html prefix which will refer to this directory
-# eg.
-#   httppref = '/newspage/',
-# or leave blank for relative links between pages: (Recommended)
-#   httppref = ''
-httppref = ''
-
-# The name of the 'root' news page in this directory.
-# A .html suffix will be added.
-rootpage = 'root'
-
-# Set skipempty to 0 if you wish to see links to empty groups as well.
-# Only affects the -a option.
-skipempty = 1
-
-# pagelinkicon can contain html to put an icon after links to
-# further pages. This helps to make important links stand out.
-# Set to '' if not wanted, or '...' is quite a good one.
-pagelinkicon = '... <img src="http://pelican.cl.cam.ac.uk/icons/page.xbm"> '
-
-# ---------------------------------------------------------------------
-# Less important personal preferences:
-
-# Sublistsize controls the maximum number of items the will appear as
-# an indented sub-list before the whole thing is moved onto a different
-# page. The smaller this is, the more pages you will have, but the
-# shorter each will be.
-sublistsize = 4
-
-# That should be all.                                                 #
-#######################################################################
-
-for dir in os.curdir, os.environ['HOME']:
-    rcfile = os.path.join(dir, '.newslistrc.py')
-    if os.path.exists(rcfile):
-        print(rcfile)
-        exec(open(rcfile).read())
-        break
-
-from nntplib import NNTP
-from stat import *
-
-rcsrev = '$Revision$'
-rcsrev = ' '.join([s for s in rcsrev.split() if '$' not in s])
-desc = {}
-
-# Make (possibly) relative filenames into absolute ones
-treefile = os.path.join(topdir,treefile)
-descfile = os.path.join(topdir,descfile)
-page = os.path.join(topdir,pagedir)
-
-# First the bits for creating trees ---------------------------
-
-# Addtotree creates/augments a tree from a list of group names
-def addtotree(tree, groups):
-    print('Updating tree...')
-    for i in groups:
-        parts = i.split('.')
-        makeleaf(tree, parts)
-
-# Makeleaf makes a leaf and the branch leading to it if necessary
-def makeleaf(tree,path):
-    j = path[0]
-    l = len(path)
-
-    if j not in tree:
-        tree[j] = {}
-    if l == 1:
-        tree[j]['.'] = '.'
-    if l > 1:
-        makeleaf(tree[j],path[1:])
-
-# Then the bits for outputting trees as pages ----------------
-
-# Createpage creates an HTML file named <root>.html containing links
-# to those groups beginning with <root>.
-
-def createpage(root, tree, p):
-    filename = os.path.join(pagedir, root+'.html')
-    if root == rootpage:
-        detail = ''
-    else:
-        detail = ' under ' + root
-    with open(filename, 'w') as f:
-        # f.write('Content-Type: text/html\n')
-        f.write('<html>\n<head>\n')
-        f.write('<title>Newsgroups available%s</title>\n' % detail)
-        f.write('</head>\n<body>\n')
-        f.write('<h1>Newsgroups available%s</h1>\n' % detail)
-        f.write('<a href="%s%s.html">Back to top level</a><p>\n' %
-                (httppref, rootpage))
-        printtree(f, tree, 0, p)
-        f.write('\n<p>')
-        f.write("<i>This page automatically created by 'newslist' v. %s." %
-                rcsrev)
-        f.write(time.ctime(time.time()) + '</i>\n')
-        f.write('</body>\n</html>\n')
-
-# Printtree prints the groups as a bulleted list.  Groups with
-# more than <sublistsize> subgroups will be put on a separate page.
-# Other sets of subgroups are just indented.
-
-def printtree(f, tree, indent, p):
-    l = len(tree)
-
-    if l > sublistsize and indent > 0:
-        # Create a new page and a link to it
-        f.write('<li><b><a href="%s%s.html">' % (httppref, p[1:]))
-        f.write(p[1:] + '.*')
-        f.write('</a></b>%s\n' % pagelinkicon)
-        createpage(p[1:], tree, p)
-        return
-
-    kl = sorted(tree.keys())
-
-    if l > 1:
-        if indent > 0:
-            # Create a sub-list
-            f.write('<li>%s\n<ul>' % p[1:])
-        else:
-            # Create a main list
-            f.write('<ul>')
-        indent = indent + 1
-
-    for i in kl:
-        if i == '.':
-            # Output a newsgroup
-            f.write('<li><a href="news:%s">%s</a> ' % (p[1:], p[1:]))
-            if p[1:] in desc:
-                f.write('     <i>%s</i>\n' % desc[p[1:]])
-            else:
-                f.write('\n')
-        else:
-            # Output a hierarchy
-            printtree(f, tree[i], indent, p+'.'+i)
-
-    if l > 1:
-        f.write('\n</ul>')
-
-# Reading descriptions file ---------------------------------------
-
-# This returns a dict mapping group name to its description
-
-def readdesc(descfile):
-    global desc
-    desc = {}
-
-    if descfile == '':
-        return
-
-    try:
-        with open(descfile, 'r') as d:
-            print('Reading descriptions...')
-            for l in d:
-                bits = l.split()
-                try:
-                    grp = bits[0]
-                    dsc = ' '.join(bits[1:])
-                    if len(dsc) > 1:
-                        desc[grp] = dsc
-                except IndexError:
-                    pass
-    except IOError:
-        print('Failed to open description file ' + descfile)
-        return
-
-# Check that ouput directory exists, ------------------------------
-# and offer to create it if not
-
-def checkopdir(pagedir):
-    if not os.path.isdir(pagedir):
-        print('Directory %s does not exist.' % pagedir)
-        print('Shall I create it for you? (y/n)')
-        if sys.stdin.readline()[0] == 'y':
-            try:
-                os.mkdir(pagedir, 0o777)
-            except:
-                print('Sorry - failed!')
-                sys.exit(1)
-        else:
-            print('OK. Exiting.')
-            sys.exit(1)
-
-# Read and write current local tree ----------------------------------
-
-def readlocallist(treefile):
-    print('Reading current local group list...')
-    tree = {}
-    try:
-        treetime = time.localtime(os.stat(treefile)[ST_MTIME])
-    except:
-        print('\n*** Failed to open local group cache '+treefile)
-        print('If this is the first time you have run newslist, then')
-        print('use the -a option to create it.')
-        sys.exit(1)
-    treedate = '%02d%02d%02d' % (treetime[0] % 100, treetime[1], treetime[2])
-    try:
-        with open(treefile, 'rb') as dump:
-            tree = marshal.load(dump)
-    except IOError:
-        print('Cannot open local group list ' + treefile)
-    return (tree, treedate)
-
-def writelocallist(treefile, tree):
-    try:
-        with open(treefile, 'wb') as dump:
-            groups = marshal.dump(tree, dump)
-        print('Saved list to %s\n' % treefile)
-    except:
-        print('Sorry - failed to write to local group cache', treefile)
-        print('Does it (or its directory) have the correct permissions?')
-        sys.exit(1)
-
-# Return list of all groups on server -----------------------------
-
-def getallgroups(server):
-    print('Getting list of all groups...')
-    treedate = '010101'
-    info = server.list()[1]
-    groups = []
-    print('Processing...')
-    if skipempty:
-        print('\nIgnoring following empty groups:')
-    for i in info:
-        grpname = i[0].split()[0]
-        if skipempty and int(i[1]) < int(i[2]):
-            print(grpname.decode() + ' ', end=' ')
-        else:
-            groups.append(grpname.decode())
-    print('\n')
-    if skipempty:
-        print('(End of empty groups)')
-    return groups
-
-# Return list of new groups on server -----------------------------
-
-def getnewgroups(server, treedate):
-    print('Getting list of new groups since start of %s...' % treedate, end=' ')
-    info = server.newgroups(treedate, '000001')[1]
-    print('got %d.' % len(info))
-    print('Processing...', end=' ')
-    groups = []
-    for i in info:
-        grpname = i.split()[0]
-        groups.append(grpname.decode())
-    print('Done')
-    return groups
-
-# Now the main program --------------------------------------------
-
-def main():
-    tree = {}
-
-    # Check that the output directory exists
-    checkopdir(pagedir)
-
-    try:
-        print('Connecting to %s...' % newshost)
-        if sys.version[0] == '0':
-            s = NNTP.init(newshost)
-        else:
-            s = NNTP(newshost)
-        connected = True
-    except (nntplib.error_temp, nntplib.error_perm) as x:
-        print('Error connecting to host:', x)
-        print('I\'ll try to use just the local list.')
-        connected = False
-
-    # If -a is specified, read the full list of groups from server
-    if connected and len(sys.argv) > 1 and sys.argv[1] == '-a':
-        groups = getallgroups(s)
-
-    # Otherwise just read the local file and then add
-    # groups created since local file last modified.
-    else:
-
-        (tree, treedate) = readlocallist(treefile)
-        if connected:
-            groups = getnewgroups(s, treedate)
-
-    if connected:
-        addtotree(tree, groups)
-        writelocallist(treefile,tree)
-
-    # Read group descriptions
-    readdesc(descfile)
-
-    print('Creating pages...')
-    createpage(rootpage, tree, '')
-    print('Done')
-
-if __name__ == "__main__":
-    main()
-
-# That's all folks
-######################################################################
diff --git a/Demo/scripts/pi.py b/Demo/scripts/pi.py
deleted file mode 100755
index 0740cd0..0000000
--- a/Demo/scripts/pi.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#! /usr/bin/env python
-
-# Print digits of pi forever.
-#
-# The algorithm, using Python's 'long' integers ("bignums"), works
-# with continued fractions, and was conceived by Lambert Meertens.
-#
-# See also the ABC Programmer's Handbook, by Geurts, Meertens & Pemberton,
-# published by Prentice-Hall (UK) Ltd., 1990.
-
-import sys
-
-def main():
-    k, a, b, a1, b1 = 2, 4, 1, 12, 4
-    while True:
-        # Next approximation
-        p, q, k = k*k, 2*k+1, k+1
-        a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
-        # Print common digits
-        d, d1 = a//b, a1//b1
-        while d == d1:
-            output(d)
-            a, a1 = 10*(a%b), 10*(a1%b1)
-            d, d1 = a//b, a1//b1
-
-def output(d):
-    # Use write() to avoid spaces between the digits
-    sys.stdout.write(str(d))
-    # Flush so the output is seen immediately
-    sys.stdout.flush()
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/pp.py b/Demo/scripts/pp.py
deleted file mode 100755
index 2c948f7..0000000
--- a/Demo/scripts/pp.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#! /usr/bin/env python
-
-# Emulate some Perl command line options.
-# Usage: pp [-a] [-c] [-d] [-e scriptline] [-F fieldsep] [-n] [-p] [file] ...
-# Where the options mean the following:
-#   -a            : together with -n or -p, splits each line into list F
-#   -c            : check syntax only, do not execute any code
-#   -d            : run the script under the debugger, pdb
-#   -e scriptline : gives one line of the Python script; may be repeated
-#   -F fieldsep   : sets the field separator for the -a option [not in Perl]
-#   -n            : runs the script for each line of input
-#   -p            : prints the line after the script has run
-# When no script lines have been passed, the first file argument
-# contains the script.  With -n or -p, the remaining arguments are
-# read as input to the script, line by line.  If a file is '-'
-# or missing, standard input is read.
-
-# XXX To do:
-# - add -i extension option (change files in place)
-# - make a single loop over the files and lines (changes effect of 'break')?
-# - add an option to specify the record separator
-# - except for -n/-p, run directly from the file if at all possible
-
-import sys
-import getopt
-
-FS = ''
-SCRIPT = []
-AFLAG = 0
-CFLAG = 0
-DFLAG = 0
-NFLAG = 0
-PFLAG = 0
-
-try:
-    optlist, ARGS = getopt.getopt(sys.argv[1:], 'acde:F:np')
-except getopt.error as msg:
-    sys.stderr.write('%s: %s\n' % (sys.argv[0], msg))
-    sys.exit(2)
-
-for option, optarg in optlist:
-    if option == '-a':
-        AFLAG = 1
-    elif option == '-c':
-        CFLAG = 1
-    elif option == '-d':
-        DFLAG = 1
-    elif option == '-e':
-        for line in optarg.split('\n'):
-            SCRIPT.append(line)
-    elif option == '-F':
-        FS = optarg
-    elif option == '-n':
-        NFLAG = 1
-        PFLAG = 0
-    elif option == '-p':
-        NFLAG = 1
-        PFLAG = 1
-    else:
-        print(option, 'not recognized???')
-
-if not ARGS: ARGS.append('-')
-
-if not SCRIPT:
-    if ARGS[0] == '-':
-        fp = sys.stdin
-    else:
-        fp = open(ARGS[0], 'r')
-    while 1:
-        line = fp.readline()
-        if not line: break
-        SCRIPT.append(line[:-1])
-    del fp
-    del ARGS[0]
-    if not ARGS: ARGS.append('-')
-
-if CFLAG:
-    prologue = ['if 0:']
-    epilogue = []
-elif NFLAG:
-    # Note that it is on purpose that AFLAG and PFLAG are
-    # tested dynamically each time through the loop
-    prologue = [
-            'LINECOUNT = 0',
-            'for FILE in ARGS:',
-            '   \tif FILE == \'-\':',
-            '   \t   \tFP = sys.stdin',
-            '   \telse:',
-            '   \t   \tFP = open(FILE, \'r\')',
-            '   \tLINENO = 0',
-            '   \twhile 1:',
-            '   \t   \tLINE = FP.readline()',
-            '   \t   \tif not LINE: break',
-            '   \t   \tLINENO = LINENO + 1',
-            '   \t   \tLINECOUNT = LINECOUNT + 1',
-            '   \t   \tL = LINE[:-1]',
-            '   \t   \taflag = AFLAG',
-            '   \t   \tif aflag:',
-            '   \t   \t   \tif FS: F = L.split(FS)',
-            '   \t   \t   \telse: F = L.split()'
-            ]
-    epilogue = [
-            '   \t   \tif not PFLAG: continue',
-            '   \t   \tif aflag:',
-            '   \t   \t   \tif FS: print(FS.join(F))',
-            '   \t   \t   \telse: print(\' \'.join(F))',
-            '   \t   \telse: print(L)',
-            ]
-else:
-    prologue = ['if 1:']
-    epilogue = []
-
-# Note that we indent using tabs only, so that any indentation style
-# used in 'command' will come out right after re-indentation.
-
-program = '\n'.join(prologue) + '\n'
-for line in SCRIPT:
-    program += '   \t   \t' + line + '\n'
-program += '\n'.join(epilogue) + '\n'
-
-if DFLAG:
-    import pdb
-    pdb.run(program)
-else:
-    exec(program)
diff --git a/Demo/scripts/primes.py b/Demo/scripts/primes.py
deleted file mode 100755
index 0924aab..0000000
--- a/Demo/scripts/primes.py
+++ /dev/null
@@ -1,27 +0,0 @@
-#! /usr/bin/env python
-
-# Print prime numbers in a given range
-
-def main():
-    import sys
-    min, max = 2, 0x7fffffff
-    if sys.argv[1:]:
-        min = int(eval(sys.argv[1]))
-        if sys.argv[2:]:
-            max = int(eval(sys.argv[2]))
-    primes(min, max)
-
-def primes(min, max):
-    if 2 >= min: print(2)
-    primes = [2]
-    i = 3
-    while i <= max:
-        for p in primes:
-            if i%p == 0 or p*p > i: break
-        if i%p != 0:
-            primes.append(i)
-            if i >= min: print(i)
-        i = i+2
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/queens.py b/Demo/scripts/queens.py
deleted file mode 100755
index 726433c..0000000
--- a/Demo/scripts/queens.py
+++ /dev/null
@@ -1,85 +0,0 @@
-#! /usr/bin/env python
-
-"""N queens problem.
-
-The (well-known) problem is due to Niklaus Wirth.
-
-This solution is inspired by Dijkstra (Structured Programming).  It is
-a classic recursive backtracking approach.
-
-"""
-
-N = 8                                   # Default; command line overrides
-
-class Queens:
-
-    def __init__(self, n=N):
-        self.n = n
-        self.reset()
-
-    def reset(self):
-        n = self.n
-        self.y = [None] * n             # Where is the queen in column x
-        self.row = [0] * n              # Is row[y] safe?
-        self.up = [0] * (2*n-1)         # Is upward diagonal[x-y] safe?
-        self.down = [0] * (2*n-1)       # Is downward diagonal[x+y] safe?
-        self.nfound = 0                 # Instrumentation
-
-    def solve(self, x=0):               # Recursive solver
-        for y in range(self.n):
-            if self.safe(x, y):
-                self.place(x, y)
-                if x+1 == self.n:
-                    self.display()
-                else:
-                    self.solve(x+1)
-                self.remove(x, y)
-
-    def safe(self, x, y):
-        return not self.row[y] and not self.up[x-y] and not self.down[x+y]
-
-    def place(self, x, y):
-        self.y[x] = y
-        self.row[y] = 1
-        self.up[x-y] = 1
-        self.down[x+y] = 1
-
-    def remove(self, x, y):
-        self.y[x] = None
-        self.row[y] = 0
-        self.up[x-y] = 0
-        self.down[x+y] = 0
-
-    silent = 0                          # If true, count solutions only
-
-    def display(self):
-        self.nfound = self.nfound + 1
-        if self.silent:
-            return
-        print('+-' + '--'*self.n + '+')
-        for y in range(self.n-1, -1, -1):
-            print('|', end=' ')
-            for x in range(self.n):
-                if self.y[x] == y:
-                    print("Q", end=' ')
-                else:
-                    print(".", end=' ')
-            print('|')
-        print('+-' + '--'*self.n + '+')
-
-def main():
-    import sys
-    silent = 0
-    n = N
-    if sys.argv[1:2] == ['-n']:
-        silent = 1
-        del sys.argv[1]
-    if sys.argv[1:]:
-        n = int(sys.argv[1])
-    q = Queens(n)
-    q.silent = silent
-    q.solve()
-    print("Found", q.nfound, "solutions.")
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/script.py b/Demo/scripts/script.py
deleted file mode 100755
index b490b17..0000000
--- a/Demo/scripts/script.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#! /usr/bin/env python
-
-# script.py -- Make typescript of terminal session.
-# Usage:
-#       -a      Append to typescript.
-#       -p      Use Python as shell.
-# Author: Steen Lumholt.
-
-
-import os, time, sys, getopt
-import pty
-
-def read(fd):
-    data = os.read(fd, 1024)
-    script.write(data)
-    return data
-
-shell = 'sh'
-filename = 'typescript'
-mode = 'wb'
-if 'SHELL' in os.environ:
-    shell = os.environ['SHELL']
-
-try:
-    opts, args = getopt.getopt(sys.argv[1:], 'ap')
-except getopt.error as msg:
-    print('%s: %s' % (sys.argv[0], msg))
-    sys.exit(2)
-
-for o, a in opts:
-    if o == '-a':
-        mode = 'ab'
-    elif o == '-p':
-        shell = 'python'
-
-script = open(filename, mode)
-
-sys.stdout.write('Script started, file is %s\n' % filename)
-script.write(('Script started on %s\n' % time.ctime(time.time())).encode())
-pty.spawn(shell, read)
-script.write(('Script done on %s\n' % time.ctime(time.time())).encode())
-sys.stdout.write('Script done, file is %s\n' % filename)
diff --git a/Demo/scripts/toaiff.py b/Demo/scripts/toaiff.py
deleted file mode 100644
index 0e9be23..0000000
--- a/Demo/scripts/toaiff.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""Convert "arbitrary" sound files to AIFF (Apple and SGI's audio format).
-
-Input may be compressed.
-Uncompressed file type may be AIFF, WAV, VOC, 8SVX, NeXT/Sun, and others.
-An exception is raised if the file is not of a recognized type.
-Returned filename is either the input filename or a temporary filename;
-in the latter case the caller must ensure that it is removed.
-Other temporary files used are removed by the function.
-"""
-
-import os
-import tempfile
-import pipes
-import sndhdr
-
-__all__ = ["error", "toaiff"]
-
-table = {}
-
-t = pipes.Template()
-t.append('sox -t au - -t aiff -r 8000 -', '--')
-table['au'] = t
-
-# XXX The following is actually sub-optimal.
-# XXX The HCOM sampling rate can be 22k, 22k/2, 22k/3 or 22k/4.
-# XXX We must force the output sampling rate else the SGI won't play
-# XXX files sampled at 5.5k or 7.333k; however this means that files
-# XXX sampled at 11k are unnecessarily expanded.
-# XXX Similar comments apply to some other file types.
-t = pipes.Template()
-t.append('sox -t hcom - -t aiff -r 22050 -', '--')
-table['hcom'] = t
-
-t = pipes.Template()
-t.append('sox -t voc - -t aiff -r 11025 -', '--')
-table['voc'] = t
-
-t = pipes.Template()
-t.append('sox -t wav - -t aiff -', '--')
-table['wav'] = t
-
-t = pipes.Template()
-t.append('sox -t 8svx - -t aiff -r 16000 -', '--')
-table['8svx'] = t
-
-t = pipes.Template()
-t.append('sox -t sndt - -t aiff -r 16000 -', '--')
-table['sndt'] = t
-
-t = pipes.Template()
-t.append('sox -t sndr - -t aiff -r 16000 -', '--')
-table['sndr'] = t
-
-uncompress = pipes.Template()
-uncompress.append('uncompress', '--')
-
-
-class error(Exception):
-    pass
-
-def toaiff(filename):
-    temps = []
-    ret = None
-    try:
-        ret = _toaiff(filename, temps)
-    finally:
-        for temp in temps[:]:
-            if temp != ret:
-                try:
-                    os.unlink(temp)
-                except os.error:
-                    pass
-                temps.remove(temp)
-    return ret
-
-def _toaiff(filename, temps):
-    if filename[-2:] == '.Z':
-        (fd, fname) = tempfile.mkstemp()
-        os.close(fd)
-        temps.append(fname)
-        sts = uncompress.copy(filename, fname)
-        if sts:
-            raise error(filename + ': uncompress failed')
-    else:
-        fname = filename
-    try:
-        ftype = sndhdr.whathdr(fname)
-        if ftype:
-            ftype = ftype[0] # All we're interested in
-    except IOError as msg:
-        if type(msg) == type(()) and len(msg) == 2 and \
-                type(msg.args[0]) == type(0) and type(msg.args[1]) == type(''):
-            msg = msg.args[1]
-        if type(msg) != type(''):
-            msg = repr(msg)
-        raise error(filename + ': ' + msg)
-    if ftype == 'aiff':
-        return fname
-    if ftype is None or not ftype in table:
-        raise error('%s: unsupported audio file type %r' % (filename, ftype))
-    (fd, temp) = tempfile.mkstemp()
-    os.close(fd)
-    temps.append(temp)
-    sts = table[ftype].copy(fname, temp)
-    if sts:
-        raise error(filename + ': conversion to aiff failed')
-    return temp
diff --git a/Demo/scripts/unbirthday.py b/Demo/scripts/unbirthday.py
deleted file mode 100755
index af58f8f..0000000
--- a/Demo/scripts/unbirthday.py
+++ /dev/null
@@ -1,106 +0,0 @@
-#! /usr/bin/env python
-
-# Calculate your unbirthday count (see Alice in Wonderland).
-# This is defined as the number of days from your birth until today
-# that weren't your birthday.  (The day you were born is not counted).
-# Leap years make it interesting.
-
-import sys
-import time
-import calendar
-
-def main():
-    if sys.argv[1:]:
-        year = int(sys.argv[1])
-    else:
-        year = int(input('In which year were you born? '))
-    if 0 <= year < 100:
-        print("I'll assume that by", year, end=' ')
-        year = year + 1900
-        print('you mean', year, 'and not the early Christian era')
-    elif not (1850 <= year <= time.localtime()[0]):
-        print("It's hard to believe you were born in", year)
-        return
-
-    if sys.argv[2:]:
-        month = int(sys.argv[2])
-    else:
-        month = int(input('And in which month? (1-12) '))
-    if not (1 <= month <= 12):
-        print('There is no month numbered', month)
-        return
-
-    if sys.argv[3:]:
-        day = int(sys.argv[3])
-    else:
-        day = int(input('And on what day of that month? (1-31) '))
-    if month == 2 and calendar.isleap(year):
-        maxday = 29
-    else:
-        maxday = calendar.mdays[month]
-    if not (1 <= day <= maxday):
-        print('There are no', day, 'days in that month!')
-        return
-
-    bdaytuple = (year, month, day)
-    bdaydate = mkdate(bdaytuple)
-    print('You were born on', format(bdaytuple))
-
-    todaytuple = time.localtime()[:3]
-    todaydate = mkdate(todaytuple)
-    print('Today is', format(todaytuple))
-
-    if bdaytuple > todaytuple:
-        print('You are a time traveler.  Go back to the future!')
-        return
-
-    if bdaytuple == todaytuple:
-        print('You were born today.  Have a nice life!')
-        return
-
-    days = todaydate - bdaydate
-    print('You have lived', days, 'days')
-
-    age = 0
-    for y in range(year, todaytuple[0] + 1):
-        if bdaytuple < (y, month, day) <= todaytuple:
-            age = age + 1
-
-    print('You are', age, 'years old')
-
-    if todaytuple[1:] == bdaytuple[1:]:
-        print('Congratulations!  Today is your', nth(age), 'birthday')
-        print('Yesterday was your', end=' ')
-    else:
-        print('Today is your', end=' ')
-    print(nth(days - age), 'unbirthday')
-
-def format(date):
-    (year, month, day) = date
-    return '%d %s %d' % (day, calendar.month_name[month], year)
-
-def nth(n):
-    if n == 1: return '1st'
-    if n == 2: return '2nd'
-    if n == 3: return '3rd'
-    return '%dth' % n
-
-def mkdate(date):
-    # January 1st, in 0 A.D. is arbitrarily defined to be day 1,
-    # even though that day never actually existed and the calendar
-    # was different then...
-    (year, month, day) = date
-    days = year*365                  # years, roughly
-    days = days + (year+3)//4        # plus leap years, roughly
-    days = days - (year+99)//100     # minus non-leap years every century
-    days = days + (year+399)//400    # plus leap years every 4 centirues
-    for i in range(1, month):
-        if i == 2 and calendar.isleap(year):
-            days = days + 29
-        else:
-            days = days + calendar.mdays[i]
-    days = days + day
-    return days
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/update.py b/Demo/scripts/update.py
deleted file mode 100755
index d49e4b3..0000000
--- a/Demo/scripts/update.py
+++ /dev/null
@@ -1,92 +0,0 @@
-#! /usr/bin/env python
-
-# Update a bunch of files according to a script.
-# The input file contains lines of the form <filename>:<lineno>:<text>,
-# meaning that the given line of the given file is to be replaced
-# by the given text.  This is useful for performing global substitutions
-# on grep output:
-
-import os
-import sys
-import re
-
-pat = '^([^: \t\n]+):([1-9][0-9]*):'
-prog = re.compile(pat)
-
-class FileObj:
-    def __init__(self, filename):
-        self.filename = filename
-        self.changed = 0
-        try:
-            self.lines = open(filename, 'r').readlines()
-        except IOError as msg:
-            print('*** Can\'t open "%s":' % filename, msg)
-            self.lines = None
-            return
-        print('diffing', self.filename)
-
-    def finish(self):
-        if not self.changed:
-            print('no changes to', self.filename)
-            return
-        try:
-            os.rename(self.filename, self.filename + '~')
-            fp = open(self.filename, 'w')
-        except (os.error, IOError) as msg:
-            print('*** Can\'t rewrite "%s":' % self.filename, msg)
-            return
-        print('writing', self.filename)
-        for line in self.lines:
-            fp.write(line)
-        fp.close()
-        self.changed = 0
-
-    def process(self, lineno, rest):
-        if self.lines is None:
-            print('(not processed): %s:%s:%s' % (
-                      self.filename, lineno, rest), end=' ')
-            return
-        i = eval(lineno) - 1
-        if not 0 <= i < len(self.lines):
-            print('*** Line number out of range: %s:%s:%s' % (
-                      self.filename, lineno, rest), end=' ')
-            return
-        if self.lines[i] == rest:
-            print('(no change): %s:%s:%s' % (
-                      self.filename, lineno, rest), end=' ')
-            return
-        if not self.changed:
-            self.changed = 1
-        print('%sc%s' % (lineno, lineno))
-        print('<', self.lines[i], end=' ')
-        print('---')
-        self.lines[i] = rest
-        print('>', self.lines[i], end=' ')
-
-def main():
-    if sys.argv[1:]:
-        try:
-            fp = open(sys.argv[1], 'r')
-        except IOError as msg:
-            print('Can\'t open "%s":' % sys.argv[1], msg)
-            sys.exit(1)
-    else:
-        fp = sys.stdin
-    curfile = None
-    while 1:
-        line = fp.readline()
-        if not line:
-            if curfile: curfile.finish()
-            break
-        n = prog.match(line)
-        if n < 0:
-            print('Funny line:', line, end=' ')
-            continue
-        filename, lineno = prog.group(1, 2)
-        if not curfile or filename != curfile.filename:
-            if curfile: curfile.finish()
-            curfile = FileObj(filename)
-        curfile.process(lineno, line[n:])
-
-if __name__ == "__main__":
-    main()
diff --git a/Demo/scripts/wh.py b/Demo/scripts/wh.py
deleted file mode 100755
index b9b09ef..0000000
--- a/Demo/scripts/wh.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# This is here so I can use 'wh' instead of 'which' in '~/bin/generic_python'
-import which
diff --git a/Demo/sockets/README b/Demo/sockets/README
deleted file mode 100644
index eba7c23..0000000
--- a/Demo/sockets/README
+++ /dev/null
@@ -1,14 +0,0 @@
-This directory contains some demonstrations of the socket module:
-
-broadcast.py	 	Broadcast the time to radio.py.
-echosvr.py		About the simplest TCP server possible.
-finger.py		Client for the 'finger' protocol.
-ftp.py			A very simple ftp client.
-gopher.py		A simple gopher client.
-mcast.py		IPv4/v6 multicast example
-radio.py		Receive time broadcasts from broadcast.py.
-telnet.py		Client for the 'telnet' protocol.
-throughput.py		Client and server to measure TCP throughput.
-unixclient.py		Unix socket example, client side
-unixserver.py		Unix socket example, server side
-udpecho.py		Client and server for the UDP echo protocol.
diff --git a/Demo/sockets/broadcast.py b/Demo/sockets/broadcast.py
deleted file mode 100755
index 6d2b1e8..0000000
--- a/Demo/sockets/broadcast.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# Send UDP broadcast packets
-
-MYPORT = 50000
-
-import sys, time
-from socket import *
-
-s = socket(AF_INET, SOCK_DGRAM)
-s.bind(('', 0))
-s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
-
-while 1:
-    data = repr(time.time()) + '\n'
-    s.sendto(data, ('<broadcast>', MYPORT))
-    time.sleep(2)
diff --git a/Demo/sockets/echosvr.py b/Demo/sockets/echosvr.py
deleted file mode 100755
index 7de6391..0000000
--- a/Demo/sockets/echosvr.py
+++ /dev/null
@@ -1,31 +0,0 @@
-#! /usr/bin/env python
-
-# Python implementation of an 'echo' tcp server: echo all data it receives.
-#
-# This is the simplest possible server, servicing a single request only.
-
-import sys
-from socket import *
-
-# The standard echo port isn't very useful, it requires root permissions!
-# ECHO_PORT = 7
-ECHO_PORT = 50000 + 7
-BUFSIZE = 1024
-
-def main():
-    if len(sys.argv) > 1:
-        port = int(eval(sys.argv[1]))
-    else:
-        port = ECHO_PORT
-    s = socket(AF_INET, SOCK_STREAM)
-    s.bind(('', port))
-    s.listen(1)
-    conn, (remotehost, remoteport) = s.accept()
-    print('connected by', remotehost, remoteport)
-    while 1:
-        data = conn.recv(BUFSIZE)
-        if not data:
-            break
-        conn.send(data)
-
-main()
diff --git a/Demo/sockets/finger.py b/Demo/sockets/finger.py
deleted file mode 100755
index e8b9ed2..0000000
--- a/Demo/sockets/finger.py
+++ /dev/null
@@ -1,58 +0,0 @@
-#! /usr/bin/env python
-
-# Python interface to the Internet finger daemon.
-#
-# Usage: finger [options] [user][@host] ...
-#
-# If no host is given, the finger daemon on the local host is contacted.
-# Options are passed uninterpreted to the finger daemon!
-
-
-import sys, string
-from socket import *
-
-
-# Hardcode the number of the finger port here.
-# It's not likely to change soon...
-#
-FINGER_PORT = 79
-
-
-# Function to do one remote finger invocation.
-# Output goes directly to stdout (although this can be changed).
-#
-def finger(host, args):
-    s = socket(AF_INET, SOCK_STREAM)
-    s.connect((host, FINGER_PORT))
-    s.send(args + '\n')
-    while 1:
-        buf = s.recv(1024)
-        if not buf: break
-        sys.stdout.write(buf)
-    sys.stdout.flush()
-
-
-# Main function: argument parsing.
-#
-def main():
-    options = ''
-    i = 1
-    while i < len(sys.argv) and sys.argv[i][:1] == '-':
-        options = options + sys.argv[i] + ' '
-        i = i+1
-    args = sys.argv[i:]
-    if not args:
-        args = ['']
-    for arg in args:
-        if '@' in arg:
-            at = string.index(arg, '@')
-            host = arg[at+1:]
-            arg = arg[:at]
-        else:
-            host = ''
-        finger(host, options + arg)
-
-
-# Call the main function.
-#
-main()
diff --git a/Demo/sockets/ftp.py b/Demo/sockets/ftp.py
deleted file mode 100755
index 5ea99c7..0000000
--- a/Demo/sockets/ftp.py
+++ /dev/null
@@ -1,152 +0,0 @@
-# A simple FTP client.
-#
-# The information to write this program was gathered from RFC 959,
-# but this is not a complete implementation!  Yet it shows how a simple
-# FTP client can be built, and you are welcome to extend it to suit
-# it to your needs...
-#
-# How it works (assuming you've read the RFC):
-#
-# User commands are passed uninterpreted to the server.  However, the
-# user never needs to send a PORT command.  Rather, the client opens a
-# port right away and sends the appropriate PORT command to the server.
-# When a response code 150 is received, this port is used to receive
-# the data (which is written to stdout in this version), and when the
-# data is exhausted, a new port is opened and a corresponding PORT
-# command sent.  In order to avoid errors when reusing ports quickly
-# (and because there is no s.getsockname() method in Python yet) we
-# cycle through a number of ports in the 50000 range.
-
-
-import sys, posix, string
-from socket import *
-
-
-BUFSIZE = 1024
-
-# Default port numbers used by the FTP protocol.
-#
-FTP_PORT = 21
-FTP_DATA_PORT = FTP_PORT - 1
-
-# Change the data port to something not needing root permissions.
-#
-FTP_DATA_PORT = FTP_DATA_PORT + 50000
-
-
-# Main program (called at the end of this file).
-#
-def main():
-    hostname = sys.argv[1]
-    control(hostname)
-
-
-# Control process (user interface and user protocol interpreter).
-#
-def control(hostname):
-    #
-    # Create control connection
-    #
-    s = socket(AF_INET, SOCK_STREAM)
-    s.connect((hostname, FTP_PORT))
-    f = s.makefile('r') # Reading the replies is easier from a file...
-    #
-    # Control loop
-    #
-    r = None
-    while 1:
-        code = getreply(f)
-        if code in ('221', 'EOF'): break
-        if code == '150':
-            getdata(r)
-            code = getreply(f)
-            r = None
-        if not r:
-            r = newdataport(s, f)
-        cmd = getcommand()
-        if not cmd: break
-        s.send(cmd + '\r\n')
-
-
-# Create a new data port and send a PORT command to the server for it.
-# (Cycle through a number of ports to avoid problems with reusing
-# a port within a short time.)
-#
-nextport = 0
-#
-def newdataport(s, f):
-    global nextport
-    port = nextport + FTP_DATA_PORT
-    nextport = (nextport+1) % 16
-    r = socket(AF_INET, SOCK_STREAM)
-    r.bind((gethostbyname(gethostname()), port))
-    r.listen(1)
-    sendportcmd(s, f, port)
-    return r
-
-
-# Send an appropriate port command.
-#
-def sendportcmd(s, f, port):
-    hostname = gethostname()
-    hostaddr = gethostbyname(hostname)
-    hbytes = string.splitfields(hostaddr, '.')
-    pbytes = [repr(port//256), repr(port%256)]
-    bytes = hbytes + pbytes
-    cmd = 'PORT ' + string.joinfields(bytes, ',')
-    s.send(cmd + '\r\n')
-    code = getreply(f)
-
-
-# Process an ftp reply and return the 3-digit reply code (as a string).
-# The reply should be a line of text starting with a 3-digit number.
-# If the 4th char is '-', it is a multi-line reply and is
-# terminate by a line starting with the same 3-digit number.
-# Any text while receiving the reply is echoed to the file.
-#
-def getreply(f):
-    line = f.readline()
-    if not line: return 'EOF'
-    print(line, end=' ')
-    code = line[:3]
-    if line[3:4] == '-':
-        while 1:
-            line = f.readline()
-            if not line: break # Really an error
-            print(line, end=' ')
-            if line[:3] == code and line[3:4] != '-': break
-    return code
-
-
-# Get the data from the data connection.
-#
-def getdata(r):
-    print('(accepting data connection)')
-    conn, host = r.accept()
-    print('(data connection accepted)')
-    while 1:
-        data = conn.recv(BUFSIZE)
-        if not data: break
-        sys.stdout.write(data)
-    print('(end of data connection)')
-
-def raw_input(prompt):
-    sys.stdout.write(prompt)
-    sys.stdout.flush()
-    return sys.stdin.readline()
-
-# Get a command from the user.
-#
-def getcommand():
-    try:
-        while 1:
-            line = input('ftp.py> ')
-            if line: return line
-    except EOFError:
-        return ''
-
-
-# Call the main program.
-#
-if __name__ == '__main__':
-    main()
diff --git a/Demo/sockets/gopher.py b/Demo/sockets/gopher.py
deleted file mode 100755
index c287319..0000000
--- a/Demo/sockets/gopher.py
+++ /dev/null
@@ -1,352 +0,0 @@
-#! /usr/bin/env python
-
-# A simple gopher client.
-#
-# Usage: gopher [ [selector] host [port] ]
-
-import sys
-import os
-import socket
-
-# Default selector, host and port
-DEF_SELECTOR = ''
-DEF_HOST     = 'gopher.micro.umn.edu'
-DEF_PORT     = 70
-
-# Recognized file types
-T_TEXTFILE  = '0'
-T_MENU      = '1'
-T_CSO       = '2'
-T_ERROR     = '3'
-T_BINHEX    = '4'
-T_DOS       = '5'
-T_UUENCODE  = '6'
-T_SEARCH    = '7'
-T_TELNET    = '8'
-T_BINARY    = '9'
-T_REDUNDANT = '+'
-T_SOUND     = 's'
-
-# Dictionary mapping types to strings
-typename = {'0': '<TEXT>', '1': '<DIR>', '2': '<CSO>', '3': '<ERROR>', \
-        '4': '<BINHEX>', '5': '<DOS>', '6': '<UUENCODE>', '7': '<SEARCH>', \
-        '8': '<TELNET>', '9': '<BINARY>', '+': '<REDUNDANT>', 's': '<SOUND>'}
-
-# Oft-used characters and strings
-CRLF = '\r\n'
-TAB = '\t'
-
-# Open a TCP connection to a given host and port
-def open_socket(host, port):
-    if not port:
-        port = DEF_PORT
-    elif type(port) == type(''):
-        port = int(port)
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.connect((host, port))
-    return s
-
-# Send a selector to a given host and port, return a file with the reply
-def send_request(selector, host, port):
-    s = open_socket(host, port)
-    s.send(selector + CRLF)
-    s.shutdown(1)
-    return s.makefile('r')
-
-# Get a menu in the form of a list of entries
-def get_menu(selector, host, port):
-    f = send_request(selector, host, port)
-    list = []
-    while 1:
-        line = f.readline()
-        if not line:
-            print('(Unexpected EOF from server)')
-            break
-        if line[-2:] == CRLF:
-            line = line[:-2]
-        elif line[-1:] in CRLF:
-            line = line[:-1]
-        if line == '.':
-            break
-        if not line:
-            print('(Empty line from server)')
-            continue
-        typechar = line[0]
-        parts = line[1:].split(TAB)
-        if len(parts) < 4:
-            print('(Bad line from server: %r)' % (line,))
-            continue
-        if len(parts) > 4:
-            print('(Extra info from server: %r)' % (parts[4:],))
-        parts.insert(0, typechar)
-        list.append(parts)
-    f.close()
-    return list
-
-# Get a text file as a list of lines, with trailing CRLF stripped
-def get_textfile(selector, host, port):
-    list = []
-    get_alt_textfile(selector, host, port, list.append)
-    return list
-
-# Get a text file and pass each line to a function, with trailing CRLF stripped
-def get_alt_textfile(selector, host, port, func):
-    f = send_request(selector, host, port)
-    while 1:
-        line = f.readline()
-        if not line:
-            print('(Unexpected EOF from server)')
-            break
-        if line[-2:] == CRLF:
-            line = line[:-2]
-        elif line[-1:] in CRLF:
-            line = line[:-1]
-        if line == '.':
-            break
-        if line[:2] == '..':
-            line = line[1:]
-        func(line)
-    f.close()
-
-# Get a binary file as one solid data block
-def get_binary(selector, host, port):
-    f = send_request(selector, host, port)
-    data = f.read()
-    f.close()
-    return data
-
-# Get a binary file and pass each block to a function
-def get_alt_binary(selector, host, port, func, blocksize):
-    f = send_request(selector, host, port)
-    while 1:
-        data = f.read(blocksize)
-        if not data:
-            break
-        func(data)
-
-# A *very* simple interactive browser
-
-# Browser main command, has default arguments
-def browser(*args):
-    selector = DEF_SELECTOR
-    host = DEF_HOST
-    port = DEF_PORT
-    n = len(args)
-    if n > 0 and args[0]:
-        selector = args[0]
-    if n > 1 and args[1]:
-        host = args[1]
-    if n > 2 and args[2]:
-        port = args[2]
-    if n > 3:
-        raise RuntimeError('too many args')
-    try:
-        browse_menu(selector, host, port)
-    except socket.error as msg:
-        print('Socket error:', msg)
-        sys.exit(1)
-    except KeyboardInterrupt:
-        print('\n[Goodbye]')
-
-# Browse a menu
-def browse_menu(selector, host, port):
-    list = get_menu(selector, host, port)
-    while 1:
-        print('----- MENU -----')
-        print('Selector:', repr(selector))
-        print('Host:', host, ' Port:', port)
-        print()
-        for i in range(len(list)):
-            item = list[i]
-            typechar, description = item[0], item[1]
-            print(repr(i+1).rjust(3) + ':', description, end=' ')
-            if typechar in typename:
-                print(typename[typechar])
-            else:
-                print('<TYPE=' + repr(typechar) + '>')
-        print()
-        while 1:
-            try:
-                str = input('Choice [CR == up a level]: ')
-            except EOFError:
-                print()
-                return
-            if not str:
-                return
-            try:
-                choice = int(str)
-            except ValueError:
-                print('Choice must be a number; try again:')
-                continue
-            if not 0 < choice <= len(list):
-                print('Choice out of range; try again:')
-                continue
-            break
-        item = list[choice-1]
-        typechar = item[0]
-        [i_selector, i_host, i_port] = item[2:5]
-        if typechar in typebrowser:
-            browserfunc = typebrowser[typechar]
-            try:
-                browserfunc(i_selector, i_host, i_port)
-            except (IOError, socket.error):
-                t, v, tb = sys.exc_info()
-                print('***', t, ':', v)
-        else:
-            print('Unsupported object type')
-
-# Browse a text file
-def browse_textfile(selector, host, port):
-    x = None
-    try:
-        p = os.popen('${PAGER-more}', 'w')
-        x = SaveLines(p)
-        get_alt_textfile(selector, host, port, x.writeln)
-    except IOError as msg:
-        print('IOError:', msg)
-    if x:
-        x.close()
-    f = open_savefile()
-    if not f:
-        return
-    x = SaveLines(f)
-    try:
-        get_alt_textfile(selector, host, port, x.writeln)
-        print('Done.')
-    except IOError as msg:
-        print('IOError:', msg)
-    x.close()
-
-def raw_input(prompt):
-    sys.stdout.write(prompt)
-    sys.stdout.flush()
-    return sys.stdin.readline()
-
-# Browse a search index
-def browse_search(selector, host, port):
-    while 1:
-        print('----- SEARCH -----')
-        print('Selector:', repr(selector))
-        print('Host:', host, ' Port:', port)
-        print()
-        try:
-            query = input('Query [CR == up a level]: ')
-        except EOFError:
-            print()
-            break
-        query = query.strip()
-        if not query:
-            break
-        if '\t' in query:
-            print('Sorry, queries cannot contain tabs')
-            continue
-        browse_menu(selector + TAB + query, host, port)
-
-# "Browse" telnet-based information, i.e. open a telnet session
-def browse_telnet(selector, host, port):
-    if selector:
-        print('Log in as', repr(selector))
-    if type(port) != type(''):
-        port = repr(port)
-    sts = os.system('set -x; exec telnet ' + host + ' ' + port)
-    if sts:
-        print('Exit status:', sts)
-
-# "Browse" a binary file, i.e. save it to a file
-def browse_binary(selector, host, port):
-    f = open_savefile()
-    if not f:
-        return
-    x = SaveWithProgress(f)
-    get_alt_binary(selector, host, port, x.write, 8*1024)
-    x.close()
-
-# "Browse" a sound file, i.e. play it or save it
-def browse_sound(selector, host, port):
-    browse_binary(selector, host, port)
-
-# Dictionary mapping types to browser functions
-typebrowser = {'0': browse_textfile, '1': browse_menu, \
-        '4': browse_binary, '5': browse_binary, '6': browse_textfile, \
-        '7': browse_search, \
-        '8': browse_telnet, '9': browse_binary, 's': browse_sound}
-
-# Class used to save lines, appending a newline to each line
-class SaveLines:
-    def __init__(self, f):
-        self.f = f
-    def writeln(self, line):
-        self.f.write(line + '\n')
-    def close(self):
-        sts = self.f.close()
-        if sts:
-            print('Exit status:', sts)
-
-# Class used to save data while showing progress
-class SaveWithProgress:
-    def __init__(self, f):
-        self.f = f
-    def write(self, data):
-        sys.stdout.write('#')
-        sys.stdout.flush()
-        self.f.write(data)
-    def close(self):
-        print()
-        sts = self.f.close()
-        if sts:
-            print('Exit status:', sts)
-
-# Ask for and open a save file, or return None if not to save
-def open_savefile():
-    try:
-        savefile = input( \
-    'Save as file [CR == don\'t save; |pipeline or ~user/... OK]: ')
-    except EOFError:
-        print()
-        return None
-    savefile = savefile.strip()
-    if not savefile:
-        return None
-    if savefile[0] == '|':
-        cmd = savefile[1:].strip()
-        try:
-            p = os.popen(cmd, 'w')
-        except IOError as msg:
-            print(repr(cmd), ':', msg)
-            return None
-        print('Piping through', repr(cmd), '...')
-        return p
-    if savefile[0] == '~':
-        savefile = os.path.expanduser(savefile)
-    try:
-        f = open(savefile, 'w')
-    except IOError as msg:
-        print(repr(savefile), ':', msg)
-        return None
-    print('Saving to', repr(savefile), '...')
-    return f
-
-# Test program
-def test():
-    if sys.argv[4:]:
-        print('usage: gopher [ [selector] host [port] ]')
-        sys.exit(2)
-    elif sys.argv[3:]:
-        browser(sys.argv[1], sys.argv[2], sys.argv[3])
-    elif sys.argv[2:]:
-        try:
-            port = int(sys.argv[2])
-            selector = ''
-            host = sys.argv[1]
-        except ValueError:
-            selector = sys.argv[1]
-            host = sys.argv[2]
-            port = ''
-        browser(selector, host, port)
-    elif sys.argv[1:]:
-        browser('', sys.argv[1])
-    else:
-        browser()
-
-# Call the test program as a main program
-test()
diff --git a/Demo/sockets/mcast.py b/Demo/sockets/mcast.py
deleted file mode 100755
index b7f8556..0000000
--- a/Demo/sockets/mcast.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python
-#
-# Send/receive UDP multicast packets.
-# Requires that your OS kernel supports IP multicast.
-#
-# Usage:
-#   mcast -s (sender, IPv4)
-#   mcast -s -6 (sender, IPv6)
-#   mcast    (receivers, IPv4)
-#   mcast  -6  (receivers, IPv6)
-
-MYPORT = 8123
-MYGROUP_4 = '225.0.0.250'
-MYGROUP_6 = 'ff15:7079:7468:6f6e:6465:6d6f:6d63:6173'
-MYTTL = 1 # Increase to reach other networks
-
-import time
-import struct
-import socket
-import sys
-
-def main():
-    group = MYGROUP_6 if "-6" in sys.argv[1:] else MYGROUP_4
-
-    if "-s" in sys.argv[1:]:
-        sender(group)
-    else:
-        receiver(group)
-
-
-def sender(group):
-    addrinfo = socket.getaddrinfo(group, None)[0]
-
-    s = socket.socket(addrinfo[0], socket.SOCK_DGRAM)
-
-    # Set Time-to-live (optional)
-    ttl_bin = struct.pack('@i', MYTTL)
-    if addrinfo[0] == socket.AF_INET: # IPv4
-        s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl_bin)
-    else:
-        s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS, ttl_bin)
-
-    while True:
-        data = repr(time.time()).encode('utf-8') + b'\0'
-        s.sendto(data, (addrinfo[4][0], MYPORT))
-        time.sleep(1)
-
-
-def receiver(group):
-    # Look up multicast group address in name server and find out IP version
-    addrinfo = socket.getaddrinfo(group, None)[0]
-
-    # Create a socket
-    s = socket.socket(addrinfo[0], socket.SOCK_DGRAM)
-
-    # Allow multiple copies of this program on one machine
-    # (not strictly needed)
-    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-
-    # Bind it to the port
-    s.bind(('', MYPORT))
-
-    group_bin = socket.inet_pton(addrinfo[0], addrinfo[4][0])
-    # Join group
-    if addrinfo[0] == socket.AF_INET: # IPv4
-        mreq = group_bin + struct.pack('=I', socket.INADDR_ANY)
-        s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
-    else:
-        mreq = group_bin + struct.pack('@I', 0)
-        s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mreq)
-
-    # Loop, printing any data we receive
-    while True:
-        data, sender = s.recvfrom(1500)
-        while data[-1:] == '\0': data = data[:-1] # Strip trailing \0's
-        print(str(sender) + '  ' + repr(data))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/Demo/sockets/radio.py b/Demo/sockets/radio.py
deleted file mode 100755
index fa4ce75..0000000
--- a/Demo/sockets/radio.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Receive UDP packets transmitted by a broadcasting service
-
-MYPORT = 50000
-
-import sys
-from socket import *
-
-s = socket(AF_INET, SOCK_DGRAM)
-s.bind(('', MYPORT))
-
-while 1:
-    data, wherefrom = s.recvfrom(1500, 0)
-    sys.stderr.write(repr(wherefrom) + '\n')
-    sys.stdout.write(data)
diff --git a/Demo/sockets/rpython.py b/Demo/sockets/rpython.py
deleted file mode 100755
index b654dc2..0000000
--- a/Demo/sockets/rpython.py
+++ /dev/null
@@ -1,35 +0,0 @@
-#! /usr/bin/env python
-
-# Remote python client.
-# Execute Python commands remotely and send output back.
-
-import sys
-import string
-from socket import *
-
-PORT = 4127
-BUFSIZE = 1024
-
-def main():
-    if len(sys.argv) < 3:
-        print("usage: rpython host command")
-        sys.exit(2)
-    host = sys.argv[1]
-    port = PORT
-    i = string.find(host, ':')
-    if i >= 0:
-        port = string.atoi(port[i+1:])
-        host = host[:i]
-    command = string.join(sys.argv[2:])
-    s = socket(AF_INET, SOCK_STREAM)
-    s.connect((host, port))
-    s.send(command)
-    s.shutdown(1)
-    reply = ''
-    while 1:
-        data = s.recv(BUFSIZE)
-        if not data: break
-        reply = reply + data
-    print(reply, end=' ')
-
-main()
diff --git a/Demo/sockets/rpythond.py b/Demo/sockets/rpythond.py
deleted file mode 100755
index d745cc7..0000000
--- a/Demo/sockets/rpythond.py
+++ /dev/null
@@ -1,52 +0,0 @@
-#! /usr/bin/env python
-
-# Remote python server.
-# Execute Python commands remotely and send output back.
-# WARNING: This version has a gaping security hole -- it accepts requests
-# from any host on the Internet!
-
-import sys
-from socket import *
-import io
-import traceback
-
-PORT = 4127
-BUFSIZE = 1024
-
-def main():
-    if len(sys.argv) > 1:
-        port = int(eval(sys.argv[1]))
-    else:
-        port = PORT
-    s = socket(AF_INET, SOCK_STREAM)
-    s.bind(('', port))
-    s.listen(1)
-    while 1:
-        conn, (remotehost, remoteport) = s.accept()
-        print('connected by', remotehost, remoteport)
-        request = ''
-        while 1:
-            data = conn.recv(BUFSIZE)
-            if not data:
-                break
-            request = request + data
-        reply = execute(request)
-        conn.send(reply)
-        conn.close()
-
-def execute(request):
-    stdout = sys.stdout
-    stderr = sys.stderr
-    sys.stdout = sys.stderr = fakefile = io.StringIO()
-    try:
-        try:
-            exec(request, {}, {})
-        except:
-            print()
-            traceback.print_exc(100)
-    finally:
-        sys.stderr = stderr
-        sys.stdout = stdout
-    return fakefile.getvalue()
-
-main()
diff --git a/Demo/sockets/telnet.py b/Demo/sockets/telnet.py
deleted file mode 100755
index 038036ff..0000000
--- a/Demo/sockets/telnet.py
+++ /dev/null
@@ -1,109 +0,0 @@
-#! /usr/bin/env python
-
-# Minimal interface to the Internet telnet protocol.
-#
-# It refuses all telnet options and does not recognize any of the other
-# telnet commands, but can still be used to connect in line-by-line mode.
-# It's also useful to play with a number of other services,
-# like time, finger, smtp and even ftp.
-#
-# Usage: telnet host [port]
-#
-# The port may be a service name or a decimal port number;
-# it defaults to 'telnet'.
-
-
-import sys, posix, time
-from socket import *
-
-BUFSIZE = 1024
-
-# Telnet protocol characters
-
-IAC  = chr(255) # Interpret as command
-DONT = chr(254)
-DO   = chr(253)
-WONT = chr(252)
-WILL = chr(251)
-
-def main():
-    host = sys.argv[1]
-    try:
-        hostaddr = gethostbyname(host)
-    except error:
-        sys.stderr.write(sys.argv[1] + ': bad host name\n')
-        sys.exit(2)
-    #
-    if len(sys.argv) > 2:
-        servname = sys.argv[2]
-    else:
-        servname = 'telnet'
-    #
-    if '0' <= servname[:1] <= '9':
-        port = eval(servname)
-    else:
-        try:
-            port = getservbyname(servname, 'tcp')
-        except error:
-            sys.stderr.write(servname + ': bad tcp service name\n')
-            sys.exit(2)
-    #
-    s = socket(AF_INET, SOCK_STREAM)
-    #
-    try:
-        s.connect((host, port))
-    except error as msg:
-        sys.stderr.write('connect failed: ' + repr(msg) + '\n')
-        sys.exit(1)
-    #
-    pid = posix.fork()
-    #
-    if pid == 0:
-        # child -- read stdin, write socket
-        while 1:
-            line = sys.stdin.readline()
-            s.send(line)
-    else:
-        # parent -- read socket, write stdout
-        iac = 0         # Interpret next char as command
-        opt = ''        # Interpret next char as option
-        while 1:
-            data = s.recv(BUFSIZE)
-            if not data:
-                # EOF; kill child and exit
-                sys.stderr.write( '(Closed by remote host)\n')
-                posix.kill(pid, 9)
-                sys.exit(1)
-            cleandata = ''
-            for c in data:
-                if opt:
-                    print(ord(c))
-                    s.send(opt + c)
-                    opt = ''
-                elif iac:
-                    iac = 0
-                    if c == IAC:
-                        cleandata = cleandata + c
-                    elif c in (DO, DONT):
-                        if c == DO: print('(DO)', end=' ')
-                        else: print('(DONT)', end=' ')
-                        opt = IAC + WONT
-                    elif c in (WILL, WONT):
-                        if c == WILL: print('(WILL)', end=' ')
-                        else: print('(WONT)', end=' ')
-                        opt = IAC + DONT
-                    else:
-                        print('(command)', ord(c))
-                elif c == IAC:
-                    iac = 1
-                    print('(IAC)', end=' ')
-                else:
-                    cleandata = cleandata + c
-            sys.stdout.write(cleandata)
-            sys.stdout.flush()
-
-
-try:
-    main()
-except KeyboardInterrupt:
-    pass
diff --git a/Demo/sockets/throughput.py b/Demo/sockets/throughput.py
deleted file mode 100755
index 64244aa..0000000
--- a/Demo/sockets/throughput.py
+++ /dev/null
@@ -1,93 +0,0 @@
-#! /usr/bin/env python
-
-# Test network throughput.
-#
-# Usage:
-# 1) on host_A: throughput -s [port]                    # start a server
-# 2) on host_B: throughput -c  count host_A [port]      # start a client
-#
-# The server will service multiple clients until it is killed.
-#
-# The client performs one transfer of count*BUFSIZE bytes and
-# measures the time it takes (roundtrip!).
-
-
-import sys, time
-from socket import *
-
-MY_PORT = 50000 + 42
-
-BUFSIZE = 1024
-
-
-def main():
-    if len(sys.argv) < 2:
-        usage()
-    if sys.argv[1] == '-s':
-        server()
-    elif sys.argv[1] == '-c':
-        client()
-    else:
-        usage()
-
-
-def usage():
-    sys.stdout = sys.stderr
-    print('Usage:    (on host_A) throughput -s [port]')
-    print('and then: (on host_B) throughput -c count host_A [port]')
-    sys.exit(2)
-
-
-def server():
-    if len(sys.argv) > 2:
-        port = eval(sys.argv[2])
-    else:
-        port = MY_PORT
-    s = socket(AF_INET, SOCK_STREAM)
-    s.bind(('', port))
-    s.listen(1)
-    print('Server ready...')
-    while 1:
-        conn, (host, remoteport) = s.accept()
-        while 1:
-            data = conn.recv(BUFSIZE)
-            if not data:
-                break
-            del data
-        conn.send('OK\n')
-        conn.close()
-        print('Done with', host, 'port', remoteport)
-
-
-def client():
-    if len(sys.argv) < 4:
-        usage()
-    count = int(eval(sys.argv[2]))
-    host = sys.argv[3]
-    if len(sys.argv) > 4:
-        port = eval(sys.argv[4])
-    else:
-        port = MY_PORT
-    testdata = 'x' * (BUFSIZE-1) + '\n'
-    t1 = time.time()
-    s = socket(AF_INET, SOCK_STREAM)
-    t2 = time.time()
-    s.connect((host, port))
-    t3 = time.time()
-    i = 0
-    while i < count:
-        i = i+1
-        s.send(testdata)
-    s.shutdown(1) # Send EOF
-    t4 = time.time()
-    data = s.recv(BUFSIZE)
-    t5 = time.time()
-    print(data)
-    print('Raw timers:', t1, t2, t3, t4, t5)
-    print('Intervals:', t2-t1, t3-t2, t4-t3, t5-t4)
-    print('Total:', t5-t1)
-    print('Throughput:', round((BUFSIZE*count*0.001) / (t5-t1), 3), end=' ')
-    print('K/sec.')
-
-
-main()
diff --git a/Demo/sockets/udpecho.py b/Demo/sockets/udpecho.py
deleted file mode 100755
index 9966fd8..0000000
--- a/Demo/sockets/udpecho.py
+++ /dev/null
@@ -1,64 +0,0 @@
-#! /usr/bin/env python
-
-# Client and server for udp (datagram) echo.
-#
-# Usage: udpecho -s [port]            (to start a server)
-# or:    udpecho -c host [port] <file (client)
-
-import sys
-from socket import *
-
-ECHO_PORT = 50000 + 7
-BUFSIZE = 1024
-
-def main():
-    if len(sys.argv) < 2:
-        usage()
-    if sys.argv[1] == '-s':
-        server()
-    elif sys.argv[1] == '-c':
-        client()
-    else:
-        usage()
-
-def usage():
-    sys.stdout = sys.stderr
-    print('Usage: udpecho -s [port]            (server)')
-    print('or:    udpecho -c host [port] <file (client)')
-    sys.exit(2)
-
-def server():
-    if len(sys.argv) > 2:
-        port = eval(sys.argv[2])
-    else:
-        port = ECHO_PORT
-    s = socket(AF_INET, SOCK_DGRAM)
-    s.bind(('', port))
-    print('udp echo server ready')
-    while 1:
-        data, addr = s.recvfrom(BUFSIZE)
-        print('server received %r from %r' % (data, addr))
-        s.sendto(data, addr)
-
-def client():
-    if len(sys.argv) < 3:
-        usage()
-    host = sys.argv[2]
-    if len(sys.argv) > 3:
-        port = eval(sys.argv[3])
-    else:
-        port = ECHO_PORT
-    addr = host, port
-    s = socket(AF_INET, SOCK_DGRAM)
-    s.bind(('', 0))
-    print('udp echo client ready, reading stdin')
-    while 1:
-        line = sys.stdin.readline()
-        if not line:
-            break
-        print('addr = ', addr)
-        s.sendto(bytes(line, 'ascii'), addr)
-        data, fromaddr = s.recvfrom(BUFSIZE)
-        print('client received %r from %r' % (data, fromaddr))
-
-main()
diff --git a/Demo/sockets/unicast.py b/Demo/sockets/unicast.py
deleted file mode 100644
index dd15e3c..0000000
--- a/Demo/sockets/unicast.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Send UDP broadcast packets
-
-MYPORT = 50000
-
-import sys, time
-from socket import *
-
-s = socket(AF_INET, SOCK_DGRAM)
-s.bind(('', 0))
-
-while 1:
-    data = repr(time.time()) + '\n'
-    s.sendto(data, ('', MYPORT))
-    time.sleep(2)
diff --git a/Demo/sockets/unixclient.py b/Demo/sockets/unixclient.py
deleted file mode 100644
index 5e87eed..0000000
--- a/Demo/sockets/unixclient.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# Echo client demo using Unix sockets
-# Piet van Oostrum
-
-from socket import *
-
-FILE = 'unix-socket'
-s = socket(AF_UNIX, SOCK_STREAM)
-s.connect(FILE)
-s.send(b'Hello, world')
-data = s.recv(1024)
-s.close()
-print('Received', repr(data))
diff --git a/Demo/sockets/unixserver.py b/Demo/sockets/unixserver.py
deleted file mode 100644
index c3c9c4f..0000000
--- a/Demo/sockets/unixserver.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Echo server demo using Unix sockets (handles one connection only)
-# Piet van Oostrum
-
-import os
-from socket import *
-
-FILE = 'unix-socket'
-s = socket(AF_UNIX, SOCK_STREAM)
-s.bind(FILE)
-
-print('Sock name is: ['+s.getsockname()+']')
-
-# Wait for a connection
-s.listen(1)
-conn, addr = s.accept()
-
-while True:
-    data = conn.recv(1024)
-    if not data:
-        break
-    conn.send(data)
-
-conn.close()
-os.unlink(FILE)
diff --git a/Demo/threads/Coroutine.py b/Demo/threads/Coroutine.py
deleted file mode 100644
index 690fadc..0000000
--- a/Demo/threads/Coroutine.py
+++ /dev/null
@@ -1,159 +0,0 @@
-# Coroutine implementation using Python threads.
-#
-# Combines ideas from Guido's Generator module, and from the coroutine
-# features of Icon and Simula 67.
-#
-# To run a collection of functions as coroutines, you need to create
-# a Coroutine object to control them:
-#    co = Coroutine()
-# and then 'create' a subsidiary object for each function in the
-# collection:
-#    cof1 = co.create(f1 [, arg1, arg2, ...]) # [] means optional,
-#    cof2 = co.create(f2 [, arg1, arg2, ...]) #... not list
-#    cof3 = co.create(f3 [, arg1, arg2, ...])
-# etc.  The functions need not be distinct; 'create'ing the same
-# function multiple times gives you independent instances of the
-# function.
-#
-# To start the coroutines running, use co.tran on one of the create'd
-# functions; e.g., co.tran(cof2).  The routine that first executes
-# co.tran is called the "main coroutine".  It's special in several
-# respects:  it existed before you created the Coroutine object; if any of
-# the create'd coroutines exits (does a return, or suffers an unhandled
-# exception), EarlyExit error is raised in the main coroutine; and the
-# co.detach() method transfers control directly to the main coroutine
-# (you can't use co.tran() for this because the main coroutine doesn't
-# have a name ...).
-#
-# Coroutine objects support these methods:
-#
-# handle = .create(func [, arg1, arg2, ...])
-#    Creates a coroutine for an invocation of func(arg1, arg2, ...),
-#    and returns a handle ("name") for the coroutine so created.  The
-#    handle can be used as the target in a subsequent .tran().
-#
-# .tran(target, data=None)
-#    Transfer control to the create'd coroutine "target", optionally
-#    passing it an arbitrary piece of data. To the coroutine A that does
-#    the .tran, .tran acts like an ordinary function call:  another
-#    coroutine B can .tran back to it later, and if it does A's .tran
-#    returns the 'data' argument passed to B's tran.  E.g.,
-#
-#    in coroutine coA   in coroutine coC    in coroutine coB
-#      x = co.tran(coC)   co.tran(coB)        co.tran(coA,12)
-#      print x # 12
-#
-#    The data-passing feature is taken from Icon, and greatly cuts
-#    the need to use global variables for inter-coroutine communication.
-#
-# .back( data=None )
-#    The same as .tran(invoker, data=None), where 'invoker' is the
-#    coroutine that most recently .tran'ed control to the coroutine
-#    doing the .back.  This is akin to Icon's "&source".
-#
-# .detach( data=None )
-#    The same as .tran(main, data=None), where 'main' is the
-#    (unnameable!) coroutine that started it all.  'main' has all the
-#    rights of any other coroutine:  upon receiving control, it can
-#    .tran to an arbitrary coroutine of its choosing, go .back to
-#    the .detach'er, or .kill the whole thing.
-#
-# .kill()
-#    Destroy all the coroutines, and return control to the main
-#    coroutine.  None of the create'ed coroutines can be resumed after a
-#    .kill().  An EarlyExit exception does a .kill() automatically.  It's
-#    a good idea to .kill() coroutines you're done with, since the
-#    current implementation consumes a thread for each coroutine that
-#    may be resumed.
-
-import _thread as thread
-import sync
-
-class _CoEvent:
-    def __init__(self, func):
-        self.f = func
-        self.e = sync.event()
-
-    def __repr__(self):
-        if self.f is None:
-            return 'main coroutine'
-        else:
-            return 'coroutine for func ' + self.f.__name__
-
-    def __hash__(self):
-        return id(self)
-
-    def __cmp__(x,y):
-        return cmp(id(x), id(y))
-
-    def resume(self):
-        self.e.post()
-
-    def wait(self):
-        self.e.wait()
-        self.e.clear()
-
-class Killed(Exception): pass
-class EarlyExit(Exception): pass
-
-class Coroutine:
-    def __init__(self):
-        self.active = self.main = _CoEvent(None)
-        self.invokedby = {self.main: None}
-        self.killed = 0
-        self.value  = None
-        self.terminated_by = None
-
-    def create(self, func, *args):
-        me = _CoEvent(func)
-        self.invokedby[me] = None
-        thread.start_new_thread(self._start, (me,) + args)
-        return me
-
-    def _start(self, me, *args):
-        me.wait()
-        if not self.killed:
-            try:
-                try:
-                    me.f(*args)
-                except Killed:
-                    pass
-            finally:
-                if not self.killed:
-                    self.terminated_by = me
-                    self.kill()
-
-    def kill(self):
-        if self.killed:
-            raise TypeError('kill() called on dead coroutines')
-        self.killed = 1
-        for coroutine in self.invokedby.keys():
-            coroutine.resume()
-
-    def back(self, data=None):
-        return self.tran( self.invokedby[self.active], data )
-
-    def detach(self, data=None):
-        return self.tran( self.main, data )
-
-    def tran(self, target, data=None):
-        if target not in self.invokedby:
-            raise TypeError('.tran target %r is not an active coroutine' % (target,))
-        if self.killed:
-            raise TypeError('.tran target %r is killed' % (target,))
-        self.value = data
-        me = self.active
-        self.invokedby[target] = me
-        self.active = target
-        target.resume()
-
-        me.wait()
-        if self.killed:
-            if self.main is not me:
-                raise Killed
-            if self.terminated_by is not None:
-                raise EarlyExit('%r terminated early' % (self.terminated_by,))
-
-        return self.value
-
-# end of module
diff --git a/Demo/threads/Generator.py b/Demo/threads/Generator.py
deleted file mode 100644
index 3a2963f..0000000
--- a/Demo/threads/Generator.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Generator implementation using threads
-
-import _thread as thread
-import sys
-
-class Killed(Exception):
-    pass
-
-class Generator:
-    # Constructor
-    def __init__(self, func, args):
-        self.getlock = thread.allocate_lock()
-        self.putlock = thread.allocate_lock()
-        self.getlock.acquire()
-        self.putlock.acquire()
-        self.func = func
-        self.args = args
-        self.done = 0
-        self.killed = 0
-        thread.start_new_thread(self._start, ())
-
-    # Internal routine
-    def _start(self):
-        try:
-            self.putlock.acquire()
-            if not self.killed:
-                try:
-                    self.func(self, *self.args)
-                except Killed:
-                    pass
-        finally:
-            if not self.killed:
-                self.done = 1
-                self.getlock.release()
-
-    # Called by producer for each value; raise Killed if no more needed
-    def put(self, value):
-        if self.killed:
-            raise TypeError('put() called on killed generator')
-        self.value = value
-        self.getlock.release()  # Resume consumer thread
-        self.putlock.acquire()  # Wait for next get() call
-        if self.killed:
-            raise Killed
-
-    # Called by producer to get next value; raise EOFError if no more
-    def get(self):
-        if self.killed:
-            raise TypeError('get() called on killed generator')
-        self.putlock.release()  # Resume producer thread
-        self.getlock.acquire()  # Wait for value to appear
-        if self.done:
-            raise EOFError  # Say there are no more values
-        return self.value
-
-    # Called by consumer if no more values wanted
-    def kill(self):
-        if self.killed:
-            raise TypeError('kill() called on killed generator')
-        self.killed = 1
-        self.putlock.release()
-
-    # Clone constructor
-    def clone(self):
-        return Generator(self.func, self.args)
-
-def pi(g):
-    k, a, b, a1, b1 = 2, 4, 1, 12, 4
-    while 1:
-        # Next approximation
-        p, q, k = k*k, 2*k+1, k+1
-        a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
-        # Print common digits
-        d, d1 = a//b, a1//b1
-        while d == d1:
-            g.put(int(d))
-            a, a1 = 10*(a%b), 10*(a1%b1)
-            d, d1 = a//b, a1//b1
-
-def test():
-    g = Generator(pi, ())
-    g.kill()
-    g = Generator(pi, ())
-    for i in range(10): print(g.get(), end=' ')
-    print()
-    h = g.clone()
-    g.kill()
-    while 1:
-        print(h.get(), end=' ')
-        sys.stdout.flush()
-
-test()
diff --git a/Demo/threads/README b/Demo/threads/README
deleted file mode 100644
index a379521..0000000
--- a/Demo/threads/README
+++ /dev/null
@@ -1,11 +0,0 @@
-This directory contains some demonstrations of the thread module.
-
-These are mostly "proof of concept" type applications:
-
-Generator.py	Generator class implemented with threads.
-sync.py		Condition variables primitives by Tim Peters.
-telnet.py	Version of ../sockets/telnet.py using threads.
-
-Coroutine.py	Coroutines using threads, by Tim Peters (22 May 94)
-fcmp.py		Example of above, by Tim
-squasher.py	Another example of above, also by Tim
diff --git a/Demo/threads/fcmp.py b/Demo/threads/fcmp.py
deleted file mode 100644
index bc2e3ed..0000000
--- a/Demo/threads/fcmp.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# Coroutine example:  controlling multiple instances of a single function
-
-from Coroutine import *
-
-# fringe visits a nested list in inorder, and detaches for each non-list
-# element; raises EarlyExit after the list is exhausted
-def fringe(co, list):
-    for x in list:
-        if type(x) is type([]):
-            fringe(co, x)
-        else:
-            co.back(x)
-
-def printinorder(list):
-    co = Coroutine()
-    f = co.create(fringe, co, list)
-    try:
-        while 1:
-            print(co.tran(f), end=' ')
-    except EarlyExit:
-        pass
-    print()
-
-printinorder([1,2,3])  # 1 2 3
-printinorder([[[[1,[2]]],3]]) # ditto
-x = [0, 1, [2, [3]], [4,5], [[[6]]] ]
-printinorder(x) # 0 1 2 3 4 5 6
-
-# fcmp lexicographically compares the fringes of two nested lists
-def fcmp(l1, l2):
-    co1 = Coroutine(); f1 = co1.create(fringe, co1, l1)
-    co2 = Coroutine(); f2 = co2.create(fringe, co2, l2)
-    while 1:
-        try:
-            v1 = co1.tran(f1)
-        except EarlyExit:
-            try:
-                v2 = co2.tran(f2)
-            except EarlyExit:
-                return 0
-            co2.kill()
-            return -1
-        try:
-            v2 = co2.tran(f2)
-        except EarlyExit:
-            co1.kill()
-            return 1
-        if v1 != v2:
-            co1.kill(); co2.kill()
-            return cmp(v1,v2)
-
-print(fcmp(range(7), x))  #  0; fringes are equal
-print(fcmp(range(6), x))  # -1; 1st list ends early
-print(fcmp(x, range(6)))  #  1; 2nd list ends early
-print(fcmp(range(8), x))  #  1; 2nd list ends early
-print(fcmp(x, range(8)))  # -1; 1st list ends early
-print(fcmp([1,[[2],8]],
-           [[[1],2],8]))  #  0
-print(fcmp([1,[[3],8]],
-           [[[1],2],8]))  #  1
-print(fcmp([1,[[2],8]],
-           [[[1],2],9]))  # -1
-
-# end of example
diff --git a/Demo/threads/find.py b/Demo/threads/find.py
deleted file mode 100644
index 2b4ef7d..0000000
--- a/Demo/threads/find.py
+++ /dev/null
@@ -1,154 +0,0 @@
-# A parallelized "find(1)" using the thread module.
-
-# This demonstrates the use of a work queue and worker threads.
-# It really does do more stats/sec when using multiple threads,
-# although the improvement is only about 20-30 percent.
-# (That was 8 years ago.  In 2002, on Linux, I can't measure
-# a speedup. :-( )
-
-# I'm too lazy to write a command line parser for the full find(1)
-# command line syntax, so the predicate it searches for is wired-in,
-# see function selector() below.  (It currently searches for files with
-# world write permission.)
-
-# Usage: parfind.py [-w nworkers] [directory] ...
-# Default nworkers is 4
-
-
-import sys
-import getopt
-import time
-import os
-from stat import *
-import _thread as thread
-
-
-# Work queue class.  Usage:
-#   wq = WorkQ()
-#   wq.addwork(func, (arg1, arg2, ...)) # one or more calls
-#   wq.run(nworkers)
-# The work is done when wq.run() completes.
-# The function calls executed by the workers may add more work.
-# Don't use keyboard interrupts!
-
-class WorkQ:
-
-    # Invariants:
-
-    # - busy and work are only modified when mutex is locked
-    # - len(work) is the number of jobs ready to be taken
-    # - busy is the number of jobs being done
-    # - todo is locked iff there is no work and somebody is busy
-
-    def __init__(self):
-        self.mutex = thread.allocate()
-        self.todo = thread.allocate()
-        self.todo.acquire()
-        self.work = []
-        self.busy = 0
-
-    def addwork(self, func, args):
-        job = (func, args)
-        self.mutex.acquire()
-        self.work.append(job)
-        self.mutex.release()
-        if len(self.work) == 1:
-            self.todo.release()
-
-    def _getwork(self):
-        self.todo.acquire()
-        self.mutex.acquire()
-        if self.busy == 0 and len(self.work) == 0:
-            self.mutex.release()
-            self.todo.release()
-            return None
-        job = self.work[0]
-        del self.work[0]
-        self.busy = self.busy + 1
-        self.mutex.release()
-        if len(self.work) > 0:
-            self.todo.release()
-        return job
-
-    def _donework(self):
-        self.mutex.acquire()
-        self.busy = self.busy - 1
-        if self.busy == 0 and len(self.work) == 0:
-            self.todo.release()
-        self.mutex.release()
-
-    def _worker(self):
-        time.sleep(0.00001)     # Let other threads run
-        while 1:
-            job = self._getwork()
-            if not job:
-                break
-            func, args = job
-            func(*args)
-            self._donework()
-
-    def run(self, nworkers):
-        if not self.work:
-            return # Nothing to do
-        for i in range(nworkers-1):
-            thread.start_new(self._worker, ())
-        self._worker()
-        self.todo.acquire()
-
-
-# Main program
-
-def main():
-    nworkers = 4
-    opts, args = getopt.getopt(sys.argv[1:], '-w:')
-    for opt, arg in opts:
-        if opt == '-w':
-            nworkers = int(arg)
-    if not args:
-        args = [os.curdir]
-
-    wq = WorkQ()
-    for dir in args:
-        wq.addwork(find, (dir, selector, wq))
-
-    t1 = time.time()
-    wq.run(nworkers)
-    t2 = time.time()
-
-    sys.stderr.write('Total time %r sec.\n' % (t2-t1))
-
-
-# The predicate -- defines what files we look for.
-# Feel free to change this to suit your purpose
-
-def selector(dir, name, fullname, stat):
-    # Look for world writable files that are not symlinks
-    return (stat[ST_MODE] & 0o002) != 0 and not S_ISLNK(stat[ST_MODE])
-
-
-# The find procedure -- calls wq.addwork() for subdirectories
-
-def find(dir, pred, wq):
-    try:
-        names = os.listdir(dir)
-    except os.error as msg:
-        print(repr(dir), ':', msg)
-        return
-    for name in names:
-        if name not in (os.curdir, os.pardir):
-            fullname = os.path.join(dir, name)
-            try:
-                stat = os.lstat(fullname)
-            except os.error as msg:
-                print(repr(fullname), ':', msg)
-                continue
-            if pred(dir, name, fullname, stat):
-                print(fullname)
-            if S_ISDIR(stat[ST_MODE]):
-                if not os.path.ismount(fullname):
-                    wq.addwork(find, (fullname, pred, wq))
-
-
-# Call the main program
-
-main()
diff --git a/Demo/threads/squasher.py b/Demo/threads/squasher.py
deleted file mode 100644
index 35b1b1d..0000000
--- a/Demo/threads/squasher.py
+++ /dev/null
@@ -1,105 +0,0 @@
-# Coroutine example:  general coroutine transfers
-#
-# The program is a variation of a Simula 67 program due to Dahl & Hoare,
-# (Dahl/Dijkstra/Hoare, Structured Programming; Academic Press, 1972)
-# who in turn credit the original example to Conway.
-#
-# We have a number of input lines, terminated by a 0 byte.  The problem
-# is to squash them together into output lines containing 72 characters
-# each.  A semicolon must be added between input lines.  Runs of blanks
-# and tabs in input lines must be squashed into single blanks.
-# Occurrences of "**" in input lines must be replaced by "^".
-#
-# Here's a test case:
-
-test = """\
-   d    =   sqrt(b**2  -  4*a*c)
-twoa    =   2*a
-   L    =   -b/twoa
-   R    =   d/twoa
-  A1    =   L + R
-  A2    =   L - R\0
-"""
-
-# The program should print:
-
-# d = sqrt(b^2 - 4*a*c);twoa = 2*a; L = -b/twoa; R = d/twoa; A1 = L + R;
-#A2 = L - R
-#done
-
-# getline: delivers the next input line to its invoker
-# disassembler: grabs input lines from getline, and delivers them one
-#    character at a time to squasher, also inserting a semicolon into
-#    the stream between lines
-# squasher:  grabs characters from disassembler and passes them on to
-#    assembler, first replacing "**" with "^" and squashing runs of
-#    whitespace
-# assembler: grabs characters from squasher and packs them into lines
-#    with 72 character each, delivering each such line to putline;
-#    when it sees a null byte, passes the last line to putline and
-#    then kills all the coroutines
-# putline: grabs lines from assembler, and just prints them
-
-from Coroutine import *
-
-def getline(text):
-    for line in string.splitfields(text, '\n'):
-        co.tran(codisassembler, line)
-
-def disassembler():
-    while 1:
-        card = co.tran(cogetline)
-        for i in range(len(card)):
-            co.tran(cosquasher, card[i])
-        co.tran(cosquasher, ';')
-
-def squasher():
-    while 1:
-        ch = co.tran(codisassembler)
-        if ch == '*':
-            ch2 = co.tran(codisassembler)
-            if ch2 == '*':
-                ch = '^'
-            else:
-                co.tran(coassembler, ch)
-                ch = ch2
-        if ch in ' \t':
-            while 1:
-                ch2 = co.tran(codisassembler)
-                if ch2 not in ' \t':
-                    break
-            co.tran(coassembler, ' ')
-            ch = ch2
-        co.tran(coassembler, ch)
-
-def assembler():
-    line = ''
-    while 1:
-        ch = co.tran(cosquasher)
-        if ch == '\0':
-            break
-        if len(line) == 72:
-            co.tran(coputline, line)
-            line = ''
-        line = line + ch
-    line = line + ' ' * (72 - len(line))
-    co.tran(coputline, line)
-    co.kill()
-
-def putline():
-    while 1:
-        line = co.tran(coassembler)
-        print(line)
-
-import string
-co = Coroutine()
-cogetline = co.create(getline, test)
-coputline = co.create(putline)
-coassembler = co.create(assembler)
-codisassembler = co.create(disassembler)
-cosquasher = co.create(squasher)
-
-co.tran(coputline)
-print('done')
-
-# end of example
diff --git a/Demo/threads/sync.py b/Demo/threads/sync.py
deleted file mode 100644
index 90fff2e..0000000
--- a/Demo/threads/sync.py
+++ /dev/null
@@ -1,599 +0,0 @@
-# Defines classes that provide synchronization objects.  Note that use of
-# this module requires that your Python support threads.
-#
-#    condition(lock=None)       # a POSIX-like condition-variable object
-#    barrier(n)                 # an n-thread barrier
-#    event()                    # an event object
-#    semaphore(n=1)             # a semaphore object, with initial count n
-#    mrsw()                     # a multiple-reader single-writer lock
-#
-# CONDITIONS
-#
-# A condition object is created via
-#   import this_module
-#   your_condition_object = this_module.condition(lock=None)
-#
-# As explained below, a condition object has a lock associated with it,
-# used in the protocol to protect condition data.  You can specify a
-# lock to use in the constructor, else the constructor will allocate
-# an anonymous lock for you.  Specifying a lock explicitly can be useful
-# when more than one condition keys off the same set of shared data.
-#
-# Methods:
-#   .acquire()
-#      acquire the lock associated with the condition
-#   .release()
-#      release the lock associated with the condition
-#   .wait()
-#      block the thread until such time as some other thread does a
-#      .signal or .broadcast on the same condition, and release the
-#      lock associated with the condition.  The lock associated with
-#      the condition MUST be in the acquired state at the time
-#      .wait is invoked.
-#   .signal()
-#      wake up exactly one thread (if any) that previously did a .wait
-#      on the condition; that thread will awaken with the lock associated
-#      with the condition in the acquired state.  If no threads are
-#      .wait'ing, this is a nop.  If more than one thread is .wait'ing on
-#      the condition, any of them may be awakened.
-#   .broadcast()
-#      wake up all threads (if any) that are .wait'ing on the condition;
-#      the threads are woken up serially, each with the lock in the
-#      acquired state, so should .release() as soon as possible.  If no
-#      threads are .wait'ing, this is a nop.
-#
-#      Note that if a thread does a .wait *while* a signal/broadcast is
-#      in progress, it's guaranteeed to block until a subsequent
-#      signal/broadcast.
-#
-#      Secret feature:  `broadcast' actually takes an integer argument,
-#      and will wake up exactly that many waiting threads (or the total
-#      number waiting, if that's less).  Use of this is dubious, though,
-#      and probably won't be supported if this form of condition is
-#      reimplemented in C.
-#
-# DIFFERENCES FROM POSIX
-#
-# + A separate mutex is not needed to guard condition data.  Instead, a
-#   condition object can (must) be .acquire'ed and .release'ed directly.
-#   This eliminates a common error in using POSIX conditions.
-#
-# + Because of implementation difficulties, a POSIX `signal' wakes up
-#   _at least_ one .wait'ing thread.  Race conditions make it difficult
-#   to stop that.  This implementation guarantees to wake up only one,
-#   but you probably shouldn't rely on that.
-#
-# PROTOCOL
-#
-# Condition objects are used to block threads until "some condition" is
-# true.  E.g., a thread may wish to wait until a producer pumps out data
-# for it to consume, or a server may wish to wait until someone requests
-# its services, or perhaps a whole bunch of threads want to wait until a
-# preceding pass over the data is complete.  Early models for conditions
-# relied on some other thread figuring out when a blocked thread's
-# condition was true, and made the other thread responsible both for
-# waking up the blocked thread and guaranteeing that it woke up with all
-# data in a correct state.  This proved to be very delicate in practice,
-# and gave conditions a bad name in some circles.
-#
-# The POSIX model addresses these problems by making a thread responsible
-# for ensuring that its own state is correct when it wakes, and relies
-# on a rigid protocol to make this easy; so long as you stick to the
-# protocol, POSIX conditions are easy to "get right":
-#
-#  A) The thread that's waiting for some arbitrarily-complex condition
-#     (ACC) to become true does:
-#
-#     condition.acquire()
-#     while not (code to evaluate the ACC):
-#           condition.wait()
-#           # That blocks the thread, *and* releases the lock.  When a
-#           # condition.signal() happens, it will wake up some thread that
-#           # did a .wait, *and* acquire the lock again before .wait
-#           # returns.
-#           #
-#           # Because the lock is acquired at this point, the state used
-#           # in evaluating the ACC is frozen, so it's safe to go back &
-#           # reevaluate the ACC.
-#
-#     # At this point, ACC is true, and the thread has the condition
-#     # locked.
-#     # So code here can safely muck with the shared state that
-#     # went into evaluating the ACC -- if it wants to.
-#     # When done mucking with the shared state, do
-#     condition.release()
-#
-#  B) Threads that are mucking with shared state that may affect the
-#     ACC do:
-#
-#     condition.acquire()
-#     # muck with shared state
-#     condition.release()
-#     if it's possible that ACC is true now:
-#         condition.signal() # or .broadcast()
-#
-#     Note:  You may prefer to put the "if" clause before the release().
-#     That's fine, but do note that anyone waiting on the signal will
-#     stay blocked until the release() is done (since acquiring the
-#     condition is part of what .wait() does before it returns).
-#
-# TRICK OF THE TRADE
-#
-# With simpler forms of conditions, it can be impossible to know when
-# a thread that's supposed to do a .wait has actually done it.  But
-# because this form of condition releases a lock as _part_ of doing a
-# wait, the state of that lock can be used to guarantee it.
-#
-# E.g., suppose thread A spawns thread B and later wants to wait for B to
-# complete:
-#
-# In A:                             In B:
-#
-# B_done = condition()              ... do work ...
-# B_done.acquire()                  B_done.acquire(); B_done.release()
-# spawn B                           B_done.signal()
-# ... some time later ...           ... and B exits ...
-# B_done.wait()
-#
-# Because B_done was in the acquire'd state at the time B was spawned,
-# B's attempt to acquire B_done can't succeed until A has done its
-# B_done.wait() (which releases B_done).  So B's B_done.signal() is
-# guaranteed to be seen by the .wait().  Without the lock trick, B
-# may signal before A .waits, and then A would wait forever.
-#
-# BARRIERS
-#
-# A barrier object is created via
-#   import this_module
-#   your_barrier = this_module.barrier(num_threads)
-#
-# Methods:
-#   .enter()
-#      the thread blocks until num_threads threads in all have done
-#      .enter().  Then the num_threads threads that .enter'ed resume,
-#      and the barrier resets to capture the next num_threads threads
-#      that .enter it.
-#
-# EVENTS
-#
-# An event object is created via
-#   import this_module
-#   your_event = this_module.event()
-#
-# An event has two states, `posted' and `cleared'.  An event is
-# created in the cleared state.
-#
-# Methods:
-#
-#   .post()
-#      Put the event in the posted state, and resume all threads
-#      .wait'ing on the event (if any).
-#
-#   .clear()
-#      Put the event in the cleared state.
-#
-#   .is_posted()
-#      Returns 0 if the event is in the cleared state, or 1 if the event
-#      is in the posted state.
-#
-#   .wait()
-#      If the event is in the posted state, returns immediately.
-#      If the event is in the cleared state, blocks the calling thread
-#      until the event is .post'ed by another thread.
-#
-# Note that an event, once posted, remains posted until explicitly
-# cleared.  Relative to conditions, this is both the strength & weakness
-# of events.  It's a strength because the .post'ing thread doesn't have to
-# worry about whether the threads it's trying to communicate with have
-# already done a .wait (a condition .signal is seen only by threads that
-# do a .wait _prior_ to the .signal; a .signal does not persist).  But
-# it's a weakness because .clear'ing an event is error-prone:  it's easy
-# to mistakenly .clear an event before all the threads you intended to
-# see the event get around to .wait'ing on it.  But so long as you don't
-# need to .clear an event, events are easy to use safely.
-#
-# SEMAPHORES
-#
-# A semaphore object is created via
-#   import this_module
-#   your_semaphore = this_module.semaphore(count=1)
-#
-# A semaphore has an integer count associated with it.  The initial value
-# of the count is specified by the optional argument (which defaults to
-# 1) passed to the semaphore constructor.
-#
-# Methods:
-#
-#   .p()
-#      If the semaphore's count is greater than 0, decrements the count
-#      by 1 and returns.
-#      Else if the semaphore's count is 0, blocks the calling thread
-#      until a subsequent .v() increases the count.  When that happens,
-#      the count will be decremented by 1 and the calling thread resumed.
-#
-#   .v()
-#      Increments the semaphore's count by 1, and wakes up a thread (if
-#      any) blocked by a .p().  It's an (detected) error for a .v() to
-#      increase the semaphore's count to a value larger than the initial
-#      count.
-#
-# MULTIPLE-READER SINGLE-WRITER LOCKS
-#
-# A mrsw lock is created via
-#   import this_module
-#   your_mrsw_lock = this_module.mrsw()
-#
-# This kind of lock is often useful with complex shared data structures.
-# The object lets any number of "readers" proceed, so long as no thread
-# wishes to "write".  When a (one or more) thread declares its intention
-# to "write" (e.g., to update a shared structure), all current readers
-# are allowed to finish, and then a writer gets exclusive access; all
-# other readers & writers are blocked until the current writer completes.
-# Finally, if some thread is waiting to write and another is waiting to
-# read, the writer takes precedence.
-#
-# Methods:
-#
-#   .read_in()
-#      If no thread is writing or waiting to write, returns immediately.
-#      Else blocks until no thread is writing or waiting to write.  So
-#      long as some thread has completed a .read_in but not a .read_out,
-#      writers are blocked.
-#
-#   .read_out()
-#      Use sometime after a .read_in to declare that the thread is done
-#      reading.  When all threads complete reading, a writer can proceed.
-#
-#   .write_in()
-#      If no thread is writing (has completed a .write_in, but hasn't yet
-#      done a .write_out) or reading (similarly), returns immediately.
-#      Else blocks the calling thread, and threads waiting to read, until
-#      the current writer completes writing or all the current readers
-#      complete reading; if then more than one thread is waiting to
-#      write, one of them is allowed to proceed, but which one is not
-#      specified.
-#
-#   .write_out()
-#      Use sometime after a .write_in to declare that the thread is done
-#      writing.  Then if some other thread is waiting to write, it's
-#      allowed to proceed.  Else all threads (if any) waiting to read are
-#      allowed to proceed.
-#
-#   .write_to_read()
-#      Use instead of a .write_in to declare that the thread is done
-#      writing but wants to continue reading without other writers
-#      intervening.  If there are other threads waiting to write, they
-#      are allowed to proceed only if the current thread calls
-#      .read_out; threads waiting to read are only allowed to proceed
-#      if there are are no threads waiting to write.  (This is a
-#      weakness of the interface!)
-
-import _thread as thread
-
-class condition:
-    def __init__(self, lock=None):
-        # the lock actually used by .acquire() and .release()
-        if lock is None:
-            self.mutex = thread.allocate_lock()
-        else:
-            if hasattr(lock, 'acquire') and \
-               hasattr(lock, 'release'):
-                self.mutex = lock
-            else:
-                raise TypeError('condition constructor requires ' \
-                                 'a lock argument')
-
-        # lock used to block threads until a signal
-        self.checkout = thread.allocate_lock()
-        self.checkout.acquire()
-
-        # internal critical-section lock, & the data it protects
-        self.idlock = thread.allocate_lock()
-        self.id = 0
-        self.waiting = 0  # num waiters subject to current release
-        self.pending = 0  # num waiters awaiting next signal
-        self.torelease = 0      # num waiters to release
-        self.releasing = 0      # 1 iff release is in progress
-
-    def acquire(self):
-        self.mutex.acquire()
-
-    def release(self):
-        self.mutex.release()
-
-    def wait(self):
-        mutex, checkout, idlock = self.mutex, self.checkout, self.idlock
-        if not mutex.locked():
-            raise ValueError("condition must be .acquire'd when .wait() invoked")
-
-        idlock.acquire()
-        myid = self.id
-        self.pending = self.pending + 1
-        idlock.release()
-
-        mutex.release()
-
-        while 1:
-            checkout.acquire(); idlock.acquire()
-            if myid < self.id:
-                break
-            checkout.release(); idlock.release()
-
-        self.waiting = self.waiting - 1
-        self.torelease = self.torelease - 1
-        if self.torelease:
-            checkout.release()
-        else:
-            self.releasing = 0
-            if self.waiting == self.pending == 0:
-                self.id = 0
-        idlock.release()
-        mutex.acquire()
-
-    def signal(self):
-        self.broadcast(1)
-
-    def broadcast(self, num = -1):
-        if num < -1:
-            raise ValueError('.broadcast called with num %r' % (num,))
-        if num == 0:
-            return
-        self.idlock.acquire()
-        if self.pending:
-            self.waiting = self.waiting + self.pending
-            self.pending = 0
-            self.id = self.id + 1
-        if num == -1:
-            self.torelease = self.waiting
-        else:
-            self.torelease = min( self.waiting,
-                                  self.torelease + num )
-        if self.torelease and not self.releasing:
-            self.releasing = 1
-            self.checkout.release()
-        self.idlock.release()
-
-class barrier:
-    def __init__(self, n):
-        self.n = n
-        self.togo = n
-        self.full = condition()
-
-    def enter(self):
-        full = self.full
-        full.acquire()
-        self.togo = self.togo - 1
-        if self.togo:
-            full.wait()
-        else:
-            self.togo = self.n
-            full.broadcast()
-        full.release()
-
-class event:
-    def __init__(self):
-        self.state  = 0
-        self.posted = condition()
-
-    def post(self):
-        self.posted.acquire()
-        self.state = 1
-        self.posted.broadcast()
-        self.posted.release()
-
-    def clear(self):
-        self.posted.acquire()
-        self.state = 0
-        self.posted.release()
-
-    def is_posted(self):
-        self.posted.acquire()
-        answer = self.state
-        self.posted.release()
-        return answer
-
-    def wait(self):
-        self.posted.acquire()
-        if not self.state:
-            self.posted.wait()
-        self.posted.release()
-
-class semaphore:
-    def __init__(self, count=1):
-        if count <= 0:
-            raise ValueError('semaphore count %d; must be >= 1' % count)
-        self.count = count
-        self.maxcount = count
-        self.nonzero = condition()
-
-    def p(self):
-        self.nonzero.acquire()
-        while self.count == 0:
-            self.nonzero.wait()
-        self.count = self.count - 1
-        self.nonzero.release()
-
-    def v(self):
-        self.nonzero.acquire()
-        if self.count == self.maxcount:
-            raise ValueError('.v() tried to raise semaphore count above ' \
-                  'initial value %r' % self.maxcount)
-        self.count = self.count + 1
-        self.nonzero.signal()
-        self.nonzero.release()
-
-class mrsw:
-    def __init__(self):
-        # critical-section lock & the data it protects
-        self.rwOK = thread.allocate_lock()
-        self.nr = 0  # number readers actively reading (not just waiting)
-        self.nw = 0  # number writers either waiting to write or writing
-        self.writing = 0  # 1 iff some thread is writing
-
-        # conditions
-        self.readOK  = condition(self.rwOK)  # OK to unblock readers
-        self.writeOK = condition(self.rwOK)  # OK to unblock writers
-
-    def read_in(self):
-        self.rwOK.acquire()
-        while self.nw:
-            self.readOK.wait()
-        self.nr = self.nr + 1
-        self.rwOK.release()
-
-    def read_out(self):
-        self.rwOK.acquire()
-        if self.nr <= 0:
-            raise ValueError('.read_out() invoked without an active reader')
-        self.nr = self.nr - 1
-        if self.nr == 0:
-            self.writeOK.signal()
-        self.rwOK.release()
-
-    def write_in(self):
-        self.rwOK.acquire()
-        self.nw = self.nw + 1
-        while self.writing or self.nr:
-            self.writeOK.wait()
-        self.writing = 1
-        self.rwOK.release()
-
-    def write_out(self):
-        self.rwOK.acquire()
-        if not self.writing:
-            raise ValueError('.write_out() invoked without an active writer')
-        self.writing = 0
-        self.nw = self.nw - 1
-        if self.nw:
-            self.writeOK.signal()
-        else:
-            self.readOK.broadcast()
-        self.rwOK.release()
-
-    def write_to_read(self):
-        self.rwOK.acquire()
-        if not self.writing:
-            raise ValueError('.write_to_read() invoked without an active writer')
-        self.writing = 0
-        self.nw = self.nw - 1
-        self.nr = self.nr + 1
-        if not self.nw:
-            self.readOK.broadcast()
-        self.rwOK.release()
-
-# The rest of the file is a test case, that runs a number of parallelized
-# quicksorts in parallel.  If it works, you'll get about 600 lines of
-# tracing output, with a line like
-#     test passed! 209 threads created in all
-# as the last line.  The content and order of preceding lines will
-# vary across runs.
-
-def _new_thread(func, *args):
-    global TID
-    tid.acquire(); id = TID = TID+1; tid.release()
-    io.acquire(); alive.append(id); \
-                  print('starting thread', id, '--', len(alive), 'alive'); \
-                  io.release()
-    thread.start_new_thread( func, (id,) + args )
-
-def _qsort(tid, a, l, r, finished):
-    # sort a[l:r]; post finished when done
-    io.acquire(); print('thread', tid, 'qsort', l, r); io.release()
-    if r-l > 1:
-        pivot = a[l]
-        j = l+1   # make a[l:j] <= pivot, and a[j:r] > pivot
-        for i in range(j, r):
-            if a[i] <= pivot:
-                a[j], a[i] = a[i], a[j]
-                j = j + 1
-        a[l], a[j-1] = a[j-1], pivot
-
-        l_subarray_sorted = event()
-        r_subarray_sorted = event()
-        _new_thread(_qsort, a, l, j-1, l_subarray_sorted)
-        _new_thread(_qsort, a, j, r,   r_subarray_sorted)
-        l_subarray_sorted.wait()
-        r_subarray_sorted.wait()
-
-    io.acquire(); print('thread', tid, 'qsort done'); \
-                  alive.remove(tid); io.release()
-    finished.post()
-
-def _randarray(tid, a, finished):
-    io.acquire(); print('thread', tid, 'randomizing array'); \
-                  io.release()
-    for i in range(1, len(a)):
-        wh.acquire(); j = randint(0,i); wh.release()
-        a[i], a[j] = a[j], a[i]
-    io.acquire(); print('thread', tid, 'randomizing done'); \
-                  alive.remove(tid); io.release()
-    finished.post()
-
-def _check_sort(a):
-    if a != range(len(a)):
-        raise ValueError('a not sorted', a)
-
-def _run_one_sort(tid, a, bar, done):
-    # randomize a, and quicksort it
-    # for variety, all the threads running this enter a barrier
-    # at the end, and post `done' after the barrier exits
-    io.acquire(); print('thread', tid, 'randomizing', a); \
-                  io.release()
-    finished = event()
-    _new_thread(_randarray, a, finished)
-    finished.wait()
-
-    io.acquire(); print('thread', tid, 'sorting', a); io.release()
-    finished.clear()
-    _new_thread(_qsort, a, 0, len(a), finished)
-    finished.wait()
-    _check_sort(a)
-
-    io.acquire(); print('thread', tid, 'entering barrier'); \
-                  io.release()
-    bar.enter()
-    io.acquire(); print('thread', tid, 'leaving barrier'); \
-                  io.release()
-    io.acquire(); alive.remove(tid); io.release()
-    bar.enter() # make sure they've all removed themselves from alive
-                ##  before 'done' is posted
-    bar.enter() # just to be cruel
-    done.post()
-
-def test():
-    global TID, tid, io, wh, randint, alive
-    import random
-    randint = random.randint
-
-    TID = 0                             # thread ID (1, 2, ...)
-    tid = thread.allocate_lock()        # for changing TID
-    io  = thread.allocate_lock()        # for printing, and 'alive'
-    wh  = thread.allocate_lock()        # for calls to random
-    alive = []                          # IDs of active threads
-
-    NSORTS = 5
-    arrays = []
-    for i in range(NSORTS):
-        arrays.append( range( (i+1)*10 ) )
-
-    bar = barrier(NSORTS)
-    finished = event()
-    for i in range(NSORTS):
-        _new_thread(_run_one_sort, arrays[i], bar, finished)
-    finished.wait()
-
-    print('all threads done, and checking results ...')
-    if alive:
-        raise ValueError('threads still alive at end', alive)
-    for i in range(NSORTS):
-        a = arrays[i]
-        if len(a) != (i+1)*10:
-            raise ValueError('length of array', i, 'screwed up')
-        _check_sort(a)
-
-    print('test passed!', TID, 'threads created in all')
-
-if __name__ == '__main__':
-    test()
-
-# end of module
diff --git a/Demo/threads/telnet.py b/Demo/threads/telnet.py
deleted file mode 100644
index dfe4905..0000000
--- a/Demo/threads/telnet.py
+++ /dev/null
@@ -1,114 +0,0 @@
-# Minimal interface to the Internet telnet protocol.
-#
-# *** modified to use threads ***
-#
-# It refuses all telnet options and does not recognize any of the other
-# telnet commands, but can still be used to connect in line-by-line mode.
-# It's also useful to play with a number of other services,
-# like time, finger, smtp and even ftp.
-#
-# Usage: telnet host [port]
-#
-# The port may be a service name or a decimal port number;
-# it defaults to 'telnet'.
-
-
-import sys, os, time
-from socket import *
-import _thread as thread
-
-BUFSIZE = 8*1024
-
-# Telnet protocol characters
-
-IAC  = chr(255) # Interpret as command
-DONT = chr(254)
-DO   = chr(253)
-WONT = chr(252)
-WILL = chr(251)
-
-def main():
-    if len(sys.argv) < 2:
-        sys.stderr.write('usage: telnet hostname [port]\n')
-        sys.exit(2)
-    host = sys.argv[1]
-    try:
-        hostaddr = gethostbyname(host)
-    except error:
-        sys.stderr.write(sys.argv[1] + ': bad host name\n')
-        sys.exit(2)
-    #
-    if len(sys.argv) > 2:
-        servname = sys.argv[2]
-    else:
-        servname = 'telnet'
-    #
-    if '0' <= servname[:1] <= '9':
-        port = eval(servname)
-    else:
-        try:
-            port = getservbyname(servname, 'tcp')
-        except error:
-            sys.stderr.write(servname + ': bad tcp service name\n')
-            sys.exit(2)
-    #
-    s = socket(AF_INET, SOCK_STREAM)
-    #
-    try:
-        s.connect((host, port))
-    except error as msg:
-        sys.stderr.write('connect failed: %r\n' % (msg,))
-        sys.exit(1)
-    #
-    thread.start_new(child, (s,))
-    parent(s)
-
-def parent(s):
-    # read socket, write stdout
-    iac = 0         # Interpret next char as command
-    opt = ''        # Interpret next char as option
-    while 1:
-        data, dummy = s.recvfrom(BUFSIZE)
-        if not data:
-            # EOF -- exit
-            sys.stderr.write( '(Closed by remote host)\n')
-            sys.exit(1)
-        cleandata = ''
-        for c in data:
-            if opt:
-                print(ord(c))
-##                              print '(replying: %r)' % (opt+c,)
-                s.send(opt + c)
-                opt = ''
-            elif iac:
-                iac = 0
-                if c == IAC:
-                    cleandata = cleandata + c
-                elif c in (DO, DONT):
-                    if c == DO: print('(DO)', end=' ')
-                    else: print('(DONT)', end=' ')
-                    opt = IAC + WONT
-                elif c in (WILL, WONT):
-                    if c == WILL: print('(WILL)', end=' ')
-                    else: print('(WONT)', end=' ')
-                    opt = IAC + DONT
-                else:
-                    print('(command)', ord(c))
-            elif c == IAC:
-                iac = 1
-                print('(IAC)', end=' ')
-            else:
-                cleandata = cleandata + c
-        sys.stdout.write(cleandata)
-        sys.stdout.flush()
-##              print 'Out:', repr(cleandata)
-
-def child(s):
-    # read stdin, write socket
-    while 1:
-        line = sys.stdin.readline()
-##              print 'Got:', repr(line)
-        if not line: break
-        s.send(line)
-
-main()
diff --git a/Demo/tix/INSTALL.txt b/Demo/tix/INSTALL.txt
deleted file mode 100644
index ac70b68..0000000
--- a/Demo/tix/INSTALL.txt
+++ /dev/null
@@ -1,89 +0,0 @@
-$Id$
-
-Installing Tix.py
-----------------
-
-0) To use Tix.py, you need Tcl/Tk (V8.3.3), Tix (V8.1.1) and Python (V2.1.1).
-   Tix.py has been written and tested on a Intel Pentium running RH Linux 5.2
-   and Mandrake Linux 7.0 and Windows with the above mentioned packages.
-
-   Older versions, e.g. Tix 4.1 and Tk 8.0, might also work.
-
-   There is nothing OS-specific in Tix.py itself so it should work on
-   any machine with Tix and Python installed. You can get Tcl and Tk
-   from http://dev.scriptics.com and Tix from http://tix.sourceforge.net.
-
-1) Build and install Tcl/Tk 8.3. Build and install Tix 8.1.
-   Ensure that Tix is properly installed by running tixwish and executing
-   the demo programs. Under Unix, use the --enable-shared configure option
-   for all three. We recommend tcl8.3.3 for this release of Tix.py.
-
-2a) If you have a distribution like ActiveState with a tcl subdirectory
-   of $PYTHONHOME, which contains the directories tcl8.3 and tk8.3,
-   make a directory tix8.1 as well. Recursively copy the files from
-   <tix>/library to $PYTHONHOME/lib/tix8.1, and copy the dynamic library
-   (tix8183.dll or libtix8.1.8.3.so) to the same place as the tcl dynamic
-   libraries  ($PYTHONHOME/Dlls or lib/python-2.1/lib-dynload). In this
-   case you are all installed, and you can skip to the end.
-
-2b) Modify Modules/Setup.dist and setup.py to change the version of the 
-   tix library from tix4.1.8.0 to tix8.1.8.3
-   These modified files can be used for Tkinter with or without Tix.
-   
-3) The default is to build dynamically, and use the Tcl 'package require'.
-   To build statically, modify the Modules/Setup file to link in the Tix 
-   library according to the comments in the file. On Linux this looks like:
-
-# *** Always uncomment this (leave the leading underscore in!):
-_tkinter _tkinter.c tkappinit.c -DWITH_APPINIT \
-# *** Uncomment and edit to reflect where your Tcl/Tk libraries are:
-	-L/usr/local/lib \
-# *** Uncomment and edit to reflect where your Tcl/Tk headers are:
-	-I/usr/local/include \
-# *** Uncomment and edit to reflect where your X11 header files are:
-	-I/usr/X11R6/include \
-# *** Or uncomment this for Solaris:
-#	-I/usr/openwin/include \
-# *** Uncomment and edit for BLT extension only:
-#	-DWITH_BLT -I/usr/local/blt/blt8.0-unoff/include -lBLT8.0 \
-# *** Uncomment and edit for PIL (TkImaging) extension only:
-#     (See http://www.pythonware.com/products/pil/ for more info)
-#	-DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
-# *** Uncomment and edit for TOGL extension only:
-#	-DWITH_TOGL togl.c \
-# *** Uncomment and edit for Tix extension only:
-	-DWITH_TIX -ltix8.1.8.3 \
-# *** Uncomment and edit to reflect your Tcl/Tk versions:
-	-ltk8.3 -ltcl8.3 \
-# *** Uncomment and edit to reflect where your X11 libraries are:
-	-L/usr/X11R6/lib \
-# *** Or uncomment this for Solaris:
-#	-L/usr/openwin/lib \
-# *** Uncomment these for TOGL extension only:
-#	-lGL -lGLU -lXext -lXmu \
-# *** Uncomment for AIX:
-#	-lld \
-# *** Always uncomment this; X11 libraries to link with:
-	-lX11
-
-4) Rebuild Python and reinstall.
-
-You should now have a working Tix implementation in Python. To see if all
-is as it should be, run the 'tixwidgets.py' script in the Demo/tix directory.
-Under X windows, do
-	/usr/local/bin/python Demo/tix/tixwidgets.py
-
-If this does not work, you may need to tell python where to find
-the Tcl, Tk and Tix library files. This is done by setting the
-TCL_LIBRARY, TK_LIBRARY and TIX_LIBRARY environment variables. Try this:
-
-	env 	TCL_LIBRARY=/usr/local/lib/tcl8.3 \
-		TK_LIBRARY=/usr/local/lib/tk8.3 \
-		TIX_LIBRARY=/usr/local/lib/tix8.1 \
-		/usr/local/bin/python Demo/tix/tixwidgets.py
-
-
-If you find any bugs or have suggestions for improvement, please report them
-via http://tix.sourceforge.net
-
-
diff --git a/Demo/tix/README.txt b/Demo/tix/README.txt
deleted file mode 100644
index e0196ac..0000000
--- a/Demo/tix/README.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-About Tix.py
------------
-
-Tix.py is based on an idea of Jean-Marc Lugrin (lugrin@ms.com) who wrote
-pytix (another Python-Tix marriage). Tix widgets are an attractive and
-useful extension to Tk. See http://tix.sourceforge.net
-for more details about Tix and how to get it.
-
-Features:
-	1) It is almost complete.
-	2) Tix widgets are represented by classes in Python. Sub-widgets
-	   are members of the mega-widget class. For example, if a
-	   particular TixWidget (e.g. ScrolledText) has an embedded widget
-	   (Text in this case), it is possible to call the methods of the
-	   child directly.
-	3) The members of the class are created automatically. In the case
-	   of widgets like ButtonBox, the members are added dynamically.
-
-
diff --git a/Demo/tix/bitmaps/about.xpm b/Demo/tix/bitmaps/about.xpm
deleted file mode 100755
index 33ffcc0..0000000
--- a/Demo/tix/bitmaps/about.xpm
+++ /dev/null
@@ -1,50 +0,0 @@
-/* XPM */
-static char * about_xpm[] = {
-"50 40 7 1",
-" 	s None	c None",
-".	c black",
-"X	c white",
-"o	c gray70",
-"O	c navy",
-"+	c red",
-"@	c yellow",
-"                                                  ",
-"                                                  ",
-"                                                  ",
-"        .................................         ",
-"      ..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoo.         ",
-"      .XooooooooooooooooooooooooooooooXo.         ",
-"     .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooXo.         ",
-"     ..oooooooooooooooooooooooooooooooXo.         ",
-"     ...............................XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.++++     ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo+++       ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.Xo+++++       ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.Xo++++++      ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.Xo+++   +     ",
-"     .OOOOO@@@@@OOOOOOOOOOOOOOOOOOO.Xo++.         ",
-"     .OOOOOOO@OOOOO@OOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOO@OOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOO@OOOO@@OOO@OOO@OOOOOOO.XoXo.         ",
-"     .OOOOOOO@OOOOO@OOOO@O@OOOOOOOO.XoXo.         ",
-"     .OOOOOOO@OOOOO@OOOOO@OOOOOOOOO.XoXo.         ",
-"     .OOOOOOO@OOOOO@OOOOO@OOOOOOOOO.XoXo.         ",
-"     .OOOOOOO@OOOOO@OOOO@O@OOOOOOOO.XoXo.         ",
-"     .OOOOOOO@OOOO@@@OO@OOO@OOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.XoXo.         ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.Xo..          ",
-"     .OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.Xo            ",
-"      OOOOOOOOOOOOOOOOOOOOOOOOOOOOO.X.            ",
-"        .............................             ",
-"                                                  ",
-"                                                  ",
-"                                                  "};
diff --git a/Demo/tix/bitmaps/bold.xbm b/Demo/tix/bitmaps/bold.xbm
deleted file mode 100755
index ebff8d1..0000000
--- a/Demo/tix/bitmaps/bold.xbm
+++ /dev/null
@@ -1,6 +0,0 @@
-#define bold_width 16
-#define bold_height 16
-static unsigned char bold_bits[] = {
-   0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xfc, 0x0f, 0x18, 0x1c, 0x18, 0x18,
-   0x18, 0x18, 0x18, 0x1c, 0xf8, 0x0f, 0xf8, 0x0f, 0x18, 0x18, 0x18, 0x30,
-   0x18, 0x30, 0x18, 0x38, 0xfc, 0x3f, 0xfc, 0x1f};
diff --git a/Demo/tix/bitmaps/capital.xbm b/Demo/tix/bitmaps/capital.xbm
deleted file mode 100755
index fb4e070..0000000
--- a/Demo/tix/bitmaps/capital.xbm
+++ /dev/null
@@ -1,6 +0,0 @@
-#define capital_width 16
-#define capital_height 16
-static unsigned char capital_bits[] = {
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x08, 0x30, 0x0c, 0x30, 0x06,
-   0x30, 0x03, 0xb0, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x01, 0xb0, 0x03,
-   0x30, 0x07, 0x30, 0x0e, 0x30, 0x1c, 0x00, 0x00};
diff --git a/Demo/tix/bitmaps/centerj.xbm b/Demo/tix/bitmaps/centerj.xbm
deleted file mode 100755
index 9d2c064..0000000
--- a/Demo/tix/bitmaps/centerj.xbm
+++ /dev/null
@@ -1,6 +0,0 @@
-#define centerj_width 16
-#define centerj_height 16
-static unsigned char centerj_bits[] = {
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3e, 0x00, 0x00, 0xc0, 0x0d,
-   0x00, 0x00, 0x58, 0x77, 0x00, 0x00, 0xb0, 0x3b, 0x00, 0x00, 0xdc, 0xf7,
-   0x00, 0x00, 0xf0, 0x3e, 0x00, 0x00, 0xd8, 0x7e};
diff --git a/Demo/tix/bitmaps/combobox.xbm b/Demo/tix/bitmaps/combobox.xbm
deleted file mode 100755
index f5947f5..0000000
--- a/Demo/tix/bitmaps/combobox.xbm
+++ /dev/null
@@ -1,14 +0,0 @@
-#define combobox_width 32
-#define combobox_height 32
-static unsigned char combobox_bits[] = {
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0xfc, 0xff, 0xff, 0x3e, 0x04, 0x00, 0x80, 0x2a, 0x04, 0x00, 0x80, 0x2a,
-   0x04, 0x00, 0x80, 0x2a, 0x04, 0x00, 0x80, 0x2b, 0xfc, 0xff, 0xff, 0x3e,
-   0x08, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x3e, 0x08, 0x00, 0x00, 0x2a,
-   0x28, 0x49, 0x00, 0x2a, 0x08, 0x00, 0x00, 0x3e, 0x08, 0x00, 0x00, 0x22,
-   0x08, 0x00, 0x00, 0x22, 0x28, 0x49, 0x12, 0x22, 0x08, 0x00, 0x00, 0x22,
-   0x08, 0x00, 0x00, 0x22, 0x08, 0x00, 0x00, 0x22, 0x28, 0x49, 0x02, 0x22,
-   0x08, 0x00, 0x00, 0x3e, 0x08, 0x00, 0x00, 0x2a, 0x08, 0x00, 0x00, 0x2a,
-   0xf8, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
diff --git a/Demo/tix/bitmaps/combobox.xpm b/Demo/tix/bitmaps/combobox.xpm
deleted file mode 100755
index d0234ab..0000000
--- a/Demo/tix/bitmaps/combobox.xpm
+++ /dev/null
@@ -1,49 +0,0 @@
-/* XPM */
-static char * combobox_xpm[] = {
-"50 40 6 1",
-" 	s None	c None",
-".	c black",
-"X	c white",
-"o	c #FFFF80808080",
-"O	c gray70",
-"+	c #808000008080",
-"                                                  ",
-"                                                  ",
-"                                                  ",
-"   ....................................  XXXXXXX  ",
-"   .ooooooooooooooooooooooooooooooooooX  X  .  .  ",
-"   .ooooooooooooooooooooooooooooooooooX  X  .  .  ",
-"   .oooo.oooooooooooooooooooooooooooooX  X  .  .  ",
-"   .oo.o..oo.o.oo.o.ooooooooooooooooooX  X  .  .  ",
-"   .o..o.o.o.oo.oo.oo.ooooooooooooooooX  X ... .  ",
-"   .oo.oo.oo.o.oo.ooo.ooooooooooooooooX  X  .  .  ",
-"   .ooooooooooooooooooooooooooooooooooX  X     .  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  X......  ",
-"                                                  ",
-"                                                  ",
-"                                                  ",
-"   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  ",
-"   X............................................  ",
-"   X.OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.OOOOX.  ",
-"   X.O+OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.OX OX.  ",
-"   X.O++OOO+OO+++OOOOOOOOOOOOOOOOOOOOOOOX.X ..X.  ",
-"   X.O+O+O+OOO+O+OOOOOOOOOOOOOOOOOOOOOOOX.OOOOX.  ",
-"   X.O++OOO+OO+++OOOOOOOOOOOOOOOOOOOOOOOX.OOOOX.  ",
-"   X.OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.XXXXX.  ",
-"   X.O.....X..........................OOX.X  .X.  ",
-"   X.OX...XXX.X.XX.XX.................OOX.X  .X.  ",
-"   X.OX.X..X..X.XX..XX.X..............OOX.X  .X.  ",
-"   X.O.X...X..X.X...X..X..............OOX.X  .X.  ",
-"   X.OOOOOOOOOOOOOOOOOOOOOOOO+OOOOOOOOOOX.X  .X.  ",
-"   X.OOOOOOOOO+OOO+OOOOO+OOOO+OOOOOOOOOOX.X  .X.  ",
-"   X.O+++OO+OO+O+OO++O++OO+OO+OOOOOOOOOOX.X...X.  ",
-"   X.OO+OO++OO+O+OO+OOO+OO+O++OOOOOOOOOOX.OOOOX.  ",
-"   X.OOOOOOOO+OOOOO++OO+OOOOOOOOOOOOOOOOX.OOOOX.  ",
-"   X.OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.X  .X.  ",
-"   X.OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.O .OX.  ",
-"   X.OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOX.OOOOX.  ",
-"   X.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.XXXXX.  ",
-"   X............................................  ",
-"                                                  ",
-"                                                  ",
-"                                                  "};
diff --git a/Demo/tix/bitmaps/combobox.xpm.1 b/Demo/tix/bitmaps/combobox.xpm.1
deleted file mode 100755
index 63792a4..0000000
--- a/Demo/tix/bitmaps/combobox.xpm.1
+++ /dev/null
@@ -1,47 +0,0 @@
-/* XPM */
-static char * combobox_xpm[] = {
-"50 40 4 1",
-" 	s None	c None",
-".	c black",
-"X	c #FFFF80808080",
-"o	c gray70",
-"                                                  ",
-"                                                  ",
-"                                                  ",
-"   ....................................  .......  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .  .  .  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .  .  .  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .  .  .  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .  .  .  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  . ... .  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .  .  .  ",
-"   .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .     .  ",
-"   ....................................  .......  ",
-"                                                  ",
-"   .............................................  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .o...................................o.ooooo.  ",
-"   .o...................................o.ooooo.  ",
-"   .o...................................o.ooooo.  ",
-"   .o...................................o.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .ooooooooooooooooooooooooooooooooooooo.ooooo.  ",
-"   .............................................  ",
-"                                                  ",
-"                                                  ",
-"                                                  ",
-"                                                  ",
-"                                                  "};
diff --git a/Demo/tix/bitmaps/drivea.xbm b/Demo/tix/bitmaps/drivea.xbm
deleted file mode 100755
author	Serhiy Storchaka <storchaka@gmail.com>	2013-01-29 09:07:27 (GMT)
committer	Serhiy Storchaka <storchaka@gmail.com>	2013-01-29 09:07:27 (GMT)
commit	db6add7d7114a1cc86d5d62df7f625a37deee2d4 (patch)
tree	de1660a59904f12938a025ae965fd3391bab3be3 /Python/strdup.c
parent	0ef48f02f2161c035679f85782fd5a0a712e032a (diff)
parent	077cb347a9ecfa5736050292045fb702ede9bed9 (diff)
download	cpython-db6add7d7114a1cc86d5d62df7f625a37deee2d4.zip cpython-db6add7d7114a1cc86d5d62df7f625a37deee2d4.tar.gz cpython-db6add7d7114a1cc86d5d62df7f625a37deee2d4.tar.bz2