Mass check-in after untabifying all files that need it.

1 files changed, 294 insertions, 294 deletions

diff --git a/Lib/telnetlib.py b/Lib/telnetlib.py
index 2012e16d41..8cf372e3f9 100644
--- a/Lib/telnetlib.py
+++ b/Lib/telnetlib.py
@@ -76,7 +76,7 @@ class Telnet:
 
     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,362 +86,362 @@ class Telnet:
 
     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.
-
-	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)
+        """Constructor.
+
+        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)
 
     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.msg("send %s", `buffer`)
-	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.
-
-	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()
+        """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.
+
+        """
+        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.
-
-	"""
-	self.process_rawq()
-	while not self.eof and self.sock_avail():
-	    self.fill_rawq()
-	    self.process_rawq()
-	return self.read_very_lazy()
+        """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()
 
     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.
-
-	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
+        """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.
+
+        """
+        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.
-
-	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
+        """Get next char from raw queue.
+
+        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
 
     def fill_rawq(self):
-	"""Fill raw queue from exactly one recv() system call.
-
-	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.msg("recv %s", `buf`)
-	self.eof = (not buf)
-	self.rawq = self.rawq + buf
+        """Fill raw queue from exactly one recv() system call.
+
+        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.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.
-
-	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.
-
-	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.
-
-	"""
-	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)
+        """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.
+
+        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 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)
 
 
 def test():
@@ -454,18 +454,18 @@ def test():
     """
     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)