Fuck. For PC support, this must be in the distribution.

42 files changed, 6555 insertions, 0 deletions

diff --git a/Lib/dos-8x3/arrayio.py b/Lib/dos-8x3/arrayio.py
new file mode 100755
index 0000000..5b06f92
--- /dev/null
+++ b/Lib/dos-8x3/arrayio.py
@@ -0,0 +1,142 @@
+"""File-like objects that read/write an array buffer.
+
+This implements (nearly) all stdio methods.
+
+f = ArrayIO()       # ready for writing
+f = ArrayIO(buf)    # ready for reading
+f.close()           # explicitly release resources held
+flag = f.isatty()   # always false
+pos = f.tell()      # get current position
+f.seek(pos)         # set current position
+f.seek(pos, mode)   # mode 0: absolute; 1: relative; 2: relative to EOF
+buf = f.read()      # read until EOF
+buf = f.read(n)     # read up to n bytes
+buf = f.readline()  # read until end of line ('\n') or EOF
+list = f.readlines()# list of f.readline() results until EOF
+f.write(buf)        # write at current position
+f.writelines(list)  # for line in list: f.write(line)
+f.getvalue()        # return whole file's contents as a string
+
+Notes:
+- This is very similar to StringIO.  StringIO is faster for reading,
+  but ArrayIO is faster for writing.
+- ArrayIO uses an array object internally, but all its interfaces
+  accept and return strings.
+- Using a real file is often faster (but less convenient).
+- fileno() is left unimplemented so that code which uses it triggers
+  an exception early.
+- Seeking far beyond EOF and then writing will insert real null
+  bytes that occupy space in the buffer.
+- There's a simple test set (see end of this file).
+"""
+
+import string
+from array import array
+
+class ArrayIO:
+	def __init__(self, buf = ''):
+		self.buf = array('c', buf)
+		self.pos = 0
+		self.closed = 0
+		self.softspace = 0
+	def close(self):
+		if not self.closed:
+			self.closed = 1
+			del self.buf, self.pos
+	def isatty(self):
+		return 0
+	def seek(self, pos, mode = 0):
+		if mode == 1:
+			pos = pos + self.pos
+		elif mode == 2:
+			pos = pos + len(self.buf)
+		self.pos = max(0, pos)
+	def tell(self):
+		return self.pos
+	def read(self, n = -1):
+		if n < 0:
+			newpos = len(self.buf)
+		else:
+			newpos = min(self.pos+n, len(self.buf))
+		r = self.buf[self.pos:newpos].tostring()
+		self.pos = newpos
+		return r
+	def readline(self):
+		i = string.find(self.buf[self.pos:].tostring(), '\n')
+		if i < 0:
+			newpos = len(self.buf)
+		else:
+			newpos = self.pos+i+1
+		r = self.buf[self.pos:newpos].tostring()
+		self.pos = newpos
+		return r
+	def readlines(self):
+		lines = string.splitfields(self.read(), '\n')
+		if not lines:
+			return lines
+		for i in range(len(lines)-1):
+			lines[i] = lines[i] + '\n'
+		if not lines[-1]:
+			del lines[-1]
+		return lines
+	def write(self, s):
+		if not s: return
+		a = array('c', s)
+		n = self.pos - len(self.buf)
+		if n > 0:
+			self.buf[len(self.buf):] = array('c', '\0')*n
+		newpos = self.pos + len(a)
+		self.buf[self.pos:newpos] = a
+		self.pos = newpos
+	def writelines(self, list):
+		self.write(string.joinfields(list, ''))
+	def flush(self):
+		pass
+	def getvalue(self):
+		return self.buf.tostring()
+
+
+# A little test suite
+
+def test():
+	import sys
+	if sys.argv[1:]:
+		file = sys.argv[1]
+	else:
+		file = '/etc/passwd'
+	lines = open(file, 'r').readlines()
+	text = open(file, 'r').read()
+	f = ArrayIO()
+	for line in lines[:-2]:
+		f.write(line)
+	f.writelines(lines[-2:])
+	if f.getvalue() != text:
+		raise RuntimeError, 'write failed'
+	length = f.tell()
+	print 'File length =', length
+	f.seek(len(lines[0]))
+	f.write(lines[1])
+	f.seek(0)
+	print 'First line =', `f.readline()`
+	here = f.tell()
+	line = f.readline()
+	print 'Second line =', `line`
+	f.seek(-len(line), 1)
+	line2 = f.read(len(line))
+	if line != line2:
+		raise RuntimeError, 'bad result after seek back'
+	f.seek(len(line2), 1)
+	list = f.readlines()
+	line = list[-1]
+	f.seek(f.tell() - len(line))
+	line2 = f.read()
+	if line != line2:
+		raise RuntimeError, 'bad result after seek back from EOF'
+	print 'Read', len(list), 'more lines'
+	print 'File length =', f.tell()
+	if f.tell() != length:
+		raise RuntimeError, 'bad length'
+	f.close()
+
+if __name__ == '__main__':
+	test()
diff --git a/Lib/dos-8x3/ast.py b/Lib/dos-8x3/ast.py
new file mode 100755
index 0000000..6f92bee
--- /dev/null
+++ b/Lib/dos-8x3/ast.py
@@ -0,0 +1,224 @@
+"""Object-oriented interface to the parser module.
+
+This module exports three classes which together provide an interface
+to the parser module.  Together, the three classes represent two ways
+to create parsed representations of Python source and the two starting
+data types (source text and tuple representations).  Each class
+provides interfaces which are identical other than the constructors.
+The constructors are described in detail in the documentation for each
+class and the remaining, shared portion of the interface is documented
+below.  Briefly, the three classes provided are:
+
+AST
+    Defines the primary interface to the AST objects and supports creation
+    from the tuple representation of the parse tree.
+
+ExpressionAST
+    Supports creation of expression constructs from source text.
+
+SuiteAST
+    Supports creation of statement suites from source text.
+
+FileSuiteAST
+    Convenience subclass of the `SuiteAST' class; loads source text of the
+    suite from an external file.
+
+Aside from the constructors, several methods are provided to allow
+access to the various interpretations of the parse tree and to check
+conditions of the construct represented by the parse tree.
+
+ast()
+    Returns the corresponding `parser.ASTType' object.
+
+code()
+    Returns the compiled code object.
+
+filename()
+    Returns the name of the associated source file, if known.
+
+isExpression()
+    Returns true value if parse tree represents an expression, or a false
+    value otherwise.
+
+isSuite()
+    Returns true value if parse tree represents a suite of statements, or
+    a false value otherwise.
+
+text()
+    Returns the source text, or None if not available.
+
+tuple()
+    Returns the tuple representing the parse tree.
+"""
+
+__version__ = '$Revision$'
+__copyright__ = """Copyright (c) 1995, 1996 by Fred L. Drake, Jr.
+
+This software may be used and distributed freely for any purpose provided
+that this notice is included unchanged on any and all copies.  The author
+does not warrant or guarantee this software in any way.
+"""
+
+class AST:
+    """Base class for Abstract Syntax Tree objects.
+
+    Creates an Abstract Syntax Tree based on the tuple representation
+    of the parse tree.  The parse tree can represent either an
+    expression or a suite; which will be recognized automatically.
+    This base class provides all of the query methods for subclass
+    objects defined in this module.
+    """
+    _p = __import__('parser')		# import internally to avoid
+					# namespace pollution at the
+					# top level
+    _text = None
+    _code = None
+    _ast  = None
+    _type = 'unknown'
+    _tupl = None
+
+    def __init__(self, tuple):
+	"""Create an `AST' instance from a tuple-tree representation.
+
+	tuple
+	    The tuple tree to convert.
+
+	The tuple-tree may represent either an expression or a suite; the
+	type will be determined automatically.
+	"""
+	if type(tuple) is not type(()):
+	    raise TypeError, 'Base AST class requires tuple parameter.'
+
+	self._tupl = tuple
+	self._ast  = self._p.tuple2ast(tuple)
+	self._type = (self._p.isexpr(self._ast) and 'expression') or 'suite'
+
+    def tuple(self):
+	"""Returns the tuple representing the parse tree.
+	"""
+	if self._tupl is None:
+	    self._tupl = self._p.ast2tuple(self._ast)
+	return self._tupl
+
+    def code(self):
+	"""Returns the compiled code object.
+
+	The code object returned by this method may be passed to the
+	exec statement if `AST.isSuite()' is true or to the eval()
+	function if `AST.isExpression()' is true.  All the usual rules
+	regarding execution of code objects apply.
+	"""
+	if not self._code:
+	    self._code = self._p.compileast(self._ast)
+	return self._code
+
+    def ast(self):
+	"""Returns the corresponding `parser.ASTType' object.
+	"""
+	return self._ast
+
+    def filename(self):
+	"""Returns the name of the source file if known, or None.
+	"""
+	return None
+
+    def text(self):
+	"""Returns the source text, or None if not available.
+
+	If the instance is of class `AST', None is returned since no
+	source text is available.  If of class `ExpressionAST' or
+	`SuiteAST', the source text passed to the constructor is
+	returned.
+	"""
+	return self._text
+
+    def isSuite(self):
+	"""Determine if `AST' instance represents a suite of statements.
+	"""
+	return self._type == 'suite'
+
+    def isExpression(self):
+	"""Determine if `AST' instance represents an expression.
+	"""
+	return self._type == 'expression'
+
+
+
+class SuiteAST(AST):
+    """Statement suite parse tree representation.
+
+    This subclass of the `AST' base class represents statement suites
+    parsed from the source text of a Python suite.  If the source text
+    does not represent a parsable suite of statements, the appropriate
+    exception is raised by the parser.
+    """
+    _type = 'suite'
+
+    def __init__(self, text):
+	"""Initialize a `SuiteAST' from source text.
+
+	text
+	    Source text to parse.
+	"""
+	if type(text) is not type(''):
+	    raise TypeError, 'SuiteAST requires source text parameter.'
+	self._text = text
+	self._ast  = self._p.suite(text)
+
+    def isSuite(self):
+	return 1
+
+    def isExpression(self):
+	return 0
+
+
+class FileSuiteAST(SuiteAST):
+    """Representation of a python source file syntax tree.
+
+    This provides a convenience wrapper around the `SuiteAST' class to
+    load the source text from an external file.
+    """
+    def __init__(self, fileName):
+	"""Initialize a `SuiteAST' from a source file.
+
+	fileName
+	    Name of the external source file.
+	"""
+	self._fileName = fileName
+	SuiteAST.__init__(self, open(fileName).read())
+
+    def filename(self):
+	return self._fileName
+
+
+
+class ExpressionAST(AST):
+    """Expression parse tree representation.
+
+    This subclass of the `AST' base class represents expression
+    constructs parsed from the source text of a Python expression.  If
+    the source text does not represent a parsable expression, the
+    appropriate exception is raised by the Python parser.
+    """
+    _type = 'expression'
+
+    def __init__(self, text):
+	"""Initialize an expression AST from source text.
+
+	text
+	    Source text to parse.
+	"""
+	if type(text) is not type(''):
+	    raise TypeError, 'ExpressionAST requires source text parameter.'
+	self._text = text
+	self._ast  = self._p.expr(text)
+
+    def isSuite(self):
+	return 0
+
+    def isExpression(self):
+	return 1
+
+
+#
+#  end of file
diff --git a/Lib/dos-8x3/basehttp.py b/Lib/dos-8x3/basehttp.py
new file mode 100755
index 0000000..281ddf6
--- /dev/null
+++ b/Lib/dos-8x3/basehttp.py
@@ -0,0 +1,482 @@
+"""HTTP server base class.
+
+Note: the class in this module doesn't implement any HTTP request; see
+SimpleHTTPServer for simple implementations of GET, HEAD and POST
+(including CGI scripts).
+
+Contents:
+
+- BaseHTTPRequestHandler: HTTP request handler base class
+- test: test function
+
+XXX To do:
+
+- send server version
+- log requests even later (to capture byte count)
+- log user-agent header and other interesting goodies
+- send error log to separate file
+- are request names really case sensitive?
+
+"""
+
+
+# See also:
+#
+# HTTP Working Group                                        T. Berners-Lee
+# INTERNET-DRAFT                                            R. T. Fielding
+# <draft-ietf-http-v10-spec-00.txt>                     H. Frystyk Nielsen
+# Expires September 8, 1995                                  March 8, 1995
+#
+# URL: http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-v10-spec-00.txt
+
+
+# Log files
+# ---------
+# 
+# Here's a quote from the NCSA httpd docs about log file format.
+# 
+# | The logfile format is as follows. Each line consists of: 
+# | 
+# | host rfc931 authuser [DD/Mon/YYYY:hh:mm:ss] "request" ddd bbbb 
+# | 
+# |        host: Either the DNS name or the IP number of the remote client 
+# |        rfc931: Any information returned by identd for this person,
+# |                - otherwise. 
+# |        authuser: If user sent a userid for authentication, the user name,
+# |                  - otherwise. 
+# |        DD: Day 
+# |        Mon: Month (calendar name) 
+# |        YYYY: Year 
+# |        hh: hour (24-hour format, the machine's timezone) 
+# |        mm: minutes 
+# |        ss: seconds 
+# |        request: The first line of the HTTP request as sent by the client. 
+# |        ddd: the status code returned by the server, - if not available. 
+# |        bbbb: the total number of bytes sent,
+# |              *not including the HTTP/1.0 header*, - if not available 
+# | 
+# | You can determine the name of the file accessed through request.
+# 
+# (Actually, the latter is only true if you know the server configuration
+# at the time the request was made!)
+
+
+__version__ = "0.2"
+
+
+import sys
+import time
+import socket # For gethostbyaddr()
+import string
+import rfc822
+import mimetools
+import SocketServer
+
+# Default error message
+DEFAULT_ERROR_MESSAGE = """\
+<head>
+<title>Error response</title>
+</head>
+<body>
+<h1>Error response</h1>
+<p>Error code %(code)d.
+<p>Message: %(message)s.
+<p>Error code explanation: %(code)s = %(explain)s.
+</body>
+"""
+
+
+class HTTPServer(SocketServer.TCPServer):
+
+    def server_bind(self):
+	"""Override server_bind to store the server name."""
+	SocketServer.TCPServer.server_bind(self)
+	host, port = self.socket.getsockname()
+	if not host or host == '0.0.0.0':
+	    host = socket.gethostname()
+	hostname, hostnames, hostaddrs = socket.gethostbyaddr(host)
+	if '.' not in hostname:
+	    for host in hostnames:
+		if '.' in host:
+		    hostname = host
+		    break
+	self.server_name = hostname
+	self.server_port = port
+
+
+class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
+
+    """HTTP request handler base class.
+
+    The following explanation of HTTP serves to guide you through the
+    code as well as to expose any misunderstandings I may have about
+    HTTP (so you don't need to read the code to figure out I'm wrong
+    :-).
+
+    HTTP (HyperText Transfer Protocol) is an extensible protocol on
+    top of a reliable stream transport (e.g. TCP/IP).  The protocol
+    recognizes three parts to a request:
+
+    1. One line identifying the request type and path
+    2. An optional set of RFC-822-style headers
+    3. An optional data part
+
+    The headers and data are separated by a blank line.
+
+    The first line of the request has the form
+
+    <command> <path> <version>
+
+    where <command> is a (case-sensitive) keyword such as GET or POST,
+    <path> is a string containing path information for the request,
+    and <version> should be the string "HTTP/1.0".  <path> is encoded
+    using the URL encoding scheme (using %xx to signify the ASCII
+    character with hex code xx).
+
+    The protocol is vague about whether lines are separated by LF
+    characters or by CRLF pairs -- for compatibility with the widest
+    range of clients, both should be accepted.  Similarly, whitespace
+    in the request line should be treated sensibly (allowing multiple
+    spaces between components and allowing trailing whitespace).
+
+    Similarly, for output, lines ought to be separated by CRLF pairs
+    but most clients grok LF characters just fine.
+
+    If the first line of the request has the form
+
+    <command> <path>
+
+    (i.e. <version> is left out) then this is assumed to be an HTTP
+    0.9 request; this form has no optional headers and data part and
+    the reply consists of just the data.
+
+    The reply form of the HTTP 1.0 protocol again has three parts:
+
+    1. One line giving the response code
+    2. An optional set of RFC-822-style headers
+    3. The data
+
+    Again, the headers and data are separated by a blank line.
+
+    The response code line has the form
+
+    <version> <responsecode> <responsestring>
+
+    where <version> is the protocol version (always "HTTP/1.0"),
+    <responsecode> is a 3-digit response code indicating success or
+    failure of the request, and <responsestring> is an optional
+    human-readable string explaining what the response code means.
+
+    This server parses the request and the headers, and then calls a
+    function specific to the request type (<command>).  Specifically,
+    a request SPAM will be handled by a method handle_SPAM().  If no
+    such method exists the server sends an error response to the
+    client.  If it exists, it is called with no arguments:
+
+    do_SPAM()
+
+    Note that the request name is case sensitive (i.e. SPAM and spam
+    are different requests).
+
+    The various request details are stored in instance variables:
+
+    - client_address is the client IP address in the form (host,
+    port);
+
+    - command, path and version are the broken-down request line;
+
+    - headers is an instance of mimetools.Message (or a derived
+    class) containing the header information;
+
+    - rfile is a file object open for reading positioned at the
+    start of the optional input data part;
+
+    - wfile is a file object open for writing.
+
+    IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!
+
+    The first thing to be written must be the response line.  Then
+    follow 0 or more header lines, then a blank line, and then the
+    actual data (if any).  The meaning of the header lines depends on
+    the command executed by the server; in most cases, when data is
+    returned, there should be at least one header line of the form
+
+    Content-type: <type>/<subtype>
+
+    where <type> and <subtype> should be registered MIME types,
+    e.g. "text/html" or "text/plain".
+
+    """
+
+    # The Python system version, truncated to its first component.
+    sys_version = "Python/" + string.split(sys.version)[0]
+
+    # The server software version.  You may want to override this.
+    # The format is multiple whitespace-separated strings,
+    # where each string is of the form name[/version].
+    server_version = "BaseHTTP/" + __version__
+
+    def handle(self):
+	"""Handle a single HTTP request.
+
+	You normally don't need to override this method; see the class
+	__doc__ string for information on how to handle specific HTTP
+	commands such as GET and POST.
+
+	"""
+
+	self.raw_requestline = self.rfile.readline()
+	self.request_version = version = "HTTP/0.9" # Default
+	requestline = self.raw_requestline
+	if requestline[-2:] == '\r\n':
+	    requestline = requestline[:-2]
+	elif requestline[-1:] == '\n':
+	    requestline = requestline[:-1]
+	self.requestline = requestline
+	words = string.split(requestline)
+	if len(words) == 3:
+	    [command, path, version] = words
+	    if version != self.protocol_version:
+		self.send_error(400, "Bad request version (%s)" % `version`)
+		return
+	elif len(words) == 2:
+	    [command, path] = words
+	    if command != 'GET':
+		self.send_error(400,
+				"Bad HTTP/0.9 request type (%s)" % `command`)
+		return
+	else:
+	    self.send_error(400, "Bad request syntax (%s)" % `requestline`)
+	    return
+	self.command, self.path, self.request_version = command, path, version
+	self.headers = self.MessageClass(self.rfile, 0)
+	mname = 'do_' + command
+	if not hasattr(self, mname):
+	    self.send_error(501, "Unsupported method (%s)" % `mname`)
+	    return
+	method = getattr(self, mname)
+	method()
+
+    def send_error(self, code, message=None):
+	"""Send and log an error reply.
+
+	Arguments are the error code, and a detailed message.
+	The detailed message defaults to the short entry matching the
+	response code.
+
+	This sends an error response (so it must be called before any
+	output has been generated), logs the error, and finally sends
+	a piece of HTML explaining the error to the user.
+
+	"""
+
+	try:
+	    short, long = self.responses[code]
+	except KeyError:
+	    short, long = '???', '???'
+	if not message:
+	    message = short
+	explain = long
+	self.log_error("code %d, message %s", code, message)
+	self.send_response(code, message)
+	self.end_headers()
+	self.wfile.write(self.error_message_format %
+			 {'code': code,
+			  'message': message,
+			  'explain': explain})
+
+    error_message_format = DEFAULT_ERROR_MESSAGE
+
+    def send_response(self, code, message=None):
+	"""Send the response header and log the response code.
+
+	Also send two standard headers with the server software
+	version and the current date.
+
+	"""
+	self.log_request(code)
+	if message is None:
+	    if self.responses.has_key(code):
+		message = self.responses[code][1]
+	    else:
+		message = ''
+	if self.request_version != 'HTTP/0.9':
+	    self.wfile.write("%s %s %s\r\n" %
+			     (self.protocol_version, str(code), message))
+	self.send_header('Server', self.version_string())
+	self.send_header('Date', self.date_time_string())
+
+    def send_header(self, keyword, value):
+	"""Send a MIME header."""
+	if self.request_version != 'HTTP/0.9':
+	    self.wfile.write("%s: %s\r\n" % (keyword, value))
+
+    def end_headers(self):
+	"""Send the blank line ending the MIME headers."""
+	if self.request_version != 'HTTP/0.9':
+	    self.wfile.write("\r\n")
+
+    def log_request(self, code='-', size='-'):
+	"""Log an accepted request.
+
+	This is called by send_reponse().
+
+	"""
+
+	self.log_message('"%s" %s %s',
+			 self.requestline, str(code), str(size))
+
+    def log_error(self, *args):
+	"""Log an error.
+
+	This is called when a request cannot be fulfilled.  By
+	default it passes the message on to log_message().
+
+	Arguments are the same as for log_message().
+
+	XXX This should go to the separate error log.
+
+	"""
+
+	apply(self.log_message, args)
+
+    def log_message(self, format, *args):
+	"""Log an arbitrary message.
+
+	This is used by all other logging functions.  Override
+	it if you have specific logging wishes.
+
+	The first argument, FORMAT, is a format string for the
+	message to be logged.  If the format string contains
+	any % escapes requiring parameters, they should be
+	specified as subsequent arguments (it's just like
+	printf!).
+
+	The client host and current date/time are prefixed to
+	every message.
+
+	"""
+
+	sys.stderr.write("%s - - [%s] %s\n" %
+			 (self.address_string(),
+			  self.log_date_time_string(),
+			  format%args))
+
+    def version_string(self):
+	"""Return the server software version string."""
+	return self.server_version + ' ' + self.sys_version
+
+    def date_time_string(self):
+	"""Return the current date and time formatted for a message header."""
+	now = time.time()
+	year, month, day, hh, mm, ss, wd, y, z = time.gmtime(now)
+	s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
+		self.weekdayname[wd],
+		day, self.monthname[month], year,
+		hh, mm, ss)
+	return s
+
+    def log_date_time_string(self):
+	"""Return the current time formatted for logging."""
+	now = time.time()
+	year, month, day, hh, mm, ss, x, y, z = time.localtime(now)
+	s = "%02d/%3s/%04d %02d:%02d:%02d" % (
+		day, self.monthname[month], year, hh, mm, ss)
+	return s
+
+    weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+    monthname = [None,
+		 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+		 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+    def address_string(self):
+	"""Return the client address formatted for logging.
+
+	This version looks up the full hostname using gethostbyaddr(),
+	and tries to find a name that contains at least one dot.
+
+	"""
+
+	(host, port) = self.client_address
+	try:
+	    name, names, addresses = socket.gethostbyaddr(host)
+	except socket.error, msg:
+	    return host
+	names.insert(0, name)
+	for name in names:
+	    if '.' in name: return name
+	return names[0]
+
+
+    # Essentially static class variables
+
+    # The version of the HTTP protocol we support.
+    # Don't override unless you know what you're doing (hint: incoming
+    # requests are required to have exactly this version string).
+    protocol_version = "HTTP/1.0"
+
+    # The Message-like class used to parse headers
+    MessageClass = mimetools.Message
+
+    # Table mapping response codes to messages; entries have the
+    # form {code: (shortmessage, longmessage)}.
+    # See http://www.w3.org/hypertext/WWW/Protocols/HTTP/HTRESP.html
+    responses = {
+	200: ('OK', 'Request fulfilled, document follows'),
+	201: ('Created', 'Document created, URL follows'),
+	202: ('Accepted',
+	      'Request accepted, processing continues off-line'),
+	203: ('Partial information', 'Request fulfilled from cache'),
+	204: ('No response', 'Request fulfilled, nothing follows'),
+	
+	301: ('Moved', 'Object moved permanently -- see URI list'),
+	302: ('Found', 'Object moved temporarily -- see URI list'),
+	303: ('Method', 'Object moved -- see Method and URL list'),
+	304: ('Not modified',
+	      'Document has not changed singe given time'),
+	
+	400: ('Bad request',
+	      'Bad request syntax or unsupported method'),
+	401: ('Unauthorized',
+	      'No permission -- see authorization schemes'),
+	402: ('Payment required',
+	      'No payment -- see charging schemes'),
+	403: ('Forbidden',
+	      'Request forbidden -- authorization will not help'),
+	404: ('Not found', 'Nothing matches the given URI'),
+	
+	500: ('Internal error', 'Server got itself in trouble'),
+	501: ('Not implemented',
+	      'Server does not support this operation'),
+	502: ('Service temporarily overloaded',
+	      'The server cannot process the request due to a high load'),
+	503: ('Gateway timeout',
+	      'The gateway server did not receive a timely response'),
+	
+	}
+
+
+def test(HandlerClass = BaseHTTPRequestHandler,
+	 ServerClass = HTTPServer):
+    """Test the HTTP request handler class.
+
+    This runs an HTTP server on port 8000 (or the first command line
+    argument).
+
+    """
+
+    if sys.argv[1:]:
+	port = string.atoi(sys.argv[1])
+    else:
+	port = 8000
+    server_address = ('', port)
+
+    httpd = ServerClass(server_address, HandlerClass)
+
+    print "Serving HTTP on port", port, "..."
+    httpd.serve_forever()
+
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/dos-8x3/bastion.py b/Lib/dos-8x3/bastion.py
new file mode 100755
index 0000000..7ddd93e
--- /dev/null
+++ b/Lib/dos-8x3/bastion.py
@@ -0,0 +1,162 @@
+"""Bastionification utility.
+
+A bastion (for another object -- the 'original') is an object that has
+the same methods as the original but does not give access to its
+instance variables.  Bastions have a number of uses, but the most
+obvious one is to provide code executing in restricted mode with a
+safe interface to an object implemented in unrestricted mode.
+
+The bastionification routine has an optional second argument which is
+a filter function.  Only those methods for which the filter method
+(called with the method name as argument) returns true are accessible.
+The default filter method returns true unless the method name begins
+with an underscore.
+
+There are a number of possible implementations of bastions.  We use a
+'lazy' approach where the bastion's __getattr__() discipline does all
+the work for a particular method the first time it is used.  This is
+usually fastest, especially if the user doesn't call all available
+methods.  The retrieved methods are stored as instance variables of
+the bastion, so the overhead is only occurred on the first use of each
+method.
+
+Detail: the bastion class has a __repr__() discipline which includes
+the repr() of the original object.  This is precomputed when the
+bastion is created.
+
+"""
+
+__version__ = '$Revision$'
+# $Source$
+
+
+from types import MethodType
+
+
+class BastionClass:
+
+    """Helper class used by the Bastion() function.
+
+    You could subclass this and pass the subclass as the bastionclass
+    argument to the Bastion() function, as long as the constructor has
+    the same signature (a get() function and a name for the object).
+
+    """
+
+    def __init__(self, get, name):
+	"""Constructor.
+
+	Arguments:
+
+	get - a function that gets the attribute value (by name)
+	name - a human-readable name for the original object
+	       (suggestion: use repr(object))
+
+	"""
+	self._get_ = get
+	self._name_ = name
+
+    def __repr__(self):
+	"""Return a representation string.
+
+	This includes the name passed in to the constructor, so that
+	if you print the bastion during debugging, at least you have
+	some idea of what it is.
+
+	"""
+	return "<Bastion for %s>" % self._name_
+
+    def __getattr__(self, name):
+	"""Get an as-yet undefined attribute value.
+
+	This calls the get() function that was passed to the
+	constructor.  The result is stored as an instance variable so
+	that the next time the same attribute is requested,
+	__getattr__() won't be invoked.
+
+	If the get() function raises an exception, this is simply
+	passed on -- exceptions are not cached.
+
+	"""
+	attribute = self._get_(name)
+	self.__dict__[name] = attribute
+	return attribute
+
+
+def Bastion(object, filter = lambda name: name[:1] != '_',
+	    name=None, bastionclass=BastionClass):
+    """Create a bastion for an object, using an optional filter.
+
+    See the Bastion module's documentation for background.
+
+    Arguments:
+
+    object - the original object
+    filter - a predicate that decides whether a function name is OK;
+             by default all names are OK that don't start with '_'
+    name - the name of the object; default repr(object)
+    bastionclass - class used to create the bastion; default BastionClass
+
+    """
+
+    # Note: we define *two* ad-hoc functions here, get1 and get2.
+    # Both are intended to be called in the same way: get(name).
+    # It is clear that the real work (getting the attribute
+    # from the object and calling the filter) is done in get1.
+    # Why can't we pass get1 to the bastion?  Because the user
+    # would be able to override the filter argument!  With get2,
+    # overriding the default argument is no security loophole:
+    # all it does is call it.
+    # Also notice that we can't place the object and filter as
+    # instance variables on the bastion object itself, since
+    # the user has full access to all instance variables!
+
+    def get1(name, object=object, filter=filter):
+	"""Internal function for Bastion().  See source comments."""
+	if filter(name):
+	    attribute = getattr(object, name)
+	    if type(attribute) == MethodType:
+		return attribute
+	raise AttributeError, name
+
+    def get2(name, get1=get1):
+	"""Internal function for Bastion().  See source comments."""
+	return get1(name)
+
+    if name is None:
+	name = `object`
+    return bastionclass(get2, name)
+
+
+def _test():
+    """Test the Bastion() function."""
+    class Original:
+	def __init__(self):
+	    self.sum = 0
+	def add(self, n):
+	    self._add(n)
+	def _add(self, n):
+	    self.sum = self.sum + n
+	def total(self):
+	    return self.sum
+    o = Original()
+    b = Bastion(o)
+    b.add(81)
+    b.add(18)
+    print "b.total() =", b.total()
+    try:
+	print "b.sum =", b.sum,
+    except:
+	print "inaccessible"
+    else:
+	print "accessible"
+    try:
+	print "b._add =", b._add,
+    except:
+	print "inaccessible"
+    else:
+	print "accessible"
+
+
+if __name__ == '__main__':
+    _test()
diff --git a/Lib/dos-8x3/cgihttps.py b/Lib/dos-8x3/cgihttps.py
new file mode 100755
index 0000000..837f7c2
--- /dev/null
+++ b/Lib/dos-8x3/cgihttps.py
@@ -0,0 +1,203 @@
+"""CGI-savvy HTTP Server.
+
+This module builds on SimpleHTTPServer by implementing GET and POST
+requests to cgi-bin scripts.
+
+"""
+
+
+__version__ = "0.3"
+
+
+import os
+import sys
+import time
+import socket
+import string
+import urllib
+import BaseHTTPServer
+import SimpleHTTPServer
+
+
+class CGIHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
+
+    """Complete HTTP server with GET, HEAD and POST commands.
+
+    GET and HEAD also support running CGI scripts.
+
+    The POST command is *only* implemented for CGI scripts.
+
+    """
+
+    def do_POST(self):
+	"""Serve a POST request.
+
+	This is only implemented for CGI scripts.
+
+	"""
+
+	if self.is_cgi():
+	    self.run_cgi()
+	else:
+	    self.send_error(501, "Can only POST to CGI scripts")
+
+    def send_head(self):
+	"""Version of send_head that support CGI scripts"""
+	if self.is_cgi():
+	    return self.run_cgi()
+	else:
+	    return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
+
+    def is_cgi(self):
+	"""test whether PATH corresponds to a CGI script.
+
+	Return a tuple (dir, rest) if PATH requires running a
+	CGI script, None if not.  Note that rest begins with a
+	slash if it is not empty.
+
+	The default implementation tests whether the path
+	begins with one of the strings in the list
+	self.cgi_directories (and the next character is a '/'
+	or the end of the string).
+
+	"""
+
+	path = self.path
+
+	for x in self.cgi_directories:
+	    i = len(x)
+	    if path[:i] == x and (not path[i:] or path[i] == '/'):
+		self.cgi_info = path[:i], path[i+1:]
+		return 1
+	return 0
+
+    cgi_directories = ['/cgi-bin', '/htbin']
+
+    def run_cgi(self):
+	"""Execute a CGI script."""
+	dir, rest = self.cgi_info
+	i = string.rfind(rest, '?')
+	if i >= 0:
+	    rest, query = rest[:i], rest[i+1:]
+	else:
+	    query = ''
+	i = string.find(rest, '/')
+	if i >= 0:
+	    script, rest = rest[:i], rest[i:]
+	else:
+	    script, rest = rest, ''
+	scriptname = dir + '/' + script
+	scriptfile = self.translate_path(scriptname)
+	if not os.path.exists(scriptfile):
+	    self.send_error(404, "No such CGI script (%s)" % `scriptname`)
+	    return
+	if not os.path.isfile(scriptfile):
+	    self.send_error(403, "CGI script is not a plain file (%s)" %
+			    `scriptname`)
+	    return
+	if not executable(scriptfile):
+	    self.send_error(403, "CGI script is not executable (%s)" %
+			    `scriptname`)
+	    return
+	nobody = nobody_uid()
+	self.send_response(200, "Script output follows")
+	self.wfile.flush() # Always flush before forking
+	pid = os.fork()
+	if pid != 0:
+	    # Parent
+	    pid, sts = os.waitpid(pid, 0)
+	    if sts:
+		self.log_error("CGI script exit status x%x" % sts)
+	    return
+	# Child
+	try:
+	    # Reference: http://hoohoo.ncsa.uiuc.edu/cgi/env.html
+	    # XXX Much of the following could be prepared ahead of time!
+	    env = {}
+	    env['SERVER_SOFTWARE'] = self.version_string()
+	    env['SERVER_NAME'] = self.server.server_name
+	    env['GATEWAY_INTERFACE'] = 'CGI/1.1'
+	    env['SERVER_PROTOCOL'] = self.protocol_version
+	    env['SERVER_PORT'] = str(self.server.server_port)
+	    env['REQUEST_METHOD'] = self.command
+	    uqrest = urllib.unquote(rest)
+	    env['PATH_INFO'] = uqrest
+	    env['PATH_TRANSLATED'] = self.translate_path(uqrest)
+	    env['SCRIPT_NAME'] = scriptname
+	    if query:
+		env['QUERY_STRING'] = query
+	    host = self.address_string()
+	    if host != self.client_address[0]:
+		env['REMOTE_HOST'] = host
+	    env['REMOTE_ADDR'] = self.client_address[0]
+	    # AUTH_TYPE
+	    # REMOTE_USER
+	    # REMOTE_IDENT
+	    env['CONTENT_TYPE'] = self.headers.type
+	    length = self.headers.getheader('content-length')
+	    if length:
+		env['CONTENT_LENGTH'] = length
+	    accept = []
+	    for line in self.headers.getallmatchingheaders('accept'):
+		if line[:1] in string.whitespace:
+		    accept.append(string.strip(line))
+		else:
+		    accept = accept + string.split(line[7:])
+	    env['HTTP_ACCEPT'] = string.joinfields(accept, ',')
+	    ua = self.headers.getheader('user-agent')
+	    if ua:
+		env['HTTP_USER_AGENT'] = ua
+	    # XXX Other HTTP_* headers
+	    import regsub
+	    decoded_query = regsub.gsub('+', ' ', query)
+	    try:
+		os.setuid(nobody)
+	    except os.error:
+		pass
+	    os.dup2(self.rfile.fileno(), 0)
+	    os.dup2(self.wfile.fileno(), 1)
+	    print scriptfile, script, decoded_query
+	    os.execve(scriptfile,
+		      [script, decoded_query],
+		      env)
+	except:
+	    self.server.handle_error(self.request, self.client_address)
+	    os._exit(127)
+
+
+nobody = None
+
+def nobody_uid():
+    """Internal routine to get nobody's uid"""
+    global nobody
+    if nobody:
+	return nobody
+    import pwd
+    try:
+	nobody = pwd.getpwnam('nobody')[2]
+    except pwd.error:
+	nobody = 1 + max(map(lambda x: x[2], pwd.getpwall()))
+    return nobody
+
+
+def executable(path):
+    """Test for executable file."""
+    try:
+	st = os.stat(path)
+    except os.error:
+	return 0
+    return st[0] & 0111 != 0
+
+
+def test(HandlerClass = CGIHTTPRequestHandler,
+	 ServerClass = BaseHTTPServer.HTTPServer):
+    import sys
+    if sys.argv[1:2] == ['-r']:
+	db = MyArchive()
+	db.regenindices()
+	return
+    SimpleHTTPServer.test(HandlerClass, ServerClass)
+
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/dos-8x3/compilea.py b/Lib/dos-8x3/compilea.py
new file mode 100755
index 0000000..3120284
--- /dev/null
+++ b/Lib/dos-8x3/compilea.py
@@ -0,0 +1,70 @@
+# Routines to force "compilation" of all .py files in a directory
+# tree or on sys.path.  By default recursion is pruned at a depth of
+# 10 and the current directory, if it occurs in sys.path, is skipped.
+# When called as a script, compiles argument directories, or sys.path
+# if no arguments.
+# After a similar module by Sjoerd Mullender.
+
+import os
+import sys
+import py_compile
+
+def compile_dir(dir, maxlevels = 10):
+	print 'Listing', dir, '...'
+	try:
+		names = os.listdir(dir)
+	except os.error:
+		print "Can't list", dir
+		names = []
+	names.sort()
+	for name in names:
+		fullname = os.path.join(dir, name)
+		if os.path.isfile(fullname):
+			head, tail = name[:-3], name[-3:]
+			if tail == '.py':
+				print 'Compiling', fullname, '...'
+				try:
+					py_compile.compile(fullname)
+				except KeyboardInterrupt:
+					del names[:]
+					print '\n[interrupt]'
+					break
+				except:
+					if type(sys.exc_type) == type(''):
+						exc_type_name = sys.exc_type
+					else: exc_type_name = sys.exc_type.__name__
+					print 'Sorry:', exc_type_name + ':',
+					print sys.exc_value
+		elif maxlevels > 0 and \
+		     name != os.curdir and name != os.pardir and \
+		     os.path.isdir(fullname) and \
+		     not os.path.islink(fullname):
+			compile_dir(fullname, maxlevels - 1)
+
+def compile_path(skip_curdir = 1):
+	for dir in sys.path:
+		if dir == os.curdir and skip_curdir:
+			print 'Skipping current directory'
+		else:
+			compile_dir(dir, 0)
+
+def main():
+	import getopt
+	try:
+		opts, args = getopt.getopt(sys.argv[1:], 'l')
+	except getopt.error, msg:
+		print msg
+		print "usage: compileall [-l] [directory ...]"
+		print "-l: don't recurse down"
+		print "if no arguments, -l sys.path is assumed"
+	maxlevels = 10
+	for o, a in opts:
+		if o == '-l': maxlevels = 0
+	if args:
+		for dir in sys.argv[1:]:
+			compile_dir(dir, maxlevels)
+	else:
+		compile_path()
+
+if __name__ == '__main__':
+	main()
diff --git a/Lib/dos-8x3/complex.py b/Lib/dos-8x3/complex.py
new file mode 100755
index 0000000..f4892f3
--- /dev/null
+++ b/Lib/dos-8x3/complex.py
@@ -0,0 +1,275 @@
+# Complex numbers
+# ---------------
+
+# 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)
+# Polar([r [,phi [,fullcircle]]]) ->
+#	the complex number z for which r == z.radius() and phi == z.angle(fullcircle)
+#	(r and phi default to 0)
+#
+# 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)
+# long(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.
+# (I suppose it would be easy to implement a cmath module.)
+#
+# 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 types, math
+
+if not hasattr(math, 'hypot'):
+	def hypot(x, y):
+		# XXX I know there's a way to compute this without possibly causing
+		# overflow, but I can't remember what it is right now...
+		return math.sqrt(x*x + y*y)
+	math.hypot = hypot
+
+twopi = math.pi*2.0
+halfpi = math.pi/2.0
+
+def IsComplex(obj):
+	return hasattr(obj, 're') and hasattr(obj, 'im')
+
+def Polar(r = 0, phi = 0, fullcircle = twopi):
+	phi = phi * (twopi / fullcircle)
+	return Complex(math.cos(phi)*r, math.sin(phi)*r)
+
+class Complex:
+
+	def __init__(self, re=0, im=0):
+		if IsComplex(re):
+			im = im + re.im
+			re = re.re
+		if IsComplex(im):
+			re = re - im.im
+			im = im.re
+		self.re = re
+		self.im = im
+
+	def __setattr__(self, name, value):
+		if hasattr(self, name):
+			raise TypeError, "Complex numbers have set-once attributes"
+		self.__dict__[name] = value
+
+	def __repr__(self):
+		if not self.im:
+			return 'Complex(%s)' % `self.re`
+		else:
+			return 'Complex(%s, %s)' % (`self.re`, `self.im`)
+
+	def __str__(self):
+		if not self.im:
+			return `self.re`
+		else:
+			return 'Complex(%s, %s)' % (`self.re`, `self.im`)
+
+	def __coerce__(self, other):
+		if IsComplex(other):
+			return self, other
+		return self, Complex(other)	# May fail
+
+	def __cmp__(self, other):
+		return cmp(self.re, other.re) or cmp(self.im, other.im)
+
+	def __hash__(self):
+		if not self.im: return hash(self.re)
+		mod = sys.maxint + 1L
+		return int((hash(self.re) + 2L*hash(self.im) + mod) % (2L*mod) - mod)
+
+	def __neg__(self):
+		return Complex(-self.re, -self.im)
+
+	def __pos__(self):
+		return self
+
+	def __abs__(self):
+		return math.hypot(self.re, self.im)
+		##return math.sqrt(self.re*self.re + self.im*self.im)
+
+
+	def __int__(self):
+		if self.im:
+			raise ValueError, "can't convert Complex with nonzero im to int"
+		return int(self.re)
+
+	def __long__(self):
+		if self.im:
+			raise ValueError, "can't convert Complex with nonzero im to long"
+		return long(self.re)
+
+	def __float__(self):
+		if self.im:
+			raise ValueError, "can't convert Complex with nonzero im to float"
+		return float(self.re)
+
+	def __nonzero__(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):
+		return Complex(self.re + other.re, self.im + other.im)
+
+	__radd__ = __add__
+
+	def __sub__(self, other):
+		return Complex(self.re - other.re, self.im - other.im)
+
+	def __rsub__(self, other):
+		return Complex(other.re - self.re, other.im - self.im)
+
+	def __mul__(self, 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):
+		# Deviating from the general principle of not forcing re or im
+		# to be floats, we cast to float here, otherwise division
+		# of Complex numbers with integer re and im parts would use
+		# the (truncating) integer division
+		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):
+		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: raise TypeError, 'Complex to the Complex power'
+			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):
+		return pow(base, self)
+
+
+# Everything below this point is part of the test suite
+
+def checkop(expr, a, b, value, fuzz = 1e-6):
+	import sys
+	print '       ', a, 'and', b,
+	try:
+		result = eval(expr)
+	except:
+		result = sys.exc_type
+	print '->', result
+	if (type(result) == type('') or type(value) == type('')):
+		ok = result == value
+	else:
+		ok = abs(result - value) <= fuzz
+	if not ok:
+		print '!!\t!!\t!! should be', value, 'diff', abs(result - value)
+
+
+def test():
+	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), 'TypeError'),
+			(Complex(0,10), 1, Complex(0,10)),
+			(Complex(0,10), Complex(1), Complex(0,10)),
+			(Complex(1), Complex(0,10), 'TypeError'),
+			(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),
+		],
+	}
+	exprs = testsuite.keys()
+	exprs.sort()
+	for expr in exprs:
+		print expr + ':'
+		t = (expr,)
+		for item in testsuite[expr]:
+			apply(checkop, t+item)
+	
+
+if __name__ == '__main__':
+	test()
diff --git a/Lib/dos-8x3/formatte.py b/Lib/dos-8x3/formatte.py
new file mode 100755
index 0000000..0266379
--- /dev/null
+++ b/Lib/dos-8x3/formatte.py
@@ -0,0 +1,399 @@
+import regex
+import regsub
+import string
+import sys
+from types import StringType
+
+
+AS_IS = None
+
+
+class NullFormatter:
+
+    def __init__(self): pass
+    def end_paragraph(self, blankline): pass
+    def add_line_break(self): pass
+    def add_hor_rule(self, abswidth=None, percentwidth=1.0,
+		     height=None, align=None): pass
+    def add_label_data(self, format, counter): pass
+    def add_flowing_data(self, data): pass
+    def add_literal_data(self, data): pass
+    def flush_softspace(self): pass
+    def push_alignment(self, align): pass
+    def pop_alignment(self): pass
+    def push_font(self, x): pass
+    def pop_font(self): pass
+    def push_margin(self, margin): pass
+    def pop_margin(self): pass
+    def set_spacing(self, spacing): pass
+    def push_style(self, *styles): pass
+    def pop_style(self, n=1): pass
+    def assert_line_data(self, flag=1): pass
+
+
+class AbstractFormatter:
+
+    def __init__(self, writer):
+	self.writer = writer		# Output device
+	self.align = None		# Current alignment
+	self.align_stack = []		# Alignment stack
+	self.font_stack = []		# Font state
+	self.margin_stack = []		# Margin state
+	self.spacing = None		# Vertical spacing state
+	self.style_stack = []		# Other state, e.g. color
+	self.nospace = 1		# Should leading space be suppressed
+	self.softspace = 0		# Should a space be inserted
+	self.para_end = 1		# Just ended a paragraph
+	self.parskip = 0		# Skipped space between paragraphs?
+	self.hard_break = 1		# Have a hard break
+	self.have_label = 0
+
+    def end_paragraph(self, blankline):
+	if not self.hard_break:
+	    self.writer.send_line_break()
+	    self.have_label = 0
+	if self.parskip < blankline and not self.have_label:
+	    self.writer.send_paragraph(blankline - self.parskip)
+	    self.parskip = blankline
+	    self.have_label = 0
+	self.hard_break = self.nospace = self.para_end = 1
+	self.softspace = 0
+
+    def add_line_break(self):
+	if not (self.hard_break or self.para_end):
+	    self.writer.send_line_break()
+	    self.have_label = self.parskip = 0
+	self.hard_break = self.nospace = 1
+	self.softspace = 0
+
+    def add_hor_rule(self, *args, **kw):
+	if not self.hard_break:
+	    self.writer.send_line_break()
+	apply(self.writer.send_hor_rule, args, kw)
+	self.hard_break = self.nospace = 1
+	self.have_label = self.para_end = self.softspace = self.parskip = 0
+
+    def add_label_data(self, format, counter, blankline = None):
+	if self.have_label or not self.hard_break:
+	    self.writer.send_line_break()
+	if not self.para_end:
+	    self.writer.send_paragraph((blankline and 1) or 0)
+	if type(format) is StringType:
+	    self.writer.send_label_data(self.format_counter(format, counter))
+	else:
+	    self.writer.send_label_data(format)
+	self.nospace = self.have_label = self.hard_break = self.para_end = 1
+	self.softspace = self.parskip = 0
+
+    def format_counter(self, format, counter):
+        label = ''
+        for c in format:
+            try:
+                if c == '1':
+		    label = label + ('%d' % counter)
+                elif c in 'aA':
+		    if counter > 0:
+			label = label + self.format_letter(c, counter)
+                elif c in 'iI':
+		    if counter > 0:
+			label = label + self.format_roman(c, counter)
+		else:
+		    label = label + c
+            except:
+                label = label + c
+        return label
+
+    def format_letter(self, case, counter):
+	label = ''
+	while counter > 0:
+	    counter, x = divmod(counter-1, 26)
+	    s = chr(ord(case) + x)
+	    label = s + label
+	return label
+
+    def format_roman(self, case, counter):
+        ones = ['i', 'x', 'c', 'm']
+        fives = ['v', 'l', 'd']
+        label, index = '', 0
+	# This will die of IndexError when counter is too big
+        while counter > 0:
+            counter, x = divmod(counter, 10)
+            if x == 9:
+                label = ones[index] + ones[index+1] + label
+            elif x == 4:
+                label = ones[index] + fives[index] + label
+            else:
+                if x >= 5:
+                    s = fives[index]
+                    x = x-5
+                else:
+                    s = ''
+                s = s + ones[index]*x
+		label = s + label
+            index = index + 1
+        if case == 'I':
+	    return string.upper(label)
+        return label
+
+    def add_flowing_data(self, data,
+			 # These are only here to load them into locals:
+			 whitespace = string.whitespace,
+			 join = string.join, split = string.split):
+	if not data: return
+	# The following looks a bit convoluted but is a great improvement over
+	# data = regsub.gsub('[' + string.whitespace + ']+', ' ', data)
+	prespace = data[:1] in whitespace
+	postspace = data[-1:] in whitespace
+	data = join(split(data))
+	if self.nospace and not data:
+	    return
+	elif prespace or self.softspace:
+	    if not data:
+		if not self.nospace:
+		    self.softspace = 1
+		    self.parskip = 0
+		return
+	    if not self.nospace:
+		data = ' ' + data
+	self.hard_break = self.nospace = self.para_end = \
+			  self.parskip = self.have_label = 0
+	self.softspace = postspace
+	self.writer.send_flowing_data(data)
+
+    def add_literal_data(self, data):
+	if not data: return
+	#  Caller is expected to cause flush_softspace() if needed.
+	self.hard_break = data[-1:] == '\n'
+	self.nospace = self.para_end = self.softspace = \
+		       self.parskip = self.have_label = 0
+	self.writer.send_literal_data(data)
+
+    def flush_softspace(self):
+	if self.softspace:
+	    self.hard_break = self.nospace = self.para_end = self.parskip = \
+			      self.have_label = self.softspace = 0
+	    self.writer.send_flowing_data(' ')
+
+    def push_alignment(self, align):
+	if align and align != self.align:
+	    self.writer.new_alignment(align)
+	    self.align = align
+	    self.align_stack.append(align)
+	else:
+	    self.align_stack.append(self.align)
+
+    def pop_alignment(self):
+	if self.align_stack:
+	    del self.align_stack[-1]
+	if self.align_stack:
+	    self.align = align = self.align_stack[-1]
+	    self.writer.new_alignment(align)
+	else:
+	    self.align = None
+	    self.writer.new_alignment(None)
+
+    def push_font(self, (size, i, b, tt)):
+	if self.softspace:
+	    self.hard_break = self.nospace = self.para_end = self.softspace = 0
+	    self.writer.send_flowing_data(' ')
+	if self.font_stack:
+	    csize, ci, cb, ctt = self.font_stack[-1]
+	    if size is AS_IS: size = csize
+	    if i is AS_IS: i = ci
+	    if b is AS_IS: b = cb
+	    if tt is AS_IS: tt = ctt
+	font = (size, i, b, tt)
+	self.font_stack.append(font)
+	self.writer.new_font(font)
+
+    def pop_font(self):
+	if self.softspace:
+	    self.hard_break = self.nospace = self.para_end = self.softspace = 0
+	    self.writer.send_flowing_data(' ')
+	if self.font_stack:
+	    del self.font_stack[-1]
+	if self.font_stack:
+	    font = self.font_stack[-1]
+	else:
+	    font = None
+	self.writer.new_font(font)
+
+    def push_margin(self, margin):
+	self.margin_stack.append(margin)
+	fstack = filter(None, self.margin_stack)
+	if not margin and fstack:
+	    margin = fstack[-1]
+	self.writer.new_margin(margin, len(fstack))
+
+    def pop_margin(self):
+	if self.margin_stack:
+	    del self.margin_stack[-1]
+	fstack = filter(None, self.margin_stack)
+	if fstack:
+	    margin = fstack[-1]
+	else:
+	    margin = None
+	self.writer.new_margin(margin, len(fstack))
+
+    def set_spacing(self, spacing):
+	self.spacing = spacing
+	self.writer.new_spacing(spacing)
+
+    def push_style(self, *styles):
+	if self.softspace:
+	    self.hard_break = self.nospace = self.para_end = self.softspace = 0
+	    self.writer.send_flowing_data(' ')
+	for style in styles:
+	    self.style_stack.append(style)
+	self.writer.new_styles(tuple(self.style_stack))
+
+    def pop_style(self, n=1):
+	if self.softspace:
+	    self.hard_break = self.nospace = self.para_end = self.softspace = 0
+	    self.writer.send_flowing_data(' ')
+	del self.style_stack[-n:]
+	self.writer.new_styles(tuple(self.style_stack))
+
+    def assert_line_data(self, flag=1):
+	self.nospace = self.hard_break = not flag
+	self.para_end = self.have_label = 0
+
+
+class NullWriter:
+    """Minimal writer interface to use in testing.
+    """
+    def __init__(self): pass
+    def new_alignment(self, align): pass
+    def new_font(self, font): pass
+    def new_margin(self, margin, level): pass
+    def new_spacing(self, spacing): pass
+    def new_styles(self, styles): pass
+    def send_paragraph(self, blankline): pass
+    def send_line_break(self): pass
+    def send_hor_rule(self, *args, **kw): pass
+    def send_label_data(self, data): pass
+    def send_flowing_data(self, data): pass
+    def send_literal_data(self, data): pass
+
+
+class AbstractWriter(NullWriter):
+
+    def __init__(self):
+	pass
+
+    def new_alignment(self, align):
+	print "new_alignment(%s)" % `align`
+
+    def new_font(self, font):
+	print "new_font(%s)" % `font`
+
+    def new_margin(self, margin, level):
+	print "new_margin(%s, %d)" % (`margin`, level)
+
+    def new_spacing(self, spacing):
+	print "new_spacing(%s)" % `spacing`
+
+    def new_styles(self, styles):
+	print "new_styles(%s)" % `styles`
+
+    def send_paragraph(self, blankline):
+	print "send_paragraph(%s)" % `blankline`
+
+    def send_line_break(self):
+	print "send_line_break()"
+
+    def send_hor_rule(self, *args, **kw):
+	print "send_hor_rule()"
+
+    def send_label_data(self, data):
+	print "send_label_data(%s)" % `data`
+
+    def send_flowing_data(self, data):
+	print "send_flowing_data(%s)" % `data`
+
+    def send_literal_data(self, data):
+	print "send_literal_data(%s)" % `data`
+
+
+class DumbWriter(NullWriter):
+
+    def __init__(self, file=None, maxcol=72):
+	self.file = file or sys.stdout
+	self.maxcol = maxcol
+	NullWriter.__init__(self)
+	self.reset()
+
+    def reset(self):
+	self.col = 0
+	self.atbreak = 0
+
+    def send_paragraph(self, blankline):
+	self.file.write('\n' + '\n'*blankline)
+	self.col = 0
+	self.atbreak = 0
+
+    def send_line_break(self):
+	self.file.write('\n')
+	self.col = 0
+	self.atbreak = 0
+
+    def send_hor_rule(self, *args, **kw):
+	self.file.write('\n')
+	self.file.write('-'*self.maxcol)
+	self.file.write('\n')
+	self.col = 0
+	self.atbreak = 0
+
+    def send_literal_data(self, data):
+	self.file.write(data)
+	i = string.rfind(data, '\n')
+	if i >= 0:
+	    self.col = 0
+	    data = data[i+1:]
+	data = string.expandtabs(data)
+	self.col = self.col + len(data)
+	self.atbreak = 0
+
+    def send_flowing_data(self, data):
+	if not data: return
+	atbreak = self.atbreak or data[0] in string.whitespace
+	col = self.col
+	maxcol = self.maxcol
+	write = self.file.write
+	for word in string.split(data):
+	    if atbreak:
+		if col + len(word) >= maxcol:
+		    write('\n')
+		    col = 0
+		else:
+		    write(' ')
+		    col = col + 1
+	    write(word)
+	    col = col + len(word)
+	    atbreak = 1
+	self.col = col
+	self.atbreak = data[-1] in string.whitespace
+
+
+def test(file = None):
+    w = DumbWriter()
+    f = AbstractFormatter(w)
+    if file:
+	fp = open(file)
+    elif sys.argv[1:]:
+	fp = open(sys.argv[1])
+    else:
+	fp = sys.stdin
+    while 1:
+	line = fp.readline()
+	if not line:
+	    break
+	if line == '\n':
+	    f.end_paragraph(1)
+	else:
+	    f.add_flowing_data(line)
+    f.end_paragraph(0)
+
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/dos-8x3/gopherli.py b/Lib/dos-8x3/gopherli.py
new file mode 100755
index 0000000..cf06e95
--- /dev/null
+++ b/Lib/dos-8x3/gopherli.py
@@ -0,0 +1,191 @@
+# Gopher protocol client interface
+
+import string
+
+# Default selector, host and port
+DEF_SELECTOR = '1/'
+DEF_HOST     = 'gopher.micro.umn.edu'
+DEF_PORT     = 70
+
+# Recognized file types
+A_TEXT       = '0'
+A_MENU       = '1'
+A_CSO        = '2'
+A_ERROR      = '3'
+A_MACBINHEX  = '4'
+A_PCBINHEX   = '5'
+A_UUENCODED  = '6'
+A_INDEX      = '7'
+A_TELNET     = '8'
+A_BINARY     = '9'
+A_DUPLICATE  = '+'
+A_SOUND      = 's'
+A_EVENT      = 'e'
+A_CALENDAR   = 'c'
+A_HTML       = 'h'
+A_TN3270     = 'T'
+A_MIME       = 'M'
+A_IMAGE      = 'I'
+A_WHOIS      = 'w'
+A_QUERY      = 'q'
+A_GIF        = 'g'
+A_HTML       = 'h'			# HTML file
+A_WWW        = 'w'			# WWW address
+A_PLUS_IMAGE = ':'
+A_PLUS_MOVIE = ';'
+A_PLUS_SOUND = '<'
+
+
+# Function mapping all file types to strings; unknown types become TYPE='x'
+_names = dir()
+_type_to_name_map = None
+def type_to_name(gtype):
+	global _type_to_name_map
+	if not _type_to_name_map:
+		for name in _names:
+			if name[:2] == 'A_':
+				_type_to_name_map[eval(name)] = name[2:]
+	if _type_to_name_map.has_key(gtype):
+		return _type_to_name_map[gtype]
+	return 'TYPE=' + `gtype`
+
+# Names for characters and strings
+CRLF = '\r\n'
+TAB = '\t'
+
+# Send a selector to a given host and port, return a file with the reply
+def send_selector(selector, host, port = 0):
+	import socket
+	import string
+	if not port:
+		i = string.find(host, ':')
+		if i >= 0:
+			host, port = host[:i], string.atoi(host[i+1:])
+	if not port:
+		port = DEF_PORT
+	elif type(port) == type(''):
+		port = string.atoi(port)
+	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+	s.connect(host, port)
+	s.send(selector + CRLF)
+	s.shutdown(1)
+	return s.makefile('rb')
+
+# Send a selector and a query string
+def send_query(selector, query, host, port = 0):
+	return send_selector(selector + '\t' + query, host, port)
+
+# The following functions interpret the data returned by the gopher
+# server according to the expected type, e.g. textfile or directory
+
+# Get a directory in the form of a list of entries
+def get_directory(f):
+	import string
+	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
+		gtype = line[0]
+		parts = string.splitfields(line[1:], TAB)
+		if len(parts) < 4:
+			print '(Bad line from server:', `line`, ')'
+			continue
+		if len(parts) > 4:
+			if parts[4:] != ['+']:
+			    print '(Extra info from server:', parts[4:], ')'
+		else:
+			parts.append('')
+		parts.insert(0, gtype)
+		list.append(parts)
+	return list
+
+# Get a text file as a list of lines, with trailing CRLF stripped
+def get_textfile(f):
+	list = []
+	get_alt_textfile(f, list.append)
+	return list
+
+# Get a text file and pass each line to a function, with trailing CRLF stripped
+def get_alt_textfile(f, func):
+	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)
+
+# Get a binary file as one solid data block
+def get_binary(f):
+	data = f.read()
+	return data
+
+# Get a binary file and pass each block to a function
+def get_alt_binary(f, func, blocksize):
+	while 1:
+		data = f.read(blocksize)
+		if not data:
+			break
+		func(data)
+
+# Trivial test program
+def test():
+	import sys
+	import getopt
+	opts, args = getopt.getopt(sys.argv[1:], '')
+	selector = DEF_SELECTOR
+	type = selector[0]
+	host = DEF_HOST
+	port = DEF_PORT
+	if args:
+		host = args[0]
+		args = args[1:]
+	if args:
+		type = args[0]
+		args = args[1:]
+		if len(type) > 1:
+			type, selector = type[0], type
+		else:
+			selector = ''
+			if args:
+				selector = args[0]
+				args = args[1:]
+		query = ''
+		if args:
+			query = args[0]
+			args = args[1:]
+	if type == A_INDEX:
+		f = send_query(selector, query, host)
+	else:
+		f = send_selector(selector, host)
+	if type == A_TEXT:
+		list = get_textfile(f)
+		for item in list: print item
+	elif type in (A_MENU, A_INDEX):
+		list = get_directory(f)
+		for item in list: print item
+	else:
+		data = get_binary(f)
+		print 'binary data:', len(data), 'bytes:', `data[:100]`[:40]
+
+# Run the test when run as script
+if __name__ == '__main__':
+	test()
diff --git a/Lib/dos-8x3/htmlenti.py b/Lib/dos-8x3/htmlenti.py
new file mode 100755
index 0000000..55aefaa
--- /dev/null
+++ b/Lib/dos-8x3/htmlenti.py
@@ -0,0 +1,105 @@
+# Proposed entity definitions for HTML, taken from
+# http://www.w3.org/hypertext/WWW/MarkUp/html-spec/html-spec_14.html
+
+entitydefs = {
+    'lt':       '<',
+    'gt':       '>',
+    'amp':      '&',
+    'quot':	'"',
+    'nbsp':	chr(160),	# no-break space
+    'iexcl':	chr(161),	# inverted exclamation mark
+    'cent':	chr(162),	# cent sign
+    'pound':	chr(163),	# pound sterling sign
+    'curren':	chr(164),	# general currency sign
+    'yen':	chr(165),	# yen sign
+    'brvbar':	chr(166),	# broken (vertical) bar
+    'sect':	chr(167),	# section sign
+    'uml':	chr(168),	# umlaut (dieresis)
+    'copy':	chr(169),	# copyright sign
+    'ordf':	chr(170),	# ordinal indicator, feminine
+    'laquo':	chr(171),	# angle quotation mark, left
+    'not':	chr(172),	# not sign
+    'shy':	chr(173),	# soft hyphen
+    'reg':	chr(174),	# registered sign
+    'macr':	chr(175),	# macron
+    'deg':	chr(176),	# degree sign
+    'plusmn':	chr(177),	# plus-or-minus sign
+    'sup2':	chr(178),	# superscript two
+    'sup3':	chr(179),	# superscript three
+    'acute':	chr(180),	# acute accent
+    'micro':	chr(181),	# micro sign
+    'para':	chr(182),	# pilcrow (paragraph sign)
+    'middot':	chr(183),	# middle dot
+    'cedil':	chr(184),	# cedilla
+    'sup1':	chr(185),	# superscript one
+    'ordm':	chr(186),	# ordinal indicator, masculine
+    'raquo':	chr(187),	# angle quotation mark, right
+    'frac14':	chr(188),	# fraction one-quarter
+    'frac12':	chr(189),	# fraction one-half
+    'frac34':	chr(190),	# fraction three-quarters
+    'iquest':	chr(191),	# inverted question mark
+    'Agrave':	chr(192),	# capital A, grave accent
+    'Aacute':	chr(193),	# capital A, acute accent
+    'Acirc':	chr(194),	# capital A, circumflex accent
+    'Atilde':	chr(195),	# capital A, tilde
+    'Auml':	chr(196),	# capital A, dieresis or umlaut mark
+    'Aring':	chr(197),	# capital A, ring
+    'AElig':	chr(198),	# capital AE diphthong (ligature)
+    'Ccedil':	chr(199),	# capital C, cedilla
+    'Egrave':	chr(200),	# capital E, grave accent
+    'Eacute':	chr(201),	# capital E, acute accent
+    'Ecirc':	chr(202),	# capital E, circumflex accent
+    'Euml':	chr(203),	# capital E, dieresis or umlaut mark
+    'Igrave':	chr(204),	# capital I, grave accent
+    'Iacute':	chr(205),	# capital I, acute accent
+    'Icirc':	chr(206),	# capital I, circumflex accent
+    'Iuml':	chr(207),	# capital I, dieresis or umlaut mark
+    'ETH':	chr(208),	# capital Eth, Icelandic
+    'Ntilde':	chr(209),	# capital N, tilde
+    'Ograve':	chr(210),	# capital O, grave accent
+    'Oacute':	chr(211),	# capital O, acute accent
+    'Ocirc':	chr(212),	# capital O, circumflex accent
+    'Otilde':	chr(213),	# capital O, tilde
+    'Ouml':	chr(214),	# capital O, dieresis or umlaut mark
+    'times':	chr(215),	# multiply sign
+    'Oslash':	chr(216),	# capital O, slash
+    'Ugrave':	chr(217),	# capital U, grave accent
+    'Uacute':	chr(218),	# capital U, acute accent
+    'Ucirc':	chr(219),	# capital U, circumflex accent
+    'Uuml':	chr(220),	# capital U, dieresis or umlaut mark
+    'Yacute':	chr(221),	# capital Y, acute accent
+    'THORN':	chr(222),	# capital THORN, Icelandic
+    'szlig':	chr(223),	# small sharp s, German (sz ligature)
+    'agrave':	chr(224),	# small a, grave accent
+    'aacute':	chr(225),	# small a, acute accent
+    'acirc':	chr(226),	# small a, circumflex accent
+    'atilde':	chr(227),	# small a, tilde
+    'auml':	chr(228),	# small a, dieresis or umlaut mark
+    'aring':	chr(229),	# small a, ring
+    'aelig':	chr(230),	# small ae diphthong (ligature)
+    'ccedil':	chr(231),	# small c, cedilla
+    'egrave':	chr(232),	# small e, grave accent
+    'eacute':	chr(233),	# small e, acute accent
+    'ecirc':	chr(234),	# small e, circumflex accent
+    'euml':	chr(235),	# small e, dieresis or umlaut mark
+    'igrave':	chr(236),	# small i, grave accent
+    'iacute':	chr(237),	# small i, acute accent
+    'icirc':	chr(238),	# small i, circumflex accent
+    'iuml':	chr(239),	# small i, dieresis or umlaut mark
+    'eth':	chr(240),	# small eth, Icelandic
+    'ntilde':	chr(241),	# small n, tilde
+    'ograve':	chr(242),	# small o, grave accent
+    'oacute':	chr(243),	# small o, acute accent
+    'ocirc':	chr(244),	# small o, circumflex accent
+    'otilde':	chr(245),	# small o, tilde
+    'ouml':	chr(246),	# small o, dieresis or umlaut mark
+    'divide':	chr(247),	# divide sign
+    'oslash':	chr(248),	# small o, slash
+    'ugrave':	chr(249),	# small u, grave accent
+    'uacute':	chr(250),	# small u, acute accent
+    'ucirc':	chr(251),	# small u, circumflex accent
+    'uuml':	chr(252),	# small u, dieresis or umlaut mark
+    'yacute':	chr(253),	# small y, acute accent
+    'thorn':	chr(254),	# small thorn, Icelandic
+    'yuml':	chr(255),	# small y, dieresis or umlaut mark
+}
diff --git a/Lib/dos-8x3/importal.py b/Lib/dos-8x3/importal.py
new file mode 100755
index 0000000..780862c
--- /dev/null
+++ b/Lib/dos-8x3/importal.py
@@ -0,0 +1,36 @@
+# THIS IS OBSOLETE -- USE MODULE 'compileall' INSTEAD!
+
+# Utility module to import all modules in the path, in the hope
+# that this will update their ".pyc" files.
+
+import os
+import sys
+
+# Sabotage 'gl' and 'stdwin' to prevent windows popping up...
+for m in 'gl', 'stdwin', 'fl', 'fm':
+	sys.modules[m] = sys
+
+exceptions = ['importall']
+
+for dir in sys.path:
+	print 'Listing', dir
+	try:
+		names = os.listdir(dir)
+	except os.error:
+		print 'Can\'t list', dir
+		names = []
+	names.sort()
+	for name in names:
+		head, tail = name[:-3], name[-3:]
+		if tail == '.py' and head not in exceptions:
+			s = 'import ' + head
+			print s
+			try:
+				exec s + '\n'
+			except KeyboardInterrupt:
+				del names[:]
+				print '\n[interrupt]'
+				break
+			except:
+				print 'Sorry:', sys.exc_type + ':',
+				print sys.exc_value
diff --git a/Lib/dos-8x3/linecach.py b/Lib/dos-8x3/linecach.py
new file mode 100755
index 0000000..7de373f
--- /dev/null
+++ b/Lib/dos-8x3/linecach.py
@@ -0,0 +1,90 @@
+# Cache lines from files.
+# This is intended to read lines from modules imported -- hence if a filename
+# is not found, it will look down the module search path for a file by
+# that name.
+
+import sys
+import os
+from stat import *
+
+def getline(filename, lineno):
+	lines = getlines(filename)
+	if 1 <= lineno <= len(lines):
+		return lines[lineno-1]
+	else:
+		return ''
+
+
+# The cache
+
+cache = {} # The cache
+
+
+# Clear the cache entirely
+
+def clearcache():
+	global cache
+	cache = {}
+
+
+# Get the lines for a file from the cache.
+# Update the cache if it doesn't contain an entry for this file already.
+
+def getlines(filename):
+	if cache.has_key(filename):
+		return cache[filename][2]
+	else:
+		return updatecache(filename)
+
+
+# Discard cache entries that are out of date.
+# (This is not checked upon each call!)
+
+def checkcache():
+	for filename in cache.keys():
+		size, mtime, lines, fullname = cache[filename]
+		try:
+			stat = os.stat(fullname)
+		except os.error:
+			del cache[filename]
+			continue
+		if size <> stat[ST_SIZE] or mtime <> stat[ST_MTIME]:
+			del cache[filename]
+
+
+# Update a cache entry and return its list of lines.
+# If something's wrong, print a message, discard the cache entry,
+# and return an empty list.
+
+def updatecache(filename):
+	if cache.has_key(filename):
+		del cache[filename]
+	if not filename or filename[0] + filename[-1] == '<>':
+		return []
+	fullname = filename
+	try:
+		stat = os.stat(fullname)
+	except os.error, msg:
+		# Try looking through the module search path
+		basename = os.path.split(filename)[1]
+		for dirname in sys.path:
+			fullname = os.path.join(dirname, basename)
+			try:
+				stat = os.stat(fullname)
+				break
+			except os.error:
+				pass
+		else:
+			# No luck
+##			print '*** Cannot stat', filename, ':', msg
+			return []
+	try:
+		fp = open(fullname, 'r')
+		lines = fp.readlines()
+		fp.close()
+	except IOError, msg:
+##		print '*** Cannot open', fullname, ':', msg
+		return []
+	size, mtime = stat[ST_SIZE], stat[ST_MTIME]
+	cache[filename] = size, mtime, lines, fullname
+	return lines
diff --git a/Lib/dos-8x3/macurl2p.py b/Lib/dos-8x3/macurl2p.py
new file mode 100755
index 0000000..65afe69
--- /dev/null
+++ b/Lib/dos-8x3/macurl2p.py
@@ -0,0 +1,76 @@
+"""Mac specific module for conversion between pathnames and URLs."""
+
+import string
+import urllib
+import os
+
+def url2pathname(pathname):
+    "Convert /-delimited pathname to mac pathname"
+    #
+    # XXXX The .. handling should be fixed...
+    #
+    tp = urllib.splittype(pathname)[0]
+    if tp and tp <> 'file':
+	raise RuntimeError, 'Cannot convert non-local URL to pathname'
+    components = string.split(pathname, '/')
+    # Remove . and embedded ..
+    i = 0
+    while i < len(components):
+	if components[i] == '.':
+	    del components[i]
+	elif components[i] == '..' and i > 0 and \
+				  components[i-1] not in ('', '..'):
+	    del components[i-1:i+1]
+	    i = i-1
+	elif components[i] == '' and i > 0 and components[i-1] <> '':
+	    del components[i]
+	else:
+	    i = i+1
+    if not components[0]:
+	# Absolute unix path, don't start with colon
+	return string.join(components[1:], ':')
+    else:
+	# relative unix path, start with colon. First replace
+	# leading .. by empty strings (giving ::file)
+	i = 0
+	while i < len(components) and components[i] == '..':
+	    components[i] = ''
+	    i = i + 1
+	return ':' + string.join(components, ':')
+
+def pathname2url(pathname):
+    "convert mac pathname to /-delimited pathname"
+    if '/' in pathname:
+	raise RuntimeError, "Cannot convert pathname containing slashes"
+    components = string.split(pathname, ':')
+    # Replace empty string ('::') by .. (will result in '/../' later)
+    for i in range(1, len(components)):
+	if components[i] == '':
+	    components[i] = '..'
+    # Truncate names longer than 31 bytes
+    components = map(lambda x: x[:31], components)
+
+    if os.path.isabs(pathname):
+	return '/' + string.join(components, '/')
+    else:
+	return string.join(components, '/')
+
+def test():
+    for url in ["index.html",
+		"bar/index.html",
+		"/foo/bar/index.html",
+		"/foo/bar/",
+		"/"]:
+	print `url`, '->', `url2pathname(url)`
+    for path in ["drive:",
+		 "drive:dir:",
+		 "drive:dir:file",
+		 "drive:file",
+		 "file",
+		 ":file",
+		 ":dir:",
+		 ":dir:file"]:
+	print `path`, '->', `pathname2url(path)`
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/dos-8x3/mimetool.py b/Lib/dos-8x3/mimetool.py
new file mode 100755
index 0000000..da33a77
--- /dev/null
+++ b/Lib/dos-8x3/mimetool.py
@@ -0,0 +1,187 @@
+# Various tools used by MIME-reading or MIME-writing programs.
+
+
+import os
+import rfc822
+import string
+import tempfile
+
+
+# A derived class of rfc822.Message that knows about MIME headers and
+# contains some hooks for decoding encoded and multipart messages.
+
+class Message(rfc822.Message):
+
+	def __init__(self, fp, seekable = 1):
+		rfc822.Message.__init__(self, fp, seekable)
+		self.encodingheader = \
+			self.getheader('content-transfer-encoding')
+		self.typeheader = \
+			self.getheader('content-type')
+		self.parsetype()
+		self.parseplist()
+
+	def parsetype(self):
+		str = self.typeheader
+		if str == None:
+			str = 'text/plain'
+		if ';' in str:
+			i = string.index(str, ';')
+			self.plisttext = str[i:]
+			str = str[:i]
+		else:
+			self.plisttext = ''
+		fields = string.splitfields(str, '/')
+		for i in range(len(fields)):
+			fields[i] = string.lower(string.strip(fields[i]))
+		self.type = string.joinfields(fields, '/')
+		self.maintype = fields[0]
+		self.subtype = string.joinfields(fields[1:], '/')
+
+	def parseplist(self):
+		str = self.plisttext
+		self.plist = []
+		while str[:1] == ';':
+			str = str[1:]
+			if ';' in str:
+				# XXX Should parse quotes!
+				end = string.index(str, ';')
+			else:
+				end = len(str)
+			f = str[:end]
+			if '=' in f:
+				i = string.index(f, '=')
+				f = string.lower(string.strip(f[:i])) + \
+					'=' + string.strip(f[i+1:])
+			self.plist.append(string.strip(f))
+			str = str[end:]
+
+	def getplist(self):
+		return self.plist
+
+	def getparam(self, name):
+		name = string.lower(name) + '='
+		n = len(name)
+		for p in self.plist:
+			if p[:n] == name:
+				return rfc822.unquote(p[n:])
+		return None
+
+	def getencoding(self):
+		if self.encodingheader == None:
+			return '7bit'
+		return string.lower(self.encodingheader)
+
+	def gettype(self):
+		return self.type
+
+	def getmaintype(self):
+		return self.maintype
+
+	def getsubtype(self):
+		return self.subtype
+
+
+
+
+# Utility functions
+# -----------------
+
+
+# Return a random string usable as a multipart boundary.
+# The method used is so that it is *very* unlikely that the same
+# string of characters will every occur again in the Universe,
+# so the caller needn't check the data it is packing for the
+# occurrence of the boundary.
+#
+# The boundary contains dots so you have to quote it in the header.
+
+_prefix = None
+
+def choose_boundary():
+	global _prefix
+	import time
+	import rand
+	if _prefix == None:
+		import socket
+		import os
+		hostid = socket.gethostbyname(socket.gethostname())
+		uid = `os.getuid()`
+		pid = `os.getpid()`
+		seed = `rand.rand()`
+		_prefix = hostid + '.' + uid + '.' + pid
+	timestamp = `int(time.time())`
+	seed = `rand.rand()`
+	return _prefix + '.' + timestamp + '.' + seed
+
+
+# Subroutines for decoding some common content-transfer-types
+
+# XXX This requires that uudecode and mmencode are in $PATH
+
+def decode(input, output, encoding):
+	if decodetab.has_key(encoding):
+		pipethrough(input, decodetab[encoding], output)
+	else:
+		raise ValueError, \
+		      'unknown Content-Transfer-Encoding: %s' % encoding
+
+def encode(input, output, encoding):
+	if encodetab.has_key(encoding):
+		pipethrough(input, encodetab[encoding], output)
+	else:
+		raise ValueError, \
+		      'unknown Content-Transfer-Encoding: %s' % encoding
+
+uudecode_pipe = '''(
+TEMP=/tmp/@uu.$$
+sed "s%^begin [0-7][0-7]* .*%begin 600 $TEMP%" | uudecode
+cat $TEMP
+rm $TEMP
+)'''
+
+decodetab = {
+	'uuencode':		uudecode_pipe,
+	'x-uuencode':		uudecode_pipe,
+	'quoted-printable':	'mmencode -u -q',
+	'base64':		'mmencode -u -b',
+}
+
+encodetab = {
+	'x-uuencode':		'uuencode tempfile',
+	'uuencode':		'uuencode tempfile',
+	'quoted-printable':	'mmencode -q',
+	'base64':		'mmencode -b',
+}
+
+def pipeto(input, command):
+	pipe = os.popen(command, 'w')
+	copyliteral(input, pipe)
+	pipe.close()
+
+def pipethrough(input, command, output):
+	tempname = tempfile.mktemp()
+	try:
+		temp = open(tempname, 'w')
+	except IOError:
+		print '*** Cannot create temp file', `tempname`
+		return
+	copyliteral(input, temp)
+	temp.close()
+	pipe = os.popen(command + ' <' + tempname, 'r')
+	copybinary(pipe, output)
+	pipe.close()
+	os.unlink(tempname)
+
+def copyliteral(input, output):
+	while 1:
+		line = input.readline()
+		if not line: break
+		output.write(line)
+
+def copybinary(input, output):
+	BUFSIZE = 8192
+	while 1:
+		line = input.read(BUFSIZE)
+		if not line: break
+		output.write(line)
diff --git a/Lib/dos-8x3/multifil.py b/Lib/dos-8x3/multifil.py
new file mode 100755
index 0000000..71e0dd0
--- /dev/null
+++ b/Lib/dos-8x3/multifil.py
@@ -0,0 +1,128 @@
+# A class that makes each part of a multipart message "feel" like an
+# ordinary file, as long as you use fp.readline().  Allows recursive
+# use, for nested multipart messages.  Probably best used together
+# with module mimetools.
+#
+# Suggested use:
+#
+# real_fp = open(...)
+# fp = MultiFile(real_fp)
+#
+# "read some lines from fp"
+# fp.push(separator)
+# while 1:
+#	"read lines from fp until it returns an empty string" (A)
+#	if not fp.next(): break
+# fp.pop()
+# "read remaining lines from fp until it returns an empty string"
+#
+# The latter sequence may be used recursively at (A).
+# It is also allowed to use multiple push()...pop() sequences.
+# Note that if a nested multipart message is terminated by a separator
+# for an outer message, this is not reported, even though it is really
+# illegal input.
+
+import sys
+import string
+
+err = sys.stderr.write
+
+Error = 'multifile.Error'
+
+class MultiFile:
+	#
+	def __init__(self, fp):
+		self.fp = fp
+		self.stack = [] # Grows down
+		self.level = 0
+		self.last = 0
+		self.start = self.fp.tell()
+		self.posstack = [] # Grows down
+	#
+	def tell(self):
+		if self.level > 0:
+			return self.lastpos
+		return self.fp.tell() - self.start
+	#
+	def seek(self, pos):
+		if not 0 <= pos <= self.tell() or \
+				self.level > 0 and pos > self.lastpos:
+			raise Error, 'bad MultiFile.seek() call'
+		self.fp.seek(pos + self.start)
+		self.level = 0
+		self.last = 0
+	#
+	def readline(self):
+		if self.level > 0: return ''
+		line = self.fp.readline()
+		if not line:
+			self.level = len(self.stack)
+			self.last = (self.level > 0)
+			if self.last:
+				err('*** Sudden EOF in MultiFile.readline()\n')
+			return ''
+		if line[:2] <> '--': return line
+		n = len(line)
+		k = n
+		while k > 0 and line[k-1] in string.whitespace: k = k-1
+		mark = line[2:k]
+		if mark[-2:] == '--': mark1 = mark[:-2]
+		else: mark1 = None
+		for i in range(len(self.stack)):
+			sep = self.stack[i]
+			if sep == mark:
+				self.last = 0
+				break
+			elif mark1 <> None and sep == mark1:
+				self.last = 1
+				break
+		else:
+			return line
+		# Get here after break out of loop
+		self.lastpos = self.tell() - len(line)
+		self.level = i+1
+		if self.level > 1:
+			err('*** Missing endmarker in MultiFile.readline()\n')
+		return ''
+	#
+	def readlines(self):
+		list = []
+		while 1:
+			line = self.readline()
+			if not line: break
+			list.append(line)
+		return list
+	#
+	def read(self): # Note: no size argument -- read until EOF only!
+		return string.joinfields(self.readlines(), '')
+	#
+	def next(self):
+		while self.readline(): pass
+		if self.level > 1 or self.last:
+			return 0
+		self.level = 0
+		self.last = 0
+		self.start = self.fp.tell()
+		return 1
+	#
+	def push(self, sep):
+		if self.level > 0:
+			raise Error, 'bad MultiFile.push() call'
+		self.stack.insert(0, sep)
+		self.posstack.insert(0, self.start)
+		self.start = self.fp.tell()
+	#
+	def pop(self):
+		if self.stack == []:
+			raise Error, 'bad MultiFile.pop() call'
+		if self.level <= 1:
+			self.last = 0
+		else:
+			abslastpos = self.lastpos + self.start
+		self.level = max(0, self.level - 1)
+		del self.stack[0]
+		self.start = self.posstack[0]
+		del self.posstack[0]
+		if self.level > 0:
+			self.lastpos = abslastpos - self.start
+	#
diff --git a/Lib/dos-8x3/nturl2pa.py b/Lib/dos-8x3/nturl2pa.py
new file mode 100755
index 0000000..17f01f5
--- /dev/null
+++ b/Lib/dos-8x3/nturl2pa.py
@@ -0,0 +1,52 @@
+#
+# nturl2path convert a NT pathname to a file URL and 
+# vice versa  
+
+def url2pathname(url):
+	""" Convert a URL to a DOS path...
+	Currently only works for absolute paths
+
+		///C|/foo/bar/spam.foo
+
+			becomes
+
+		C:\foo\bar\spam.foo
+	"""
+	import string
+	comp = string.splitfields(url, '|')
+	if len(comp) != 2 or comp[0][-1] not in string.letters:
+		error = 'Bad URL: ' + url
+		raise IOError, error
+	drive = string.upper(comp[0][-1])
+	components = string.splitfields(comp[1], '/')
+	path = drive + ':'
+	for  comp in components:
+		if comp:
+			path = path + '\\' + comp
+	return path
+
+def pathname2url(p):
+
+	""" Convert a DOS path name to a file url...
+	Currently only works for absolute paths
+
+		C:\foo\bar\spam.foo
+
+			becomes
+
+		///C|/foo/bar/spam.foo
+	"""
+
+	import string
+	comp = string.splitfields(p, ':')
+	if len(comp) != 2 or len(comp[0]) > 1:
+		error = 'Bad path: ' + p
+		raise IOError, error
+
+	drive = string.upper(comp[0])
+	components = string.splitfields(comp[1], '\\')
+	path = '///' + drive + '|'
+	for comp in components:
+		if comp:
+			path = path + '/' + comp
+	return path
diff --git a/Lib/dos-8x3/para.py b/Lib/dos-8x3/para.py
new file mode 100755
index 0000000..c9b3bdd
--- /dev/null
+++ b/Lib/dos-8x3/para.py
@@ -0,0 +1,409 @@
+# Text formatting abstractions
+# Note -- this module is obsolete, it's too slow anyway
+
+
+# Oft-used type object
+Int = type(0)
+
+
+# Represent a paragraph.  This is a list of words with associated
+# font and size information, plus indents and justification for the
+# entire paragraph.
+# Once the words have been added to a paragraph, it can be laid out
+# for different line widths.  Once laid out, it can be rendered at
+# different screen locations.  Once rendered, it can be queried
+# for mouse hits, and parts of the text can be highlighted
+class Para:
+	#
+	def __init__(self):
+		self.words = [] # The words
+		self.just = 'l' # Justification: 'l', 'r', 'lr' or 'c'
+		self.indent_left = self.indent_right = self.indent_hang = 0
+		# Final lay-out parameters, may change
+		self.left = self.top = self.right = self.bottom = \
+			self.width = self.height = self.lines = None
+	#
+	# Add a word, computing size information for it.
+	# Words may also be added manually by appending to self.words
+	# Each word should be a 7-tuple:
+	# (font, text, width, space, stretch, ascent, descent)
+	def addword(self, d, font, text, space, stretch):
+		if font <> None:
+			d.setfont(font)
+		width = d.textwidth(text)
+		ascent = d.baseline()
+		descent = d.lineheight() - ascent
+		spw = d.textwidth(' ')
+		space = space * spw
+		stretch = stretch * spw
+		tuple = (font, text, width, space, stretch, ascent, descent)
+		self.words.append(tuple)
+	#
+	# Hooks to begin and end anchors -- insert numbers in the word list!
+	def bgn_anchor(self, id):
+		self.words.append(id)
+	#
+	def end_anchor(self, id):
+		self.words.append(0)
+	#
+	# Return the total length (width) of the text added so far, in pixels
+	def getlength(self):
+		total = 0
+		for word in self.words:
+			if type(word) <> Int:
+				total = total + word[2] + word[3]
+		return total
+	#
+	# Tab to a given position (relative to the current left indent):
+	# remove all stretch, add fixed space up to the new indent.
+	# If the current position is already beying the tab stop,
+	# don't add any new space (but still remove the stretch)
+	def tabto(self, tab):
+		total = 0
+		as, de = 1, 0
+		for i in range(len(self.words)):
+			word = self.words[i]
+			if type(word) == Int: continue
+			fo, te, wi, sp, st, as, de = word
+			self.words[i] = fo, te, wi, sp, 0, as, de
+			total = total + wi + sp
+		if total < tab:
+			self.words.append(None, '', 0, tab-total, 0, as, de)
+	#
+	# Make a hanging tag: tab to hang, increment indent_left by hang,
+	# and reset indent_hang to -hang
+	def makehangingtag(self, hang):
+		self.tabto(hang)
+		self.indent_left = self.indent_left + hang
+		self.indent_hang = -hang
+	#
+	# Decide where the line breaks will be given some screen width
+	def layout(self, linewidth):
+		self.width = linewidth
+		height = 0
+		self.lines = lines = []
+		avail1 = self.width - self.indent_left - self.indent_right
+		avail = avail1 - self.indent_hang
+		words = self.words
+		i = 0
+		n = len(words)
+		lastfont = None
+		while i < n:
+			firstfont = lastfont
+			charcount = 0
+			width = 0
+			stretch = 0
+			ascent = 0
+			descent = 0
+			lsp = 0
+			j = i
+			while i < n:
+				word = words[i]
+				if type(word) == Int:
+					if word > 0 and width >= avail:
+						break
+					i = i+1
+					continue
+				fo, te, wi, sp, st, as, de = word
+				if width + wi > avail and width > 0 and wi > 0:
+					break
+				if fo <> None:
+					lastfont = fo
+					if width == 0:
+						firstfont = fo
+				charcount = charcount + len(te) + (sp > 0)
+				width = width + wi + sp
+				lsp = sp
+				stretch = stretch + st
+				lst = st
+				ascent = max(ascent, as)
+				descent = max(descent, de)
+				i = i+1
+			while i > j and type(words[i-1]) == Int and \
+				words[i-1] > 0: i = i-1
+			width = width - lsp
+			if i < n:
+				stretch = stretch - lst
+			else:
+				stretch = 0
+			tuple = i-j, firstfont, charcount, width, stretch, \
+				ascent, descent
+			lines.append(tuple)
+			height = height + ascent + descent
+			avail = avail1
+		self.height = height
+	#
+	# Call a function for all words in a line
+	def visit(self, wordfunc, anchorfunc):
+		avail1 = self.width - self.indent_left - self.indent_right
+		avail = avail1 - self.indent_hang
+		v = self.top
+		i = 0
+		for tuple in self.lines:
+			wordcount, firstfont, charcount, width, stretch, \
+				ascent, descent = tuple
+			h = self.left + self.indent_left
+			if i == 0: h = h + self.indent_hang
+			extra = 0
+			if self.just == 'r': h = h + avail - width
+			elif self.just == 'c': h = h + (avail - width) / 2
+			elif self.just == 'lr' and stretch > 0:
+				extra = avail - width
+			v2 = v + ascent + descent
+			for j in range(i, i+wordcount):
+				word = self.words[j]
+				if type(word) == Int:
+					ok = anchorfunc(self, tuple, word, \
+							h, v)
+					if ok <> None: return ok
+					continue
+				fo, te, wi, sp, st, as, de = word
+				if extra > 0 and stretch > 0:
+					ex = extra * st / stretch
+					extra = extra - ex
+					stretch = stretch - st
+				else:
+					ex = 0
+				h2 = h + wi + sp + ex
+				ok = wordfunc(self, tuple, word, h, v, \
+					h2, v2, (j==i), (j==i+wordcount-1))
+				if ok <> None: return ok
+				h = h2
+			v = v2
+			i = i + wordcount
+			avail = avail1
+	#
+	# Render a paragraph in "drawing object" d, using the rectangle
+	# given by (left, top, right) with an unspecified bottom.
+	# Return the computed bottom of the text.
+	def render(self, d, left, top, right):
+		if self.width <> right-left:
+			self.layout(right-left)
+		self.left = left
+		self.top = top
+		self.right = right
+		self.bottom = self.top + self.height
+		self.anchorid = 0
+		try:
+			self.d = d
+			self.visit(self.__class__._renderword, \
+				   self.__class__._renderanchor)
+		finally:
+			self.d = None
+		return self.bottom
+	#
+	def _renderword(self, tuple, word, h, v, h2, v2, isfirst, islast):
+		if word[0] <> None: self.d.setfont(word[0])
+		baseline = v + tuple[5]
+		self.d.text((h, baseline - word[5]), word[1])
+		if self.anchorid > 0:
+			self.d.line((h, baseline+2), (h2, baseline+2))
+	#
+	def _renderanchor(self, tuple, word, h, v):
+		self.anchorid = word
+	#
+	# Return which anchor(s) was hit by the mouse
+	def hitcheck(self, mouseh, mousev):
+		self.mouseh = mouseh
+		self.mousev = mousev
+		self.anchorid = 0
+		self.hits = []
+		self.visit(self.__class__._hitcheckword, \
+			   self.__class__._hitcheckanchor)
+		return self.hits
+	#
+	def _hitcheckword(self, tuple, word, h, v, h2, v2, isfirst, islast):
+		if self.anchorid > 0 and h <= self.mouseh <= h2 and \
+			v <= self.mousev <= v2:
+			self.hits.append(self.anchorid)
+	#
+	def _hitcheckanchor(self, tuple, word, h, v):
+		self.anchorid = word
+	#
+	# Return whether the given anchor id is present
+	def hasanchor(self, id):
+		return id in self.words or -id in self.words
+	#
+	# Extract the raw text from the word list, substituting one space
+	# for non-empty inter-word space, and terminating with '\n'
+	def extract(self):
+		text = ''
+		for w in self.words:
+			if type(w) <> Int:
+				word = w[1]
+				if w[3]: word = word + ' '
+				text = text + word
+		return text + '\n'
+	#
+	# Return which character position was hit by the mouse, as
+	# an offset in the entire text as returned by extract().
+	# Return None if the mouse was not in this paragraph
+	def whereis(self, d, mouseh, mousev):
+		if mousev < self.top or mousev > self.bottom:
+			return None
+		self.mouseh = mouseh
+		self.mousev = mousev
+		self.lastfont = None
+		self.charcount = 0
+		try:
+			self.d = d
+			return self.visit(self.__class__._whereisword, \
+					  self.__class__._whereisanchor)
+		finally:
+			self.d = None
+	#
+	def _whereisword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
+		fo, te, wi, sp, st, as, de = word
+		if fo <> None: self.lastfont = fo
+		h = h1
+		if isfirst: h1 = 0
+		if islast: h2 = 999999
+		if not (v1 <= self.mousev <= v2 and h1 <= self.mouseh <= h2):
+			self.charcount = self.charcount + len(te) + (sp > 0)
+			return
+		if self.lastfont <> None:
+			self.d.setfont(self.lastfont)
+		cc = 0
+		for c in te:
+			cw = self.d.textwidth(c)
+			if self.mouseh <= h + cw/2:
+				return self.charcount + cc
+			cc = cc+1
+			h = h+cw
+		self.charcount = self.charcount + cc
+		if self.mouseh <= (h+h2) / 2:
+			return self.charcount
+		else:
+			return self.charcount + 1
+	#
+	def _whereisanchor(self, tuple, word, h, v):
+		pass
+	#
+	# Return screen position corresponding to position in paragraph.
+	# Return tuple (h, vtop, vbaseline, vbottom).
+	# This is more or less the inverse of whereis()
+	def screenpos(self, d, pos):
+		if pos < 0:
+			ascent, descent = self.lines[0][5:7]
+			return self.left, self.top, self.top + ascent, \
+				self.top + ascent + descent
+		self.pos = pos
+		self.lastfont = None
+		try:
+			self.d = d
+			ok = self.visit(self.__class__._screenposword, \
+					self.__class__._screenposanchor)
+		finally:
+			self.d = None
+		if ok == None:
+			ascent, descent = self.lines[-1][5:7]
+			ok = self.right, self.bottom - ascent - descent, \
+				self.bottom - descent, self.bottom
+		return ok
+	#
+	def _screenposword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
+		fo, te, wi, sp, st, as, de = word
+		if fo <> None: self.lastfont = fo
+		cc = len(te) + (sp > 0)
+		if self.pos > cc:
+			self.pos = self.pos - cc
+			return
+		if self.pos < cc:
+			self.d.setfont(self.lastfont)
+			h = h1 + self.d.textwidth(te[:self.pos])
+		else:
+			h = h2
+		ascent, descent = tuple[5:7]
+		return h, v1, v1+ascent, v2
+	#
+	def _screenposanchor(self, tuple, word, h, v):
+		pass
+	#
+	# Invert the stretch of text between pos1 and pos2.
+	# If pos1 is None, the beginning is implied;
+	# if pos2 is None, the end is implied.
+	# Undoes its own effect when called again with the same arguments
+	def invert(self, d, pos1, pos2):
+		if pos1 == None:
+			pos1 = self.left, self.top, self.top, self.top
+		else:
+			pos1 = self.screenpos(d, pos1)
+		if pos2 == None:
+			pos2 = self.right, self.bottom,self.bottom,self.bottom
+		else:
+			pos2 = self.screenpos(d, pos2)
+		h1, top1, baseline1, bottom1 = pos1
+		h2, top2, baseline2, bottom2 = pos2
+		if bottom1 <= top2:
+			d.invert((h1, top1), (self.right, bottom1))
+			h1 = self.left
+			if bottom1 < top2:
+				d.invert((h1, bottom1), (self.right, top2))
+			top1, bottom1 = top2, bottom2
+		d.invert((h1, top1), (h2, bottom2))
+
+
+# Test class Para
+# XXX This was last used on the Mac, hence the weird fonts...
+def test():
+	import stdwin
+	from stdwinevents import *
+	words = 'The', 'quick', 'brown', 'fox', 'jumps', 'over', \
+		'the', 'lazy', 'dog.'
+	paralist = []
+	for just in 'l', 'r', 'lr', 'c':
+		p = Para()
+		p.just = just
+		p.addword(stdwin, ('New York', 'p', 12), words[0], 1, 1)
+		for word in words[1:-1]:
+			p.addword(stdwin, None, word, 1, 1)
+		p.addword(stdwin, None, words[-1], 2, 4)
+		p.addword(stdwin, ('New York', 'b', 18), 'Bye!', 0, 0)
+		p.addword(stdwin, ('New York', 'p', 10), 'Bye!', 0, 0)
+		paralist.append(p)
+	window = stdwin.open('Para.test()')
+	start = stop = selpara = None
+	while 1:
+		etype, win, detail = stdwin.getevent()
+		if etype == WE_CLOSE:
+			break
+		if etype == WE_SIZE:
+			window.change((0, 0), (1000, 1000))
+		if etype == WE_DRAW:
+			width, height = window.getwinsize()
+			d = None
+			try:
+				d = window.begindrawing()
+				d.cliprect(detail)
+				d.erase(detail)
+				v = 0
+				for p in paralist:
+					v = p.render(d, 0, v, width)
+					if p == selpara and \
+					   start <> None and stop <> None:
+						p.invert(d, start, stop)
+			finally:
+				if d: d.close()
+		if etype == WE_MOUSE_DOWN:
+			if selpara and start <> None and stop <> None:
+				d = window.begindrawing()
+				selpara.invert(d, start, stop)
+				d.close()
+			start = stop = selpara = None
+			mouseh, mousev = detail[0]
+			for p in paralist:
+				start = p.whereis(stdwin, mouseh, mousev)
+				if start <> None:
+					selpara = p
+					break
+		if etype == WE_MOUSE_UP and start <> None and selpara:
+			mouseh, mousev = detail[0]
+			stop = selpara.whereis(stdwin, mouseh, mousev)
+			if stop == None: start = selpara = None
+			else:
+				if start > stop:
+					start, stop = stop, start
+				d = window.begindrawing()
+				selpara.invert(d, start, stop)
+				d.close()
+	window.close()
diff --git a/Lib/dos-8x3/posixfil.py b/Lib/dos-8x3/posixfil.py
new file mode 100755
index 0000000..459cd52
--- /dev/null
+++ b/Lib/dos-8x3/posixfil.py
@@ -0,0 +1,207 @@
+#
+# Start of posixfile.py
+#
+
+#
+# Extended file operations
+#
+# f = posixfile.open(filename, [mode, [bufsize]])
+#	will create a new posixfile object
+#
+# f = posixfile.fileopen(fileobject)
+#	will create a posixfile object from a builtin file object
+#
+# f.file()
+#	will return the original builtin file object
+#
+# f.dup()
+#	will return a new file object based on a new filedescriptor
+#
+# f.dup2(fd)
+#	will return a new file object based on the given filedescriptor
+#
+# f.flags(mode)
+#	will turn on the associated flag (merge)
+#	mode can contain the following characters:
+#
+#   (character representing a flag)
+#	a	append only flag
+#	c	close on exec flag
+#	n	no delay flag
+#	s	synchronization flag
+#   (modifiers)
+#	!	turn flags 'off' instead of default 'on'
+#	=	copy flags 'as is' instead of default 'merge'
+#	?	return a string in which the characters represent the flags
+#		that are set
+#
+#	note: - the '!' and '=' modifiers are mutually exclusive.
+#	      - the '?' modifier will return the status of the flags after they
+#		have been changed by other characters in the mode string
+#
+# f.lock(mode [, len [, start [, whence]]])
+#	will (un)lock a region
+#	mode can contain the following characters:
+#
+#   (character representing type of lock)
+#	u	unlock
+#	r	read lock
+#	w	write lock
+#   (modifiers)
+#	|	wait until the lock can be granted
+#	?	return the first lock conflicting with the requested lock
+#		or 'None' if there is no conflict. The lock returned is in the
+#		format (mode, len, start, whence, pid) where mode is a
+#		character representing the type of lock ('r' or 'w')
+#
+#	note: - the '?' modifier prevents a region from being locked; it is
+#		query only
+#
+
+class _posixfile_:
+    states = ['open', 'closed']
+
+    #
+    # Internal routines
+    #
+    def __repr__(self):
+	file = self._file_
+	return "<%s posixfile '%s', mode '%s' at %s>" % \
+		(self.states[file.closed], file.name, file.mode, \
+		 hex(id(self))[2:])
+
+    def __del__(self):
+	self._file_.close()
+
+    #
+    # Initialization routines
+    #
+    def open(self, name, mode='r', bufsize=-1):
+	import __builtin__
+	return self.fileopen(__builtin__.open(name, mode, bufsize))
+
+    def fileopen(self, file):
+	if `type(file)` != "<type 'file'>":
+	    raise TypeError, 'posixfile.fileopen() arg must be file object'
+	self._file_  = file
+	# Copy basic file methods
+	for method in file.__methods__:
+	    setattr(self, method, getattr(file, method))
+	return self
+
+    #
+    # New methods
+    #
+    def file(self):
+	return self._file_
+
+    def dup(self):
+	import posix
+
+	try: ignore = posix.fdopen
+	except: raise AttributeError, 'dup() method unavailable'
+
+	return posix.fdopen(posix.dup(self._file_.fileno()), self._file_.mode)
+
+    def dup2(self, fd):
+	import posix
+
+	try: ignore = posix.fdopen
+	except: raise AttributeError, 'dup() method unavailable'
+
+	posix.dup2(self._file_.fileno(), fd)
+	return posix.fdopen(fd, self._file_.mode)
+
+    def flags(self, *which):
+	import fcntl, FCNTL
+
+	if which:
+	    if len(which) > 1:
+		raise TypeError, 'Too many arguments'
+	    which = which[0]
+	else: which = '?'
+
+	l_flags = 0
+	if 'n' in which: l_flags = l_flags | FCNTL.O_NDELAY
+	if 'a' in which: l_flags = l_flags | FCNTL.O_APPEND
+	if 's' in which: l_flags = l_flags | FCNTL.O_SYNC
+
+	file = self._file_
+
+	if '=' not in which:
+	    cur_fl = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0)
+	    if '!' in which: l_flags = cur_fl & ~ l_flags
+	    else: l_flags = cur_fl | l_flags
+
+	l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFL, l_flags)
+
+	if 'c' in which:	
+	    arg = ('!' not in which)	# 0 is don't, 1 is do close on exec
+	    l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFD, arg)
+
+	if '?' in which:
+	    which = ''			# Return current flags
+	    l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0)
+	    if FCNTL.O_APPEND & l_flags: which = which + 'a'
+	    if fcntl.fcntl(file.fileno(), FCNTL.F_GETFD, 0) & 1:
+		which = which + 'c'
+	    if FCNTL.O_NDELAY & l_flags: which = which + 'n'
+	    if FCNTL.O_SYNC & l_flags: which = which + 's'
+	    return which
+	
+    def lock(self, how, *args):
+	import struct, fcntl, FCNTL
+
+	if 'w' in how: l_type = FCNTL.F_WRLCK
+	elif 'r' in how: l_type = FCNTL.F_RDLCK
+	elif 'u' in how: l_type = FCNTL.F_UNLCK
+	else: raise TypeError, 'no type of lock specified'
+
+	if '|' in how: cmd = FCNTL.F_SETLKW
+	elif '?' in how: cmd = FCNTL.F_GETLK
+	else: cmd = FCNTL.F_SETLK
+
+	l_whence = 0
+	l_start = 0
+	l_len = 0
+
+	if len(args) == 1:
+	    l_len = args[0]
+	elif len(args) == 2:
+	    l_len, l_start = args
+	elif len(args) == 3:
+	    l_len, l_start, l_whence = args
+	elif len(args) > 3:
+	    raise TypeError, 'too many arguments'
+
+	flock = struct.pack('hhllhh', l_type, l_whence, l_start, l_len, 0, 0)
+	flock = fcntl.fcntl(self._file_.fileno(), cmd, flock)
+
+	if '?' in how:
+	    l_type, l_whence, l_start, l_len, l_sysid, l_pid = \
+		struct.unpack('hhllhh', flock)
+	    if l_type != FCNTL.F_UNLCK:
+		if l_type == FCNTL.F_RDLCK:
+		    return 'r', l_len, l_start, l_whence, l_pid
+		else:
+		    return 'w', l_len, l_start, l_whence, l_pid
+
+#
+# Public routine to obtain a posixfile object
+#
+def open(name, mode='r', bufsize=-1):
+    return _posixfile_().open(name, mode, bufsize)
+
+def fileopen(file):
+    return _posixfile_().fileopen(file)
+
+#
+# Constants
+#
+SEEK_SET = 0
+SEEK_CUR = 1
+SEEK_END = 2
+
+#
+# End of posixfile.py
+#
diff --git a/Lib/dos-8x3/posixpat.py b/Lib/dos-8x3/posixpat.py
new file mode 100755
index 0000000..d284834
--- /dev/null
+++ b/Lib/dos-8x3/posixpat.py
@@ -0,0 +1,307 @@
+# Module 'posixpath' -- common operations on POSIX pathnames
+
+import posix
+import stat
+
+
+# Normalize the case of a pathname.  Trivial in Posix, string.lower on Mac.
+# On MS-DOS this may also turn slashes into backslashes; however, other
+# normalizations (such as optimizing '../' away) are not allowed
+# (another function should be defined to do that).
+
+def normcase(s):
+	return s
+
+
+# Return wheter a path is absolute.
+# Trivial in Posix, harder on the Mac or MS-DOS.
+
+def isabs(s):
+	return s[:1] == '/'
+
+
+# Join two pathnames.
+# Ignore the first part if the second part is absolute.
+# Insert a '/' unless the first part is empty or already ends in '/'.
+
+def join(a, b):
+	if b[:1] == '/': return b
+	if a == '' or a[-1:] == '/': return a + b
+	# Note: join('x', '') returns 'x/'; is this what we want?
+	return a + '/' + b
+
+
+# Split a path in head (everything up to the last '/') and tail (the
+# rest).  If the path ends in '/', tail will be empty.  If there is no
+# '/' in the path, head  will be empty.
+# Trailing '/'es are stripped from head unless it is the root.
+
+def split(p):
+	import string
+	i = string.rfind(p, '/') + 1
+	head, tail = p[:i], p[i:]
+	if head and head <> '/'*len(head):
+		while head[-1] == '/':
+			head = head[:-1]
+	return head, tail
+
+
+# Split a path in root and extension.
+# The extension is everything starting at the first dot in the last
+# pathname component; the root is everything before that.
+# It is always true that root + ext == p.
+
+def splitext(p):
+	root, ext = '', ''
+	for c in p:
+		if c == '/':
+			root, ext = root + ext + c, ''
+		elif c == '.':
+			if ext:
+				root, ext = root + ext, c
+			else:
+				ext = c
+		elif ext:
+			ext = ext + c
+		else:
+			root = root + c
+	return root, ext
+
+
+# Split a pathname into a drive specification and the rest of the
+# path.  Useful on DOS/Windows/NT; on Unix, the drive is always empty.
+
+def splitdrive(p):
+	return '', p
+
+
+# Return the tail (basename) part of a path.
+
+def basename(p):
+	return split(p)[1]
+
+
+# Return the head (dirname) part of a path.
+
+def dirname(p):
+	return split(p)[0]
+
+
+# Return the longest prefix of all list elements.
+
+def commonprefix(m):
+	if not m: return ''
+	prefix = m[0]
+	for item in m:
+		for i in range(len(prefix)):
+			if prefix[:i+1] <> item[:i+1]:
+				prefix = prefix[:i]
+				if i == 0: return ''
+				break
+	return prefix
+
+
+# Is a path a symbolic link?
+# This will always return false on systems where posix.lstat doesn't exist.
+
+def islink(path):
+	try:
+		st = posix.lstat(path)
+	except (posix.error, AttributeError):
+		return 0
+	return stat.S_ISLNK(st[stat.ST_MODE])
+
+
+# Does a path exist?
+# This is false for dangling symbolic links.
+
+def exists(path):
+	try:
+		st = posix.stat(path)
+	except posix.error:
+		return 0
+	return 1
+
+
+# Is a path a posix directory?
+# This follows symbolic links, so both islink() and isdir() can be true
+# for the same path.
+
+def isdir(path):
+	try:
+		st = posix.stat(path)
+	except posix.error:
+		return 0
+	return stat.S_ISDIR(st[stat.ST_MODE])
+
+
+# Is a path a regular file?
+# This follows symbolic links, so both islink() and isfile() can be true
+# for the same path.
+
+def isfile(path):
+	try:
+		st = posix.stat(path)
+	except posix.error:
+		return 0
+	return stat.S_ISREG(st[stat.ST_MODE])
+
+
+# Are two filenames really pointing to the same file?
+
+def samefile(f1, f2):
+	s1 = posix.stat(f1)
+	s2 = posix.stat(f2)
+	return samestat(s1, s2)
+
+
+# Are two open files really referencing the same file?
+# (Not necessarily the same file descriptor!)
+# XXX Oops, posix.fstat() doesn't exist yet!
+
+def sameopenfile(fp1, fp2):
+	s1 = posix.fstat(fp1)
+	s2 = posix.fstat(fp2)
+	return samestat(s1, s2)
+
+
+# Are two stat buffers (obtained from stat, fstat or lstat)
+# describing the same file?
+
+def samestat(s1, s2):
+	return s1[stat.ST_INO] == s2[stat.ST_INO] and \
+		s1[stat.ST_DEV] == s2[stat.ST_DEV]
+
+
+# Is a path a mount point?
+# (Does this work for all UNIXes?  Is it even guaranteed to work by POSIX?)
+
+def ismount(path):
+	try:
+		s1 = posix.stat(path)
+		s2 = posix.stat(join(path, '..'))
+	except posix.error:
+		return 0 # It doesn't exist -- so not a mount point :-)
+	dev1 = s1[stat.ST_DEV]
+	dev2 = s2[stat.ST_DEV]
+	if dev1 != dev2:
+		return 1		# path/.. on a different device as path
+	ino1 = s1[stat.ST_INO]
+	ino2 = s2[stat.ST_INO]
+	if ino1 == ino2:
+		return 1		# path/.. is the same i-node as path
+	return 0
+
+
+# Directory tree walk.
+# For each directory under top (including top itself, but excluding
+# '.' and '..'), func(arg, dirname, filenames) is called, where
+# dirname is the name of the directory and filenames is the list
+# files files (and subdirectories etc.) in the directory.
+# The func may modify the filenames list, to implement a filter,
+# or to impose a different order of visiting.
+
+def walk(top, func, arg):
+	try:
+		names = posix.listdir(top)
+	except posix.error:
+		return
+	func(arg, top, names)
+	exceptions = ('.', '..')
+	for name in names:
+		if name not in exceptions:
+			name = join(top, name)
+			if isdir(name) and not islink(name):
+				walk(name, func, arg)
+
+
+# Expand paths beginning with '~' or '~user'.
+# '~' means $HOME; '~user' means that user's home directory.
+# If the path doesn't begin with '~', or if the user or $HOME is unknown,
+# the path is returned unchanged (leaving error reporting to whatever
+# function is called with the expanded path as argument).
+# See also module 'glob' for expansion of *, ? and [...] in pathnames.
+# (A function should also be defined to do full *sh-style environment
+# variable expansion.)
+
+def expanduser(path):
+	if path[:1] <> '~':
+		return path
+	i, n = 1, len(path)
+	while i < n and path[i] <> '/':
+		i = i+1
+	if i == 1:
+		if not posix.environ.has_key('HOME'):
+			return path
+		userhome = posix.environ['HOME']
+	else:
+		import pwd
+		try:
+			pwent = pwd.getpwnam(path[1:i])
+		except KeyError:
+			return path
+		userhome = pwent[5]
+	if userhome[-1:] == '/': i = i+1
+	return userhome + path[i:]
+
+
+# Expand paths containing shell variable substitutions.
+# This expands the forms $variable and ${variable} only.
+# Non-existant variables are left unchanged.
+
+_varprog = None
+
+def expandvars(path):
+	global _varprog
+	if '$' not in path:
+		return path
+	if not _varprog:
+		import regex
+		_varprog = regex.compile('$\([a-zA-Z0-9_]+\|{[^}]*}\)')
+	i = 0
+	while 1:
+		i = _varprog.search(path, i)
+		if i < 0:
+			break
+		name = _varprog.group(1)
+		j = i + len(_varprog.group(0))
+		if name[:1] == '{' and name[-1:] == '}':
+			name = name[1:-1]
+		if posix.environ.has_key(name):
+			tail = path[j:]
+			path = path[:i] + posix.environ[name]
+			i = len(path)
+			path = path + tail
+		else:
+			i = j
+	return path
+
+
+# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
+# It should be understood that this may change the meaning of the path
+# if it contains symbolic links!
+
+def normpath(path):
+	import string
+	# Treat initial slashes specially
+	slashes = ''
+	while path[:1] == '/':
+		slashes = slashes + '/'
+		path = path[1:]
+	comps = string.splitfields(path, '/')
+	i = 0
+	while i < len(comps):
+		if comps[i] == '.':
+			del comps[i]
+		elif comps[i] == '..' and i > 0 and \
+					  comps[i-1] not in ('', '..'):
+			del comps[i-1:i+1]
+			i = i-1
+		elif comps[i] == '' and i > 0 and comps[i-1] <> '':
+			del comps[i]
+		else:
+			i = i+1
+	# If the path is now empty, substitute '.'
+	if not comps and not slashes:
+		comps.append('.')
+	return slashes + string.joinfields(comps, '/')
diff --git a/Lib/dos-8x3/py_compi.py b/Lib/dos-8x3/py_compi.py
new file mode 100755
index 0000000..2e68ba8
--- /dev/null
+++ b/Lib/dos-8x3/py_compi.py
@@ -0,0 +1,31 @@
+# Routine to "compile" a .py file to a .pyc file.
+# This has intimate knowledge of how Python/import.c does it.
+# By Sjoerd Mullender (I forced him to write it :-).
+
+import imp
+MAGIC = imp.get_magic()
+
+def wr_long(f, x):
+	f.write(chr( x        & 0xff))
+	f.write(chr((x >> 8)  & 0xff))
+	f.write(chr((x >> 16) & 0xff))
+	f.write(chr((x >> 24) & 0xff))
+
+def compile(file, cfile = None):
+	import os, marshal, __builtin__
+	f = open(file)
+	codestring = f.read()
+	f.close()
+	timestamp = os.stat(file)[8]
+	codeobject = __builtin__.compile(codestring, file, 'exec')
+	if not cfile:
+		cfile = file + 'c'
+	fc = open(cfile, 'wb')
+	fc.write(MAGIC)
+	wr_long(fc, timestamp)
+	marshal.dump(codeobject, fc)
+	fc.close()
+	if os.name == 'mac':
+		import macfs
+		macfs.FSSpec(cfile).SetCreatorType('Pyth', 'PYC ')
+		macfs.FSSpec(file).SetCreatorType('Pyth', 'TEXT')
diff --git a/Lib/dos-8x3/queue.py b/Lib/dos-8x3/queue.py
new file mode 100755
index 0000000..5125fd5
--- /dev/null
+++ b/Lib/dos-8x3/queue.py
@@ -0,0 +1,121 @@
+# A multi-producer, multi-consumer queue.
+
+Empty = 'Queue.Empty' # Exception raised by get_nowait()
+
+class Queue:
+
+	# Initialize a queue object with a given maximum size
+	# (If maxsize is <= 0, the maximum size is infinite)
+	def __init__(self, maxsize):
+		import thread
+		self._init(maxsize)
+		self.mutex = thread.allocate_lock()
+		self.esema = thread.allocate_lock()
+		self.esema.acquire_lock()
+		self.fsema = thread.allocate_lock()
+
+	# Get an approximation of the queue size (not reliable!)
+	def qsize(self):
+		self.mutex.acquire_lock()
+		n = self._qsize()
+		self.mutex.release_lock()
+		return n
+
+	# Check if the queue is empty (not reliable!)
+	def empty(self):
+		self.mutex.acquire_lock()
+		n = self._empty()
+		self.mutex.release_lock()
+		return n
+
+	# Check if the queue is full (not reliable!)
+	def full(self):
+		self.mutex.acquire_lock()
+		n = self._full()
+		self.mutex.release_lock()
+		return n
+
+	# Put a new item into the queue
+	def put(self, item):
+		self.fsema.acquire_lock()
+		self.mutex.acquire_lock()
+		was_empty = self._empty()
+		self._put(item)
+		if was_empty:
+			self.esema.release_lock()
+		if not self._full():
+			self.fsema.release_lock()
+		self.mutex.release_lock()
+
+	# Get an item from the queue,
+	# blocking if necessary until one is available
+	def get(self):
+		self.esema.acquire_lock()
+		self.mutex.acquire_lock()
+		was_full = self._full()
+		item = self._get()
+		if was_full:
+			self.fsema.release_lock()
+		if not self._empty():
+			self.esema.release_lock()
+		self.mutex.release_lock()
+		return item
+
+	# Get an item from the queue if one is immediately available,
+	# raise Empty if the queue is empty or temporarily unavailable
+	def get_nowait(self):
+		locked = self.esema.acquire_lock(0)
+		self.mutex.acquire_lock()
+		if self._empty():
+			# The queue is empyt -- we can't have esema
+			self.mutex.release_lock()
+			raise Empty
+		if not locked:
+			locked = self.esema.acquire_lock(0)
+			if not locked:
+				# Somebody else has esema
+				# but we have mutex --
+				# go out of their way
+				self.mutex.release_lock()
+				raise Empty
+		was_full = self._full()
+		item = self._get()
+		if was_full:
+			self.fsema.release_lock()
+		if not self._empty():
+			self.esema.release_lock()
+		self.mutex.release_lock()
+		return item
+
+	# XXX Need to define put_nowait() as well.
+		
+
+	# Override these methods to implement other queue organizations
+	# (e.g. stack or priority queue).
+	# These will only be called with appropriate locks held
+
+	# Initialize the queue representation
+	def _init(self, maxsize):
+		self.maxsize = maxsize
+		self.queue = []
+
+	def _qsize(self):
+		return len(self.queue)
+
+	# Check wheter the queue is empty
+	def _empty(self):
+		return not self.queue
+
+	# Check whether the queue is full
+	def _full(self):
+		return self.maxsize > 0 and len(self.queue) == self.maxsize
+
+	# Put a new item in the queue
+	def _put(self, item):
+		self.queue.append(item)
+
+	# Get an item from the queue
+	def _get(self):
+		item = self.queue[0]
+		del self.queue[0]
+		return item
diff --git a/Lib/dos-8x3/regex_sy.py b/Lib/dos-8x3/regex_sy.py
new file mode 100755
index 0000000..bb80f4e
--- /dev/null
+++ b/Lib/dos-8x3/regex_sy.py
@@ -0,0 +1,41 @@
+# These bits are passed to regex.set_syntax() to choose among
+# alternative regexp syntaxes.
+
+# 1 means plain parentheses serve as grouping, and backslash
+#   parentheses are needed for literal searching.
+# 0 means backslash-parentheses are grouping, and plain parentheses
+#   are for literal searching.
+RE_NO_BK_PARENS = 1
+
+# 1 means plain | serves as the "or"-operator, and \| is a literal.
+# 0 means \| serves as the "or"-operator, and | is a literal.
+RE_NO_BK_VBAR = 2
+
+# 0 means plain + or ? serves as an operator, and \+, \? are literals.
+# 1 means \+, \? are operators and plain +, ? are literals.
+RE_BK_PLUS_QM = 4
+
+# 1 means | binds tighter than ^ or $.
+# 0 means the contrary.
+RE_TIGHT_VBAR = 8
+
+# 1 means treat \n as an _OR operator
+# 0 means treat it as a normal character
+RE_NEWLINE_OR = 16
+
+# 0 means that a special characters (such as *, ^, and $) always have
+#   their special meaning regardless of the surrounding context.
+# 1 means that special characters may act as normal characters in some
+#   contexts.  Specifically, this applies to:
+#	^ - only special at the beginning, or after ( or |
+#	$ - only special at the end, or before ) or |
+#	*, +, ? - only special when not after the beginning, (, or |
+RE_CONTEXT_INDEP_OPS = 32
+
+# Now define combinations of bits for the standard possibilities.
+RE_SYNTAX_AWK = (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS)
+RE_SYNTAX_EGREP = (RE_SYNTAX_AWK | RE_NEWLINE_OR)
+RE_SYNTAX_GREP = (RE_BK_PLUS_QM | RE_NEWLINE_OR)
+RE_SYNTAX_EMACS = 0
+
+# (Python's obsolete "regexp" module used a syntax similar to awk.)
diff --git a/Lib/dos-8x3/simpleht.py b/Lib/dos-8x3/simpleht.py
new file mode 100755
index 0000000..dd3107a
--- /dev/null
+++ b/Lib/dos-8x3/simpleht.py
@@ -0,0 +1,168 @@
+"""Simple HTTP Server.
+
+This module builds on BaseHTTPServer by implementing the standard GET
+and HEAD requests in a fairly straightforward manner.
+
+"""
+
+
+__version__ = "0.3"
+
+
+import os
+import pwd
+import sys
+import time
+import socket
+import string
+import posixpath
+import SocketServer
+import BaseHTTPServer
+
+
+def nobody_uid():
+    """Internal routine to get nobody's uid"""
+    try:
+	nobody = pwd.getpwnam('nobody')[2]
+    except pwd.error:
+	nobody = 1 + max(map(lambda x: x[2], pwd.getpwall()))
+    return nobody
+
+nobody = nobody_uid()
+
+
+class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+
+    """Simple HTTP request handler with GET and HEAD commands.
+
+    This serves files from the current directory and any of its
+    subdirectories.  It assumes that all files are plain text files
+    unless they have the extension ".html" in which case it assumes
+    they are HTML files.
+
+    The GET and HEAD requests are identical except that the HEAD
+    request omits the actual contents of the file.
+
+    """
+
+    server_version = "SimpleHTTP/" + __version__
+
+    def do_GET(self):
+	"""Serve a GET request."""
+	f = self.send_head()
+	if f:
+	    self.copyfile(f, self.wfile)
+	    f.close()
+
+    def do_HEAD(self):
+	"""Serve a HEAD request."""
+	f = self.send_head()
+	if f:
+	    f.close()
+
+    def send_head(self):
+	"""Common code for GET and HEAD commands.
+
+	This sends the response code and MIME headers.
+
+	Return value is either a file object (which has to be copied
+	to the outputfile by the caller unless the command was HEAD,
+	and must be closed by the caller under all circumstances), or
+	None, in which case the caller has nothing further to do.
+
+	"""
+	path = self.translate_path(self.path)
+	if os.path.isdir(path):
+	    self.send_error(403, "Directory listing not supported")
+	    return None
+	try:
+	    f = open(path)
+	except IOError:
+	    self.send_error(404, "File not found")
+	    return None
+	self.send_response(200)
+	self.send_header("Content-type", self.guess_type(path))
+	self.end_headers()
+	return f
+
+    def translate_path(self, path):
+	"""Translate a /-separated PATH to the local filename syntax.
+
+	Components that mean special things to the local file system
+	(e.g. drive or directory names) are ignored.  (XXX They should
+	probably be diagnosed.)
+
+	"""
+	path = posixpath.normpath(path)
+	words = string.splitfields(path, '/')
+	words = filter(None, words)
+	path = os.getcwd()
+	for word in words:
+	    drive, word = os.path.splitdrive(word)
+	    head, word = os.path.split(word)
+	    if word in (os.curdir, os.pardir): continue
+	    path = os.path.join(path, word)
+	return path
+
+    def copyfile(self, source, outputfile):
+	"""Copy all data between two file objects.
+
+	The SOURCE argument is a file object open for reading
+	(or anything with a read() method) and the DESTINATION
+	argument is a file object open for writing (or
+	anything with a write() method).
+
+	The only reason for overriding this would be to change
+	the block size or perhaps to replace newlines by CRLF
+	-- note however that this the default server uses this
+	to copy binary data as well.
+
+	"""
+
+	BLOCKSIZE = 8192
+	while 1:
+	    data = source.read(BLOCKSIZE)
+	    if not data: break
+	    outputfile.write(data)
+
+    def guess_type(self, path):
+	"""Guess the type of a file.
+
+	Argument is a PATH (a filename).
+
+	Return value is a string of the form type/subtype,
+	usable for a MIME Content-type header.
+
+	The default implementation looks the file's extension
+	up in the table self.extensions_map, using text/plain
+	as a default; however it would be permissible (if
+	slow) to look inside the data to make a better guess.
+
+	"""
+
+	base, ext = posixpath.splitext(path)
+	if self.extensions_map.has_key(ext):
+	    return self.extensions_map[ext]
+	ext = string.lower(ext)
+	if self.extensions_map.has_key(ext):
+	    return self.extensions_map[ext]
+	else:
+	    return self.extensions_map['']
+
+    extensions_map = {
+	    '': 'text/plain',	# Default, *must* be present
+	    '.html': 'text/html',
+	    '.htm': 'text/html',
+	    '.gif': 'image/gif',
+	    '.jpg': 'image/jpeg',
+	    '.jpeg': 'image/jpeg',
+	    }
+
+
+def test(HandlerClass = SimpleHTTPRequestHandler,
+	 ServerClass = SocketServer.TCPServer):
+    BaseHTTPServer.test(HandlerClass, ServerClass)
+
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/dos-8x3/socketse.py b/Lib/dos-8x3/socketse.py
new file mode 100755
index 0000000..9a646ab
--- /dev/null
+++ b/Lib/dos-8x3/socketse.py
@@ -0,0 +1,413 @@
+"""Generic socket server classes.
+
+This module tries to capture the various aspects of defining a server:
+
+- address family:
+	- AF_INET: IP (Internet Protocol) sockets (default)
+	- AF_UNIX: Unix domain sockets
+	- others, e.g. AF_DECNET are conceivable (see <socket.h>
+- socket type:
+	- SOCK_STREAM (reliable stream, e.g. TCP)
+	- SOCK_DGRAM (datagrams, e.g. UDP)
+- client address verification before further looking at the request
+	(This is actually a hook for any processing that needs to look
+	 at the request before anything else, e.g. logging)
+- how to handle multiple requests:
+	- synchronous (one request is handled at a time)
+	- forking (each request is handled by a new process)
+	- threading (each request is handled by a new thread)
+
+The classes in this module favor the server type that is simplest to
+write: a synchronous TCP/IP server.  This is bad class design, but
+save some typing.  (There's also the issue that a deep class hierarchy
+slows down method lookups.)
+
+There are four classes in an inheritance diagram that represent
+synchronous servers of four types:
+
+	+-----------+        +------------------+
+	| TCPServer |------->| UnixStreamServer |
+	+-----------+        +------------------+
+	      |
+	      v
+	+-----------+        +--------------------+
+	| UDPServer |------->| UnixDatagramServer |
+	+-----------+        +--------------------+
+
+(Note that UnixDatagramServer derives from UDPServer, not from
+UnixStreamServer -- the only difference between an IP and a Unix
+stream server is the address family, which is simply repeated in both
+unix server classes.)
+
+Forking and threading versions of each type of server can be created
+using the ForkingServer and ThreadingServer mix-in classes.  For
+instance, a threading UDP server class is created as follows:
+
+	class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
+
+(The Mix-in class must come first, since it overrides a method defined
+in UDPServer!)
+
+To implement a service, you must derive a class from
+BaseRequestHandler and redefine its handle() method.  You can then run
+various versions of the service by combining one of the server classes
+with your request handler class.
+
+The request handler class must be different for datagram or stream
+services.  This can be hidden by using the mix-in request handler
+classes StreamRequestHandler or DatagramRequestHandler.
+
+Of course, you still have to use your head!
+
+For instance, it makes no sense to use a forking server if the service
+contains state in memory that can be modified by requests (since the
+modifications in the child process would never reach the initial state
+kept in the parent process and passed to each child).  In this case,
+you can use a threading server, but you will probably have to use
+locks to avoid two requests that come in nearly simultaneous to apply
+conflicting changes to the server state.
+
+On the other hand, if you are building e.g. an HTTP server, where all
+data is stored externally (e.g. in the file system), a synchronous
+class will essentially render the service "deaf" while one request is
+being handled -- which may be for a very long time if a client is slow
+to reqd all the data it has requested.  Here a threading or forking
+server is appropriate.
+
+In some cases, it may be appropriate to process part of a request
+synchronously, but to finish processing in a forked child depending on
+the request data.  This can be implemented by using a synchronous
+server and doing an explicit fork in the request handler class's
+handle() method.
+
+Another approach to handling multiple simultaneous requests in an
+environment that supports neither threads nor fork (or where these are
+too expensive or inappropriate for the service) is to maintain an
+explicit table of partially finished requests and to use select() to
+decide which request to work on next (or whether to handle a new
+incoming request).  This is particularly important for stream services
+where each client can potentially be connected for a long time (if
+threads or subprocesses can't be used).
+
+Future work:
+- Standard classes for Sun RPC (which uses either UDP or TCP)
+- Standard mix-in classes to implement various authentication
+  and encryption schemes
+- Standard framework for select-based multiplexing
+
+XXX Open problems:
+- What to do with out-of-band data?
+
+"""
+
+
+__version__ = "0.2"
+
+
+import socket
+import sys
+import os
+
+
+class TCPServer:
+
+    """Base class for various socket-based server classes.
+
+    Defaults to synchronous IP stream (i.e., TCP).
+
+    Methods for the caller:
+
+    - __init__(server_address, RequestHandlerClass)
+    - serve_forever()
+    - handle_request()	# if you don't use serve_forever()
+    - fileno() -> int	# for select()
+
+    Methods that may be overridden:
+
+    - server_bind()
+    - server_activate()
+    - get_request() -> request, client_address
+    - verify_request(request, client_address)
+    - process_request(request, client_address)
+    - handle_error()
+
+    Methods for derived classes:
+
+    - finish_request(request, client_address)
+
+    Class variables that may be overridden by derived classes or
+    instances:
+
+    - address_family
+    - socket_type
+    - request_queue_size (only for stream sockets)
+
+    Instance variables:
+
+    - server_address
+    - RequestHandlerClass
+    - socket
+
+    """
+
+    address_family = socket.AF_INET
+
+    socket_type = socket.SOCK_STREAM
+
+    request_queue_size = 5
+
+    def __init__(self, server_address, RequestHandlerClass):
+	"""Constructor.  May be extended, do not override."""
+	self.server_address = server_address
+	self.RequestHandlerClass = RequestHandlerClass
+	self.socket = socket.socket(self.address_family,
+				    self.socket_type)
+	self.server_bind()
+	self.server_activate()
+
+    def server_bind(self):
+	"""Called by constructor to bind the socket.
+
+	May be overridden.
+
+	"""
+	self.socket.bind(self.server_address)
+
+    def server_activate(self):
+	"""Called by constructor to activate the server.
+
+	May be overridden.
+
+	"""
+	self.socket.listen(self.request_queue_size)
+
+    def fileno(self):
+	"""Return socket file number.
+
+	Interface required by select().
+
+	"""
+	return self.socket.fileno()
+
+    def serve_forever(self):
+	"""Handle one request at a time until doomsday."""
+	while 1:
+	    self.handle_request()
+
+    # The distinction between handling, getting, processing and
+    # finishing a request is fairly arbitrary.  Remember:
+    #
+    # - handle_request() is the top-level call.  It calls
+    #   get_request(), verify_request() and process_request()
+    # - get_request() is different for stream or datagram sockets
+    # - process_request() is the place that may fork a new process
+    #   or create a new thread to finish the request
+    # - finish_request() instantiates the request handler class;
+    #   this constructor will handle the request all by itself
+
+    def handle_request(self):
+	"""Handle one request, possibly blocking."""
+	request, client_address = self.get_request()
+	if self.verify_request(request, client_address):
+	    try:
+		self.process_request(request, client_address)
+	    except:
+		self.handle_error(request, client_address)
+
+    def get_request(self):
+	"""Get the request and client address from the socket.
+
+	May be overridden.
+
+	"""
+	return self.socket.accept()
+
+    def verify_request(self, request, client_address):
+	"""Verify the request.  May be overridden.
+
+	Return true if we should proceed with this request.
+
+	"""
+	return 1
+
+    def process_request(self, request, client_address):
+	"""Call finish_request.
+
+	Overridden by ForkingMixIn and ThreadingMixIn.
+
+	"""
+	self.finish_request(request, client_address)
+
+    def finish_request(self, request, client_address):
+	"""Finish one request by instantiating RequestHandlerClass."""
+	self.RequestHandlerClass(request, client_address, self)
+
+    def handle_error(self, request, client_address):
+	"""Handle an error gracefully.  May be overridden.
+
+	The default is to print a traceback and continue.
+
+	"""
+	exc, value, tb = sys.exc_type, sys.exc_value, sys.exc_traceback
+	print '-'*40
+	print 'Exception happened during processing of request from',
+	print client_address
+	import traceback
+	traceback.print_exception(exc, value, tb)
+	print '-'*40
+
+
+class UDPServer(TCPServer):
+
+    """UDP server class."""
+
+    socket_type = socket.SOCK_DGRAM
+
+    max_packet_size = 8192
+
+    def get_request(self):
+	return self.socket.recvfrom(max_packet_size)
+
+
+if hasattr(socket, 'AF_UNIX'):
+
+    class UnixStreamServer(TCPServer):
+
+	address_family = socket.AF_UNIX
+
+
+    class UnixDatagramServer(UDPServer):
+
+	address_family = socket.AF_UNIX
+
+
+class ForkingMixIn:
+
+    """Mix-in class to handle each request in a new process."""
+
+    active_children = None
+
+    def collect_children(self):
+	"""Internal routine to wait for died children."""
+	while self.active_children:
+	    pid, status = os.waitpid(0, os.WNOHANG)
+	    if not pid: break
+	    self.active_children.remove(pid)
+
+    def process_request(self, request, client_address):
+	"""Fork a new subprocess to process the request."""
+	self.collect_children()
+	pid = os.fork()
+	if pid:
+	    # Parent process
+	    if self.active_children is None:
+		self.active_children = []
+	    self.active_children.append(pid)
+	    return
+	else:
+	    # Child process.
+	    # This must never return, hence os._exit()!
+	    try:
+		self.finish_request(request, client_address)
+		os._exit(0)
+	    except:
+		try:
+		    self.handle_error(request,
+				      client_address)
+		finally:
+		    os._exit(1)
+
+
+class ThreadingMixIn:
+
+    """Mix-in class to handle each request in a new thread."""
+
+    def process_request(self, request, client_address):
+	"""Start a new thread to process the request."""
+	import thread
+	thread.start_new_thread(self.finish_request,
+				(request, client_address))
+
+
+class ForkingUDPServer(ForkingMixIn, UDPServer): pass
+class ForkingTCPServer(ForkingMixIn, TCPServer): pass
+
+class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
+class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
+
+
+class BaseRequestHandler:
+
+    """Base class for request handler classes.
+
+    This class is instantiated for each request to be handled.  The
+    constructor sets the instance variables request, client_address
+    and server, and then calls the handle() method.  To implement a
+    specific service, all you need to do is to derive a class which
+    defines a handle() method.
+
+    The handle() method can find the request as self.request, the
+    client address as self.client_request, and the server (in case it
+    needs access to per-server information) as self.server.  Since a
+    separate instance is created for each request, the handle() method
+    can define arbitrary other instance variariables.
+
+    """
+
+    def __init__(self, request, client_address, server):
+	self.request = request
+	self.client_address = client_address
+	self.server = server
+	try:
+	    self.setup()
+	    self.handle()
+	    self.finish()
+	finally:
+	    sys.exc_traceback = None	# Help garbage collection
+
+    def setup(self):
+	pass
+
+    def __del__(self):
+	pass
+
+    def handle(self):
+	pass
+
+    def finish(self):
+	pass
+
+
+# The following two classes make it possible to use the same service
+# class for stream or datagram servers.
+# Each class sets up these instance variables:
+# - rfile: a file object from which receives the request is read
+# - wfile: a file object to which the reply is written
+# When the handle() method returns, wfile is flushed properly
+
+
+class StreamRequestHandler(BaseRequestHandler):
+
+    """Define self.rfile and self.wfile for stream sockets."""
+
+    def setup(self):
+	self.connection = self.request
+	self.rfile = self.connection.makefile('rb')
+	self.wfile = self.connection.makefile('wb', 0)
+
+    def finish(self):
+	self.wfile.flush()
+
+
+class DatagramRequestHandler(BaseRequestHandler):
+
+    """Define self.rfile and self.wfile for datagram sockets."""
+
+    def setup(self):
+	import StringIO
+	self.packet, self.socket = self.request
+	self.rfile = StringIO.StringIO(self.packet)
+	self.wfile = StringIO.StringIO(self.packet)
+
+    def finish(self):
+	self.socket.send(self.wfile.getvalue())
diff --git a/Lib/dos-8x3/statcach.py b/Lib/dos-8x3/statcach.py
new file mode 100755
index 0000000..770aef0
--- /dev/null
+++ b/Lib/dos-8x3/statcach.py
@@ -0,0 +1,82 @@
+# Module 'statcache'
+#
+# Maintain a cache of file stats.
+# There are functions to reset the cache or to selectively remove items.
+
+import os
+from stat import *
+
+# The cache.
+# Keys are pathnames, values are `os.stat' outcomes.
+#
+cache = {}
+
+
+# Stat a file, possibly out of the cache.
+#
+def stat(path):
+	if cache.has_key(path):
+		return cache[path]
+	cache[path] = ret = os.stat(path)
+	return ret
+
+
+# Reset the cache completely.
+#
+def reset():
+	global cache
+	cache = {}
+
+
+# Remove a given item from the cache, if it exists.
+#
+def forget(path):
+	if cache.has_key(path):
+		del cache[path]
+
+
+# Remove all pathnames with a given prefix.
+#
+def forget_prefix(prefix):
+	n = len(prefix)
+	for path in cache.keys():
+		if path[:n] == prefix:
+			del cache[path]
+
+
+# Forget about a directory and all entries in it, but not about
+# entries in subdirectories.
+#
+def forget_dir(prefix):
+	if prefix[-1:] == '/' and prefix <> '/':
+		prefix = prefix[:-1]
+	forget(prefix)
+	if prefix[-1:] <> '/':
+		prefix = prefix + '/'
+	n = len(prefix)
+	for path in cache.keys():
+		if path[:n] == prefix:
+			rest = path[n:]
+			if rest[-1:] == '/': rest = rest[:-1]
+			if '/' not in rest:
+				del cache[path]
+
+
+# Remove all pathnames except with a given prefix.
+# Normally used with prefix = '/' after a chdir().
+#
+def forget_except_prefix(prefix):
+	n = len(prefix)
+	for path in cache.keys():
+		if path[:n] <> prefix:
+			del cache[path]
+
+
+# Check for directory.
+#
+def isdir(path):
+	try:
+		st = stat(path)
+	except os.error:
+		return 0
+	return S_ISDIR(st[ST_MODE])
diff --git a/Lib/dos-8x3/stringio.py b/Lib/dos-8x3/stringio.py
new file mode 100755
index 0000000..bbd9428
--- /dev/null
+++ b/Lib/dos-8x3/stringio.py
@@ -0,0 +1,156 @@
+# class StringIO implements  file-like objects that read/write a
+# string buffer (a.k.a. "memory files").
+#
+# This implements (nearly) all stdio methods.
+#
+# f = StringIO()      # ready for writing
+# f = StringIO(buf)   # ready for reading
+# f.close()           # explicitly release resources held
+# flag = f.isatty()   # always false
+# pos = f.tell()      # get current position
+# f.seek(pos)         # set current position
+# f.seek(pos, mode)   # mode 0: absolute; 1: relative; 2: relative to EOF
+# buf = f.read()      # read until EOF
+# buf = f.read(n)     # read up to n bytes
+# buf = f.readline()  # read until end of line ('\n') or EOF
+# list = f.readlines()# list of f.readline() results until EOF
+# f.write(buf)        # write at current position
+# f.writelines(list)  # for line in list: f.write(line)
+# f.getvalue()        # return whole file's contents as a string
+#
+# Notes:
+# - Using a real file is often faster (but less convenient).
+# - fileno() is left unimplemented so that code which uses it triggers
+#   an exception early.
+# - Seeking far beyond EOF and then writing will insert real null
+#   bytes that occupy space in the buffer.
+# - There's a simple test set (see end of this file).
+
+import string
+
+class StringIO:
+	def __init__(self, buf = ''):
+		self.buf = buf
+		self.len = len(buf)
+		self.buflist = []
+		self.pos = 0
+		self.closed = 0
+		self.softspace = 0
+	def close(self):
+		if not self.closed:
+			self.closed = 1
+			del self.buf, self.pos
+	def isatty(self):
+		return 0
+	def seek(self, pos, mode = 0):
+		if self.buflist:
+			self.buf = self.buf + string.joinfields(self.buflist, '')
+			self.buflist = []
+		if mode == 1:
+			pos = pos + self.pos
+		elif mode == 2:
+			pos = pos + self.len
+		self.pos = max(0, pos)
+	def tell(self):
+		return self.pos
+	def read(self, n = -1):
+		if self.buflist:
+			self.buf = self.buf + string.joinfields(self.buflist, '')
+			self.buflist = []
+		if n < 0:
+			newpos = self.len
+		else:
+			newpos = min(self.pos+n, self.len)
+		r = self.buf[self.pos:newpos]
+		self.pos = newpos
+		return r
+	def readline(self):
+		if self.buflist:
+			self.buf = self.buf + string.joinfields(self.buflist, '')
+			self.buflist = []
+		i = string.find(self.buf, '\n', self.pos)
+		if i < 0:
+			newpos = self.len
+		else:
+			newpos = i+1
+		r = self.buf[self.pos:newpos]
+		self.pos = newpos
+		return r
+	def readlines(self):
+		lines = []
+		line = self.readline()
+		while line:
+			lines.append(line)
+			line = self.readline()
+		return lines
+	def write(self, s):
+		if not s: return
+		if self.pos > self.len:
+			self.buflist.append('\0'*(self.pos - self.len))
+			self.len = self.pos
+		newpos = self.pos + len(s)
+		if self.pos < self.len:
+			if self.buflist:
+				self.buf = self.buf + string.joinfields(self.buflist, '')
+				self.buflist = []
+			self.buflist = [self.buf[:self.pos], s, self.buf[newpos:]]
+			self.buf = ''
+		else:
+			self.buflist.append(s)
+			self.len = newpos
+		self.pos = newpos
+	def writelines(self, list):
+		self.write(string.joinfields(list, ''))
+	def flush(self):
+		pass
+	def getvalue(self):
+		if self.buflist:
+			self.buf = self.buf + string.joinfields(self.buflist, '')
+			self.buflist = []
+		return self.buf
+
+
+# A little test suite
+
+def test():
+	import sys
+	if sys.argv[1:]:
+		file = sys.argv[1]
+	else:
+		file = '/etc/passwd'
+	lines = open(file, 'r').readlines()
+	text = open(file, 'r').read()
+	f = StringIO()
+	for line in lines[:-2]:
+		f.write(line)
+	f.writelines(lines[-2:])
+	if f.getvalue() != text:
+		raise RuntimeError, 'write failed'
+	length = f.tell()
+	print 'File length =', length
+	f.seek(len(lines[0]))
+	f.write(lines[1])
+	f.seek(0)
+	print 'First line =', `f.readline()`
+	here = f.tell()
+	line = f.readline()
+	print 'Second line =', `line`
+	f.seek(-len(line), 1)
+	line2 = f.read(len(line))
+	if line != line2:
+		raise RuntimeError, 'bad result after seek back'
+	f.seek(len(line2), 1)
+	list = f.readlines()
+	line = list[-1]
+	f.seek(f.tell() - len(line))
+	line2 = f.read()
+	if line != line2:
+		raise RuntimeError, 'bad result after seek back from EOF'
+	print 'Read', len(list), 'more lines'
+	print 'File length =', f.tell()
+	if f.tell() != length:
+		raise RuntimeError, 'bad length'
+	f.close()
+
+if __name__ == '__main__':
+	test()
diff --git a/Lib/dos-8x3/test_aud.py b/Lib/dos-8x3/test_aud.py
new file mode 100755
index 0000000..3acf1bf
--- /dev/null
+++ b/Lib/dos-8x3/test_aud.py
@@ -0,0 +1,202 @@
+# Test audioop.
+import audioop
+
+def gendata1():
+	return '\0\1\2'
+
+def gendata2():
+	if audioop.getsample('\0\1', 2, 0) == 1:
+		return '\0\0\0\1\0\2'
+	else:
+		return '\0\0\1\0\2\0'
+
+def gendata4():
+	if audioop.getsample('\0\0\0\1', 4, 0) == 1:
+		return '\0\0\0\0\0\0\0\1\0\0\0\2'
+	else:
+		return '\0\0\0\0\1\0\0\0\2\0\0\0'
+
+def testmax(data):
+	if audioop.max(data[0], 1) <> 2 or \
+		  audioop.max(data[1], 2) <> 2 or \
+		  audioop.max(data[2], 4) <> 2:
+		return 0
+	return 1
+
+def testmaxpp(data):
+	if audioop.maxpp(data[0], 1) <> 0 or \
+		  audioop.maxpp(data[1], 2) <> 0 or \
+		  audioop.maxpp(data[2], 4) <> 0:
+		return 0
+	return 1
+
+def testavg(data):
+	if audioop.avg(data[0], 1) <> 1 or \
+		  audioop.avg(data[1], 2) <> 1 or \
+		  audioop.avg(data[2], 4) <> 1:
+		return 0
+	return 1
+
+def testavgpp(data):
+	if audioop.avgpp(data[0], 1) <> 0 or \
+		  audioop.avgpp(data[1], 2) <> 0 or \
+		  audioop.avgpp(data[2], 4) <> 0:
+		return 0
+	return 1
+
+def testrms(data):
+	if audioop.rms(data[0], 1) <> 1 or \
+		  audioop.rms(data[1], 2) <> 1 or \
+		  audioop.rms(data[2], 4) <> 1:
+		return 0
+	return 1
+
+def testcross(data):
+	if audioop.cross(data[0], 1) <> 0 or \
+		  audioop.cross(data[1], 2) <> 0 or \
+		  audioop.cross(data[2], 4) <> 0:
+		return 0
+	return 1
+
+def testadd(data):
+	data2 = []
+	for d in data:
+		str = ''
+		for s in d:
+			str = str + chr(ord(s)*2)
+		data2.append(str)
+	if audioop.add(data[0], data[0], 1) <> data2[0] or \
+		  audioop.add(data[1], data[1], 2) <> data2[1] or \
+		  audioop.add(data[2], data[2], 4) <> data2[2]:
+		return 0
+	return 1
+
+def testbias(data):
+	# Note: this test assumes that avg() works
+	d1 = audioop.bias(data[0], 1, 100)
+	d2 = audioop.bias(data[1], 2, 100)
+	d4 = audioop.bias(data[2], 4, 100)
+	if audioop.avg(d1, 1) <> 101 or \
+		  audioop.avg(d2, 2) <> 101 or \
+		  audioop.avg(d4, 4) <> 101:
+		return 0
+	return 1
+
+def testlin2lin(data):
+	# too simple: we test only the size
+	for d1 in data:
+		for d2 in data:
+			got = len(d1)/3
+			wtd = len(d2)/3
+			if len(audioop.lin2lin(d1, got, wtd)) <> len(d2):
+				return 0
+	return 1
+
+def testadpcm2lin(data):
+	# Very cursory test
+	if audioop.adpcm2lin('\0\0', 1, None) <> ('\0\0\0\0', (0,0)):
+		return 0
+	return 1
+
+def testlin2adpcm(data):
+	# Very cursory test
+	if audioop.lin2adpcm('\0\0\0\0', 1, None) <> ('\0\0', (0,0)):
+		return 0
+	return 1
+
+def testlin2ulaw(data):
+	if audioop.lin2ulaw(data[0], 1) <> '\377\347\333' or \
+		  audioop.lin2ulaw(data[1], 2) <> '\377\377\377' or \
+		  audioop.lin2ulaw(data[2], 4) <> '\377\377\377':
+		return 0
+	return 1
+
+def testulaw2lin(data):
+	# Cursory
+	d = audioop.lin2ulaw(data[0], 1)
+	if audioop.ulaw2lin(d, 1) <> data[0]:
+		return 0
+	return 1
+
+def testmul(data):
+	data2 = []
+	for d in data:
+		str = ''
+		for s in d:
+			str = str + chr(ord(s)*2)
+		data2.append(str)
+	if audioop.mul(data[0], 1, 2) <> data2[0] or \
+		  audioop.mul(data[1],2, 2) <> data2[1] or \
+		  audioop.mul(data[2], 4, 2) <> data2[2]:
+		return 0
+	return 1
+
+def testreverse(data):
+	if audioop.reverse(data[0], 1) <> '\2\1\0':
+		return 0
+	return 1
+
+def testtomono(data):
+	data2 = ''
+	for d in data[0]:
+		data2 = data2 + d + d
+	if audioop.tomono(data2, 1, 0.5, 0.5) <> data[0]:
+		return 0
+	return 1
+
+def testtostereo(data):
+	data2 = ''
+	for d in data[0]:
+		data2 = data2 + d + d
+	if audioop.tostereo(data[0], 1, 1, 1) <> data2:
+		return 0
+	return 1
+
+def testfindfactor(data):
+	if audioop.findfactor(data[1], data[1]) <> 1.0:
+		return 0
+	return 1
+
+def testfindfit(data):
+	if audioop.findfit(data[1], data[1]) <> (0, 1.0):
+		return 0
+	return 1
+
+def testfindmax(data):
+	if audioop.findmax(data[1], 1) <> 2:
+		return 0
+	return 1
+
+def testgetsample(data):
+	for i in range(3):
+		if audioop.getsample(data[0], 1, i) <> i or \
+			  audioop.getsample(data[1], 2, i) <> i or \
+			  audioop.getsample(data[2], 4, i) <> i:
+			return 0
+	return 1
+
+def testone(name, data):
+	try:
+		func = eval('test'+name)
+	except NameError:
+		print 'No test found for audioop.'+name+'()'
+		return
+	try:
+		rv = func(data)
+	except 'xx':
+		print 'Test FAILED for audioop.'+name+'() (with an exception)'
+		return
+	if not rv:
+		print 'Test FAILED for audioop.'+name+'()'
+
+def testall():
+	data = [gendata1(), gendata2(), gendata4()]
+	names = dir(audioop)
+	# We know there is a routine 'add'
+	routines = []
+	for n in names:
+		if type(eval('audioop.'+n)) == type(audioop.add):
+			routines.append(n)
+	for n in routines:
+		testone(n, data)
+testall()
diff --git a/Lib/dos-8x3/test_bui.py b/Lib/dos-8x3/test_bui.py
new file mode 100755
index 0000000..33fef8d
--- /dev/null
+++ b/Lib/dos-8x3/test_bui.py
@@ -0,0 +1,13 @@
+# Python test set -- part 4, built-in functions
+
+from test_support import *
+
+print '4. Built-in functions'
+
+print 'test_b1'
+unload('test_b1')
+import test_b1
+
+print 'test_b2'
+unload('test_b2')
+import test_b2
diff --git a/Lib/dos-8x3/test_exc.py b/Lib/dos-8x3/test_exc.py
new file mode 100755
index 0000000..4fbee3e
--- /dev/null
+++ b/Lib/dos-8x3/test_exc.py
@@ -0,0 +1,92 @@
+# Python test set -- part 5, built-in exceptions
+
+from test_support import *
+
+print '5. Built-in exceptions'
+# XXX This is not really enough, each *operation* should be tested!
+
+def r(name): print name
+
+r(AttributeError)
+import sys
+try: x = sys.undefined_attribute
+except AttributeError: pass
+
+r(EOFError)
+import sys
+fp = open(TESTFN, 'w')
+fp.close()
+fp = open(TESTFN, 'r')
+savestdin = sys.stdin
+try:
+	try:
+		sys.stdin = fp
+		x = raw_input()
+	except EOFError:
+		pass
+finally:
+	sys.stdin = savestdin
+	fp.close()
+
+r(IOError)
+try: open('this file does not exist', 'r')
+except IOError: pass
+
+r(ImportError)
+try: import undefined_module
+except ImportError: pass
+
+r(IndexError)
+x = []
+try: a = x[10]
+except IndexError: pass
+
+r(KeyError)
+x = {}
+try: a = x['key']
+except KeyError: pass
+
+r(KeyboardInterrupt)
+print '(not testable in a script)'
+
+r(MemoryError)
+print '(not safe to test)'
+
+r(NameError)
+try: x = undefined_variable
+except NameError: pass
+
+r(OverflowError)
+x = 1
+try:
+	while 1: x = x+x
+except OverflowError: pass
+
+r(RuntimeError)
+print '(not used any more?)'
+
+r(SyntaxError)
+try: exec '/\n'
+except SyntaxError: pass
+
+r(SystemError)
+print '(hard to reproduce)'
+
+r(SystemExit)
+import sys
+try: sys.exit(0)
+except SystemExit: pass
+
+r(TypeError)
+try: [] + ()
+except TypeError: pass
+
+r(ValueError)
+try: x = chr(10000)
+except ValueError: pass
+
+r(ZeroDivisionError)
+try: x = 1/0
+except ZeroDivisionError: pass
+
+unlink(TESTFN)
diff --git a/Lib/dos-8x3/test_gra.py b/Lib/dos-8x3/test_gra.py
new file mode 100755
index 0000000..b9607ac
--- /dev/null
+++ b/Lib/dos-8x3/test_gra.py
@@ -0,0 +1,513 @@
+# Python test set -- part 1, grammar.
+# This just tests whether the parser accepts them all.
+
+from test_support import *
+
+print '1. Parser'
+
+print '1.1 Tokens'
+
+print '1.1.1 Backslashes'
+
+# Backslash means line continuation:
+x = 1 \
++ 1
+if x <> 2: raise TestFailed, 'backslash for line continuation'
+
+# Backslash does not means continuation in comments :\
+x = 0
+if x <> 0: raise TestFailed, 'backslash ending comment'
+
+print '1.1.2 Numeric literals'
+
+print '1.1.2.1 Plain integers'
+if 0xff <> 255: raise TestFailed, 'hex int'
+if 0377 <> 255: raise TestFailed, 'octal int'
+if  2147483647   != 017777777777: raise TestFailed, 'large positive int'
+try:
+	from sys import maxint
+except ImportError:
+	maxint = 2147483647
+if maxint == 2147483647:
+	if -2147483647-1 != 020000000000: raise TestFailed, 'max negative int'
+	# XXX -2147483648
+	if 037777777777 != -1: raise TestFailed, 'oct -1'
+	if 0xffffffff != -1: raise TestFailed, 'hex -1'
+	for s in '2147483648', '040000000000', '0x100000000':
+		try:
+			x = eval(s)
+		except OverflowError:
+			continue
+##		raise TestFailed, \
+		print \
+			  'No OverflowError on huge integer literal ' + `s`
+elif eval('maxint == 9223372036854775807'):
+	if eval('-9223372036854775807-1 != 01000000000000000000000'):
+		raise TestFailed, 'max negative int'
+	if eval('01777777777777777777777') != -1: raise TestFailed, 'oct -1'
+	if eval('0xffffffffffffffff') != -1: raise TestFailed, 'hex -1'
+	for s in '9223372036854775808', '02000000000000000000000', \
+		 '0x10000000000000000':
+		try:
+			x = eval(s)
+		except OverflowError:
+			continue
+		raise TestFailed, \
+			  'No OverflowError on huge integer literal ' + `s`
+else:
+	print 'Weird maxint value', maxint
+
+print '1.1.2.2 Long integers'
+x = 0L
+x = 0l
+x = 0xffffffffffffffffL
+x = 0xffffffffffffffffl
+x = 077777777777777777L
+x = 077777777777777777l
+x = 123456789012345678901234567890L
+x = 123456789012345678901234567890l
+
+print '1.1.2.3 Floating point'
+x = 3.14
+x = 314.
+x = 0.314
+# XXX x = 000.314
+x = .314
+x = 3e14
+x = 3E14
+x = 3e-14
+x = 3e+14
+x = 3.e14
+x = .3e14
+x = 3.1e4
+
+print '1.1.3 String literals'
+
+def assert(s):
+	if not s: raise TestFailed, 'see traceback'
+
+x = ''; y = ""; assert(len(x) == 0 and x == y)
+x = '\''; y = "'"; assert(len(x) == 1 and x == y and ord(x) == 39)
+x = '"'; y = "\""; assert(len(x) == 1 and x == y and ord(x) == 34)
+x = "doesn't \"shrink\" does it"
+y = 'doesn\'t "shrink" does it'
+assert(len(x) == 24 and x == y)
+x = "does \"shrink\" doesn't it"
+y = 'does "shrink" doesn\'t it'
+assert(len(x) == 24 and x == y)
+x = """
+The "quick"
+brown fox
+jumps over
+the 'lazy' dog.
+"""
+y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
+assert(x == y)
+y = '''
+The "quick"
+brown fox
+jumps over
+the 'lazy' dog.
+'''; assert(x == y)
+y = "\n\
+The \"quick\"\n\
+brown fox\n\
+jumps over\n\
+the 'lazy' dog.\n\
+"; assert(x == y)
+y = '\n\
+The \"quick\"\n\
+brown fox\n\
+jumps over\n\
+the \'lazy\' dog.\n\
+'; assert(x == y)
+
+
+print '1.2 Grammar'
+
+print 'single_input' # NEWLINE | simple_stmt | compound_stmt NEWLINE
+# XXX can't test in a script -- this rule is only used when interactive
+
+print 'file_input' # (NEWLINE | stmt)* ENDMARKER
+# Being tested as this very moment this very module
+
+print 'expr_input' # testlist NEWLINE
+# XXX Hard to test -- used only in calls to input()
+
+print 'eval_input' # testlist ENDMARKER
+x = eval('1, 0 or 1')
+
+print 'funcdef'
+### 'def' NAME parameters ':' suite
+### parameters: '(' [varargslist] ')'
+### varargslist: (fpdef ['=' test] ',')* '*' NAME
+###            | fpdef ['=' test] (',' fpdef ['=' test])* [',']
+### fpdef: NAME | '(' fplist ')'
+### fplist: fpdef (',' fpdef)* [',']
+def f1(): pass
+def f2(one_argument): pass
+def f3(two, arguments): pass
+def f4(two, (compound, (argument, list))): pass
+def a1(one_arg,): pass
+def a2(two, args,): pass
+def v0(*rest): pass
+def v1(a, *rest): pass
+def v2(a, b, *rest): pass
+def v3(a, (b, c), *rest): pass
+def d01(a=1): pass
+d01()
+d01(1)
+def d11(a, b=1): pass
+d11(1)
+d11(1, 2)
+def d21(a, b, c=1): pass
+d21(1, 2)
+d21(1, 2, 3)
+def d02(a=1, b=2): pass
+d02()
+d02(1)
+d02(1, 2)
+def d12(a, b=1, c=2): pass
+d12(1)
+d12(1, 2)
+d12(1, 2, 3)
+def d22(a, b, c=1, d=2): pass
+d22(1, 2)
+d22(1, 2, 3)
+d22(1, 2, 3, 4)
+def d01v(a=1, *rest): pass
+d01v()
+d01v(1)
+d01v(1, 2)
+def d11v(a, b=1, *rest): pass
+d11v(1)
+d11v(1, 2)
+d11v(1, 2, 3)
+def d21v(a, b, c=1, *rest): pass
+d21v(1, 2)
+d21v(1, 2, 3)
+d21v(1, 2, 3, 4)
+def d02v(a=1, b=2, *rest): pass
+d02v()
+d02v(1)
+d02v(1, 2)
+d02v(1, 2, 3)
+def d12v(a, b=1, c=2, *rest): pass
+d12v(1)
+d12v(1, 2)
+d12v(1, 2, 3)
+d12v(1, 2, 3, 4)
+def d22v(a, b, c=1, d=2, *rest): pass
+d22v(1, 2)
+d22v(1, 2, 3)
+d22v(1, 2, 3, 4)
+d22v(1, 2, 3, 4, 5)
+
+### stmt: simple_stmt | compound_stmt
+# Tested below
+
+### simple_stmt: small_stmt (';' small_stmt)* [';']
+print 'simple_stmt'
+x = 1; pass; del x
+
+### small_stmt: expr_stmt | print_stmt  | pass_stmt | del_stmt | flow_stmt | import_stmt | global_stmt | access_stmt | exec_stmt
+# Tested below
+
+print 'expr_stmt' # (exprlist '=')* exprlist
+1
+1, 2, 3
+x = 1
+x = 1, 2, 3
+x = y = z = 1, 2, 3
+x, y, z = 1, 2, 3
+abc = a, b, c = x, y, z = xyz = 1, 2, (3, 4)
+# NB these variables are deleted below
+
+print 'print_stmt' # 'print' (test ',')* [test]
+print 1, 2, 3
+print 1, 2, 3,
+print
+print 0 or 1, 0 or 1,
+print 0 or 1
+
+print 'del_stmt' # 'del' exprlist
+del abc
+del x, y, (z, xyz)
+
+print 'pass_stmt' # 'pass'
+pass
+
+print 'flow_stmt' # break_stmt | continue_stmt | return_stmt | raise_stmt
+# Tested below
+
+print 'break_stmt' # 'break'
+while 1: break
+
+print 'continue_stmt' # 'continue'
+i = 1
+while i: i = 0; continue
+
+print 'return_stmt' # 'return' [testlist]
+def g1(): return
+def g2(): return 1
+g1()
+x = g2()
+
+print 'raise_stmt' # 'raise' test [',' test]
+try: raise RuntimeError, 'just testing'
+except RuntimeError: pass
+try: raise KeyboardInterrupt
+except KeyboardInterrupt: pass
+
+print 'import_stmt' # 'import' NAME (',' NAME)* | 'from' NAME 'import' ('*' | NAME (',' NAME)*)
+import sys
+import time, sys
+from time import time
+from sys import *
+from sys import path, argv
+
+print 'global_stmt' # 'global' NAME (',' NAME)*
+def f():
+	global a
+	global a, b
+	global one, two, three, four, five, six, seven, eight, nine, ten
+
+print 'exec_stmt' # 'exec' expr ['in' expr [',' expr]]
+def f():
+	z = None
+	del z
+	exec 'z=1+1\n'
+	if z <> 2: raise TestFailed, 'exec \'z=1+1\'\\n'
+	del z
+	exec 'z=1+1'
+	if z <> 2: raise TestFailed, 'exec \'z=1+1\''
+f()
+g = {}
+exec 'z = 1' in g
+if g.has_key('__builtins__'): del g['__builtins__']
+if g <> {'z': 1}: raise TestFailed, 'exec \'z = 1\' in g'
+g = {}
+l = {}
+exec 'global a; a = 1; b = 2' in g, l
+if g.has_key('__builtins__'): del g['__builtins__']
+if l.has_key('__builtins__'): del l['__builtins__']
+if (g, l) <> ({'a':1}, {'b':2}): raise TestFailed, 'exec ... in g, l'
+
+
+### compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
+# Tested below
+
+print 'if_stmt' # 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+if 1: pass
+if 1: pass
+else: pass
+if 0: pass
+elif 0: pass
+if 0: pass
+elif 0: pass
+elif 0: pass
+elif 0: pass
+else: pass
+
+print 'while_stmt' # 'while' test ':' suite ['else' ':' suite]
+while 0: pass
+while 0: pass
+else: pass
+
+print 'for_stmt' # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
+for i in 1, 2, 3: pass
+for i, j, k in (): pass
+else: pass
+class Squares:
+	def __init__(self, max):
+		self.max = max
+		self.sofar = []
+	def __len__(self): return len(self.sofar)
+	def __getitem__(self, i):
+		if not 0 <= i < self.max: raise IndexError
+		n = len(self.sofar)
+		while n <= i:
+			self.sofar.append(n*n)
+			n = n+1
+		return self.sofar[i]
+n = 0
+for x in Squares(10): n = n+x
+if n != 285: raise TestFailed, 'for over growing sequence'
+
+print 'try_stmt'
+### try_stmt: 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
+###         | 'try' ':' suite 'finally' ':' suite
+### except_clause: 'except' [expr [',' expr]]
+try:
+	1/0
+except ZeroDivisionError:
+	pass
+else:
+	pass
+try: 1/0
+except EOFError: pass
+except TypeError, msg: pass
+except RuntimeError, msg: pass
+except: pass
+else: pass
+try: 1/0
+except (EOFError, TypeError, ZeroDivisionError): pass
+try: 1/0
+except (EOFError, TypeError, ZeroDivisionError), msg: pass
+try: pass
+finally: pass
+
+print 'suite' # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
+if 1: pass
+if 1:
+	pass
+if 1:
+	#
+	#
+	#
+	pass
+	pass
+	#
+	pass
+	#
+
+print 'test'
+### and_test ('or' and_test)*
+### and_test: not_test ('and' not_test)*
+### not_test: 'not' not_test | comparison
+if not 1: pass
+if 1 and 1: pass
+if 1 or 1: pass
+if not not not 1: pass
+if not 1 and 1 and 1: pass
+if 1 and 1 or 1 and 1 and 1 or not 1 and 1: pass
+
+print 'comparison'
+### comparison: expr (comp_op expr)*
+### comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
+if 1: pass
+x = (1 == 1)
+if 1 == 1: pass
+if 1 != 1: pass
+if 1 <> 1: pass
+if 1 < 1: pass
+if 1 > 1: pass
+if 1 <= 1: pass
+if 1 >= 1: pass
+if 1 is 1: pass
+if 1 is not 1: pass
+if 1 in (): pass
+if 1 not in (): pass
+if 1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1: pass
+
+print 'binary mask ops'
+x = 1 & 1
+x = 1 ^ 1
+x = 1 | 1
+
+print 'shift ops'
+x = 1 << 1
+x = 1 >> 1
+x = 1 << 1 >> 1
+
+print 'additive ops'
+x = 1
+x = 1 + 1
+x = 1 - 1 - 1
+x = 1 - 1 + 1 - 1 + 1
+
+print 'multiplicative ops'
+x = 1 * 1
+x = 1 / 1
+x = 1 % 1
+x = 1 / 1 * 1 % 1
+
+print 'unary ops'
+x = +1
+x = -1
+x = ~1
+x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
+x = -1*1/1 + 1*1 - ---1*1
+
+print 'selectors'
+### trailer: '(' [testlist] ')' | '[' subscript ']' | '.' NAME
+### subscript: expr | [expr] ':' [expr]
+f1()
+f2(1)
+f2(1,)
+f3(1, 2)
+f3(1, 2,)
+f4(1, (2, (3, 4)))
+v0()
+v0(1)
+v0(1,)
+v0(1,2)
+v0(1,2,3,4,5,6,7,8,9,0)
+v1(1)
+v1(1,)
+v1(1,2)
+v1(1,2,3)
+v1(1,2,3,4,5,6,7,8,9,0)
+v2(1,2)
+v2(1,2,3)
+v2(1,2,3,4)
+v2(1,2,3,4,5,6,7,8,9,0)
+v3(1,(2,3))
+v3(1,(2,3),4)
+v3(1,(2,3),4,5,6,7,8,9,0)
+import sys, time
+c = sys.path[0]
+x = time.time()
+x = sys.modules['time'].time()
+a = '01234'
+c = a[0]
+c = a[-1]
+s = a[0:5]
+s = a[:5]
+s = a[0:]
+s = a[:]
+s = a[-5:]
+s = a[:-1]
+s = a[-4:-3]
+
+print 'atoms'
+### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING
+### dictmaker: test ':' test (',' test ':' test)* [',']
+
+x = (1)
+x = (1 or 2 or 3)
+x = (1 or 2 or 3, 2, 3)
+
+x = []
+x = [1]
+x = [1 or 2 or 3]
+x = [1 or 2 or 3, 2, 3]
+x = []
+
+x = {}
+x = {'one': 1}
+x = {'one': 1,}
+x = {'one' or 'two': 1 or 2}
+x = {'one': 1, 'two': 2}
+x = {'one': 1, 'two': 2,}
+x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
+
+x = `x`
+x = `1 or 2 or 3`
+x = x
+x = 'x'
+x = 123
+
+### exprlist: expr (',' expr)* [',']
+### testlist: test (',' test)* [',']
+# These have been exercised enough above
+
+print 'classdef' # 'class' NAME ['(' testlist ')'] ':' suite
+class B: pass
+class C1(B): pass
+class C2(B): pass
+class D(C1, C2, B): pass
+class C:
+	def meth1(self): pass
+	def meth2(self, arg): pass
+	def meth3(self, a1, a2): pass
diff --git a/Lib/dos-8x3/test_opc.py b/Lib/dos-8x3/test_opc.py
new file mode 100755
index 0000000..b1e944b
--- /dev/null
+++ b/Lib/dos-8x3/test_opc.py
@@ -0,0 +1,59 @@
+# Python test set -- part 2, opcodes
+
+from test_support import *
+
+
+print '2. Opcodes'
+print 'XXX Not yet fully implemented'
+
+print '2.1 try inside for loop'
+n = 0
+for i in range(10):
+	n = n+i
+	try: 1/0
+	except NameError: pass
+	except ZeroDivisionError: pass
+	except TypeError: pass
+	try: pass
+	except: pass
+	try: pass
+	finally: pass
+	n = n+i
+if n <> 90:
+	raise TestFailed, 'try inside for'
+
+
+print '2.2 raise class exceptions'
+
+class AClass: pass
+class BClass(AClass): pass
+class CClass: pass
+
+try: raise AClass()
+except: pass
+
+try: raise AClass()
+except AClass: pass
+
+try: raise BClass()
+except AClass: pass
+
+try: raise BClass()
+except CClass: raise TestFailed
+except: pass
+
+a = AClass()
+b = BClass()
+
+try: raise AClass, b
+except BClass, v: raise TestFailed
+except AClass, v:
+	if v != b: raise TestFailed
+
+
+try: raise b
+except AClass, v:
+	if v != b: raise TestFailed
+
+try:  raise BClass, a
+except TypeError: pass
diff --git a/Lib/dos-8x3/test_ope.py b/Lib/dos-8x3/test_ope.py
new file mode 100755
index 0000000..1a75065
--- /dev/null
+++ b/Lib/dos-8x3/test_ope.py
@@ -0,0 +1,5 @@
+# Python test set -- part 3, built-in operations.
+
+
+print '3. Operations'
+print 'XXX Not yet implemented'
diff --git a/Lib/dos-8x3/test_rgb.py b/Lib/dos-8x3/test_rgb.py
new file mode 100755
index 0000000..cdadc66
--- /dev/null
+++ b/Lib/dos-8x3/test_rgb.py
@@ -0,0 +1,49 @@
+# Testing rgbimg module
+
+import rgbimg, os
+
+error = 'test_rgbimg.error'
+
+print 'RGBimg test suite:'
+
+def findfile(file):
+	if os.path.isabs(file): return file
+	import sys
+	for dn in sys.path:
+		fn = os.path.join(dn, file)
+		if os.path.exists(fn): return fn
+	return file
+
+def testimg(rgb_file, raw_file):
+	rgb_file = findfile(rgb_file)
+	raw_file = findfile(raw_file)
+	width, height = rgbimg.sizeofimage(rgb_file)
+	rgb = rgbimg.longimagedata(rgb_file)
+	if len(rgb) != width * height * 4:
+		raise error, 'bad image length'
+	raw = open(raw_file, 'r').read()
+	if rgb != raw:
+		raise error, 'images don\'t match for '+rgb_file+' and '+raw_file
+	for depth in [1, 3, 4]:
+		rgbimg.longstoimage(rgb, width, height, depth, '@.rgb')
+	os.unlink('@.rgb')
+
+ttob = rgbimg.ttob(0)
+if ttob != 0:
+	raise error, 'ttob should start out as zero'
+
+testimg('test.rgb', 'test.rawimg')
+
+ttob = rgbimg.ttob(1)
+if ttob != 0:
+	raise error, 'ttob should be zero'
+
+testimg('test.rgb', 'test.rawimg.rev')
+
+ttob = rgbimg.ttob(0)
+if ttob != 1:
+	raise error, 'ttob should be one'
+
+ttob = rgbimg.ttob(0)
+if ttob != 0:
+	raise error, 'ttob should be zero'
diff --git a/Lib/dos-8x3/test_sel.py b/Lib/dos-8x3/test_sel.py
new file mode 100755
index 0000000..f185308
--- /dev/null
+++ b/Lib/dos-8x3/test_sel.py
@@ -0,0 +1,23 @@
+# Testing select module
+
+def test():
+	import select
+	import os
+	cmd = 'for i in 0 1 2 3 4 5 6 7 8 9; do date; sleep 3; done'
+	p = os.popen(cmd, 'r')
+	for tout in (0, 1, 2, 4, 8, 16) + (None,)*10:
+		print 'timeout =', tout
+		rfd, wfd, xfd = select.select([p], [], [], tout)
+		print rfd, wfd, xfd
+		if (rfd, wfd, xfd) == ([], [], []):
+			continue
+		if (rfd, wfd, xfd) == ([p], [], []):
+			line = p.readline()
+			print `line`
+			if not line:
+				print 'EOF'
+				break
+			continue
+		print 'Heh?'
+
+test()
diff --git a/Lib/dos-8x3/test_sig.py b/Lib/dos-8x3/test_sig.py
new file mode 100755
index 0000000..bfcf517
--- /dev/null
+++ b/Lib/dos-8x3/test_sig.py
@@ -0,0 +1,50 @@
+# Test the signal module
+
+import signal
+import os
+
+
+pid = os.getpid()
+
+# Shell script that will send us asynchronous signals
+script = """
+(
+	set -x
+	sleep 2
+	kill -5 %(pid)d
+	sleep 2
+	kill -2 %(pid)d
+	sleep 2
+	kill -3 %(pid)d
+) &
+""" % vars()
+
+def handlerA(*args):
+	print "handlerA", args
+
+HandlerBCalled = "HandlerBCalled"	# Exception
+
+def handlerB(*args):
+	print "handlerB", args
+	raise HandlerBCalled, args
+
+signal.alarm(20)			# Entire test lasts at most 20 sec.
+signal.signal(5, handlerA)
+signal.signal(2, handlerB)
+signal.signal(3, signal.SIG_IGN)
+signal.signal(signal.SIGALRM, signal.default_int_handler)
+
+os.system(script)
+
+print "starting pause() loop..."
+
+try:
+	while 1:
+		print "call pause()..."
+		try:
+			signal.pause()
+			print "pause() returned"
+		except HandlerBCalled:
+			print "HandlerBCalled exception caught"
+except KeyboardInterrupt:
+	print "KeyboardInterrupt (assume the alarm() went off)"
diff --git a/Lib/dos-8x3/test_sup.py b/Lib/dos-8x3/test_sup.py
new file mode 100755
index 0000000..7a76664
--- /dev/null
+++ b/Lib/dos-8x3/test_sup.py
@@ -0,0 +1,41 @@
+# Python test set -- supporting definitions.
+
+TestFailed = 'test_support -- test failed'	# Exception
+
+def unload(name):
+	import sys
+	try:
+		del sys.modules[name]
+	except KeyError:
+		pass
+
+def forget(modname):
+	unload(modname)
+	import sys, os
+	for dirname in sys.path:
+		try:
+			os.unlink(os.path.join(dirname, modname + '.pyc'))
+		except os.error:
+			pass
+
+FUZZ = 1e-6
+
+def fcmp(x, y): # fuzzy comparison function
+	if type(x) == type(0.0) or type(y) == type(0.0):
+		try:
+			x, y = coerce(x, y)
+			fuzz = (abs(x) + abs(y)) * FUZZ
+			if abs(x-y) <= fuzz:
+				return 0
+		except:
+			pass
+	elif type(x) == type(y) and type(x) in (type(()), type([])):
+		for i in range(min(len(x), len(y))):
+			outcome = fcmp(x[i], y[i])
+			if outcome <> 0:
+				return outcome
+		return cmp(len(x), len(y))
+	return cmp(x, y)
+
+TESTFN = '@test' # Filename used for testing
+from os import unlink
diff --git a/Lib/dos-8x3/test_thr.py b/Lib/dos-8x3/test_thr.py
new file mode 100755
index 0000000..4e0eb70
--- /dev/null
+++ b/Lib/dos-8x3/test_thr.py
@@ -0,0 +1,106 @@
+# Very rudimentary test of thread module
+
+# Create a bunch of threads, let each do some work, wait until all are done
+
+import whrandom
+import thread
+import time
+
+mutex = thread.allocate_lock()
+whmutex = thread.allocate_lock() # for calls to whrandom
+running = 0
+done = thread.allocate_lock()
+done.acquire()
+
+numtasks = 10
+
+def task(ident):
+	global running
+	whmutex.acquire()
+	delay = whrandom.random() * numtasks
+	whmutex.release()
+	print 'task', ident, 'will run for', delay, 'sec'
+	time.sleep(delay)
+	print 'task', ident, 'done'
+	mutex.acquire()
+	running = running - 1
+	if running == 0:
+		done.release()
+	mutex.release()
+
+next_ident = 0
+def newtask():
+	global next_ident, running
+	mutex.acquire()
+	next_ident = next_ident + 1
+	print 'creating task', next_ident
+	thread.start_new_thread(task, (next_ident,))
+	running = running + 1
+	mutex.release()
+
+for i in range(numtasks):
+	newtask()
+
+print 'waiting for all tasks to complete'
+done.acquire()
+print 'all tasks done'
+
+class barrier:
+	def __init__(self, n):
+		self.n = n
+		self.waiting = 0
+		self.checkin  = thread.allocate_lock()
+		self.checkout = thread.allocate_lock()
+		self.checkout.acquire()
+
+	def enter(self):
+		checkin, checkout = self.checkin, self.checkout
+
+		checkin.acquire()
+		self.waiting = self.waiting + 1
+		if self.waiting == self.n:
+			self.waiting = self.n - 1
+			checkout.release()
+			return
+		checkin.release()
+
+		checkout.acquire()
+		self.waiting = self.waiting - 1
+		if self.waiting == 0:
+			checkin.release()
+			return
+		checkout.release()
+
+numtrips = 3
+def task2(ident):
+	global running
+	for i in range(numtrips):
+		if ident == 0:
+			# give it a good chance to enter the next
+			# barrier before the others are all out
+			# of the current one
+			delay = 0.001
+		else:
+			whmutex.acquire()
+			delay = whrandom.random() * numtasks
+			whmutex.release()
+		print 'task', ident, 'will run for', delay, 'sec'
+		time.sleep(delay)
+		print 'task', ident, 'entering barrier', i
+		bar.enter()
+		print 'task', ident, 'leaving barrier', i
+	mutex.acquire()
+	running = running - 1
+	if running == 0:
+		done.release()
+	mutex.release()
+
+print '\n*** Barrier Test ***'
+if done.acquire(0):
+	raise ValueError, "'done' should have remained acquired"
+bar = barrier(numtasks)
+running = numtasks
+for i in range(numtasks):
+	thread.start_new_thread(task2, (i,))
+done.acquire()
+print 'all tasks done'
diff --git a/Lib/dos-8x3/test_typ.py b/Lib/dos-8x3/test_typ.py
new file mode 100755
index 0000000..51c76dc
--- /dev/null
+++ b/Lib/dos-8x3/test_typ.py
@@ -0,0 +1,182 @@
+# Python test set -- part 6, built-in types
+
+from test_support import *
+
+print '6. Built-in types'
+
+print '6.1 Truth value testing'
+if None: raise TestFailed, 'None is true instead of false'
+if 0: raise TestFailed, '0 is true instead of false'
+if 0L: raise TestFailed, '0L is true instead of false'
+if 0.0: raise TestFailed, '0.0 is true instead of false'
+if '': raise TestFailed, '\'\' is true instead of false'
+if (): raise TestFailed, '() is true instead of false'
+if []: raise TestFailed, '[] is true instead of false'
+if {}: raise TestFailed, '{} is true instead of false'
+if not 1: raise TestFailed, '1 is false instead of true'
+if not 1L: raise TestFailed, '1L is false instead of true'
+if not 1.0: raise TestFailed, '1.0 is false instead of true'
+if not 'x': raise TestFailed, '\'x\' is false instead of true'
+if not (1, 1): raise TestFailed, '(1, 1) is false instead of true'
+if not [1]: raise TestFailed, '[1] is false instead of true'
+if not {'x': 1}: raise TestFailed, '{\'x\': 1} is false instead of true'
+def f(): pass
+class C: pass
+import sys
+x = C()
+if not f: raise TestFailed, 'f is false instead of true'
+if not C: raise TestFailed, 'C is false instead of true'
+if not sys: raise TestFailed, 'sys is false instead of true'
+if not x: raise TestFailed, 'x is false instead of true'
+
+print '6.2 Boolean operations'
+if 0 or 0: raise TestFailed, '0 or 0 is true instead of false'
+if 1 and 1: pass
+else: raise TestFailed, '1 and 1 is false instead of false'
+if not 1: raise TestFailed, 'not 1 is true instead of false'
+
+print '6.3 Comparisons'
+if 0 < 1 <= 1 == 1 >= 1 > 0 <> 1: pass
+else: raise TestFailed, 'int comparisons failed'
+if 0L < 1L <= 1L == 1L >= 1L > 0L <> 1L: pass
+else: raise TestFailed, 'long int comparisons failed'
+if 0.0 < 1.0 <= 1.0 == 1.0 >= 1.0 > 0.0 <> 1.0: pass
+else: raise TestFailed, 'float comparisons failed'
+if '' < 'a' <= 'a' == 'a' < 'abc' < 'abd' < 'b': pass
+else: raise TestFailed, 'string comparisons failed'
+if 0 in [0] and 0 not in [1]: pass
+else: raise TestFailed, 'membership test failed'
+if None is None and [] is not []: pass
+else: raise TestFailed, 'identity test failed'
+
+print '6.4 Numeric types (mostly conversions)'
+if 0 <> 0L or 0 <> 0.0 or 0L <> 0.0: raise TestFailed, 'mixed comparisons'
+if 1 <> 1L or 1 <> 1.0 or 1L <> 1.0: raise TestFailed, 'mixed comparisons'
+if -1 <> -1L or -1 <> -1.0 or -1L <> -1.0:
+	raise TestFailed, 'int/long/float value not equal'
+if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
+else: raise TestFailed, 'int() does not round properly'
+if long(1.9) == 1L == long(1.1) and long(-1.1) == -1L == long(-1.9): pass
+else: raise TestFailed, 'long() does not round properly'
+if float(1) == 1.0 and float(-1) == -1.0 and float(0) == 0.0: pass
+else: raise TestFailed, 'float() does not work properly'
+print '6.4.1 32-bit integers'
+if 12 + 24 <> 36: raise TestFailed, 'int op'
+if 12 + (-24) <> -12: raise TestFailed, 'int op'
+if (-12) + 24 <> 12: raise TestFailed, 'int op'
+if (-12) + (-24) <> -36: raise TestFailed, 'int op'
+if not 12 < 24: raise TestFailed, 'int op'
+if not -24 < -12: raise TestFailed, 'int op'
+# Test for a particular bug in integer multiply
+xsize, ysize, zsize = 238, 356, 4
+if not (xsize*ysize*zsize == zsize*xsize*ysize == 338912):
+	raise TestFailed, 'int mul commutativity'
+print '6.4.2 Long integers'
+if 12L + 24L <> 36L: raise TestFailed, 'long op'
+if 12L + (-24L) <> -12L: raise TestFailed, 'long op'
+if (-12L) + 24L <> 12L: raise TestFailed, 'long op'
+if (-12L) + (-24L) <> -36L: raise TestFailed, 'long op'
+if not 12L < 24L: raise TestFailed, 'long op'
+if not -24L < -12L: raise TestFailed, 'long op'
+print '6.4.3 Floating point numbers'
+if 12.0 + 24.0 <> 36.0: raise TestFailed, 'float op'
+if 12.0 + (-24.0) <> -12.0: raise TestFailed, 'float op'
+if (-12.0) + 24.0 <> 12.0: raise TestFailed, 'float op'
+if (-12.0) + (-24.0) <> -36.0: raise TestFailed, 'float op'
+if not 12.0 < 24.0: raise TestFailed, 'float op'
+if not -24.0 < -12.0: raise TestFailed, 'float op'
+
+print '6.5 Sequence types'
+
+print '6.5.1 Strings'
+if len('') <> 0: raise TestFailed, 'len(\'\')'
+if len('a') <> 1: raise TestFailed, 'len(\'a\')'
+if len('abcdef') <> 6: raise TestFailed, 'len(\'abcdef\')'
+if 'xyz' + 'abcde' <> 'xyzabcde': raise TestFailed, 'string concatenation'
+if 'xyz'*3 <> 'xyzxyzxyz': raise TestFailed, 'string repetition *3'
+if 0*'abcde' <> '': raise TestFailed, 'string repetition 0*'
+if min('abc') <> 'a' or max('abc') <> 'c': raise TestFailed, 'min/max string'
+if 'a' in 'abc' and 'b' in 'abc' and 'c' in 'abc' and 'd' not in 'abc': pass
+else: raise TestFailed, 'in/not in string'
+x = 'x'*103
+if '%s!'%x != x+'!': raise TestFailed, 'nasty string formatting bug'
+
+print '6.5.2 Tuples'
+if len(()) <> 0: raise TestFailed, 'len(())'
+if len((1,)) <> 1: raise TestFailed, 'len((1,))'
+if len((1,2,3,4,5,6)) <> 6: raise TestFailed, 'len((1,2,3,4,5,6))'
+if (1,2)+(3,4) <> (1,2,3,4): raise TestFailed, 'tuple concatenation'
+if (1,2)*3 <> (1,2,1,2,1,2): raise TestFailed, 'tuple repetition *3'
+if 0*(1,2,3) <> (): raise TestFailed, 'tuple repetition 0*'
+if min((1,2)) <> 1 or max((1,2)) <> 2: raise TestFailed, 'min/max tuple'
+if 0 in (0,1,2) and 1 in (0,1,2) and 2 in (0,1,2) and 3 not in (0,1,2): pass
+else: raise TestFailed, 'in/not in tuple'
+
+print '6.5.3 Lists'
+if len([]) <> 0: raise TestFailed, 'len([])'
+if len([1,]) <> 1: raise TestFailed, 'len([1,])'
+if len([1,2,3,4,5,6]) <> 6: raise TestFailed, 'len([1,2,3,4,5,6])'
+if [1,2]+[3,4] <> [1,2,3,4]: raise TestFailed, 'list concatenation'
+if [1,2]*3 <> [1,2,1,2,1,2]: raise TestFailed, 'list repetition *3'
+if 0*[1,2,3] <> []: raise TestFailed, 'list repetition 0*'
+if min([1,2]) <> 1 or max([1,2]) <> 2: raise TestFailed, 'min/max list'
+if 0 in [0,1,2] and 1 in [0,1,2] and 2 in [0,1,2] and 3 not in [0,1,2]: pass
+else: raise TestFailed, 'in/not in list'
+
+print '6.5.3a Additional list operations'
+a = [0,1,2,3,4]
+a[0] = 5
+a[1] = 6
+a[2] = 7
+if a <> [5,6,7,3,4]: raise TestFailed, 'list item assignment [0], [1], [2]'
+a[-2] = 8
+a[-1] = 9
+if a <> [5,6,7,8,9]: raise TestFailed, 'list item assignment [-2], [-1]'
+a[:2] = [0,4]
+a[-3:] = []
+a[1:1] = [1,2,3]
+if a <> [0,1,2,3,4]: raise TestFailed, 'list slice assignment'
+del a[1:4]
+if a <> [0,4]: raise TestFailed, 'list slice deletion'
+del a[0]
+if a <> [4]: raise TestFailed, 'list item deletion [0]'
+del a[-1]
+if a <> []: raise TestFailed, 'list item deletion [-1]'
+a.append(0)
+a.append(1)
+a.append(2)
+if a <> [0,1,2]: raise TestFailed, 'list append'
+a.insert(0, -2)
+a.insert(1, -1)
+a.insert(2,0)
+if a <> [-2,-1,0,0,1,2]: raise TestFailed, 'list insert'
+if a.count(0) <> 2: raise TestFailed, ' list count'
+if a.index(0) <> 2: raise TestFailed, 'list index'
+a.remove(0)
+if a <> [-2,-1,0,1,2]: raise TestFailed, 'list remove'
+a.reverse()
+if a <> [2,1,0,-1,-2]: raise TestFailed, 'list reverse'
+a.sort()
+if a <> [-2,-1,0,1,2]: raise TestFailed, 'list sort'
+def revcmp(a, b): return cmp(b, a)
+a.sort(revcmp)
+if a <> [2,1,0,-1,-2]: raise TestFailed, 'list sort with cmp func'
+
+print '6.6 Mappings == Dictionaries'
+d = {}
+if d.keys() <> []: raise TestFailed, '{}.keys()'
+if d.has_key('a') <> 0: raise TestFailed, '{}.has_key(\'a\')'
+if len(d) <> 0: raise TestFailed, 'len({})'
+d = {'a': 1, 'b': 2}
+if len(d) <> 2: raise TestFailed, 'len(dict)'
+k = d.keys()
+k.sort()
+if k <> ['a', 'b']: raise TestFailed, 'dict keys()'
+if d.has_key('a') and d.has_key('b') and not d.has_key('c'): pass
+else: raise TestFailed, 'dict keys()'
+if d['a'] <> 1 or d['b'] <> 2: raise TestFailed, 'dict item'
+d['c'] = 3
+d['a'] = 4
+if d['c'] <> 3 or d['a'] <> 4: raise TestFailed, 'dict item assignment'
+del d['b']
+if d <> {'a': 4, 'c': 3}: raise TestFailed, 'dict item deletion'
diff --git a/Lib/dos-8x3/tracebac.py b/Lib/dos-8x3/tracebac.py
new file mode 100755
index 0000000..8d2dfdc
--- /dev/null
+++ b/Lib/dos-8x3/tracebac.py
@@ -0,0 +1,125 @@
+# Format and print Python stack traces
+
+import linecache
+import string
+import sys
+import types
+
+def _print(file, str='', terminator='\n'):
+	file.write(str+terminator)
+	
+
+def print_tb(tb, limit=None, file=None):
+	if not file:
+		file = sys.stderr
+	if limit is None:
+		if hasattr(sys, 'tracebacklimit'):
+			limit = sys.tracebacklimit
+	n = 0
+	while tb is not None and (limit is None or n < limit):
+		f = tb.tb_frame
+		lineno = tb.tb_lineno
+		co = f.f_code
+		filename = co.co_filename
+		name = co.co_name
+		_print(file,
+		       '  File "%s", line %d, in %s' % (filename,lineno,name))
+		line = linecache.getline(filename, lineno)
+		if line: _print(file, '    ' + string.strip(line))
+		tb = tb.tb_next
+		n = n+1
+
+def format_tb(tb, limit = None):
+	list = []
+	for filename, lineno, name, line in extract_tb(tb, limit):
+		item = '  File "%s", line %d, in %s\n' % (filename,lineno,name)
+		if line:
+			item = item + '    %s\n' % string.strip(line)
+		list.append(item)
+	return list
+
+def extract_tb(tb, limit = None):
+	if limit is None:
+		if hasattr(sys, 'tracebacklimit'):
+			limit = sys.tracebacklimit
+	list = []
+	n = 0
+	while tb is not None and (limit is None or n < limit):
+		f = tb.tb_frame
+		lineno = tb.tb_lineno
+		co = f.f_code
+		filename = co.co_filename
+		name = co.co_name
+		line = linecache.getline(filename, lineno)
+		if line: line = string.strip(line)
+		else: line = None
+		list.append(filename, lineno, name, line)
+		tb = tb.tb_next
+		n = n+1
+	return list
+
+
+def print_exception(etype, value, tb, limit=None, file=None):
+	if not file:
+		file = sys.stderr
+	if tb:
+		_print(file, 'Traceback (innermost last):')
+		print_tb(tb, limit, file)
+	lines = format_exception_only(etype, value)
+	for line in lines[:-1]:
+		_print(file, line, ' ')
+	_print(file, lines[-1], '')
+
+def format_exception(etype, value, tb, limit = None):
+	if tb:
+		list = ['Traceback (innermost last):\n']
+		list = list + format_tb(tb, limit)
+	list = list + format_exception_only(etype, value)
+	return list
+
+def format_exception_only(etype, value):
+	list = []
+	if type(etype) == types.ClassType:
+		stype = etype.__name__
+	else:
+		stype = etype
+	if value is None:
+		list.append(str(stype) + '\n')
+	else:
+		if etype is SyntaxError:
+			try:
+				msg, (filename, lineno, offset, line) = value
+			except:
+				pass
+			else:
+				if not filename: filename = "<string>"
+				list.append('  File "%s", line %d\n' %
+					    (filename, lineno))
+				i = 0
+				while i < len(line) and \
+				      line[i] in string.whitespace:
+					i = i+1
+				list.append('    %s\n' % string.strip(line))
+				s = '    '
+				for c in line[i:offset-1]:
+					if c in string.whitespace:
+						s = s + c
+					else:
+						s = s + ' '
+				list.append('%s^\n' % s)
+				value = msg
+		list.append('%s: %s\n' % (str(stype), str(value)))
+	return list
+
+
+def print_exc(limit=None, file=None):
+	if not file:
+		file = sys.stderr
+	print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback,
+			limit, file)
+
+def print_last(limit=None, file=None):
+	if not file:
+		file = sys.stderr
+	print_exception(sys.last_type, sys.last_value, sys.last_traceback,
+			limit, file)
diff --git a/Lib/dos-8x3/userdict.py b/Lib/dos-8x3/userdict.py
new file mode 100755
index 0000000..f6b2f82
--- /dev/null
+++ b/Lib/dos-8x3/userdict.py
@@ -0,0 +1,18 @@
+# A more or less complete user-defined wrapper around dictionary objects
+
+class UserDict:
+	def __init__(self): self.data = {}
+	def __repr__(self): return repr(self.data)
+	def __cmp__(self, dict):
+		if type(dict) == type(self.data):
+			return cmp(self.data, dict)
+		else:
+			return cmp(self.data, dict.data)
+	def __len__(self): return len(self.data)
+	def __getitem__(self, key): return self.data[key]
+	def __setitem__(self, key, item): self.data[key] = item
+	def __delitem__(self, key): del self.data[key]
+	def keys(self): return self.data.keys()
+	def items(self): return self.data.items()
+	def values(self): return self.data.values()
+	def has_key(self, key): return self.data.has_key(key)
diff --git a/Lib/dos-8x3/userlist.py b/Lib/dos-8x3/userlist.py
new file mode 100755
index 0000000..1f19ad9
--- /dev/null
+++ b/Lib/dos-8x3/userlist.py
@@ -0,0 +1,50 @@
+# A more or less complete user-defined wrapper around list objects
+
+class UserList:
+	def __init__(self, list = None):
+		self.data = []
+		if list is not None:
+			if type(list) == type(self.data):
+				self.data[:] = list
+			else:
+				self.data[:] = list.data[:]
+	def __repr__(self): return repr(self.data)
+	def __cmp__(self, list):
+		if type(list) == type(self.data):
+			return cmp(self.data, list)
+		else:
+			return cmp(self.data, list.data)
+	def __len__(self): return len(self.data)
+	def __getitem__(self, i): return self.data[i]
+	def __setitem__(self, i, item): self.data[i] = item
+	def __delitem__(self, i): del self.data[i]
+	def __getslice__(self, i, j):
+		userlist = UserList()
+		userlist.data[:] = self.data[i:j]
+		return userlist
+	def __setslice__(self, i, j, list):
+		if type(list) == type(self.data):
+			self.data[i:j] = list
+		else:
+			self.data[i:j] = list.data
+	def __delslice__(self, i, j): del self.data[i:j]
+	def __add__(self, list):
+		if type(list) == type(self.data):
+			return self.__class__(self.data + list)
+		else:
+			return self.__class__(self.data + list.data)
+	def __radd__(self, list):
+		if type(list) == type(self.data):
+			return self.__class__(list + self.data)
+		else:
+			return self.__class__(list.data + self.data)
+	def __mul__(self, n):
+		return self.__class__(self.data*n)
+	__rmul__ = __mul__
+	def append(self, item): self.data.append(item)
+	def insert(self, i, item): self.data.insert(i, item)
+	def remove(self, item): self.data.remove(item)
+	def count(self, item): return self.data.count(item)
+	def index(self, item): return self.data.index(item)
+	def reverse(self): self.data.reverse()
+	def sort(self, *args): apply(self.data.sort, args)
diff --git a/Lib/dos-8x3/whatsoun.py b/Lib/dos-8x3/whatsoun.py
new file mode 100755
index 0000000..b7b349c
--- /dev/null
+++ b/Lib/dos-8x3/whatsoun.py
@@ -0,0 +1,270 @@
+# This module contains several routines that help recognizing sound
+# files.
+#
+# Function whathdr() recognizes various types of sound file headers.
+# It understands almost all headers that SOX can decode.
+#
+# The return tuple contains the following items, in this order:
+# - file type (as SOX understands it)
+# - sampling rate (0 if unknown or hard to decode)
+# - number of channels (0 if unknown or hard to decode)
+# - number of frames in the file (-1 if unknown or hard to decode)
+# - number of bits/sample, or 'U' for U-LAW, or 'A' for A-LAW
+#
+# If the file doesn't have a recognizable type, it returns None.
+# If the file can't be opened, IOError is raised.
+#
+# To compute the total time, divide the number of frames by the
+# sampling rate (a frame contains a sample for each channel).
+#
+# Function whatraw() calls the "whatsound" program and interprets its
+# output.  You'll have to guess the sampling rate by listening though!
+#
+# Function what() calls whathdr() and if it doesn't recognize the file
+# then calls whatraw().
+#
+# Finally, the function test() is a simple main program that calls
+# what() for all files mentioned on the argument list.  For directory
+# arguments it calls what() for all files in that directory.  Default
+# argument is "." (testing all files in the current directory).  The
+# option -r tells it to recurse down directories found inside
+# explicitly given directories.
+#
+# The file structure is top-down except that the test program and its
+# subroutine come last.
+
+
+#------------------------------------------------------#
+# Guess the type of any sound file, raw or with header #
+#------------------------------------------------------#
+
+def what(filename):
+	res = whathdr(filename)
+	if not res:
+		res = whatraw(filename)
+	return res
+
+
+#-----------------------------#
+# Guess the type of raw sound #
+#-----------------------------#
+
+def whatraw(filename):
+	# Assume it's always 1 channel, byte-sized samples
+	# Don't assume anything about the rate
+	import os
+	from stat import ST_SIZE
+	# XXX "whatsound" should be part of the distribution somehow...
+	cmd = 'whatsound ' + filename + ' 2>/dev/null'
+	cmd = 'PATH=$PATH:/ufs/guido/bin/sgi\n' + cmd
+	pipe = os.popen(cmd, 'r')
+	data = pipe.read()
+	sts = pipe.close()
+	if sts:
+		return None
+	if data[:13] == '-t raw -b -s ':
+		type = 'sb'
+		sample_size = 8
+	elif data[:13] == '-t raw -b -u ':
+		type = 'ub'
+		sample_size = 8
+	elif data[:13] == '-t raw -b -U ':
+		type = 'ul'
+		sample_size = 'U'
+	else:
+		return None
+	try:
+		frame_count = os.stat(filename)[ST_SIZE]
+	except IOError:
+		frame_count = -1
+	return type, 0, 1, frame_count, sample_size
+
+
+#-------------------------#
+# Recognize sound headers #
+#-------------------------#
+
+def whathdr(filename):
+	f = open(filename, 'r')
+	h = f.read(512)
+	for tf in tests:
+		res = tf(h, f)
+		if res:
+			return res
+	return None
+
+
+#-----------------------------------#
+# Subroutines per sound header type #
+#-----------------------------------#
+
+tests = []
+
+def test_aifc(h, f):
+	import aifc
+	if h[:4] <> 'FORM':
+		return None
+	if h[8:12] == 'AIFC':
+		fmt = 'aifc'
+	elif h[8:12] == 'AIFF':
+		fmt = 'aiff'
+	else:
+		return None
+	f.seek(0)
+	try:
+		a = aifc.openfp(f, 'r')
+	except (EOFError, aifc.Error):
+		return None
+	return (fmt, a.getframerate(), a.getnchannels(), \
+		a.getnframes(), 8*a.getsampwidth())
+
+tests.append(test_aifc)
+
+
+def test_au(h, f):
+	if h[:4] == '.snd':
+		f = get_long_be
+	elif h[:4] in ('\0ds.', 'dns.'):
+		f = get_long_le
+	else:
+		return None
+	type = 'au'
+	hdr_size = f(h[4:8])
+	data_size = f(h[8:12])
+	encoding = f(h[12:16])
+	rate = f(h[16:20])
+	nchannels = f(h[20:24])
+	sample_size = 1 # default
+	if encoding == 1:
+		sample_bits = 'U'
+	elif encoding == 2:
+		sample_bits = 8
+	elif encoding == 3:
+		sample_bits = 16
+		sample_size = 2
+	else:
+		sample_bits = '?'
+	frame_size = sample_size * nchannels
+	return type, rate, nchannels, data_size/frame_size, sample_bits
+
+tests.append(test_au)
+
+
+def test_hcom(h, f):
+	if h[65:69] <> 'FSSD' or h[128:132] <> 'HCOM':
+		return None
+	divisor = get_long_be(h[128+16:128+20])
+	return 'hcom', 22050/divisor, 1, -1, 8
+
+tests.append(test_hcom)
+
+
+def test_voc(h, f):
+	if h[:20] <> 'Creative Voice File\032':
+		return None
+	sbseek = get_short_le(h[20:22])
+	rate = 0
+	if 0 <= sbseek < 500 and h[sbseek] == '\1':
+		ratecode = ord(h[sbseek+4])
+		rate = int(1000000.0 / (256 - ratecode))
+	return 'voc', rate, 1, -1, 8
+
+tests.append(test_voc)
+
+
+def test_wav(h, f):
+	# 'RIFF' <len> 'WAVE' 'fmt ' <len>
+	if h[:4] <> 'RIFF' or h[8:12] <> 'WAVE' or h[12:16] <> 'fmt ':
+		return None
+	style = get_short_le(h[20:22])
+	nchannels = get_short_le(h[22:24])
+	rate = get_long_le(h[24:28])
+	sample_bits = get_short_le(h[34:36])
+	return 'wav', rate, nchannels, -1, sample_bits
+
+tests.append(test_wav)
+
+
+def test_8svx(h, f):
+	if h[:4] <> 'FORM' or h[8:12] <> '8SVX':
+		return None
+	# Should decode it to get #channels -- assume always 1
+	return '8svx', 0, 1, 0, 8
+
+tests.append(test_8svx)
+
+
+def test_sndt(h, f):
+	if h[:5] == 'SOUND':
+		nsamples = get_long_le(h[8:12])
+		rate = get_short_le(h[20:22])
+		return 'sndt', rate, 1, nsamples, 8
+
+tests.append(test_sndt)
+
+
+def test_sndr(h, f):
+	if h[:2] == '\0\0':
+		rate = get_short_le(h[2:4])
+		if 4000 <= rate <= 25000:
+			return 'sndr', rate, 1, -1, 8
+
+tests.append(test_sndr)
+
+
+#---------------------------------------------#
+# Subroutines to extract numbers from strings #
+#---------------------------------------------#
+
+def get_long_be(s):
+	return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
+
+def get_long_le(s):
+	return (ord(s[3])<<24) | (ord(s[2])<<16) | (ord(s[1])<<8) | ord(s[0])
+
+def get_short_be(s):
+	return (ord(s[0])<<8) | ord(s[1])
+
+def get_short_le(s):
+	return (ord(s[1])<<8) | ord(s[0])
+
+
+#--------------------#
+# Small test program #
+#--------------------#
+
+def test():
+	import sys
+	recursive = 0
+	if sys.argv[1:] and sys.argv[1] == '-r':
+		del sys.argv[1:2]
+		recursive = 1
+	try:
+		if sys.argv[1:]:
+			testall(sys.argv[1:], recursive, 1)
+		else:
+			testall(['.'], recursive, 1)
+	except KeyboardInterrupt:
+		sys.stderr.write('\n[Interrupted]\n')
+		sys.exit(1)
+
+def testall(list, recursive, toplevel):
+	import sys
+	import os
+	for filename in list:
+		if os.path.isdir(filename):
+			print filename + '/:',
+			if recursive or toplevel:
+				print 'recursing down:'
+				import glob
+				names = glob.glob(os.path.join(filename, '*'))
+				testall(names, recursive, 0)
+			else:
+				print '*** directory (use -r) ***'
+		else:
+			print filename + ':',
+			sys.stdout.flush()
+			try:
+				print what(filename)
+			except IOError:
+				print '*** not found ***'