From 548703a1b81f6adf68a3dd4b497a88f5c4a31f4a Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Thu, 26 Mar 1998 22:14:20 +0000 Subject: The usual. --- Lib/dos-8x3/basehttp.py | 388 ++++++++++++++++---------------- Lib/dos-8x3/bastion.py | 104 ++++----- Lib/dos-8x3/cgihttps.py | 244 ++++++++++---------- Lib/dos-8x3/compilea.py | 159 ++++++++----- Lib/dos-8x3/configpa.py | 291 ++++++++++++------------ Lib/dos-8x3/exceptio.py | 34 +-- Lib/dos-8x3/fileinpu.py | 200 ++++++++--------- Lib/dos-8x3/formatte.py | 442 ++++++++++++++++++------------------ Lib/dos-8x3/gopherli.py | 23 +- Lib/dos-8x3/macurl2p.py | 80 +++---- Lib/dos-8x3/mimetype.py | 50 ++--- Lib/dos-8x3/mimewrit.py | 58 ++--- Lib/dos-8x3/multifil.py | 13 +- Lib/dos-8x3/posixfil.py | 276 +++++++++++------------ Lib/dos-8x3/py_compi.py | 95 +++++--- Lib/dos-8x3/queue.py | 170 +++++++------- Lib/dos-8x3/reconver.py | 64 +++--- Lib/dos-8x3/rlcomple.py | 98 ++++---- Lib/dos-8x3/simpleht.py | 178 +++++++-------- Lib/dos-8x3/socketse.py | 256 ++++++++++----------- Lib/dos-8x3/telnetli.py | 586 ++++++++++++++++++++++++------------------------ Lib/dos-8x3/test_arr.py | 76 +++---- Lib/dos-8x3/test_aud.py | 194 ++++++++-------- Lib/dos-8x3/test_bin.py | 24 +- Lib/dos-8x3/test_bsd.py | 56 ++--- Lib/dos-8x3/test_cma.py | 32 +-- Lib/dos-8x3/test_err.py | 60 ++--- Lib/dos-8x3/test_exc.py | 20 +- Lib/dos-8x3/test_ima.py | 62 ++--- Lib/dos-8x3/test_img.py | 56 ++--- Lib/dos-8x3/test_opc.py | 30 +-- Lib/dos-8x3/test_reg.py | 70 +++--- Lib/dos-8x3/test_rgb.py | 58 ++--- Lib/dos-8x3/test_sel.py | 52 ++--- Lib/dos-8x3/test_soc.py | 174 +++++++------- Lib/dos-8x3/test_str.py | 16 +- Lib/dos-8x3/test_sun.py | 25 ++- Lib/dos-8x3/test_tim.py | 12 +- Lib/dos-8x3/test_typ.py | 5 + Lib/dos-8x3/test_unp.py | 16 +- Lib/dos-8x3/test_xml.py | 25 +++ Lib/dos-8x3/tracebac.py | 6 + Lib/dos-8x3/userdict.py | 30 +-- 43 files changed, 2524 insertions(+), 2384 deletions(-) create mode 100644 Lib/dos-8x3/test_xml.py 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 @@ DEFAULT_ERROR_MESSAGE = """\ 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 @@ class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler): server_version = "BaseHTTP/" + __version__ def handle(self): - """Handle a single HTTP request. - - You normally don't need to override this method; see the class - __doc__ string for information on how to handle specific HTTP - commands such as GET and POST. - - """ - - self.raw_requestline = self.rfile.readline() - self.request_version = version = "HTTP/0.9" # Default - requestline = self.raw_requestline - if requestline[-2:] == '\r\n': - requestline = requestline[:-2] - elif requestline[-1:] == '\n': - requestline = requestline[:-1] - self.requestline = requestline - words = string.split(requestline) - if len(words) == 3: - [command, path, version] = words - if version[: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() + """Handle a single HTTP request. + + You normally don't need to override this method; see the class + __doc__ string for information on how to handle specific HTTP + commands such as GET and POST. + + """ + + self.raw_requestline = self.rfile.readline() + self.request_version = version = "HTTP/0.9" # Default + requestline = self.raw_requestline + if requestline[-2:] == '\r\n': + requestline = requestline[:-2] + elif requestline[-1:] == '\n': + requestline = requestline[:-1] + self.requestline = requestline + words = string.split(requestline) + if len(words) == 3: + [command, path, version] = words + if version[: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. - - Arguments are the error code, and a detailed message. - The detailed message defaults to the short entry matching the - response code. - - This sends an error response (so it must be called before any - output has been generated), logs the error, and finally sends - a piece of HTML explaining the error to the user. - - """ - - try: - short, long = self.responses[code] - except KeyError: - short, long = '???', '???' - if not message: - message = short - explain = long - self.log_error("code %d, message %s", code, message) - self.send_response(code, message) - self.end_headers() - self.wfile.write(self.error_message_format % - {'code': code, - 'message': message, - 'explain': explain}) + """Send and log an error reply. + + Arguments are the error code, and a detailed message. + The detailed message defaults to the short entry matching the + response code. + + This sends an error response (so it must be called before any + output has been generated), logs the error, and finally sends + a piece of HTML explaining the error to the user. + + """ + + try: + short, long = self.responses[code] + except KeyError: + short, long = '???', '???' + if not message: + message = short + explain = long + self.log_error("code %d, message %s", code, message) + self.send_response(code, message) + self.end_headers() + self.wfile.write(self.error_message_format % + {'code': code, + 'message': message, + 'explain': explain}) error_message_format = DEFAULT_ERROR_MESSAGE def send_response(self, code, message=None): - """Send the response header and log the response code. - - Also send two standard headers with the server software - version and the current date. - - """ - self.log_request(code) - if message is None: - if self.responses.has_key(code): - message = self.responses[code][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()) + """Send the response header and log the response code. + + Also send two standard headers with the server software + version and the current date. + + """ + self.log_request(code) + if message is None: + if self.responses.has_key(code): + message = self.responses[code][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 @@ class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler): # 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 @@ def test(HandlerClass = BaseHTTPRequestHandler, """ 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 @@ class BastionClass: """ 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 "" % self._name_ + """ + return "" % 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 @@ def Bastion(object, filter = lambda name: name[:1] != '_', # 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 @@ def _test(): 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 @@ class CGIHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): """ 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 @@ def nobody_uid(): """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. + + 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) -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) + """ + 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 @@ ConfigParser -- responsible for for parsing a list of 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 @@ DEFAULTSECT = "DEFAULT" # 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. - - 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) + """Get an option value for a given section. + + All % interpolations are expanded in the return values, based + on the defaults passed into the constructor. + + 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. - - 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`) + """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`) 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 @@ Exception(*) 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 @@ class SyntaxError(StandardError): 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 MemoryError(StandardError): 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 @@ _state = None 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 @@ def close(): 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 = '' - 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 = '' + 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 @@ def _test(): 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 @@ AS_IS = None 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 @@ class AbstractFormatter: # 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 @@ class AbstractFormatter: 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 NullWriter: 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 @@ A_PLUS_SOUND = '<' # 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_selector(selector, host, port = 0): 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 @@ def get_directory(f): 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 @@ def url2pathname(pathname): # 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 @@ def guess_type(url): """ 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 @@ class MimeWriter: 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 @@ class MimeWriter: """ 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 @@ class MultiFile: 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 @@ class _posixfile_: # 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)` != "": - 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)` != "": + 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 - - if which: - if len(which) > 1: - raise TypeError, 'Too many arguments' - which = which[0] - else: which = '?' - - l_flags = 0 - if 'n' in which: l_flags = l_flags | FCNTL.O_NDELAY - if 'a' in which: l_flags = l_flags | FCNTL.O_APPEND - if 's' in which: l_flags = l_flags | FCNTL.O_SYNC - - file = self._file_ - - if '=' not in which: - cur_fl = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0) - if '!' in which: l_flags = cur_fl & ~ l_flags - else: l_flags = cur_fl | l_flags - - l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFL, l_flags) - - if 'c' in which: - arg = ('!' not in which) # 0 is don't, 1 is do close on exec - l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFD, arg) - - if '?' in which: - which = '' # Return current flags - l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0) - if FCNTL.O_APPEND & l_flags: which = which + 'a' - if fcntl.fcntl(file.fileno(), FCNTL.F_GETFD, 0) & 1: - which = which + 'c' - if FCNTL.O_NDELAY & l_flags: which = which + 'n' - if FCNTL.O_SYNC & l_flags: which = which + 's' - return which - + import fcntl, FCNTL + + if which: + if len(which) > 1: + raise TypeError, 'Too many arguments' + which = which[0] + else: which = '?' + + l_flags = 0 + if 'n' in which: l_flags = l_flags | FCNTL.O_NDELAY + if 'a' in which: l_flags = l_flags | FCNTL.O_APPEND + if 's' in which: l_flags = l_flags | FCNTL.O_SYNC + + file = self._file_ + + if '=' not in which: + cur_fl = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0) + if '!' in which: l_flags = cur_fl & ~ l_flags + else: l_flags = cur_fl | l_flags + + l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFL, l_flags) + + if 'c' in which: + arg = ('!' not in which) # 0 is don't, 1 is do close on exec + l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFD, arg) + + if '?' in which: + which = '' # Return current flags + l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0) + if FCNTL.O_APPEND & l_flags: which = which + 'a' + if fcntl.fcntl(file.fileno(), FCNTL.F_GETFD, 0) & 1: + which = which + 'c' + if FCNTL.O_NDELAY & l_flags: which = which + 'n' + if FCNTL.O_SYNC & l_flags: which = which + 's' + return which + def lock(self, how, *args): - import struct, fcntl, FCNTL - - if 'w' in how: l_type = FCNTL.F_WRLCK - elif 'r' in how: l_type = FCNTL.F_RDLCK - elif 'u' in how: l_type = FCNTL.F_UNLCK - else: raise TypeError, 'no type of lock specified' - - if '|' in how: cmd = FCNTL.F_SETLKW - elif '?' in how: cmd = FCNTL.F_GETLK - else: cmd = FCNTL.F_SETLK - - l_whence = 0 - l_start = 0 - l_len = 0 - - if len(args) == 1: - l_len = args[0] - elif len(args) == 2: - l_len, l_start = args - elif len(args) == 3: - l_len, l_start, l_whence = args - elif len(args) > 3: - raise TypeError, 'too many arguments' - - # Hack by davem@magnet.com to get locking to go on freebsd; - # additions for AIX by Vladimir.Marangozov@imag.fr + import struct, fcntl, FCNTL + + if 'w' in how: l_type = FCNTL.F_WRLCK + elif 'r' in how: l_type = FCNTL.F_RDLCK + elif 'u' in how: l_type = FCNTL.F_UNLCK + else: raise TypeError, 'no type of lock specified' + + if '|' in how: cmd = FCNTL.F_SETLKW + elif '?' in how: cmd = FCNTL.F_GETLK + else: cmd = FCNTL.F_SETLK + + l_whence = 0 + l_start = 0 + l_len = 0 + + if len(args) == 1: + l_len = args[0] + elif len(args) == 2: + l_len, l_start = args + elif len(args) == 3: + l_len, l_start, l_whence = args + elif len(args) > 3: + raise TypeError, 'too many arguments' + + # 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) - - 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 + 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 # # 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)) - -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') + "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, 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 @@ class Queue: # 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 @@ def convert(s, syntax=None): """ 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 @@ def quote(s, quote=None): """ 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 @@ def main(): 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 @@ import __main__ 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. - - 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 + """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. + + """ + 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. - - 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. - - """ - 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 + """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. + + 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 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 @@ class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): 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. - - This sends the response code and MIME headers. - - Return value is either a file object (which has to be copied - to the outputfile by the caller unless the command was HEAD, - and must be closed by the caller under all circumstances), or - None, in which case the caller has nothing further to do. - - """ - path = self.translate_path(self.path) - if os.path.isdir(path): - self.send_error(403, "Directory listing not supported") - return None - try: - f = open(path) - except IOError: - self.send_error(404, "File not found") - return None - self.send_response(200) - self.send_header("Content-type", self.guess_type(path)) - self.end_headers() - return f + """Common code for GET and HEAD commands. + + This sends the response code and MIME headers. + + Return value is either a file object (which has to be copied + to the outputfile by the caller unless the command was HEAD, + and must be closed by the caller under all circumstances), or + None, in which case the caller has nothing further to do. + + """ + path = self.translate_path(self.path) + if os.path.isdir(path): + self.send_error(403, "Directory listing not supported") + return None + try: + f = open(path) + except IOError: + self.send_error(404, "File not found") + return None + self.send_response(200) + self.send_header("Content-type", self.guess_type(path)) + self.end_headers() + return f def translate_path(self, path): - """Translate a /-separated PATH to the local filename syntax. - - Components that mean special things to the local file system - (e.g. drive or directory names) are ignored. (XXX They should - probably be diagnosed.) - - """ - path = posixpath.normpath(path) - words = string.splitfields(path, '/') - words = filter(None, words) - path = os.getcwd() - for word in words: - drive, word = os.path.splitdrive(word) - head, word = os.path.split(word) - if word in (os.curdir, os.pardir): continue - path = os.path.join(path, word) - return path + """Translate a /-separated PATH to the local filename syntax. + + Components that mean special things to the local file system + (e.g. drive or directory names) are ignored. (XXX They should + probably be diagnosed.) + + """ + path = posixpath.normpath(path) + words = string.splitfields(path, '/') + words = filter(None, words) + path = os.getcwd() + for word in words: + drive, word = os.path.splitdrive(word) + head, word = os.path.split(word) + if word in (os.curdir, os.pardir): continue + path = os.path.join(path, word) + return path def copyfile(self, source, outputfile): - """Copy all data between two file objects. + """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 + - AF_INET: IP (Internet Protocol) sockets (default) + - AF_UNIX: Unix domain sockets + - others, e.g. AF_DECNET are conceivable (see - 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 @@ slows down method lookups.) 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 @@ Forking and threading versions of each type of server can be created using the ForkingServer and ThreadingServer mix-in classes. For instance, a threading UDP server class is created as follows: - class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass + class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass The Mix-in class must come first, since it overrides a method defined in UDPServer! @@ -119,8 +119,8 @@ class TCPServer: - __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 @@ class TCPServer: 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 @@ class TCPServer: # 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 @@ class UDPServer(TCPServer): 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 @@ class ForkingMixIn: 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 @@ class ThreadingMixIn: """Mix-in class to handle each request in a new thread.""" def process_request(self, request, client_address): - """Start a new thread to process the request.""" - import thread - thread.start_new_thread(self.finish_request, - (request, client_address)) + """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 @@ class BaseRequestHandler: """ 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 @@ class StreamRequestHandler(BaseRequestHandler): """Define self.rfile and self.wfile for stream sockets.""" def setup(self): - self.connection = self.request - self.rfile = self.connection.makefile('rb', 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 @@ class DatagramRequestHandler(BaseRequestHandler): """Define self.rfile and self.wfile for datagram sockets.""" def setup(self): - import StringIO - self.packet, self.socket = self.request - self.rfile = StringIO.StringIO(self.packet) - self.wfile = StringIO.StringIO(self.packet) + 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 @@ 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,360 +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.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.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(): @@ -452,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) 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 @@ def main(): 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() - - 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 = 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 + + 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 gendata1(): 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 testratecv(data): 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 @@ def testall(): # 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 @@ from test_support import verbose 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 @@ def test(): 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 @@ from test_support import verbose 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 @@ def test(openmethod, what): 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 @@ import cmath 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 @@ import errno 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 @@ errors = ['E2BIG', 'EACCES', 'EADDRINUSE', 'EADDRNOTAVAIL', 'EADV', # 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 @@ print '5. Built-in exceptions' 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.close() 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 @@ except NameError: pass 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 @@ def main(use_rgbimg=1): 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 @@ def main(use_rgbimg=1): # 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 @@ def main(use_rgbimg=1): # 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 @@ def main(use_rgbimg=1): # 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 @@ def getrgbimage(name): 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 @@ def getimage(name): 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 @@ def get_qualified_path(name): 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 @@ def main(): 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 @@ def testimage(name): # 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__ - - parts = string.splitfields(ourname, os.sep) - parts[-1] = name - name = string.joinfields(parts, os.sep) - sizes = imgfile.getsizes(name) + # 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) 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 @@ def testimage(name): # 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 @@ def testimage(name): # 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 @@ def testimage(name): # 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 @@ def testimage(name): 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 'XXX Not yet fully implemented' print '2.1 try inside for loop' n = 0 for i in range(10): - n = n+i - try: 1/0 - except NameError: pass - except ZeroDivisionError: pass - except TypeError: pass - try: pass - except: pass - try: pass - finally: pass - n = n+i + 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 BClass(AClass): pass class CClass: pass class DClass(AClass): def __init__(self, ignore): - pass + pass try: raise AClass() except: pass @@ -50,12 +50,12 @@ b = BClass() 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 @@ except TypeError: pass 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 @@ if verbose: print 'Running regex_tests test suite' 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 @@ error = 'test_rgbimg.error' 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 @@ for source, target in table: 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 @@ if verbose: 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 Nope: class Almost: def fileno(self): - return 'fileno' + return 'fileno' try: rfd, wfd, xfd = select.select([Nope()], [], []) @@ -34,31 +34,31 @@ else: 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 @@ import string 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 @@ socket.SOCK_SEQPACKET 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", - - "MSG_OOB", "MSG_PEEK", "MSG_DONTROUTE", "MSG_EOR", - "MSG_TRUNC", "MSG_CTRUNC", "MSG_WAITALL", "MSG_BTAG", - "MSG_ETAG", - - "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", - - "IPPORT_RESERVED", "IPPORT_USERRESERVED", - - "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", - ): + "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", + + "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", + + "IPPORT_RESERVED", "IPPORT_USERRESERVED", + + "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", + ): missing_ok(optional) socktype = socket.SocketType @@ -80,7 +80,7 @@ if verbose: for name in all_host_names: if string.find(name, '.'): - break + break else: print 'FQDN not found' @@ -95,52 +95,52 @@ canfork = hasattr(os, 'fork') 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 @@ import strop, sys 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 sunaudiodev 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 @@ if long(time.mktime(time.localtime(t))) <> long(t): 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 @@ except TypeError: 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 @@ if a <> [-2,-1,0,1,2]: raise TestFailed, 'list sort' def revcmp(a, b): return cmp(b, a) a.sort(revcmp) if a <> [2,1,0,-1,-2]: raise TestFailed, 'list sort with cmp func' +# 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 @@ l = [4, 5, 6] 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 @@ BozoError = 'BozoError' 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 = """\ + + + +]> +Hello, world! +""" + +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 @@ def format_exception(etype, value, tb, limit = None): 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 @@ def extract_stack(f=None, limit = None): # 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 @@ class UserDict: def __init__(self): self.data = {} def __repr__(self): return repr(self.data) def __cmp__(self, dict): - if type(dict) == type(self.data): - return cmp(self.data, dict) - else: - return cmp(self.data, dict.data) + 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 -- cgit v0.12