diff --git a/Lib/dos-8x3/basehttp.py b/Lib/dos-8x3/basehttp.py
index 7dadd71..7c8975d 100755
--- a/Lib/dos-8x3/basehttp.py
+++ b/Lib/dos-8x3/basehttp.py
@@ -89,19 +89,19 @@
 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
+        """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):
@@ -217,196 +217,196 @@
     server_version = "BaseHTTP/" + __version__
 
     def handle(self):
-	"""Handle a single HTTP request.
+        """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.
+        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[:5] != 'HTTP/':
-		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()
+        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[:5] != 'HTTP/':
+                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.
+        """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.
+        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.
+        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})
+        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.
+        """Send the response header and log the response code.
 
-	Also send two standard headers with the server software
-	version and the current date.
+        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][0]
-	    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())
+        """
+        self.log_request(code)
+        if message is None:
+            if self.responses.has_key(code):
+                message = self.responses[code][0]
+            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))
+        """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")
+        """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.
+        """Log an accepted request.
 
-	This is called by send_reponse().
+        This is called by send_reponse().
 
-	"""
+        """
 
-	self.log_message('"%s" %s %s',
-			 self.requestline, str(code), str(size))
+        self.log_message('"%s" %s %s',
+                         self.requestline, str(code), str(size))
 
     def log_error(self, *args):
-	"""Log an error.
+        """Log an error.
 
-	This is called when a request cannot be fulfilled.  By
-	default it passes the message on to log_message().
+        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().
+        Arguments are the same as for log_message().
 
-	XXX This should go to the separate error log.
+        XXX This should go to the separate error log.
 
-	"""
+        """
 
-	apply(self.log_message, args)
+        apply(self.log_message, args)
 
     def log_message(self, format, *args):
-	"""Log an arbitrary message.
+        """Log an arbitrary message.
 
-	This is used by all other logging functions.  Override
-	it if you have specific logging wishes.
+        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 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.
+        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))
+        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
+        """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
+        """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
+        """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']
+                 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+                 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
 
     def address_string(self):
-	"""Return the client address formatted for logging.
+        """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.
+        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]
+        (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
@@ -423,42 +423,42 @@
     # 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'),
-	
-	}
+        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):
+         ServerClass = HTTPServer):
     """Test the HTTP request handler class.
 
     This runs an HTTP server on port 8000 (or the first command line
@@ -467,9 +467,9 @@
     """
 
     if sys.argv[1:]:
-	port = string.atoi(sys.argv[1])
+        port = string.atoi(sys.argv[1])
     else:
-	port = 8000
+        port = 8000
     server_address = ('', port)
 
     httpd = ServerClass(server_address, HandlerClass)
diff --git a/Lib/dos-8x3/bastion.py b/Lib/dos-8x3/bastion.py
index 9411ff9..a6e716b 100755
--- a/Lib/dos-8x3/bastion.py
+++ b/Lib/dos-8x3/bastion.py
@@ -41,47 +41,47 @@
     """
 
     def __init__(self, get, name):
-	"""Constructor.
+        """Constructor.
 
-	Arguments:
+        Arguments:
 
-	get - a function that gets the attribute value (by name)
-	name - a human-readable name for the original object
-	       (suggestion: use repr(object))
+        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
+        """
+        self._get_ = get
+        self._name_ = name
 
     def __repr__(self):
-	"""Return a representation string.
+        """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.
+        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_
+        """
+        return "<Bastion for %s>" % self._name_
 
     def __getattr__(self, name):
-	"""Get an as-yet undefined attribute value.
+        """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.
+        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.
+        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
+        """
+        attribute = self._get_(name)
+        self.__dict__[name] = attribute
+        return attribute
 
 
 def Bastion(object, filter = lambda name: name[:1] != '_',
-	    name=None, bastionclass=BastionClass):
+            name=None, bastionclass=BastionClass):
     """Create a bastion for an object, using an optional filter.
 
     See the Bastion module's documentation for background.
@@ -109,33 +109,33 @@
     # 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
+        """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)
+        """Internal function for Bastion().  See source comments."""
+        return get1(name)
 
     if name is None:
-	name = `object`
+        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
+        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)
     testcode = """if 1:
@@ -143,23 +143,23 @@
     b.add(18)
     print "b.total() =", b.total()
     try:
-	print "b.sum =", b.sum,
+        print "b.sum =", b.sum,
     except:
-	print "inaccessible"
+        print "inaccessible"
     else:
-	print "accessible"
+        print "accessible"
     try:
-	print "b._add =", b._add,
+        print "b._add =", b._add,
     except:
-	print "inaccessible"
+        print "inaccessible"
     else:
-	print "accessible"
+        print "accessible"
     try:
-	print "b._get_.func_defaults =", b._get_.func_defaults,
+        print "b._get_.func_defaults =", b._get_.func_defaults,
     except:
-	print "inaccessible"
+        print "inaccessible"
     else:
-	print "accessible"
+        print "accessible"
     \n"""
     exec testcode
     print '='*20, "Using rexec:", '='*20
diff --git a/Lib/dos-8x3/cgihttps.py b/Lib/dos-8x3/cgihttps.py
index b40edbc..bb8cb2d 100755
--- a/Lib/dos-8x3/cgihttps.py
+++ b/Lib/dos-8x3/cgihttps.py
@@ -30,138 +30,138 @@
     """
 
     def do_POST(self):
-	"""Serve a POST request.
+        """Serve a POST request.
 
-	This is only implemented for CGI scripts.
+        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")
+        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)
+        """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.
+        """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.
+        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).
+        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
+        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
+        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
-	    decoded_query = string.replace(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)
+        """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
+            decoded_query = string.replace(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
@@ -170,26 +170,26 @@
     """Internal routine to get nobody's uid"""
     global nobody
     if nobody:
-	return nobody
+        return nobody
     import pwd
     try:
-	nobody = pwd.getpwnam('nobody')[2]
+        nobody = pwd.getpwnam('nobody')[2]
     except pwd.error:
-	nobody = 1 + max(map(lambda x: x[2], pwd.getpwall()))
+        nobody = 1 + max(map(lambda x: x[2], pwd.getpwall()))
     return nobody
 
 
 def executable(path):
     """Test for executable file."""
     try:
-	st = os.stat(path)
+        st = os.stat(path)
     except os.error:
-	return 0
+        return 0
     return st[0] & 0111 != 0
 
 
 def test(HandlerClass = CGIHTTPRequestHandler,
-	 ServerClass = BaseHTTPServer.HTTPServer):
+         ServerClass = BaseHTTPServer.HTTPServer):
     SimpleHTTPServer.test(HandlerClass, ServerClass)
 
 
diff --git a/Lib/dos-8x3/compilea.py b/Lib/dos-8x3/compilea.py
index 9947569..f695b3a 100755
--- a/Lib/dos-8x3/compilea.py
+++ b/Lib/dos-8x3/compilea.py
@@ -1,70 +1,109 @@
-# 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.
+"""Module/script to "compile" all .py files to .pyc (or .pyo) file.
+
+When called as a script with arguments, this compiles the directories
+given as arguments recursively; the -l option prevents it from
+recursing into directories.
+
+Without arguments, if compiles all modules on sys.path, without
+recursing into subdirectories.  (Even though it should do so for
+packages -- for now, you'll have to deal with packages separately.)
+
+See module py_compile for details of the actual byte-compilation.
+
+"""
 
 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_dir(dir, maxlevels=10, ddir=None):
+    """Byte-compile all modules in the given directory tree.
 
-def compile_path(skip_curdir = 1):
-	for dir in sys.path:
-		if (not dir or dir == os.curdir) and skip_curdir:
-			print 'Skipping current directory'
-		else:
-			compile_dir(dir, 0)
+    Arguments (only dir is required):
+
+    dir:       the directory to byte-compile
+    maxlevels: maximum recursion level (default 10)
+    ddir:      if given, purported directory name (this is the
+               directory name that will show up in error messages)
+
+    """
+    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 ddir:
+            dfile = os.path.join(ddir, name)
+        else:
+            dfile = None
+        if os.path.isfile(fullname):
+            head, tail = name[:-3], name[-3:]
+            if tail == '.py':
+                print 'Compiling', fullname, '...'
+                try:
+                    py_compile.compile(fullname, None, dfile)
+                except KeyboardInterrupt:
+                    raise KeyboardInterrupt
+                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, dfile)
+
+def compile_path(skip_curdir=1, maxlevels=0):
+    """Byte-compile all module on sys.path.
+
+    Arguments (all optional):
+
+    skip_curdir: if true, skip current directory (default true)
+    maxlevels:   max recursion level (default 0)
+
+    """
+    for dir in sys.path:
+        if (not dir or dir == os.curdir) and skip_curdir:
+            print 'Skipping current directory'
+        else:
+            compile_dir(dir, maxlevels)
 
 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()
+    """Script main program."""
+    import getopt
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'ld:')
+    except getopt.error, msg:
+        print msg
+        print "usage: compileall [-l] [-d destdir] [directory ...]"
+        print "-l: don't recurse down"
+        print "-d destdir: purported directory name for error messages"
+        print "if no arguments, -l sys.path is assumed"
+        sys.exit(2)
+    maxlevels = 10
+    ddir = None
+    for o, a in opts:
+        if o == '-l': maxlevels = 0
+        if o == '-d': ddir = a
+    if ddir:
+        if len(args) != 1:
+            print "-d destdir require exactly one directory argument"
+            sys.exit(2)
+    try:
+        if args:
+            for dir in args:
+                compile_dir(dir, maxlevels, ddir)
+        else:
+            compile_path()
+    except KeyboardInterrupt:
+        print "\n[interrupt]"
 
 if __name__ == '__main__':
-	main()
+    main()
diff --git a/Lib/dos-8x3/configpa.py b/Lib/dos-8x3/configpa.py
index 2f3ca51..957222c 100644
--- a/Lib/dos-8x3/configpa.py
+++ b/Lib/dos-8x3/configpa.py
@@ -34,23 +34,23 @@
     sections() -- return all the configuration section names, sans DEFAULT
 
     options(section) -- return list of configuration options for the named
-			section
+                        section
 
     read(*filenames) -- read and parse the list of named configuration files
 
     get(section, option, raw=0) -- return a string value for the named
-				   option.  All % interpolations are
-				   expanded in the return values, based on
-				   the defaults passed into the constructor
-				   and the DEFAULT section.
+                                   option.  All % interpolations are
+                                   expanded in the return values, based on
+                                   the defaults passed into the constructor
+                                   and the DEFAULT section.
 
     getint(section, options) -- like get(), but convert value to an integer
 
     getfloat(section, options) -- like get(), but convert value to a float
 
     getboolean(section, options) -- like get(), but convert value to
-				    a boolean (currently defined as 0
-				    or 1, only)
+                                    a boolean (currently defined as 0
+                                    or 1, only)
 """
 
 import sys
@@ -71,185 +71,186 @@
 # exception classes
 class Error:
     def __init__(self, msg=''):
-	self.__msg = msg
+        self.__msg = msg
     def __repr__(self):
-	return self.__msg
+        return self.__msg
 
 class NoSectionError(Error):
     def __init__(self, section):
-	Error.__init__(self, 'No section: %s' % section)
-	self.section = section
+        Error.__init__(self, 'No section: %s' % section)
+        self.section = section
 
 class DuplicateSectionError(Error):
     def __init__(self, section):
-	Error.__init__(self, "Section %s already exists" % section)
-	self.section = section
+        Error.__init__(self, "Section %s already exists" % section)
+        self.section = section
 
 class NoOptionError(Error):
     def __init__(self, option, section):
-	Error.__init__(self, "No option `%s' in section: %s" %
-		       (option, section))
-	self.option = option
-	self.section = section
+        Error.__init__(self, "No option `%s' in section: %s" %
+                       (option, section))
+        self.option = option
+        self.section = section
 
 class InterpolationError(Error):
     def __init__(self, reference, option, section):
-	Error.__init__(self,
-		       "Bad value substitution: sect `%s', opt `%s', ref `%s'"
-		       % (section, option, reference))
-	self.reference = reference
-	self.option = option
-	self.section = section
+        Error.__init__(self,
+                       "Bad value substitution: sect `%s', opt `%s', ref `%s'"
+                       % (section, option, reference))
+        self.reference = reference
+        self.option = option
+        self.section = section
 
 
 
 class ConfigParser:
     def __init__(self, defaults=None):
-	self.__sections = {}
-	if defaults is None:
-	    self.__defaults = {}
-	else:
-	    self.__defaults = defaults
+        self.__sections = {}
+        if defaults is None:
+            self.__defaults = {}
+        else:
+            self.__defaults = defaults
 
     def defaults(self):
-	return self.__defaults
+        return self.__defaults
 
     def sections(self):
-	"""Return a list of section names, excluding [DEFAULT]"""
-	# self.__sections will never have [DEFAULT] in it
-	return self.__sections.keys()
+        """Return a list of section names, excluding [DEFAULT]"""
+        # self.__sections will never have [DEFAULT] in it
+        return self.__sections.keys()
 
     def add_section(self, section):
-	"""Create a new section in the configuration.
+        """Create a new section in the configuration.
 
-	Raise DuplicateSectionError if a section by the specified name
-	already exists.
-	"""
-	if self.__sections.has_key(section):
-	    raise DuplicateSectionError(section)
-	self.__sections[section] = {}
+        Raise DuplicateSectionError if a section by the specified name
+        already exists.
+        """
+        if self.__sections.has_key(section):
+            raise DuplicateSectionError(section)
+        self.__sections[section] = {}
 
     def has_section(self, section):
-	"""Indicate whether the named section is present in the configuration.
+        """Indicate whether the named section is present in the configuration.
 
-	The DEFAULT section is not acknowledged.
-	"""
-	return self.__sections.has_key(section)
+        The DEFAULT section is not acknowledged.
+        """
+        return self.__sections.has_key(section)
 
     def options(self, section):
-	try:
-	    opts = self.__sections[section].copy()
-	except KeyError:
-	    raise NoSectionError(section)
-	opts.update(self.__defaults)
-	return opts.keys()
+        try:
+            opts = self.__sections[section].copy()
+        except KeyError:
+            raise NoSectionError(section)
+        opts.update(self.__defaults)
+        return opts.keys()
 
     def read(self, filenames):
-	"""Read and parse a list of filenames."""
-	if type(filenames) is type(''):
-	    filenames = [filenames]
-	for file in filenames:
-	    try:
-		fp = open(file, 'r')
-		self.__read(fp)
-	    except IOError:
-		pass
+        """Read and parse a list of filenames."""
+        if type(filenames) is type(''):
+            filenames = [filenames]
+        for file in filenames:
+            try:
+                fp = open(file, 'r')
+                self.__read(fp)
+            except IOError:
+                pass
 
     def get(self, section, option, raw=0):
-	"""Get an option value for a given section.
+        """Get an option value for a given section.
 
-	All % interpolations are expanded in the return values, based
-	on the defaults passed into the constructor.
+        All % interpolations are expanded in the return values, based
+        on the defaults passed into the constructor.
 
-	The section DEFAULT is special.
-	"""
-	try:
-	    d = self.__sections[section].copy()
-	except KeyError:
-	    if section == DEFAULTSECT:
-		d = {}
-	    else:
-		raise NoSectionError(section)
-	d.update(self.__defaults)
-	option = string.lower(option)
-	try:
-	    rawval = d[option]
-	except KeyError:
-	    raise NoOptionError(option, section)
-	# do the string interpolation
-	if raw:
-	    return rawval
-	try:
-	    return rawval % d
-	except KeyError, key:
-	    raise InterpolationError(key, option, section)
+        The section DEFAULT is special.
+        """
+        try:
+            sectdict = self.__sections[section].copy()
+        except KeyError:
+            if section == DEFAULTSECT:
+                sectdict = {}
+            else:
+                raise NoSectionError(section)
+        d = self.__defaults.copy()
+        d.update(sectdict)
+        option = string.lower(option)
+        try:
+            rawval = d[option]
+        except KeyError:
+            raise NoOptionError(option, section)
+        # do the string interpolation
+        if raw:
+            return rawval
+        try:
+            return rawval % d
+        except KeyError, key:
+            raise InterpolationError(key, option, section)
 
     def __get(self, section, conv, option):
-	return conv(self.get(section, option))
+        return conv(self.get(section, option))
 
     def getint(self, section, option):
-	return self.__get(section, string.atoi, option)
+        return self.__get(section, string.atoi, option)
 
     def getfloat(self, section, option):
-	return self.__get(section, string.atof, option)
+        return self.__get(section, string.atof, option)
 
     def getboolean(self, section, option):
-	v = self.get(section, option)
-	val = string.atoi(v)
-	if val not in (0, 1):
-	    raise ValueError, 'Not a boolean: %s' % v
-	return val
+        v = self.get(section, option)
+        val = string.atoi(v)
+        if val not in (0, 1):
+            raise ValueError, 'Not a boolean: %s' % v
+        return val
 
     def __read(self, fp):
-	"""Parse a sectioned setup file.
+        """Parse a sectioned setup file.
 
-	The sections in setup file contains a title line at the top,
-	indicated by a name in square brackets (`[]'), plus key/value
-	options lines, indicated by `name: value' format lines.
-	Continuation are represented by an embedded newline then
-	leading whitespace.  Blank lines, lines beginning with a '#',
-	and just about everything else is ignored.
-	"""
-	cursect = None			# None, or a dictionary
-	optname = None
-	lineno = 0
-	while 1:
-	    line = fp.readline()
-	    if not line:
-		break
-	    lineno = lineno + 1
-	    # comment or blank line?
-	    if string.strip(line) == '' or line[0] in '#;':
-		continue
-	    if string.lower(string.split(line)[0]) == 'rem' \
-	       and line[0] == "r":	# no leading whitespace
-		continue
-	    # continuation line?
-	    if line[0] in ' \t' and cursect <> None and optname:
-		value = string.strip(line)
-		if value:
-		    cursect = cursect[optname] + '\n ' + value
-	    # a section header?
-	    elif secthead_cre.match(line) >= 0:
-		sectname = secthead_cre.group(1)
-		if self.__sections.has_key(sectname):
-		    cursect = self.__sections[sectname]
-		elif sectname == DEFAULTSECT:
-		    cursect = self.__defaults
-		else:
-		    cursect = {'name': sectname}
-		    self.__sections[sectname] = cursect
-		# So sections can't start with a continuation line.
-		optname = None
-	    # an option line?
-	    elif option_cre.match(line) >= 0:
-		optname, optval = option_cre.group(1, 3)
-		optname = string.lower(optname)
-		optval = string.strip(optval)
-		# allow empty values
-		if optval == '""':
-		    optval = ''
-		cursect[optname] = optval
-	    # an error
-	    else:
-		print 'Error in %s at %d: %s', (fp.name, lineno, `line`)
+        The sections in setup file contains a title line at the top,
+        indicated by a name in square brackets (`[]'), plus key/value
+        options lines, indicated by `name: value' format lines.
+        Continuation are represented by an embedded newline then
+        leading whitespace.  Blank lines, lines beginning with a '#',
+        and just about everything else is ignored.
+        """
+        cursect = None                  # None, or a dictionary
+        optname = None
+        lineno = 0
+        while 1:
+            line = fp.readline()
+            if not line:
+                break
+            lineno = lineno + 1
+            # comment or blank line?
+            if string.strip(line) == '' or line[0] in '#;':
+                continue
+            if string.lower(string.split(line)[0]) == 'rem' \
+               and line[0] == "r":      # no leading whitespace
+                continue
+            # continuation line?
+            if line[0] in ' \t' and cursect <> None and optname:
+                value = string.strip(line)
+                if value:
+                    cursect = cursect[optname] + '\n ' + value
+            # a section header?
+            elif secthead_cre.match(line) >= 0:
+                sectname = secthead_cre.group(1)
+                if self.__sections.has_key(sectname):
+                    cursect = self.__sections[sectname]
+                elif sectname == DEFAULTSECT:
+                    cursect = self.__defaults
+                else:
+                    cursect = {'name': sectname}
+                    self.__sections[sectname] = cursect
+                # So sections can't start with a continuation line.
+                optname = None
+            # an option line?
+            elif option_cre.match(line) >= 0:
+                optname, optval = option_cre.group(1, 3)
+                optname = string.lower(optname)
+                optval = string.strip(optval)
+                # allow empty values
+                if optval == '""':
+                    optval = ''
+                cursect[optname] = optval
+            # an error
+            else:
+                print 'Error in %s at %d: %s', (fp.name, lineno, `line`)
diff --git a/Lib/dos-8x3/exceptio.py b/Lib/dos-8x3/exceptio.py
index c7bbbf4..ba63be6 100644
--- a/Lib/dos-8x3/exceptio.py
+++ b/Lib/dos-8x3/exceptio.py
@@ -48,18 +48,18 @@
 
 class Exception:
     def __init__(self, *args):
-	self.args = args
+        self.args = args
 
     def __str__(self):
         if not self.args:
             return ''
-	elif len(self.args) == 1:
-	    return str(self.args[0])
-	else:
-	    return str(self.args)
+        elif len(self.args) == 1:
+            return str(self.args[0])
+        else:
+            return str(self.args)
 
     def __getitem__(self, i):
-	return self.args[i]
+        return self.args[i]
 
 class StandardError(Exception):
     pass
@@ -68,21 +68,21 @@
     filename = lineno = offset = text = None
     msg = ""
     def __init__(self, *args):
-	self.args = args
-	if len(self.args) >= 1:
-	    self.msg = self.args[0]
-	if len(self.args) == 2:
-	    info = self.args[1]
-	    try:
-		self.filename, self.lineno, self.offset, self.text = info
-	    except:
-		pass
+        self.args = args
+        if len(self.args) >= 1:
+            self.msg = self.args[0]
+        if len(self.args) == 2:
+            info = self.args[1]
+            try:
+                self.filename, self.lineno, self.offset, self.text = info
+            except:
+                pass
     def __str__(self):
         return str(self.msg)
 
 class IOError(StandardError):
     def __init__(self, *args):
-	self.args = args
+        self.args = args
         self.errno = None
         self.strerror = None
         if len(args) == 2:
@@ -146,7 +146,7 @@
 
 class SystemExit(Exception):
     def __init__(self, *args):
-	self.args = args
+        self.args = args
         if len(args) == 0:
             self.code = None
         elif len(args) == 1:
diff --git a/Lib/dos-8x3/fileinpu.py b/Lib/dos-8x3/fileinpu.py
index b332202..2f895e9 100644
--- a/Lib/dos-8x3/fileinpu.py
+++ b/Lib/dos-8x3/fileinpu.py
@@ -80,7 +80,7 @@
 def input(files=(), inplace=0, backup=""):
     global _state
     if _state and _state._file:
-	raise RuntimeError, "input() already active"
+        raise RuntimeError, "input() already active"
     _state = FileInput(files, inplace, backup)
     return _state
 
@@ -89,151 +89,151 @@
     state = _state
     _state = None
     if state:
-	state.close()
+        state.close()
 
 def nextfile():
     if not _state:
-	raise RuntimeError, "no active input()"
+        raise RuntimeError, "no active input()"
     return _state.nextfile()
 
 def filename():
     if not _state:
-	raise RuntimeError, "no active input()"
+        raise RuntimeError, "no active input()"
     return _state.filename()
 
 def lineno():
     if not _state:
-	raise RuntimeError, "no active input()"
+        raise RuntimeError, "no active input()"
     return _state.lineno()
 
 def filelineno():
     if not _state:
-	raise RuntimeError, "no active input()"
+        raise RuntimeError, "no active input()"
     return _state.filelineno()
 
 def isfirstline():
     if not _state:
-	raise RuntimeError, "no active input()"
+        raise RuntimeError, "no active input()"
     return _state.isfirstline()
 
 def isstdin():
     if not _state:
-	raise RuntimeError, "no active input()"
+        raise RuntimeError, "no active input()"
     return _state.isstdin()
 
 class FileInput:
 
     def __init__(self, files=(), inplace=0, backup=""):
-	if type(files) == type(''):
-	    files = (files,)
-	else:
-	    files = tuple(files)
-	    if not files:
-		files = tuple(sys.argv[1:])
-		if not files:
-		    files = ('-',)
-	self._files = files
-	self._inplace = inplace
-	self._backup = backup
-	self._savestdout = None
-	self._output = None
-	self._filename = None
-	self._lineno = 0
-	self._filelineno = 0
-	self._file = None
-	self._isstdin = 0
+        if type(files) == type(''):
+            files = (files,)
+        else:
+            files = tuple(files)
+            if not files:
+                files = tuple(sys.argv[1:])
+                if not files:
+                    files = ('-',)
+        self._files = files
+        self._inplace = inplace
+        self._backup = backup
+        self._savestdout = None
+        self._output = None
+        self._filename = None
+        self._lineno = 0
+        self._filelineno = 0
+        self._file = None
+        self._isstdin = 0
 
     def __del__(self):
-	self.close()
+        self.close()
 
     def close(self):
-	self.nextfile()
-	self._files = ()
+        self.nextfile()
+        self._files = ()
 
     def __getitem__(self, i):
-	if i != self._lineno:
-	    raise RuntimeError, "accessing lines out of order"
-	line = self.readline()
-	if not line:
-	    raise IndexError, "end of input reached"
-	return line
+        if i != self._lineno:
+            raise RuntimeError, "accessing lines out of order"
+        line = self.readline()
+        if not line:
+            raise IndexError, "end of input reached"
+        return line
 
     def nextfile(self):
-	savestdout = self._savestdout
-	self._savestdout = 0
-	if savestdout:
-	    sys.stdout = savestdout
+        savestdout = self._savestdout
+        self._savestdout = 0
+        if savestdout:
+            sys.stdout = savestdout
 
-	output = self._output
-	self._output = 0
-	if output:
-	    output.close()
+        output = self._output
+        self._output = 0
+        if output:
+            output.close()
 
-	file = self._file
-	self._file = 0
-	if file and not self._isstdin:
-	    file.close()
+        file = self._file
+        self._file = 0
+        if file and not self._isstdin:
+            file.close()
 
-	backupfilename = self._backupfilename
-	self._backupfilename = 0
-	if backupfilename and not self._backup:
-	    try: os.unlink(backupfilename)
-	    except: pass
+        backupfilename = self._backupfilename
+        self._backupfilename = 0
+        if backupfilename and not self._backup:
+            try: os.unlink(backupfilename)
+            except: pass
 
-	self._isstdin = 0
+        self._isstdin = 0
 
     def readline(self):
-	if not self._file:
-	    if not self._files:
-		return ""
-	    self._filename = self._files[0]
-	    self._files = self._files[1:]
-	    self._filelineno = 0
-	    self._file = None
-	    self._isstdin = 0
-	    self._backupfilename = 0
-	    if self._filename == '-':
-		self._filename = '<stdin>'
-		self._file = sys.stdin
-		self._isstdin = 1
-	    else:
-		if self._inplace:
-		    self._backupfilename = (
-			self._filename + (self._backup or ".bak"))
-		    try: os.unlink(self._backupfilename)
-		    except os.error: pass
-		    # The next three lines may raise IOError
-		    os.rename(self._filename, self._backupfilename)
-		    self._file = open(self._backupfilename, "r")
-		    self._output = open(self._filename, "w")
-		    self._savestdout = sys.stdout
-		    sys.stdout = self._output
-		else:
-		    # This may raise IOError
-		    self._file = open(self._filename, "r")
-	line = self._file.readline()
-	if line:
-	    self._lineno = self._lineno + 1
-	    self._filelineno = self._filelineno + 1
-	    return line
-	self.nextfile()
-	# Recursive call
-	return self.readline()
+        if not self._file:
+            if not self._files:
+                return ""
+            self._filename = self._files[0]
+            self._files = self._files[1:]
+            self._filelineno = 0
+            self._file = None
+            self._isstdin = 0
+            self._backupfilename = 0
+            if self._filename == '-':
+                self._filename = '<stdin>'
+                self._file = sys.stdin
+                self._isstdin = 1
+            else:
+                if self._inplace:
+                    self._backupfilename = (
+                        self._filename + (self._backup or ".bak"))
+                    try: os.unlink(self._backupfilename)
+                    except os.error: pass
+                    # The next three lines may raise IOError
+                    os.rename(self._filename, self._backupfilename)
+                    self._file = open(self._backupfilename, "r")
+                    self._output = open(self._filename, "w")
+                    self._savestdout = sys.stdout
+                    sys.stdout = self._output
+                else:
+                    # This may raise IOError
+                    self._file = open(self._filename, "r")
+        line = self._file.readline()
+        if line:
+            self._lineno = self._lineno + 1
+            self._filelineno = self._filelineno + 1
+            return line
+        self.nextfile()
+        # Recursive call
+        return self.readline()
 
     def filename(self):
-	return self._filename
+        return self._filename
 
     def lineno(self):
-	return self._lineno
+        return self._lineno
 
     def filelineno(self):
-	return self._filelineno
+        return self._filelineno
 
     def isfirstline(self):
-	return self._filelineno == 1
+        return self._filelineno == 1
 
     def isstdin(self):
-	return self._isstdin
+        return self._isstdin
 
 def _test():
     import getopt
@@ -241,13 +241,13 @@
     backup = 0
     opts, args = getopt.getopt(sys.argv[1:], "ib:")
     for o, a in opts:
-	if o == '-i': inplace = 1
-	if o == '-b': backup = a
+        if o == '-i': inplace = 1
+        if o == '-b': backup = a
     for line in input(args, inplace=inplace, backup=backup):
-	if line[-1:] == '\n': line = line[:-1]
-	if line[-1:] == '\r': line = line[:-1]
-	print "%d: %s[%d]%s %s" % (lineno(), filename(), filelineno(),
-				   isfirstline() and "*" or "", line)
+        if line[-1:] == '\n': line = line[:-1]
+        if line[-1:] == '\r': line = line[:-1]
+        print "%d: %s[%d]%s %s" % (lineno(), filename(), filelineno(),
+                                   isfirstline() and "*" or "", line)
     print "%d: %s[%d]" % (lineno(), filename(), filelineno())
 
 if __name__ == '__main__':
diff --git a/Lib/dos-8x3/formatte.py b/Lib/dos-8x3/formatte.py
index 504807d..a3e82a4 100755
--- a/Lib/dos-8x3/formatte.py
+++ b/Lib/dos-8x3/formatte.py
@@ -9,9 +9,9 @@
 class NullFormatter:
 
     def __init__(self, writer=None):
-	if not writer:
-	    writer = NullWriter()
-	self.writer = writer
+        if not writer:
+            writer = NullWriter()
+        self.writer = writer
     def end_paragraph(self, blankline): pass
     def add_line_break(self): pass
     def add_hor_rule(self, *args, **kw): pass
@@ -39,88 +39,88 @@
     #  in all circumstances.
 
     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
+        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
+        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
+        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
+        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
+        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)
+                    label = label + ('%d' % counter)
                 elif c in 'aA':
-		    if counter > 0:
-			label = label + self.format_letter(c, counter)
+                    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
+                    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
+        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
+        # This will die of IndexError when counter is too big
         while counter > 0:
             counter, x = divmod(counter, 10)
             if x == 9:
@@ -134,132 +134,132 @@
                 else:
                     s = ''
                 s = s + ones[index]*x
-		label = s + label
+                label = s + label
             index = index + 1
         if case == 'I':
-	    return string.upper(label)
+            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)
+                         # 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
-	if self.softspace:
-	    self.writer.send_flowing_data(" ")
-	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)
+        if not data: return
+        if self.softspace:
+            self.writer.send_flowing_data(" ")
+        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.para_end = self.parskip = \
-			      self.have_label = self.softspace = 0
-	    self.nospace = 1
-	    self.writer.send_flowing_data(' ')
+        if self.softspace:
+            self.hard_break = self.para_end = self.parskip = \
+                              self.have_label = self.softspace = 0
+            self.nospace = 1
+            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)
+        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)
+        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.para_end = self.softspace = 0
-	    self.nospace = 1
-	    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)
+        if self.softspace:
+            self.hard_break = self.para_end = self.softspace = 0
+            self.nospace = 1
+            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.font_stack:
-	    del self.font_stack[-1]
-	if self.font_stack:
-	    font = self.font_stack[-1]
-	else:
-	    font = None
-	self.writer.new_font(font)
+        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))
+        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))
+        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)
+        self.spacing = spacing
+        self.writer.new_spacing(spacing)
 
     def push_style(self, *styles):
-	if self.softspace:
-	    self.hard_break = self.para_end = self.softspace = 0
-	    self.nospace = 1
-	    self.writer.send_flowing_data(' ')
-	for style in styles:
-	    self.style_stack.append(style)
-	self.writer.new_styles(tuple(self.style_stack))
+        if self.softspace:
+            self.hard_break = self.para_end = self.softspace = 0
+            self.nospace = 1
+            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):
-	del self.style_stack[-n:]
-	self.writer.new_styles(tuple(self.style_stack))
+        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.parskip = self.have_label = 0
+        self.nospace = self.hard_break = not flag
+        self.para_end = self.parskip = self.have_label = 0
 
 
 class NullWriter:
@@ -282,119 +282,119 @@
 class AbstractWriter(NullWriter):
 
     def __init__(self):
-	pass
+        pass
 
     def new_alignment(self, align):
-	print "new_alignment(%s)" % `align`
+        print "new_alignment(%s)" % `align`
 
     def new_font(self, font):
-	print "new_font(%s)" % `font`
+        print "new_font(%s)" % `font`
 
     def new_margin(self, margin, level):
-	print "new_margin(%s, %d)" % (`margin`, level)
+        print "new_margin(%s, %d)" % (`margin`, level)
 
     def new_spacing(self, spacing):
-	print "new_spacing(%s)" % `spacing`
+        print "new_spacing(%s)" % `spacing`
 
     def new_styles(self, styles):
-	print "new_styles(%s)" % `styles`
+        print "new_styles(%s)" % `styles`
 
     def send_paragraph(self, blankline):
-	print "send_paragraph(%s)" % `blankline`
+        print "send_paragraph(%s)" % `blankline`
 
     def send_line_break(self):
-	print "send_line_break()"
+        print "send_line_break()"
 
     def send_hor_rule(self, *args, **kw):
-	print "send_hor_rule()"
+        print "send_hor_rule()"
 
     def send_label_data(self, data):
-	print "send_label_data(%s)" % `data`
+        print "send_label_data(%s)" % `data`
 
     def send_flowing_data(self, data):
-	print "send_flowing_data(%s)" % `data`
+        print "send_flowing_data(%s)" % `data`
 
     def send_literal_data(self, data):
-	print "send_literal_data(%s)" % `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()
+        self.file = file or sys.stdout
+        self.maxcol = maxcol
+        NullWriter.__init__(self)
+        self.reset()
 
     def reset(self):
-	self.col = 0
-	self.atbreak = 0
+        self.col = 0
+        self.atbreak = 0
 
     def send_paragraph(self, blankline):
-	self.file.write('\n' + '\n'*blankline)
-	self.col = 0
-	self.atbreak = 0
+        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
+        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
+        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
+        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
+        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)
+        fp = open(file)
     elif sys.argv[1:]:
-	fp = open(sys.argv[1])
+        fp = open(sys.argv[1])
     else:
-	fp = sys.stdin
+        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)
+        line = fp.readline()
+        if not line:
+            break
+        if line == '\n':
+            f.end_paragraph(1)
+        else:
+            f.add_flowing_data(line)
     f.end_paragraph(0)
 
 
diff --git a/Lib/dos-8x3/gopherli.py b/Lib/dos-8x3/gopherli.py
index cf06e95..033e579 100755
--- a/Lib/dos-8x3/gopherli.py
+++ b/Lib/dos-8x3/gopherli.py
@@ -38,10 +38,10 @@
 
 # Function mapping all file types to strings; unknown types become TYPE='x'
 _names = dir()
-_type_to_name_map = None
+_type_to_name_map = {}
 def type_to_name(gtype):
 	global _type_to_name_map
-	if not _type_to_name_map:
+	if _type_to_name_map=={}:
 		for name in _names:
 			if name[:2] == 'A_':
 				_type_to_name_map[eval(name)] = name[2:]
@@ -75,6 +75,22 @@
 def send_query(selector, query, host, port = 0):
 	return send_selector(selector + '\t' + query, host, port)
 
+# Takes a path as returned by urlparse and returns the appropriate selector
+def path_to_selector(path):
+	if path=="/":
+		return "/"
+	else:
+		return path[2:] # Cuts initial slash and data type identifier
+
+# Takes a path as returned by urlparse and maps it to a string
+# See section 3.4 of RFC 1738 for details
+def path_to_datatype_name(path):
+	if path=="/":
+		# No way to tell, although "INDEX" is likely
+		return "TYPE='unknown'"
+	else:
+		return type_to_name(path[1])
+
 # The following functions interpret the data returned by the gopher
 # server according to the expected type, e.g. textfile or directory
 
@@ -103,7 +119,8 @@
 			continue
 		if len(parts) > 4:
 			if parts[4:] != ['+']:
-			    print '(Extra info from server:', parts[4:], ')'
+				print '(Extra info from server:',
+				print parts[4:], ')'
 		else:
 			parts.append('')
 		parts.insert(0, gtype)
diff --git a/Lib/dos-8x3/macurl2p.py b/Lib/dos-8x3/macurl2p.py
index db4c599..dced58a 100755
--- a/Lib/dos-8x3/macurl2p.py
+++ b/Lib/dos-8x3/macurl2p.py
@@ -12,71 +12,71 @@
     #
     tp = urllib.splittype(pathname)[0]
     if tp and tp <> 'file':
-	raise RuntimeError, 'Cannot convert non-local URL to pathname'
+        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 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:], ':')
+        # 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, ':')
+        # 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"
+        raise RuntimeError, "Cannot convert pathname containing slashes"
     components = string.split(pathname, ':')
     # Remove empty first and/or last component
     if components[0] == '':
-    	del components[0]
+        del components[0]
     if components[-1] == '':
-    	del components[-1]
+        del components[-1]
     # Replace empty string ('::') by .. (will result in '/../' later)
     for i in range(len(components)):
-	if components[i] == '':
-	    components[i] = '..'
+        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, '/')
+        return '/' + string.join(components, '/')
     else:
-	return string.join(components, '/')
+        return string.join(components, '/')
 
 def test():
     for url in ["index.html",
-		"bar/index.html",
-		"/foo/bar/index.html",
-		"/foo/bar/",
-		"/"]:
-	print `url`, '->', `url2pathname(url)`
+                "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)`
+                 "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/mimetype.py b/Lib/dos-8x3/mimetype.py
index fd0e1c5..296c0ca 100644
--- a/Lib/dos-8x3/mimetype.py
+++ b/Lib/dos-8x3/mimetype.py
@@ -48,49 +48,49 @@
 
     """
     if not inited:
-	init()
+        init()
     base, ext = posixpath.splitext(url)
     while suffix_map.has_key(ext):
-	base, ext = posixpath.splitext(base + suffix_map[ext])
+        base, ext = posixpath.splitext(base + suffix_map[ext])
     if encodings_map.has_key(ext):
-	encoding = encodings_map[ext]
-	base, ext = posixpath.splitext(base)
+        encoding = encodings_map[ext]
+        base, ext = posixpath.splitext(base)
     else:
-	encoding = None
+        encoding = None
     if types_map.has_key(ext):
-	return types_map[ext], encoding
+        return types_map[ext], encoding
     elif types_map.has_key(string.lower(ext)):
-	return types_map[string.lower(ext)], encoding
+        return types_map[string.lower(ext)], encoding
     else:
-	return None, encoding
+        return None, encoding
 
 def init(files=None):
     global inited
     for file in files or knownfiles:
-	s = read_mime_types(file)
-	if s:
-	    for key, value in s.items():
-		types_map[key] = value
+        s = read_mime_types(file)
+        if s:
+            for key, value in s.items():
+                types_map[key] = value
     inited = 1
 
 def read_mime_types(file):
     try:
-	f = open(file)
+        f = open(file)
     except IOError:
-	return None
+        return None
     map = {}
     while 1:
-	line = f.readline()
-	if not line: break
-	words = string.split(line)
-	for i in range(len(words)):
-	    if words[i][0] == '#':
-		del words[i:]
-		break
-	if not words: continue
-	type, suffixes = words[0], words[1:]
-	for suff in suffixes:
-	    map['.'+suff] = type
+        line = f.readline()
+        if not line: break
+        words = string.split(line)
+        for i in range(len(words)):
+            if words[i][0] == '#':
+                del words[i:]
+                break
+        if not words: continue
+        type, suffixes = words[0], words[1:]
+        for suff in suffixes:
+            map['.'+suff] = type
     f.close()
     return map
 
diff --git a/Lib/dos-8x3/mimewrit.py b/Lib/dos-8x3/mimewrit.py
index 29a9933..0f8b990 100644
--- a/Lib/dos-8x3/mimewrit.py
+++ b/Lib/dos-8x3/mimewrit.py
@@ -47,7 +47,7 @@
     w.startmultipartbody(subtype)
     for each part:
         subwriter = w.nextpart()
-	...use the subwriter's methods to create the subpart...
+        ...use the subwriter's methods to create the subpart...
     w.lastpart()
 
     The subwriter is another MimeWriter instance, and should be
@@ -82,46 +82,46 @@
     """
 
     def __init__(self, fp):
-	self._fp = fp
-	self._headers = []
+        self._fp = fp
+        self._headers = []
 
     def addheader(self, key, value, prefix=0):
-	lines = string.splitfields(value, "\n")
-	while lines and not lines[-1]: del lines[-1]
-	while lines and not lines[0]: del lines[0]
-	for i in range(1, len(lines)):
-	    lines[i] = "    " + string.strip(lines[i])
-	value = string.joinfields(lines, "\n") + "\n"
-	line = key + ": " + value
-	if prefix:
-	    self._headers.insert(0, line)
-	else:
-	    self._headers.append(line)
+        lines = string.splitfields(value, "\n")
+        while lines and not lines[-1]: del lines[-1]
+        while lines and not lines[0]: del lines[0]
+        for i in range(1, len(lines)):
+            lines[i] = "    " + string.strip(lines[i])
+        value = string.joinfields(lines, "\n") + "\n"
+        line = key + ": " + value
+        if prefix:
+            self._headers.insert(0, line)
+        else:
+            self._headers.append(line)
 
     def flushheaders(self):
-	self._fp.writelines(self._headers)
-	self._headers = []
+        self._fp.writelines(self._headers)
+        self._headers = []
 
     def startbody(self, ctype, plist=[], prefix=1):
-	for name, value in plist:
-	    ctype = ctype + ';\n %s=\"%s\"' % (name, value)
-	self.addheader("Content-Type", ctype, prefix=prefix)
-	self.flushheaders()
-	self._fp.write("\n")
-	return self._fp
+        for name, value in plist:
+            ctype = ctype + ';\n %s=\"%s\"' % (name, value)
+        self.addheader("Content-Type", ctype, prefix=prefix)
+        self.flushheaders()
+        self._fp.write("\n")
+        return self._fp
 
     def startmultipartbody(self, subtype, boundary=None, plist=[], prefix=1):
-	self._boundary = boundary or mimetools.choose_boundary()
-	return self.startbody("multipart/" + subtype,
-			      [("boundary", self._boundary)] + plist,
-			      prefix=prefix)
+        self._boundary = boundary or mimetools.choose_boundary()
+        return self.startbody("multipart/" + subtype,
+                              [("boundary", self._boundary)] + plist,
+                              prefix=prefix)
 
     def nextpart(self):
-	self._fp.write("\n--" + self._boundary + "\n")
-	return self.__class__(self._fp)
+        self._fp.write("\n--" + self._boundary + "\n")
+        return self.__class__(self._fp)
 
     def lastpart(self):
-	self._fp.write("\n--" + self._boundary + "--\n")
+        self._fp.write("\n--" + self._boundary + "--\n")
 
 
 if __name__ == '__main__':
diff --git a/Lib/dos-8x3/multifil.py b/Lib/dos-8x3/multifil.py
index 71e0dd0..8ba88e4 100755
--- a/Lib/dos-8x3/multifil.py
+++ b/Lib/dos-8x3/multifil.py
@@ -44,8 +44,17 @@
 			return self.lastpos
 		return self.fp.tell() - self.start
 	#
-	def seek(self, pos):
-		if not 0 <= pos <= self.tell() or \
+	def seek(self, pos, whence=0):
+		here = self.tell()
+		if whence:
+			if whence == 1:
+				pos = pos + here
+			elif whence == 2:
+				if self.level > 0:
+					pos = pos + self.lastpos
+				else:
+					raise Error, "can't use whence=2 yet"
+		if not 0 <= pos <= here or \
 				self.level > 0 and pos > self.lastpos:
 			raise Error, 'bad MultiFile.seek() call'
 		self.fp.seek(pos + self.start)
diff --git a/Lib/dos-8x3/posixfil.py b/Lib/dos-8x3/posixfil.py
index d66517f..d3aeac0 100755
--- a/Lib/dos-8x3/posixfil.py
+++ b/Lib/dos-8x3/posixfil.py
@@ -6,56 +6,56 @@
 # Extended file operations
 #
 # f = posixfile.open(filename, [mode, [bufsize]])
-#	will create a new posixfile object
+#       will create a new posixfile object
 #
 # f = posixfile.fileopen(fileobject)
-#	will create a posixfile object from a builtin file object
+#       will create a posixfile object from a builtin file object
 #
 # f.file()
-#	will return the original builtin file object
+#       will return the original builtin file object
 #
 # f.dup()
-#	will return a new file object based on a new filedescriptor
+#       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
+#       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:
+#       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
+#       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
+#       !       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
+#       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:
+#       will (un)lock a region
+#       mode can contain the following characters:
 #
 #   (character representing type of lock)
-#	u	unlock
-#	r	read lock
-#	w	write 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')
+#       |       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
+#       note: - the '?' modifier prevents a region from being locked; it is
+#               query only
 #
 
 class _posixfile_:
@@ -65,149 +65,149 @@
     # 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:])
+        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()
+        self._file_.close()
 
     #
     # Initialization routines
     #
     def open(self, name, mode='r', bufsize=-1):
-	import __builtin__
-	return self.fileopen(__builtin__.open(name, mode, bufsize))
+        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
+        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_
+        return self._file_
 
     def dup(self):
-	import posix
+        import posix
 
-	try: ignore = posix.fdopen
-	except: raise AttributeError, 'dup() method unavailable'
+        try: ignore = posix.fdopen
+        except: raise AttributeError, 'dup() method unavailable'
 
-	return posix.fdopen(posix.dup(self._file_.fileno()), self._file_.mode)
+        return posix.fdopen(posix.dup(self._file_.fileno()), self._file_.mode)
 
     def dup2(self, fd):
-	import posix
+        import posix
 
-	try: ignore = posix.fdopen
-	except: raise AttributeError, 'dup() method unavailable'
+        try: ignore = posix.fdopen
+        except: raise AttributeError, 'dup() method unavailable'
 
-	posix.dup2(self._file_.fileno(), fd)
-	return posix.fdopen(fd, self._file_.mode)
+        posix.dup2(self._file_.fileno(), fd)
+        return posix.fdopen(fd, self._file_.mode)
 
     def flags(self, *which):
-	import fcntl, FCNTL
+        import fcntl, FCNTL
 
-	if which:
-	    if len(which) > 1:
-		raise TypeError, 'Too many arguments'
-	    which = which[0]
-	else: which = '?'
+        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
+        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_
+        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
+        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)
+        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 '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
-	
+        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
+        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 '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
+        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
+        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'
+        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'
 
-	# Hack by davem@magnet.com to get locking to go on freebsd;
-	# additions for AIX by Vladimir.Marangozov@imag.fr
+        # Hack by davem@magnet.com to get locking to go on freebsd;
+        # additions for AIX by Vladimir.Marangozov@imag.fr
         import sys, os
         if sys.platform in ('netbsd1', 'freebsd2', 'freebsd3'):
-	    flock = struct.pack('lxxxxlxxxxlhh', \
-		  l_start, l_len, os.getpid(), l_type, l_whence) 
+            flock = struct.pack('lxxxxlxxxxlhh', \
+                  l_start, l_len, os.getpid(), l_type, l_whence) 
         elif sys.platform in ['aix3', 'aix4']:
             flock = struct.pack('hhlllii', \
                   l_type, l_whence, l_start, l_len, 0, 0, 0)
-	else:
-	    flock = struct.pack('hhllhh', \
-		  l_type, l_whence, l_start, l_len, 0, 0)
+        else:
+            flock = struct.pack('hhllhh', \
+                  l_type, l_whence, l_start, l_len, 0, 0)
 
-	flock = fcntl.fcntl(self._file_.fileno(), cmd, flock)
+        flock = fcntl.fcntl(self._file_.fileno(), cmd, flock)
 
-	if '?' in how:
-	    if sys.platform in ('netbsd1', 'freebsd2', 'freebsd3'):
-		l_start, l_len, l_pid, l_type, l_whence = \
-		    struct.unpack('lxxxxlxxxxlhh', flock)
+        if '?' in how:
+            if sys.platform in ('netbsd1', 'freebsd2', 'freebsd3'):
+                l_start, l_len, l_pid, l_type, l_whence = \
+                    struct.unpack('lxxxxlxxxxlhh', flock)
             elif sys.platform in ['aix3', 'aix4']:
                 l_type, l_whence, l_start, l_len, l_sysid, l_pid, l_vfs = \
                     struct.unpack('hhlllii', flock)
-	    elif sys.platform == "linux2":
-		l_type, l_whence, l_start, l_len, l_pid, l_sysid = \
-		    struct.unpack('hhllhh', flock)
-	    else:
-		l_type, l_whence, l_start, l_len, l_sysid, l_pid = \
-		    struct.unpack('hhllhh', flock)
+            elif sys.platform == "linux2":
+                l_type, l_whence, l_start, l_len, l_pid, l_sysid = \
+                    struct.unpack('hhllhh', flock)
+            else:
+                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
+            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
diff --git a/Lib/dos-8x3/py_compi.py b/Lib/dos-8x3/py_compi.py
index 1adc3a2..949de6c 100755
--- a/Lib/dos-8x3/py_compi.py
+++ b/Lib/dos-8x3/py_compi.py
@@ -1,37 +1,68 @@
-# 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 :-).
+"""Routine to "compile" a .py file to a .pyc (or .pyo) file.
+
+This module has intimate knowledge of the format of .pyc files.
+"""
 
 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))
+    "Internal; write a 32-bit int to a file in little-endian order."
+    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)
-	try:
-	    timestamp = os.fstat(file.fileno())
-	except AttributeError:
-	    timestamp = long(os.stat(file)[8])
-	codestring = f.read()
-	f.close()
-	codeobject = __builtin__.compile(codestring, file, 'exec')
-	if not cfile:
-		cfile = file + (__debug__ and 'c' or 'o')
-	fc = open(cfile, 'wb')
-	fc.write('\0\0\0\0')
-	wr_long(fc, timestamp)
-	marshal.dump(codeobject, fc)
-	fc.flush()
-	fc.seek(0, 0)
-	fc.write(MAGIC)
-	fc.close()
-	if os.name == 'mac':
-		import macfs
-		macfs.FSSpec(cfile).SetCreatorType('Pyth', 'PYC ')
-		macfs.FSSpec(file).SetCreatorType('Pyth', 'TEXT')
+def compile(file, cfile=None, dfile=None):
+    """Byte-compile one Python source file to Python bytecode.
+
+    Arguments:
+
+    file:  source filename
+    cfile: target filename; defaults to source with 'c' or 'o' appended
+           ('c' normally, 'o' in optimizing mode, giving .pyc or .pyo)
+    dfile: purported filename; defaults to source (this is the filename
+           that will show up in error messages)
+
+    Note that it isn't necessary to byte-compile Python modules for
+    execution efficiency -- Python itself byte-compiles a module when
+    it is loaded, and if it can, writes out the bytecode to the
+    corresponding .pyc (or .pyo) file.
+
+    However, if a Python installation is shared between users, it is a
+    good idea to byte-compile all modules upon installation, since
+    other users may not be able to write in the source directories,
+    and thus they won't be able to write the .pyc/.pyo file, and then
+    they would be byte-compiling every module each time it is loaded.
+    This can slow down program start-up considerably.
+
+    See compileall.py for a script/module that uses this module to
+    byte-compile all installed files (or all files in selected
+    directories).
+
+    """
+    import os, marshal, __builtin__
+    f = open(file)
+    try:
+        timestamp = os.fstat(file.fileno())
+    except AttributeError:
+        timestamp = long(os.stat(file)[8])
+    codestring = f.read()
+    f.close()
+    if codestring and codestring[-1] != '\n':
+        codestring = codestring + '\n'
+    codeobject = __builtin__.compile(codestring, dfile or file, 'exec')
+    if not cfile:
+        cfile = file + (__debug__ and 'c' or 'o')
+    fc = open(cfile, 'wb')
+    fc.write('\0\0\0\0')
+    wr_long(fc, timestamp)
+    marshal.dump(codeobject, fc)
+    fc.flush()
+    fc.seek(0, 0)
+    fc.write(MAGIC)
+    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
index 1cec4e3..6710153 100755
--- a/Lib/dos-8x3/queue.py
+++ b/Lib/dos-8x3/queue.py
@@ -4,102 +4,102 @@
 # exceptions, but also when -X option is used.
 try:
     class Empty(Exception):
-	pass
+        pass
 except TypeError:
     # string based exceptions
-    Empty = 'Queue.Empty'		# Exception raised by get_nowait()
+    Empty = 'Queue.Empty'               # Exception raised by get_nowait()
 
 class Queue:
     def __init__(self, maxsize):
-	"""Initialize a queue object with a given maximum size.
+        """Initialize a queue object with a given maximum size.
 
-	If maxsize is <= 0, the queue size is infinite.
-	"""
-	import thread
-	self._init(maxsize)
-	self.mutex = thread.allocate_lock()
-	self.esema = thread.allocate_lock()
-	self.esema.acquire_lock()
-	self.fsema = thread.allocate_lock()
+        If maxsize is <= 0, the queue size is infinite.
+        """
+        import thread
+        self._init(maxsize)
+        self.mutex = thread.allocate_lock()
+        self.esema = thread.allocate_lock()
+        self.esema.acquire_lock()
+        self.fsema = thread.allocate_lock()
 
     def qsize(self):
-	"""Returns the approximate size of the queue (not reliable!)."""
-	self.mutex.acquire_lock()
-	n = self._qsize()
-	self.mutex.release_lock()
-	return n
+        """Returns the approximate size of the queue (not reliable!)."""
+        self.mutex.acquire_lock()
+        n = self._qsize()
+        self.mutex.release_lock()
+        return n
 
     def empty(self):
-	"""Returns 1 if the queue is empty, 0 otherwise (not reliable!)."""
-	self.mutex.acquire_lock()
-	n = self._empty()
-	self.mutex.release_lock()
-	return n
+        """Returns 1 if the queue is empty, 0 otherwise (not reliable!)."""
+        self.mutex.acquire_lock()
+        n = self._empty()
+        self.mutex.release_lock()
+        return n
 
     def full(self):
-	"""Returns 1 if the queue is full, 0 otherwise (not reliable!)."""
-	self.mutex.acquire_lock()
-	n = self._full()
-	self.mutex.release_lock()
-	return n
+        """Returns 1 if the queue is full, 0 otherwise (not reliable!)."""
+        self.mutex.acquire_lock()
+        n = self._full()
+        self.mutex.release_lock()
+        return n
 
     def put(self, item):
-	"""Put an item into the queue."""
-	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()
+        """Put an item into the queue."""
+        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()
 
     def get(self):
-	"""Gets and returns an item from the queue.
-	This method blocks if necessary until an item is available.
-	"""
-	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
+        """Gets and returns an item from the queue.
+        This method blocks if necessary until an item is available.
+        """
+        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):
-	"""Gets and returns an item from the queue.
-	Only gets an item if one is immediately available, Otherwise
-	this raises the Empty exception if the queue is empty or
-	temporarily unavailable.
-	"""
-	locked = self.esema.acquire_lock(0)
-	self.mutex.acquire_lock()
-	if self._empty():
-	    # The queue is empty -- 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
+        """Gets and returns an item from the queue.
+        Only gets an item if one is immediately available, Otherwise
+        this raises the Empty exception if the queue is empty or
+        temporarily unavailable.
+        """
+        locked = self.esema.acquire_lock(0)
+        self.mutex.acquire_lock()
+        if self._empty():
+            # The queue is empty -- 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.
 
@@ -110,26 +110,26 @@
 
     # Initialize the queue representation
     def _init(self, maxsize):
-	self.maxsize = maxsize
-	self.queue = []
+        self.maxsize = maxsize
+        self.queue = []
 
     def _qsize(self):
-	return len(self.queue)
+        return len(self.queue)
 
     # Check wheter the queue is empty
     def _empty(self):
-	return not self.queue
+        return not self.queue
 
     # Check whether the queue is full
     def _full(self):
-	return self.maxsize > 0 and len(self.queue) == self.maxsize
+        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)
+        self.queue.append(item)
 
     # Get an item from the queue
     def _get(self):
-	item = self.queue[0]
-	del self.queue[0]
-	return item
+        item = self.queue[0]
+        del self.queue[0]
+        return item
diff --git a/Lib/dos-8x3/reconver.py b/Lib/dos-8x3/reconver.py
index f0b61fc..2b044b6 100644
--- a/Lib/dos-8x3/reconver.py
+++ b/Lib/dos-8x3/reconver.py
@@ -108,36 +108,36 @@
     """
     table = mastertable.copy()
     if syntax is None:
-	syntax = regex.get_syntax()
+        syntax = regex.get_syntax()
     if syntax & RE_NO_BK_PARENS:
-	del table[r'\('], table[r'\)']
-	del table['('], table[')']
+        del table[r'\('], table[r'\)']
+        del table['('], table[')']
     if syntax & RE_NO_BK_VBAR:
-	del table[r'\|']
-	del table['|']
+        del table[r'\|']
+        del table['|']
     if syntax & RE_BK_PLUS_QM:
-	table['+'] = r'\+'
-	table['?'] = r'\?'
-	table[r'\+'] = '+'
-	table[r'\?'] = '?'
+        table['+'] = r'\+'
+        table['?'] = r'\?'
+        table[r'\+'] = '+'
+        table[r'\?'] = '?'
     if syntax & RE_NEWLINE_OR:
-	table['\n'] = '|'
+        table['\n'] = '|'
     res = ""
 
     i = 0
     end = len(s)
     while i < end:
-	c = s[i]
-	i = i+1
-	if c == '\\':
-	    c = s[i]
-	    i = i+1
-	    key = '\\' + c
-	    key = table.get(key, key)
-	    res = res + key
-	else:
-	    c = table.get(c, c)
-	    res = res + c
+        c = s[i]
+        i = i+1
+        if c == '\\':
+            c = s[i]
+            i = i+1
+            key = '\\' + c
+            key = table.get(key, key)
+            res = res + key
+        else:
+            c = table.get(c, c)
+            res = res + c
     return res
 
 
@@ -155,21 +155,21 @@
 
     """
     if quote is None:
-	q = "'"
-	altq = "'"
-	if q in s and altq not in s:
-	    q = altq
+        q = "'"
+        altq = "'"
+        if q in s and altq not in s:
+            q = altq
     else:
-	assert quote in ('"', "'")
-	q = quote
+        assert quote in ('"', "'")
+        q = quote
     res = q
     for c in s:
-	if c == q: c = '\\' + c
-	elif c < ' ' or c > '~': c = "\\%03o" % ord(c)
-	res = res + c
+        if c == q: c = '\\' + c
+        elif c < ' ' or c > '~': c = "\\%03o" % ord(c)
+        res = res + c
     res = res + q
     if '\\' in res:
-	res = 'r' + res
+        res = 'r' + res
     return res
 
 
@@ -179,7 +179,7 @@
     s = eval(sys.stdin.read())
     sys.stdout.write(quote(convert(s)))
     if sys.stdout.isatty():
-	sys.stdout.write("\n")
+        sys.stdout.write("\n")
 
 
 if __name__ == '__main__':
diff --git a/Lib/dos-8x3/rlcomple.py b/Lib/dos-8x3/rlcomple.py
index 4deb0bc..e0ae72c 100644
--- a/Lib/dos-8x3/rlcomple.py
+++ b/Lib/dos-8x3/rlcomple.py
@@ -47,60 +47,60 @@
 class Completer:
 
     def complete(self, text, state):
-	"""Return the next possible completion for 'text'.
+        """Return the next possible completion for 'text'.
 
-	This is called successively with state == 0, 1, 2, ... until it
-	returns None.  The completion should begin with 'text'.
+        This is called successively with state == 0, 1, 2, ... until it
+        returns None.  The completion should begin with 'text'.
 
-	"""
-	if state == 0:
-	    if "." in text:
-		self.matches = self.attr_matches(text)
-	    else:
-		self.matches = self.global_matches(text)
-	return self.matches[state]
+        """
+        if state == 0:
+            if "." in text:
+                self.matches = self.attr_matches(text)
+            else:
+                self.matches = self.global_matches(text)
+        return self.matches[state]
 
     def global_matches(self, text):
-	"""Compute matches when text is a simple name.
+        """Compute matches when text is a simple name.
 
-	Return a list of all keywords, built-in functions and names
-	currently defines in __main__ that match.
+        Return a list of all keywords, built-in functions and names
+        currently defines in __main__ that match.
 
-	"""
-	import keyword
-	matches = []
-	n = len(text)
-	for list in [keyword.kwlist,
-		     __builtin__.__dict__.keys(),
-		     __main__.__dict__.keys()]:
-	    for word in list:
-		if word[:n] == text:
-		    matches.append(word)
-	return matches
+        """
+        import keyword
+        matches = []
+        n = len(text)
+        for list in [keyword.kwlist,
+                     __builtin__.__dict__.keys(),
+                     __main__.__dict__.keys()]:
+            for word in list:
+                if word[:n] == text:
+                    matches.append(word)
+        return matches
 
     def attr_matches(self, text):
-	"""Compute matches when text contains a dot.
+        """Compute matches when text contains a dot.
 
-	Assuming the text is of the form NAME.NAME....[NAME], and is
-	evaluabable in the globals of __main__, it will be evaluated
-	and its attributes (as revealed by dir()) are used as possible
-	completions.
+        Assuming the text is of the form NAME.NAME....[NAME], and is
+        evaluabable in the globals of __main__, it will be evaluated
+        and its attributes (as revealed by dir()) are used as possible
+        completions.
 
-	WARNING: this can still invoke arbitrary C code, if an object
-	with a __getattr__ hook is evaluated.
+        WARNING: this can still invoke arbitrary C code, if an object
+        with a __getattr__ hook is evaluated.
 
-	"""
-	import re
-	m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
-	if not m:
-	    return
-	expr, attr = m.group(1, 3)
-	words = dir(eval(expr, __main__.__dict__))
-	matches = []
-	n = len(attr)
-	for word in words:
-	    if word[:n] == attr:
-		matches.append("%s.%s" % (expr, word))
-	return matches
+        """
+        import re
+        m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
+        if not m:
+            return
+        expr, attr = m.group(1, 3)
+        words = dir(eval(expr, __main__.__dict__))
+        matches = []
+        n = len(attr)
+        for word in words:
+            if word[:n] == attr:
+                matches.append("%s.%s" % (expr, word))
+        return matches
 
 readline.set_completer(Completer().complete)
diff --git a/Lib/dos-8x3/simpleht.py b/Lib/dos-8x3/simpleht.py
index ac3e384..7126855 100755
--- a/Lib/dos-8x3/simpleht.py
+++ b/Lib/dos-8x3/simpleht.py
@@ -36,119 +36,119 @@
     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()
+        """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()
+        """Serve a HEAD request."""
+        f = self.send_head()
+        if f:
+            f.close()
 
     def send_head(self):
-	"""Common code for GET and HEAD commands.
+        """Common code for GET and HEAD commands.
 
-	This sends the response code and MIME headers.
+        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.
+        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
+        """
+        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.
+        """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.)
+        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
+        """
+        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.
+        """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 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.
+        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)
+        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.
+        """Guess the type of a file.
 
-	Argument is a PATH (a filename).
+        Argument is a PATH (a filename).
 
-	Return value is a string of the form type/subtype,
-	usable for a MIME Content-type header.
+        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.
+        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['']
+        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',
-	    }
+            '': '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):
+         ServerClass = SocketServer.TCPServer):
     BaseHTTPServer.test(HandlerClass, ServerClass)
 
 
diff --git a/Lib/dos-8x3/socketse.py b/Lib/dos-8x3/socketse.py
index 049a4b6..64a86d1 100755
--- a/Lib/dos-8x3/socketse.py
+++ b/Lib/dos-8x3/socketse.py
@@ -3,19 +3,19 @@
 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>
+        - 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)
+        - 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)
+        (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)
+        - 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
@@ -25,14 +25,14 @@
 There are four classes in an inheritance diagram that represent
 synchronous servers of four types:
 
-	+-----------+        +------------------+
-	| TCPServer |------->| UnixStreamServer |
-	+-----------+        +------------------+
-	      |
-	      v
-	+-----------+        +--------------------+
-	| UDPServer |------->| UnixDatagramServer |
-	+-----------+        +--------------------+
+        +-----------+        +------------------+
+        | TCPServer |------->| UnixStreamServer |
+        +-----------+        +------------------+
+              |
+              v
+        +-----------+        +--------------------+
+        | UDPServer |------->| UnixDatagramServer |
+        +-----------+        +--------------------+
 
 Note that UnixDatagramServer derives from UDPServer, not from
 UnixStreamServer -- the only difference between an IP and a Unix
@@ -43,7 +43,7 @@
 using the ForkingServer and ThreadingServer mix-in classes.  For
 instance, a threading UDP server class is created as follows:
 
-	class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
+        class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
 
 The Mix-in class must come first, since it overrides a method defined
 in UDPServer!
@@ -119,8 +119,8 @@
 
     - __init__(server_address, RequestHandlerClass)
     - serve_forever()
-    - handle_request()	# if you don't use serve_forever()
-    - fileno() -> int	# for select()
+    - handle_request()  # if you don't use serve_forever()
+    - fileno() -> int   # for select()
 
     Methods that may be overridden:
 
@@ -157,42 +157,42 @@
     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()
+        """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.
+        """Called by constructor to bind the socket.
 
-	May be overridden.
+        May be overridden.
 
-	"""
-	self.socket.bind(self.server_address)
+        """
+        self.socket.bind(self.server_address)
 
     def server_activate(self):
-	"""Called by constructor to activate the server.
+        """Called by constructor to activate the server.
 
-	May be overridden.
+        May be overridden.
 
-	"""
-	self.socket.listen(self.request_queue_size)
+        """
+        self.socket.listen(self.request_queue_size)
 
     def fileno(self):
-	"""Return socket file number.
+        """Return socket file number.
 
-	Interface required by select().
+        Interface required by select().
 
-	"""
-	return self.socket.fileno()
+        """
+        return self.socket.fileno()
 
     def serve_forever(self):
-	"""Handle one request at a time until doomsday."""
-	while 1:
-	    self.handle_request()
+        """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:
@@ -206,54 +206,54 @@
     #   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)
+        """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.
+        """Get the request and client address from the socket.
 
-	May be overridden.
+        May be overridden.
 
-	"""
-	return self.socket.accept()
+        """
+        return self.socket.accept()
 
     def verify_request(self, request, client_address):
-	"""Verify the request.  May be overridden.
+        """Verify the request.  May be overridden.
 
-	Return true if we should proceed with this request.
+        Return true if we should proceed with this request.
 
-	"""
-	return 1
+        """
+        return 1
 
     def process_request(self, request, client_address):
-	"""Call finish_request.
+        """Call finish_request.
 
-	Overridden by ForkingMixIn and ThreadingMixIn.
+        Overridden by ForkingMixIn and ThreadingMixIn.
 
-	"""
-	self.finish_request(request, client_address)
+        """
+        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)
+        """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.
+        """Handle an error gracefully.  May be overridden.
 
-	The default is to print a traceback and continue.
+        The default is to print a traceback and continue.
 
-	"""
-	print '-'*40
-	print 'Exception happened during processing of request from',
-	print client_address
-	import traceback
-	traceback.print_exc()
-	print '-'*40
+        """
+        print '-'*40
+        print 'Exception happened during processing of request from',
+        print client_address
+        import traceback
+        traceback.print_exc()
+        print '-'*40
 
 
 class UDPServer(TCPServer):
@@ -265,19 +265,19 @@
     max_packet_size = 8192
 
     def get_request(self):
-	return self.socket.recvfrom(self.max_packet_size)
+        return self.socket.recvfrom(self.max_packet_size)
 
 
 if hasattr(socket, 'AF_UNIX'):
 
     class UnixStreamServer(TCPServer):
 
-	address_family = socket.AF_UNIX
+        address_family = socket.AF_UNIX
 
 
     class UnixDatagramServer(UDPServer):
 
-	address_family = socket.AF_UNIX
+        address_family = socket.AF_UNIX
 
 
 class ForkingMixIn:
@@ -287,34 +287,34 @@
     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)
+        """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)
+        """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:
@@ -322,10 +322,10 @@
     """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))
+        """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
@@ -354,27 +354,27 @@
     """
 
     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
+        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
+        pass
 
     def __del__(self):
-	pass
+        pass
 
     def handle(self):
-	pass
+        pass
 
     def finish(self):
-	pass
+        pass
 
 
 # The following two classes make it possible to use the same service
@@ -390,12 +390,12 @@
     """Define self.rfile and self.wfile for stream sockets."""
 
     def setup(self):
-	self.connection = self.request
-	self.rfile = self.connection.makefile('rb', 0)
-	self.wfile = self.connection.makefile('wb', 0)
+        self.connection = self.request
+        self.rfile = self.connection.makefile('rb', 0)
+        self.wfile = self.connection.makefile('wb', 0)
 
     def finish(self):
-	self.wfile.flush()
+        self.wfile.flush()
 
 
 class DatagramRequestHandler(BaseRequestHandler):
@@ -403,10 +403,10 @@
     """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)
+        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())
+        self.socket.send(self.wfile.getvalue())
diff --git a/Lib/dos-8x3/telnetli.py b/Lib/dos-8x3/telnetli.py
index 4784a69..8cf372e 100644
--- a/Lib/dos-8x3/telnetli.py
+++ b/Lib/dos-8x3/telnetli.py
@@ -76,7 +76,7 @@
 
     read_until(expected, [timeout])
         Read until the expected string has been seen, or a timeout is
-	hit (default is no timeout); may block.
+        hit (default is no timeout); may block.
 
     read_all()
         Read all data until EOF; may block.
@@ -86,360 +86,362 @@
 
     read_very_eager()
         Read all data available already queued or on the socket,
-	without blocking.
+        without blocking.
 
     read_eager()
         Read either data already queued or some data available on the
-	socket, without blocking.
+        socket, without blocking.
 
     read_lazy()
         Read all data in the raw queue (processing it first), without
-	doing any socket I/O.
+        doing any socket I/O.
 
     read_very_lazy()
         Reads all data in the cooked queue, without doing any socket
-	I/O.
+        I/O.
 
     """
 
     def __init__(self, host=None, port=0):
-	"""Constructor.
+        """Constructor.
 
-	When called without arguments, create an unconnected instance.
-	With a hostname argument, it connects the instance; a port
-	number is optional.
+        When called without arguments, create an unconnected instance.
+        With a hostname argument, it connects the instance; a port
+        number is optional.
 
-	"""
-	self.debuglevel = DEBUGLEVEL
-	self.host = host
-	self.port = port
-	self.sock = None
-	self.rawq = ''
-	self.irawq = 0
-	self.cookedq = ''
-	self.eof = 0
-	if host:
-	    self.open(host, port)
+        """
+        self.debuglevel = DEBUGLEVEL
+        self.host = host
+        self.port = port
+        self.sock = None
+        self.rawq = ''
+        self.irawq = 0
+        self.cookedq = ''
+        self.eof = 0
+        if host:
+            self.open(host, port)
 
     def open(self, host, port=0):
-	"""Connect to a host.
+        """Connect to a host.
 
-	The optional second argument is the port number, which
-	defaults to the standard telnet port (23).
+        The optional second argument is the port number, which
+        defaults to the standard telnet port (23).
 
-	Don't try to reopen an already connected instance.
+        Don't try to reopen an already connected instance.
 
-	"""
-	self.eof = 0
-	if not port:
-	    port = TELNET_PORT
-	self.host = host
-	self.port = port
-	self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-	self.sock.connect((self.host, self.port))
+        """
+        self.eof = 0
+        if not port:
+            port = TELNET_PORT
+        self.host = host
+        self.port = port
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.connect((self.host, self.port))
 
     def __del__(self):
-	"""Destructor -- close the connection."""
-	self.close()
+        """Destructor -- close the connection."""
+        self.close()
 
     def msg(self, msg, *args):
-	"""Print a debug message, when the debug level is > 0.
+        """Print a debug message, when the debug level is > 0.
 
-	If extra arguments are present, they are substituted in the
-	message using the standard string formatting operator.
+        If extra arguments are present, they are substituted in the
+        message using the standard string formatting operator.
 
-	"""
-	if self.debuglevel > 0:
-	    print 'Telnet(%s,%d):' % (self.host, self.port),
-	    if args:
-		print msg % args
-	    else:
-		print msg
+        """
+        if self.debuglevel > 0:
+            print 'Telnet(%s,%d):' % (self.host, self.port),
+            if args:
+                print msg % args
+            else:
+                print msg
 
     def set_debuglevel(self, debuglevel):
-	"""Set the debug level.
+        """Set the debug level.
 
-	The higher it is, the more debug output you get (on sys.stdout).
+        The higher it is, the more debug output you get (on sys.stdout).
 
-	"""
-	self.debuglevel = debuglevel
+        """
+        self.debuglevel = debuglevel
 
     def close(self):
-	"""Close the connection."""
-	if self.sock:
-	    self.sock.close()
-	self.sock = 0
-	self.eof = 1
+        """Close the connection."""
+        if self.sock:
+            self.sock.close()
+        self.sock = 0
+        self.eof = 1
 
     def get_socket(self):
-	"""Return the socket object used internally."""
-	return self.sock
+        """Return the socket object used internally."""
+        return self.sock
 
     def fileno(self):
-	"""Return the fileno() of the socket object used internally."""
-	return self.sock.fileno()
+        """Return the fileno() of the socket object used internally."""
+        return self.sock.fileno()
 
     def write(self, buffer):
-	"""Write a string to the socket, doubling any IAC characters.
+        """Write a string to the socket, doubling any IAC characters.
 
-	Can block if the connection is blocked.  May raise
-	socket.error if the connection is closed.
+        Can block if the connection is blocked.  May raise
+        socket.error if the connection is closed.
 
-	"""
-	if IAC in buffer:
-	    buffer = string.replace(buffer, IAC, IAC+IAC)
-	self.sock.send(buffer)
+        """
+        if IAC in buffer:
+            buffer = string.replace(buffer, IAC, IAC+IAC)
+        self.msg("send %s", `buffer`)
+        self.sock.send(buffer)
 
     def read_until(self, match, timeout=None):
-	"""Read until a given string is encountered or until timeout.
+        """Read until a given string is encountered or until timeout.
 
-	When no match is found, return whatever is available instead,
-	possibly the empty string.  Raise EOFError if the connection
-	is closed and no cooked data is available.
+        When no match is found, return whatever is available instead,
+        possibly the empty string.  Raise EOFError if the connection
+        is closed and no cooked data is available.
 
-	"""
-	n = len(match)
-	self.process_rawq()
-	i = string.find(self.cookedq, match)
-	if i >= 0:
-	    i = i+n
-	    buf = self.cookedq[:i]
-	    self.cookedq = self.cookedq[i:]
-	    return buf
-	s_reply = ([self], [], [])
-	s_args = s_reply
-	if timeout is not None:
-	    s_args = s_args + (timeout,)
-	while not self.eof and apply(select.select, s_args) == s_reply:
-	    i = max(0, len(self.cookedq)-n)
-	    self.fill_rawq()
-	    self.process_rawq()
-	    i = string.find(self.cookedq, match, i)
-	    if i >= 0:
-		i = i+n
-		buf = self.cookedq[:i]
-		self.cookedq = self.cookedq[i:]
-		return buf
-	return self.read_very_lazy()
+        """
+        n = len(match)
+        self.process_rawq()
+        i = string.find(self.cookedq, match)
+        if i >= 0:
+            i = i+n
+            buf = self.cookedq[:i]
+            self.cookedq = self.cookedq[i:]
+            return buf
+        s_reply = ([self], [], [])
+        s_args = s_reply
+        if timeout is not None:
+            s_args = s_args + (timeout,)
+        while not self.eof and apply(select.select, s_args) == s_reply:
+            i = max(0, len(self.cookedq)-n)
+            self.fill_rawq()
+            self.process_rawq()
+            i = string.find(self.cookedq, match, i)
+            if i >= 0:
+                i = i+n
+                buf = self.cookedq[:i]
+                self.cookedq = self.cookedq[i:]
+                return buf
+        return self.read_very_lazy()
 
     def read_all(self):
-	"""Read all data until EOF; block until connection closed."""
-	self.process_rawq()
-	while not self.eof:
-	    self.fill_rawq()
-	    self.process_rawq()
-	buf = self.cookedq
-	self.cookedq = ''
-	return buf
+        """Read all data until EOF; block until connection closed."""
+        self.process_rawq()
+        while not self.eof:
+            self.fill_rawq()
+            self.process_rawq()
+        buf = self.cookedq
+        self.cookedq = ''
+        return buf
 
     def read_some(self):
-	"""Read at least one byte of cooked data unless EOF is hit.
+        """Read at least one byte of cooked data unless EOF is hit.
 
-	Return '' if EOF is hit.  Block if no data is immediately
-	available.
+        Return '' if EOF is hit.  Block if no data is immediately
+        available.
 
-	"""
-	self.process_rawq()
-	while not self.cookedq and not self.eof:
-	    self.fill_rawq()
-	    self.process_rawq()
-	buf = self.cookedq
-	self.cookedq = ''
-	return buf
+        """
+        self.process_rawq()
+        while not self.cookedq and not self.eof:
+            self.fill_rawq()
+            self.process_rawq()
+        buf = self.cookedq
+        self.cookedq = ''
+        return buf
 
     def read_very_eager(self):
-	"""Read everything that's possible without blocking in I/O (eager).
-	
-	Raise EOFError if connection closed and no cooked data
-	available.  Return '' if no cooked data available otherwise.
-	Don't block unless in the midst of an IAC sequence.
+        """Read everything that's possible without blocking in I/O (eager).
+        
+        Raise EOFError if connection closed and no cooked data
+        available.  Return '' if no cooked data available otherwise.
+        Don't block unless in the midst of an IAC sequence.
 
-	"""
-	self.process_rawq()
-	while not self.eof and self.sock_avail():
-	    self.fill_rawq()
-	    self.process_rawq()
-	return self.read_very_lazy()
+        """
+        self.process_rawq()
+        while not self.eof and self.sock_avail():
+            self.fill_rawq()
+            self.process_rawq()
+        return self.read_very_lazy()
 
     def read_eager(self):
-	"""Read readily available data.
+        """Read readily available data.
 
-	Raise EOFError if connection closed and no cooked data
-	available.  Return '' if no cooked data available otherwise.
-	Don't block unless in the midst of an IAC sequence.
+        Raise EOFError if connection closed and no cooked data
+        available.  Return '' if no cooked data available otherwise.
+        Don't block unless in the midst of an IAC sequence.
 
-	"""
-	self.process_rawq()
-	while not self.cookedq and not self.eof and self.sock_avail():
-	    self.fill_rawq()
-	    self.process_rawq()
-	return self.read_very_lazy()
+        """
+        self.process_rawq()
+        while not self.cookedq and not self.eof and self.sock_avail():
+            self.fill_rawq()
+            self.process_rawq()
+        return self.read_very_lazy()
 
     def read_lazy(self):
-	"""Process and return data that's already in the queues (lazy).
-	
-	Raise EOFError if connection closed and no data available.
-	Return '' if no cooked data available otherwise.  Don't block
-	unless in the midst of an IAC sequence.
+        """Process and return data that's already in the queues (lazy).
+        
+        Raise EOFError if connection closed and no data available.
+        Return '' if no cooked data available otherwise.  Don't block
+        unless in the midst of an IAC sequence.
 
-	"""
-	self.process_rawq()
-	return self.read_very_lazy()
+        """
+        self.process_rawq()
+        return self.read_very_lazy()
 
     def read_very_lazy(self):
-	"""Return any data available in the cooked queue (very lazy).
+        """Return any data available in the cooked queue (very lazy).
 
-	Raise EOFError if connection closed and no data available.
-	Return '' if no cooked data available otherwise.  Don't block.
+        Raise EOFError if connection closed and no data available.
+        Return '' if no cooked data available otherwise.  Don't block.
 
-	"""
-	buf = self.cookedq
-	self.cookedq = ''
-	if not buf and self.eof and not self.rawq:
-	    raise EOFError, 'telnet connection closed'
-	return buf
+        """
+        buf = self.cookedq
+        self.cookedq = ''
+        if not buf and self.eof and not self.rawq:
+            raise EOFError, 'telnet connection closed'
+        return buf
 
     def process_rawq(self):
-	"""Transfer from raw queue to cooked queue.
+        """Transfer from raw queue to cooked queue.
 
-	Set self.eof when connection is closed.  Don't block unless in
-	the midst of an IAC sequence.
+        Set self.eof when connection is closed.  Don't block unless in
+        the midst of an IAC sequence.
 
-	"""
-	buf = ''
-	try:
-	    while self.rawq:
-		c = self.rawq_getchar()
-		if c == theNULL:
-		    continue
-		if c == "\021":
-		    continue
-		if c != IAC:
-		    buf = buf + c
-		    continue
-		c = self.rawq_getchar()
-		if c == IAC:
-		    buf = buf + c
-		elif c in (DO, DONT):
-		    opt = self.rawq_getchar()
-		    self.msg('IAC %s %d', c == DO and 'DO' or 'DONT', ord(c))
-		    self.sock.send(IAC + WONT + opt)
-		elif c in (WILL, WONT):
-		    opt = self.rawq_getchar()
-		    self.msg('IAC %s %d',
-			     c == WILL and 'WILL' or 'WONT', ord(c))
-		else:
-		    self.msg('IAC %s not recognized' % `c`)
-	except EOFError: # raised by self.rawq_getchar()
-	    pass
-	self.cookedq = self.cookedq + buf
+        """
+        buf = ''
+        try:
+            while self.rawq:
+                c = self.rawq_getchar()
+                if c == theNULL:
+                    continue
+                if c == "\021":
+                    continue
+                if c != IAC:
+                    buf = buf + c
+                    continue
+                c = self.rawq_getchar()
+                if c == IAC:
+                    buf = buf + c
+                elif c in (DO, DONT):
+                    opt = self.rawq_getchar()
+                    self.msg('IAC %s %d', c == DO and 'DO' or 'DONT', ord(c))
+                    self.sock.send(IAC + WONT + opt)
+                elif c in (WILL, WONT):
+                    opt = self.rawq_getchar()
+                    self.msg('IAC %s %d',
+                             c == WILL and 'WILL' or 'WONT', ord(c))
+                else:
+                    self.msg('IAC %s not recognized' % `c`)
+        except EOFError: # raised by self.rawq_getchar()
+            pass
+        self.cookedq = self.cookedq + buf
 
     def rawq_getchar(self):
-	"""Get next char from raw queue.
+        """Get next char from raw queue.
 
-	Block if no data is immediately available.  Raise EOFError
-	when connection is closed.
+        Block if no data is immediately available.  Raise EOFError
+        when connection is closed.
 
-	"""
-	if not self.rawq:
-	    self.fill_rawq()
-	    if self.eof:
-		raise EOFError
-	c = self.rawq[self.irawq]
-	self.irawq = self.irawq + 1
-	if self.irawq >= len(self.rawq):
-	    self.rawq = ''
-	    self.irawq = 0
-	return c
+        """
+        if not self.rawq:
+            self.fill_rawq()
+            if self.eof:
+                raise EOFError
+        c = self.rawq[self.irawq]
+        self.irawq = self.irawq + 1
+        if self.irawq >= len(self.rawq):
+            self.rawq = ''
+            self.irawq = 0
+        return c
 
     def fill_rawq(self):
-	"""Fill raw queue from exactly one recv() system call.
+        """Fill raw queue from exactly one recv() system call.
 
-	Block if no data is immediately available.  Set self.eof when
-	connection is closed.
+        Block if no data is immediately available.  Set self.eof when
+        connection is closed.
 
-	"""
-	if self.irawq >= len(self.rawq):
-	    self.rawq = ''
-	    self.irawq = 0
-	# The buffer size should be fairly small so as to avoid quadratic
-	# behavior in process_rawq() above
-	buf = self.sock.recv(50)
-	self.eof = (not buf)
-	self.rawq = self.rawq + buf
+        """
+        if self.irawq >= len(self.rawq):
+            self.rawq = ''
+            self.irawq = 0
+        # The buffer size should be fairly small so as to avoid quadratic
+        # behavior in process_rawq() above
+        buf = self.sock.recv(50)
+        self.msg("recv %s", `buf`)
+        self.eof = (not buf)
+        self.rawq = self.rawq + buf
 
     def sock_avail(self):
-	"""Test whether data is available on the socket."""
-	return select.select([self], [], [], 0) == ([self], [], [])
+        """Test whether data is available on the socket."""
+        return select.select([self], [], [], 0) == ([self], [], [])
 
     def interact(self):
-	"""Interaction function, emulates a very dumb telnet client."""
-	while 1:
-	    rfd, wfd, xfd = select.select([self, sys.stdin], [], [])
-	    if self in rfd:
-		try:
-		    text = self.read_eager()
-		except EOFError:
-		    print '*** Connection closed by remote host ***'
-		    break
-		if text:
-		    sys.stdout.write(text)
-		    sys.stdout.flush()
-	    if sys.stdin in rfd:
-		line = sys.stdin.readline()
-		if not line:
-		    break
-		self.write(line)
+        """Interaction function, emulates a very dumb telnet client."""
+        while 1:
+            rfd, wfd, xfd = select.select([self, sys.stdin], [], [])
+            if self in rfd:
+                try:
+                    text = self.read_eager()
+                except EOFError:
+                    print '*** Connection closed by remote host ***'
+                    break
+                if text:
+                    sys.stdout.write(text)
+                    sys.stdout.flush()
+            if sys.stdin in rfd:
+                line = sys.stdin.readline()
+                if not line:
+                    break
+                self.write(line)
 
     def expect(self, list, timeout=None):
-	"""Read until one from a list of a regular expressions matches.
+        """Read until one from a list of a regular expressions matches.
 
-	The first argument is a list of regular expressions, either
-	compiled (re.RegexObject instances) or uncompiled (strings).
-	The optional second argument is a timeout, in seconds; default
-	is no timeout.
+        The first argument is a list of regular expressions, either
+        compiled (re.RegexObject instances) or uncompiled (strings).
+        The optional second argument is a timeout, in seconds; default
+        is no timeout.
 
-	Return a tuple of three items: the index in the list of the
-	first regular expression that matches; the match object
-	returned; and the text read up till and including the match.
+        Return a tuple of three items: the index in the list of the
+        first regular expression that matches; the match object
+        returned; and the text read up till and including the match.
 
-	If EOF is read and no text was read, raise EOFError.
-	Otherwise, when nothing matches, return (-1, None, text) where
-	text is the text received so far (may be the empty string if a
-	timeout happened).
+        If EOF is read and no text was read, raise EOFError.
+        Otherwise, when nothing matches, return (-1, None, text) where
+        text is the text received so far (may be the empty string if a
+        timeout happened).
 
-	If a regular expression ends with a greedy match (e.g. '.*')
-	or if more than one expression can match the same input, the
-	results are undeterministic, and may depend on the I/O timing.
+        If a regular expression ends with a greedy match (e.g. '.*')
+        or if more than one expression can match the same input, the
+        results are undeterministic, and may depend on the I/O timing.
 
-	"""
-	re = None
-	list = list[:]
-	indices = range(len(list))
-	for i in indices:
-	    if not hasattr(list[i], "search"):
-		if not re: import re
-		list[i] = re.compile(list[i])
-	while 1:
-	    self.process_rawq()
-	    for i in indices:
-		m = list[i].search(self.cookedq)
-		if m:
-		    e = m.end()
-		    text = self.cookedq[:e]
-		    self.cookedq = self.cookedq[e:]
-		    return (i, m, text)
-	    if self.eof:
-		break
-	    if timeout is not None:
-		r, w, x = select.select([self.fileno()], [], [], timeout)
-		if not r:
-		    break
-	    self.fill_rawq()
-	text = self.read_very_lazy()
-	if not text and self.eof:
-	    raise EOFError
-	return (-1, None, text)
+        """
+        re = None
+        list = list[:]
+        indices = range(len(list))
+        for i in indices:
+            if not hasattr(list[i], "search"):
+                if not re: import re
+                list[i] = re.compile(list[i])
+        while 1:
+            self.process_rawq()
+            for i in indices:
+                m = list[i].search(self.cookedq)
+                if m:
+                    e = m.end()
+                    text = self.cookedq[:e]
+                    self.cookedq = self.cookedq[e:]
+                    return (i, m, text)
+            if self.eof:
+                break
+            if timeout is not None:
+                r, w, x = select.select([self.fileno()], [], [], timeout)
+                if not r:
+                    break
+            self.fill_rawq()
+        text = self.read_very_lazy()
+        if not text and self.eof:
+            raise EOFError
+        return (-1, None, text)
 
 
 def test():
@@ -452,18 +454,18 @@
     """
     debuglevel = 0
     while sys.argv[1:] and sys.argv[1] == '-d':
-	debuglevel = debuglevel+1
-	del sys.argv[1]
+        debuglevel = debuglevel+1
+        del sys.argv[1]
     host = 'localhost'
     if sys.argv[1:]:
-	host = sys.argv[1]
+        host = sys.argv[1]
     port = 0
     if sys.argv[2:]:
-	portstr = sys.argv[2]
-	try:
-	    port = int(portstr)
-	except ValueError:
-	    port = socket.getservbyname(portstr, 'tcp')
+        portstr = sys.argv[2]
+        try:
+            port = int(portstr)
+        except ValueError:
+            port = socket.getservbyname(portstr, 'tcp')
     tn = Telnet()
     tn.set_debuglevel(debuglevel)
     tn.open(host, port)
diff --git a/Lib/dos-8x3/test_arr.py b/Lib/dos-8x3/test_arr.py
index e95fac4..6a0d17c 100644
--- a/Lib/dos-8x3/test_arr.py
+++ b/Lib/dos-8x3/test_arr.py
@@ -10,50 +10,50 @@
     testtype('c', 'c')
 
     for type in (['b', 'h', 'i', 'l', 'f', 'd']):
-	testtype(type, 1)
+        testtype(type, 1)
 
     unlink(TESTFN)
 
 
 def testtype(type, example):
 
-	a = array.array(type)
-	a.append(example)
-	if verbose:
-	    print 40*'*'
-	    print 'array after append: ', a
-	a.typecode
-	a.itemsize
-	if a.typecode in ('i', 'b', 'h', 'l'):
-	    a.byteswap()
+        a = array.array(type)
+        a.append(example)
+        if verbose:
+            print 40*'*'
+            print 'array after append: ', a
+        a.typecode
+        a.itemsize
+        if a.typecode in ('i', 'b', 'h', 'l'):
+            a.byteswap()
 
-	if a.typecode == 'c':
-	    f = open(TESTFN, "w")
-	    f.write("The quick brown fox jumps over the lazy dog.\n")
-	    f.close()
-	    f = open(TESTFN, 'r')
-	    a.fromfile(f, 10)
-	    f.close()
-	    if verbose:
-		print 'char array with 10 bytes of TESTFN appended: ', a
-	    a.fromlist(['a', 'b', 'c'])
-	    if verbose:
-		print 'char array with list appended: ', a
+        if a.typecode == 'c':
+            f = open(TESTFN, "w")
+            f.write("The quick brown fox jumps over the lazy dog.\n")
+            f.close()
+            f = open(TESTFN, 'r')
+            a.fromfile(f, 10)
+            f.close()
+            if verbose:
+                print 'char array with 10 bytes of TESTFN appended: ', a
+            a.fromlist(['a', 'b', 'c'])
+            if verbose:
+                print 'char array with list appended: ', a
 
-	a.insert(0, example)
-	if verbose:
-	    print 'array of %s after inserting another:' % a.typecode, a
-	f = open(TESTFN, 'w')
-	a.tofile(f)
-	f.close()
-	a.tolist()
-	a.tostring()
-	if verbose:
-	    print 'array of %s converted to a list: ' % a.typecode, a.tolist()
-	if verbose:
-	    print 'array of %s converted to a string: ' \
-	           % a.typecode, `a.tostring()`
+        a.insert(0, example)
+        if verbose:
+            print 'array of %s after inserting another:' % a.typecode, a
+        f = open(TESTFN, 'w')
+        a.tofile(f)
+        f.close()
+        a.tolist()
+        a.tostring()
+        if verbose:
+            print 'array of %s converted to a list: ' % a.typecode, a.tolist()
+        if verbose:
+            print 'array of %s converted to a string: ' \
+                   % a.typecode, `a.tostring()`
 
 
 main()
-	
+        
diff --git a/Lib/dos-8x3/test_aud.py b/Lib/dos-8x3/test_aud.py
index a03fe60..900ec58 100755
--- a/Lib/dos-8x3/test_aud.py
+++ b/Lib/dos-8x3/test_aud.py
@@ -7,166 +7,166 @@
 
 def gendata2():
     if verbose:
-	print 'getsample'
+        print 'getsample'
     if audioop.getsample('\0\1', 2, 0) == 1:
-	return '\0\0\0\1\0\2'
+        return '\0\0\0\1\0\2'
     else:
-	return '\0\0\1\0\2\0'
+        return '\0\0\1\0\2\0'
 
 def gendata4():
     if verbose:
-	print 'getsample'
+        print 'getsample'
     if audioop.getsample('\0\0\0\1', 4, 0) == 1:
-	return '\0\0\0\0\0\0\0\1\0\0\0\2'
+        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'
+        return '\0\0\0\0\1\0\0\0\2\0\0\0'
 
 def testmax(data):
     if verbose:
-	print 'max'
+        print 'max'
     if audioop.max(data[0], 1) <> 2 or \
-	      audioop.max(data[1], 2) <> 2 or \
-	      audioop.max(data[2], 4) <> 2:
-	return 0
+              audioop.max(data[1], 2) <> 2 or \
+              audioop.max(data[2], 4) <> 2:
+        return 0
     return 1
 
 def testminmax(data):
     if verbose:
-	print 'minmax'
+        print 'minmax'
     if audioop.minmax(data[0], 1) <> (0, 2) or \
-	      audioop.minmax(data[1], 2) <> (0, 2) or \
-	      audioop.minmax(data[2], 4) <> (0, 2):
-	return 0
+              audioop.minmax(data[1], 2) <> (0, 2) or \
+              audioop.minmax(data[2], 4) <> (0, 2):
+        return 0
     return 1
 
 def testmaxpp(data):
     if verbose:
-	print 'maxpp'
+        print 'maxpp'
     if audioop.maxpp(data[0], 1) <> 0 or \
-	      audioop.maxpp(data[1], 2) <> 0 or \
-	      audioop.maxpp(data[2], 4) <> 0:
-	return 0
+              audioop.maxpp(data[1], 2) <> 0 or \
+              audioop.maxpp(data[2], 4) <> 0:
+        return 0
     return 1
 
 def testavg(data):
     if verbose:
-	print 'avg'
+        print 'avg'
     if audioop.avg(data[0], 1) <> 1 or \
-	      audioop.avg(data[1], 2) <> 1 or \
-	      audioop.avg(data[2], 4) <> 1:
-	return 0
+              audioop.avg(data[1], 2) <> 1 or \
+              audioop.avg(data[2], 4) <> 1:
+        return 0
     return 1
 
 def testavgpp(data):
     if verbose:
-	print 'avgpp'
+        print 'avgpp'
     if audioop.avgpp(data[0], 1) <> 0 or \
-	      audioop.avgpp(data[1], 2) <> 0 or \
-	      audioop.avgpp(data[2], 4) <> 0:
-	return 0
+              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
+              audioop.rms(data[1], 2) <> 1 or \
+              audioop.rms(data[2], 4) <> 1:
+        return 0
     return 1
 
 def testcross(data):
     if verbose:
-	print 'cross'
+        print 'cross'
     if audioop.cross(data[0], 1) <> 0 or \
-	      audioop.cross(data[1], 2) <> 0 or \
-	      audioop.cross(data[2], 4) <> 0:
-	return 0
+              audioop.cross(data[1], 2) <> 0 or \
+              audioop.cross(data[2], 4) <> 0:
+        return 0
     return 1
 
 def testadd(data):
     if verbose:
-	print 'add'
+        print 'add'
     data2 = []
     for d in data:
-	str = ''
-	for s in d:
-	    str = str + chr(ord(s)*2)
-	data2.append(str)
+        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
+              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):
     if verbose:
-	print 'bias'
+        print 'bias'
     # 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
+              audioop.avg(d2, 2) <> 101 or \
+              audioop.avg(d4, 4) <> 101:
+        return 0
     return 1
 
 def testlin2lin(data):
     if verbose:
-	print 'lin2lin'
+        print 'lin2lin'
     # 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
+        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 0
     return 1
 
 def testlin2adpcm(data):
     if verbose:
-	print 'lin2adpcm'
+        print 'lin2adpcm'
     # Very cursory test
     if audioop.lin2adpcm('\0\0\0\0', 1, None) <> ('\0\0', (0,0)):
-	return 0
+        return 0
     return 1
 
 def testlin2ulaw(data):
     if verbose:
-	print 'lin2ulaw'
+        print 'lin2ulaw'
     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
+              audioop.lin2ulaw(data[1], 2) <> '\377\377\377' or \
+              audioop.lin2ulaw(data[2], 4) <> '\377\377\377':
+        return 0
     return 1
 
 def testulaw2lin(data):
     if verbose:
-	print 'ulaw2lin'
+        print 'ulaw2lin'
     # Cursory
     d = audioop.lin2ulaw(data[0], 1)
     if audioop.ulaw2lin(d, 1) <> data[0]:
-	return 0
+        return 0
     return 1
 
 def testmul(data):
     if verbose:
-	print 'mul'
+        print 'mul'
     data2 = []
     for d in data:
-	str = ''
-	for s in d:
-	    str = str + chr(ord(s)*2)
-	data2.append(str)
+        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
+              audioop.mul(data[1],2, 2) <> data2[1] or \
+              audioop.mul(data[2], 4, 2) <> data2[2]:
+        return 0
     return 1
 
 def testratecv(data):
@@ -181,75 +181,75 @@
 
 def testreverse(data):
     if verbose:
-	print 'reverse'
+        print 'reverse'
     if audioop.reverse(data[0], 1) <> '\2\1\0':
-	return 0
+        return 0
     return 1
 
 def testtomono(data):
     if verbose:
-	print 'tomono'
+        print 'tomono'
     data2 = ''
     for d in data[0]:
-	data2 = data2 + d + d
+        data2 = data2 + d + d
     if audioop.tomono(data2, 1, 0.5, 0.5) <> data[0]:
-	return 0
+        return 0
     return 1
 
 def testtostereo(data):
     if verbose:
-	print 'tostereo'
+        print 'tostereo'
     data2 = ''
     for d in data[0]:
-	data2 = data2 + d + d
+        data2 = data2 + d + d
     if audioop.tostereo(data[0], 1, 1, 1) <> data2:
-	return 0
+        return 0
     return 1
 
 def testfindfactor(data):
     if verbose:
-	print 'findfactor'
+        print 'findfactor'
     if audioop.findfactor(data[1], data[1]) <> 1.0:
-	return 0
+        return 0
     return 1
 
 def testfindfit(data):
     if verbose:
-	print 'findfit'
+        print 'findfit'
     if audioop.findfit(data[1], data[1]) <> (0, 1.0):
-	return 0
+        return 0
     return 1
 
 def testfindmax(data):
     if verbose:
-	print 'findmax'
+        print 'findmax'
     if audioop.findmax(data[1], 1) <> 2:
-	return 0
+        return 0
     return 1
 
 def testgetsample(data):
     if verbose:
-	print 'getsample'
+        print 'getsample'
     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
+        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)
+        func = eval('test'+name)
     except NameError:
-	print 'No test found for audioop.'+name+'()'
-	return
+        print 'No test found for audioop.'+name+'()'
+        return
     try:
-	rv = func(data)
+        rv = func(data)
     except 'xx':
-	print 'Test FAILED for audioop.'+name+'() (with an exception)'
-	return
+        print 'Test FAILED for audioop.'+name+'() (with an exception)'
+        return
     if not rv:
-	print 'Test FAILED for audioop.'+name+'()'
+        print 'Test FAILED for audioop.'+name+'()'
 
 def testall():
     data = [gendata1(), gendata2(), gendata4()]
@@ -257,8 +257,8 @@
     # We know there is a routine 'add'
     routines = []
     for n in names:
-	if type(eval('audioop.'+n)) == type(audioop.add):
-	    routines.append(n)
+        if type(eval('audioop.'+n)) == type(audioop.add):
+            routines.append(n)
     for n in routines:
-	testone(n, data)
+        testone(n, data)
 testall()
diff --git a/Lib/dos-8x3/test_bin.py b/Lib/dos-8x3/test_bin.py
index aa156d9..fe3843d 100644
--- a/Lib/dos-8x3/test_bin.py
+++ b/Lib/dos-8x3/test_bin.py
@@ -11,11 +11,11 @@
 def test():
 
     try:
-	fname1 = tempfile.mktemp()
-	fname2 = tempfile.mktemp()
-	f = open(fname1, 'w')
+        fname1 = tempfile.mktemp()
+        fname2 = tempfile.mktemp()
+        f = open(fname1, 'w')
     except:
-	raise ImportError, "Cannot test binascii without a temp file"
+        raise ImportError, "Cannot test binascii without a temp file"
 
     start = 'Jack is my hero'
     f.write(start)
@@ -23,24 +23,24 @@
     
     binhex.binhex(fname1, fname2)
     if verbose:
-	print 'binhex'
+        print 'binhex'
 
     binhex.hexbin(fname2, fname1)
     if verbose:
-	print 'hexbin'
+        print 'hexbin'
 
     f = open(fname1, 'r')
     finish = f.readline()
 
     if start <> finish:
-	print 'Error: binhex <> hexbin'
+        print 'Error: binhex <> hexbin'
     elif verbose:
-	print 'binhex == hexbin'
+        print 'binhex == hexbin'
 
     try:
-	import os
-	os.unlink(fname1)
-	os.unlink(fname2)
+        import os
+        os.unlink(fname1)
+        os.unlink(fname2)
     except:
-	pass
+        pass
 test()
diff --git a/Lib/dos-8x3/test_bsd.py b/Lib/dos-8x3/test_bsd.py
index 7a95eb9..1188e06 100644
--- a/Lib/dos-8x3/test_bsd.py
+++ b/Lib/dos-8x3/test_bsd.py
@@ -9,12 +9,12 @@
 def test(openmethod, what):
 
     if verbose:
-	print '\nTesting: ', what
-	
+        print '\nTesting: ', what
+        
     fname = tempfile.mktemp()
     f = openmethod(fname, 'c')
     if verbose:
-	print 'creation...'
+        print 'creation...'
     f['0'] = ''
     f['a'] = 'Guido'
     f['b'] = 'van'
@@ -22,47 +22,47 @@
     f['d'] = 'invented'
     f['f'] = 'Python'
     if verbose:
-	print '%s %s %s' % (f['a'], f['b'], f['c'])
+        print '%s %s %s' % (f['a'], f['b'], f['c'])
 
     if what == 'BTree' :
-	if verbose:
-	    print 'key ordering...'
-	f.set_location(f.first()[0])
-	while 1:
-	    try:
-		rec = f.next()
-	    except KeyError:
-		if rec <> f.last():
-		    print 'Error, last <> last!'
-		f.previous()
-		break
-	    if verbose:
-		print rec
-	if not f.has_key('a'):
-	    print 'Error, missing key!'
+        if verbose:
+            print 'key ordering...'
+        f.set_location(f.first()[0])
+        while 1:
+            try:
+                rec = f.next()
+            except KeyError:
+                if rec <> f.last():
+                    print 'Error, last <> last!'
+                f.previous()
+                break
+            if verbose:
+                print rec
+        if not f.has_key('a'):
+            print 'Error, missing key!'
 
     f.sync()
     f.close()
     if verbose:
-	print 'modification...'
+        print 'modification...'
     f = openmethod(fname, 'w')
     f['d'] = 'discovered'
 
     if verbose:
-	print 'access...'
+        print 'access...'
     for key in f.keys():
-	word = f[key]
-	if verbose:
-	    print word
+        word = f[key]
+        if verbose:
+            print word
 
     f.close()
 
 types = [(bsddb.btopen, 'BTree'),
-	 (bsddb.hashopen, 'Hash Table'),
-	 # (bsddb.rnopen,'Record Numbers'), 'put' for RECNO for bsddb 1.85
+         (bsddb.hashopen, 'Hash Table'),
+         # (bsddb.rnopen,'Record Numbers'), 'put' for RECNO for bsddb 1.85
          #                                   appears broken... at least on
-	 #                                   Solaris Intel - rmasse 1/97
-	 ]
+         #                                   Solaris Intel - rmasse 1/97
+         ]
 
 for type in types:
     test(type[0], type[1])
diff --git a/Lib/dos-8x3/test_cma.py b/Lib/dos-8x3/test_cma.py
index 71e7729..509c739 100644
--- a/Lib/dos-8x3/test_cma.py
+++ b/Lib/dos-8x3/test_cma.py
@@ -6,27 +6,27 @@
 from test_support import verbose
 
 testdict = {'acos' : 1.0,
-	    'acosh' : 1.0,
-	    'asin' : 1.0,
-	    'asinh' : 1.0,
-	    'atan' : 0.2,
-	    'atanh' : 0.2,
-	    'cos' : 1.0,
-	    'cosh' : 1.0,
-	    'exp' : 1.0,
-	    'log' : 1.0,
-	    'log10' : 1.0,
-	    'sin' : 1.0,
-	    'sinh' : 1.0,
-	    'sqrt' : 1.0,
-	    'tan' : 1.0,
-	    'tanh' : 1.0}
+            'acosh' : 1.0,
+            'asin' : 1.0,
+            'asinh' : 1.0,
+            'atan' : 0.2,
+            'atanh' : 0.2,
+            'cos' : 1.0,
+            'cosh' : 1.0,
+            'exp' : 1.0,
+            'log' : 1.0,
+            'log10' : 1.0,
+            'sin' : 1.0,
+            'sinh' : 1.0,
+            'sqrt' : 1.0,
+            'tan' : 1.0,
+            'tanh' : 1.0}
 
 for func in testdict.keys():
     f = getattr(cmath, func)
     r = f(testdict[func])
     if verbose:
-	print 'Calling %s(%f) = %f' % (func, testdict[func], abs(r))
+        print 'Calling %s(%f) = %f' % (func, testdict[func], abs(r))
 
 p = cmath.pi
 e = cmath.e
diff --git a/Lib/dos-8x3/test_err.py b/Lib/dos-8x3/test_err.py
index 7228fdf..cb1e729 100644
--- a/Lib/dos-8x3/test_err.py
+++ b/Lib/dos-8x3/test_err.py
@@ -7,31 +7,31 @@
 from test_support import verbose
 
 errors = ['E2BIG', 'EACCES', 'EADDRINUSE', 'EADDRNOTAVAIL', 'EADV',
-	  'EAFNOSUPPORT', 'EAGAIN', 'EALREADY', 'EBADE', 'EBADF',
-	  'EBADFD', 'EBADMSG', 'EBADR', 'EBADRQC', 'EBADSLT',
-	  'EBFONT', 'EBUSY', 'ECHILD', 'ECHRNG', 'ECOMM',
-	  'ECONNABORTED', 'ECONNREFUSED', 'ECONNRESET',
-	  'EDEADLK', 'EDEADLOCK', 'EDESTADDRREQ', 'EDOM',
-	  'EDQUOT', 'EEXIST', 'EFAULT', 'EFBIG', 'EHOSTDOWN',
-	  'EHOSTUNREACH', 'EIDRM', 'EILSEQ', 'EINPROGRESS',
-	  'EINTR', 'EINVAL', 'EIO', 'EISCONN', 'EISDIR',
-	  'EL2HLT', 'EL2NSYNC', 'EL3HLT', 'EL3RST', 'ELIBACC',
-	  'ELIBBAD', 'ELIBEXEC', 'ELIBMAX', 'ELIBSCN', 'ELNRNG',
-	  'ELOOP', 'EMFILE', 'EMLINK', 'EMSGSIZE', 'EMULTIHOP',
-	  'ENAMETOOLONG', 'ENETDOWN', 'ENETRESET', 'ENETUNREACH',
-	  'ENFILE', 'ENOANO', 'ENOBUFS', 'ENOCSI', 'ENODATA',
-	  'ENODEV', 'ENOENT', 'ENOEXEC', 'ENOLCK', 'ENOLINK',
-	  'ENOMEM', 'ENOMSG', 'ENONET', 'ENOPKG', 'ENOPROTOOPT',
-	  'ENOSPC', 'ENOSR', 'ENOSTR', 'ENOSYS', 'ENOTBLK',
-	  'ENOTCONN', 'ENOTDIR', 'ENOTEMPTY', 'ENOTOBACCO', 'ENOTSOCK',
-	  'ENOTTY', 'ENOTUNIQ', 'ENXIO', 'EOPNOTSUPP',
-	  'EOVERFLOW', 'EPERM', 'EPFNOSUPPORT', 'EPIPE',
-	  'EPROTO', 'EPROTONOSUPPORT', 'EPROTOTYPE',
-	  'ERANGE', 'EREMCHG', 'EREMOTE', 'ERESTART',
-	  'EROFS', 'ESHUTDOWN', 'ESOCKTNOSUPPORT', 'ESPIPE',
-	  'ESRCH', 'ESRMNT', 'ESTALE', 'ESTRPIPE', 'ETIME',
-	  'ETIMEDOUT', 'ETOOMANYREFS', 'ETXTBSY', 'EUNATCH',
-	  'EUSERS', 'EWOULDBLOCK', 'EXDEV', 'EXFULL']
+          'EAFNOSUPPORT', 'EAGAIN', 'EALREADY', 'EBADE', 'EBADF',
+          'EBADFD', 'EBADMSG', 'EBADR', 'EBADRQC', 'EBADSLT',
+          'EBFONT', 'EBUSY', 'ECHILD', 'ECHRNG', 'ECOMM',
+          'ECONNABORTED', 'ECONNREFUSED', 'ECONNRESET',
+          'EDEADLK', 'EDEADLOCK', 'EDESTADDRREQ', 'EDOM',
+          'EDQUOT', 'EEXIST', 'EFAULT', 'EFBIG', 'EHOSTDOWN',
+          'EHOSTUNREACH', 'EIDRM', 'EILSEQ', 'EINPROGRESS',
+          'EINTR', 'EINVAL', 'EIO', 'EISCONN', 'EISDIR',
+          'EL2HLT', 'EL2NSYNC', 'EL3HLT', 'EL3RST', 'ELIBACC',
+          'ELIBBAD', 'ELIBEXEC', 'ELIBMAX', 'ELIBSCN', 'ELNRNG',
+          'ELOOP', 'EMFILE', 'EMLINK', 'EMSGSIZE', 'EMULTIHOP',
+          'ENAMETOOLONG', 'ENETDOWN', 'ENETRESET', 'ENETUNREACH',
+          'ENFILE', 'ENOANO', 'ENOBUFS', 'ENOCSI', 'ENODATA',
+          'ENODEV', 'ENOENT', 'ENOEXEC', 'ENOLCK', 'ENOLINK',
+          'ENOMEM', 'ENOMSG', 'ENONET', 'ENOPKG', 'ENOPROTOOPT',
+          'ENOSPC', 'ENOSR', 'ENOSTR', 'ENOSYS', 'ENOTBLK',
+          'ENOTCONN', 'ENOTDIR', 'ENOTEMPTY', 'ENOTOBACCO', 'ENOTSOCK',
+          'ENOTTY', 'ENOTUNIQ', 'ENXIO', 'EOPNOTSUPP',
+          'EOVERFLOW', 'EPERM', 'EPFNOSUPPORT', 'EPIPE',
+          'EPROTO', 'EPROTONOSUPPORT', 'EPROTOTYPE',
+          'ERANGE', 'EREMCHG', 'EREMOTE', 'ERESTART',
+          'EROFS', 'ESHUTDOWN', 'ESOCKTNOSUPPORT', 'ESPIPE',
+          'ESRCH', 'ESRMNT', 'ESTALE', 'ESTRPIPE', 'ETIME',
+          'ETIMEDOUT', 'ETOOMANYREFS', 'ETXTBSY', 'EUNATCH',
+          'EUSERS', 'EWOULDBLOCK', 'EXDEV', 'EXFULL']
 
 #
 # This is is a wee bit bogus since the module only conditionally adds
@@ -40,10 +40,10 @@
 #
 for error in errors:
     try:
-	a = getattr(errno, error)
+        a = getattr(errno, error)
     except AttributeError:
-	if verbose:
-	    print '%s: not found' % error
+        if verbose:
+            print '%s: not found' % error
     else:
-	if verbose:
-	    print '%s: %d' % (error, a)
+        if verbose:
+            print '%s: %d' % (error, a)
diff --git a/Lib/dos-8x3/test_exc.py b/Lib/dos-8x3/test_exc.py
index dbcdbe8..9796ef4 100755
--- a/Lib/dos-8x3/test_exc.py
+++ b/Lib/dos-8x3/test_exc.py
@@ -8,9 +8,9 @@
 
 def r(thing):
     if type(thing) == ClassType:
-	print thing.__name__
+        print thing.__name__
     else:
-	print thing
+        print thing
 
 r(AttributeError)
 import sys
@@ -24,14 +24,14 @@
 fp = open(TESTFN, 'r')
 savestdin = sys.stdin
 try:
-	try:
-		sys.stdin = fp
-		x = raw_input()
-	except EOFError:
-		pass
+        try:
+                sys.stdin = fp
+                x = raw_input()
+        except EOFError:
+                pass
 finally:
-	sys.stdin = savestdin
-	fp.close()
+        sys.stdin = savestdin
+        fp.close()
 
 r(IOError)
 try: open('this file does not exist', 'r')
@@ -64,7 +64,7 @@
 r(OverflowError)
 x = 1
 try:
-	while 1: x = x+x
+        while 1: x = x+x
 except OverflowError: pass
 
 r(RuntimeError)
diff --git a/Lib/dos-8x3/test_ima.py b/Lib/dos-8x3/test_ima.py
index 89b111c..63ab138 100644
--- a/Lib/dos-8x3/test_ima.py
+++ b/Lib/dos-8x3/test_ima.py
@@ -15,14 +15,14 @@
     uu.decode(get_qualified_path('testrgb.uue'), 'test.rgb')
 
     if use_rgbimg:
-	image, width, height = getrgbimage('test.rgb')
+        image, width, height = getrgbimage('test.rgb')
     else:
-	image, width, height = getimage('test.rgb')
-	
+        image, width, height = getimage('test.rgb')
+        
     # Return the selected part of image, which should by width by height
     # in size and consist of pixels of psize bytes.
     if verbose:
-	print 'crop'
+        print 'crop'
     newimage = imageop.crop (image, 4, width, height, 0, 0, 1, 1)
 
     # Return image scaled to size newwidth by newheight. No interpolation
@@ -30,7 +30,7 @@
     # Therefore, computer-generated images or dithered images will
     # not look nice after scaling. 
     if verbose:
-	print 'scale'
+        print 'scale'
     scaleimage = imageop.scale(image, 4, width, height, 1, 1)
 
     # Run a vertical low-pass filter over an image. It does so by computing
@@ -38,34 +38,34 @@
     # pixels. The main use of this routine is to forestall excessive flicker
     # if the image two vertically-aligned source pixels,  hence the name. 
     if verbose:
-	print 'tovideo'
+        print 'tovideo'
     videoimage = imageop.tovideo (image, 4, width, height)
 
     # Convert an rgb image to an 8 bit rgb
     if verbose:
-	print 'rgb2rgb8'
+        print 'rgb2rgb8'
     greyimage = imageop.rgb2rgb8(image, width, height)
 
     # Convert an 8 bit rgb image to a 24 bit rgb image
     if verbose:
-	print 'rgb82rgb'
+        print 'rgb82rgb'
     image = imageop.rgb82rgb(greyimage, width, height)
     
     # Convert an rgb image to an 8 bit greyscale image
     if verbose:
-	print 'rgb2grey'
+        print 'rgb2grey'
     greyimage = imageop.rgb2grey(image, width, height)
 
     # Convert an 8 bit greyscale image to a 24 bit rgb image
     if verbose:
-	print 'grey2rgb'
+        print 'grey2rgb'
     image = imageop.grey2rgb(greyimage, width, height)
     
     # Convert a 8-bit deep greyscale image to a 1-bit deep image by
     # tresholding all the pixels. The resulting image is tightly packed
     # and is probably only useful as an argument to mono2grey. 
     if verbose:
-	print 'grey2mono'
+        print 'grey2mono'
     monoimage = imageop.grey2mono (greyimage, width, height, 0) 
 
     # monoimage, width, height = getimage('monotest.rgb')
@@ -75,42 +75,42 @@
     # monochrome  black-and-white image to greyscale pass the values 0 and
     # 255 respectively.
     if verbose:
-	print 'mono2grey'
+        print 'mono2grey'
     greyimage = imageop.mono2grey (monoimage, width, height, 0, 255)
 
     # Convert an 8-bit greyscale image to a 1-bit monochrome image using a
     # (simple-minded) dithering algorithm.
     if verbose:
-	print 'dither2mono'
+        print 'dither2mono'
     monoimage = imageop.dither2mono (greyimage, width, height)
 
     # Convert an 8-bit greyscale image to a 4-bit greyscale image without
     # dithering. 
     if verbose:
-	print 'grey2grey4'
+        print 'grey2grey4'
     grey4image = imageop.grey2grey4 (greyimage, width, height) 
 
     # Convert an 8-bit greyscale image to a 2-bit greyscale image without
     # dithering. 
     if verbose:
-	print 'grey2grey2'
+        print 'grey2grey2'
     grey2image = imageop.grey2grey2 (greyimage, width, height) 
 
     # Convert an 8-bit greyscale image to a 2-bit greyscale image with
     # dithering. As for dither2mono, the dithering algorithm is currently
     # very simple. 
     if verbose:
-	print 'dither2grey2'
+        print 'dither2grey2'
     grey2image = imageop.dither2grey2 (greyimage, width, height) 
 
     # Convert a 4-bit greyscale image to an 8-bit greyscale image. 
     if verbose:
-	print 'grey42grey'
+        print 'grey42grey'
     greyimage = imageop.grey42grey (grey4image, width, height) 
 
     # Convert a 2-bit greyscale image to an 8-bit greyscale image. 
     if verbose:
-	print 'grey22grey'
+        print 'grey22grey'
     image = imageop.grey22grey (grey2image, width, height)
 
     # Cleanup
@@ -123,12 +123,12 @@
     import rgbimg
 
     try:
-	sizes = rgbimg.sizeofimage(name)
+        sizes = rgbimg.sizeofimage(name)
     except rgbimg.error:
-	name = get_qualified_path(name)
-	sizes = rgbimg.sizeofimage(name)
+        name = get_qualified_path(name)
+        sizes = rgbimg.sizeofimage(name)
     if verbose:
-	print 'rgbimg opening test image: %s, sizes: %s' % (name, str(sizes))
+        print 'rgbimg opening test image: %s, sizes: %s' % (name, str(sizes))
 
     image = rgbimg.longimagedata(name)
     return (image, sizes[0], sizes[1])
@@ -141,12 +141,12 @@
     import imgfile
   
     try:
-	sizes = imgfile.getsizes(name)
+        sizes = imgfile.getsizes(name)
     except imgfile.error:
-	name = get_qualified_path(name)
-	sizes = imgfile.getsizes(name)
+        name = get_qualified_path(name)
+        sizes = imgfile.getsizes(name)
     if verbose:
-	print 'imgfile opening test image: %s, sizes: %s' % (name, str(sizes))
+        print 'imgfile opening test image: %s, sizes: %s' % (name, str(sizes))
 
     image = imgfile.read(name)
     return (image, sizes[0], sizes[1])
@@ -157,13 +157,13 @@
     import os
     path = sys.path
     try:
-	path = [os.path.dirname(__file__)] + path
+        path = [os.path.dirname(__file__)] + path
     except NameError:
-	pass
+        pass
     for dir in path:
-	fullname = os.path.join(dir, name)
-	if os.path.exists(fullname):
-	    return fullname
+        fullname = os.path.join(dir, name)
+        if os.path.exists(fullname):
+            return fullname
     return name
 
 # rgbimg (unlike imgfile) is portable to platforms other than SGI.
diff --git a/Lib/dos-8x3/test_img.py b/Lib/dos-8x3/test_img.py
index 576a51c..aa9c414 100644
--- a/Lib/dos-8x3/test_img.py
+++ b/Lib/dos-8x3/test_img.py
@@ -24,12 +24,12 @@
     unlink('greytest.rgb')
 
 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
+        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 testimage(name):
     """Run through the imgfile's battery of possible methods
@@ -44,23 +44,23 @@
 
     # try opening the name directly
     try:
-	# This function returns a tuple (x, y, z) where x and y are the size
-	# of the image in pixels and z is the number of bytes per pixel. Only
-	# 3 byte RGB pixels and 1 byte greyscale pixels are supported.
-	sizes = imgfile.getsizes(name)
+        # This function returns a tuple (x, y, z) where x and y are the size
+        # of the image in pixels and z is the number of bytes per pixel. Only
+        # 3 byte RGB pixels and 1 byte greyscale pixels are supported.
+        sizes = imgfile.getsizes(name)
     except imgfile.error:
-	# get a more qualified path component of the script...
-	if __name__ == '__main__':
-	    ourname = sys.argv[0]
-	else: # ...or the full path of the module
-	    ourname = sys.modules[__name__].__file__
+        # get a more qualified path component of the script...
+        if __name__ == '__main__':
+            ourname = sys.argv[0]
+        else: # ...or the full path of the module
+            ourname = sys.modules[__name__].__file__
 
-	parts = string.splitfields(ourname, os.sep)
-	parts[-1] = name
-	name = string.joinfields(parts, os.sep)
-	sizes = imgfile.getsizes(name)
+        parts = string.splitfields(ourname, os.sep)
+        parts[-1] = name
+        name = string.joinfields(parts, os.sep)
+        sizes = imgfile.getsizes(name)
     if verbose:
-	print 'Opening test image: %s, sizes: %s' % (name, str(sizes))
+        print 'Opening test image: %s, sizes: %s' % (name, str(sizes))
     # This function reads and decodes the image on the specified file,
     # and returns it as a python string. The string has either 1 byte
     # greyscale pixels or 4 byte RGBA pixels. The bottom left pixel
@@ -74,12 +74,12 @@
     # are stored as 4 byte values of which only the lower three
     # bytes are used). These are the formats returned by gl.lrectread. 
     if verbose:
-	print 'Writing output file'
+        print 'Writing output file'
     imgfile.write (outputfile, image, sizes[0], sizes[1], sizes[2]) 
    
 
     if verbose:
-	print 'Opening scaled test image: %s, sizes: %s' % (name, str(sizes))
+        print 'Opening scaled test image: %s, sizes: %s' % (name, str(sizes))
     # This function is identical to read but it returns an image that
     # is scaled to the given x and y sizes. If the filter and blur
     # parameters are omitted scaling is done by simply dropping
@@ -93,7 +93,7 @@
     # makes no attempt to keep the aspect ratio correct, so that
     # is the users' responsibility.
     if verbose:
-	print 'Filtering with "impulse"'
+        print 'Filtering with "impulse"'
     simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'impulse', 2.0)
 
     # This function sets a global flag which defines whether the
@@ -101,14 +101,14 @@
     # top (flag is zero, compatible with SGI GL) or from top to
     # bottom(flag is one, compatible with X). The default is zero. 
     if verbose:
-	print 'Switching to X compatibility'
+        print 'Switching to X compatibility'
     imgfile.ttob (1) 
 
     if verbose:
-	print 'Filtering with "triangle"'
+        print 'Filtering with "triangle"'
     simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'triangle', 3.0)
     if verbose:
-	print 'Switching back to SGI compatibility'
+        print 'Switching back to SGI compatibility'
     imgfile.ttob (0) 
     
     if verbose: print 'Filtering with "quadratic"'
@@ -117,7 +117,7 @@
     simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'gaussian', 1.0)
 
     if verbose:
-	print 'Writing output file'
+        print 'Writing output file'
     imgfile.write (outputfile, simage, sizes[0]/2, sizes[1]/2, sizes[2]) 
 
     os.unlink(outputfile)
diff --git a/Lib/dos-8x3/test_opc.py b/Lib/dos-8x3/test_opc.py
index 15c9dda..bdace26 100755
--- a/Lib/dos-8x3/test_opc.py
+++ b/Lib/dos-8x3/test_opc.py
@@ -9,18 +9,18 @@
 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
+        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'
+        raise TestFailed, 'try inside for'
 
 
 print '2.2 raise class exceptions'
@@ -30,7 +30,7 @@
 class CClass: pass
 class DClass(AClass):
     def __init__(self, ignore):
-	pass
+        pass
 
 try: raise AClass()
 except: pass
@@ -50,12 +50,12 @@
 
 try: raise AClass, b
 except BClass, v:
-	if v != b: raise TestFailed
+        if v != b: raise TestFailed
 else: raise TestFailed
 
 try: raise b
 except AClass, v:
-	if v != b: raise TestFailed
+        if v != b: raise TestFailed
 
 # not enough arguments
 try:  raise BClass, a
@@ -64,7 +64,7 @@
 try:  raise DClass, a
 except DClass, v:
     if not isinstance(v, DClass):
-	raise TestFailed
+        raise TestFailed
 
 print '2.3 comparing function objects'
 
diff --git a/Lib/dos-8x3/test_reg.py b/Lib/dos-8x3/test_reg.py
index 4be6026..6a7f01b 100644
--- a/Lib/dos-8x3/test_reg.py
+++ b/Lib/dos-8x3/test_reg.py
@@ -67,44 +67,44 @@
 for t in tests:
     pattern=s=outcome=repl=expected=None
     if len(t)==5:
-	pattern, s, outcome, repl, expected = t
+        pattern, s, outcome, repl, expected = t
     elif len(t)==3:
-	pattern, s, outcome = t 
+        pattern, s, outcome = t 
     else:
-	raise ValueError, ('Test tuples should have 3 or 5 fields',t)
+        raise ValueError, ('Test tuples should have 3 or 5 fields',t)
 
     try:
-	obj=regex.compile(pattern)
+        obj=regex.compile(pattern)
     except regex.error:
-	if outcome==SYNTAX_ERROR: pass    # Expected a syntax error
-	else: 
-	    # Regex syntax errors aren't yet reported, so for 
-	    # the official test suite they'll be quietly ignored.
-	    pass
-	    #print '=== Syntax error:', t
+        if outcome==SYNTAX_ERROR: pass    # Expected a syntax error
+        else: 
+            # Regex syntax errors aren't yet reported, so for 
+            # the official test suite they'll be quietly ignored.
+            pass
+            #print '=== Syntax error:', t
     else:
-	try:
-	    result=obj.search(s)
-	except regex.error, msg:
-	    print '=== Unexpected exception', t, repr(msg)
-	if outcome==SYNTAX_ERROR:
-	    # This should have been a syntax error; forget it.
-	    pass
-	elif outcome==FAIL:
-	    if result==-1: pass   # No match, as expected
-	    else: print '=== Succeeded incorrectly', t
-	elif outcome==SUCCEED:
-	    if result!=-1:
-		# Matched, as expected, so now we compute the
-		# result string and compare it to our expected result.
-		start, end = obj.regs[0]
-		found=s[start:end]
-		groups=obj.group(1,2,3,4,5,6,7,8,9,10)
-		vardict=vars()
-		for i in range(len(groups)):
-		    vardict['g'+str(i+1)]=str(groups[i])
-		repl=eval(repl)
-		if repl!=expected:
-		    print '=== grouping error', t, repr(repl)+' should be '+repr(expected)
-	    else:
-		print '=== Failed incorrectly', t
+        try:
+            result=obj.search(s)
+        except regex.error, msg:
+            print '=== Unexpected exception', t, repr(msg)
+        if outcome==SYNTAX_ERROR:
+            # This should have been a syntax error; forget it.
+            pass
+        elif outcome==FAIL:
+            if result==-1: pass   # No match, as expected
+            else: print '=== Succeeded incorrectly', t
+        elif outcome==SUCCEED:
+            if result!=-1:
+                # Matched, as expected, so now we compute the
+                # result string and compare it to our expected result.
+                start, end = obj.regs[0]
+                found=s[start:end]
+                groups=obj.group(1,2,3,4,5,6,7,8,9,10)
+                vardict=vars()
+                for i in range(len(groups)):
+                    vardict['g'+str(i+1)]=str(groups[i])
+                repl=eval(repl)
+                if repl!=expected:
+                    print '=== grouping error', t, repr(repl)+' should be '+repr(expected)
+            else:
+                print '=== Failed incorrectly', t
diff --git a/Lib/dos-8x3/test_rgb.py b/Lib/dos-8x3/test_rgb.py
index c5b7c83..0c449da 100755
--- a/Lib/dos-8x3/test_rgb.py
+++ b/Lib/dos-8x3/test_rgb.py
@@ -9,32 +9,32 @@
 print 'RGBimg test suite:'
 
 def findfile(file):
-	if os.path.isabs(file): return file
-	import sys
-	path = sys.path
-	try:
-	    path = [os.path.dirname(__file__)] + path
-	except NameError:
-	    pass
-	for dn in path:
-		fn = os.path.join(dn, file)
-		if os.path.exists(fn): return fn
-	return file
+        if os.path.isabs(file): return file
+        import sys
+        path = sys.path
+        try:
+            path = [os.path.dirname(__file__)] + path
+        except NameError:
+            pass
+        for dn in 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, 'rb').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')
+        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, 'rb').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')
 
 table = [
     ('testrgb.uue', 'test.rgb'),
@@ -45,7 +45,7 @@
     source = findfile(source)
     target = findfile(target)
     if verbose:
-	print "uudecoding", source, "->", target, "..."
+        print "uudecoding", source, "->", target, "..."
     uu.decode(source, target)
 
 if verbose:
@@ -53,23 +53,23 @@
 
 ttob = rgbimg.ttob(0)
 if ttob != 0:
-	raise error, 'ttob should start out as zero'
+        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'
+        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'
+        raise error, 'ttob should be one'
 
 ttob = rgbimg.ttob(0)
 if ttob != 0:
-	raise error, 'ttob should be zero'
+        raise error, 'ttob should be zero'
 
 for source, target in table:
     unlink(findfile(target))
diff --git a/Lib/dos-8x3/test_sel.py b/Lib/dos-8x3/test_sel.py
index 53185b1..60de360 100755
--- a/Lib/dos-8x3/test_sel.py
+++ b/Lib/dos-8x3/test_sel.py
@@ -16,7 +16,7 @@
 
 class Almost:
     def fileno(self):
-	return 'fileno'
+        return 'fileno'
     
 try:
     rfd, wfd, xfd = select.select([Nope()], [], [])
@@ -34,31 +34,31 @@
 
 
 def test():
-	import sys
-	if sys.platform[:3] in ('win', 'mac', 'os2'):
-		if verbose:
-			print "Can't test select easily on", sys.platform
-		return
-	cmd = 'for i in 0 1 2 3 4 5 6 7 8 9; do echo testing...; sleep 1; done'
-	p = os.popen(cmd, 'r')
-	for tout in (0, 1, 2, 4, 8, 16) + (None,)*10:
-		if verbose:
-			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()
-			if verbose:
-				print `line`
-			if not line:
-				if verbose:
-					print 'EOF'
-				break
-			continue
-		print 'Heh?'
-	p.close()
+        import sys
+        if sys.platform[:3] in ('win', 'mac', 'os2'):
+                if verbose:
+                        print "Can't test select easily on", sys.platform
+                return
+        cmd = 'for i in 0 1 2 3 4 5 6 7 8 9; do echo testing...; sleep 1; done'
+        p = os.popen(cmd, 'r')
+        for tout in (0, 1, 2, 4, 8, 16) + (None,)*10:
+                if verbose:
+                        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()
+                        if verbose:
+                                print `line`
+                        if not line:
+                                if verbose:
+                                        print 'EOF'
+                                break
+                        continue
+                print 'Heh?'
+        p.close()
 
 test()
 
diff --git a/Lib/dos-8x3/test_soc.py b/Lib/dos-8x3/test_soc.py
index b602c91..772b86b 100644
--- a/Lib/dos-8x3/test_soc.py
+++ b/Lib/dos-8x3/test_soc.py
@@ -1,11 +1,11 @@
 # Not tested:
-#	socket.fromfd()
-# 	sktobj.getsockopt()
-#	sktobj.recvfrom()
-#	sktobj.sendto()
-#	sktobj.setblocking()
-# 	sktobj.setsockopt()
-#	sktobj.shutdown()
+#       socket.fromfd()
+#       sktobj.getsockopt()
+#       sktobj.recvfrom()
+#       sktobj.sendto()
+#       sktobj.setblocking()
+#       sktobj.setsockopt()
+#       sktobj.shutdown()
 
 
 from test_support import verbose, TestFailed
@@ -16,9 +16,9 @@
 
 def missing_ok(str):
     try:
-	getattr(socket, str)
+        getattr(socket, str)
     except AttributeError:
-	pass
+        pass
 
 try: raise socket.error
 except socket.error: print "socket.error"
@@ -33,37 +33,37 @@
 
 for optional in ("AF_UNIX",
 
-		 "SO_DEBUG", "SO_ACCEPTCONN", "SO_REUSEADDR", "SO_KEEPALIVE",
-		 "SO_DONTROUTE", "SO_BROADCAST", "SO_USELOOPBACK", "SO_LINGER",
-		 "SO_OOBINLINE", "SO_REUSEPORT", "SO_SNDBUF", "SO_RCVBUF",
-		 "SO_SNDLOWAT", "SO_RCVLOWAT", "SO_SNDTIMEO", "SO_RCVTIMEO",
-		 "SO_ERROR", "SO_TYPE", "SOMAXCONN",
+                 "SO_DEBUG", "SO_ACCEPTCONN", "SO_REUSEADDR", "SO_KEEPALIVE",
+                 "SO_DONTROUTE", "SO_BROADCAST", "SO_USELOOPBACK", "SO_LINGER",
+                 "SO_OOBINLINE", "SO_REUSEPORT", "SO_SNDBUF", "SO_RCVBUF",
+                 "SO_SNDLOWAT", "SO_RCVLOWAT", "SO_SNDTIMEO", "SO_RCVTIMEO",
+                 "SO_ERROR", "SO_TYPE", "SOMAXCONN",
 
-		 "MSG_OOB", "MSG_PEEK", "MSG_DONTROUTE", "MSG_EOR",
-		 "MSG_TRUNC", "MSG_CTRUNC", "MSG_WAITALL", "MSG_BTAG",
-		 "MSG_ETAG",
+                 "MSG_OOB", "MSG_PEEK", "MSG_DONTROUTE", "MSG_EOR",
+                 "MSG_TRUNC", "MSG_CTRUNC", "MSG_WAITALL", "MSG_BTAG",
+                 "MSG_ETAG",
 
-		 "SOL_SOCKET",
+                 "SOL_SOCKET",
 
-		 "IPPROTO_IP", "IPPROTO_ICMP", "IPPROTO_IGMP",
-		 "IPPROTO_GGP", "IPPROTO_TCP", "IPPROTO_EGP",
-		 "IPPROTO_PUP", "IPPROTO_UDP", "IPPROTO_IDP",
-		 "IPPROTO_HELLO", "IPPROTO_ND", "IPPROTO_TP",
-		 "IPPROTO_XTP", "IPPROTO_EON", "IPPROTO_BIP",
-		 "IPPROTO_RAW", "IPPROTO_MAX",
+                 "IPPROTO_IP", "IPPROTO_ICMP", "IPPROTO_IGMP",
+                 "IPPROTO_GGP", "IPPROTO_TCP", "IPPROTO_EGP",
+                 "IPPROTO_PUP", "IPPROTO_UDP", "IPPROTO_IDP",
+                 "IPPROTO_HELLO", "IPPROTO_ND", "IPPROTO_TP",
+                 "IPPROTO_XTP", "IPPROTO_EON", "IPPROTO_BIP",
+                 "IPPROTO_RAW", "IPPROTO_MAX",
 
-		 "IPPORT_RESERVED", "IPPORT_USERRESERVED",
+                 "IPPORT_RESERVED", "IPPORT_USERRESERVED",
 
-		 "INADDR_ANY", "INADDR_BROADCAST", "INADDR_LOOPBACK",
-		 "INADDR_UNSPEC_GROUP", "INADDR_ALLHOSTS_GROUP",
-		 "INADDR_MAX_LOCAL_GROUP", "INADDR_NONE",
+                 "INADDR_ANY", "INADDR_BROADCAST", "INADDR_LOOPBACK",
+                 "INADDR_UNSPEC_GROUP", "INADDR_ALLHOSTS_GROUP",
+                 "INADDR_MAX_LOCAL_GROUP", "INADDR_NONE",
 
-		 "IP_OPTIONS", "IP_HDRINCL", "IP_TOS", "IP_TTL",
-		 "IP_RECVOPTS", "IP_RECVRETOPTS", "IP_RECVDSTADDR",
-		 "IP_RETOPTS", "IP_MULTICAST_IF", "IP_MULTICAST_TTL",
-		 "IP_MULTICAST_LOOP", "IP_ADD_MEMBERSHIP",
-		 "IP_DROP_MEMBERSHIP",
-		 ):
+                 "IP_OPTIONS", "IP_HDRINCL", "IP_TOS", "IP_TTL",
+                 "IP_RECVOPTS", "IP_RECVRETOPTS", "IP_RECVDSTADDR",
+                 "IP_RETOPTS", "IP_MULTICAST_IF", "IP_MULTICAST_TTL",
+                 "IP_MULTICAST_LOOP", "IP_ADD_MEMBERSHIP",
+                 "IP_DROP_MEMBERSHIP",
+                 ):
     missing_ok(optional)
 
 socktype = socket.SocketType
@@ -80,7 +80,7 @@
 
 for name in all_host_names:
     if string.find(name, '.'):
-	break
+        break
 else:
     print 'FQDN not found'
 
@@ -95,52 +95,52 @@
 try:
     PORT = 50007
     if not canfork or os.fork():
-	# parent is server
-	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-	s.bind(hostname, PORT)
-	s.listen(1)
-	if verbose:
-	    print 'parent accepting'
-	if canfork:
-	    conn, addr = s.accept()
-	    if verbose:
-		print 'connected by', addr
-	    # couple of interesting tests while we've got a live socket
-	    f = conn.fileno()
-	    if verbose:
-		print 'fileno:', f
-	    p = conn.getpeername()
-	    if verbose:
-		print 'peer:', p
-	    n = conn.getsockname()
-	    if verbose:
-		print 'sockname:', n
-	    f = conn.makefile()
-	    if verbose:
-		print 'file obj:', f
-	    while 1:
-		data = conn.recv(1024)
-		if not data:
-		    break
-		if verbose:
-		    print 'received:', data
-		conn.send(data)
-	    conn.close()
+        # parent is server
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.bind(hostname, PORT)
+        s.listen(1)
+        if verbose:
+            print 'parent accepting'
+        if canfork:
+            conn, addr = s.accept()
+            if verbose:
+                print 'connected by', addr
+            # couple of interesting tests while we've got a live socket
+            f = conn.fileno()
+            if verbose:
+                print 'fileno:', f
+            p = conn.getpeername()
+            if verbose:
+                print 'peer:', p
+            n = conn.getsockname()
+            if verbose:
+                print 'sockname:', n
+            f = conn.makefile()
+            if verbose:
+                print 'file obj:', f
+            while 1:
+                data = conn.recv(1024)
+                if not data:
+                    break
+                if verbose:
+                    print 'received:', data
+                conn.send(data)
+            conn.close()
     else:
-	try:
-	    # child is client
-	    time.sleep(5)
-	    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-	    if verbose:
-		print 'child connecting'
-	    s.connect(hostname, PORT)
-	    msg = 'socket test'
-	    s.send(msg)
-	    data = s.recv(1024)
-	    if msg <> data:
-		print 'parent/client mismatch'
-	    s.close()
-	finally:
-	    os._exit(1)
+        try:
+            # child is client
+            time.sleep(5)
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            if verbose:
+                print 'child connecting'
+            s.connect(hostname, PORT)
+            msg = 'socket test'
+            s.send(msg)
+            data = s.recv(1024)
+            if msg <> data:
+                print 'parent/client mismatch'
+            s.close()
+        finally:
+            os._exit(1)
 except socket.error, msg:
     raise TestFailed, msg
diff --git a/Lib/dos-8x3/test_str.py b/Lib/dos-8x3/test_str.py
index a4f1882..bd31058 100644
--- a/Lib/dos-8x3/test_str.py
+++ b/Lib/dos-8x3/test_str.py
@@ -3,19 +3,19 @@
 
 def test(name, input, output, *args):
     if verbose:
-	print 'string.%s%s =? %s... ' % (name, (input,) + args, output),
+        print 'string.%s%s =? %s... ' % (name, (input,) + args, output),
     f = getattr(strop, name)
     try:
-	value = apply(f, (input,) + args)
+        value = apply(f, (input,) + args)
     except:
-	 value = sys.exc_type
+         value = sys.exc_type
     if value != output:
-	if verbose:
-	    print 'no'
-	print f, `input`, `output`, `value`
+        if verbose:
+            print 'no'
+        print f, `input`, `output`, `value`
     else:
-	if verbose:
-	    print 'yes'
+        if verbose:
+            print 'yes'
 
 test('atoi', " 1 ", 1)
 test('atoi', " 1x", ValueError)
diff --git a/Lib/dos-8x3/test_sun.py b/Lib/dos-8x3/test_sun.py
index aa85752..1438c09 100644
--- a/Lib/dos-8x3/test_sun.py
+++ b/Lib/dos-8x3/test_sun.py
@@ -3,24 +3,29 @@
 import os
 
 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
+        if os.path.isabs(file): return file
+        import sys
+        path = sys.path
+        try:
+                path = [os.path.dirname(__file__)] + path
+        except NameError:
+                pass
+        for dn in path:
+                fn = os.path.join(dn, file)
+                if os.path.exists(fn): return fn
+        return file
 
 def play_sound_file(path):
     fp = open(path, 'r')
     data = fp.read()
     fp.close()
     try:
-	a = sunaudiodev.open('w')
+        a = sunaudiodev.open('w')
     except sunaudiodev.error, msg:
-	raise TestFailed, msg
+        raise TestFailed, msg
     else:
-	a.write(data)
-	a.close()
+        a.write(data)
+        a.close()
 
 def test():
     play_sound_file(findfile('audiotest.au'))
diff --git a/Lib/dos-8x3/test_tim.py b/Lib/dos-8x3/test_tim.py
index cfa18a3..03d081e 100644
--- a/Lib/dos-8x3/test_tim.py
+++ b/Lib/dos-8x3/test_tim.py
@@ -14,13 +14,13 @@
 time.sleep(1.2)
 tt = time.gmtime(t)
 for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I',
-		  'j', 'm', 'M', 'p', 'S',
-		  'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):
+                  'j', 'm', 'M', 'p', 'S',
+                  'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):
     format = ' %' + directive
     try:
-	time.strftime(format, tt)
+        time.strftime(format, tt)
     except ValueError:
-	print 'conversion specifier:', format, ' failed.'
+        print 'conversion specifier:', format, ' failed.'
 
 time.timezone
 time.tzname
@@ -33,7 +33,7 @@
 
 try:
     time.mktime((999999, 999999, 999999, 999999,
-		 999999, 999999, 999999, 999999,
-		 999999))
+                 999999, 999999, 999999, 999999,
+                 999999))
 except OverflowError:
     pass
diff --git a/Lib/dos-8x3/test_typ.py b/Lib/dos-8x3/test_typ.py
index 7cca131..6be66ca 100755
--- a/Lib/dos-8x3/test_typ.py
+++ b/Lib/dos-8x3/test_typ.py
@@ -161,6 +161,11 @@
 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'
+# The following dumps core in unpatched Python 1.5:
+def myComparison(x,y):
+    return cmp(x%3, y%7)
+z = range(12)
+z.sort(myComparison)
 
 print '6.6 Mappings == Dictionaries'
 d = {}
diff --git a/Lib/dos-8x3/test_unp.py b/Lib/dos-8x3/test_unp.py
index 1f69504..1bfd478 100644
--- a/Lib/dos-8x3/test_unp.py
+++ b/Lib/dos-8x3/test_unp.py
@@ -5,8 +5,8 @@
 
 class Seq:
     def __getitem__(self, i):
-	if i >= 0 and i < 3: return i
-	raise IndexError
+        if i >= 0 and i < 3: return i
+        raise IndexError
 
 a = -1
 b = -1
@@ -104,12 +104,12 @@
 
 class BadSeq:
     def __getitem__(self, i):
-	if i >= 0 and i < 3:
-	    return i
-	elif i == 3:
-	    raise BozoError
-	else:
-	    raise IndexError
+        if i >= 0 and i < 3:
+            return i
+        elif i == 3:
+            raise BozoError
+        else:
+            raise IndexError
 
 
 # trigger code while not expecting an IndexError
diff --git a/Lib/dos-8x3/test_xml.py b/Lib/dos-8x3/test_xml.py
new file mode 100644
index 0000000..eb868a3
--- /dev/null
+++ b/Lib/dos-8x3/test_xml.py
@@ -0,0 +1,25 @@
+'''Test module to thest the xmllib module.
+   Sjoerd Mullender
+'''
+
+from test_support import verbose
+
+testdoc = """\
+<?xml version="1.0" encoding="UTF-8" standalone='yes' ?>
+<!-- comments aren't allowed before the <?xml?> tag,
+     but they are allowed before the <!DOCTYPE> tag -->
+<!DOCTYPE greeting [
+  <!ELEMENT greeting (#PCDATA)>
+]>
+<greeting>Hello, world!</greeting>
+"""
+
+import xmllib
+if verbose:
+	parser = xmllib.TestXMLParser()
+else:
+	parser = xmllib.XMLParser()
+
+for c in testdoc:
+	parser.feed(c)
+parser.close()
diff --git a/Lib/dos-8x3/tracebac.py b/Lib/dos-8x3/tracebac.py
index d508e03..70d3230 100755
--- a/Lib/dos-8x3/tracebac.py
+++ b/Lib/dos-8x3/tracebac.py
@@ -87,6 +87,8 @@
 	if tb:
 		list = ['Traceback (innermost last):\n']
 		list = list + format_tb(tb, limit)
+	else:
+		list = []
 	list = list + format_exception_only(etype, value)
 	return list
 
@@ -186,9 +188,13 @@
 # with -O on).
 # Coded by Marc-Andre Lemburg from the example of PyCode_Addr2Line()
 # in compile.c.
+# Revised version by Jim Hugunin to work with JPython too.
 
 def tb_lineno(tb):
 	c = tb.tb_frame.f_code
+	if not hasattr(c, 'co_lnotab'):
+		return tb.tb_lineno
+
 	tab = c.co_lnotab
 	line = c.co_firstlineno
 	stopat = tb.tb_lasti
diff --git a/Lib/dos-8x3/userdict.py b/Lib/dos-8x3/userdict.py
index 3b9b157..08f3161 100755
--- a/Lib/dos-8x3/userdict.py
+++ b/Lib/dos-8x3/userdict.py
@@ -4,30 +4,30 @@
     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)
+        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 clear(self): return self.data.clear()
     def copy(self):
-	import copy
-	return copy.copy(self)
+        import copy
+        return copy.copy(self)
     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)
     def update(self, other):
-	if type(other) is type(self.data):
-	    self.data.update(other)
-	else:
-	    for k, v in other.items():
-		self.data[k] = v
+        if type(other) is type(self.data):
+            self.data.update(other)
+        else:
+            for k, v in other.items():
+                self.data[k] = v
     def get(self, key, failobj=None):
-	if self.data.has_key(key):
-	    return self.data[key]
-	else:
-	    return failobj
+        if self.data.has_key(key):
+            return self.data[key]
+        else:
+            return failobj